fix(core): share web search limits with OpenCode Web Search

OpenCode Web Search, the default search provider for Console-connected users, made its own request with no size cap and discarded the body of failed responses. It now uses the shared response handling, and OpenCode API error bodies ({ _tag, message }) supply the failure explanation. Reading a failed response for its explanation is bounded to one second so a stalled error body still fails promptly. Also formats the earlier changes with Prettier and tidies the tests.
fix(core): make web search limits non-fatal and report real errors
2026-09-27 11:07:34 +00:00 · 2026-09-23 12:57:33 -05:00 · 2026-09-23 11:44:55 -05:00
739 changed files with 9032 additions and 56184 deletions
@@ -184,7 +184,7 @@ const table = sqliteTable("session", {
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
- Keep provider-specific native compaction mechanisms in `@opencode/ai` behind `LLMClient.compact`. `SessionCompaction` chooses a summary or native compaction from the model's `compaction` setting and owns route provenance, request shrinking, the retry policy, interruption, usage accounting, and checkpoint persistence.
+- Keep native compaction mechanisms out of `SessionCompaction`. Plugins register `native` strategies through the `SessionCompaction` editor that turn a prepared request into a replacement window (the built-in `NativeCompactionPlugin` handles `@opencode/ai` compaction operations); later registrations win. Core owns the provider-mode decision, route provenance, the retry policy, overflow recovery, interruption, usage accounting, and checkpoint persistence.
 - Keep delivery vocabulary explicit. Prompts steer by default. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 - One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
 - Keep event replay ownership separate from clustered Session execution ownership.
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@aws-sdk/credential-providers": "3.1057.0",
        "@opencode/schema": "workspace:*",
@@ -54,7 +54,7 @@
    },
    "packages/app": {
      "name": "@opencode/app",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@corvu/drawer": "catalog:",
        "@dnd-kit/abstract": "0.5.0",
@@ -112,14 +112,13 @@
    },
    "packages/cli": {
      "name": "@opencode/cli",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "bin": {
        "opencode": "./bin/opencode.cjs",
        "opencode2": "./bin/opencode2.cjs",
      },
      "dependencies": {
        "@agentclientprotocol/sdk": "1.2.1",
-        "@clack/core": "1.0.0-alpha.1",
        "@clack/prompts": "1.0.0-alpha.1",
        "@effect/platform-node": "catalog:",
        "@opencode-ai/pty": "0.1.13",
@@ -136,7 +135,7 @@
        "effect": "catalog:",
        "immer": "11.1.4",
        "jsonc-parser": "3.3.1",
-        "picocolors": "1.1.1",
+        "open": "10.1.2",
        "solid-js": "catalog:",
        "tree-sitter-bash": "0.25.0",
        "tree-sitter-powershell": "0.25.10",
@@ -178,7 +177,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -204,7 +203,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
@@ -217,7 +216,7 @@
    },
    "packages/console/app": {
      "name": "@opencode/console-app",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -253,7 +252,7 @@
    },
    "packages/console/core": {
      "name": "@opencode/console-core",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -280,7 +279,7 @@
    },
    "packages/console/function": {
      "name": "@opencode/console-function",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@openauthjs/openauth": "0.0.0-20250322224806",
        "@opencode/console-core": "workspace:*",
@@ -297,7 +296,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode/console-mail",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -321,7 +320,7 @@
    },
    "packages/console/support": {
      "name": "@opencode/console-support",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@opencode/console-core": "workspace:*",
@@ -341,7 +340,7 @@
    },
    "packages/core": {
      "name": "@opencode/core",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@ai-sdk/cohere": "3.0.27",
        "@ai-sdk/gateway": "3.0.104",
@@ -369,7 +368,7 @@
        "drizzle-orm": "catalog:",
        "effect": "catalog:",
        "fuzzysort": "3.1.0",
-        "gitlab-ai-provider": "6.18.0",
+        "gitlab-ai-provider": "6.16.0",
        "google-auth-library": "10.5.0",
        "gray-matter": "4.0.3",
        "htmlparser2": "8.0.2",
@@ -409,7 +408,7 @@
    },
    "packages/desktop": {
      "name": "@opencode/desktop",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@zip.js/zip.js": "2.7.62",
        "electron-context-menu": "5.0.0",
@@ -458,7 +457,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode/enterprise",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@hono/standard-validator": "catalog:",
        "@opencode-ai/sdk": "1.18.21",
@@ -495,7 +494,7 @@
    },
    "packages/function": {
      "name": "@opencode/function",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -511,7 +510,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode/http-recorder",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@effect/platform-node-shared": "4.0.0-rc.112",
      },
@@ -530,7 +529,7 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode/httpapi-codegen",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -543,7 +542,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -557,7 +556,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -572,7 +571,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
        "@opencode/ai": "workspace:*",
@@ -598,8 +597,8 @@
      },
      "peerDependencies": {
        "@opencode/theme": "workspace:*",
-        "@opentui/core": ">=0.5.12",
-        "@opentui/solid": ">=0.5.12",
+        "@opentui/core": ">=0.5.10",
+        "@opentui/solid": ">=0.5.10",
        "solid-js": ">=1.9.0",
      },
      "optionalPeers": [
@@ -611,7 +610,7 @@
    },
    "packages/plugin-browser": {
      "name": "@opencode/plugin-browser",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -641,7 +640,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -656,7 +655,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -680,7 +679,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -701,7 +700,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "@effect/platform-node-shared": "catalog:",
@@ -723,7 +722,7 @@
    },
    "packages/session-ui": {
      "name": "@opencode/session-ui",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -758,7 +757,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -778,7 +777,7 @@
    },
    "packages/stats/app": {
      "name": "@opencode/stats-app",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@ibm/plex": "6.4.1",
        "@kobalte/core": "catalog:",
@@ -812,7 +811,7 @@
    },
    "packages/stats/core": {
      "name": "@opencode/stats-core",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@aws-sdk/client-athena": "3.933.0",
        "@planetscale/database": "1.19.0",
@@ -831,7 +830,7 @@
    },
    "packages/stats/server": {
      "name": "@opencode/stats-server",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@aws-sdk/client-firehose": "3.933.0",
        "@effect/platform-node": "catalog:",
@@ -877,7 +876,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -891,7 +890,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -910,6 +909,7 @@
        "effect": "catalog:",
        "fuzzysort": "catalog:",
        "get-east-asian-width": "catalog:",
+        "open": "10.1.2",
        "opentui-spinner": "catalog:",
        "remeda": "catalog:",
        "solid-js": "catalog:",
@@ -925,7 +925,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -960,7 +960,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -982,7 +982,6 @@
        "mime-types": "3.0.2",
        "minimatch": "10.2.5",
        "npm-package-arg": "13.0.2",
-        "open": "11.0.4",
        "pacote": "21.5.1",
      },
      "devDependencies": {
@@ -998,7 +997,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -1039,7 +1038,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.18",
+      "version": "2.0.15",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -1099,7 +1098,6 @@
    "@types/node": "catalog:",
    "bun-types": "1.4.2",
    "effect": "catalog:",
-    "open": "11.0.4",
    "solid-js": "catalog:",
  },
  "catalog": {
@@ -1116,9 +1114,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.5.12",
-    "@opentui/keymap": "0.5.12",
-    "@opentui/solid": "0.5.12",
+    "@opentui/core": "0.5.10",
+    "@opentui/keymap": "0.5.10",
+    "@opentui/solid": "0.5.10",
    "@pierre/diffs": "1.2.10",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.71.0",
@@ -2254,27 +2252,27 @@

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

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

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

-    "@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": ["@opentui/core-linux-arm64@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-ncJXcgudhBf2GdJyF3xVQN/Ec+1F7GOL+pRrURmgBYSj2v1w6EyoDQFAACtPTK2c3R38W6fvZwL4JSLlm4EFXQ=="],

-    "@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-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-dGMphDKexSdeYqwl0wgoFBP88Ta/cdi1Zc1mk29/ENkSCGz+74zlCHgqTHRNGLmI8W5TfuUtCyktQH11/Z+TBQ=="],

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

-    "@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-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-Oj4H9hApuvuTKPWxh4SoZAgGJorR7vbvnrZA/cAkSMAk2VGSoHRRcqeXQbcH8IcdjVZ0KFpv8Zkl/D5Ye+2mew=="],

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

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

-    "@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/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/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=="],
+    "@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=="],

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

@@ -4116,7 +4114,7 @@

    "github-slugger": ["github-slugger@2.0.0", "", {}, "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw=="],

-    "gitlab-ai-provider": ["gitlab-ai-provider@6.18.0", "", { "dependencies": { "@anthropic-ai/sdk": "^0.71.0", "@anycable/core": "^0.9.2", "graphql-request": "^6.1.0", "isomorphic-ws": "^5.0.0", "openai": "^6.16.0", "socket.io-client": "^4.8.1", "vscode-jsonrpc": "^8.2.1", "zod": "^3.25.76" }, "peerDependencies": { "@ai-sdk/provider": ">=3.0.0", "@ai-sdk/provider-utils": ">=4.0.0" } }, "sha512-dXTXkNt1SFCL7jGlqazHL6iUJEug21qq0tx2s+Tui7jWNUqIAHEzY9WY1+PnZlhxvB56jPPBcFAT0attpjnopg=="],
+    "gitlab-ai-provider": ["gitlab-ai-provider@6.16.0", "", { "dependencies": { "@anthropic-ai/sdk": "^0.71.0", "@anycable/core": "^0.9.2", "graphql-request": "^6.1.0", "isomorphic-ws": "^5.0.0", "openai": "^6.16.0", "socket.io-client": "^4.8.1", "vscode-jsonrpc": "^8.2.1", "zod": "^3.25.76" }, "peerDependencies": { "@ai-sdk/provider": ">=3.0.0", "@ai-sdk/provider-utils": ">=4.0.0" } }, "sha512-HMC3sKgWYaYSsgm86Cnq2e6laHlYkhiFQ6rFD5qsVghv9//6h4Ofr7j5R2KjQx9Hl8EBercPsmzjoEjEN7dX5Q=="],

    "glob": ["glob@13.0.5", "", { "dependencies": { "minimatch": "^10.2.1", "minipass": "^7.1.2", "path-scurry": "^2.0.0" } }, "sha512-BzXxZg24Ibra1pbQ/zE7Kys4Ua1ks7Bn6pKLkVPZ9FZe4JQS6/Q7ef3LG1H+k7lUf5l4T3PLSyYyYJVYUvfgTw=="],

@@ -4324,7 +4322,7 @@

    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],

-    "is-docker": ["is-docker@4.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-LHE+wROyG/Y/0ZnbktRCoTix2c1RhgWaZraMZ8o1Q7zCh0VSrICJQO5oqIIISrcSBtrXv0o233w1IYwsWCjTzA=="],
+    "is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],

    "is-document.all": ["is-document.all@1.0.0", "", { "dependencies": { "call-bound": "^1.0.4" } }, "sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g=="],

@@ -4342,8 +4340,6 @@

    "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],

-    "is-in-ssh": ["is-in-ssh@1.0.0", "", {}, "sha512-jYa6Q9rH90kR1vKB6NM7qqd1mge3Fx4Dhw5TVlK1MUBqhEOuCagrEHMevNuCcbECmXZ0ThXkRm+Ymr51HwEPAw=="],
-
    "is-inside-container": ["is-inside-container@1.0.0", "", { "dependencies": { "is-docker": "^3.0.0" }, "bin": { "is-inside-container": "cli.js" } }, "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA=="],

    "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="],
@@ -4390,7 +4386,7 @@

    "is-whitespace": ["is-whitespace@0.3.0", "", {}, "sha512-RydPhl4S6JwAyj0JJjshWJEFG6hNye3pZFBRZaTUfZFwGHxzppNaNOVgQuS/E/SlhrApuMXrpnK1EEIXfdo3Dg=="],

-    "is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="],
+    "is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],

    "isarray": ["isarray@1.0.0", "", {}, "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ=="],

@@ -4854,7 +4850,7 @@

    "oniguruma-to-es": ["oniguruma-to-es@4.3.6", "", { "dependencies": { "oniguruma-parser": "^0.12.2", "regex": "^6.1.0", "regex-recursion": "^6.0.2" } }, "sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA=="],

-    "open": ["open@11.0.4", "", { "dependencies": { "default-browser": "^5.5.1", "define-lazy-prop": "^3.0.0", "is-in-ssh": "^1.0.0", "is-inside-container": "^1.0.0", "powershell-utils": "^0.2.1", "wsl-utils": "^1.0.0" } }, "sha512-++Zlftm0kVLPmzC06t6epuWmcRMDbI4z5P3NNX979WA/k23+NtSOynEGzsVfZwguKw2mi5umVgnBlJQMwRz4Pg=="],
+    "open": ["open@10.1.2", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "is-wsl": "^3.1.0" } }, "sha512-cxN6aIDPz6rm8hbebcP7vrQNhvRcveZoJU72Y7vskh4oIm+BZwBECnx5nTmrlres1Qapvx27Qo1Auukpf8PKXw=="],

    "openai": ["openai@6.49.0", "", { "peerDependencies": { "@aws-sdk/credential-provider-node": ">=3.972.0 <4", "@smithy/hash-node": ">=4.3.0 <5", "@smithy/signature-v4": ">=5.4.0 <6", "ws": "^8.18.0", "zod": "^3.25 || ^4.0" }, "optionalPeers": ["@aws-sdk/credential-provider-node", "@smithy/hash-node", "@smithy/signature-v4", "ws", "zod"] }, "sha512-aYCc0C6L864eR6WSYIwQGyXriw/nIyZx0ObvhzOEVuk0zoBDpynjSbrionWI7q65B5H8jJX0DXR9snEzM6bfPg=="],

@@ -4998,8 +4994,6 @@

    "postject": ["postject@1.0.0-alpha.6", "", { "dependencies": { "commander": "^9.4.0" }, "bin": { "postject": "dist/cli.js" } }, "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A=="],

-    "powershell-utils": ["powershell-utils@0.2.1", "", {}, "sha512-C+y9x90UElAddDZmV4qOx9W53B61PO7cIqWz2dQsWlwswuq4mr8NEwytdGKboYbQlGZ3awrkTeNvcZiZNHnQ8A=="],
-
    "preact": ["preact@11.0.0-beta.0", "", {}, "sha512-IcODoASASYwJ9kxz7+MJeiJhvLriwSb4y4mHIyxdgaRZp6kPUud7xytrk/6GZw8U3y6EFJaRb5wi9SrEK+8+lg=="],

    "preact-render-to-string": ["preact-render-to-string@6.6.5", "", { "peerDependencies": { "preact": ">=10 || >= 11.0.0-0" } }, "sha512-O6MHzYNIKYaiSX3bOw0gGZfEbOmlIDtDfWwN1JJdc/T3ihzRT6tGGSEWE088dWrEDGa1u7101q+6fzQnO9XCPA=="],
@@ -5820,7 +5814,7 @@

    "ws": ["ws@8.21.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g=="],

-    "wsl-utils": ["wsl-utils@1.0.0", "", { "dependencies": { "is-wsl": "^3.1.0", "powershell-utils": "^0.1.0" } }, "sha512-Hl0ZOAs672vg+06kfujwRhoS6/jehvULrlFkuF2dRu6pHgA8U06h3xqNIqNNU1LTXPcedxByAR4GS6pwQK0mgA=="],
+    "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="],

    "xdg-basedir": ["xdg-basedir@5.1.0", "", {}, "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="],

@@ -5916,6 +5910,8 @@

    "@astrojs/telemetry/ci-info": ["ci-info@4.4.0", "", {}, "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg=="],

+    "@astrojs/telemetry/is-docker": ["is-docker@4.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-LHE+wROyG/Y/0ZnbktRCoTix2c1RhgWaZraMZ8o1Q7zCh0VSrICJQO5oqIIISrcSBtrXv0o233w1IYwsWCjTzA=="],
+
    "@aws-crypto/crc32/@aws-sdk/types": ["@aws-sdk/types@3.974.4", "", { "dependencies": { "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-dSFDNG00MEz0/xl5gxL62giLd1iYyJsTxZ1I1DOj6lC+bbgLB4TRsYClJg3b62dhXT1uATzsTNXPnC+33EJV3A=="],

    "@aws-crypto/crc32c/@aws-sdk/types": ["@aws-sdk/types@3.974.4", "", { "dependencies": { "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-dSFDNG00MEz0/xl5gxL62giLd1iYyJsTxZ1I1DOj6lC+bbgLB4TRsYClJg3b62dhXT1uATzsTNXPnC+33EJV3A=="],
@@ -6398,6 +6394,8 @@

    "builder-util/js-yaml": ["js-yaml@4.3.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ=="],

+    "chrome-launcher/is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="],
+
    "chromium-bidi/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],

    "clean-css/source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
@@ -6502,10 +6500,6 @@

    "import-in-the-middle/es-module-lexer": ["es-module-lexer@2.3.2", "", {}, "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw=="],

-    "is-inside-container/is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
-
-    "is-wsl/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
-
    "js-beautify/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],

    "js-beautify/nopt": ["nopt@7.2.1", "", { "dependencies": { "abbrev": "^2.0.0" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w=="],
@@ -6516,6 +6510,8 @@

    "lighthouse/devtools-protocol": ["devtools-protocol@0.0.1663043", "", {}, "sha512-33aOY3ZnBP1dgZsshgaL+/XlsQleiFZgyUaDtdZkEa1nbZhVY1MoDeWjk+wxg25fU924l1ZJfoGNmjjeA/5s1w=="],

+    "lighthouse/open": ["open@8.4.2", "", { "dependencies": { "define-lazy-prop": "^2.0.0", "is-docker": "^2.1.1", "is-wsl": "^2.2.0" } }, "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ=="],
+
    "lighthouse/ws": ["ws@7.5.13", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA=="],

    "md-to-react-email/marked": ["marked@7.0.4", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-t8eP0dXRJMtMvBojtkcsA7n48BkauktUKzfkPSCq85ZMTJ0v76Rke4DYz01omYpPTUh4p/f7HePgRo3ebG8+QQ=="],
@@ -6618,6 +6614,8 @@

    "sst/jose": ["jose@5.2.3", "", {}, "sha512-KUXdbctm1uHVL8BYhnyHkgp3zDX5KW8ZhAKVFEfUbU2P8Alpzjb+48hHvjOdQIyPshoblhzsuqOwEEAbtHVirA=="],

+    "storybook/open": ["open@10.2.0", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "wsl-utils": "^0.1.0" } }, "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA=="],
+
    "storybook-solidjs-vite/semver": ["semver@7.8.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg=="],

    "storybook-solidjs-vite/vite": ["vite@7.1.11", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-uzcxnSDVjAopEUjljkWh8EIrg6tlzrjFUfMcR1EVsRDGwf/ccef0qQPRyOrROwhrTDaApueq+ja+KLPlzR/zdg=="],
@@ -6704,10 +6702,6 @@

    "write-file-atomic/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],

-    "wsl-utils/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
-
-    "wsl-utils/powershell-utils": ["powershell-utils@0.1.0", "", {}, "sha512-dM0jVuXJPsDN6DvRpea484tCUaMiXWjuCn++HGTqUWzGDjv5tZkEZldAJ/UMlqRYGFrD/etByo4/xOuC/snX2A=="],
-
    "yaml-language-server/prettier": ["prettier@3.9.6", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-OpN0zzVdiaiAhxpuuj5efpIS4sY9j7bY6uR5mnj5yPzGkdkjNKSJeUThPb60Jw29QuAZgA4o+/iB49kFiaBX6g=="],

    "yaml-language-server/request-light": ["request-light@0.5.8", "", {}, "sha512-3Zjgh+8b5fhRJBQZoy+zbVKpAQGLyka0MPgW3zruTF4dFFJ8Fqcfu9YsAvi/rvdcaTeWG3MkbZv4WKxAn/84Lg=="],
@@ -7342,6 +7336,8 @@

    "builder-util/js-yaml/argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],

+    "chrome-launcher/is-wsl/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
    "cliui/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],

    "cliui/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
@@ -7402,6 +7398,12 @@

    "lazystream/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],

+    "lighthouse/open/define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="],
+
+    "lighthouse/open/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
+    "lighthouse/open/is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="],
+
    "miniflare/sharp/@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],

    "miniflare/sharp/@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.0.4" }, "os": "darwin", "cpu": "x64" }, "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q=="],
@@ -7672,10 +7674,6 @@

    "@astrojs/starlight/@astrojs/mdx/@astrojs/markdown-remark/shiki": ["shiki@3.23.0", "", { "dependencies": { "@shikijs/core": "3.23.0", "@shikijs/engine-javascript": "3.23.0", "@shikijs/engine-oniguruma": "3.23.0", "@shikijs/langs": "3.23.0", "@shikijs/themes": "3.23.0", "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-55Dj73uq9ZXL5zyeRPzHQsK7Nbyt6Y10k5s7OjuFZGMhpp4r/rsLBH0o/0fstIzX1Lep9VxefWljK/SKCzygIA=="],

-    "@astrojs/starlight/astro/@astrojs/telemetry/is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
-
-    "@astrojs/starlight/astro/@astrojs/telemetry/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
-
    "@astrojs/starlight/astro/p-queue/p-timeout": ["p-timeout@6.1.4", "", {}, "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg=="],

    "@astrojs/starlight/astro/sharp/@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],
@@ -8078,10 +8076,6 @@

    "@opencode/web/@astrojs/cloudflare/wrangler/workerd": ["workerd@1.20260708.1", "", { "optionalDependencies": { "@cloudflare/workerd-darwin-64": "1.20260708.1", "@cloudflare/workerd-darwin-arm64": "1.20260708.1", "@cloudflare/workerd-linux-64": "1.20260708.1", "@cloudflare/workerd-linux-arm64": "1.20260708.1", "@cloudflare/workerd-windows-64": "1.20260708.1" }, "bin": { "workerd": "bin/workerd" } }, "sha512-WAK+Kt/VVCSldH2qSr8lx46XCJ4Q+bdlHNaFqUtOHthBEIB8C1N8HVW+VOLrxDoTCk0NGNv0zajnBeQK4JOB9w=="],

-    "@opencode/web/astro/@astrojs/telemetry/is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
-
-    "@opencode/web/astro/@astrojs/telemetry/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
-
    "@opencode/web/astro/js-yaml/argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],

    "@opencode/web/astro/p-queue/p-timeout": ["p-timeout@6.1.4", "", {}, "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg=="],
@@ -8222,10 +8216,6 @@

    "archiver-utils/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],

-    "astro-expressive-code/astro/@astrojs/telemetry/is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
-
-    "astro-expressive-code/astro/@astrojs/telemetry/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
-
    "astro-expressive-code/astro/js-yaml/argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],

    "astro-expressive-code/astro/p-queue/p-timeout": ["p-timeout@6.1.4", "", {}, "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg=="],
@@ -8328,10 +8318,6 @@

    "temp/rimraf/glob/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="],

-    "toolbeam-docs-theme/astro/@astrojs/telemetry/is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
-
-    "toolbeam-docs-theme/astro/@astrojs/telemetry/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
-
    "toolbeam-docs-theme/astro/js-yaml/argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],

    "toolbeam-docs-theme/astro/p-queue/p-timeout": ["p-timeout@6.1.4", "", {}, "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg=="],
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-7DgxTpKv6ITKTom0mhlJNPQfdEjtEHK5P8uyCr26HZw=",
-    "aarch64-linux": "sha256-PJxW1Ibfx6oS1neWPSHqzP1Pm1HT9my1TrrHmOb6/no=",
-    "aarch64-darwin": "sha256-VIme5VHfM8JxNiDSOykkr5FytghDLI0FxkhiOXUSyQw=",
-    "x86_64-darwin": "sha256-rQ/j0QkR1vxAq4jgUbr0nY4RDyiLTJqN8q1AfoiEqVQ="
+    "x86_64-linux": "sha256-LQ1GAz1qF4R5P4j/kkgUygsQvxm7KStVlMf24nmyq44=",
+    "aarch64-linux": "sha256-PsNR3VaClA1O1vSE0z/Hb3XRT1pb6PvNRXuK+giIx6s=",
+    "aarch64-darwin": "sha256-7VCS+GT7tDYAMgqNCnLh1zvHAZkLTnJJ4vtfM88ruT8=",
+    "x86_64-darwin": "sha256-HyxXjiFVd8vcKvSb/BuHAY5Jj3MGgdXEvuhDuglp4ss="
  }
 }
@@ -2,7 +2,7 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "2.0.18",
+  "version": "2.0.15",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.4.2",
@@ -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.12",
-      "@opentui/keymap": "0.5.12",
-      "@opentui/solid": "0.5.12",
+      "@opentui/core": "0.5.10",
+      "@opentui/keymap": "0.5.10",
+      "@opentui/solid": "0.5.10",
      "@tanstack/solid-virtual": "3.13.37",
      "@shikijs/stream": "4.4.3",
      "@standard-schema/spec": "1.1.0",
@@ -162,7 +162,6 @@
    "@types/node": "catalog:",
    "bun-types": "1.4.2",
    "effect": "catalog:",
-    "open": "11.0.4",
    "solid-js": "catalog:"
  },
  "patchedDependencies": {
@@ -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`. `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.
+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.

-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.
+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.

-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.
+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.

 `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`.

@@ -55,7 +55,7 @@ const request = LLM.request({
  prompt: "Say hello.",
 })

-const response = yield * LLMClient.generate(request) // inside Effect.gen
+const response = yield * LLMClient.generate(request)
 ```

 `LLM.request(...)` builds an `LLMRequest`. `LLMClient.generate(...)` reads the executable route carried by `request.model.route`, builds the provider-native body, asks the route's transport for a real `HttpClientRequest.HttpClientRequest`, sends it through `RequestExecutor.Service`, parses the provider stream into common `LLMEvent`s, and finally returns an `LLMResponse`.
@@ -96,13 +96,13 @@ When a provider supports multiple physical transports, selection remains executi

 ### Media Routes

-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.
+Media does not fit the SSE-frames-to-event-state-machine LLM route. `MediaRoute.make(...)` (`src/route/media.ts`) composes a `MediaProtocol` kind with `Endpoint` and `Auth` and owns 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)`; use `MediaProtocol.decodeJson` / `text` / `bytes` so decode failures retain the raw body and HTTP context. `Generation` (`src/generation.ts`) is the provider-neutral handle for a queued generation over a `GenerationRoute` (`status`, `result`, `cancel`, `pollHint`). Image protocol files follow the same section order as LLM protocols and declare unsupported common fields once through `MediaInput.rejectUnsupported`.

-`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.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 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`. `Generation.AwaitOptions` (`{ 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.
+`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 `MediaProtocol.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 `MediaProtocol.decodeFrame` and raise stream-time failures with `MediaProtocol.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.

-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`).
+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. 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)`, `.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:
+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:

 ```ts
 const openai = OpenAI.configure({ apiKey, baseURL })
@@ -275,7 +275,6 @@ 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.
@@ -1,38 +1,40 @@
 # @opencode/ai

-Schema-first APIs for text, images, video, speech, and transcription, built with Effect.
+Schema-first language model and image-generation APIs built with Effect.

 ```ts
-import { Effect } from "effect"
-import { AIClient, LLM } from "@opencode/ai"
+import { Effect, Layer } from "effect"
+import { LLM, LLMClient } from "@opencode/ai"
+import { RequestExecutor } from "@opencode/ai/route"
 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({
-    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 response = yield* LLMClient.generate(request)
  console.log(response.text)
 })

-// Every modality client plus the HTTP request executor; `AIClient.layerWith(executor)` swaps the executor.
-await Effect.runPromise(program.pipe(Effect.provide(AIClient.layer)))
+const llmLayer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
+
+await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 ```

-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.
+Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. 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
-provider's image route from the model and returns `Media.Asset`s with lazily decoded bytes:
+The same configured facade names image models. `Image.request` resolves the provider's image route from the ref and
+returns `Media.Asset`s with lazily decoded bytes:

 ```ts
 import { NodeFileSystem } from "@effect/platform-node"
-import { Image, Media } from "@opencode/ai"
+import { Image, ImageClient, Media } from "@opencode/ai"

 const image = Effect.gen(function* () {
  const response = yield* Image.generate({
@@ -44,38 +46,21 @@ const image = Effect.gen(function* () {
  yield* Media.write(response.image, "./garden.png")
 })

-// `Media.file` / `Media.write` use the Effect `FileSystem` service; provide your platform's layer.
-await Effect.runPromise(image.pipe(Effect.provide(AIClient.layer), Effect.provide(NodeFileSystem.layer)))
+// `asset.bytes()` / `Media.write` also need the executor, so merge it into the environment instead of hiding it.
+const imageLayer = ImageClient.layer.pipe(Layer.provideMerge(RequestExecutor.fetchLayer))
+
+await Effect.runPromise(image.pipe(Effect.provide(imageLayer), Effect.provide(NodeFileSystem.layer)))
 ```

-Advanced: each client also has its own `layer`, which requires `RequestExecutor.Service`. Compose client layers with
-`Layer.provideMerge`, not `Layer.provide`: `asset.bytes()`, `Media.write`, and Gemini's `media` output parts need the
-executor too, and hiding it fails type-checking with `RequestExecutorService` left in the requirements.
-
-To share a policy such as logging across every client, wrap the executor once with `RequestExecutor.middleware`:
-
-```ts
-import { RequestExecutor } from "@opencode/ai/route"
-
-const logged = RequestExecutor.middleware((request, next) =>
-  Effect.log(`${request.method} ${request.url}`).pipe(Effect.andThen(next(request))),
-)
-
-const everything = AIClient.layerWith(logged) // or AI.make({ layer: logged })
-```
-
-Prefer promises? `@opencode/ai/promise` exposes the same LLM and media APIs over one managed runtime, plus asset
-helpers; `ai.file` and `ai.write` load `node:fs/promises` on first use, so no Effect `FileSystem` is needed:
+Prefer promises? `@opencode/ai/promise` exposes the same LLM and image APIs over one managed runtime:

 ```ts
 import { AI } from "@opencode/ai/promise"

 const ai = AI.make()
-const input = { model: openai.responses("gpt-4o-mini"), prompt: "Say hello." }
-const text = await ai.llm.generate(input)
+const text = await ai.llm.generate({ model: openai.responses("gpt-4o-mini"), prompt: "Say hello." })
 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(ai.llm.request(input))) {
+for await (const event of ai.llm.stream({ model: openai.responses("gpt-4o-mini"), prompt: "Stream hello." })) {
  // LLMEvent
 }
 await ai.dispose()
@@ -337,9 +322,10 @@ and `moonshot/responses`; each exports `model(modelID, settings)`.
 MiniMax defaults to its Messages API and reads `MINIMAX_API_KEY` when `apiKey` is omitted:

 ```ts
-import { Effect } from "effect"
-import { AIClient, LLM } from "@opencode/ai"
+import { Effect, Layer } from "effect"
+import { LLM, LLMClient } from "@opencode/ai"
 import { MiniMax } from "@opencode/ai/providers"
+import { RequestExecutor } from "@opencode/ai/route"

 const minimax = MiniMax.configure({ apiKey: process.env.MINIMAX_API_KEY })
 const request = LLM.request({
@@ -349,7 +335,8 @@ const request = LLM.request({
  generation: { maxTokens: 1536 },
 })

-const response = await Effect.runPromise(LLM.generate(request).pipe(Effect.provide(AIClient.layer)))
+const layer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
+const response = await Effect.runPromise(LLMClient.generate(request).pipe(Effect.provide(layer)))
 console.log(response.text)
 ```

@@ -418,14 +405,14 @@ Use `Image.generate` for one-off generation or editing:
 import { Image, Media } from "@opencode/ai"

 const generation = Image.generate({
-  model: meta.image("muse-image-1.0"),
+  model: meta("muse-image-1.0"),
  prompt: "A flat black square on a white background.",
  n: 1,
  providerOptions: { reasoningStrength: "low" },
 })

 const edit = Image.generate({
-  model: meta.image("muse-image-1.0"),
+  model: meta("muse-image-1.0"),
  prompt: "Make the square purple.",
  images: [Media.bytes(imageBytes, "image/webp")],
  format: "png",
@@ -472,25 +459,6 @@ 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`, `/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.
-
 `Media.Asset` is the one asset type shared by image requests, image responses, LLM messages, and tool results.
 `asset.source` is the serializable `Media.Source` (`bytes`, `base64`, `url`, or `ref`); `asset.bytes()`,
 `asset.base64()`, and `asset.dataUrl()` decode or download lazily and cache; `asset.materialize()` pulls a `url`
@@ -500,8 +468,9 @@ asset into owned bytes before the provider URL expires. Construct assets with `M
 Pass ordered image inputs to the same method for editing, composition, or image-conditioned generation:

 ```ts
-const composed = Effect.gen(function* () {
-  const response = yield* Image.generate({
+const response =
+  yield *
+  Image.generate({
    model,
    prompt: "Combine these product photos into one studio scene",
    images: [
@@ -512,25 +481,23 @@ const composed = Effect.gen(function* () {
    providerOptions,
    http,
  })
-  return response.images
-})
 ```

 `Media.ref(provider, id)` represents provider file handles such as OpenAI file IDs or Gemini Files URIs; routes
-only forward refs that belong to their own provider (OpenAI, xAI, and Gemini images accept them). No shipped route
-returns a ref yet, and `asset.bytes()` / `materialize()` on a ref fail by design. Raw strings are not accepted as
-image inputs, avoiding ambiguity between base64, URLs, and provider IDs. Empty or omitted `images` uses text-to-image generation; a
-non-empty array selects the provider's edit behavior (see the table above for routes that limit the count). OpenAI
+only forward refs that belong to their own provider. Raw strings are not accepted as image inputs, avoiding
+ambiguity between base64, URLs, and provider IDs. Empty or omitted `images` uses text-to-image generation; a
+non-empty array selects the provider's edit behavior without enforcing provider image-count limits locally. OpenAI
 uses multipart for byte/data-URL edits and its JSON reference body for URL or file-ID edits. The common `mask`
 field selects inpainting; routes that cannot honor it fail with `UnsupportedOperation`:

 ```ts
-const inpainted = Image.generate({
-  model: openai.image("gpt-image-2"),
-  prompt,
-  images: [Media.bytes(sourceBytes, "image/png")],
-  mask: Media.bytes(maskBytes, "image/png"),
-})
+yield *
+  Image.generate({
+    model: openai.image("gpt-image-2"),
+    prompt,
+    images: [Media.bytes(sourceBytes, "image/png")],
+    mask: Media.bytes(maskBytes, "image/png"),
+  })
 ```

 On multipart requests, `http.body` can override option fields but not structural `model`, `prompt`, `image[]`,
@@ -541,31 +508,31 @@ not accept image inputs. These cases fail with a typed `AIError` before network
 Provider-native image options belong to each request. Raw `http.body` fields have final precedence over them:

 ```ts
-const medium = Image.generate({
-  model: openai.image("gpt-image-2"),
-  prompt,
-  providerOptions: { quality: "medium" },
-  http,
-})
+yield *
+  Image.generate({
+    model: openai.image("gpt-image-2"),
+    prompt,
+    providerOptions: { quality: "medium" },
+    http,
+  })
 ```

 xAI image models use the same request API with xAI-native controls:

 ```ts
-import { XAI } from "@opencode/ai/providers"
-
-const xai = Image.generate({
-  model: XAI.configure({ apiKey }).image("any-model-id"),
-  prompt,
-  n: 2,
-  aspectRatio: "16:9",
-  providerOptions: {
-    resolution: "1k",
-    responseFormat: "b64_json",
-    future_option: true,
-  },
-  http,
-})
+yield *
+  Image.generate({
+    model: XAI.configure({ apiKey })("any-model-id"),
+    prompt,
+    n: 2,
+    aspectRatio: "16:9",
+    providerOptions: {
+      resolution: "1k",
+      responseFormat: "b64_json",
+      future_option: true,
+    },
+    http,
+  })
 ```

 Google's current Gemini image models use the same direct API:
@@ -575,7 +542,7 @@ import { Google } from "@opencode/ai/providers"

 const googleProgram = Effect.gen(function* () {
  const response = yield* Image.generate({
-    model: Google.configure({ apiKey }).image("any-model-id"),
+    model: Google.configure({ apiKey })("any-model-id"),
    prompt: "A robot tending a rooftop garden",
    aspectRatio: "16:9",
    seed: 42,
@@ -600,88 +567,23 @@ their mapped aliases, and `http.body` is the final deep overlay. The selected mo
 Z.ai image models infer open Z.ai-native options from the selected model:

 ```ts
-import { ZAI } from "@opencode/ai/providers"
-
-const zai = Image.generate({
-  model: ZAI.configure({ apiKey }).image("any-model-id"),
-  prompt,
-  providerOptions: {
-    quality: "hd",
-    userID: "user-123",
-    future_option: true,
-  },
-  http,
-})
+yield *
+  Image.generate({
+    model: ZAI.configure({ apiKey })("any-model-id"),
+    prompt,
+    providerOptions: {
+      quality: "hd",
+      userID: "user-123",
+      future_option: true,
+    },
+    http,
+  })
 ```

 Z.ai does not include trustworthy MIME metadata for output URLs, so generated images use
 `application/octet-stream` until materialized. Output URLs expire after 30 days; call `asset.materialize()` and
 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:
-
-```ts
-import { Stream } from "effect"
-import { ImageEvent } from "@opencode/ai"
-
-const previews = Image.stream({
-  model: openai.image("gpt-image-2"),
-  prompt: "A lighthouse at dusk",
-  providerOptions: { partialImages: 2 },
-}).pipe(Stream.runForEach((event) => (ImageEvent.is.imagePartial(event) ? showPreview(event.image) : Effect.void)))
-```
-
-The provider may send fewer previews than requested when the final image is ready first.
-
-### Queued image providers
-
-Black Forest Labs, fal, Replicate, and Stability's creative upscaler are submit-then-poll routes. `Image.generate`
-and `Image.stream` poll for you (pass `{ poll }` to tune the interval and timeout); `Image.start` returns a
-`Generation` whose `token` is serializable JSON for `Image.resume` in another process:
-
-```ts
-import { BlackForestLabs, Stability } from "@opencode/ai/providers"
-
-const bfl = BlackForestLabs.configure({ apiKey: process.env.BFL_API_KEY })
-
-const submit = Effect.gen(function* () {
-  const generation = yield* Image.start({ model: bfl.image("flux-2-pro"), prompt, size: "1024x768" })
-  persist({ provider: "black-forest-labs", modelID: "flux-2-pro", token: generation.token })
-})
-
-const finish = Effect.gen(function* () {
-  const saved = load()
-  const resumed = yield* Image.resume(bfl.image(saved.modelID), saved.token)
-  return yield* resumed.await({ poll: { interval: "2 seconds" } })
-})
-```
-
-The token carries no route identity, so persist the provider and model ID alongside it: `resume` needs the model.
-
- **Black Forest Labs** — results are downloaded before returning, because `result.sample` expires in 10 minutes.
- **Replicate** — inputs are model-defined, so only `prompt` lowers: sizing, count, seed, format, and files go in
-  `providerOptions` under the model's names, with files as `Media.Asset` (data URLs up to 256 KB, larger by URL).
-  Outputs are removed an hour after the prediction completes. `Prefer: wait=60` in `headers` or `http.headers` holds
-  the submission open so a fast prediction costs one result read.
- **Stability** — `stability.image(id)` generates inline; `stability.upscale()` is the creative upscaler, queued:
-
-```ts
-const stability = Stability.configure({ apiKey: process.env.STABILITY_API_KEY })
-const upscaled = Effect.gen(function* () {
-  const small = yield* Media.file("./small.png")
-  return yield* Image.generate(
-    { model: stability.upscale(), prompt: "A lighthouse", images: [small] },
-    { poll: { interval: "5 seconds" } },
-  )
-})
-```
-
-Imagen is not available: Google shut it down on the Gemini API, and Vertex discontinued the Imagen 4 models on
-2026-06-30. `Google.image(...)` uses Gemini-native image models.
-
 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:

 ```ts
@@ -698,7 +600,7 @@ const program = Effect.gen(function* () {
 })
 ```

-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.
+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.

 ## Video generation

@@ -709,8 +611,8 @@ Common fields (`frames`, `references`, `video`, `durationSeconds`, `aspectRatio`
 under `providerOptions`, inferred from the selected model.

 ```ts
-import { Video } from "@opencode/ai"
-import { Google, Runway } from "@opencode/ai/providers"
+import { Video, VideoClient } from "@opencode/ai"
+import { Google } from "@opencode/ai/providers"

 const google = Google.configure({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY })

@@ -739,7 +641,6 @@ const controlled = Effect.gen(function* () {
  generation.id // provider operation / task / request id
  generation.status // "queued" | "running" | "completed" | "failed" | "cancelled" | "expired"
  generation.token // route-owned JSON: `{ operation }`, `{ requestID }`, `{ taskID }`, or fal's follow-up URLs
-  // The token carries no route identity: persist the provider and model ID alongside it, since `resume` needs the model.
  const saved = JSON.stringify(generation.token)

  const resumed = yield* Video.resume(google.video("veo-3.1-generate-preview"), JSON.parse(saved))
@@ -750,8 +651,8 @@ const controlled = Effect.gen(function* () {
 const events = Video.stream({ model: Runway.configure({ apiKey }).video("gen4.5"), prompt }, { poll })
 ```

-Status polls, result fetches, cancels, and asset downloads all run through the same request executor with the route's
-auth. `Generation.await` and `Generation.events` fail with a
+`VideoClient.layer` needs `RequestExecutor.Service`, and status polls, result fetches, cancels, and asset downloads
+all run through the same executor with the route's auth. `Generation.await` and `Generation.events` fail with a
 `Timeout` reason when `poll.timeout` (default 10 minutes) elapses. Failed,
 cancelled, and expired generations fail typed with the provider's terminal document on `reason.body`; moderation
 outcomes (Veo `raiMediaFilteredReasons`, xAI `respect_moderation`, Runway `SAFETY.*` codes) surface as `notices` when
@@ -770,20 +671,15 @@ Provider notes:
 - **Runway** expects pixel ratios in `aspectRatio` for most models (`"1280:720"`), pins `X-Runway-Version`, reports
  `usage: { type: "credits" }`, and its output URLs expire after 24–48 hours.

-The promise client exposes the same surface: `ai.video.start(...)` resolves to a handle with `await`, `events`,
-`result`, `refresh`, `cancel`, and `token`; `ai.video.generate`, `ai.video.resume(model, token)`, and
-`ai.video.stream` mirror the Effect API. The handle's `status` and `progress` are a snapshot from when it was
-created; `refresh()` resolves to a new handle. Every promise method and stream accepts `{ signal }`: like `fetch`,
-aborting rejects the Promise or throws from the `for await` loop with `signal.reason` (an `AbortError` `DOMException`
-unless `abort(reason)` passed one), while `break` stops a stream without throwing.
+The promise client exposes the same surface: `ai.video.start(...)` resolves to a handle with `await`, `refresh`,
+`cancel`, and `token`; `ai.video.generate`, `ai.video.resume(model, token)`, and `ai.video.stream` mirror the Effect
+API.

 ```ts
 import { ai } from "@opencode/ai/promise"

 const generation = await ai.video.start({ model, prompt })
-for await (const event of generation.events({ poll: { interval: 10_000 } })) console.log(event.type)
-const video = await generation.result({ signal })
-await ai.write(video.video, "./kite.mp4")
+const video = await generation.await({ poll: { interval: 10_000 }, signal })
 ```

 ## Speech generation
@@ -835,16 +731,16 @@ ElevenLabs and Cartesia. `{ id }` selects an OpenAI custom voice (`{ id: "voice_
 plain string elsewhere. There is no cross-provider voice catalog. `format` is the container-level word (`mp3`, `wav`,
 `pcm`, `opus`, `aac`, `flac`); sample rates and bitrates live under `providerOptions`, and a value the route cannot
 produce fails as `UnsupportedOperation`. Streams buffer every chunk so `finish` can carry the whole clip.
+`SpeechClient.layer` needs `RequestExecutor.Service`.

 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 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
+- **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
  `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`);
@@ -863,7 +759,7 @@ The promise client mirrors the Effect API; `ai.speech.stream` is an `AsyncIterab
 import { ai } from "@opencode/ai/promise"

 const response = await ai.speech.generate({ model, text: "Hello from OpenCode.", voice: "coral" })
-await ai.write(response.audio, "hello.mp3")
+await Bun.write("hello.mp3", await ai.run(response.audio.bytes()))

 for await (const event of ai.speech.stream({ model, text: "Hello from OpenCode.", voice: "coral" })) {
  if (event.type === "audio-delta") player.write(event.chunk)
@@ -880,7 +776,6 @@ facades. Common fields (`language`, `prompt`, `timestamps: "none" | "segment" |
 natively or fail with a typed `AIError` before any network call; a route may return more than asked.

 ```ts
-import { Console, Effect, Stream } from "effect"
 import { Media, Transcription, TranscriptionEvent } from "@opencode/ai"
 import { AssemblyAI, Deepgram, OpenAI } from "@opencode/ai/providers"

@@ -907,7 +802,7 @@ const program = Effect.gen(function* () {
    Stream.runDrain,
  )

-  // Queued: persist the token with the provider and model ID (the token alone cannot pick the model), resume, and await.
+  // Queued: persist the token, resume from another process, and await.
  const model = AssemblyAI.configure({ apiKey }).transcription("universal-3-5-pro")
  const generation = yield* Transcription.start({ model, audio })
  const resumed = yield* Transcription.resume(model, JSON.parse(JSON.stringify(generation.token)))
@@ -916,7 +811,7 @@ const program = Effect.gen(function* () {
 ```

 Inline routes emit only `finish` from `stream` (no faked deltas); queued routes emit `generation-queued` /
-`generation-progress` before it.
+`generation-progress` before it. `TranscriptionClient.layer` needs `RequestExecutor.Service`.

 Provider notes:

@@ -928,7 +823,6 @@ Provider notes:
 The promise client mirrors the Effect API:

 ```ts
-const audio = await ai.file("./call.mp3")
 const text = (await ai.transcription.generate({ model, audio })).text
 for await (const event of ai.transcription.stream({ model, audio })) if (event.type === "text-delta") write(event.delta)
 const generation = await ai.transcription.start({ model: assemblyai, audio })
@@ -938,19 +832,17 @@ 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`** — run direct input or an `LLMRequest` through `LLMClient` for one-import use.
+- **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`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.
- **`Image.request` / `generate` / `stream` / `start` / `resume`** — images over inline, streaming (partial previews), and queued routes through a provider-neutral request and response model.
+- **`Image.request` / `Image.generate` / `Image.stream`** — generate images through a provider-neutral image request and response model.
 - **`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.
- **`@opencode/ai/promise`** — `AI.make({ layer? })` and a default `ai` client exposing `llm`, `image`, `video`, `speech`, and `transcription` as Promise / `AsyncIterable` APIs, plus `file`, `write`, `bytes`, `base64`, and `materialize` for assets.
+- **`@opencode/ai/promise`** — `AI.make({ layer? })` and a default `ai` client exposing `llm`, `image`, `video`, `speech`, and `transcription` as Promise / `AsyncIterable` APIs.

 ## Testing

@@ -1013,13 +905,11 @@ This is different from prompt caching, server-side history storage, or truncatio
 Prefer this operation, where supported, when the application owns compaction policy and durable context updates.

 ```ts
-const compacted = Effect.gen(function* () {
-  const result = yield* LLMClient.compact(request)
-  const next = LLMRequest.update(request, {
-    messages: result.replacement,
-  })
-  return yield* LLMClient.generate(next)
+const result = yield * LLMClient.compact(request)
+const next = LLMRequest.update(request, {
+  messages: result.replacement,
 })
+const response = yield * LLMClient.generate(next)
 ```

 `replacement` replaces the complete input window. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly.
@@ -1035,16 +925,16 @@ The input must still fit the model's context window. Explicit compaction is not
 OpenAI Responses also exposes a separate, explicitly selected mechanism:

 ```ts
-const checkpoint = Effect.gen(function* () {
-  const result = yield* LLMClient.compact(request, {
+const result =
+  yield *
+  LLMClient.compact(request, {
    mechanism: "trigger",
    webSocket, // Optional: without it, the request uses HTTP/SSE.
  })

-  result.checkpoint // Successful encrypted CompactionPart.
-  result.responseID
-  result.usage
-})
+result.checkpoint // Successful encrypted CompactionPart.
+result.responseID
+result.usage
 ```

 This appends a native `compaction_trigger` control item to the full input and sends a normal Responses request, with tools and instructions retained, `stream: true`, `store: false`, and parallel tool calls enabled. It removes normal-answer text/output-format controls, forced tool choices, output-token/tool-call limits, and automatic `context_management`. Body overlays cannot replace `input` or supply `previous_response_id`/`conversation`; the complete canonical history is required for safe stateless replay. Request metadata, auth, headers, query parameters, service tier, and supported prompt-cache settings are preserved.
@@ -1058,11 +948,9 @@ The supplied WebSocket executor can reuse a compatible append baseline for the c
 Trigger support is separate from endpoint support. Only the OpenAI Responses route advertises it; Azure, xAI, Chat, and compatible Responses routes do not inherit it. Untyped calls still fail before sending: missing route capabilities return `UnsupportedOperation`, while unknown mechanism names and invalid inputs return `InvalidRequest`. Dynamic callers must narrow for the selected mechanism:

 ```ts
-const narrowed = Effect.gen(function* () {
-  if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
-    const result = yield* LLMClient.compact(request, { mechanism: "trigger" })
-  }
-})
+if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
+  const result = yield * LLMClient.compact(request, { mechanism: "trigger" })
+}
 ```

 This capability describes protocol implementation, **not universal availability on OpenAI API deployments**. The host application owns subscription/deployment eligibility, OAuth, endpoint selection, and deployment-specific headers. Local protocol/socket tests do not establish live provider support.
@@ -1071,10 +959,9 @@ This capability describes protocol implementation, **not universal availability

 `providerOptions.contextManagement` lets the provider decide when to compact during an ordinary `generate` or `stream` call. This is an advanced option for callers that own persistence and recovery: persist the complete assistant message, including its checkpoint, before continuing. Enabling the option does not provide durable checkpoint storage, interruption recovery, or model-switch policy. Keep the prior context until a successful checkpoint has been persisted.

-Enable OpenAI compaction with typed provider options:
+Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:

 ```ts
-import { Effect } from "effect"
 import { LLM, LLMClient, LLMRequest, Message } from "@opencode/ai"
 import { OpenAI } from "@opencode/ai/providers"

@@ -1085,11 +972,9 @@ const request = LLM.request({
    contextManagement: [{ type: "compaction", compactThreshold: 200_000 }],
  },
 })
-const continued = Effect.gen(function* () {
-  const response = yield* LLMClient.generate(request)
-  return LLMRequest.update(request, {
-    messages: [...request.messages, response.message, Message.user("Continue")],
-  })
+const response = yield * LLMClient.generate(request)
+const next = LLMRequest.update(request, {
+  messages: [...request.messages, response.message, Message.user("Continue")],
 })
 ```

@@ -1317,7 +1202,7 @@ Compose a route with `Route.make({ protocol, endpoint, auth, framing, ... })`. T

 ## Effect

-This package is built on Effect. Public methods return `Effect` or `Stream`; provide `AIClient.layer` (or `AIClient.layerWith(executor)`) for every modality, then import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
+This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for LLM dispatch and `ImageClient.layer` for image dispatch, then import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.

 ## See also

@@ -1,7 +1,6 @@
 # Media generation in `@opencode/ai` — public API direction

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

 ## Goal

@@ -12,11 +11,11 @@ The design below is derived from a survey of the raw provider APIs (OpenAI, Gemi
 ## What the survey forces

 1. **Three execution shapes, everywhere.** Inline sync (OpenAI images, all TTS, Gemini), async job with polling or webhook (every video provider, BFL, fal, Replicate, AssemblyAI), and bidirectional streams (ElevenLabs/Cartesia/Deepgram WS, realtime). Video has no sync provider at all.
-2. **Output is never just bytes.** base64, signed URLs with TTLs from 10 minutes (BFL, so its route downloads before returning via `PollContext.materialize`) to 2 days (Veo), URLs that need auth plus redirect (Veo), separate download endpoints (Sora `/content?variant=`), raw bodies (Stability, TTS). Multi-output is the norm.
+2. **Output is never just bytes.** base64, signed URLs with TTLs from 10 minutes (BFL) to 2 days (Veo), URLs that need auth plus redirect (Veo), separate download endpoints (Sora `/content?variant=`), raw bodies (Stability, TTS). Multi-output is the norm.
 3. **Inputs have roles.** First/last frame, mask, style/subject reference, source video for edit/extend, reference audio, prior generation id, provider-side file handles (`file_id`, `gs://`, `runway://`, `mm_file://`).
 4. **Partial streaming is modality-specific.** Images: a few whole partial frames. Audio: ordered chunks plus timestamp events. Jobs: status/progress/logs. Video: none.
 5. **Usage is a union**: tokens, seconds, characters (often only in headers), credits, compute time.
-6. **Moderation can be partial success** (Veo strips audio but returns video). Deprecations are constant (Sora API shuts down 2026-09-24; Imagen is shut down on the Gemini API and past its 2026-06-30 discontinuation date on Vertex).
+6. **Moderation can be partial success** (Veo strips audio but returns video). Deprecations are constant (Sora API shuts down 2026-09-24, Imagen on Gemini API 2026-08-17).

 ## Where existing SDKs are weak and we should not be

@@ -41,7 +40,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 — `.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`.
+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`.

 ```ts
 import { OpenAI, Google } from "@opencode/ai/providers"
@@ -55,7 +54,7 @@ Speech.request({ model: openai.speech("gpt-4o-mini-tts"), text })
 Transcription.request({ model: openai.transcription("gpt-4o-transcribe"), audio })
 ```

-The request namespace and the selector share one word (`Image.request` + `.image(...)`). That redundancy is accepted: a callable facade returning a lazily resolved ref would be a second way to construct the same model, and the type machinery to infer `providerOptions` through it is not worth one word. Where a provider has two routes for one modality, the selectors stay explicit (`openai.chat`, `stability.image` inline vs `stability.upscale()` queued), and one default per modality per provider is part of the facade definition (OpenAI image → Images API, Google image → Gemini-native; Imagen is shut down, so there is no `google.imagen`). The facade selector (`openai.image(id)`) is the public path for media models. Modality-specific package entrypoints (`model(modelID, settings)` beside today's LLM paths such as `@opencode/ai/providers/openai/responses`) are deferred until Core has a modality-aware model resolver; Core's resolver accepts only `LanguageModel` today.
+The request namespace and the selector share one word (`Image.request` + `.image(...)`). That redundancy is accepted: a callable facade returning a lazily resolved ref would be a second way to construct the same model, and the type machinery to infer `providerOptions` through it is not worth one word. Where a provider has two APIs for one modality, the selectors stay explicit (`openai.chat`, a future `google.imagen`), and one default per modality per provider is part of the facade definition (OpenAI image → Images API, Google image → Gemini-native since Imagen on the Gemini API shuts down 2026-08-17). Provider package entrypoints keep `model(modelID, settings)` per modality-specific path, e.g. `@opencode/ai/providers/openai/responses`.

 ### `Media` — the asset type

@@ -87,18 +86,10 @@ class Media.Asset {

 Media.bytes(data, mediaType?)      Media.base64(data, mediaType?)
 Media.url(url, options?)           Media.ref(provider, id)
-Media.file(path)                   // Effect<Asset, AIError, FileSystem>: reads + sniffs
-Media.write(asset, path)           // Effect<void, AIError, FileSystem | RequestExecutor.Service>
+Media.file(path)                   // Bun/Node: reads + sniffs; Effect FileSystem variant for layers
+Media.write(asset, path)           // convenience, uses FileSystem
 ```

-`Media.file` and `Media.write` stay Effect-only: bring your platform's `FileSystem` layer. The Promise client owns the
-runtime path: `ai.file(path)` and `ai.write(asset, path)` read and write through `node:fs/promises` (loaded on first
-use) with the same media-type sniffing and `InvalidRequest` failures, and `ai.bytes`, `ai.base64`, and
-`ai.materialize` run the asset methods in its runtime.
-
-A `ref` source is accepted as input only by routes whose provider issues file handles. No shipped route produces one
-yet, so `bytes()` and `materialize()` on a ref fail by design until a producer exists.
-
 Raw-PCM outputs (Gemini TTS, Cartesia raw, Deepgram WS) carry `info.encoding/sampleRate/channels` because there is no container header.

 ### Modality namespaces
@@ -113,87 +104,77 @@ import { OpenAI, Google, ElevenLabs, Fal } from "@opencode/ai/providers"
 #### Image

 ```ts
-Effect.gen(function* () {
-  const request = Image.request({
-    model: openai.image("gpt-image-2"),
-    prompt: "A robot tending a rooftop garden",
-    images: [yield* Media.file("./ref.png")],     // references / edit sources
-    mask: yield* Media.file("./mask.png"),
-    n: 2,
-    size: "1536x1024",                            // OpenAI sizes by pixels; Gemini/xAI take aspectRatio instead
-    format: "webp",
-    providerOptions: { quality: "high", background: "transparent" },   // typed per model
-  })
-
-  const response = yield* Image.generate(request) // ImageResponse
-  response.image                                  // Media.Asset (first)
-  response.images                                 // Media.Asset[]
-  response.usage                                  // Usage union (see below)
-  response.notices                                // moderation / partial-result notices
-
-  Image.stream(request)                           // Stream<ImageEvent>
-  // ImageEvent: generation-queued | generation-progress | image-partial { index, image } | image { index, image } | finish { usage }
+const request = Image.request({
+  model: openai.image("gpt-image-2"),
+  prompt: "A robot tending a rooftop garden",
+  images: [Media.file("./ref.png")],           // references / edit sources
+  mask: Media.file("./mask.png"),
+  n: 2,
+  size: "1536x1024",                            // or aspectRatio: "3:2"
+  seed: 7,
+  format: "webp",
+  providerOptions: { quality: "high", background: "transparent" },   // typed per model
 })
+
+const response = yield* Image.generate(request)   // ImageResponse
+response.image                                    // Media.Asset (first)
+response.images                                   // Media.Asset[]
+response.usage                                    // Usage union (see below)
+response.notices                                  // moderation / partial-result notices
+
+yield* Image.stream(request)                      // Stream<ImageEvent>
+// ImageEvent: generation-queued | generation-progress | image-partial { index, image } | image { index, image } | finish { usage }
 ```

-`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`, 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

 Shipped in phase 2 (`src/video.ts`, `src/video-client.ts`, protocols `google-video`, `xai-video`, `fal-video`, `runway-video`).

 ```ts
-Effect.gen(function* () {
-  const request = Video.request({
-    model: google.video("veo-3.1-generate-preview"),
-    prompt: "Panning wide shot of a calico kitten sleeping in the sunshine",
-    frames: { first: yield* Media.file("./start.png"), last: yield* Media.file("./end.png") },
-    references: [yield* Media.file("./style.png")],
-    video: Media.bytes(previous, "video/mp4"),    // edit / extend source
-    durationSeconds: 8,
-    aspectRatio: "16:9",
-    resolution: "1080p",
-    audio: true,
-    n: 1,
-    seed: 7,
-    negativePrompt: "text, watermark",            // common, not provider-native
-    providerOptions: { personGeneration: "allow_adult" },
-  })
-
-  // Simple: wait for it.
-  const response = yield* Video.generate(request, { poll: { interval: "10 seconds", timeout: "10 minutes" } })
-  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
-
-  // Explicit generation control.
-  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}; 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.
-  const resumed = yield* Video.resume(model, JSON.parse(saved))
-
-  // Progress as a stream.
-  Video.stream(request, { poll })                    // Stream<VideoEvent>: generation-queued { id, position } | generation-progress { id, progress } | video { index, video } | finish { usage, notices }
+const request = Video.request({
+  model: google.video("veo-3.1-generate-preview"),
+  prompt: "Panning wide shot of a calico kitten sleeping in the sunshine",
+  frames: { first: Media.file("./start.png"), last: Media.file("./end.png") },
+  references: [Media.file("./style.png")],
+  video: Media.bytes(previous, "video/mp4"),    // edit / extend source
+  durationSeconds: 8,
+  aspectRatio: "16:9",
+  resolution: "1080p",
+  audio: true,
+  n: 1,
+  seed: 7,
+  negativePrompt: "text, watermark",            // common, not provider-native
+  providerOptions: { personGeneration: "allow_adult" },
 })
+
+// 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.notices                                   // Veo raiMediaFilteredReasons → filtered, xAI respect_moderation → moderated
+yield* response.video.materialize()                // pull bytes before the URL expires
+
+// Explicit generation control.
+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
+
+// Resume from another process. The token is validated against the route's codec and refreshed once.
+const resumed = yield* Video.resume(model, JSON.parse(saved))
+
+// Progress as a stream.
+yield* Video.stream(request, { poll })             // Stream<VideoEvent>: generation-queued { id, position } | generation-progress { id, progress } | video { index, video } | finish { usage, notices }
 ```

 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, 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`.
+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`.

 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.
@@ -217,7 +198,7 @@ const request = Speech.request({
 })

 const response = yield* Speech.generate(request)   // SpeechResponse: audio: Media.Asset, timestamps?, usage?, providerMetadata?
-yield* Speech.stream(request)                      // Stream<SpeechEvent>: generation-queued | generation-progress | audio-delta { chunk } | timestamps { items } | finish { audio, usage? }
+yield* Speech.stream(request)                      // Stream<SpeechEvent>: 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`
@@ -243,12 +224,10 @@ 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'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"`.
+(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"`.

 **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
@@ -281,7 +260,7 @@ const request = Transcription.request({
  language: "en",                                  // provider-native passthrough
  timestamps: "segment",                           // none | segment | word
  diarize: true,
-  speakers: 2,                                     // exact speaker count (AssemblyAI only)
+  speakers: 2,                                     // expected count, hint only (AssemblyAI)
  providerOptions: { known_speaker_names: ["agent"] },
 })

@@ -295,11 +274,10 @@ 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 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
+`<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
 `finish` event carries the whole transcript (text, segments, words, language, duration, usage), so the stream route's
 `collect` is just "take `finish`".

@@ -314,12 +292,11 @@ 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 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.
+  cross-provider speaker model. `speakers` is a hint; only AssemblyAI (`speakers_expected`) accepts it.
 - **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 (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.
+  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.
 - **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.
@@ -329,7 +306,7 @@ Settled rules:

 | Provider | Kind | Audio input | `timestamps` | `diarize` | Unsupported | Usage |
 |---|---|---|---|---|---|---|
-| 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` |
+| 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` |
 | 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`) |
@@ -343,23 +320,24 @@ with the realtime work in phase 5. ElevenLabs Scribe is not implemented yet.
 ```ts
 class Generation<Response> {
  readonly id: string
-  readonly route: GenerationRoute<Response>        // token-free: { status, result, cancel?: Effect } closed over the decoded token
+  readonly route: GenerationRoute<Response>        // token-free: { status, result, cancel?: Effect; pollHint? } closed over the decoded token
  readonly token: unknown                          // route-owned serializable JSON
  readonly status: "queued" | "running" | "completed" | "failed" | "cancelled" | "expired"
  readonly progress?: number                       // 0..1, normalized
  readonly position?: number
+  readonly expiresAt?: number
  refresh(): Effect<Generation<Response>, AIError>
  result(): Effect<Response, AIError>
-  await(options?: GenerationAwaitOptions): Effect<Response, AIError>
+  await(options?: AwaitOptions): Effect<Response, AIError>
  cancel(): Effect<void, AIError>
-  events(options?: GenerationAwaitOptions): Stream<GenerationEvent, AIError>   // fails with Timeout past poll.timeout, checked per observation
+  events(options?: AwaitOptions): Stream<GenerationEvent, AIError>   // fails with Timeout past poll.timeout, checked per observation
 }

-GenerationAwaitOptions = { poll?: Poll }
-Poll = { interval?: Duration; timeout?: Duration }
+AwaitOptions = { poll?: Poll }
+Poll = { interval?: Duration; timeout?: Duration; schedule?: Schedule }   // route may override from provider hints (`openai-poll-after-ms`)
 ```

-`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`.
+`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`.

 ### Usage

@@ -385,56 +363,48 @@ const ai = AI.make()                                // ManagedRuntime over Reque
 // AI.make({ layer }) to inject a custom executor / recorder / middleware

 const image = await ai.image.generate({ model, prompt })
-await ai.bytes(image.image)                         // also ai.base64, ai.materialize, ai.write(asset, path)
-const reference = await ai.file("./ref.png")
+await image.image.bytes()

 for await (const event of ai.speech.stream({ model, text, voice })) { … }

-const generation = await ai.video.start({ model, prompt })    // snapshot handle; refresh() returns a new one
-for await (const event of generation.events({ poll: { interval: 10_000 } })) { … }
+const generation = await ai.video.start({ model, prompt })
 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 resumed = ai.video.resume(model, JSON.parse(saved))

-const request = ai.llm.request({ model, prompt })
-const text = await ai.llm.generate(request)
+const text = await ai.llm.generate({ model, prompt })   // closes today's gap: LLM has no promise API either
 for await (const event of ai.llm.stream(request)) { … }

 await ai.dispose()
 ```

-Streams become `AsyncIterable` via `Stream.toAsyncIterable`. `AIError` is thrown as-is. Aborting an `AbortSignal` interrupts the work and, like `fetch`, rejects the Promise or throws from the stream with `signal.reason` instead of ending the stream as if complete. Nothing in `src/*` except this entrypoint knows about promises.
+Streams become `AsyncIterable` via `Stream.toAsyncIterable`. `AIError` is thrown as-is. `AbortSignal` maps to interruption. Nothing in `src/*` except this entrypoint knows about promises.

 ### Providers

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

 | Facade | llm | image | video | speech | transcription | other |
 |---|---|---|---|---|---|---|
-| `OpenAI` | responses (default), chat | Images API (stream) | *Sora skipped (decision 8)* | ✓ | ✓ | |
-| `Google` | Gemini | Gemini-native | Veo | Gemini TTS | `gemini-3.5-transcribe` | |
+| `OpenAI` | responses (default), chat | Images API | Sora (deprecated 2026-09-24) | ✓ | ✓ | |
+| `Google` | Gemini | Gemini-native (default), `imagen` | Veo | Gemini TTS | `gemini-3.5-transcribe` | |
 | `XAI` | ✓ | ✓ | ✓ | | | |
-| `ElevenLabs` | | | | ✓ | *Scribe (pending)* | *soundEffect, music (phase 5)* |
+| `ElevenLabs` | | | | ✓ | Scribe | soundEffect, music |
 | `Cartesia` | | | | ✓ | | |
 | `Deepgram` | | | | Aura | ✓ | |
-| `Fal` | | ✓ (queued) | ✓ | | | |
+| `Fal` | | ✓ | ✓ | | | |
 | `AssemblyAI` | | | | | ✓ (queued) | |
-| `BlackForestLabs` | | ✓ (queued) | | | | |
-| `Replicate` | | ✓ (queued) | | | | |
-| `Stability` | | `image` (inline), `upscale()` (queued) | | | | |
-| `Runway` | | | ✓ | | | |
-| `Luma`, `Kling`, `MiniMax` | | *deferred* | *deferred* | | | |
+| `Replicate`, `Runway`, `Luma`, `Kling`, `MiniMax`, `BlackForestLabs`, `Stability` | | per provider | | | | |

-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.
+New facades follow the existing one-file-per-provider rule. Package entrypoints are modality-specific, such as `@opencode/ai/providers/openai/images`, and return the concrete model.

-`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.
+`ImageModel<Options>` already gives typed `providerOptions` per model; `VideoModel`, `SpeechModel`, `TranscriptionModel` follow the same generic. A shared `MediaModel` union is what `Generation` and the promise client key on.

 ### Routes and protocols

 Media does not fit the LLM four-axis route (SSE frames → event state machine) except for streaming TTS/STT. Reuse `Endpoint`, `Auth`, `Framing`, `RequestExecutor`, and add media protocol kinds:

 - `MediaProtocol.inline` — `body.from(request)` (JSON, multipart, or query), `response.decode(response)` (JSON, or binary body → `Media.Asset`).
- `MediaProtocol.queued` — `start` (body + decode to `{ token, snapshot }`), `status`, `result`, optional `cancel`, and a `token` codec. `result` is always a separate GET (against the status document for Veo/xAI/Runway, fal's `response_url` otherwise) so `await` after `start` and after `resume` share one path. `PollContext.auth` hands the auth headers the route sent to the protocol for output URLs that need them (Veo downloads); they become transient `Media.Asset.headers`, never part of `source`. There is no separate `download` step: `Media.Asset.bytes()` downloads through the executor with those headers. `MediaRoute.inline(...)` / `MediaRoute.queued(...)` compose each kind with endpoint and auth; the queued route decodes the token once and hands `Generation` a token-free `{ status, result, cancel? }`.
+- `MediaProtocol.queued` — `start` (body + decode to `{ token, snapshot }`), `status`, `result`, optional `cancel`, `pollHint`, and a `token` codec. `result` is always a separate GET (against the status document for Veo/xAI/Runway, fal's `response_url` otherwise) so `await` after `start` and after `resume` share one path. `PollContext.auth` hands the auth headers the route sent to the protocol for output URLs that need them (Veo downloads); they become transient `Media.Asset.headers`, never part of `source`. There is no separate `download` step: `Media.Asset.bytes()` downloads through the executor with those headers. `MediaRoute.inline(...)` / `MediaRoute.queued(...)` compose each kind with endpoint and auth; the queued route decodes the token once and hands `Generation` a token-free `{ status, result, cancel? }`.
 - `MediaProtocol.stream` — `body.from(request)` over the request plus its `mode`, `frames` (a function that picks the framing for the call: `Framing.sse`, `lines`, `document`, or the raw bytes), fresh per-response `initial()` state, `step` emitting modality events, and `finish(state, context)` — with the observed response for header-only usage — emitting exactly one terminal event or failing as an incomplete stream. The route fills `reason.http` on stream errors. `MediaRoute.stream(...)` exposes `stream` and `generate` (the same stream folded by the modality's `collect`).

 `MediaRoute.inline` / `MediaRoute.queued` / `MediaRoute.stream` compose one protocol kind with endpoint/auth and tag the route with its `kind`; `ImageModel`/`VideoModel`/`SpeechModel`/`TranscriptionModel` share the `MediaModel` base (`src/media-model.ts`).
@@ -468,7 +438,7 @@ Foundation + Image ship together as the reference implementation, serially. Vide
 1. **Foundation** — per-modality selectors, `Media`, `Generation`, `Poll`, `Usage` union, `MediaProtocol` kinds, `@opencode/ai/promise` with `llm` + `image`. Port the five existing image protocols onto it. Unify `MediaPart` and add the `media` LLM event (fixes Gemini image output being dropped).
 2. **Video** — ✅ Veo, xAI, fal, Runway shipped (`MediaProtocol.queued`, `Video.start/generate/resume/stream`, promise `ai.video`). Deferred: `Video.complete` (webhooks), Luma, Kling, MiniMax, Replicate.
 3. **Speech + Transcription** — ✅ Speech: OpenAI, Gemini TTS, ElevenLabs, Cartesia, Deepgram shipped (`MediaProtocol.stream`, `Speech.generate/stream`, promise `ai.speech`). ✅ Transcription: OpenAI, Gemini, Deepgram, AssemblyAI shipped across all three route kinds (`Transcription.generate/stream/start/resume`, promise `ai.transcription`). Pending: ElevenLabs Scribe. Deferred: `Speech.session` and `Transcription.session` (WebSocket streaming).
-4. **Image queued routes and partials** — ✅ BFL, fal, Replicate, and Stability creative upscale queued; Stability generate inline; OpenAI `partial_images` streaming (`image-partial` restored). Imagen dropped: shut down on the Gemini API and discontinued on Vertex (2026-06-30). Deferred: Stability's synchronous edit and fast/conservative upscale endpoints.
+4. **Image queued routes and partials** — BFL, fal, Replicate, Stability; OpenAI `partial_images` streaming.
 5. **Later** — ElevenLabs music/SFX, Lyria, `Speech.session` / `Transcription.session`, realtime.

 Core adoption (session attachments beyond png/jpeg/gif/webp/pdf, image-generation tool, TUI rendering) comes after phase 1 and is a Core concern.
@@ -1,7 +1,18 @@
-import { Config, Effect, Formatter, Schema, Stream } from "effect"
+import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
 import { NodeFileSystem } from "@effect/platform-node"
-import { AIClient, Image, LLM, LLMRequest, Media, Message, ProviderID, Tool, ToolRuntime } from "@opencode/ai"
-import { Route, Auth, Endpoint, Framing, Protocol } from "@opencode/ai/route"
+import {
+  Image,
+  ImageClient,
+  LLM,
+  LLMClient,
+  LLMRequest,
+  Media,
+  Message,
+  ProviderID,
+  Tool,
+  ToolRuntime,
+} from "@opencode/ai"
+import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode/ai/route"
 import { OpenAI } from "@opencode/ai/providers"

 /**
@@ -232,10 +243,12 @@ const generateImage = Effect.gen(function* () {
  yield* Media.write(response.image, "tutorial-image.jpg").pipe(Effect.provide(NodeFileSystem.layer))
 })

-// Provide every modality client and the HTTP request executor once with
-// `AIClient.layer` (`AIClient.layerWith(executor)` swaps the executor). Keep one
-// path enabled at a time so the tutorial can demonstrate generate, stream, or
+// Provide the LLM runtime and the HTTP request executor once. Keep one path
+// enabled at a time so the tutorial can demonstrate generate, stream, or
 // tool-loop behavior without spending tokens on every example.
+const requestExecutorLayer = RequestExecutor.fetchLayer
+const llmClientLayer = LLMClient.layer.pipe(Layer.provide(requestExecutorLayer))
+const imageClientLayer = ImageClient.layer.pipe(Layer.provide(requestExecutorLayer))

 const program = Effect.gen(function* () {
  // yield* generateOnce
@@ -244,6 +257,6 @@ const program = Effect.gen(function* () {
  // yield* generateDynamicObject.pipe(Effect.andThen((response) => Effect.sync(() => console.log(response.object))))
  // yield* generateImage
  yield* streamWithTools
-}).pipe(Effect.provide(AIClient.layer))
+}).pipe(Effect.provide(Layer.mergeAll(requestExecutorLayer, llmClientLayer, imageClientLayer)))

 Effect.runPromise(program)
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.18",
+  "version": "2.0.15",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -108,7 +108,7 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    id: "fal",
    label: "fal",
    tier: "canary",
-    note: "fal queue image and video recorded tests",
+    note: "fal queue video recorded tests",
    vars: [{ name: "FAL_KEY" }],
    // fal has no free authenticated list endpoint; a 404 for an unknown request id proves the key was accepted.
    validate: (env) =>
@@ -123,34 +123,6 @@ const PROVIDERS: ReadonlyArray<Provider> = [
        return yield* responseError(response)
      }),
  },
-  {
-    id: "black-forest-labs",
-    label: "Black Forest Labs",
-    tier: "canary",
-    note: "BFL FLUX queued image recorded tests",
-    vars: [{ name: "BFL_API_KEY" }],
-    validate: (env) =>
-      HttpClientRequest.get("https://api.bfl.ai/v1/credits").pipe(
-        HttpClientRequest.setHeader("x-key", Redacted.value(Redacted.make(env.BFL_API_KEY))),
-        executeRequest,
-      ),
-  },
-  {
-    id: "replicate",
-    label: "Replicate",
-    tier: "canary",
-    note: "Replicate prediction image recorded tests",
-    vars: [{ name: "REPLICATE_API_TOKEN" }],
-    validate: (env) => validateBearer("https://api.replicate.com/v1/account", Redacted.make(env.REPLICATE_API_TOKEN)),
-  },
-  {
-    id: "stability",
-    label: "Stability AI",
-    tier: "canary",
-    note: "Stability inline generate and queued upscale recorded tests",
-    vars: [{ name: "STABILITY_API_KEY" }],
-    validate: (env) => validateBearer("https://api.stability.ai/v1/user/balance", Redacted.make(env.STABILITY_API_KEY)),
-  },
  {
    id: "runway",
    label: "Runway",
@@ -1,24 +0,0 @@
-import { Layer } from "effect"
-import { ImageClient } from "./image-client.js"
-import { LLMClient } from "./route/client.js"
-import { RequestExecutor } from "./route/executor.js"
-import { SpeechClient } from "./speech-client.js"
-import { TranscriptionClient } from "./transcription-client.js"
-import { VideoClient } from "./video-client.js"
-
-/** Every modality client over `executor`, which stays in the output so `asset.bytes()` and `Media.write` resolve. */
-export const layerWith = <E, R>(executor: Layer.Layer<RequestExecutor.Service, E, R>) =>
-  Layer.mergeAll(
-    LLMClient.layer,
-    ImageClient.layer,
-    VideoClient.layer,
-    SpeechClient.layer,
-    TranscriptionClient.layer,
-  ).pipe(Layer.provideMerge(executor))
-
-/** Every modality client plus the executor over `RequestExecutor.fetchLayer`: the one layer most programs need. */
-export const layer = layerWith(RequestExecutor.fetchLayer)
-
-export type Services = Layer.Success<typeof layer>
-
-export * as AIClient from "./ai-client.js"
@@ -86,7 +86,7 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
    })
  }),
 )
-export const fetchLayer = layer.pipe(Layer.provideMerge(RequestExecutor.fetchLayer))
+export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer))

 export const EvaluationClient = {
  Service,
@@ -214,7 +214,7 @@ export function request(input: EvaluationRequest | EvaluationRequestInput) {
  return new EvaluationRequest({
    ...input,
    model: input.model as unknown as EvaluationModel,
-    http: HttpOptions.make(input.http),
+    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
  })
 }

@@ -11,6 +11,7 @@ export interface Snapshot {
  /** Normalized 0..1 when the provider reports progress. */
  readonly progress?: number
  readonly position?: number
+  readonly expiresAt?: number
 }

 /**
@@ -21,11 +22,15 @@ export interface Route<Response> {
  readonly status: Effect.Effect<Snapshot, AIError>
  readonly result: Effect.Effect<Response, AIError>
  readonly cancel?: Effect.Effect<void, AIError>
+  /** Provider polling hint (e.g. `openai-poll-after-ms`) that overrides the default interval for the next poll. */
+  readonly pollHint?: (snapshot: Snapshot) => Duration.Duration | undefined
 }

 export interface Poll {
  readonly interval?: Duration.Input
  readonly timeout?: Duration.Input
+  /** Full override of the polling schedule; `interval` and `pollHint` are ignored when supplied. */
+  readonly schedule?: Schedule.Schedule<unknown, Snapshot>
 }

 export interface AwaitOptions {
@@ -53,13 +58,12 @@ 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
  readonly progress?: number
  readonly position?: number
+  readonly expiresAt?: number

  constructor(
    readonly route: Route<Response>,
@@ -71,6 +75,7 @@ export class Generation<Response> {
    this.status = snapshot.status
    this.progress = snapshot.progress
    this.position = snapshot.position
+    this.expiresAt = snapshot.expiresAt
  }

  get snapshot(): Snapshot {
@@ -79,11 +84,12 @@ export class Generation<Response> {
      status: this.status,
      progress: this.progress,
      position: this.position,
+      expiresAt: this.expiresAt,
    }
  }

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

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

  /**
-   * 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.)
+   * 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.)
   */
  events(options?: AwaitOptions): Stream.Stream<Event, AIError> {
    if (this.terminal) return Stream.make(this.event())
@@ -123,26 +128,17 @@ 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) =>
-              now >= deadline
-                ? this.timeoutError(timeout)
-                : this.refresh().pipe(
-                    Effect.timeoutOrElse({
-                      duration: Duration.millis(deadline - now),
-                      orElse: () => this.timeoutError(timeout),
-                    }),
-                  ),
+              this.refresh().pipe(
+                Effect.timeoutOrElse({
+                  duration: Duration.millis(Math.max(0, deadline - now)),
+                  orElse: () => this.timeoutError(timeout),
+                }),
+              ),
            ),
          )
-          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(
+          return Stream.fromEffectSchedule(refresh, this.schedule(options?.poll)).pipe(
            Stream.takeUntil((generation) => generation.terminal),
            Stream.map((generation) => generation.event()),
          )
@@ -172,8 +168,15 @@ export class Generation<Response> {
    )
  }

-  private schedule(poll: Poll | undefined) {
-    return Schedule.spaced(poll?.interval ?? DEFAULT_POLL_INTERVAL)
+  private schedule(poll: Poll | undefined): Schedule.Schedule<unknown, Generation<Response>> {
+    if (poll?.schedule) return poll.schedule.pipe(Schedule.setInputType<Generation<Response>>())
+    const interval = poll?.interval ?? DEFAULT_POLL_INTERVAL
+    const pollHint = this.route.pollHint
+    const spaced = Schedule.spaced(interval).pipe(Schedule.setInputType<Generation<Response>>())
+    if (!pollHint) return spaced
+    return spaced.pipe(
+      Schedule.modifyDelay((metadata) => Effect.succeed(pollHint(metadata.input.snapshot) ?? interval)),
+    )
  }
 }

@@ -1,30 +1,61 @@
-import { Context } from "effect"
-import { MediaClient } from "./media-client.js"
+import { Context, Effect, Layer, Stream } from "effect"
+import { RequestExecutor } from "./route/executor.js"
+import type { AIError } from "./schema/index.js"
 import {
-  ImageOutputEvent,
-  ImageFinishEvent,
+  responseEvents,
  type ImageEvent,
+  type ImageOptions,
  type ImageRequestFor,
  type ImageResponse,
 } from "./image.js"

-export type Interface = MediaClient.Interface<ImageRequestFor, ImageEvent, ImageResponse>
+export interface Interface {
+  readonly generate: <Options extends ImageOptions>(
+    request: ImageRequestFor<Options>,
+  ) => Effect.Effect<ImageResponse, AIError>
+  readonly stream: <Options extends ImageOptions>(
+    request: ImageRequestFor<Options>,
+  ) => Stream.Stream<ImageEvent, AIError>
+}

-export class ImageClientService extends Context.Service<ImageClientService, Interface>()("@opencode/ImageClient") {}
-export const Service = ImageClientService
-export type Service = ImageClientService
+export class Service extends Context.Service<Service, Interface>()("@opencode/ImageClient") {}
+
+export const generate = <Options extends ImageOptions>(
+  request: ImageRequestFor<Options>,
+): Effect.Effect<ImageResponse, AIError, Service> =>
+  Effect.gen(function* () {
+    const client = yield* Service
+    return yield* client.generate(request)
+  })
+
+export const stream = <Options extends ImageOptions>(
+  request: ImageRequestFor<Options>,
+): Stream.Stream<ImageEvent, 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
+    const generate = <Options extends ImageOptions>(request: ImageRequestFor<Options>) =>
+      request.model.route.generate(request, executor.execute)
+    return Service.of({
+      generate,
+      // Inline routes have no partial frames yet; the stream is the completed response expanded into events.
+      stream: (request) =>
+        Stream.fromIterableEffect(Effect.map(generate(request), responseEvents)),
+    })
+  }),
+)

 export const ImageClient = {
  Service,
-  ...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,
-      }),
-    ],
-  }),
+  layer,
+  generate,
+  stream,
 } as const
@@ -1,48 +1,50 @@
 import { Effect, Schema, Stream } from "effect"
-import { Generation, ProgressEvent, QueuedEvent, type AwaitOptions } from "./generation.js"
 import { Media } from "./media.js"
 import { MediaModel, composeRoute, tryRequest } from "./media-model.js"
 import { MediaRoute } from "./route/media.js"
-import { AIError, HttpOptions, MediaUsage, ProviderMetadata, type OpenString } from "./schema/index.js"
+import type { MediaProtocol } from "./route/media-protocol.js"
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js"
 import { ImageClient, Service } from "./image-client.js"

 // ---------------------------------------------------------------------------
 // Model
 // ---------------------------------------------------------------------------

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

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

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

-  /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
-  static fromRoute<Options extends ImageOptions>(
-    route: MediaModel.InlineRouteInput<ImageRequestFor<Options>, ImageResponse>,
-    input: MediaRoute.ModelInput,
-  ): ImageModel<Options>
-  static fromRoute<Options extends ImageOptions, Frame, State>(
-    route: MediaModel.StreamRouteInput<ImageRequestFor<Options>, ImageEvent, Frame, State>,
-    input: MediaRoute.ModelInput,
-  ): ImageModel<Options>
-  static fromRoute<Options extends ImageOptions, Token>(
-    route: MediaModel.QueuedRouteInput<ImageRequestFor<Options>, ImageResponse, Token>,
-    input: MediaRoute.ModelInput,
-  ): ImageModel<Options>
-  static fromRoute<Options extends ImageOptions, Frame, State, Token>(
-    route: MediaModel.AnyRouteInput<ImageRequestFor<Options>, ImageEvent, ImageResponse, Frame, State, Token>,
+  static make<Options extends ImageOptions = ImageOptions>(input: MediaModel.Input<ImageRoute<Options>>) {
+    return new ImageModel<Options>(input)
+  }
+
+  /** Compose an inline image protocol with its canonical path into a model for one deployment. */
+  static fromRoute<Options extends ImageOptions = ImageOptions>(
+    route: ImageModel.RouteInput<Options>,
    input: MediaRoute.ModelInput,
  ) {
    return new ImageModel<Options>({
      id: input.id,
-      provider: route.protocol.provider,
+      provider: route.provider,
      http: input.http,
-      route: composeRoute(route, input, collectResponse) as ImageRoute,
+      route: composeRoute(MediaRoute.inline, route, input),
    })
  }
 }

+export namespace ImageModel {
+  export type RouteInput<Options extends ImageOptions = ImageOptions> = MediaModel.RouteInput<
+    ImageRequestFor<Options>,
+    MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>
+  >
+}
+
 export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
  expected: "Image.Model",
 })
@@ -60,7 +62,7 @@ export const ImageSize = Schema.declare<ImageSize>(
 export type ImageAspectRatio = Media.AspectRatio
 export const ImageAspectRatio = Media.AspectRatio

-export type ImageFormat = OpenString<"png" | "jpeg" | "webp">
+export type ImageFormat = "png" | "jpeg" | "webp" | (string & {})

 export class ImageRequest extends Schema.Class<ImageRequest>("Image.Request")({
  model: ImageModelSchema,
@@ -115,13 +117,6 @@ export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")
  }
 }

-/** The `index`-th lower-fidelity preview of an image still generating; the `image` event supersedes it. */
-export const ImagePartialEvent = Schema.Struct({
-  type: Schema.tag("image-partial"),
-  index: Schema.Number,
-  image: Media.AssetSchema,
-}).annotate({ identifier: "Image.Event.Partial" })
-
 export const ImageOutputEvent = Schema.Struct({
  type: Schema.tag("image"),
  index: Schema.Number,
@@ -135,37 +130,24 @@ export const ImageFinishEvent = Schema.Struct({
  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "Image.Event.Finish" })

-const imageEventTagged = Schema.Union([
-  QueuedEvent,
-  ProgressEvent,
-  ImagePartialEvent,
-  ImageOutputEvent,
-  ImageFinishEvent,
-]).pipe(Schema.toTaggedUnion("type"))
+const imageEventTagged = Schema.Union([ImageOutputEvent, ImageFinishEvent]).pipe(Schema.toTaggedUnion("type"))
 export const ImageEvent = Object.assign(imageEventTagged, {
  is: {
-    generationQueued: imageEventTagged.guards["generation-queued"],
-    generationProgress: imageEventTagged.guards["generation-progress"],
-    imagePartial: imageEventTagged.guards["image-partial"],
    image: imageEventTagged.guards.image,
    finish: imageEventTagged.guards.finish,
  },
 })
 export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>

-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.
-  if (finish === undefined) return Effect.die(new Error("The image stream completed without a finish event"))
-  return Effect.succeed(
-    new ImageResponse({
-      images: events.filter(ImageEvent.is.image).map((event) => event.image),
-      usage: finish.usage,
-      notices: finish.notices,
-      providerMetadata: finish.providerMetadata,
-    }),
-  )
-}
+/** Inline routes produce every image at once; expand the response into the streaming event shape. */
+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,
+  }),
+]

 // ---------------------------------------------------------------------------
 // Request-shaped call API
@@ -179,43 +161,30 @@ export function request(input: ImageRequest | ImageRequestInput) {
  if (input instanceof ImageRequest) return input
  return new ImageRequest({
    ...input,
-    http: HttpOptions.make(input.http),
+    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
  })
 }

 const requestEffect = (input: ImageRequest | ImageRequestInput) => tryRequest(() => request(input))

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

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

-/** Inline and streaming routes fail with `UnsupportedOperation`. */
-export function start<const Model extends ImageModel>(
-  input: ImageRequest | ImageRequestInput<Model>,
-): 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 = (model: ImageModel, token: unknown): Effect.Effect<Generation<ImageResponse>, AIError, Service> =>
-  ImageClient.resume(model, token)
-
 export const Image = {
  request,
  generate,
  stream,
-  start,
-  resume,
 } as const
@@ -1,4 +1,3 @@
-export { AIClient } from "./ai-client.js"
 export { LLMClient } from "./route/client.js"
 export { ImageClient } from "./image-client.js"
 export { Auth } from "./route/auth.js"
@@ -9,7 +8,7 @@ export type {
  RouteLanguageModelInput,
  RouteRoutedLanguageModelInput,
  Interface as LLMClientShape,
-  LLMClientService,
+  Service as LLMClientService,
 } from "./route/client.js"
 export * from "./schema/index.js"
 export {
@@ -1,6 +1,5 @@
-import { Effect, JsonSchema, Schema, Stream } from "effect"
-import { tryRequest } from "./media-model.js"
-import { LLMClient, Service, type StreamOptions } from "./route/client.js"
+import { Effect, JsonSchema, Schema } from "effect"
+import { LLMClient, Service } from "./route/client.js"
 import {
  GenerationOptions,
  HttpOptions,
@@ -36,26 +35,9 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
  readonly http?: HttpOptions.Input
 }

-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 generate = LLMClient.generate

-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 stream = LLMClient.stream

 export const request = <const SelectedLanguageModel extends LanguageModel>(
  input: RequestInput<SelectedLanguageModel>,
@@ -79,7 +61,7 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
    toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
    generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
    providerOptions: requestProviderOptions,
-    http: HttpOptions.make(requestHttp),
+    http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
  })
 }

@@ -1,77 +0,0 @@
-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"
@@ -1,18 +1,16 @@
 import { Effect } from "effect"
 import { Endpoint } from "./route/endpoint.js"
-import { MediaRoute } from "./route/media.js"
+import type { MediaRoute } from "./route/media.js"
 import type { MediaProtocol } from "./route/media-protocol.js"
 import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "./schema/index.js"

 /**
 * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
- * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
- * marker so one cannot stand in for the other in requests.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`) 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> {
-  // 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
+  declare protected readonly _Options: (options: Options) => Options
  readonly id: ModelID
  readonly provider: ProviderID
  readonly route: Route
@@ -27,8 +25,6 @@ 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
@@ -38,63 +34,31 @@ export namespace MediaModel {

  /** A protocol plus its canonical start path; `ModelInput.baseURL` overrides `baseURL` per deployment. */
  export interface RouteInput<Request extends MediaRoute.MediaRequest, Protocol> {
+    readonly id: string
+    readonly provider: string | ProviderID
    readonly protocol: Protocol
    readonly path: Endpoint.EndpointPart<MediaProtocol.Body, Request>
    readonly baseURL?: string
    /** Headers the protocol requires on every call, such as a pinned API version; deployment headers win. */
    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> =
-    | 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, 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 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>(
+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,
-): 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.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.QueuedRouteInput<Request, Response, Token> => route.protocol.kind === "queued"
+): Route =>
+  compose({
+    id: route.id,
+    provider: route.provider,
+    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 },
+  })

 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
 export const tryRequest = <A>(make: () => A): Effect.Effect<A, AIError> =>
@@ -6,7 +6,7 @@ import { ProviderID } from "./schema/ids.js"
 import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js"
 import { ProviderMetadata } from "./schema/options.js"
 import { Service } from "./route/executor-service.js"
-import { detectMediaType, fileMediaType } from "./utils/media-type.js"
+import { detectMediaType, extensionMediaType } from "./utils/media-type.js"

 export { detectMediaType } from "./utils/media-type.js"

@@ -309,7 +309,7 @@ export const file = (path: string, options?: AssetOptions): Effect.Effect<Asset,
    const data = yield* fs
      .readFile(path)
      .pipe(Effect.mapError((cause) => invalid(`Failed to read media file ${path}`, cause)))
-    return bytes(data, fileMediaType(data, path), options)
+    return bytes(data, detectMediaType(data) ?? extensionMediaType(path), options)
  })

 /** Materialize an asset and write its bytes through `FileSystem`. */
@@ -1,30 +1,32 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect"
-import { AIClient } from "./ai-client.js"
-import type { AwaitOptions, Event, Generation, Snapshot } from "./generation.js"
-import { Image, type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js"
+import type { AwaitOptions, Generation, Snapshot } from "./generation.js"
+import { Image, ImageModel, ImageRequest, type ImageRequestInput } from "./image.js"
+import { ImageClient } from "./image-client.js"
 import { LLM } from "./index.js"
-import { Media } from "./media.js"
-import { tryRequest } from "./media-model.js"
+import { LLMClient } from "./route/client.js"
 import { RequestExecutor } from "./route/executor.js"
-import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js"
+import { LanguageModel, LLMRequest } from "./schema/index.js"
 import type { RequestInput } from "./llm.js"
-import { Speech, type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js"
+import { Speech, SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js"
+import { SpeechClient } from "./speech-client.js"
 import {
  Transcription,
-  type TranscriptionModel,
-  type TranscriptionRequest,
+  TranscriptionModel,
+  TranscriptionRequest,
+  type TranscriptionOptions,
  type TranscriptionRequestInput,
 } from "./transcription.js"
-import { fileMediaType } from "./utils/media-type.js"
-import { Video, type VideoModel, type VideoRequest, type VideoRequestInput } from "./video.js"
+import { TranscriptionClient } from "./transcription-client.js"
+import { Video, VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js"
+import { VideoClient } from "./video-client.js"

 /**
 * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
 * and transcription clients over a request executor; every method runs the corresponding Effect API and rethrows
- * `AIError` unchanged. `file` and `write` load `node:fs/promises` on first use, so importing this module does not.
+ * `AIError` unchanged.
 */
 export interface Options {
-  /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or `RequestExecutor.middleware(fn)` here. */
+  /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
  readonly layer?: Layer.Layer<RequestExecutor.Service>
 }

@@ -32,51 +34,57 @@ export interface RunOptions {
  readonly signal?: AbortSignal
 }

-export type Services = AIClient.Services
+export type Services =
+  | Layer.Success<typeof LLMClient.layer>
+  | Layer.Success<typeof ImageClient.layer>
+  | Layer.Success<typeof VideoClient.layer>
+  | Layer.Success<typeof SpeechClient.layer>
+  | Layer.Success<typeof TranscriptionClient.layer>
+  | RequestExecutor.Service

-/**
- * Promise view of a `Generation`. Its fields are a snapshot taken when the handle was created; `refresh()` resolves to a
- * new handle rather than updating this one.
- */
+/** Promise view of a `Generation`: its snapshot plus `await`, `refresh`, and `cancel` returning promises. */
 export type GenerationHandle<Response> = Snapshot & {
  /** Serializable JSON; pass it back to `resume` from another process. */
  readonly token: unknown
  readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>
-  /** Status observations until the first terminal one, polling like `await`; abort throws `signal.reason`. */
-  readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>
-  /** The result without polling; fails when the generation has not completed. */
-  readonly result: (options?: RunOptions) => Promise<Response>
  readonly refresh: (options?: RunOptions) => Promise<GenerationHandle<Response>>
  readonly cancel: (options?: RunOptions) => Promise<void>
 }

-// Fails with `signal.reason` so aborted calls reject and aborted streams throw like `fetch`: an `AbortError` by default.
 const abortEffect = (signal: AbortSignal | undefined) =>
  signal === undefined
    ? Effect.never
-    : Effect.callback<never, unknown>((resume) => {
+    : Effect.callback<void>((resume) => {
        if (signal.aborted) {
-          resume(Effect.fail(signal.reason))
+          resume(Effect.void)
          return
        }
-        const onAbort = () => resume(Effect.fail(signal.reason))
+        const onAbort = () => resume(Effect.void)
        signal.addEventListener("abort", onAbort, { once: true })
        return Effect.sync(() => signal.removeEventListener("abort", onAbort))
      })

 export const make = (options: Options = {}) => {
-  const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer))
+  const runtime = ManagedRuntime.make(
+    Layer.mergeAll(
+      LLMClient.layer,
+      ImageClient.layer,
+      VideoClient.layer,
+      SpeechClient.layer,
+      TranscriptionClient.layer,
+    ).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)),
+  )

-  /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
+  /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
  const run = <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) =>
-    runtime.runPromise(Effect.raceFirst(effect, abortEffect(options?.signal)))
+    runtime.runPromise(effect, { signal: options?.signal })

  const iterate = <A, E>(stream: Stream.Stream<A, E, Services>, options?: RunOptions): AsyncIterable<A> =>
    Stream.toAsyncIterable(
      Stream.unwrap(
        runtime.contextEffect.pipe(
          Effect.map(
-            (context): Stream.Stream<A, unknown> =>
+            (context): Stream.Stream<A, E> =>
              stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context)),
          ),
        ),
@@ -87,117 +95,84 @@ export const make = (options: Options = {}) => {
    ...generation.snapshot,
    token: generation.token,
    await: (options) => run(generation.await({ poll: options?.poll }), options),
-    events: (options) => iterate(generation.events({ poll: options?.poll }), options),
-    result: (options) => run(generation.result(), options),
    refresh: (options) => run(generation.refresh(), options).then(handle),
    cancel: (options) => run(generation.cancel(), options),
  })

-  const llmRequest = (input: RequestInput | LLMRequest) =>
-    input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input))
+  // 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 ? input : 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,
-    /** Decoded asset bytes, downloading `url` sources through the executor. */
-    bytes: (asset: Media.Asset, options?: RunOptions) => run(asset.bytes(), options),
-    base64: (asset: Media.Asset, options?: RunOptions) => run(asset.base64(), options),
-    /** Pull a `url` asset into owned bytes before the provider URL expires. */
-    materialize: (asset: Media.Asset, options?: RunOptions) => run(asset.materialize(), options),
-    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
-    file: async (path: string, options?: Media.AssetOptions & RunOptions) => {
-      const { readFile } = await import("node:fs/promises")
-      return run(
-        Effect.tryPromise({
-          try: (signal) => readFile(path, { signal }),
-          catch: (cause) => fileError(`Failed to read media file ${path}`, cause),
-        }).pipe(
-          Effect.map((buffer) => {
-            const data = new Uint8Array(buffer)
-            return Media.bytes(data, fileMediaType(data, path), options)
-          }),
-        ),
-        options,
-      )
-    },
-    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
-    write: async (asset: Media.Asset, path: string, options?: RunOptions) => {
-      const { writeFile } = await import("node:fs/promises")
-      return run(
-        asset.bytes().pipe(
-          Effect.flatMap((data) =>
-            Effect.tryPromise({
-              try: (signal) => writeFile(path, data, { signal }),
-              catch: (cause) => fileError(`Failed to write media file ${path}`, cause),
-            }),
-          ),
-        ),
-        options,
-      )
-    },
    llm: {
      request: LLM.request,
      generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) =>
-        run(Effect.flatMap(llmRequest(input), LLM.generate), options),
+        run(LLM.generate(llmRequest(input)), options),
      stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) =>
-        iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
+        iterate(LLM.stream(llmRequest(input)), options),
    },
    image: {
      request: Image.request,
      generate: <const Model extends ImageModel>(
        input: ImageRequestInput<Model> | ImageRequest,
-        options?: AwaitOptions & RunOptions,
-      ) => run(Image.generate(input, { poll: options?.poll }), options),
-      stream: <const Model extends ImageModel>(
-        input: ImageRequestInput<Model> | ImageRequest,
-        options?: AwaitOptions & RunOptions,
-      ) => iterate(Image.stream(input, { poll: options?.poll }), options),
-      start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) =>
-        run(Image.start(input), options).then(handle),
-      resume: (model: ImageModel, token: unknown, options?: RunOptions) =>
-        run(Image.resume(model, token), options).then(handle),
+        options?: RunOptions,
+      ) => run(Image.generate(imageRequest(input)), options),
+      stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) =>
+        iterate(Image.stream(imageRequest(input)), options),
    },
    video: {
      request: Video.request,
      start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) =>
-        run(Video.start(input), options).then(handle),
+        run(Video.start(videoRequest(input)), options).then(handle),
      generate: <const Model extends VideoModel>(
        input: VideoRequestInput<Model> | VideoRequest,
        options?: AwaitOptions & RunOptions,
-      ) => run(Video.generate(input, { poll: options?.poll }), options),
-      resume: (model: VideoModel, token: unknown, options?: RunOptions) =>
+      ) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+      resume: <Options extends VideoOptions>(model: VideoModel<Options>, 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(input, { poll: options?.poll }), options),
+      ) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
    },
    speech: {
      request: Speech.request,
      generate: <const Model extends SpeechModel>(
        input: SpeechRequestInput<Model> | SpeechRequest,
        options?: RunOptions,
-      ) => run(Speech.generate(input), options),
+      ) => run(Speech.generate(speechRequest(input)), options),
      stream: <const Model extends SpeechModel>(
        input: SpeechRequestInput<Model> | SpeechRequest,
        options?: RunOptions,
-      ) => iterate(Speech.stream(input), options),
+      ) => iterate(Speech.stream(speechRequest(input)), options),
    },
    transcription: {
      request: Transcription.request,
      generate: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: AwaitOptions & RunOptions,
-      ) => run(Transcription.generate(input, { poll: options?.poll }), options),
+      ) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
      stream: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: AwaitOptions & RunOptions,
-      ) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
+      ) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
      start: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: RunOptions,
-      ) => run(Transcription.start(input), options).then(handle),
-      resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) =>
-        run(Transcription.resume(model, token), options).then(handle),
+      ) => 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),
    },
    dispose: () => runtime.dispose(),
  }
@@ -205,9 +180,6 @@ export const make = (options: Options = {}) => {

 export type Client = ReturnType<typeof make>

-const fileError = (message: string, cause: unknown) =>
-  new AIError({ reason: new InvalidRequestError({ message, cause }) })
-
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export const ai = make()

@@ -70,11 +70,7 @@ export const protocol = Protocol.make({
      return {
        ...(yield* OpenAIChat.protocol.body.from(req)),
        enable_thinking: opts.enableThinking,
-        // 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),
+        thinking_budget: opts.thinkingBudget,
        preserve_thinking: opts.preserveThinking,
        clear_thinking: opts.clearThinking,
        thinking: opts.thinking,
@@ -26,21 +26,18 @@ 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 {
-        ...body,
+        ...(yield* AnthropicMessages.protocol.body.from(
+          LLMRequest.update(req, {
+            providerOptions: { ...req.providerOptions, thinking: undefined },
+          }),
+        )),
        thinking:
          opts.thinking === undefined
            ? undefined
            : {
                type: opts.thinking.type,
-                budget_tokens:
-                  budget === undefined ? undefined : ProviderShared.fitThinkingBudget(budget, body.max_tokens),
+                budget_tokens: opts.thinking.budgetTokens ?? opts.thinking.budget_tokens,
              },
      }
    }),
@@ -18,6 +18,7 @@ import {
  type CacheHint,
  type FinishReasonDetails,
  type FinishReason,
+  type JsonSchema,
  type MediaPart,
  type ProviderMetadata,
  type ProviderOptions,
@@ -30,13 +31,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([
@@ -523,10 +524,10 @@ const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined, key: s
  return typeof provider.redactedData === "string" ? provider.redactedData : undefined
 }

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

@@ -1026,15 +1027,6 @@ 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
@@ -1042,12 +1034,22 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
  const format = outputConfig?.format ?? undefined
  const updates = resolveEffortUpdates(request, options.effort ?? outputConfig?.effort ?? undefined)
  const generation = request.generation
+  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  // Allocate the 4-breakpoint budget in invalidation order: tools → system →
  // messages. Tools live highest in the cache hierarchy, so when callers
  // over-mark we keep their tool hints and shed the message-tail ones first.
  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))
+  const tools =
+    flattened.tools.length === 0
+      ? undefined
+      : flattened.tools.map((tool) =>
+          lowerTool(
+            breakpoints,
+            tool,
+            ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
+          ),
+        )
  // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
  const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice)
  const systemParts = request.system.filter((part) => part.text.length > 0)
@@ -1067,7 +1069,6 @@ 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,
@@ -1075,12 +1076,12 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
    tools,
    tool_choice: toolChoice,
    stream: true as const,
-    max_tokens: maxTokens,
+    max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
    temperature: generation?.temperature,
    top_p: generation?.topP,
    top_k: generation?.topK,
    stop_sequences: generation?.stop,
-    thinking: applyThinkingBindingDefault(request.model, fitThinking(options.thinking, maxTokens)),
+    thinking: applyThinkingBindingDefault(request.model, options.thinking),
    output_config,
    // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
    cache_control: options.cache_control ?? options.cacheControl,
@@ -4,12 +4,14 @@ import type { Status } from "../generation.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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "assemblyai-transcription", name: "AssemblyAI", provider: "assemblyai" })
+const ADAPTER = "assemblyai-transcription"
+const NAME = "AssemblyAI"
+const PROVIDER = ProviderID.make("assemblyai")
 export const DEFAULT_BASE_URL = "https://api.assemblyai.com"
 export const PATH = "/v2/transcript"
 export const UPLOAD_PATH = "/v2/upload"
@@ -31,7 +33,7 @@ export type AssemblyAITranscriptionOptions = {
    readonly fallback_language?: string
    readonly code_switching?: boolean
  }
-  readonly speech_models?: ReadonlyArray<OpenString<"universal-3-5-pro" | "universal-2">>
+  readonly speech_models?: ReadonlyArray<"universal-3-5-pro" | "universal-2" | (string & {})>
 } & Record<string, unknown>

 export type Request = TranscriptionRequestFor<AssemblyAITranscriptionOptions>
@@ -88,12 +90,12 @@ const STATUS = {
 // 5. Request body construction
 // ---------------------------------------------------------------------------

-const decodeUpload = route.decodeJson(Upload)
+const decodeUpload = MediaProtocol.decodeJson(ADAPTER, NAME, Upload)

 /** `/v2/transcript` only takes a URL, so inline audio is uploaded to `/v2/upload` first. */
 const prepare = Effect.fn("AssemblyAITranscription.prepare")(function* (request: Request, send: MediaProtocol.Send) {
  if (request.audio.source.type !== "bytes" && request.audio.source.type !== "base64") return request
-  const audio = yield* MediaInput.inlineBytes(route.id, request.audio)
+  const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio)
  const uploaded = yield* send(UPLOAD_PATH, MediaProtocol.binary(audio, "application/octet-stream")).pipe(
    Effect.flatMap(decodeUpload),
  )
@@ -101,7 +103,7 @@ const prepare = Effect.fn("AssemblyAITranscription.prepare")(function* (request:
 })

 const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (request: Request) {
-  const audio = yield* ProviderShared.mediaReference(request.audio, route.provider, route.name)
+  const audio = yield* ProviderShared.mediaReference(request.audio, PROVIDER, NAME)
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -110,11 +112,8 @@ 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, and `speakers_expected` require speaker labels.
-        speaker_labels:
-          request.diarize === true || request.timestamps === "segment" || request.speakers !== undefined
-            ? true
-            : undefined,
+        // Turn-level `utterances`, the only segments AssemblyAI returns, require speaker labels.
+        speaker_labels: request.diarize === true || request.timestamps === "segment" ? true : undefined,
        speakers_expected: request.speakers,
      },
      request.providerOptions,
@@ -127,7 +126,7 @@ const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeTranscript = route.decodeJson(Transcript)
+const decodeTranscript = MediaProtocol.decodeJson(ADAPTER, NAME, Transcript)

 const decodeStart = Effect.fn("AssemblyAITranscription.decodeStart")(function* (
  response: HttpClientResponse.HttpClientResponse,
@@ -157,8 +156,9 @@ const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function*
  const status = yield* MediaProtocol.status(STATUS, transcript.status, output)
  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.pending(context.token.transcriptID)
+    return yield* output.ended("failed", `${NAME} transcription failed${error === undefined ? "" : `: ${error}`}`)
+  if (status !== "completed")
+    return yield* output.invalid(`${NAME} transcript ${context.token.transcriptID} has not finished`)
  const duration = transcript.audio_duration ?? undefined
  return new TranscriptionResponse({
    text: transcript.text ?? "",
@@ -190,7 +190,9 @@ const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function*

 const transcriptPath = (token: Token) => `${PATH}/${token.transcriptID}`

-export const protocol = MediaProtocol.queued<Request, TranscriptionResponse, Token>(route, {
+export const protocol = MediaProtocol.queued<Request, TranscriptionResponse, Token>({
+  id: ADAPTER,
+  name: NAME,
  token: Token,
  start: { prepare, body: { from: fromRequest }, decode: decodeStart },
  status: { path: transcriptPath, decode: decodeStatus },
@@ -199,7 +201,7 @@ export const protocol = MediaProtocol.queued<Request, TranscriptionResponse, Tok

 export const model = (input: MediaRoute.ModelInput) =>
  TranscriptionModel.fromRoute<AssemblyAITranscriptionOptions, Token>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
    input,
  )

@@ -9,8 +9,9 @@ import {
  type CacheHint,
  type FinishReason,
  type FinishReasonDetails,
+  type JsonSchema,
  type LLMRequest,
-  type LanguageModel,
+  type LanguageModelToolSchemaCompatibility,
  type ProviderMetadata,
  type ReasoningPart,
  type ToolCallPart,
@@ -25,6 +26,7 @@ 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"

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

-const lowerTools = (breakpoints: BedrockCache.Breakpoints, tools: ReadonlyArray<ToolDefinition>): BedrockTool[] => {
+const lowerTools = (
+  compatibility: LanguageModelToolSchemaCompatibility | undefined,
+  breakpoints: BedrockCache.Breakpoints,
+  tools: ReadonlyArray<ToolDefinition>,
+): BedrockTool[] => {
  const result: BedrockTool[] = []
  for (const tool of tools) {
-    result.push(lowerToolSpec(tool))
+    result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility)))
    const cachePoint = BedrockCache.block(breakpoints, tool.cache)
    if (cachePoint) result.push(cachePoint)
  }
@@ -424,50 +430,17 @@ const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArra
  return content.length === 0 ? undefined : content
 }

-// Nova 2 rejects `maxTokens` at high reasoning effort, where its output can exceed the field's maximum. Other models
-// that take `reasoningConfig`, such as Grok on Bedrock, accept it.
-const isNova2 = (model: LanguageModel) => /\bamazon\.nova-2-/.test(model.id)
-const isHighReasoningEffort = Schema.is(
-  Schema.Struct({
-    additionalModelRequestFields: Schema.Struct({
-      reasoningConfig: Schema.Struct({ maxReasoningEffort: Schema.Literal("high") }),
-    }),
-  }),
-)
-
-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(breakpoints, flattened.tools),
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
      // Converse has no native "none". Keep definitions stable for prompt
      // caching and omit only the unsupported choice.
      toolChoice,
@@ -482,14 +455,14 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
  }
  const inferenceConfig = (() => {
    if (
-      maxTokens === undefined &&
+      generation?.maxTokens === undefined &&
      generation?.temperature === undefined &&
      generation?.topP === undefined &&
      (generation?.stop === undefined || generation.stop.length === 0)
    )
      return undefined
    return {
-      maxTokens,
+      maxTokens: generation?.maxTokens,
      temperature: generation?.temperature,
      topP: generation?.topP,
      stopSequences: generation?.stop,
@@ -501,15 +474,9 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
    system,
    inferenceConfig,
    toolConfig,
-    // 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 }),
-          },
+    // 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 },
  }
 })

@@ -1,220 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { HttpClientResponse } from "effect/unstable/http"
-import type { Status } from "../generation.js"
-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 } from "../schema/index.js"
-import { ProviderShared, optionalNull } from "./shared.js"
-import { MediaInput } from "./utils/media-input.js"
-
-const route = MediaProtocol.identity({ id: "bfl-images", name: "Black Forest Labs", provider: "black-forest-labs" })
-export const DEFAULT_BASE_URL = "https://api.bfl.ai"
-
-// ---------------------------------------------------------------------------
-// 1. Public model input
-// ---------------------------------------------------------------------------
-
-export type BlackForestLabsImageOptions = {
-  readonly safety_tolerance?: number
-  readonly prompt_upsampling?: boolean
-  readonly disable_pup?: boolean
-  readonly raw?: boolean
-  readonly guidance?: number
-  readonly steps?: number
-} & Record<string, unknown>
-
-export type Request = ImageRequestFor<BlackForestLabsImageOptions>
-
-// ---------------------------------------------------------------------------
-// 2. Token and response schemas
-// ---------------------------------------------------------------------------
-
-/**
- * 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({
-  id: Schema.String,
-  status: Schema.String,
-  result: optionalNull(
-    Schema.StructWithRest(
-      Schema.Struct({ sample: Schema.String, seed: optionalNull(Schema.Number), prompt: optionalNull(Schema.String) }),
-      [Schema.Record(Schema.String, Schema.Unknown)],
-    ),
-  ),
-  cost: optionalNull(Schema.Number),
-})
-
-const STATUS = {
-  Pending: "running",
-  Reasoning: "running",
-  Generating: "running",
-  Ready: "completed",
-  Error: "failed",
-  // Moderation is terminal; `decodeResult` reports it as a content-policy failure.
-  "Content Moderated": "failed",
-  "Request Moderated": "failed",
-  "Task not found": "expired",
-} as const satisfies Record<string, Status>
-
-const isModerated = (status: string) => status === "Content Moderated" || status === "Request Moderated"
-
-// ---------------------------------------------------------------------------
-// 5. Request body construction
-// ---------------------------------------------------------------------------
-
-interface Capabilities {
-  readonly sizing: "dimensions" | "aspectRatio" | "none"
-  /** `input_image` numbers extra references `input_image_2`…; the other fields take one image. */
-  readonly imageField: "input_image" | "image_prompt" | "image"
-  readonly maxImages: number
-  readonly mask: boolean
-}
-
-const capabilities = (model: string): Capabilities => {
-  if (model.startsWith("flux-pro-1.0-fill")) return { sizing: "none", imageField: "image", maxImages: 1, mask: true }
-  if (model.startsWith("flux-pro-1.0-expand")) return { sizing: "none", imageField: "image", maxImages: 1, mask: false }
-  if (model.startsWith("flux-kontext"))
-    return { sizing: "aspectRatio", imageField: "input_image", maxImages: 4, mask: false }
-  if (model.startsWith("flux-pro-1.1-ultra"))
-    return { sizing: "aspectRatio", imageField: "image_prompt", maxImages: 1, mask: false }
-  if (model.startsWith("flux-pro-1.1") || model.startsWith("flux-dev"))
-    return { sizing: "dimensions", imageField: "image_prompt", maxImages: 1, mask: false }
-  if (model.startsWith("flux-2-klein"))
-    return { sizing: "dimensions", imageField: "input_image", maxImages: 4, mask: false }
-  return { sizing: "dimensions", imageField: "input_image", maxImages: 8, mask: false }
-}
-
-const validate = (request: Request, model: Capabilities) => {
-  const id = request.model.id
-  const images = request.images?.length ?? 0
-  if (request.n !== undefined && request.n > 1)
-    return Effect.fail(route.unsupported("media.n", `${id} generates one image per request; call it once per image`))
-  if (request.size !== undefined && model.sizing !== "dimensions")
-    return Effect.fail(route.unsupported("media.size", `${id} does not take size (width and height)`))
-  if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
-    return Effect.fail(route.unsupported("media.aspectRatio", `${id} does not take aspectRatio`))
-  if (images > model.maxImages)
-    return Effect.fail(route.unsupported("media.images", `${id} takes at most ${model.maxImages} images`))
-  if (request.mask !== undefined && !model.mask)
-    return Effect.fail(route.unsupported("media.mask", `${id} does not inpaint; use flux-pro-1.0-fill`))
-  return Effect.void
-}
-
-const imageInput = (asset: Media.Asset) => {
-  const value = asset.inline()?.base64 ?? ProviderShared.mediaUrl(asset)
-  if (value === undefined)
-    return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts inline images or https URLs`))
-  return Effect.succeed(value)
-}
-
-const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request: Request) {
-  const model = capabilities(request.model.id)
-  yield* validate(request, model)
-  const images = yield* Effect.forEach(request.images ?? [], imageInput)
-  const fields = images.map((image, index) => [
-    index === 0 ? model.imageField : `${model.imageField}_${index + 1}`,
-    image,
-  ])
-  return MediaProtocol.json(
-    mergeJsonRecords(
-      {
-        prompt: request.prompt,
-        ...(request.size === undefined ? {} : MediaInput.dimensions(request.size)),
-        aspect_ratio: request.aspectRatio,
-        seed: request.seed,
-        output_format: request.format,
-        mask: request.mask === undefined ? undefined : yield* imageInput(request.mask),
-        ...Object.fromEntries(fields),
-      },
-      request.providerOptions,
-      request.http?.body,
-    ) ?? {},
-  )
-})
-
-// ---------------------------------------------------------------------------
-// 6. Response decoding
-// ---------------------------------------------------------------------------
-
-const decodeStart = route.decodeStarted(StartResponse, (value) => ({
-  token: {
-    id: value.id,
-    pollingURL: value.polling_url,
-    ...(value.cost === undefined || value.cost === null ? {} : { cost: value.cost }),
-  },
-  snapshot: { id: value.id, status: "queued" },
-}))
-
-const decodeDocument = route.decodeJson(Result)
-
-const decodeStatus = Effect.fn("BlackForestLabsImages.decodeStatus")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<Token>,
-) {
-  const output = yield* decodeDocument(response)
-  return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) }
-})
-
-const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<Token>,
-) {
-  const output = yield* decodeDocument(response)
-  const document = output.value
-  const status = yield* MediaProtocol.status(STATUS, document.status, output)
-  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") 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: cost === undefined ? undefined : { type: "credits", credits: cost },
-    providerMetadata: {
-      bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
-    },
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 7. Protocol and route
-// ---------------------------------------------------------------------------
-
-export const protocol = MediaProtocol.queued<Request, ImageResponse, Token>(route, {
-  token: Token,
-  start: { body: { from: fromRequest }, decode: decodeStart },
-  status: { path: (token) => token.pollingURL, decode: decodeStatus },
-  result: { path: (token) => token.pollingURL, decode: decodeResult },
-})
-
-export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<BlackForestLabsImageOptions, Token>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => `/v1/${request.model.id}` },
-    input,
-  )
-
-export const BlackForestLabsImages = {
-  protocol,
-  model,
-} as const
@@ -3,12 +3,14 @@ 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 { AIError, mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { AIError, ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { SpeechModel, type SpeechEvent, type SpeechRequestFor } from "../speech.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { SpeechStream } from "./utils/speech-stream.js"

-const route = MediaProtocol.identity({ id: "cartesia-speech", name: "Cartesia", provider: "cartesia" })
+const ADAPTER = "cartesia-speech"
+const NAME = "Cartesia"
+const PROVIDER = ProviderID.make("cartesia")
 export const DEFAULT_BASE_URL = "https://api.cartesia.ai"
 export const API_VERSION = "2026-08-14"
 export const BYTES_PATH = "/tts/bytes"
@@ -20,6 +22,8 @@ const DEFAULT_BIT_RATE = 128000
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type CartesiaSpeechString<Known extends string> = Known | (string & {})
+
 export type CartesiaEncoding = SpeechStream.PcmEncoding

 export type CartesiaSpeechOptions = {
@@ -28,7 +32,7 @@ export type CartesiaSpeechOptions = {
  readonly encoding?: CartesiaEncoding
  readonly generation_config?: {
    readonly volume?: number
-    readonly emotion?: OpenString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">
+    readonly emotion?: CartesiaSpeechString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">
  }
  readonly pronunciation_dict_id?: string
 } & Record<string, unknown>
@@ -56,7 +60,7 @@ const SseEvent = Schema.Struct({
  error_code: optionalNull(Schema.String),
 })

-const decodeEvent = route.decodeFrame(SseEvent)
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SseEvent)

 // ---------------------------------------------------------------------------
 // 4. Parser state
@@ -80,14 +84,16 @@ const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request
  const format = request.format ?? (sse ? "pcm" : "mp3")
  const container = CONTAINERS[format]
  if (container === undefined)
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} supports the pcm, wav, and mp3 formats, not "${format}"`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} supports the pcm, wav, and mp3 formats, not "${format}"`,
    )
  if (sse && container !== "raw")
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} streams and timestamps only raw PCM; request format "pcm" instead of "${format}"`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} streams and timestamps only raw PCM; request format "pcm" instead of "${format}"`,
    )
  const sampleRate = request.providerOptions?.sampleRate ?? DEFAULT_SAMPLE_RATE
  if (container === "mp3")
@@ -98,7 +104,7 @@ const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request
 const fromRequest = Effect.fn("CartesiaSpeech.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
  const voice = SpeechStream.voiceID(request.voice)
  if (voice === undefined)
-    return yield* ProviderShared.invalidRequest(`${route.name} requires a voice id; pass it as \`voice\``)
+    return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``)
  const { sampleRate: _sampleRate, bitRate: _bitRate, encoding: _encoding, ...native } = request.providerOptions ?? {}
  return MediaProtocol.json(
    mergeJsonRecords(
@@ -132,7 +138,7 @@ const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state: State, fra
  if (event.type === "error")
    return yield* new AIError({
      reason: classifyProviderFailure({
-        message: `${route.name} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
+        message: `${NAME} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
        status: event.status_code,
        rawBody: frame,
      }),
@@ -144,10 +150,10 @@ const finish = Effect.fn("CartesiaSpeech.finish")(function* (
  state: State,
  context: MediaProtocol.ResponseContext<Request>,
 ) {
-  if (usesSse(context.request) && !state.done) return yield* route.incomplete()
+  if (usesSse(context.request) && !state.done) return yield* MediaProtocol.incomplete(ADAPTER)
  const format = yield* outputFormat(context.request)
  return yield* SpeechStream.finish(
-    route,
+    ADAPTER,
    state,
    format.container === "raw"
      ? SpeechStream.pcm(format.encoding, format.sample_rate)
@@ -159,7 +165,9 @@ const finish = Effect.fn("CartesiaSpeech.finish")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>(route, {
+export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["instructions"],
  body: { from: fromRequest },
  frames: (bytes, context) => (usesSse(context.request) ? Framing.sse.frame(bytes) : bytes),
@@ -171,6 +179,8 @@ export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint
 export const model = (input: MediaRoute.ModelInput) =>
  SpeechModel.fromRoute<CartesiaSpeechOptions, string | Uint8Array, State>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      headers: { "Cartesia-Version": API_VERSION },
@@ -1,12 +1,14 @@
 import { Effect } from "effect"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { SpeechModel, type SpeechEvent, type SpeechRequestFor } from "../speech.js"
 import { MediaInput } from "./utils/media-input.js"
 import { SpeechStream } from "./utils/speech-stream.js"

-const route = MediaProtocol.identity({ id: "deepgram-speech", name: "Deepgram", provider: "deepgram" })
+const ADAPTER = "deepgram-speech"
+const NAME = "Deepgram"
+const PROVIDER = ProviderID.make("deepgram")
 export const DEFAULT_BASE_URL = "https://api.deepgram.com"
 export const PATH = "/v1/speak"

@@ -14,11 +16,13 @@ export const PATH = "/v1/speak"
 // 1. Public model input
 // ---------------------------------------------------------------------------

-export type DeepgramEncoding = OpenString<"linear16" | "mulaw" | "alaw" | "mp3" | "opus" | "flac" | "aac">
+export type DeepgramSpeechString<Known extends string> = Known | (string & {})
+
+export type DeepgramEncoding = DeepgramSpeechString<"linear16" | "mulaw" | "alaw" | "mp3" | "opus" | "flac" | "aac">

 export type DeepgramSpeechOptions = {
  readonly encoding?: DeepgramEncoding
-  readonly container?: OpenString<"wav" | "ogg" | "none">
+  readonly container?: DeepgramSpeechString<"wav" | "ogg" | "none">
  readonly sampleRate?: number
  readonly bitRate?: number
  readonly mip_opt_out?: boolean
@@ -56,7 +60,7 @@ const audioFormat = (request: Request) => {

 const queryParameters = (request: Request) => {
  const { encoding: _encoding, container: _container, sampleRate, bitRate, ...native } = request.providerOptions ?? {}
-  return MediaInput.query(route.id, {
+  return MediaInput.query(ADAPTER, {
    ...native,
    model: request.model.id,
    ...audioFormat(request),
@@ -67,17 +71,15 @@ 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 &&
    request.providerOptions?.encoding === undefined
  )
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} has no encoding for format "${request.format}"; pass providerOptions.encoding`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} has no encoding for format "${request.format}"; pass providerOptions.encoding`,
    )
  return MediaProtocol.json(
    mergeJsonRecords({ text: request.text }, request.http?.body) ?? {},
@@ -89,32 +91,24 @@ const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request:
 // 6. Stream parsing
 // ---------------------------------------------------------------------------

-/** Deepgram wraps raw encodings in WAV unless `container` is `none`, and defaults their sample rate per encoding. */
-const HEADERLESS_ENCODINGS: Readonly<
-  Record<string, { readonly encoding: SpeechStream.PcmEncoding; readonly sampleRate: number }>
-> = {
-  linear16: { encoding: "pcm_s16le", sampleRate: 24000 },
-  mulaw: { encoding: "pcm_mulaw", sampleRate: 8000 },
-  alaw: { encoding: "pcm_alaw", sampleRate: 8000 },
+const HEADERLESS_ENCODINGS: Readonly<Record<string, SpeechStream.PcmEncoding>> = {
+  linear16: "pcm_s16le",
+  mulaw: "pcm_mulaw",
+  alaw: "pcm_alaw",
 }

 const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) => {
  const headers = context.http.headers
  const mediaType = headers["content-type"]
  const format = audioFormat(context.request)
-  const headerless = HEADERLESS_ENCODINGS[format.encoding ?? ""]
-  const container = format.container ?? (headerless === undefined ? undefined : "wav")
+  const encoding = HEADERLESS_ENCODINGS[format.encoding ?? ""]
  const requestID = headers["dg-request-id"]
  const modelName = headers["dg-model-name"]
-  return SpeechStream.finish(route, state, {
-    ...(container === "none" && headerless !== undefined
-      ? SpeechStream.pcm(
-          headerless.encoding,
-          SpeechStream.sampleRate(mediaType) ?? context.request.providerOptions?.sampleRate ?? headerless.sampleRate,
-          mediaType,
-        )
+  return SpeechStream.finish(ADAPTER, state, {
+    ...(format.container === "none" && encoding !== undefined
+      ? SpeechStream.pcm(encoding, SpeechStream.sampleRate(mediaType), mediaType)
      : // Deepgram's default encoding is MP3; WAV is a container around any encoding.
-        { mediaType, info: { format: container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
+        { mediaType, info: { format: format.container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
    usage: SpeechStream.headerUsage("characters", headers["dg-char-count"]),
    providerMetadata:
      requestID === undefined && modelName === undefined
@@ -127,8 +121,10 @@ const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) =
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, SpeechEvent, Uint8Array, State>(route, {
-  unsupported: ["voice", "language", "instructions"],
+export const protocol = MediaProtocol.stream<Request, SpeechEvent, Uint8Array, State>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["voice", "language", "instructions", "timestamps"],
  body: { from: fromRequest },
  frames: (bytes) => bytes,
  initial: () => ({ chunks: [] }),
@@ -138,7 +134,7 @@ export const protocol = MediaProtocol.stream<Request, SpeechEvent, Uint8Array, S

 export const model = (input: MediaRoute.ModelInput) =>
  SpeechModel.fromRoute<DeepgramSpeechOptions, Uint8Array, State>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
    input,
  )

@@ -2,12 +2,14 @@ import { Effect, Schema } from "effect"
 import type { HttpClientResponse } from "effect/unstable/http"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js"
 import { ProviderShared } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "deepgram-transcription", name: "Deepgram", provider: "deepgram" })
+const ADAPTER = "deepgram-transcription"
+const NAME = "Deepgram"
+const PROVIDER = ProviderID.make("deepgram")
 export const DEFAULT_BASE_URL = "https://api.deepgram.com"
 export const PATH = "/v1/listen"

@@ -22,7 +24,7 @@ export type DeepgramTranscriptionOptions = {
  readonly utterances?: boolean
  readonly detect_language?: boolean | ReadonlyArray<string>
  readonly keyterm?: ReadonlyArray<string>
-  readonly diarize_model?: OpenString<"latest" | "v1" | "v2">
+  readonly diarize_model?: "latest" | "v1" | "v2" | (string & {})
  readonly filler_words?: boolean
  readonly numerals?: boolean
  readonly mip_opt_out?: boolean
@@ -77,7 +79,7 @@ const ListenResponse = Schema.Struct({

 const query = (request: Request) =>
  MediaInput.query(
-    route.id,
+    ADAPTER,
    mergeJsonRecords(
      {
        model: request.model.id,
@@ -98,10 +100,8 @@ const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (re
  if (url !== undefined)
    return MediaProtocol.json(mergeJsonRecords({ url }, request.http?.body) ?? {}, yield* query(request))
  if (request.http?.body !== undefined)
-    return yield* ProviderShared.invalidRequest(
-      `${route.name} sends inline audio as the raw body, so http.body cannot apply`,
-    )
-  const audio = yield* MediaInput.inlineBytes(route.id, request.audio)
+    return yield* ProviderShared.invalidRequest(`${NAME} sends inline audio as the raw body, so http.body cannot apply`)
+  const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio)
  return MediaProtocol.binary(audio, request.audio.mediaType, yield* query(request))
 })

@@ -109,7 +109,7 @@ const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (re
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeListen = route.decodeJson(ListenResponse)
+const decodeListen = MediaProtocol.decodeJson(ADAPTER, NAME, ListenResponse)

 const speaker = (value: number | undefined) => (value === undefined ? undefined : String(value))

@@ -131,7 +131,7 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
  const output = yield* decodeListen(response)
  const channel = output.value.results.channels[0]
  const alternative = channel?.alternatives?.[0]
-  if (alternative === undefined) return yield* output.invalid(`${route.name} returned no transcript`)
+  if (alternative === undefined) return yield* output.invalid(`${NAME} returned no transcript`)
  const duration = output.value.metadata?.duration
  const requestID = output.value.metadata?.request_id
  return new TranscriptionResponse({
@@ -171,14 +171,19 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.inline<Request, TranscriptionResponse>(route, {
+export const protocol = MediaProtocol.inline<Request, TranscriptionResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["prompt", "speakers"],
  body: { from: fromRequest },
  response: { decode: decodeResponse },
 })

 export const model = (input: MediaRoute.ModelInput) =>
-  TranscriptionModel.fromRoute<DeepgramTranscriptionOptions>({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input)
+  TranscriptionModel.fromRoute<DeepgramTranscriptionOptions>(
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    input,
+  )

 export const DeepgramTranscription = {
  protocol,
@@ -2,12 +2,14 @@ import { Effect, Schema } from "effect"
 import { Framing } from "../route/framing.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { SpeechModel, type SpeechEvent, type SpeechRequestFor } from "../speech.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { SpeechStream } from "./utils/speech-stream.js"

-const route = MediaProtocol.identity({ id: "elevenlabs-speech", name: "ElevenLabs", provider: "elevenlabs" })
+const ADAPTER = "elevenlabs-speech"
+const NAME = "ElevenLabs"
+const PROVIDER = ProviderID.make("elevenlabs")
 export const DEFAULT_BASE_URL = "https://api.elevenlabs.io"
 export const PATH = "/v1/text-to-speech"

@@ -15,7 +17,9 @@ export const PATH = "/v1/text-to-speech"
 // 1. Public model input
 // ---------------------------------------------------------------------------

-export type ElevenLabsOutputFormat = OpenString<
+export type ElevenLabsSpeechString<Known extends string> = Known | (string & {})
+
+export type ElevenLabsOutputFormat = ElevenLabsSpeechString<
  | "mp3_22050_32"
  | "mp3_24000_48"
  | "mp3_44100_32"
@@ -55,7 +59,7 @@ export type ElevenLabsSpeechOptions = {
    readonly use_speaker_boost?: boolean
  }
  readonly seed?: number
-  readonly apply_text_normalization?: OpenString<"auto" | "on" | "off">
+  readonly apply_text_normalization?: ElevenLabsSpeechString<"auto" | "on" | "off">
 } & Record<string, unknown>

 export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>
@@ -75,7 +79,7 @@ const TimestampedAudio = Schema.Struct({
  alignment: optionalNull(Alignment),
 })

-const decodeRecord = route.decodeFrame(TimestampedAudio)
+const decodeRecord = MediaProtocol.decodeFrame(ADAPTER, NAME, TimestampedAudio)

 // ---------------------------------------------------------------------------
 // 4. Parser state
@@ -98,21 +102,23 @@ const OUTPUT_FORMATS: Readonly<Record<string, string>> = {
 const outputFormat = Effect.fn("ElevenLabsSpeech.outputFormat")(function* (request: MediaProtocol.Addressed<Request>) {
  const format = request.providerOptions?.outputFormat ?? OUTPUT_FORMATS[request.format ?? "mp3"]
  if (format === undefined)
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} has no default output format for "${request.format}"; pass providerOptions.outputFormat`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} has no default output format for "${request.format}"; pass providerOptions.outputFormat`,
    )
  if (request.mode === "stream" && format.startsWith("wav_"))
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`,
    )
  return format
 })

 const fromRequest = Effect.fn("ElevenLabsSpeech.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
  if (request.voice === undefined)
-    return yield* ProviderShared.invalidRequest(`${route.name} requires a voice id; pass it as \`voice\``)
+    return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``)
  const { outputFormat: _outputFormat, ...native } = request.providerOptions ?? {}
  return MediaProtocol.json(
    mergeJsonRecords(
@@ -174,7 +180,7 @@ const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (
  context: MediaProtocol.ResponseContext<Request>,
 ) {
  const requestID = context.http.headers["request-id"]
-  return yield* SpeechStream.finish(route, state, {
+  return yield* SpeechStream.finish(ADAPTER, state, {
    ...describeOutput(yield* outputFormat(context.request)),
    // `character-cost` is billed credits, not a character count (3 for 20 characters on `eleven_flash_v2_5`).
    usage: SpeechStream.headerUsage("credits", context.http.headers["character-cost"]),
@@ -186,7 +192,9 @@ const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>(route, {
+export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["instructions"],
  body: { from: fromRequest },
  frames: (bytes, context) => {
@@ -200,7 +208,7 @@ export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint

 export const model = (input: MediaRoute.ModelInput) =>
  SpeechModel.fromRoute<ElevenLabsSpeechOptions, string | Uint8Array, State>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) },
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) },
    input,
  )

@@ -1,156 +0,0 @@
-import { 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"
-import { ProviderShared, optionalNull } from "./shared.js"
-import { FalQueue } from "./utils/fal-queue.js"
-import { MediaInput } from "./utils/media-input.js"
-
-const route = MediaProtocol.identity({ id: "fal-images", name: "fal Images", provider: "fal" })
-
-// ---------------------------------------------------------------------------
-// 1. Public model input
-// ---------------------------------------------------------------------------
-
-export type FalImageOptions = {
-  readonly image_size?: OpenString<
-    "square_hd" | "square" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9"
-  >
-  readonly enable_safety_checker?: boolean
-} & Record<string, unknown>
-
-export type Request = ImageRequestFor<FalImageOptions>
-
-// ---------------------------------------------------------------------------
-// 2. Response schema
-// ---------------------------------------------------------------------------
-
-const QueueResult = Schema.StructWithRest(
-  Schema.Struct({
-    images: Schema.Array(
-      Schema.Struct({
-        url: Schema.String,
-        width: optionalNull(Schema.Number),
-        height: optionalNull(Schema.Number),
-        content_type: optionalNull(Schema.String),
-      }),
-    ),
-    seed: optionalNull(Schema.Number),
-    has_nsfw_concepts: optionalNull(Schema.Array(Schema.Boolean)),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-
-// ---------------------------------------------------------------------------
-// 5. Request body construction
-// ---------------------------------------------------------------------------
-
-const sizing = (model: string) => {
-  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
-}
-
-const validate = (request: Request) => {
-  const id = request.model.id
-  const field = sizing(id)
-  if (request.size !== undefined && request.aspectRatio !== undefined)
-    return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts either size or aspectRatio, not both`))
-  if (request.size !== undefined && field === "aspect_ratio")
-    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 && !takesImageList(id))
-    return Effect.fail(
-      route.unsupported(
-        "media.images",
-        `${id} takes one image_url; use an /edit or /multi endpoint for several images`,
-      ),
-    )
-  return Effect.void
-}
-
-// `/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 list = takesImageList(request.model.id)
-  return MediaProtocol.json(
-    mergeJsonRecords(
-      {
-        prompt: request.prompt,
-        num_images: request.n,
-        seed: request.seed,
-        image_size: request.size === undefined ? undefined : MediaInput.dimensions(request.size),
-        aspect_ratio: request.aspectRatio,
-        output_format: request.format,
-        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,
-      request.http?.body,
-    ) ?? {},
-  )
-})
-
-// ---------------------------------------------------------------------------
-// 6. Response decoding
-// ---------------------------------------------------------------------------
-
-const decodeQueueResult = route.decodeJson(QueueResult)
-
-const decodeResult = Effect.fn("FalImages.decodeResult")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<FalQueue.Token>,
-) {
-  const output = yield* decodeQueueResult(response)
-  const { images, seed, has_nsfw_concepts, ...rest } = output.value
-  if (images.length === 0) return yield* output.invalid(`${route.name} returned no images`)
-  // 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) => {
-      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
-        : flagged.map((index) => ({
-            type: "moderated" as const,
-            message: `${route.name} flagged image ${index} as NSFW`,
-          })),
-    providerMetadata: { fal: { requestId: context.token.requestID, seed: seed ?? undefined, ...rest } },
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 7. Protocol and route
-// ---------------------------------------------------------------------------
-
-export const protocol = FalQueue.protocol<Request, ImageResponse>(route, {
-  from: fromRequest,
-  decodeResult,
-})
-
-export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<FalImageOptions, FalQueue.Token>(
-    { protocol, baseURL: FalQueue.DEFAULT_BASE_URL, path: ({ request }) => `/${request.model.id}` },
-    input,
-  )
-
-export const FalImages = {
-  protocol,
-  model,
-} as const
@@ -1,34 +1,62 @@
 import { Effect, Schema } from "effect"
 import type { HttpClientResponse } from "effect/unstable/http"
+import type { Status } from "../generation.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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js"
-import { optionalNull } from "./shared.js"
-import { FalQueue } from "./utils/fal-queue.js"
+import { ProviderShared, optionalNull } from "./shared.js"

-const route = MediaProtocol.identity({ id: "fal-video", name: "fal Video", provider: "fal" })
+const ADAPTER = "fal-video"
+const NAME = "fal Video"
+const PROVIDER = ProviderID.make("fal")
+export const DEFAULT_BASE_URL = "https://queue.fal.run"

 // ---------------------------------------------------------------------------
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type FalVideoString<Known extends string> = Known | (string & {})
+
 /**
 * Provider-native input. fal video endpoints are model-specific: `duration` is a string enum whose values differ per
 * model (`"8s"` for Veo, `"5"` for Kling), and last-frame fields are named per model (`end_image_url`,
 * `last_frame_url`, `tail_image_url`), so those pass through here instead of lowering from common fields.
 */
 export type FalVideoOptions = {
-  readonly duration?: OpenString<"4s" | "6s" | "8s" | "5" | "10">
+  readonly duration?: FalVideoString<"4s" | "6s" | "8s" | "5" | "10">
 } & Record<string, unknown>

 export type Request = VideoRequestFor<FalVideoOptions>

 // ---------------------------------------------------------------------------
-// 2. Response schema
+// 2. Token and response schemas
 // ---------------------------------------------------------------------------

+/** fal hands back absolute follow-up URLs on submit; they are authoritative for status, result, and cancel. */
+export const Token = Schema.Struct({
+  requestID: Schema.String,
+  statusURL: Schema.String,
+  responseURL: Schema.String,
+  cancelURL: Schema.String,
+})
+export type Token = Schema.Schema.Type<typeof Token>
+
+const StartResponse = Schema.Struct({
+  request_id: Schema.String,
+  status_url: Schema.String,
+  response_url: Schema.String,
+  cancel_url: Schema.String,
+  queue_position: optionalNull(Schema.Number),
+})
+
+const QueueStatus = Schema.Struct({
+  status: Schema.String,
+  queue_position: optionalNull(Schema.Number),
+  error: optionalNull(Schema.Unknown),
+})
+
 const QueueResult = Schema.StructWithRest(
  Schema.Struct({
    video: Schema.Struct({
@@ -42,19 +70,30 @@ const QueueResult = Schema.StructWithRest(
  [Schema.Record(Schema.String, Schema.Unknown)],
 )

+const STATUS = {
+  IN_QUEUE: "queued",
+  IN_PROGRESS: "running",
+  COMPLETED: "completed",
+} as const satisfies Record<string, Status>
+
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------

+// fal accepts public URLs and data URIs; there is no provider file handle to forward.
+const mediaUrl = (asset: Media.Asset) =>
+  ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((reference) => reference.value))
+
 const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request: Request) {
  if (request.frames?.last !== undefined)
-    return yield* route.unsupported(
-      "video.frames.last",
-      `${route.name} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`,
-    )
-  const imageUrl =
-    request.frames?.first === undefined ? undefined : yield* FalQueue.mediaUrl(request.frames.first, route.name)
-  const videoUrl = request.video === undefined ? undefined : yield* FalQueue.mediaUrl(request.video, route.name)
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "video.frames.last",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${NAME} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`,
+    })
+  const imageUrl = request.frames?.first === undefined ? undefined : yield* mediaUrl(request.frames.first)
+  const videoUrl = request.video === undefined ? undefined : yield* mediaUrl(request.video)
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -77,11 +116,38 @@ const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request: Reques
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeQueueResult = route.decodeJson(QueueResult)
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+  token: {
+    requestID: value.request_id,
+    statusURL: value.status_url,
+    responseURL: value.response_url,
+    cancelURL: value.cancel_url,
+  },
+  snapshot: { id: value.request_id, status: "queued", position: value.queue_position ?? undefined },
+}))
+
+const decodeQueueStatus = MediaProtocol.decodeJson(ADAPTER, NAME, QueueStatus)
+const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult)
+
+const decodeStatus = Effect.fn("FalVideo.decodeStatus")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+  context: MediaProtocol.PollContext<Token>,
+) {
+  const output = yield* decodeQueueStatus(response)
+  const decoded = output.value
+  const status = yield* MediaProtocol.status(STATUS, decoded.status, output)
+  // fal reports request failures as COMPLETED with an `error`; the response endpoint carries the details.
+  const failed = status === "completed" && decoded.error !== undefined && decoded.error !== null
+  return {
+    id: context.token.requestID,
+    status: failed ? "failed" : status,
+    position: status === "queued" ? (decoded.queue_position ?? undefined) : undefined,
+  }
+})

 const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (
  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<FalQueue.Token>,
+  context: MediaProtocol.PollContext<Token>,
 ) {
  const output = yield* decodeQueueResult(response)
  const { video, seed, ...rest } = output.value
@@ -103,15 +169,26 @@ const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = FalQueue.protocol<Request, VideoResponse>(route, {
+export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>({
+  id: ADAPTER,
+  name: NAME,
+  token: Token,
  unsupported: ["n", "durationSeconds", "references"],
-  from: fromRequest,
-  decodeResult,
+  start: { body: { from: fromRequest }, decode: decodeStart },
+  status: { path: (token) => token.statusURL, decode: decodeStatus },
+  result: { path: (token) => token.responseURL, decode: decodeResult },
+  cancel: { method: "PUT", path: (token) => token.cancelURL },
 })

 export const model = (input: MediaRoute.ModelInput) =>
-  VideoModel.fromRoute<FalVideoOptions, FalQueue.Token>(
-    { protocol, baseURL: FalQueue.DEFAULT_BASE_URL, path: ({ request }) => `/${request.model.id}` },
+  VideoModel.fromRoute<FalVideoOptions, Token>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => `/${request.model.id}`,
+    },
    input,
  )

@@ -10,6 +10,7 @@ import {
  LLMEvent,
  Usage,
  type FinishReason,
+  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ProviderMetadata,
@@ -22,13 +23,13 @@ import { classifyProviderFailure } from "../provider-error.js"
 import { Media } from "../media.js"
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js"
+import { GeminiToolSchema } from "./utils/gemini-tool-schema.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
@@ -132,7 +133,7 @@ const GeminiSystemInstruction = Schema.Struct({
 const GeminiFunctionDeclaration = Schema.Struct({
  name: Schema.String,
  description: Schema.String,
-  parametersJsonSchema: JsonObject,
+  parameters: Schema.optional(JsonObject),
 })

 const GeminiTool = Schema.Struct({
@@ -265,14 +266,36 @@ interface ParserState {
  readonly seenCallIds?: ReadonlySet<string>
 }

+// =============================================================================
+// Tool Schema Conversion
+// =============================================================================
+// Tool-schema conversion has two distinct concerns:
+//
+// 1. Sanitize — fix common authoring mistakes Gemini rejects: integer/number
+//    enums (must be strings), `required` entries that don't match a property,
+//    untyped arrays (`items` must be present), and `properties`/`required`
+//    keys on non-object scalars. Mirrors OpenCode's historical Gemini rules.
+//
+// 2. Project — lossy mapping from JSON Schema to Gemini's schema dialect:
+//    drop empty root parameter schemas while preserving nested empty objects,
+//    expand type arrays into `anyOf`, derive `nullable: true` from null members,
+//    coerce `const` to `[const]` enum, recurse properties/items, and propagate
+//    only an allowlisted set of keys (description, required, format, type,
+//    nullable, enum, properties, items, allOf, anyOf, oneOf, minLength).
+//    Anything outside the allowlist (e.g. `additionalProperties`, `$ref`) is
+//    silently dropped.
+//
+// Sanitize runs first, then project. The implementation lives in
+// `utils/gemini-tool-schema` so this protocol keeps the same shape as the other
+// provider protocols.
+
 // =============================================================================
 // Request Lowering
 // =============================================================================
-// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema.
-const lowerTool = (tool: ToolDefinition) => ({
+const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema) => ({
  name: tool.name,
  description: tool.description,
-  parametersJsonSchema: tool.inputSchema,
+  parameters: GeminiToolSchema.convert(inputSchema),
 })

 const lowerToolConfig = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
@@ -442,6 +465,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
  const hasTools = flattened.tools.length > 0
  const generation = request.generation
  const options = yield* decodeOptions(request.providerOptions ?? {})
+  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  const generationConfig = {
    maxOutputTokens: generation?.maxTokens,
    temperature: generation?.temperature,
@@ -451,22 +475,10 @@ 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,
-            thinkingBudget:
-              options.thinkingConfig.thinkingBudget === undefined
-                ? undefined
-                : ProviderShared.fitThinkingBudget(
-                    options.thinkingConfig.thinkingBudget,
-                    generation?.maxTokens,
-                    MIN_THINKING_BUDGET,
-                  ),
-          },
+        : { ...options.thinkingConfig, includeThoughts: options.thinkingConfig.includeThoughts ?? true },
  }

  return {
@@ -479,7 +491,9 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
    tools: hasTools
      ? [
          {
-            functionDeclarations: flattened.tools.map(lowerTool),
+            functionDeclarations: flattened.tools.map((tool) =>
+              lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
+            ),
          },
        ]
      : undefined,
@@ -526,7 +540,19 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
  if (finishReason === undefined) return hasToolCalls ? "tool-calls" : "unknown"
  if (finishReason === "STOP") return hasToolCalls ? "tool-calls" : "stop"
  if (finishReason === "MAX_TOKENS") return "length"
-  if (GeminiGenerateContent.contentFiltered(finishReason)) return "content-filter"
+  if (
+    finishReason === "IMAGE_SAFETY" ||
+    finishReason === "RECITATION" ||
+    finishReason === "SAFETY" ||
+    finishReason === "BLOCKLIST" ||
+    finishReason === "PROHIBITED_CONTENT" ||
+    finishReason === "SPII" ||
+    finishReason === "MODEL_ARMOR" ||
+    finishReason === "IMAGE_PROHIBITED_CONTENT" ||
+    finishReason === "IMAGE_RECITATION" ||
+    finishReason === "LANGUAGE"
+  )
+    return "content-filter"
  if (
    finishReason === "MALFORMED_FUNCTION_CALL" ||
    finishReason === "UNEXPECTED_TOOL_CALL" ||
@@ -803,8 +829,6 @@ 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) => ({
@@ -3,22 +3,26 @@ import type { HttpClientResponse } from "effect/unstable/http"
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "google-images", name: "Google Images", provider: "google" })
+const ADAPTER = "google-images"
+const NAME = "Google Images"
+const PROVIDER = ProviderID.make("google")
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"

 // ---------------------------------------------------------------------------
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type GoogleImageString<Known extends string> = Known | (string & {})
+
 /** Provider-native options. Common fields (`aspectRatio`, `seed`, `images`) live on the request. */
 export type GoogleImageOptions = {
-  readonly imageSize?: OpenString<"1K" | "2K" | "4K">
-  readonly thinkingLevel?: OpenString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">
+  readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">
+  readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">
  readonly includeThoughts?: boolean
 } & Record<string, unknown>

@@ -100,13 +104,13 @@ const generationConfig = (request: Request) => {

 const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request: Request) {
  if (request.n !== undefined && request.n > 1)
-    return yield* route.unsupported(
-      "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) =>
-    GeminiGenerateContent.mediaPart(route.name, image),
-  )
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "image.n",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${NAME} generates one image per request; call it once per image instead of n=${request.n}`,
+    })
+  const parts = yield* Effect.forEach(request.images ?? [], (image) => GeminiGenerateContent.mediaPart(NAME, image))
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -122,12 +126,10 @@ const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request: Re
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeDocument = route.decodeJson(GoogleImageResponse)
-
 const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
  response: HttpClientResponse.HttpClientResponse,
 ) {
-  const output = yield* decodeDocument(response)
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, GoogleImageResponse)(response)
  const decoded = output.value
  const candidates = decoded.candidates ?? []
  const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
@@ -167,7 +169,7 @@ const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
  const images = yield* Effect.forEach(encoded, (item) =>
    MediaInput.decodedAsset(
      output.invalid,
-      `${route.name} candidate ${item.candidateIndex} part ${item.partIndex}`,
+      `${NAME} candidate ${item.candidateIndex} part ${item.partIndex}`,
      item.inlineData.data,
      item.inlineData.mimeType,
      {
@@ -190,7 +192,7 @@ const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
      candidate.finishReason === undefined ? [] : [candidate.finishReason],
    )
    return yield* output.invalid(
-      `${route.name} returned no final images${
+      `${NAME} returned no final images${
        finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
      }; inspect body for prompt feedback and candidate details`,
    )
@@ -202,7 +204,7 @@ const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
      : [
          {
            type: "filtered" as const,
-            message: `${route.name} reported prompt feedback`,
+            message: `${NAME} reported prompt feedback`,
            providerMetadata: { google: { promptFeedback: decoded.promptFeedback } },
          },
        ]),
@@ -212,7 +214,7 @@ const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
        : [
            {
              type: "filtered" as const,
-              message: `${route.name} candidate ${candidate.index ?? index} finished with ${candidate.finishReason}${
+              message: `${NAME} candidate ${candidate.index ?? index} finished with ${candidate.finishReason}${
                candidate.finishMessage === undefined ? "" : `: ${candidate.finishMessage}`
              }`,
              providerMetadata: {
@@ -262,7 +264,9 @@ const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["mask", "size", "format"],
  body: { from: fromRequest },
  response: { decode: decodeResponse },
@@ -271,6 +275,8 @@ export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
 export const model = (input: MediaRoute.ModelInput) =>
  ImageModel.fromRoute<GoogleImageOptions>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      path: ({ request }) => `/models/${request.model.id}:generateContent`,
@@ -1,12 +1,14 @@
 import { Effect, Schema } from "effect"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { SpeechModel, type SpeechEvent, type SpeechRequestFor } from "../speech.js"
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js"
 import { SpeechStream } from "./utils/speech-stream.js"

-const route = MediaProtocol.identity({ id: "google-speech", name: "Google Speech", provider: "google" })
+const ADAPTER = "google-speech"
+const NAME = "Google Speech"
+const PROVIDER = ProviderID.make("google")
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
 const DEFAULT_SAMPLE_RATE = 24000

@@ -41,7 +43,7 @@ const GenerateContentChunk = GeminiGenerateContent.chunk(
  }),
 )

-const decodeChunk = route.decodeFrame(GenerateContentChunk)
+const decodeChunk = MediaProtocol.decodeFrame(ADAPTER, NAME, GenerateContentChunk)

 // ---------------------------------------------------------------------------
 // 4. Parser state
@@ -56,18 +58,11 @@ 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 accepts raw PCM as an explicit format; omit it to accept the provider's default output`,
+    return yield* SpeechStream.unsupportedFormat(
+      PROVIDER,
+      ADAPTER,
+      `${NAME} only returns raw PCM; request format "pcm" or omit it, then wrap the samples yourself`,
    )
  const voiceName = SpeechStream.voiceID(request.voice)
  return MediaProtocol.json(
@@ -96,35 +91,22 @@ const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request: Me

 const step = Effect.fn("GoogleSpeech.step")(function* (state: State, frame: string) {
  const chunk = yield* decodeChunk(frame)
-  const blocked = GeminiGenerateContent.blocked(route.name, chunk, frame)
+  const blocked = GeminiGenerateContent.blocked(NAME, chunk, frame)
  if (blocked !== undefined) return yield* blocked
  const audio = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) =>
    part.inlineData === undefined ? [] : [part.inlineData],
  )
  const next: State = { ...GeminiGenerateContent.track(state, chunk), mimeType: state.mimeType ?? audio[0]?.mimeType }
-  const events = audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])
-  const withheld = next.chunks.length === 0 ? GeminiGenerateContent.withheld(route.name, chunk, frame) : undefined
-  if (withheld !== undefined) return yield* withheld
-  return [next, events] as const
+  return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])] as const
 })

-const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) => {
-  if (state.finishReason === undefined) return Effect.fail(route.incomplete())
+const finish = (state: State) => {
  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, {
-    ...output,
+  return SpeechStream.finish(ADAPTER, state, {
+    ...SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`),
    usage: GeminiGenerateContent.usage(state.usage),
-    notices: GeminiGenerateContent.notices(route.name, state),
    providerMetadata: GeminiGenerateContent.providerMetadata(state),
-    detail: `finish reason: ${state.finishReason}`,
+    detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
  })
 }

@@ -132,8 +114,10 @@ const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) =
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, SpeechEvent, string, State>(route, {
-  unsupported: ["instructions", "speed"],
+export const protocol = MediaProtocol.stream<Request, SpeechEvent, string, State>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["instructions", "speed", "timestamps"],
  body: { from: fromRequest },
  frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
  initial: () => ({ chunks: [] }),
@@ -144,6 +128,8 @@ export const protocol = MediaProtocol.stream<Request, SpeechEvent, string, State
 export const model = (input: MediaRoute.ModelInput) =>
  SpeechModel.fromRoute<GoogleSpeechOptions, string, State>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      // Only `gemini-3.1-flash-tts-preview` and later stream; earlier TTS models reject `streamGenerateContent`.
@@ -1,7 +1,7 @@
 import { Effect, Schema, SchemaGetter } from "effect"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import {
  TranscriptionFinishEvent,
  TranscriptionModel,
@@ -12,9 +12,12 @@ import {
  type TranscriptionWord,
  type TranscriptionEvent,
 } from "../transcription.js"
+import { ProviderShared } from "./shared.js"
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js"

-const route = MediaProtocol.identity({ id: "google-transcription", name: "Google Transcription", provider: "google" })
+const ADAPTER = "google-transcription"
+const NAME = "Google Transcription"
+const PROVIDER = ProviderID.make("google")
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"

 // ---------------------------------------------------------------------------
@@ -27,7 +30,7 @@ export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1bet
 */
 export type GoogleTranscriptionOptions = {
  readonly audioTranscriptionConfig?: {
-    readonly mode?: OpenString<"VERBATIM" | "SMART">
+    readonly mode?: "VERBATIM" | "SMART" | (string & {})
    readonly customVocabulary?: ReadonlyArray<string>
    readonly languageCodes?: ReadonlyArray<string>
  }
@@ -61,7 +64,9 @@ const AudioTranscription = Schema.Struct({
  ),
 })

-const decodeChunk = route.decodeFrame(
+const decodeChunk = MediaProtocol.decodeFrame(
+  ADAPTER,
+  NAME,
  GeminiGenerateContent.chunk(Schema.Struct({ audioTranscription: Schema.optional(AudioTranscription) })),
 )

@@ -82,14 +87,16 @@ interface State extends GeminiGenerateContent.Metadata {
 const fromRequest = Effect.fn("GoogleTranscription.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
  // General Gemini models ignore `audioTranscriptionConfig` and answer the audio conversationally.
  if (!request.model.id.includes("transcribe"))
-    return yield* route.unsupported(
-      "transcription.model",
-      `${request.model.id} is not a transcription model; use a transcribe model such as gemini-3.5-transcribe`,
-    )
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "transcription.model",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${request.model.id} is not a transcription model; use a transcribe model such as gemini-3.5-transcribe`,
+    })
  return MediaProtocol.json(
    mergeJsonRecords(
      {
-        contents: [{ role: "user", parts: [yield* GeminiGenerateContent.mediaPart(route.id, request.audio)] }],
+        contents: [{ role: "user", parts: [yield* GeminiGenerateContent.mediaPart(ADAPTER, request.audio)] }],
        generationConfig: mergeJsonRecords(
          {
            audioTranscriptionConfig: {
@@ -140,7 +147,7 @@ const turn = (part: Schema.Schema.Type<typeof AudioTranscription>) => {

 const step = Effect.fn("GoogleTranscription.step")(function* (state: State, frame: string) {
  const chunk = yield* decodeChunk(frame)
-  const blocked = GeminiGenerateContent.blocked(route.name, chunk, frame)
+  const blocked = GeminiGenerateContent.blocked(NAME, chunk, frame)
  if (blocked !== undefined) return yield* blocked
  const turns = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) =>
    part.audioTranscription === undefined ? [] : [turn(part.audioTranscription)],
@@ -154,9 +161,6 @@ const step = Effect.fn("GoogleTranscription.step")(function* (state: State, fram
    .filter((item) => item.length > 0)
    .join(" ")
  const delta = text.length === 0 || state.text.length === 0 ? text : ` ${text}`
-  const withheld =
-    state.text.length + delta.length === 0 ? GeminiGenerateContent.withheld(route.name, chunk, frame) : undefined
-  if (withheld !== undefined) return yield* withheld
  const events: ReadonlyArray<TranscriptionEvent> = [
    ...(delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta })]),
    ...segments.map((segment) => TranscriptionSegmentEvent.make({ segment })),
@@ -165,14 +169,13 @@ const step = Effect.fn("GoogleTranscription.step")(function* (state: State, fram
 })

 const finish = (state: State) => {
-  if (state.finishReason === undefined) return Effect.fail(route.incomplete())
+  if (state.finishReason === undefined) return Effect.fail(MediaProtocol.incomplete(ADAPTER))
  return Effect.succeed([
    TranscriptionFinishEvent.make({
      text: state.text,
      segments: state.segments.length === 0 ? undefined : state.segments,
      words: state.words.length === 0 ? undefined : state.words,
      usage: GeminiGenerateContent.usage(state.usage),
-      notices: GeminiGenerateContent.notices(route.name, state),
      providerMetadata: GeminiGenerateContent.providerMetadata(state),
    }),
  ])
@@ -182,7 +185,9 @@ const finish = (state: State) => {
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, string, State>(route, {
+export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, string, State>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["prompt", "speakers"],
  body: { from: fromRequest },
  frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
@@ -194,6 +199,8 @@ export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, string
 export const model = (input: MediaRoute.ModelInput) =>
  TranscriptionModel.fromRoute<GoogleTranscriptionOptions, string, State>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),
@@ -4,11 +4,13 @@ import type { Status } from "../generation.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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js"
 import { ProviderShared, optionalArray } from "./shared.js"

-const route = MediaProtocol.identity({ id: "google-video", name: "Google Veo", provider: "google" })
+const ADAPTER = "google-video"
+const NAME = "Google Veo"
+const PROVIDER = ProviderID.make("google")
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
 /** Veo keeps generated files for two days; the asset carries that deadline so callers materialize in time. */
 const FILE_RETENTION = Duration.days(2)
@@ -17,9 +19,11 @@ const FILE_RETENTION = Duration.days(2)
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type GoogleVideoString<Known extends string> = Known | (string & {})
+
 /** Provider-native `parameters`. Common fields (`aspectRatio`, `resolution`, `durationSeconds`, `seed`) live on the request. */
 export type GoogleVideoOptions = {
-  readonly personGeneration?: OpenString<"allow_all" | "allow_adult" | "dont_allow">
+  readonly personGeneration?: GoogleVideoString<"allow_all" | "allow_adult" | "dont_allow">
 } & Record<string, unknown>

 export type Request = VideoRequestFor<GoogleVideoOptions>
@@ -66,23 +70,27 @@ const Operation = Schema.Struct({

 // Veo takes inline media only; a prior Veo output is `Media.url` with transient auth, so materialize it first.
 const inlineMedia = (asset: Media.Asset) =>
-  ProviderShared.requireInlineMedia(route.name, asset).pipe(
+  ProviderShared.requireInlineMedia(NAME, asset).pipe(
    Effect.map((inline) => ({ inlineData: { mimeType: inline.mime, data: inline.base64 } })),
  )

 const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request: Request) {
  if (request.n !== undefined && request.n > 1)
-    return yield* route.unsupported(
-      "video.n",
-      `${route.name} generates one video per request; call it once per video instead of n=${request.n}`,
-    )
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "video.n",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${NAME} generates one video per request; call it once per video instead of n=${request.n}`,
+    })
  if (request.audio === false)
-    return yield* route.unsupported(
-      "video.audio",
-      `${route.name} always generates audio; audio: false cannot be honored`,
-    )
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "video.audio",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${NAME} always generates audio; audio: false cannot be honored`,
+    })
  if (request.frames?.last !== undefined && request.frames.first === undefined)
-    return yield* ProviderShared.invalidRequest(`${route.name} requires frames.first when frames.last is set`)
+    return yield* ProviderShared.invalidRequest(`${NAME} requires frames.first when frames.last is set`)
  const image = request.frames?.first === undefined ? undefined : yield* inlineMedia(request.frames.first)
  const lastFrame = request.frames?.last === undefined ? undefined : yield* inlineMedia(request.frames.last)
  const video = request.video === undefined ? undefined : yield* inlineMedia(request.video)
@@ -121,7 +129,7 @@ const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request: Req
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeStart = route.decodeStarted(StartResponse, (value) => ({
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
  token: { operation: value.name },
  snapshot: { id: value.name, status: "running" },
 }))
@@ -132,7 +140,7 @@ const statusOf = (operation: typeof Operation.Type): Status => {
  return operation.error === undefined ? "completed" : "failed"
 }

-const decodeOperation = route.decodeJson(Operation)
+const decodeOperation = MediaProtocol.decodeJson(ADAPTER, NAME, Operation)

 const decodeStatus = Effect.fn("GoogleVideo.decodeStatus")(function* (
  response: HttpClientResponse.HttpClientResponse,
@@ -149,11 +157,12 @@ 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.pending(context.token.operation)
+  if (status === "running")
+    return yield* output.invalid(`${NAME} operation ${context.token.operation} has not finished`)
  if (status === "failed")
    return yield* output.ended(
      "failed",
-      `${route.name} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`,
+      `${NAME} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`,
    )
  const generated = operation.response?.generateVideoResponse
  // Downloads require the same API key as the poll; the asset carries it transiently and follows the redirect.
@@ -170,14 +179,14 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (
  const reasons = generated?.raiMediaFilteredReasons ?? []
  const notices = reasons.map((reason) => ({
    type: "filtered" as const,
-    message: `${route.name} filtered media: ${reason}`,
+    message: `${NAME} filtered media: ${reason}`,
    providerMetadata: { google: { raiMediaFilteredReason: reason } },
  }))
  if (videos.length === 0 && (reasons.length > 0 || (generated?.raiMediaFilteredCount ?? 0) > 0))
    return yield* output.contentPolicy(
-      `${route.name} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`,
+      `${NAME} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`,
    )
-  if (videos.length === 0) return yield* output.invalid(`${route.name} operation completed without any video`)
+  if (videos.length === 0) return yield* output.invalid(`${NAME} operation completed without any video`)
  return new VideoResponse({
    videos,
    notices: notices.length === 0 ? undefined : notices,
@@ -197,7 +206,9 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (

 const operationPath = (token: Token) => `/${token.operation}`

-export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>(route, {
+export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>({
+  id: ADAPTER,
+  name: NAME,
  token: Token,
  start: { body: { from: fromRequest }, decode: decodeStart },
  status: { path: operationPath, decode: decodeStatus },
@@ -207,6 +218,8 @@ export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>(rout
 export const model = (input: MediaRoute.ModelInput) =>
  VideoModel.fromRoute<GoogleVideoOptions, Token>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      path: ({ request }) => `/models/${request.model.id}:predictLongRunning`,
@@ -4,17 +4,20 @@ 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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { JsonObject, ProviderShared, optionalNull } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "meta-images", name: "Meta Images", provider: "meta" })
-export const DEFAULT_BASE_URL = "https://api.meta.ai/v1"
+const ADAPTER = "meta-images"
+const NAME = "Meta Images"
+const PROVIDER = ProviderID.make("meta")

 // ---------------------------------------------------------------------------
 // 1. Public model input
 // ---------------------------------------------------------------------------

+type OpenString<Known extends string> = Known | (string & {})
+
 /** Provider-native options. Common fields (`n`, `size`, `format`, `images`) live on the request. */
 export type ImageOptions = {
  readonly responseFormat?: OpenString<"b64_json" | "url">
@@ -69,7 +72,7 @@ const isEdit = (request: Request) => (request.images?.length ?? 0) > 0

 // Meta has no file handles: refs are rejected even when they name this provider.
 const reference = (asset: Media.Asset) =>
-  ProviderShared.mediaReference(asset, undefined, route.name).pipe(Effect.map((item) => ({ image_url: item.value })))
+  ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((item) => ({ image_url: item.value })))

 const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request: Request) {
  const images = yield* Effect.forEach(request.images ?? [], reference)
@@ -98,23 +101,24 @@ const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request: Requ
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeDocument = route.decodeJson(Response)
-
 const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (
  response: HttpClientResponse.HttpClientResponse,
  context: MediaProtocol.DecodeContext<Request>,
 ) {
-  const output = yield* decodeDocument(response)
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, Response)(response)
  const decoded = output.value
  const requested = context.body.type === "json" ? context.body.value.output_format : undefined
  const format = decoded.output_format ?? (typeof requested === "string" ? requested : "webp")
  const mediaType = `image/${format}`
-  const images = yield* Effect.forEach(decoded.data, (item, index) =>
-    MediaInput.imageOutput(output.invalid, `${route.name} result ${index}`, item, mediaType, {
-      info: { format },
-    }),
-  )
-  if (images.length === 0) return yield* output.invalid(`${route.name} returned no images`)
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    if (item.b64_json)
+      return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+        info: { format },
+      })
+    if (item.url) return Effect.succeed(Media.url(item.url, { mediaType, info: { format } }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
  return new ImageResponse({
    images,
    usage:
@@ -135,17 +139,20 @@ const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["mask", "aspectRatio", "seed"],
  body: { from: fromRequest },
  response: { decode: decodeResponse },
 })

-export const model = (input: MediaRoute.ModelInput) =>
+export const model = (input: MediaRoute.ModelInput & { readonly baseURL: string }) =>
  ImageModel.fromRoute<ImageOptions>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
-      baseURL: DEFAULT_BASE_URL,
      path: ({ request }) => `/images/${isEdit(request) ? "edits" : "generations"}`,
    },
    input,
@@ -5,7 +5,8 @@ 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 { detectMediaType } from "../utils/media-type.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { MetaImage } from "./utils/meta-image.js"

 const ADAPTER = "meta-responses"
 const NAME = "Meta Responses"
@@ -102,7 +103,12 @@ 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)
+              if (tool.native === undefined)
+                return yield* OpenResponses.lowerTool(
+                  NAME,
+                  tool,
+                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model.compatibility?.toolSchema),
+                )
              return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta)
            }),
          ),
@@ -145,11 +151,7 @@ const HOSTED_TOOLS = {
          ),
        ),
      )
-      // Responses image items can omit output_format, including when PNG/JPEG was requested.
-      const mime =
-        item.output_format === undefined
-          ? (detectMediaType(data) ?? "application/octet-stream")
-          : `image/${item.output_format}`
+      const mime = MetaImage.mediaType(data, item.output_format)
      return {
        type: "content" as const,
        value: [{ type: "file" as const, uri: `data:${mime};base64,${item.result}`, mime }],
@@ -8,6 +8,7 @@ import {
  ProviderInternalError,
  Usage,
  type FinishReason,
+  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ProviderMetadata,
@@ -23,6 +24,7 @@ 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"
@@ -441,24 +443,23 @@ interface ReasoningStreamItem {
 // =============================================================================
 // Request Lowering
 // =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName: string, tool: ToolDefinition) {
+export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (
+  protocolName: string,
+  tool: ToolDefinition,
+  inputSchema: JsonSchema,
+) {
  if (tool.native !== undefined)
    return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`)
  return {
    type: "function" as const,
    name: tool.name,
    description: tool.description,
-    parameters: tool.inputSchema,
+    parameters: 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,
@@ -817,10 +818,22 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
  adapter: ProviderAdapter,
 ) {
  const projected = ProviderShared.flattenToolRequest(request)
+  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  return {
    ...(yield* lowerConversation(projected.request, adapter)),
    ...lowerGeneration(request),
-    tools: projected.tools.length === 0 ? undefined : yield* lowerTools(projected.tools, adapter),
+    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, toolSchemaCompatibility),
+                ),
+          ),
    tool_choice:
      allowedToolChoice(request) ??
      (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
@@ -17,6 +17,7 @@ import {
  type FinishReason,
  type FinishReasonDetails,
  type CacheHint,
+  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ReasoningPart,
@@ -28,6 +29,7 @@ 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"
@@ -128,10 +130,6 @@ const OpenAIChatUserContent = Schema.Union([
    type: Schema.Literal("image_url"),
    image_url: Schema.Struct({ url: Schema.String }),
  }),
-  Schema.Struct({
-    type: Schema.Literal("file"),
-    file: Schema.Struct({ filename: Schema.String, file_data: Schema.String }),
-  }),
 ])

 const OpenAIChatMessage = Schema.Union([
@@ -328,12 +326,17 @@ interface LoweringOptions {
  readonly toolCallID?: (id: string) => string
 }

-const lowerTool = (tool: ToolDefinition, options: LoweringOptions, supportsStrictMode: boolean): OpenAIChatTool => ({
+const lowerTool = (
+  tool: ToolDefinition,
+  inputSchema: JsonSchema,
+  options: LoweringOptions,
+  supportsStrictMode: boolean,
+): OpenAIChatTool => ({
  type: "function",
  function: {
    name: tool.name,
    description: tool.description,
-    parameters: tool.inputSchema,
+    parameters: inputSchema,
    ...(supportsStrictMode ? { strict: false } : {}),
  },
  cache_control: options.cacheControl?.(tool.cache),
@@ -357,15 +360,6 @@ const lowerToolCall = (part: ToolCallPart, options: LoweringOptions): OpenAIChat
 })

 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart) {
-  // Chat Completions accepts PDFs, and no other documents, as inline `file` parts; file URLs are not supported.
-  if (part.media.mediaType.toLowerCase() === "application/pdf")
-    return {
-      type: "file" as const,
-      file: {
-        filename: part.filename ?? "document.pdf",
-        file_data: (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl,
-      },
-    }
  if (part.media.kind !== "image")
    return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.media.mediaType}`)
  const url =
@@ -495,7 +489,7 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
  options: LoweringOptions,
 ) {
  const messages: OpenAIChatMessage[] = []
-  const attachments: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
+  const images: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
  for (const part of message.content) {
    if (!ProviderShared.supportsContent(part, ["tool-result"]))
      return yield* ProviderShared.unsupportedContent("OpenAI Chat", "tool", ["tool-result"])
@@ -517,9 +511,9 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
      cache_control: options.cacheControl?.(part.cache),
    })
    const files = content.filter((item) => item.type === "file")
-    attachments.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))))
+    images.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))))
  }
-  return { messages, attachments }
+  return { messages, images }
 })

 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
@@ -580,21 +574,21 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
    if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
      messages.push({ role: "assistant", content: "Done." })
  }
-  const pendingAttachments: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
-  const flushAttachments = () => {
-    if (pendingAttachments.length === 0) return
+  const pendingImages: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
+  const flushImages = () => {
+    if (pendingImages.length === 0) return
    bridgeTools()
-    messages.push({ role: "user", content: pendingAttachments.splice(0) })
+    messages.push({ role: "user", content: pendingImages.splice(0) })
  }
  for (const message of request.messages) {
    if (message.role === "user") bridgeTools()
    if (message.role === "system") {
      const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message)
-      if (pendingAttachments.length > 0) {
+      if (pendingImages.length > 0) {
        messages.push({
          role: "user",
          content: [
-            ...pendingAttachments.splice(0),
+            ...pendingImages.splice(0),
            { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
          ],
        })
@@ -638,13 +632,13 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
    if (message.role === "tool") {
      const lowered = yield* lowerToolMessages(message, lowering)
      messages.push(...lowered.messages)
-      pendingAttachments.push(...lowered.attachments)
+      pendingImages.push(...lowered.images)
      continue
    }
-    flushAttachments()
+    flushImages()
    messages.push(...(yield* lowerMessage(message, reasoningField, requireReasoning, lowering)))
  }
-  flushAttachments()
+  flushImages()
  return messages
 })

@@ -796,6 +790,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
      `OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`,
    )
  const generation = request.generation
+  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  const flattened = ProviderShared.flattenToolRequest(request)
  const provider = String(request.model.provider)
  const baseURL = request.model.route.endpoint.baseURL
@@ -818,7 +813,14 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
        ? hasHistory
          ? []
          : undefined
-        : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
+        : flattened.tools.map((tool) =>
+            lowerTool(
+              tool,
+              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
+              options,
+              supportsStrictMode,
+            ),
+          ),
    tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
    stream: true as const,
    ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
@@ -1,21 +1,16 @@
-import { Effect, Schema, Stream } from "effect"
-import {
-  ImageFinishEvent,
-  ImageModel,
-  ImageOutputEvent,
-  ImagePartialEvent,
-  type ImageEvent,
-  type ImageRequestFor,
-} from "../image.js"
+import { 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 { Framing } from "../route/framing.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type MediaUsage, type OpenString } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "openai-images", name: "OpenAI Images", provider: "openai" })
+const ADAPTER = "openai-images"
+const NAME = "OpenAI Images"
+const PROVIDER = ProviderID.make("openai")
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/images/generations"
 export const EDIT_PATH = "/images/edits"
@@ -24,14 +19,14 @@ export const EDIT_PATH = "/images/edits"
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type OpenAIImageString<Known extends string> = Known | (string & {})
+
 /** Provider-native options. Common fields (`n`, `size`, `format`, `images`, `mask`) live on the request. */
 export type OpenAIImageOptions = {
-  readonly quality?: OpenString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
-  readonly background?: OpenString<"auto" | "opaque" | "transparent">
-  readonly moderation?: OpenString<"auto" | "low">
+  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
+  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
+  readonly moderation?: OpenAIImageString<"auto" | "low">
  readonly outputCompression?: number
-  /** Previews sent before the final image when streaming (default 2); ignored by `Image.generate`. */
-  readonly partialImages?: number
 } & Record<string, unknown>

 export type Request = ImageRequestFor<OpenAIImageOptions>
@@ -40,68 +35,26 @@ export type Request = ImageRequestFor<OpenAIImageOptions>
 // 2. Response schema
 // ---------------------------------------------------------------------------

-const Usage = Schema.Struct({
-  input_tokens: Schema.optional(Schema.Number),
-  output_tokens: Schema.optional(Schema.Number),
-  total_tokens: Schema.optional(Schema.Number),
-  input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-
-/** 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),
+  data: Schema.Array(
+    Schema.Struct({
+      b64_json: Schema.optional(Schema.String),
+      url: Schema.optional(Schema.String),
+      revised_prompt: Schema.optional(Schema.String),
+    }),
+  ),
+  output_format: Schema.optional(Schema.String),
+  usage: Schema.optional(
+    Schema.Struct({
+      input_tokens: Schema.optional(Schema.Number),
+      output_tokens: Schema.optional(Schema.Number),
+      total_tokens: Schema.optional(Schema.Number),
+      input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+      output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    }),
+  ),
 })

-// ---------------------------------------------------------------------------
-// 3. Streaming event schema
-// ---------------------------------------------------------------------------
-
-const StreamEvent = Schema.Union([
-  Schema.Struct({
-    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),
-  }),
-])
-
-const decodeEvent = route.decodeFrame(StreamEvent)
-const decodeDocument = Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse))
-
-/** `generate` reads the whole JSON response as one frame, with the requested format for responses that omit it. */
-type Frame = string | { readonly document: string; readonly requested: string | undefined }
-
-// ---------------------------------------------------------------------------
-// 4. Parser state
-// ---------------------------------------------------------------------------
-
-interface State {
-  readonly completed: number
-  readonly format?: string
-  readonly size?: string
-  readonly quality?: string
-  readonly background?: string
-  readonly usage?: MediaUsage
-}
-
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -111,35 +64,26 @@ const RESERVED_FORM_FIELDS = new Set(["model", "prompt", "image", "image[]", "im

 const nativeOptions = (options: OpenAIImageOptions | undefined) => {
  if (!options) return undefined
-  const { outputCompression, partialImages: _, ...native } = options
+  const { outputCompression, ...native } = options
  return { output_compression: outputCompression, ...native }
 }

-const streamOptions = (request: MediaProtocol.Addressed<Request>) => {
-  if (request.mode !== "stream") return Effect.succeed(undefined)
-  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}`),
-    )
-  return Effect.succeed({ stream: true, partial_images: request.providerOptions?.partialImages ?? 2 })
-}
-
 const isEdit = (request: Request) => (request.images?.length ?? 0) > 0

-const isInline = (asset: Media.Asset) => asset.source.type === "bytes" || asset.source.type === "base64"
+const isInline = (asset: Media.Asset) => asset.inline() !== undefined

 const reference = (asset: Media.Asset) =>
-  ProviderShared.mediaReference(asset, route.provider, route.name).pipe(
+  ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(
    Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })),
  )

-const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
+const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Request) {
  const images = request.images ?? []
  const mask = request.mask
  if (mask !== undefined && images.length === 0)
    return yield* ProviderShared.invalidRequest("An OpenAI image mask requires at least one input image")
  const fields = mergeJsonRecords(
-    { n: request.n, size: request.size, output_format: request.format, ...(yield* streamOptions(request)) },
+    { n: request.n, size: request.size, output_format: request.format },
    nativeOptions(request.providerOptions),
    request.http?.body,
  )
@@ -147,17 +91,18 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Me
  // Owned bytes go through multipart edits; remote URLs and file IDs use the JSON edits body instead.
  if (images.length > 0 && images.every(isInline) && (mask === undefined || isInline(mask))) {
    const form = new FormData()
-    MediaInput.appendFields(
-      form,
-      { model: request.model.id, prompt: request.prompt },
-      { overlay: fields, reserved: RESERVED_FORM_FIELDS },
-    )
-    const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(route.id, image))
+    form.append("model", request.model.id)
+    form.append("prompt", request.prompt)
+    Object.entries(fields ?? {}).forEach(([key, value]) => {
+      if (RESERVED_FORM_FIELDS.has(key)) return
+      form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value))
+    })
+    const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(ADAPTER, image))
    uploads.forEach((data, index) =>
      form.append("image[]", MediaInput.blob(data, images[index].mediaType), `image-${index}`),
    )
    if (mask !== undefined)
-      form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(route.id, mask), mask.mediaType), "mask")
+      form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask")
    return MediaProtocol.multipart(form)
  }

@@ -177,7 +122,7 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Me
 })

 // ---------------------------------------------------------------------------
-// 6. Stream parsing
+// 6. Response decoding
 // ---------------------------------------------------------------------------

 const requestedFormat = (body: MediaProtocol.Body) => {
@@ -186,112 +131,63 @@ const requestedFormat = (body: MediaProtocol.Body) => {
  return typeof value === "string" ? value : undefined
 }

-const usage = (value: Schema.Schema.Type<typeof Usage> | undefined): MediaUsage | undefined =>
-  value === undefined
-    ? undefined
-    : {
-        type: "tokens",
-        input: value.input_tokens,
-        output: value.output_tokens,
-        total: value.total_tokens,
-        details: { openai: value },
-      }
-
-/** `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: info(format, size),
+const decodeResponse = Effect.fn("OpenAIImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+  context: MediaProtocol.DecodeContext<Request>,
+) {
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, OpenAIImageResponse)(response)
+  const decoded = output.value
+  const format = decoded.output_format ?? requestedFormat(context.body) ?? "png"
+  const mediaType = `image/${format}`
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    const providerMetadata =
+      item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } }
+    if (item.b64_json)
+      return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+        info: { format },
+        providerMetadata,
+      })
+    if (item.url) return Effect.succeed(Media.url(item.url, { mediaType, info: { format }, providerMetadata }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
+  return new ImageResponse({
+    images,
+    usage:
+      decoded.usage === undefined
+        ? undefined
+        : {
+            type: "tokens",
+            input: decoded.usage.input_tokens,
+            output: decoded.usage.output_tokens,
+            total: decoded.usage.total_tokens,
+            details: { openai: decoded.usage },
+          },
+    providerMetadata: { openai: { outputFormat: format } },
  })
-
-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, 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, event.size)
-  return [
-    {
-      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
 })

-const onDocument = Effect.fn("OpenAIImages.onDocument")(function* (frame: Exclude<Frame, string>) {
-  const invalid = (message: string, cause?: unknown) => route.frameError(message, frame.document, cause)
-  const decoded = yield* decodeDocument(frame.document).pipe(
-    Effect.mapError((cause) => invalid(`${route.name} returned an invalid response`, cause)),
-  )
-  const format = decoded.output_format ?? frame.requested ?? "png"
-  const images = yield* Effect.forEach(decoded.data, (item, index) =>
-    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,
-    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
-})
-
-const step = (state: State, frame: Frame) => (typeof frame === "string" ? onEvent(state, frame) : onDocument(frame))
-
-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,
-          size: state.size,
-          quality: state.quality,
-          background: state.background,
-        },
-      },
-    }),
-  ])
-}
-
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, ImageEvent, Frame, State>(route, {
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["aspectRatio", "seed"],
  body: { from: fromRequest },
-  frames: (bytes, context) =>
-    context.request.mode === "stream"
-      ? Framing.sse.frame(bytes)
-      : Framing.document
-          .frame(bytes)
-          .pipe(Stream.map((document) => ({ document, requested: requestedFormat(context.body) }))),
-  initial: () => ({ completed: 0 }),
-  step,
-  finish,
+  response: { decode: decodeResponse },
 })

 export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<OpenAIImageOptions, Frame, State>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) },
+  ImageModel.fromRoute<OpenAIImageOptions>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
+    },
    input,
  )

@@ -5,12 +5,14 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import { LLMRequest, type ToolDefinition, type ToolEntry } from "../schema/index.js"
+import { LLMRequest, mergeJsonRecords, type JsonSchema, 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 { OpenAIImage } from "./utils/openai-image.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
 import { ResponsesCompaction } from "./utils/responses-compaction.js"
 import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js"
@@ -39,16 +41,7 @@ const OpenAIResponsesImageGenerationTool = Schema.Struct({
  output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
  partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
  quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
-  size: Schema.optional(
-    Schema.String.check(
-      Schema.makeFilter((value) => {
-        if (value === "auto") return undefined
-        const match = /^(\d+)x(\d+)$/.exec(value)
-        if (!match) return "image size must be `auto` or `{width}x{height}`"
-        return Number(match[1]) > 0 && Number(match[2]) > 0 ? undefined : "image dimensions must be positive integers"
-      }),
-    ),
-  ),
+  size: Schema.optional(OpenAIImage.Size),
 })

 const OpenAIResponsesHostedToolItem = Schema.Union([
@@ -135,6 +128,11 @@ 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 = {
@@ -143,14 +141,12 @@ const adapter = {
  restoreHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
 } satisfies OpenResponses.ProviderAdapter

-// 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.
+// Only GPT-6 Astra accepts `configuration_update`, 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|sol|luna)$/i.test(request.model.id)
+  return /(?:^|\/)gpt-6-astra$/i.test(request.model.id)
 }

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

-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition) {
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition, inputSchema: JsonSchema) {
  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)
+  return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })

 // 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) {
-  if (tool.type === "tool") return yield* lowerTool(tool)
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
+  tool: ToolEntry,
+  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
+) {
+  if (tool.type === "tool")
+    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
  // OpenAI requires a namespace description; fall back to a generic one so a
  // missing description never blocks the request.
  return {
@@ -183,13 +183,11 @@ 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),
+      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
    ),
  }
 })

-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,
@@ -209,11 +207,15 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
  )(request.providerOptions?.contextManagement)
  const options = OpenResponsesOptions.resolve(request)
  const updates = resolveEffortUpdates(request, options.reasoningEffort)
+  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  return yield* decodeBody({
    ...(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* lowerTools(request),
+    tools:
+      request.tools.length === 0
+        ? undefined
+        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
    tool_choice:
      request.tools.length === 0
        ? undefined
@@ -225,6 +227,7 @@ 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 (
@@ -235,13 +238,18 @@ const checkpointBody = {
      return yield* ProviderShared.invalidRequest(
        "Trigger compaction requires complete canonical history, not an input or continuation override",
      )
-    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 }],
-    }
+    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,
+    })
  }),
 }

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

 export const route = Route.make({
-  compact: {
-    endpoint: ResponsesCompaction.make(adapter, lowerTools),
-    trigger: ResponsesCheckpoint.make(checkpointBody),
-  },
+  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
  id: ADAPTER,
  provider: "openai",
  providerMetadataKey: "openai",
@@ -2,11 +2,13 @@ import { Effect, Schema } from "effect"
 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 { ProviderID, mergeJsonRecords, type MediaUsage } from "../schema/index.js"
 import { SpeechModel, type SpeechEvent, type SpeechRequestFor } from "../speech.js"
 import { SpeechStream } from "./utils/speech-stream.js"

-const route = MediaProtocol.identity({ id: "openai-speech", name: "OpenAI Speech", provider: "openai" })
+const ADAPTER = "openai-speech"
+const NAME = "OpenAI Speech"
+const PROVIDER = ProviderID.make("openai")
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/audio/speech"
 /** `pcm` is raw 24 kHz, 16-bit signed little-endian mono samples without a header. */
@@ -16,11 +18,7 @@ const PCM_SAMPLE_RATE = 24000
 // 1. Public model input
 // ---------------------------------------------------------------------------

-/** `voice`, `instructions`, `speed`, and `format` are common request fields; other native body fields pass through. */
-export type OpenAISpeechOptions = {
-  /** Defaults to `"sse"` in `stream` mode on models that support it; the merged value selects the response framing. */
-  readonly stream_format?: "sse" | "audio"
-} & Record<string, unknown>
+export type OpenAISpeechOptions = Record<string, unknown>

 export type Request = SpeechRequestFor<OpenAISpeechOptions>

@@ -42,7 +40,7 @@ const SpeechStreamEvent = Schema.Union([
  }),
 ])

-const decodeEvent = route.decodeFrame(SpeechStreamEvent)
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SpeechStreamEvent)

 // ---------------------------------------------------------------------------
 // 4. Parser state
@@ -60,17 +58,7 @@ interface State extends SpeechStream.Audio {
 // `sse` is not supported for `tts-1` or `tts-1-hd`; those models stream the raw audio body instead.
 const supportsSse = (model: string) => !/^tts-1(-hd)?(-|$)/.test(model)

-const FORMATS = new Set(["mp3", "opus", "aac", "flac", "wav", "pcm"])
-
 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`)
-  if (request.format !== undefined && !FORMATS.has(request.format))
-    return yield* route.unsupported(
-      "media.format",
-      `${route.name} supports the mp3, opus, aac, flac, wav, and pcm formats, not "${request.format}"`,
-    )
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -118,11 +106,9 @@ const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state: State, frame
 })

 const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) => {
-  if (isSse(context.body) && !state.done) return Effect.fail(route.incomplete())
-  // The sent body reflects `providerOptions` and `http.body` overrides of `format`.
-  const sent = context.body.type === "json" ? context.body.value.response_format : undefined
-  const format = typeof sent === "string" ? sent : "mp3"
-  return SpeechStream.finish(route, state, {
+  if (isSse(context.body) && !state.done) return Effect.fail(MediaProtocol.incomplete(ADAPTER))
+  const format = context.request.format ?? "mp3"
+  return SpeechStream.finish(ADAPTER, state, {
    ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
    usage: state.usage,
  })
@@ -132,8 +118,10 @@ const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) =
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>(route, {
-  unsupported: ["language"],
+export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["language", "timestamps"],
  body: { from: fromRequest },
  frames: (bytes, context) => (isSse(context.body) ? Framing.sse.frame(bytes) : bytes),
  initial: () => ({ chunks: [], done: false }),
@@ -143,7 +131,7 @@ export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint

 export const model = (input: MediaRoute.ModelInput) =>
  SpeechModel.fromRoute<OpenAISpeechOptions, string | Uint8Array, State>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
    input,
  )

@@ -1,9 +1,8 @@
 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 { AIError, mergeJsonRecords, type MediaUsage } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords, type MediaUsage } from "../schema/index.js"
 import {
  TranscriptionFinishEvent,
  TranscriptionModel,
@@ -17,7 +16,9 @@ import { mediaTypeExtension } from "../utils/media-type.js"
 import { ProviderShared } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "openai-transcription", name: "OpenAI Transcription", provider: "openai" })
+const ADAPTER = "openai-transcription"
+const NAME = "OpenAI Transcription"
+const PROVIDER = ProviderID.make("openai")
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/audio/transcriptions"

@@ -60,9 +61,6 @@ 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 }),
 ])
@@ -79,25 +77,16 @@ 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)
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, Event)
+const decodeTranscript = MediaProtocol.decodeFrame(ADAPTER, NAME, Transcript)

 type Frame = string | { readonly document: string }

@@ -131,23 +120,24 @@ 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 unsupported = (operation: string, message: string) =>
+  Effect.fail(ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route: ADAPTER, message }))

 const validate = (request: MediaProtocol.Addressed<Request>, model: Capabilities) => {
  const id = request.model.id
+  if (request.mode === "stream" && !model.stream)
+    return 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`))
+    return unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`)
  if (request.prompt !== undefined && model.diarize)
-    return Effect.fail(route.unsupported("media.prompt", `${id} does not accept a prompt`))
+    return unsupported("media.prompt", `${id} does not accept a prompt`)
  if (
    request.timestamps === undefined ||
    request.timestamps === "none" ||
    model.timestamps.includes(request.timestamps)
  )
    return Effect.void
-  return Effect.fail(route.unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`))
+  return unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`)
 }

 const RESERVED_FORM_FIELDS = new Set([
@@ -160,6 +150,11 @@ const RESERVED_FORM_FIELDS = new Set([
  "stream",
 ])

+const appendField = (form: FormData, key: string, value: unknown) => {
+  if (Array.isArray(value)) return value.forEach((item) => form.append(`${key}[]`, String(item)))
+  form.append(key, typeof value === "object" && value !== null ? ProviderShared.encodeJson(value) : String(value))
+}
+
 const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
  const model = capabilities(request.model.id)
  yield* validate(request, model)
@@ -167,18 +162,18 @@ const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (requ
  const extension = mediaTypeExtension(request.audio.mediaType)
  if (extension === undefined)
    return yield* ProviderShared.invalidRequest(
-      `${route.name} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`,
+      `${NAME} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`,
    )
-  const audio = yield* MediaInput.inlineBytes(route.id, request.audio)
+  const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio)
  const responseFormat = model.diarize
    ? "diarized_json"
    : request.timestamps === undefined || request.timestamps === "none"
      ? undefined
      : "verbose_json"
-  const form = new FormData()
-  form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`)
-  MediaInput.appendFields(
-    form,
+  const native = Object.entries(mergeJsonRecords(request.providerOptions, request.http?.body) ?? {}).filter(
+    ([key]) => !RESERVED_FORM_FIELDS.has(key),
+  )
+  const fields = mergeJsonRecords(
    {
      model: request.model.id,
      language: model.languageField === "language" ? request.language : undefined,
@@ -188,14 +183,13 @@ 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: streamsEvents(request) ? true : undefined,
-    },
-    {
-      overlay: mergeJsonRecords(request.providerOptions, request.http?.body),
-      reserved: RESERVED_FORM_FIELDS,
-      repeatArrays: true,
+      stream: request.mode === "stream" ? true : undefined,
    },
+    Object.fromEntries(native),
  )
+  const form = new FormData()
+  form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`)
+  Object.entries(fields ?? {}).forEach(([key, value]) => appendField(form, key, value))
  return MediaProtocol.multipart(form)
 })

@@ -211,15 +205,7 @@ 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
@@ -247,7 +233,7 @@ const usage = (value: Transcript["usage"]): MediaUsage | undefined => {

 const finish = (state: State) => {
  const transcript = state.transcript
-  if (transcript === undefined) return Effect.fail(route.incomplete())
+  if (transcript === undefined) return Effect.fail(MediaProtocol.incomplete(ADAPTER))
  const segments = transcript.segments?.map(segment) ?? state.segments
  return Effect.succeed([
    TranscriptionFinishEvent.make({
@@ -265,11 +251,13 @@ const finish = (state: State) => {
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, Frame, State>(route, {
+export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, Frame, State>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["speakers"],
  body: { from: fromRequest },
  frames: (bytes, context) =>
-    streamsEvents(context.request)
+    context.request.mode === "stream"
      ? Framing.sse.frame(bytes)
      : Framing.document.frame(bytes).pipe(Stream.map((document) => ({ document }))),
  initial: () => ({ segments: [] }),
@@ -279,7 +267,7 @@ export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, Frame,

 export const model = (input: MediaRoute.ModelInput) =>
  TranscriptionModel.fromRoute<OpenAITranscriptionOptions, Frame, State>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
    input,
  )

@@ -1,180 +0,0 @@
-import { Duration, Effect, Schema } from "effect"
-import type { HttpClientResponse } from "effect/unstable/http"
-import type { Status } from "../generation.js"
-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 AIError } from "../schema/index.js"
-import { ProviderShared, optionalNull } from "./shared.js"
-
-const route = MediaProtocol.identity({ id: "replicate-images", name: "Replicate", provider: "replicate" })
-export const DEFAULT_BASE_URL = "https://api.replicate.com"
-const OUTPUT_RETENTION = Duration.hours(1)
-const MAX_DATA_URL_BYTES = 256 * 1024
-
-// ---------------------------------------------------------------------------
-// 1. Public model input
-// ---------------------------------------------------------------------------
-
-/** Model-defined `input` fields under the model's own names; `Media.Asset` values lower to URLs or data URLs. */
-export type ReplicateImageOptions = Record<string, unknown>
-
-export type Request = ImageRequestFor<ReplicateImageOptions>
-
-// ---------------------------------------------------------------------------
-// 2. Token and response schemas
-// ---------------------------------------------------------------------------
-
-export const Token = Schema.Struct({ id: Schema.String, getURL: Schema.String, cancelURL: Schema.String })
-export type Token = Schema.Schema.Type<typeof Token>
-
-const Prediction = Schema.Struct({
-  id: Schema.String,
-  status: Schema.String,
-  output: optionalNull(Schema.Unknown),
-  error: optionalNull(Schema.Unknown),
-  data_removed: optionalNull(Schema.Boolean),
-  completed_at: optionalNull(Schema.String),
-  metrics: optionalNull(Schema.Struct({ predict_time: optionalNull(Schema.Number) })),
-  urls: Schema.Struct({ get: Schema.String, cancel: Schema.String }),
-})
-
-const Output = Schema.Union([Schema.String, Schema.Array(Schema.String)])
-const isOutput = Schema.is(Output)
-
-const STATUS = {
-  starting: "queued",
-  processing: "running",
-  succeeded: "completed",
-  failed: "failed",
-  canceled: "cancelled",
-  // The prediction hit its `Cancel-After` deadline before it started running.
-  aborted: "expired",
-} as const satisfies Record<string, Status>
-
-// ---------------------------------------------------------------------------
-// 5. Request body construction
-// ---------------------------------------------------------------------------
-
-// Official models run by `owner/name`; anything else (`owner/name:version` or a bare version id) is a pinned version.
-const isOfficial = (model: string) => /^[^/:]+\/[^/:]+$/.test(model)
-
-const inlineSize = (source: Media.Source) => {
-  if (source.type === "bytes") return source.data.byteLength
-  if (source.type === "base64") return source.data.length * 0.75
-  return 0
-}
-
-const fileInput = (asset: Media.Asset) => {
-  if (inlineSize(asset.source) > MAX_DATA_URL_BYTES)
-    return Effect.fail(
-      ProviderShared.invalidRequest(
-        `${route.name} data URL inputs are limited to 256 KB; pass a larger file by https URL`,
-      ),
-    )
-  return ProviderShared.mediaReference(asset, undefined, route.name).pipe(Effect.map((reference) => reference.value))
-}
-
-const inputValue = (value: unknown): Effect.Effect<unknown, AIError> => {
-  if (value instanceof Media.Asset) return fileInput(value)
-  if (Array.isArray(value) && value.some((item) => item instanceof Media.Asset))
-    return Effect.forEach(value, (item) => (item instanceof Media.Asset ? fileInput(item) : Effect.succeed(item)))
-  return Effect.succeed(value)
-}
-
-const fromRequest = Effect.fn("ReplicateImages.fromRequest")(function* (request: Request) {
-  const native = yield* Effect.forEach(Object.entries(request.providerOptions ?? {}), ([key, value]) =>
-    inputValue(value).pipe(Effect.map((lowered) => [key, lowered] as const)),
-  )
-  const input = mergeJsonRecords({ prompt: request.prompt }, Object.fromEntries(native))
-  const model = request.model.id
-  return MediaProtocol.json(
-    mergeJsonRecords(isOfficial(model) ? { input } : { version: model, input }, request.http?.body) ?? {},
-  )
-})
-
-// ---------------------------------------------------------------------------
-// 6. Response decoding
-// ---------------------------------------------------------------------------
-
-const decodePrediction = route.decodeJson(Prediction)
-
-const decodeStart = Effect.fn("ReplicateImages.decodeStart")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-) {
-  const output = yield* decodePrediction(response)
-  const prediction = output.value
-  return {
-    token: { id: prediction.id, getURL: prediction.urls.get, cancelURL: prediction.urls.cancel },
-    // `Prefer: wait` can return an already-finished prediction, so `await` skips straight to the result.
-    snapshot: { id: prediction.id, status: yield* MediaProtocol.status(STATUS, prediction.status, output) },
-  }
-})
-
-const decodeStatus = Effect.fn("ReplicateImages.decodeStatus")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<Token>,
-) {
-  const output = yield* decodePrediction(response)
-  return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) }
-})
-
-const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<Token>,
-) {
-  const output = yield* decodePrediction(response)
-  const prediction = output.value
-  const status = yield* MediaProtocol.status(STATUS, prediction.status, output)
-  if (status === "failed" || status === "cancelled" || status === "expired")
-    return yield* output.ended(
-      status,
-      `${route.name} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`,
-    )
-  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))
-    return yield* output.invalid(`${route.name} prediction ${context.token.id} returned output that is not image URLs`)
-  const urls = typeof prediction.output === "string" ? [prediction.output] : prediction.output
-  if (urls.length === 0) return yield* output.invalid(`${route.name} prediction ${context.token.id} returned no images`)
-  const predictTime = prediction.metrics?.predict_time ?? undefined
-  const completedAt = prediction.completed_at ?? undefined
-  const expiresAt =
-    completedAt === undefined ? undefined : Date.parse(completedAt) + Duration.toMillis(OUTPUT_RETENTION)
-  return new ImageResponse({
-    images: urls.map((url) => Media.url(url, { expiresAt })),
-    usage: predictTime === undefined ? undefined : { type: "compute", seconds: predictTime },
-    providerMetadata: { replicate: { predictionId: prediction.id } },
-  })
-})
-
-// ---------------------------------------------------------------------------
-// 7. Protocol and route
-// ---------------------------------------------------------------------------
-
-export const protocol = MediaProtocol.queued<Request, ImageResponse, Token>(route, {
-  token: Token,
-  unsupported: ["images", "mask", "n", "size", "aspectRatio", "seed", "format"],
-  start: { body: { from: fromRequest }, decode: decodeStart },
-  status: { path: (token) => token.getURL, decode: decodeStatus },
-  result: { path: (token) => token.getURL, decode: decodeResult },
-  cancel: { method: "POST", path: (token) => token.cancelURL },
-})
-
-export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<ReplicateImageOptions, Token>(
-    {
-      protocol,
-      baseURL: DEFAULT_BASE_URL,
-      path: ({ request }) =>
-        isOfficial(request.model.id) ? `/v1/models/${request.model.id}/predictions` : "/v1/predictions",
-    },
-    input,
-  )
-
-export const ReplicateImages = {
-  protocol,
-  model,
-} as const
@@ -4,11 +4,13 @@ import type { Status } from "../generation.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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js"
 import { ProviderShared, optionalArray, optionalNull } from "./shared.js"

-const route = MediaProtocol.identity({ id: "runway-video", name: "Runway", provider: "runway" })
+const ADAPTER = "runway-video"
+const NAME = "Runway"
+const PROVIDER = ProviderID.make("runway")
 export const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1"
 /** Every Runway request must pin the API version. */
 export const API_VERSION = "2024-11-06"
@@ -23,14 +25,16 @@ const OUTPUT_RETENTION = Duration.hours(24)
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type RunwayVideoString<Known extends string> = Known | (string & {})
+
 /**
 * Provider-native options. Common fields lower to Runway's names: `aspectRatio` → `ratio` (Runway expects pixel
 * ratios such as `1280:720` for most models), `durationSeconds` → `duration`, `audio`, `negativePrompt`,
 * `resolution`, `references`, and `frames` → `promptImage`.
 */
 export type RunwayVideoOptions = {
-  readonly contentModeration?: { readonly publicFigureThreshold?: OpenString<"auto" | "low"> }
-  readonly outputFormat?: OpenString<"mp4" | "prores" | "png_sequence">
+  readonly contentModeration?: { readonly publicFigureThreshold?: RunwayVideoString<"auto" | "low"> }
+  readonly outputFormat?: RunwayVideoString<"mp4" | "prores" | "png_sequence">
 } & Record<string, unknown>

 export type Request = VideoRequestFor<RunwayVideoOptions>
@@ -71,7 +75,7 @@ const STATUS = {

 // Runway accepts HTTPS URLs, `runway://` upload URIs, and data URIs, all as one string.
 const mediaUri = (asset: Media.Asset) =>
-  ProviderShared.mediaReference(asset, route.provider, route.name).pipe(Effect.map((reference) => reference.value))
+  ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => reference.value))

 const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request: Request) {
  const first = request.frames?.first === undefined ? undefined : yield* mediaUri(request.frames.first)
@@ -109,12 +113,12 @@ const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request: Req
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeStart = route.decodeStarted(StartResponse, (value) => ({
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
  token: { taskID: value.id },
  snapshot: { id: value.id, status: "queued" },
 }))

-const decodeTask = route.decodeJson(Task)
+const decodeTask = MediaProtocol.decodeJson(ADAPTER, NAME, Task)

 const decodeStatus = Effect.fn("RunwayVideo.decodeStatus")(function* (
  response: HttpClientResponse.HttpClientResponse,
@@ -134,16 +138,16 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (
  const status = yield* MediaProtocol.status(STATUS, task.status, output)
  if (status === "failed") {
    const code = task.failureCode ?? undefined
-    const message = `${route.name} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`
+    const message = `${NAME} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`
    // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
    if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code)) return yield* output.contentPolicy(message)
    return yield* output.ended("failed", message)
  }
  if (status === "cancelled")
-    return yield* output.ended("cancelled", `${route.name} task ${context.token.taskID} was cancelled`)
-  if (status !== "completed") return yield* output.pending(context.token.taskID)
+    return yield* output.ended("cancelled", `${NAME} task ${context.token.taskID} was cancelled`)
+  if (status !== "completed") return yield* output.invalid(`${NAME} task ${context.token.taskID} has not finished`)
  const urls = task.output ?? []
-  if (urls.length === 0) return yield* output.invalid(`${route.name} task succeeded without any output`)
+  if (urls.length === 0) return yield* output.invalid(`${NAME} task succeeded without any output`)
  return new VideoResponse({
    videos: yield* Effect.forEach(urls, (url) =>
      MediaProtocol.expiringUrl(url, OUTPUT_RETENTION, { mediaType: "video/mp4" }),
@@ -164,13 +168,15 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (

 const taskPath = (token: Token) => `${TASKS_PATH}/${token.taskID}`

-export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>(route, {
+export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>({
+  id: ADAPTER,
+  name: NAME,
  token: Token,
  unsupported: ["n"],
  start: { body: { from: fromRequest }, decode: decodeStart },
  status: { path: taskPath, decode: decodeStatus },
  result: { path: taskPath, decode: decodeResult },
-  cancel: { method: "DELETE", path: taskPath, activeOnly: true },
+  cancel: { method: "DELETE", path: taskPath },
 })

 const startPath = (request: Request) => {
@@ -182,6 +188,8 @@ const startPath = (request: Request) => {
 export const model = (input: MediaRoute.ModelInput) =>
  VideoModel.fromRoute<RunwayVideoOptions, Token>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      headers: { "X-Runway-Version": API_VERSION },
@@ -1,5 +1,6 @@
 import { Tool } from "@opencode/schema/tool"
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Schema, Stream } from "effect"
+import * as Sse from "effect/unstable/encoding/Sse"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { Media } from "../media.js"
 import {
@@ -12,16 +13,17 @@ import {
  ToolDefinition,
  type ContentPart,
  type MediaPart,
-  type OpenString,
  type ProviderID,
  type TextPart,
  type ToolEntry,
  type ToolResultPart,
 } from "../schema/index.js"
-import { Json, decodeJson, encodeJson } from "../utils/json.js"
 import { isRecord } from "../utils/record.js"
-export { Json, decodeJson, encodeJson, isRecord }
+export { isRecord }

+export const Json = Schema.fromJsonString(Schema.Unknown)
+export const decodeJson = Schema.decodeUnknownSync(Json)
+export const encodeJson = Schema.encodeSync(Json)
 const isJson = Schema.is(Schema.Json)
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown)
 export const optionalArray = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.Array(schema))
@@ -33,7 +35,7 @@ export const lenient = <const S extends Schema.Top>(schema: S) =>
  )
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
 export const knownString = <Known extends string>() =>
-  Schema.declare<OpenString<Known>>((value): value is OpenString<Known> => typeof value === "string", {
+  Schema.declare<Known | (string & {})>((value): value is Known | (string & {}) => typeof value === "string", {
    expected: "string",
  })

@@ -110,14 +112,6 @@ 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 }),
@@ -217,8 +211,7 @@ export const mediaReference = (
  if (provider !== undefined && asset.source.type === "ref" && asset.source.provider === provider)
    return Effect.succeed({ type: "ref", value: asset.source.id })
  const accepted = provider === undefined ? "" : `, and ${provider} references`
-  const got = asset.source.type === "ref" ? `; got ${asset.source.provider}:${asset.source.id}` : ""
-  return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}${got}`))
+  return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}`))
 }

 /**
@@ -235,6 +228,8 @@ export const toolFileMedia = (item: Tool.FileContent): MediaPart => {
  return Message.media(asset, { filename: item.name })
 }

+export const trimBaseUrl = (value: string) => value.replace(/\/+$/, "")
+
 export const toolResultText = (part: ToolResultPart) => {
  if (part.result.type === "text") return String(part.result.value)
  if (part.result.type === "error") {
@@ -256,6 +251,51 @@ export const errorText = (error: unknown) => {
  return "Unknown stream error"
 }

+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, optionally filters named events, and drops empty and bare `null`
+ * events. `[DONE]` is dropped by default or retained for protocols that use it
+ * as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
+ */
+export const sseFraming = (
+  bytes: Stream.Stream<Uint8Array, AIError>,
+  events?: ReadonlySet<string>,
+  includeDone = false,
+): Stream.Stream<string, AIError> =>
+  bytes.pipe(
+    Stream.decodeText(),
+    Stream.mapAccumEffect(
+      () => {
+        const output: Sse.Event[] = []
+        return {
+          output,
+          parser: Sse.makeParser((event) => {
+            if (event._tag === "Event") output.push(event)
+          }),
+        }
+      },
+      (state, chunk) =>
+        Effect.gen(function* () {
+          const error = state.parser.feed(chunk)
+          if (error) return yield* eventError("sse", error.message, chunk, error)
+          return [state, state.output.splice(0)] as const
+        }),
+    ),
+    Stream.filter(
+      (event) =>
+        (events === undefined || events.has(event.event)) &&
+        event.data.length > 0 &&
+        // Some OpenAI-compatible proxies serialize an empty flush as a bare
+        // `data: null`, between events or after `[DONE]`. No protocol has a
+        // null event, so it carries nothing and must not abort the stream.
+        event.data !== "null" &&
+        (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")),
+    ),
+    Stream.map((event) => event.data),
+  )
+
 /**
 * Canonical invalid-request constructor shared by protocol lowering.
 */
@@ -1,229 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { HttpClientResponse } from "effect/unstable/http"
-import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
-import { MediaProtocol } from "../route/media-protocol.js"
-import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type OpenString } from "../schema/index.js"
-import { ProviderShared } from "./shared.js"
-import { MediaInput } from "./utils/media-input.js"
-
-const route = MediaProtocol.identity({ id: "stability-images", name: "Stability AI", provider: "stability" })
-const upscaleRoute = MediaProtocol.identity({ id: "stability-upscale", name: "Stability AI", provider: "stability" })
-export const DEFAULT_BASE_URL = "https://api.stability.ai"
-const RESULTS_PATH = "/v2beta/results"
-const UPSCALE_MODEL = "creative"
-/** Base64 JSON instead of raw bytes, so the seed and finish reason arrive with the image. */
-const HEADERS = { accept: "application/json" }
-
-// ---------------------------------------------------------------------------
-// 1. Public model input
-// ---------------------------------------------------------------------------
-
-export type StabilityStylePreset = OpenString<
-  | "enhance"
-  | "anime"
-  | "photographic"
-  | "digital-art"
-  | "comic-book"
-  | "fantasy-art"
-  | "line-art"
-  | "analog-film"
-  | "neon-punk"
-  | "isometric"
-  | "low-poly"
-  | "origami"
-  | "modeling-compound"
-  | "cinematic"
-  | "3d-model"
-  | "pixel-art"
-  | "tile-texture"
->
-
-export type StabilityImageOptions = {
-  readonly negative_prompt?: string
-  readonly style_preset?: StabilityStylePreset
-  readonly strength?: number
-  readonly cfg_scale?: number
-} & Record<string, unknown>
-
-/** Creative upscale options; the one `images` source is the image to upscale. */
-export type StabilityUpscaleOptions = {
-  readonly negative_prompt?: string
-  readonly style_preset?: StabilityStylePreset
-  readonly creativity?: number
-} & Record<string, unknown>
-
-export type Request = ImageRequestFor<StabilityImageOptions>
-export type UpscaleRequest = ImageRequestFor<StabilityUpscaleOptions>
-
-// ---------------------------------------------------------------------------
-// 2. Token and response schemas
-// ---------------------------------------------------------------------------
-
-export const Token = Schema.Struct({ id: Schema.String })
-export type Token = Schema.Schema.Type<typeof Token>
-
-// Generate names the base64 image `image`; `/v2beta/results/{id}` names it `result`.
-const ImageDocument = Schema.Struct({
-  image: Schema.optional(Schema.String),
-  result: Schema.optional(Schema.String),
-  seed: Schema.optional(Schema.Number),
-  finish_reason: Schema.optional(Schema.String),
-})
-
-const Started = Schema.Struct({ id: Schema.String })
-
-// ---------------------------------------------------------------------------
-// 5. Request body construction
-// ---------------------------------------------------------------------------
-
-/** `sd3.5-*` ids share the `sd3` endpoint and select the model with a form field. */
-const endpoint = (model: string) => (model.startsWith("sd3") ? "sd3" : model)
-
-const RESERVED_FORM_FIELDS = new Set(["image", "prompt", "mode", "model"])
-
-const form = Effect.fn("StabilityImages.form")(function* (
-  identity: MediaProtocol.Identity,
-  fields: Record<string, unknown>,
-  native: Record<string, unknown> | undefined,
-  source: Request["images"],
-) {
-  if ((source?.length ?? 0) > 1)
-    return yield* identity.unsupported("media.images", `${identity.name} takes one source image`)
-  const body = new FormData()
-  MediaInput.appendFields(body, fields, { overlay: native, reserved: RESERVED_FORM_FIELDS })
-  const image = source?.[0]
-  if (image !== undefined)
-    body.append("image", MediaInput.blob(yield* MediaInput.inlineBytes(identity.id, image), image.mediaType), "image")
-  return MediaProtocol.multipart(body)
-})
-
-const fromRequest = Effect.fn("StabilityImages.fromRequest")(function* (request: Request) {
-  if (request.n !== undefined && request.n > 1)
-    return yield* route.unsupported("media.n", `${route.name} generates one image per request; call it once per image`)
-  const target = endpoint(request.model.id)
-  const edit = (request.images?.length ?? 0) > 0
-  if (edit && target === "core")
-    return yield* route.unsupported("media.images", `${route.name} core is text-to-image only; use ultra or sd3.5-*`)
-  return yield* form(
-    route,
-    {
-      prompt: request.prompt,
-      aspect_ratio: request.aspectRatio,
-      seed: request.seed,
-      output_format: request.format,
-      model: target === "sd3" ? request.model.id : undefined,
-      mode: target === "sd3" && edit ? "image-to-image" : undefined,
-    },
-    mergeJsonRecords(request.providerOptions, request.http?.body),
-    request.images,
-  )
-})
-
-const fromUpscaleRequest = Effect.fn("StabilityImages.fromUpscaleRequest")(function* (request: UpscaleRequest) {
-  if ((request.images?.length ?? 0) === 0)
-    return yield* ProviderShared.invalidRequest(`${upscaleRoute.name} upscale requires the source image in images`)
-  return yield* form(
-    upscaleRoute,
-    { prompt: request.prompt, seed: request.seed, output_format: request.format },
-    mergeJsonRecords(request.providerOptions, request.http?.body),
-    request.images,
-  )
-})
-
-// ---------------------------------------------------------------------------
-// 6. Response decoding
-// ---------------------------------------------------------------------------
-
-const decodeImageDocument = (identity: MediaProtocol.Identity) => {
-  const decode = identity.decodeJson(ImageDocument)
-  return Effect.fn("StabilityImages.decodeImage")(function* (response: HttpClientResponse.HttpClientResponse) {
-    const output = yield* decode(response)
-    const document = output.value
-    const data = document.image ?? document.result
-    if (data === undefined) return yield* output.invalid(`${identity.name} returned no image`)
-    const image = yield* MediaInput.decodedAsset(output.invalid, `${identity.name} result`, data, undefined)
-    return new ImageResponse({
-      images: [image],
-      notices:
-        document.finish_reason === "CONTENT_FILTERED"
-          ? [{ type: "moderated", message: `${identity.name} blurred the image for violating its content policy` }]
-          : undefined,
-      providerMetadata: { stability: { seed: document.seed, finishReason: document.finish_reason } },
-    })
-  })
-}
-
-const decodeResponse = decodeImageDocument(route)
-const decodeUpscaleImage = decodeImageDocument(upscaleRoute)
-
-const decodeStart = upscaleRoute.decodeStarted(Started, (value) => ({
-  token: { id: value.id },
-  snapshot: { id: value.id, status: "queued" },
-}))
-
-// `/v2beta/results/{id}` answers 202 while in progress and 200 with the finished image document.
-const decodeStatus = (response: HttpClientResponse.HttpClientResponse, context: MediaProtocol.PollContext<Token>) =>
-  Effect.succeed({
-    id: context.token.id,
-    status: response.status === 202 ? ("running" as const) : ("completed" as const),
-  })
-
-const decodeUpscaleResult = Effect.fn("StabilityImages.decodeUpscaleResult")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  context: MediaProtocol.PollContext<Token>,
-) {
-  if (response.status === 202) {
-    const output = yield* upscaleRoute.text(response)
-    return yield* output.pending(context.token.id)
-  }
-  return yield* decodeUpscaleImage(response)
-})
-
-// ---------------------------------------------------------------------------
-// 7. Protocol and route
-// ---------------------------------------------------------------------------
-
-export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
-  unsupported: ["size", "mask"],
-  body: { from: fromRequest },
-  response: { decode: decodeResponse },
-})
-
-export const upscaleProtocol = MediaProtocol.queued<UpscaleRequest, ImageResponse, Token>(upscaleRoute, {
-  token: Token,
-  unsupported: ["n", "size", "aspectRatio", "mask"],
-  start: { body: { from: fromUpscaleRequest }, decode: decodeStart },
-  status: { path: (token) => `${RESULTS_PATH}/${token.id}`, decode: decodeStatus },
-  result: { path: (token) => `${RESULTS_PATH}/${token.id}`, decode: decodeUpscaleResult },
-})
-
-export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<StabilityImageOptions>(
-    {
-      protocol,
-      baseURL: DEFAULT_BASE_URL,
-      headers: HEADERS,
-      path: ({ request }) => `/v2beta/stable-image/generate/${endpoint(request.model.id)}`,
-    },
-    input,
-  )
-
-export const upscaleModel = (input: Omit<MediaRoute.ModelInput, "id">) =>
-  ImageModel.fromRoute<StabilityUpscaleOptions, Token>(
-    {
-      protocol: upscaleProtocol,
-      baseURL: DEFAULT_BASE_URL,
-      headers: HEADERS,
-      // Only the creative upscaler is asynchronous; fast and conservative answer inline.
-      path: `/v2beta/stable-image/upscale/${UPSCALE_MODEL}`,
-    },
-    { ...input, id: UPSCALE_MODEL },
-  )
-
-export const StabilityImages = {
-  protocol,
-  upscaleProtocol,
-  model,
-  upscaleModel,
-} as const
@@ -1,91 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { HttpClientResponse } from "effect/unstable/http"
-import type { Status } from "../../generation.js"
-import type { Media } from "../../media.js"
-import { MediaProtocol } from "../../route/media-protocol.js"
-import type { AIError } from "../../schema/index.js"
-import { ProviderShared, optionalNull } from "../shared.js"
-
-export const DEFAULT_BASE_URL = "https://queue.fal.run"
-
-/** fal hands back absolute follow-up URLs on submit; they are authoritative for status, result, and cancel. */
-export const Token = Schema.Struct({
-  requestID: Schema.String,
-  statusURL: Schema.String,
-  responseURL: Schema.String,
-  cancelURL: Schema.String,
-})
-export type Token = Schema.Schema.Type<typeof Token>
-
-const StartResponse = Schema.Struct({
-  request_id: Schema.String,
-  status_url: Schema.String,
-  response_url: Schema.String,
-  cancel_url: Schema.String,
-  queue_position: optionalNull(Schema.Number),
-})
-
-const QueueStatus = Schema.Struct({
-  status: Schema.String,
-  queue_position: optionalNull(Schema.Number),
-  error: optionalNull(Schema.Unknown),
-})
-
-const STATUS = {
-  IN_QUEUE: "queued",
-  IN_PROGRESS: "running",
-  COMPLETED: "completed",
-} as const satisfies Record<string, Status>
-
-// fal accepts public URLs and data URIs; there is no provider file handle to forward.
-export const mediaUrl = (asset: Media.Asset, name: string) =>
-  ProviderShared.mediaReference(asset, undefined, name).pipe(Effect.map((reference) => reference.value))
-
-export const protocol = <Request, Response>(
-  route: MediaProtocol.Identity,
-  input: {
-    readonly unsupported?: ReadonlyArray<keyof Request & string>
-    readonly from: (request: Request) => Effect.Effect<MediaProtocol.Body, AIError>
-    readonly decodeResult: (
-      response: HttpClientResponse.HttpClientResponse,
-      context: MediaProtocol.PollContext<Token>,
-    ) => Effect.Effect<Response, AIError>
-  },
-) => {
-  const decodeQueueStatus = route.decodeJson(QueueStatus)
-  return MediaProtocol.queued<Request, Response, Token>(route, {
-    token: Token,
-    unsupported: input.unsupported,
-    start: {
-      body: { from: input.from },
-      decode: route.decodeStarted(StartResponse, (value) => ({
-        token: {
-          requestID: value.request_id,
-          statusURL: value.status_url,
-          responseURL: value.response_url,
-          cancelURL: value.cancel_url,
-        },
-        snapshot: { id: value.request_id, status: "queued", position: value.queue_position ?? undefined },
-      })),
-    },
-    status: {
-      path: (token) => token.statusURL,
-      decode: Effect.fn("FalQueue.decodeStatus")(function* (response, context) {
-        const output = yield* decodeQueueStatus(response)
-        const decoded = output.value
-        const status = yield* MediaProtocol.status(STATUS, decoded.status, output)
-        // fal reports request failures as COMPLETED with an `error`; the response endpoint carries the details.
-        const failed = status === "completed" && decoded.error !== undefined && decoded.error !== null
-        return {
-          id: context.token.requestID,
-          status: failed ? "failed" : status,
-          position: status === "queued" ? (decoded.queue_position ?? undefined) : undefined,
-        }
-      }),
-    },
-    result: { path: (token) => token.responseURL, decode: input.decodeResult },
-    cancel: { method: "PUT", path: (token) => token.cancelURL },
-  })
-}
-
-export * as FalQueue from "./fal-queue.js"
@@ -72,44 +72,6 @@ export const blocked = (name: string, chunk: Chunk, frame: string) => {
  })
 }

-const CONTENT_FILTER_REASONS = new Set([
-  "IMAGE_SAFETY",
-  "RECITATION",
-  "SAFETY",
-  "BLOCKLIST",
-  "PROHIBITED_CONTENT",
-  "SPII",
-  "MODEL_ARMOR",
-  "IMAGE_PROHIBITED_CONTENT",
-  "IMAGE_RECITATION",
-  "LANGUAGE",
-])
-
-/** Finish reasons for which Gemini stops output on safety or policy grounds. */
-export const contentFiltered = (finishReason: string | undefined) =>
-  finishReason !== undefined && CONTENT_FILTER_REASONS.has(finishReason)
-
-/** Callers check that the response produced no output: a policy stop after output is a partial result instead. */
-export const withheld = (name: string, chunk: Chunk, frame: string) => {
-  const finishReason = chunk.candidates?.[0]?.finishReason
-  if (!contentFiltered(finishReason)) return undefined
-  return new AIError({
-    reason: new ContentPolicyError({ message: `${name} withheld its output (${finishReason})`, body: frame }),
-  })
-}
-
-/** Any finish reason other than `STOP` means the output may be cut short, so it is surfaced rather than dropped. */
-export const notices = (name: string, state: Metadata): ReadonlyArray<Media.Notice> | undefined =>
-  state.finishReason === undefined || state.finishReason === "STOP"
-    ? undefined
-    : [
-        {
-          type: contentFiltered(state.finishReason) ? "filtered" : "other",
-          message: `${name} finished with ${state.finishReason}`,
-          providerMetadata: { google: { finishReason: state.finishReason } },
-        },
-      ]
-
 export const usage = (usage: UsageMetadata | undefined): MediaUsage | undefined =>
  usage === undefined
    ? undefined
@@ -1,77 +0,0 @@
-import type { JsonSchema } from "../../schema/index.js"
-import { isRecord } from "../../utils/record.js"
-
-// Gemini's `parametersJsonSchema` accepts standard JSON Schema, but rejects a few shapes that
-// published tool schemas commonly contain. Rewrite only those and send everything else unchanged.
-const SCHEMA_MAPS = new Set([
-  "properties",
-  "patternProperties",
-  "$defs",
-  "definitions",
-  "dependentSchemas",
-  "dependencies",
-])
-const VALUES = new Set(["const", "default", "enum", "examples", "dependentRequired"])
-
-const mapValues = (record: Record<string, unknown>, map: (value: unknown, key: string) => unknown) =>
-  Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value, key)]))
-
-const normalizeNode = (schema: unknown): unknown => {
-  if (Array.isArray(schema)) return schema.map(normalizeNode)
-  if (!isRecord(schema)) return schema
-  const properties = isRecord(schema.properties) ? schema.properties : undefined
-  return Object.fromEntries(
-    Object.entries(schema).flatMap(([key, value]) => {
-      if (VALUES.has(key)) return [[key, value]]
-      if (SCHEMA_MAPS.has(key) && isRecord(value)) return [[key, mapValues(value, normalizeNode)]]
-      // `required` may only name declared properties.
-      if (key === "required" && properties && Array.isArray(value))
-        return [[key, value.filter((name) => typeof name === "string" && Object.hasOwn(properties, name))]]
-      // Draft-04 boolean exclusive bounds become the numeric form.
-      if (key === "exclusiveMinimum" && typeof value === "boolean")
-        return value && typeof schema.minimum === "number" ? [[key, schema.minimum]] : []
-      if (key === "exclusiveMaximum" && typeof value === "boolean")
-        return value && typeof schema.maximum === "number" ? [[key, schema.maximum]] : []
-      if (key === "minimum" && schema.exclusiveMinimum === true) return []
-      if (key === "maximum" && schema.exclusiveMaximum === true) return []
-      // Draft-07 tuples (`items` array plus `additionalItems`) are `prefixItems` plus `items` in 2020-12.
-      if (key === "items" && Array.isArray(value)) return [["prefixItems", value.map(normalizeNode)]]
-      if (key === "additionalItems" && Array.isArray(schema.items)) return [["items", normalizeNode(value)]]
-      return [[key, normalizeNode(value)]]
-    }),
-  )
-}
-
-// Gemini accepts a recursive `$ref` only when the loop passes through an optional property or
-// potentially empty array `items`. Replace other self-references with an unconstrained schema.
-const cutLoops = (schema: unknown, target: string, safe: boolean): unknown => {
-  if (Array.isArray(schema)) return schema.map((item) => cutLoops(item, target, safe))
-  if (!isRecord(schema)) return schema
-  if (schema.$ref === target && !safe) return {}
-  const required = Array.isArray(schema.required) ? schema.required : []
-  return mapValues(schema, (value, key) => {
-    if (VALUES.has(key)) return value
-    if (key === "items") return cutLoops(value, target, safe || !(Number(schema.minItems) > 0))
-    if (key === "properties" && isRecord(value))
-      return mapValues(value, (child, name) => cutLoops(child, target, safe || !required.includes(name)))
-    if (SCHEMA_MAPS.has(key) && isRecord(value)) return mapValues(value, (child) => cutLoops(child, target, safe))
-    return cutLoops(value, target, safe)
-  })
-}
-
-export const normalize = (schema: JsonSchema): JsonSchema => {
-  const normalized = normalizeNode(schema)
-  if (!isRecord(normalized)) return {}
-  const result = cutLoops(
-    mapValues(normalized, (value, key) =>
-      (key === "$defs" || key === "definitions") && isRecord(value)
-        ? mapValues(value, (def, name) => cutLoops(def, `#/${key}/${name}`, false))
-        : value,
-    ),
-    "#",
-    false,
-  )
-  return isRecord(result) ? result : {}
-}
-
-export * as GeminiJsonSchema from "./gemini-json-schema.js"
@@ -0,0 +1,119 @@
+import { isRecord } from "../../utils/record.js"
+
+// Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
+// handful of common JSON Schema shapes. Keep this projection isolated so the
+// Gemini protocol file still reads like the other protocol modules.
+const SCHEMA_INTENT_KEYS = [
+  "type",
+  "properties",
+  "items",
+  "prefixItems",
+  "enum",
+  "const",
+  "$ref",
+  "additionalProperties",
+  "patternProperties",
+  "required",
+  "not",
+  "if",
+  "then",
+  "else",
+]
+
+const hasCombiner = (schema: unknown) =>
+  isRecord(schema) && (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf))
+
+const hasSchemaIntent = (schema: unknown) =>
+  isRecord(schema) && (hasCombiner(schema) || SCHEMA_INTENT_KEYS.some((key) => key in schema))
+
+const sanitizeNode = (schema: unknown): unknown => {
+  if (!isRecord(schema)) return Array.isArray(schema) ? schema.map(sanitizeNode) : schema
+
+  const result: Record<string, unknown> = Object.fromEntries(
+    Object.entries(schema).map(([key, value]) => [
+      key,
+      key === "enum" && Array.isArray(value) ? value.map(String) : sanitizeNode(value),
+    ]),
+  )
+
+  if (Array.isArray(result.enum) && (result.type === "integer" || result.type === "number")) result.type = "string"
+
+  const properties = result.properties
+  if (result.type === "object" && isRecord(properties) && Array.isArray(result.required)) {
+    result.required = result.required.filter((field) => typeof field === "string" && field in properties)
+  }
+
+  if (result.type === "array" && !hasCombiner(result)) {
+    result.items = result.items ?? {}
+    if (isRecord(result.items) && !hasSchemaIntent(result.items)) result.items = { ...result.items, type: "string" }
+  }
+
+  if (typeof result.type === "string" && result.type !== "object" && !hasCombiner(result)) {
+    delete result.properties
+    delete result.required
+  }
+
+  return result
+}
+
+const emptyObjectSchema = (schema: Record<string, unknown>) =>
+  schema.type === "object" &&
+  (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
+  !schema.additionalProperties
+
+const projectNode = (schema: unknown, nested = false): Record<string, unknown> | undefined => {
+  if (!isRecord(schema)) return undefined
+  if (!nested && emptyObjectSchema(schema)) return undefined
+  const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined
+  const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined
+  const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false
+  const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf
+  const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined
+  const result = Object.fromEntries(
+    [
+      ["description", schema.description],
+      ["required", schema.required],
+      ["format", schema.format],
+      ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+      [
+        "nullable",
+        (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+          ? true
+          : undefined,
+      ],
+      ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
+      [
+        "properties",
+        isRecord(schema.properties)
+          ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
+          : undefined,
+      ],
+      [
+        "items",
+        Array.isArray(schema.items)
+          ? schema.items.map((item) => projectNode(item, true))
+          : schema.items === undefined
+            ? undefined
+            : projectNode(schema.items, true),
+      ],
+      ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+      [
+        "anyOf",
+        anyOfTypes
+          ? hasNullAnyOf && anyOfTypes.length === 1
+            ? undefined
+            : anyOfTypes.map((item) => projectNode(item, true))
+          : types && types.length > 0
+            ? types.map((type) => ({ type }))
+            : undefined,
+      ],
+      ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
+      ["minLength", schema.minLength],
+    ].filter((entry) => entry[1] !== undefined),
+  )
+  return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result
+}
+
+export const convert = (schema: unknown) => projectNode(sanitizeNode(schema))
+
+export * as GeminiToolSchema from "./gemini-tool-schema.js"
@@ -1,8 +1,7 @@
 import { Effect, Encoding } from "effect"
 import { Media } from "../../media.js"
 import type { MediaProtocol } from "../../route/media-protocol.js"
-import { mergeJsonRecords, type AIError, type ProviderID } from "../../schema/index.js"
-import { encodeJson } from "../../utils/json.js"
+import type { AIError, ProviderID } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"

 /** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
@@ -35,11 +34,6 @@ export const query = (route: string, values: Record<string, unknown>): Effect.Ef
  )
 }

-export const dimensions = (size: string) => {
-  const [width, height] = size.split("x").map(Number)
-  return { width, height }
-}
-
 /** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
 export const refID = (asset: Media.Asset, provider: ProviderID) =>
  asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined
@@ -57,38 +51,4 @@ export const decodedAsset = (
    Effect.map((bytes) => Media.bytes(bytes, mediaType, options)),
  )

-/** One image of an OpenAI-shaped `data` array, which carries either `b64_json` or a `url`. */
-export const imageOutput = (
-  invalid: (message: string, cause?: unknown) => AIError,
-  label: string,
-  item: { readonly b64_json?: string | null; readonly url?: string | null },
-  mediaType: string | undefined,
-  options?: Media.AssetOptions,
-) => {
-  if (item.b64_json) return decodedAsset(invalid, label, item.b64_json, mediaType, options)
-  if (item.url) return Effect.succeed(Media.url(item.url, { ...options, mediaType }))
-  return Effect.fail(invalid(`${label} has neither image data nor a URL`))
-}
-
-/**
- * Append multipart text fields: strings as-is, other values as JSON, or arrays as repeated `key[]` parts with
- * `repeatArrays`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace route-owned fields.
- */
-export const appendFields = (
-  form: FormData,
-  fields: Record<string, unknown>,
-  options: {
-    readonly overlay?: Record<string, unknown>
-    readonly reserved: ReadonlySet<string>
-    readonly repeatArrays?: true
-  },
-) => {
-  const overlay = Object.entries(options.overlay ?? {}).filter(([key]) => !options.reserved.has(key))
-  Object.entries(mergeJsonRecords(fields, Object.fromEntries(overlay)) ?? {}).forEach(([key, value]) => {
-    if (Array.isArray(value) && options.repeatArrays)
-      return value.forEach((item) => form.append(`${key}[]`, String(item)))
-    form.append(key, typeof value === "string" ? value : encodeJson(value))
-  })
-}
-
 export * as MediaInput from "./media-input.js"
@@ -0,0 +1,11 @@
+// Responses image items can omit output_format, including when PNG/JPEG was requested.
+export const mediaType = (data: Uint8Array, format?: string) => {
+  if (format !== undefined) return `image/${format}`
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png"
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg"
+  if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
+    return "image/webp"
+  return "application/octet-stream"
+}
+
+export * as MetaImage from "./meta-image.js"
@@ -0,0 +1,20 @@
+import { Schema } from "effect"
+
+const dimensions = (value: string) => {
+  const match = /^(\d+)x(\d+)$/.exec(value)
+  if (!match) return undefined
+  return { width: Number(match[1]), height: Number(match[2]) }
+}
+
+export const Size = Schema.String.check(
+  Schema.makeFilter((value) => {
+    if (value === "auto") return undefined
+    const parsed = dimensions(value)
+    if (!parsed) return "image size must be `auto` or `{width}x{height}`"
+    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers"
+  }),
+)
+
+export const OpenAIImage = {
+  Size,
+} as const
@@ -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, LLMEvent, LLMRequest } from "../../schema/index.js"
+import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js"
 import { OpenResponses } from "../open-responses.js"
 import { ProviderShared } from "../shared.js"

@@ -109,8 +109,12 @@ export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
      transport: source.transport,
    })
    const native = yield* body.from(request)
-    const prepared = yield* route.prepareTransport(native, request, options)
-    yield* route.streamPrepared(prepared, request, { http: executor }, options).pipe(Stream.runDrain)
+    // 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)
    if (!result) return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint")
    return result
  })
@@ -19,18 +19,12 @@ 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(
@@ -80,27 +74,17 @@ const Response = Schema.Struct({
  usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
 })

-export const make = (
-  adapter: OpenResponses.ProviderAdapter,
-  lowerTools: (request: LLMRequest) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, AIError>,
-): CompactOperation =>
+export const make = (adapter: OpenResponses.ProviderAdapter): 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: 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,
+          service_tier: request.providerOptions?.serviceTier,
+          prompt_cache_key: ProviderShared.promptCacheKey(request),
        },
        request.http?.body,
      ),
@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import { Media } from "../../media.js"
-import type { MediaProtocol } from "../../route/media-protocol.js"
-import type { AIError, MediaUsage, ProviderMetadata } from "../../schema/index.js"
+import { MediaProtocol } from "../../route/media-protocol.js"
+import type { AIError, MediaUsage, ProviderID, ProviderMetadata } from "../../schema/index.js"
 import {
  SpeechAudioDeltaEvent,
  SpeechFinishEvent,
@@ -10,6 +10,7 @@ import {
  type SpeechVoice,
 } from "../../speech.js"
 import { concatBytes } from "../../utils/bytes.js"
+import { ProviderShared } from "../shared.js"

 export interface Audio {
  /** Appended in place: the route creates fresh state for each response through `initial`. */
@@ -77,28 +78,32 @@ export const sampleRate = (mediaType: string | undefined) => {
  return rate === undefined ? undefined : Number(rate)
 }

+export const unsupportedFormat = (provider: ProviderID, route: string, message: string) =>
+  ProviderShared.unsupportedOperation({ operation: "media.format", provider, route, message })
+
 /** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
 export const finish = (
-  route: MediaProtocol.Identity,
+  route: string,
  state: Audio,
  output: {
    readonly mediaType: string | undefined
    readonly info?: Media.Info
    readonly usage?: MediaUsage
-    readonly notices?: ReadonlyArray<Media.Notice>
    readonly providerMetadata?: ProviderMetadata
    readonly detail?: string
  },
 ): Effect.Effect<ReadonlyArray<SpeechEvent>, AIError> => {
  if (state.chunks.length === 0)
    return Effect.fail(
-      route.frameError(`The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`),
+      MediaProtocol.frameError(
+        route,
+        `The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`,
+      ),
    )
  return Effect.succeed([
    SpeechFinishEvent.make({
      audio: Media.bytes(concatBytes(state.chunks), output.mediaType, { info: output.info }),
      usage: output.usage,
-      notices: output.notices,
      providerMetadata: output.providerMetadata,
    }),
  ])
@@ -1,6 +1,6 @@
-import { ToolDefinition, type JsonSchema, type LanguageModel, type LLMRequest } from "../../schema/index.js"
+import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema/index.js"
 import { isRecord } from "../../utils/record.js"
-import { GeminiJsonSchema } from "./gemini-json-schema.js"
+import { GeminiToolSchema } from "./gemini-tool-schema.js"

 const tupleItemsSchema = (items: ReadonlyArray<unknown>) => {
  const projected = items.map(moonshotNode)
@@ -9,24 +9,12 @@ const tupleItemsSchema = (items: ReadonlyArray<unknown>) => {
  return { anyOf: projected }
 }

-// Moonshot rejects an `enum` without a sibling `type`. Its `type` may be one type, or one type plus "null".
-const enumType = (values: ReadonlyArray<unknown>) => {
-  const types = [
-    ...new Set(values.map((value) => (value === null ? "null" : Array.isArray(value) ? "array" : typeof value))),
-  ]
-  if (types.length === 1) return types[0]
-  if (types.length === 2 && types.includes("null")) return [...types.filter((type) => type !== "null"), "null"]
-  return undefined
-}
-
 const moonshotNode = (schema: unknown): unknown => {
  if (Array.isArray(schema)) return schema.map(moonshotNode)
  if (!isRecord(schema)) return schema
  if (typeof schema.$ref === "string") return { $ref: schema.$ref }
-  const type = schema.type === undefined && Array.isArray(schema.enum) ? enumType(schema.enum) : undefined
-  return Object.fromEntries([
-    ...(type === undefined ? [] : [["type", type]]),
-    ...Object.entries(schema).flatMap(([key, value]) => {
+  return Object.fromEntries(
+    Object.entries(schema).flatMap(([key, value]) => {
      if (key === "items" && Array.isArray(value)) return [[key, tupleItemsSchema(value)]]
      if (key === "prefixItems") {
        if ("items" in schema) return []
@@ -35,7 +23,7 @@ const moonshotNode = (schema: unknown): unknown => {
      if (key === "unevaluatedItems") return []
      return [[key, moonshotNode(value)]]
    }),
-  ])
+  )
 }

 const moonshot = (schema: JsonSchema): JsonSchema => {
@@ -46,59 +34,25 @@ const moonshot = (schema: JsonSchema): JsonSchema => {
 const openAI = (schema: JsonSchema): JsonSchema => schema
 const responses = openAI

-const gemini = GeminiJsonSchema.normalize
+const gemini = (schema: JsonSchema): JsonSchema => GeminiToolSchema.convert(schema) ?? {}

-const MODEL_NAMES = [
-  [/gemini/i, "gemini"],
-  [/kimi/i, "moonshot"],
-] as const
-
-// Tool arguments are always a JSON object, and most providers reject a tool schema whose root does not
-// declare `type: "object"`, such as `{}` or a bare `properties` map. Effect encodes an empty struct as
-// `anyOf` object or array; every object matches its bare object branch, so that `anyOf` is dropped.
-const objectRoot = (schema: JsonSchema): JsonSchema => {
-  if (schema.type !== undefined) return schema
-  if (
-    Array.isArray(schema.anyOf) &&
-    schema.anyOf.some((branch) => isRecord(branch) && branch.type === "object" && Object.keys(branch).length === 1)
-  )
-    return { type: "object", ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")) }
-  return { type: "object", ...schema }
-}
-
-// Every tool schema gets an object root. Then an explicit `sanitizer` wins, and `none` opts out.
-// 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): JsonSchema => {
-  const root = objectRoot(schema)
-  switch (
-    model.compatibility?.sanitizer ??
-    model.route.sanitizer ??
-    MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]
-  ) {
+const modelCompatibility = (
+  schema: JsonSchema,
+  compatibility: LanguageModelToolSchemaCompatibility | undefined,
+): JsonSchema => {
+  if (compatibility === undefined) return schema
+  switch (compatibility) {
    case "gemini":
-      return gemini(root)
+      return gemini(schema)
    case "moonshot":
-      return moonshot(root)
-    case "none":
-    case undefined:
-      return root
+      return moonshot(schema)
  }
 }

-// 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
@@ -4,11 +4,13 @@ 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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { MediaInput } from "./utils/media-input.js"

-const route = MediaProtocol.identity({ id: "xai-images", name: "xAI Images", provider: "xai" })
+const ADAPTER = "xai-images"
+const NAME = "xAI Images"
+const PROVIDER = ProviderID.make("xai")
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1"
 export const PATH = "/images/generations"
 export const EDIT_PATH = "/images/edits"
@@ -17,11 +19,13 @@ export const EDIT_PATH = "/images/edits"
 // 1. Public model input
 // ---------------------------------------------------------------------------

+export type XAIImageString<Known extends string> = Known | (string & {})
+
 /** Provider-native options. Common fields (`n`, `aspectRatio`, `images`) live on the request. */
 export type XAIImageOptions = {
-  readonly resolution?: OpenString<"1k" | "2k">
-  readonly responseFormat?: OpenString<"url" | "b64_json">
-  readonly response_format?: OpenString<"url" | "b64_json">
+  readonly resolution?: XAIImageString<"1k" | "2k">
+  readonly responseFormat?: XAIImageString<"url" | "b64_json">
+  readonly response_format?: XAIImageString<"url" | "b64_json">
 } & Record<string, unknown>

 export type Request = ImageRequestFor<XAIImageOptions>
@@ -55,7 +59,7 @@ const nativeOptions = (options: XAIImageOptions | undefined) => {
 const isEdit = (request: Request) => (request.images?.length ?? 0) > 0

 const reference = (asset: Media.Asset) =>
-  ProviderShared.mediaReference(asset, route.provider, route.name).pipe(
+  ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(
    Effect.map((item) =>
      item.type === "ref" ? { file_id: item.value } : { url: item.value, type: "image_url" as const },
    ),
@@ -84,25 +88,33 @@ const fromRequest = Effect.fn("XAIImages.fromRequest")(function* (request: Reque
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeDocument = route.decodeJson(XAIImageResponse)
-
 const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (
  response: HttpClientResponse.HttpClientResponse,
 ) {
-  const output = yield* decodeDocument(response)
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, XAIImageResponse)(response)
  const decoded = output.value
-  const images = yield* Effect.forEach(decoded.data, (item, index) =>
-    MediaInput.imageOutput(output.invalid, `${route.name} result ${index}`, item, item.mime_type ?? undefined, {
-      providerMetadata:
-        item.revised_prompt === undefined || item.revised_prompt === null
-          ? undefined
-          : { xai: { revisedPrompt: item.revised_prompt } },
-    }),
-  )
-  if (images.length === 0) return yield* output.invalid(`${route.name} returned no images`)
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    const providerMetadata =
+      item.revised_prompt === undefined || item.revised_prompt === null
+        ? undefined
+        : { xai: { revisedPrompt: item.revised_prompt } }
+    if (item.b64_json)
+      return MediaInput.decodedAsset(
+        output.invalid,
+        `${NAME} result ${index}`,
+        item.b64_json,
+        item.mime_type ?? undefined,
+        {
+          providerMetadata,
+        },
+      )
+    if (item.url)
+      return Effect.succeed(Media.url(item.url, { mediaType: item.mime_type ?? undefined, providerMetadata }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
  const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
-  // xAI reports a USD cost (`cost_in_usd_ticks`) rather than tokens, seconds, or credits; the raw record stays in
-  // provider metadata.
+  // xAI reports image counts rather than tokens, seconds, or credits; the raw record stays in provider metadata.
  return new ImageResponse({
    images,
    providerMetadata: usage === undefined ? undefined : { xai: { usage } },
@@ -113,7 +125,9 @@ const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["mask", "size", "seed", "format"],
  body: { from: fromRequest },
  response: { decode: decodeResponse },
@@ -121,7 +135,13 @@ export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {

 export const model = (input: MediaRoute.ModelInput) =>
  ImageModel.fromRoute<XAIImageOptions>(
-    { protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) },
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
+    },
    input,
  )

@@ -50,8 +50,7 @@ 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))
 })
@@ -94,8 +93,6 @@ export const protocol = Protocol.make({
  },
 })

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

 export * as XAIResponses from "./xai-responses.js"
@@ -4,11 +4,13 @@ import type { Status } from "../generation.js"
 import { Media } from "../media.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords } from "../schema/index.js"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js"
 import { ProviderShared, optionalNull } from "./shared.js"

-const route = MediaProtocol.identity({ id: "xai-video", name: "xAI Video", provider: "xai" })
+const ADAPTER = "xai-video"
+const NAME = "xAI Video"
+const PROVIDER = ProviderID.make("xai")
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1"
 export const PATH = "/videos/generations"
 export const EDIT_PATH = "/videos/edits"
@@ -70,7 +72,7 @@ const STATUS = {
 // ---------------------------------------------------------------------------

 const mediaInput = (asset: Media.Asset) =>
-  ProviderShared.mediaReference(asset, route.provider, route.name).pipe(
+  ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(
    Effect.map((reference) => (reference.type === "ref" ? { file_id: reference.value } : { url: reference.value })),
  )

@@ -109,7 +111,7 @@ const fromRequest = Effect.fn("XAIVideo.fromRequest")(function* (request: Reques
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeStart = route.decodeStarted(StartResponse, (value) => ({
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
  token: { requestID: value.request_id },
  snapshot: { id: value.request_id, status: "running" },
 }))
@@ -118,7 +120,7 @@ const decodeStart = route.decodeStarted(StartResponse, (value) => ({
 const fraction = (progress: number | null | undefined) =>
  progress !== undefined && progress !== null && progress >= 0 && progress <= 100 ? progress / 100 : undefined

-const decodeVideoStatus = route.decodeJson(VideoStatus)
+const decodeVideoStatus = MediaProtocol.decodeJson(ADAPTER, NAME, VideoStatus)

 const decodeStatus = Effect.fn("XAIVideo.decodeStatus")(function* (
  response: HttpClientResponse.HttpClientResponse,
@@ -136,26 +138,26 @@ 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.pending(context.token.requestID)
+  if (status === "running") return yield* output.invalid(`${NAME} request ${context.token.requestID} has not finished`)
  if (status === "failed") {
    const code = decoded.error?.code ?? undefined
    const message = decoded.error?.message ?? undefined
    return yield* output.ended(
      "failed",
-      `${route.name} generation failed${code === undefined ? "" : ` (${code})`}${message === undefined ? "" : `: ${message}`}`,
+      `${NAME} generation failed${code === undefined ? "" : ` (${code})`}${message === undefined ? "" : `: ${message}`}`,
    )
  }
  if (status !== "completed")
-    return yield* output.ended("expired", `${route.name} request ${context.token.requestID} expired`)
+    return yield* output.ended("expired", `${NAME} request ${context.token.requestID} expired`)
  // `respect_moderation: false` marks a filtered result; a URL may still be present, so report it as a notice.
  const notices =
    decoded.video?.respect_moderation === false
-      ? [{ type: "moderated" as const, message: `${route.name} flagged the generated video for moderation` }]
+      ? [{ type: "moderated" as const, message: `${NAME} flagged the generated video for moderation` }]
      : undefined
  const url = decoded.video?.url ?? undefined
  if (url === undefined && notices !== undefined)
-    return yield* output.contentPolicy(`${route.name} withheld the video for moderation`)
-  if (url === undefined) return yield* output.invalid(`${route.name} completed without a video URL`)
+    return yield* output.contentPolicy(`${NAME} withheld the video for moderation`)
+  if (url === undefined) return yield* output.invalid(`${NAME} completed without a video URL`)
  const duration = decoded.video?.duration ?? undefined
  return new VideoResponse({
    videos: [
@@ -175,7 +177,9 @@ const decodeResult = Effect.fn("XAIVideo.decodeResult")(function* (

 const statusPath = (token: Token) => `${STATUS_PATH}/${token.requestID}`

-export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>(route, {
+export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>({
+  id: ADAPTER,
+  name: NAME,
  token: Token,
  unsupported: ["n", "seed", "negativePrompt"],
  start: { body: { from: fromRequest }, decode: decodeStart },
@@ -192,6 +196,8 @@ const startPath = (request: Request) => {
 export const model = (input: MediaRoute.ModelInput) =>
  VideoModel.fromRoute<XAIVideoOptions, Token>(
    {
+      id: ADAPTER,
+      provider: PROVIDER,
      protocol,
      baseURL: DEFAULT_BASE_URL,
      path: ({ request }) => startPath(request),
@@ -1,22 +1,26 @@
-import { Duration, Effect, Schema } from "effect"
+import { 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"
+import { ProviderID, mergeJsonRecords } from "../schema/index.js"

-const route = MediaProtocol.identity({ id: "zai-images", name: "Z.ai Images", provider: "zai" })
+const ADAPTER = "zai-images"
+const NAME = "Z.ai Images"
+const PROVIDER = ProviderID.make("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
 // ---------------------------------------------------------------------------

+export type ZAIImageString<Known extends string> = Known | (string & {})
+
 /** Provider-native options. The common `size` field lives on the request. */
 export type ZAIImageOptions = {
-  readonly quality?: OpenString<"hd" | "standard">
+  readonly quality?: ZAIImageString<"hd" | "standard">
  readonly userID?: string
 } & Record<string, unknown>

@@ -65,25 +69,23 @@ const fromRequest = Effect.fn("ZAIImages.fromRequest")(function* (request: Reque
 // 6. Response decoding
 // ---------------------------------------------------------------------------

-const decodeDocument = route.decodeJson(ZAIImageResponse)
-
 const decodeResponse = Effect.fn("ZAIImages.decodeResponse")(function* (
  response: HttpClientResponse.HttpClientResponse,
 ) {
-  const output = yield* decodeDocument(response)
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, ZAIImageResponse)(response)
  const decoded = output.value
-  if (decoded.data.length === 0) return yield* output.invalid(`${route.name} returned no images`)
+  if (decoded.data.length === 0) return yield* output.invalid(`${NAME} returned no images`)
  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: yield* Effect.forEach(decoded.data, (item) => MediaProtocol.expiringUrl(item.url, OUTPUT_RETENTION)),
+    images: decoded.data.map((item) => Media.url(item.url)),
    // Z.ai reports applied content filters alongside a successful result; surface them instead of dropping them.
    notices:
      filters.length === 0
        ? undefined
        : filters.map((filter) => ({
            type: "moderated" as const,
-            message: `${route.name} applied a content filter${filter.role === undefined ? "" : ` for ${filter.role}`}${
+            message: `${NAME} applied a content filter${filter.role === undefined ? "" : ` for ${filter.role}`}${
              filter.level === undefined ? "" : ` at level ${filter.level}`
            }`,
            providerMetadata: { zai: filter },
@@ -103,14 +105,19 @@ const decodeResponse = Effect.fn("ZAIImages.decodeResponse")(function* (
 // 7. Protocol and route
 // ---------------------------------------------------------------------------

-export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
  unsupported: ["images", "mask", "n", "aspectRatio", "seed", "format"],
  body: { from: fromRequest },
  response: { decode: decodeResponse },
 })

 export const model = (input: MediaRoute.ModelInput) =>
-  ImageModel.fromRoute<ZAIImageOptions>({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input)
+  ImageModel.fromRoute<ZAIImageOptions>(
+    { id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH },
+    input,
+  )

 export const ZAIImages = {
  protocol,
@@ -80,19 +80,12 @@ const SERVER_CODES = new Set([
  "slow_down",
  "serviceunavailableexception",
 ])
-// `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",
-])
+const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "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.
 const CONTENT_POLICY_CODES = new Set([
  "content_filter",
-  "content_moderation",
  "responsibleaipolicyviolation",
  "content_policy_violation",
  "image_content_policy_violation",
@@ -211,8 +204,6 @@ function providerCodes(value: unknown) {
  const exception = isRecord(decoded.exception) ? decoded.exception : undefined
  return [
    decoded.code,
-    // Stability's `{ id, name, errors }` bodies carry the code in `name`.
-    Array.isArray(decoded.errors) ? decoded.name : undefined,
    decoded.error_type,
    error?.code,
    error?.type,
@@ -31,7 +31,6 @@ 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]

@@ -72,7 +71,6 @@ 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)
@@ -1,12 +1,12 @@
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { AssemblyAITranscription } from "../protocols/assemblyai-transcription.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { AssemblyAITranscription, DEFAULT_BASE_URL } from "../protocols/assemblyai-transcription.js"

 export type { AssemblyAITranscriptionOptions } from "../protocols/assemblyai-transcription.js"

 export const id = ProviderID.make("assemblyai")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  /** `https://api.eu.assemblyai.com` for the EU region. */
@@ -24,8 +24,14 @@ const auth = (options: ProviderAuthOption<"optional">) => {
 }

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const transcription = (modelID: string | ModelID) => AssemblyAITranscription.model({ ...media, id: modelID })
+  const transcription = (modelID: string | ModelID) =>
+    AssemblyAITranscription.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return {
    id,
    transcription,
@@ -1,11 +1,11 @@
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
+import { ProviderShared } from "../protocols/shared.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("azure")
@@ -108,7 +108,7 @@ const configuredRoute = <Body, Prepared, Compact extends CompactionOperations |
  })

 function endpoint(input: Config, modelID: string | ModelID) {
-  const baseURL = Endpoint.trimBaseUrl(input.baseURL ?? resourceBaseURL(input.resourceName!))
+  const baseURL = ProviderShared.trimBaseUrl(input.baseURL ?? resourceBaseURL(input.resourceName!))
  const query = { "api-version": input.apiVersion ?? "v1", ...input.queryParams }

  if (input.useDeploymentBasedUrls) return { baseURL: `${baseURL}/deployments/${modelID}`, query }
@@ -1,36 +0,0 @@
-import { Auth } from "../route/auth.js"
-import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { BlackForestLabsImages } from "../protocols/bfl-images.js"
-
-export type { BlackForestLabsImageOptions } from "../protocols/bfl-images.js"
-
-export const id = ProviderID.make("black-forest-labs")
-
-export type Config = ProviderAuthOption<"optional"> & {
-  /** `https://api.eu.bfl.ai` or `https://api.us.bfl.ai` pin inference to one region. */
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions.Input
-}
-
-const auth = (options: ProviderAuthOption<"optional">) => {
-  if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("BFL_API_KEY"))
-    .pipe(Auth.header("x-key"))
-}
-
-export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const image = (modelID: string | ModelID) => BlackForestLabsImages.model({ ...media, id: modelID })
-  return {
-    id,
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-export const image = provider.image
@@ -1,11 +1,11 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { CartesiaSpeech } from "../protocols/cartesia-speech.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { CartesiaSpeech, DEFAULT_BASE_URL } from "../protocols/cartesia-speech.js"

 export type { CartesiaEncoding, CartesiaSpeechOptions } from "../protocols/cartesia-speech.js"

 export const id = ProviderID.make("cartesia")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  readonly baseURL?: string
@@ -16,8 +16,14 @@ export type Config = ProviderAuthOption<"optional"> & {
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "CARTESIA_API_KEY")

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const speech = (modelID: string | ModelID) => CartesiaSpeech.model({ ...media, id: modelID })
+  const speech = (modelID: string | ModelID) =>
+    CartesiaSpeech.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return {
    id,
    speech,
@@ -1,14 +1,14 @@
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { DeepgramSpeech } from "../protocols/deepgram-speech.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { DEFAULT_BASE_URL, DeepgramSpeech } from "../protocols/deepgram-speech.js"
 import { DeepgramTranscription } from "../protocols/deepgram-transcription.js"

 export type { DeepgramEncoding, DeepgramSpeechOptions } from "../protocols/deepgram-speech.js"
 export type { DeepgramTranscriptionOptions } from "../protocols/deepgram-transcription.js"

 export const id = ProviderID.make("deepgram")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  readonly baseURL?: string
@@ -24,11 +24,17 @@ const auth = (options: ProviderAuthOption<"optional">) => {
 }

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
+  const media = (modelID: string | ModelID) => ({
+    id: modelID,
+    auth: auth(input),
+    baseURL: input.baseURL ?? baseURL,
+    headers: input.headers,
+    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+  })
  return {
    id,
-    speech: (modelID: string | ModelID) => DeepgramSpeech.model({ ...media, id: modelID }),
-    transcription: (modelID: string | ModelID) => DeepgramTranscription.model({ ...media, id: modelID }),
+    speech: (modelID: string | ModelID) => DeepgramSpeech.model(media(modelID)),
+    transcription: (modelID: string | ModelID) => DeepgramTranscription.model(media(modelID)),
    configure,
  }
 }
@@ -1,12 +1,12 @@
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { ElevenLabsSpeech } from "../protocols/elevenlabs-speech.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { DEFAULT_BASE_URL, ElevenLabsSpeech } from "../protocols/elevenlabs-speech.js"

 export type { ElevenLabsOutputFormat, ElevenLabsSpeechOptions } from "../protocols/elevenlabs-speech.js"

 export const id = ProviderID.make("elevenlabs")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  readonly baseURL?: string
@@ -22,8 +22,14 @@ const auth = (options: ProviderAuthOption<"optional">) => {
 }

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const speech = (modelID: string | ModelID) => ElevenLabsSpeech.model({ ...media, id: modelID })
+  const speech = (modelID: string | ModelID) =>
+    ElevenLabsSpeech.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return {
    id,
    speech,
@@ -1,14 +1,12 @@
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { FalImages } from "../protocols/fal-images.js"
-import { FalVideo } from "../protocols/fal-video.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { DEFAULT_BASE_URL, FalVideo } from "../protocols/fal-video.js"

-export type { FalImageOptions } from "../protocols/fal-images.js"
 export type { FalVideoOptions } from "../protocols/fal-video.js"

 export const id = ProviderID.make("fal")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  readonly baseURL?: string
@@ -25,15 +23,20 @@ const auth = (options: ProviderAuthOption<"optional">) => {
 }

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
+  const video = (modelID: string | ModelID) =>
+    FalVideo.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return {
    id,
-    image: (modelID: string | ModelID) => FalImages.model({ ...media, id: modelID }),
-    video: (modelID: string | ModelID) => FalVideo.model({ ...media, id: modelID }),
+    video,
    configure,
  }
 }

 export const provider = configure()
-export const image = provider.image
 export const video = provider.video
@@ -1,9 +1,8 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import { Gemini } from "../protocols/gemini.js"
 import { GoogleImages } from "../protocols/google-images.js"
 import { GoogleSpeech } from "../protocols/google-speech.js"
@@ -47,14 +46,20 @@ const configuredRoute = (input: Config) => {

 export const configure = (input: Config = {}) => {
  const route = configuredRoute(input)
-  const media = MediaRoute.deployment(input, auth(input))
+  const media = (modelID: string | ModelID) => ({
+    id: modelID,
+    auth: auth(input),
+    baseURL: input.baseURL,
+    headers: input.headers,
+    http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http)),
+  })
  return {
    id,
    model: (modelID: string | ModelID) => route.model<Gemini.ProviderOptionsInput>({ id: modelID }),
-    image: (modelID: string | ModelID) => GoogleImages.model({ ...media, id: modelID }),
-    video: (modelID: string | ModelID) => GoogleVideo.model({ ...media, id: modelID }),
-    speech: (modelID: string | ModelID) => GoogleSpeech.model({ ...media, id: modelID }),
-    transcription: (modelID: string | ModelID) => GoogleTranscription.model({ ...media, id: modelID }),
+    image: (modelID: string | ModelID) => GoogleImages.model(media(modelID)),
+    video: (modelID: string | ModelID) => GoogleVideo.model(media(modelID)),
+    speech: (modelID: string | ModelID) => GoogleSpeech.model(media(modelID)),
+    transcription: (modelID: string | ModelID) => GoogleTranscription.model(media(modelID)),
    configure,
  }
 }
@@ -6,7 +6,6 @@ export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js"
 export * as AssemblyAI from "./assemblyai.js"
 export * as Azure from "./azure.js"
 export * as Baseten from "./baseten.js"
-export * as BlackForestLabs from "./black-forest-labs.js"
 export * as Cartesia from "./cartesia.js"
 export * as Cerebras from "./cerebras.js"
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
@@ -32,9 +31,7 @@ export * as OpenAICompatible from "./openai-compatible.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
 export * as OpenCodeZen from "./opencode-zen.js"
 export * as OpenRouter from "./openrouter.js"
-export * as Replicate from "./replicate.js"
 export * as Runway from "./runway.js"
-export * as Stability from "./stability.js"
 export * as TogetherAI from "./togetherai.js"
 export * as TypeSafeAI from "./typesafe-ai.js"
 export * as VercelAIGateway from "./vercel-ai-gateway.js"
@@ -7,8 +7,7 @@ import { MetaImages } from "../protocols/meta-images.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { MediaRoute } from "../route/media.js"
-import { ProviderID, ToolDefinition, type ModelID, type OpenString } from "../schema/index.js"
+import { HttpOptions, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"

 export const id = ProviderID.make("meta")
@@ -49,8 +48,8 @@ export const webSearch = (options: WebSearchOptions = {}) =>

 export interface ImageGenerationOptions {
  readonly size?: string
-  readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">
-  readonly reasoningStrength?: OpenString<"low" | "high">
+  readonly outputFormat?: "webp" | "png" | "jpeg" | (string & {})
+  readonly reasoningStrength?: "low" | "high" | (string & {})
  readonly enableImageSearch?: boolean
  readonly enableWebSearch?: boolean
  readonly enableShell?: boolean
@@ -140,8 +139,14 @@ export const configure = (input: LanguageModelOptions = {}) => {
      id: modelID,
      compatibility: { requireSignature: false },
    })
-  const media = MediaRoute.deployment(input, options.auth)
-  const image = (modelID: string | ModelID) => MetaImages.model({ ...media, id: modelID })
+  const image = (modelID: string | ModelID) =>
+    MetaImages.model({
+      id: modelID,
+      baseURL: endpoint ?? baseURL,
+      auth: options.auth,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return { id, model: responses, responses, chat, messages, image, configure }
 }

@@ -113,19 +113,19 @@ export const configure = (input: Config = {}) => {
        supportsStore: false,
        supportsStrictMode: false,
        supportsPromptCacheKey: true,
-        sanitizer: "moonshot",
+        toolSchema: "moonshot",
        reasoningField: "reasoning_content",
      },
    })
  const messages = (modelID: string | ModelID) =>
    messagesRoute.with(defaults).model<MessagesOptionsInput>({
      id: modelID,
-      compatibility: { requireSignature: false, sanitizer: "moonshot" },
+      compatibility: { requireSignature: false, toolSchema: "moonshot" },
    })
  const responses = (modelID: string | ModelID) =>
    responsesRoute
      .with(defaults)
-      .model<ResponsesOptionsInput>({ id: modelID, compatibility: { sanitizer: "moonshot" } })
+      .model<ResponsesOptionsInput>({ id: modelID, compatibility: { toolSchema: "moonshot" } })
  return { id, model: chat, chat, messages, responses, configure }
 }

@@ -32,7 +32,10 @@ const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): Provide
  return result
 }

-export const gpt5DefaultOptions = (modelID: string): ProviderOptions | undefined => {
+export const gpt5DefaultOptions = (
+  modelID: string,
+  options: { readonly textVerbosity?: boolean } = {},
+): ProviderOptions | undefined => {
  const id = modelID.toLowerCase()
  if (!id.includes("gpt-5") || id.includes("gpt-5-chat") || id.includes("gpt-5-pro")) return undefined
  return openAIProviderOptions({
@@ -44,19 +47,27 @@ export const gpt5DefaultOptions = (modelID: string): ProviderOptions | undefined
    // 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): ProviderOptions | undefined =>
-  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID))
+export const openAIDefaultOptions = (
+  modelID: string,
+  options: { readonly textVerbosity?: boolean } = {},
+): ProviderOptions | undefined =>
+  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID, options))

 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), options.providerOptions),
+    providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID, defaults), options.providerOptions),
  }
 }

@@ -1,19 +1,11 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
-import { MediaRoute } from "../route/media.js"
 import type { ProviderPackage } from "../provider-package.js"
-import {
-  HttpOptions,
-  ProviderID,
-  ToolDefinition,
-  mergeHttpOptions,
-  type ModelID,
-  type OpenString,
-} from "../schema/index.js"
+import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
-import { OpenAIImages } from "../protocols/openai-images.js"
+import { OpenAIImages, type OpenAIImageString } from "../protocols/openai-images.js"
 import { OpenAISpeech } from "../protocols/openai-speech.js"
 import { OpenAITranscription } from "../protocols/openai-transcription.js"

@@ -37,14 +29,14 @@ export type Config = RouteDefaultsInput &
  }

 export interface ImageGenerationOptions {
-  readonly action?: OpenString<"auto" | "generate" | "edit">
-  readonly background?: OpenString<"auto" | "opaque" | "transparent">
-  readonly inputFidelity?: OpenString<"low" | "high">
+  readonly action?: OpenAIImageString<"auto" | "generate" | "edit">
+  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
+  readonly inputFidelity?: OpenAIImageString<"low" | "high">
  readonly outputCompression?: number
-  readonly outputFormat?: OpenString<"png" | "jpeg" | "webp">
+  readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">
  readonly partialImages?: number
-  readonly quality?: OpenString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
-  readonly size?: OpenString<
+  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
+  readonly size?: OpenAIImageString<
    "auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792"
  >
 }
@@ -100,24 +92,26 @@ export const configure = (input: Config = {}) => {
  const modelDefaults = defaults(input)
  const responses = (id: string | ModelID) =>
    responsesRoute
-      .with(withOpenAIOptions(id, modelDefaults))
+      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
      .model<OpenAIProviderOptionsInput>({ id })
  const chat = (id: string | ModelID) =>
    chatRoute.with(withOpenAIOptions(id, modelDefaults)).model<OpenAIProviderOptionsInput>({
      id,
      compatibility: { supportsPromptCacheKey: true },
    })
-  const deployment = MediaRoute.deployment(input, auth(input))
-  const media = {
-    ...deployment,
+  const media = (modelID: string | ModelID) => ({
+    id: modelID,
+    auth: auth(input),
+    baseURL: input.baseURL,
+    headers: input.headers,
    http: mergeHttpOptions(
-      deployment.http,
+      input.http === undefined ? undefined : HttpOptions.make(input.http),
      input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }),
    ),
-  }
-  const image = (modelID: string | ModelID) => OpenAIImages.model({ ...media, id: modelID })
-  const speech = (modelID: string | ModelID) => OpenAISpeech.model({ ...media, id: modelID })
-  const transcription = (modelID: string | ModelID) => OpenAITranscription.model({ ...media, id: modelID })
+  })
+  const image = (modelID: string | ModelID) => OpenAIImages.model(media(modelID))
+  const speech = (modelID: string | ModelID) => OpenAISpeech.model(media(modelID))
+  const transcription = (modelID: string | ModelID) => OpenAITranscription.model(media(modelID))

  return {
    id,
@@ -20,7 +20,7 @@ export const configure = (input: Options = {}) => {
      auth: AuthOptions.bearer(input, "OPENCODE_API_KEY"),
      baseURL: input.baseURL ?? baseURL,
      headers: input.headers,
-      http: HttpOptions.make(input.http),
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
    })
  return { id, experimental: { evaluation }, configure }
 }
@@ -3,27 +3,29 @@ import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { HttpOptions, ProviderID, type CacheHint, type ModelID, type OpenString } from "../schema/index.js"
+import { HttpOptions, ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
 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, ProviderShared } from "../protocols/shared.js"
+import { isRecord } from "../protocols/shared.js"

 export const id = ProviderID.make("openrouter")
 const baseURL = "https://openrouter.ai/api/v1"
 const ADAPTER = "openrouter"

+type OpenRouterString<Known extends string> = Known | (string & {})
+
 export interface OpenRouterProviderRouting {
  readonly [key: string]: unknown
  readonly order?: ReadonlyArray<string>
  readonly allow_fallbacks?: boolean
  readonly require_parameters?: boolean
-  readonly data_collection?: OpenString<"allow" | "deny">
+  readonly data_collection?: OpenRouterString<"allow" | "deny">
  readonly only?: ReadonlyArray<string>
  readonly ignore?: ReadonlyArray<string>
  readonly quantizations?: ReadonlyArray<string>
-  readonly sort?: OpenString<"price" | "throughput" | "latency">
+  readonly sort?: OpenRouterString<"price" | "throughput" | "latency">
  readonly max_price?: Readonly<{
    prompt?: number | string
    completion?: number | string
@@ -39,7 +41,7 @@ export type OpenRouterPlugin =
      id: "web"
      max_results?: number
      search_prompt?: string
-      engine?: OpenString<"native" | "exa">
+      engine?: OpenRouterString<"native" | "exa">
    }>
  | Readonly<{ id: "file-parser"; max_files?: number; pdf?: { engine?: string } }>
  | Readonly<{ id: "moderation" }>
@@ -56,7 +58,7 @@ export interface OpenRouterOptions {
  readonly reasoning?: Readonly<{
    enabled?: boolean
    exclude?: boolean
-    effort?: OpenString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">
+    effort?: OpenRouterString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">
    max_tokens?: number
  }>
  readonly usage?: boolean | Readonly<{ include: boolean }>
@@ -64,7 +66,7 @@ export interface OpenRouterOptions {
  readonly web_search_options?: Readonly<{
    max_results?: number
    search_prompt?: string
-    engine?: OpenString<"native" | "exa">
+    engine?: OpenRouterString<"native" | "exa">
  }>
 }

@@ -123,7 +125,7 @@ export const protocol = Protocol.make({
          return {
            ...body,
            messages,
-            ...bodyOptions(request.providerOptions, request.generation?.maxTokens),
+            ...bodyOptions(request.providerOptions),
          } as OpenRouterBody
        }),
      ),
@@ -143,14 +145,7 @@ const cacheControl = () => {
  }
 }

-// 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 bodyOptions = (input: unknown) => {
  const openrouter = isRecord(input) ? input : {}
  const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } =
    openrouter
@@ -169,7 +164,7 @@ const bodyOptions = (input: unknown, maxTokens: number | undefined) => {
    ...(isRecord(web_search_options) ? { web_search_options } : {}),
    ...(isRecord(debug) ? { debug } : {}),
    ...(typeof user === "string" ? { user } : {}),
-    ...(isRecord(reasoning) ? { reasoning: fitReasoning(reasoning, maxTokens) } : {}),
+    ...(isRecord(reasoning) ? { reasoning } : {}),
  }
 }

@@ -203,7 +198,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
      auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
      baseURL: input.baseURL ?? baseURL,
      headers: input.headers,
-      http: HttpOptions.make(input.http),
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
    })
  return {
    id,
@@ -1,30 +0,0 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { ReplicateImages } from "../protocols/replicate-images.js"
-
-export type { ReplicateImageOptions } from "../protocols/replicate-images.js"
-
-export const id = ProviderID.make("replicate")
-
-export type Config = ProviderAuthOption<"optional"> & {
-  readonly baseURL?: string
-  /** `{ Prefer: "wait=60" }` holds the submission open until the prediction finishes (up to 60 seconds). */
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions.Input
-}
-
-const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "REPLICATE_API_TOKEN")
-
-export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const image = (modelID: string | ModelID) => ReplicateImages.model({ ...media, id: modelID })
-  return {
-    id,
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-export const image = provider.image
@@ -1,11 +1,11 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { RunwayVideo } from "../protocols/runway-video.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { DEFAULT_BASE_URL, RunwayVideo } from "../protocols/runway-video.js"

 export type { RunwayVideoOptions } from "../protocols/runway-video.js"

 export const id = ProviderID.make("runway")
+const baseURL = DEFAULT_BASE_URL

 export type Config = ProviderAuthOption<"optional"> & {
  readonly baseURL?: string
@@ -16,8 +16,14 @@ export type Config = ProviderAuthOption<"optional"> & {
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "RUNWAYML_API_SECRET")

 export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  const video = (modelID: string | ModelID) => RunwayVideo.model({ ...media, id: modelID })
+  const video = (modelID: string | ModelID) =>
+    RunwayVideo.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
  return {
    id,
    video,
@@ -1,30 +0,0 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { MediaRoute } from "../route/media.js"
-import { type HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { StabilityImages } from "../protocols/stability-images.js"
-
-export type { StabilityImageOptions, StabilityUpscaleOptions } from "../protocols/stability-images.js"
-
-export const id = ProviderID.make("stability")
-
-export type Config = ProviderAuthOption<"optional"> & {
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions.Input
-}
-
-const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "STABILITY_API_KEY")
-
-export const configure = (input: Config = {}) => {
-  const media = MediaRoute.deployment(input, auth(input))
-  return {
-    id,
-    image: (modelID: string | ModelID) => StabilityImages.model({ ...media, id: modelID }),
-    upscale: () => StabilityImages.upscaleModel(media),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const image = provider.image
-export const upscale = provider.upscale
@@ -20,7 +20,7 @@ export const configure = (input: Options = {}) => {
      auth: AuthOptions.bearer(input, "TYPESAFE_API_KEY"),
      baseURL: input.baseURL ?? baseURL,
      headers: input.headers,
-      http: HttpOptions.make(input.http),
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
    })
  return { id, experimental: { evaluation }, configure }
 }
@@ -67,7 +67,7 @@ export const configure = (input: Options = {}) => {
    EvaluationModel.make<EvaluationOptions>({
      id: modelID,
      provider: id,
-      http: HttpOptions.make(input.http),
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
      route: {
        id: "vercel-evaluation",
        evaluate: (req, send) =>
@@ -1,8 +1,7 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { MediaRoute } from "../route/media.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
 import { XAIResponses } from "../protocols/xai-responses.js"
@@ -90,14 +89,20 @@ export const configure = (input: LanguageModelOptions = {}) => {
  const chatRoute = configuredChatRoute(input)
  const responses = (modelID: string | ModelID) => responsesRoute.model<XAIProviderOptionsInput>({ id: modelID })
  const chat = (modelID: string | ModelID) => chatRoute.model<XAIProviderOptionsInput>({ id: modelID })
-  const media = MediaRoute.deployment(input, auth(input))
+  const media = (modelID: string | ModelID) => ({
+    id: modelID,
+    auth: auth(input),
+    baseURL: input.baseURL ?? baseURL,
+    headers: input.headers,
+    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+  })
  return {
    id,
    model: responses,
    responses,
    chat,
-    image: (modelID: string | ModelID) => XAIImages.model({ ...media, id: modelID }),
-    video: (modelID: string | ModelID) => XAIVideo.model({ ...media, id: modelID }),
+    image: (modelID: string | ModelID) => XAIImages.model(media(modelID)),
+    video: (modelID: string | ModelID) => XAIVideo.model(media(modelID)),
    configure,
  }
 }
@@ -5,8 +5,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { MediaRoute } from "../route/media.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"

 export const id = ProviderID.make("zai")

@@ -49,8 +48,14 @@ export const configure = (input: Config = {}) => {
        auth: auth(input),
      })
      .model<ChatOptionsInput>({ id: modelID, compatibility: ZAIChat.compatibility })
-  const media = MediaRoute.deployment(input, auth(input))
-  const image = (modelID: string | ModelID) => ZAIImages.model({ ...media, id: modelID })
+  const image = (modelID: string | ModelID) =>
+    ZAIImages.model({
+      id: modelID,
+      auth: auth(input),
+      baseURL: input.baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })

  return {
    id,
@@ -1,15 +1,12 @@
-import { Config, Effect, Option, Redacted } from "effect"
+import { Config, Effect, Redacted } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AuthenticationError, AIError, type HttpOptions } from "../schema/index.js"
+import { AuthenticationError, InvalidRequestError, AIError, type HttpOptions } from "../schema/index.js"

 export class MissingCredentialError extends Error {
  readonly _tag = "MissingCredentialError"

-  constructor(
-    readonly source: string,
-    message = `Missing auth credential: ${source}`,
-  ) {
-    super(message)
+  constructor(readonly source: string) {
+    super(`Missing auth credential: ${source}`)
  }
 }

@@ -92,14 +89,7 @@ export const optional = (secret: Secret | undefined, source = "optional value")
    ? credential(Effect.fail(new MissingCredentialError(source)))
    : credentialFromSecret(secret, source)

-export const config = (name: string) =>
-  credential(
-    Effect.gen(function* () {
-      const secret = yield* Config.option(Config.redacted(name))
-      if (Option.isSome(secret) && Redacted.value(secret.value) !== "") return secret.value
-      return yield* Effect.fail(new MissingCredentialError(name, `${name} is not set`))
-    }),
-  )
+export const config = (name: string) => credentialFromSecret(Config.redacted(name), name)

 export const effect = (load: Effect.Effect<Redacted.Redacted, CredentialError>) => credential(load)

@@ -155,10 +145,15 @@ export function scheme(name: string, source?: Secret | Credential) {
 }

 const toAIError = (error: AuthError): AIError => {
-  if (error instanceof AIError) return error
-  const message =
-    error instanceof MissingCredentialError ? error.message : `Failed to resolve auth config: ${error.message}`
-  return new AIError({ reason: new AuthenticationError({ message, cause: error }) })
+  if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
+    return new AIError({
+      reason:
+        error instanceof MissingCredentialError
+          ? new AuthenticationError({ message: error.message, cause: error })
+          : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
+    })
+  }
+  return error
 }

 export const toEffect =
@@ -11,8 +11,7 @@ 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 { ToolSchemaProjection } from "../protocols/utils/tool-schema.js"
-import type { LanguageModelSanitizerCompatibility, ProtocolID, ProviderOptions } from "../schema/index.js"
+import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
  AIError,
  CompactionResponse,
@@ -58,7 +57,6 @@ 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 },
@@ -154,7 +152,7 @@ const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefault
    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
    http: mergeHttpOptions(
      base?.http,
-      HttpOptions.make(patch.http),
+      httpOptions(patch.http),
      headers === undefined ? undefined : new HttpOptions({ headers }),
    ),
  }
@@ -174,6 +172,11 @@ const mergeHeaders = (...items: ReadonlyArray<Record<string, string> | undefined
 export const generationOptions = (input: GenerationOptions.Input | undefined) =>
  input === undefined ? undefined : GenerationOptions.make(input)

+export const httpOptions = (input: HttpOptionsInput | undefined) => {
+  if (input === undefined) return input
+  return HttpOptions.make(input)
+}
+
 export interface Interface {
  readonly compact: CompactMethod
  readonly stream: StreamMethod
@@ -258,9 +261,7 @@ const unsupportedCompaction = (request: LLMRequest, mechanism: string | undefine
  })
 }

-export class LLMClientService extends Context.Service<LLMClientService, Interface>()("@opencode/LLMClient") {}
-export const Service = LLMClientService
-export type Service = LLMClientService
+export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}

 const resolveRequestOptions = (request: LLMRequest) => {
  const messages = normalizeToolHistory(request.messages)
@@ -390,7 +391,6 @@ 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({
@@ -562,9 +562,7 @@ const prepareRequest = (request: LLMRequest) => {
      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
    )
  const resolved = applyCachePolicy(
-    applyEffortUpdates(
-      LLMRequest.update(sanitized, { tools: ToolSchemaProjection.tools(dedupe(sanitized.tools), sanitized.model) }),
-    ),
+    applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })),
  )
  const headers = resolved.model.route.headers?.({ request: resolved })
  return headers === undefined
@@ -1,4 +1,5 @@
 import type { LLMRequest } from "../schema/index.js"
+import * as ProviderShared from "../protocols/shared.js"

 export interface EndpointInput<Body, Request = LLMRequest> {
  readonly request: Request
@@ -46,8 +47,6 @@ export const merge = <Body, Request = LLMRequest>(
  query: patch.query === undefined ? base.query : { ...base.query, ...patch.query },
 })

-export const trimBaseUrl = (value: string) => value.replace(/\/+$/, "")
-
 const renderPart = <Body, Request>(part: EndpointPart<Body, Request>, input: EndpointInput<Body, Request>) =>
  typeof part === "function" ? part(input) : part

@@ -55,7 +54,7 @@ export const render = <Body, Request = LLMRequest>(
  endpoint: Definition<Body, Request>,
  input: EndpointInput<Body, Request>,
 ) => {
-  const url = new URL(`${trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`)
+  const url = new URL(`${ProviderShared.trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`)
  for (const [key, value] of Object.entries(endpoint.query ?? {})) url.searchParams.set(key, value)
  return url
 }
@@ -19,8 +19,4 @@ export type HttpMiddleware = (
  handler: HttpHandler,
 ) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>

-export class RequestExecutorService extends Context.Service<RequestExecutorService, Interface>()(
-  "@opencode/AI/RequestExecutor",
-) {}
-export const Service = RequestExecutorService
-export type Service = RequestExecutorService
+export class Service extends Context.Service<Service, Interface>()("@opencode/AI/RequestExecutor") {}
@@ -255,20 +255,4 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e

 export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer))

-/** Run `fn` on every request: it sees the raw response before status classification, inside middleware already on `executor`, and outside per-call middleware. */
-export const middleware = (fn: HttpMiddleware, executor: Layer.Layer<Service> = fetchLayer): Layer.Layer<Service> =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const inner = yield* Service
-      return Service.of({
-        execute: (request, next) =>
-          inner.execute(
-            request,
-            next === undefined ? fn : (input, handler) => fn(input, (forwarded) => next(forwarded, handler)),
-          ),
-      })
-    }),
-  ).pipe(Layer.provide(executor))
-
 export * as RequestExecutor from "./executor.js"
@@ -1,6 +1,6 @@
-import { Effect, Stream } from "effect"
-import { makeParser, type Event } from "effect/unstable/encoding/Sse"
-import { AIError, InvalidProviderOutputError } from "../schema/index.js"
+import { Stream } from "effect"
+import * as ProviderShared from "../protocols/shared.js"
+import type { AIError } from "../schema/index.js"

 /**
 * Decode a streaming HTTP response body into provider-protocol frames.
@@ -25,75 +25,19 @@ export interface Definition<Frame> {
  readonly body?: (frame: Frame) => string | undefined
 }

-/**
- * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty events and known
- * keepalives that proxies send as data. `[DONE]` is dropped by default or
- * retained for protocols that use it as their stream boundary. Retry control events are ignored without
- * interrupting the stream. Decoder failures become provider output errors so
- * the public error channel stays `AIError`.
- */
-export const sseFraming = (
-  bytes: Stream.Stream<Uint8Array, AIError>,
-  events?: ReadonlySet<string>,
-  includeDone = false,
-): Stream.Stream<string, AIError> =>
-  bytes.pipe(
-    Stream.decodeText(),
-    Stream.mapAccumEffect(
-      () => {
-        const output: Event[] = []
-        return {
-          output,
-          parser: makeParser((event) => {
-            if (event._tag === "Event") output.push(event)
-          }),
-        }
-      },
-      (state, chunk) =>
-        Effect.gen(function* () {
-          const error = state.parser.feed(chunk)
-          if (error)
-            return yield* new AIError({
-              reason: new InvalidProviderOutputError({
-                route: "sse",
-                message: error.message,
-                body: chunk,
-                cause: error,
-              }),
-            })
-          return [state, state.output.splice(0)] as const
-        }),
-    ),
-    Stream.filter(
-      (event) =>
-        (events === undefined || events.has(event.event)) &&
-        event.data.length > 0 &&
-        // Some OpenAI-compatible proxies serialize an empty flush as a bare
-        // `data: null`, between events or after `[DONE]`. No protocol has a
-        // null event, so it carries nothing and must not abort the stream.
-        event.data !== "null" &&
-        // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
-        // keepalive comment as `data: : keepalive` while reasoning.
-        event.data !== ": keepalive" &&
-        (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")),
-    ),
-    Stream.map((event) => event.data),
-  )
-
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
-export const sse: Definition<string> = { id: "sse", frame: sseFraming }
+export const sse: Definition<string> = { id: "sse", frame: ProviderShared.sseFraming }

 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
 export const sseWithDone: Definition<string> = {
  id: "sse",
-  frame: (bytes) => sseFraming(bytes, undefined, true),
+  frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
 }

 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events: ReadonlySet<string>): Definition<string> => ({
  id: "sse",
-  frame: (bytes) => sseFraming(bytes, events),
+  frame: (bytes) => ProviderShared.sseFraming(bytes, events),
 })

 export const lines: Definition<string> = {
@@ -7,7 +7,7 @@ export type {
  RouteDefaultsInput,
  AnyRoute,
  Interface as LLMClientShape,
-  LLMClientService,
+  Service as LLMClientService,
  StreamOptions,
  CompactMethod,
  CompactionOperations,
@@ -9,9 +9,7 @@ import {
  HttpContext,
  InvalidProviderOutputError,
  InvalidRequestError,
-  ProviderID,
  ProviderInternalError,
-  UnsupportedOperationError,
 } from "../schema/index.js"

 // ---------------------------------------------------------------------------
@@ -63,7 +61,7 @@ export interface DecodeContext<Request> {
 export interface Inline<Request, Response> {
  readonly kind: "inline"
  readonly id: string
-  readonly provider: ProviderID
+  readonly name: string
  /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
  readonly unsupported?: ReadonlyArray<keyof Request & string>
  readonly body: { readonly from: (request: Request) => Effect.Effect<Body, AIError> }
@@ -76,9 +74,11 @@ export interface Inline<Request, Response> {
 }

 export const inline = <Request, Response>(
-  route: Identity,
-  input: Omit<Inline<Request, Response>, "kind" | "id" | "provider">,
-): Inline<Request, Response> => ({ kind: "inline", id: route.id, provider: route.provider, ...input })
+  input: Omit<Inline<Request, Response>, "kind">,
+): Inline<Request, Response> => ({
+  kind: "inline",
+  ...input,
+})

 /** What `start` learned from the submission response: the route-owned handle plus the first observation. */
 export interface Started<Token> {
@@ -88,13 +88,11 @@ export interface Started<Token> {

 /**
 * A follow-up call's inputs: the decoded token and the auth headers the route sent, so a protocol can attach them
- * to output URLs that require the same credentials to download (Veo). `materialize` downloads an output through the
- * route's executor, for URLs that expire too soon to hand back (BFL).
+ * to output URLs that require the same credentials to download (Veo).
 */
 export interface PollContext<Token> {
  readonly token: Token
  readonly auth: Record<string, string>
-  readonly materialize: (asset: Media.Asset) => Effect.Effect<Media.Asset, AIError>
 }

 /**
@@ -107,7 +105,7 @@ export interface PollContext<Token> {
 export interface Queued<Request, Response, Token> {
  readonly kind: "queued"
  readonly id: string
-  readonly provider: ProviderID
+  readonly name: string
  /** Common request fields this protocol cannot lower; the route rejects them before `start.body.from` runs. */
  readonly unsupported?: ReadonlyArray<keyof Request & string>
  /** Serializable handle. `Generation.token` carries the encoded form so it can be persisted and resumed elsewhere. */
@@ -137,18 +135,15 @@ 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
  }
 }

 export const queued = <Request, Response, Token>(
-  route: Identity,
-  input: Omit<Queued<Request, Response, Token>, "kind" | "id" | "provider">,
-): Queued<Request, Response, Token> => ({ kind: "queued", id: route.id, provider: route.provider, ...input })
+  input: Omit<Queued<Request, Response, Token>, "kind">,
+): Queued<Request, Response, Token> => ({
+  kind: "queued",
+  ...input,
+})

 export type Mode = "generate" | "stream"

@@ -165,7 +160,7 @@ export interface ResponseContext<Request> extends DecodeContext<Addressed<Reques
 export interface Streamed<Request, Event, Frame, State> {
  readonly kind: "stream"
  readonly id: string
-  readonly provider: ProviderID
+  readonly name: string
  /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
  readonly unsupported?: ReadonlyArray<keyof Request & string>
  readonly body: { readonly from: (request: Addressed<Request>) => Effect.Effect<Body, AIError> }
@@ -180,9 +175,11 @@ export interface Streamed<Request, Event, Frame, State> {
 }

 export const stream = <Request, Event, Frame, State>(
-  route: Identity,
-  input: Omit<Streamed<Request, Event, Frame, State>, "kind" | "id" | "provider">,
-): Streamed<Request, Event, Frame, State> => ({ kind: "stream", id: route.id, provider: route.provider, ...input })
+  input: Omit<Streamed<Request, Event, Frame, State>, "kind">,
+): Streamed<Request, Event, Frame, State> => ({
+  kind: "stream",
+  ...input,
+})

 // ---------------------------------------------------------------------------
 // Response helpers
@@ -191,107 +188,71 @@ export const stream = <Request, Event, Frame, State>(
 const context = (response: HttpClientResponse.HttpClientResponse) =>
  new HttpContext({ url: response.request.url, status: response.status, headers: response.headers })

-/** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
-export const identity = (input: { readonly id: string; readonly name: string; readonly provider: string }) => {
-  const provider = ProviderID.make(input.provider)
-  const frameError = (message: string, body?: string, cause?: unknown) =>
-    new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, cause }) })
-
-  /**
-   * 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); `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)
-    const body = yield* response.text.pipe(
-      Effect.mapError(
-        (cause) =>
-          new AIError({
-            reason: new InvalidProviderOutputError({
-              route: input.id,
-              message: `Failed to read the ${input.name} response`,
-              http,
-              cause,
-            }),
-          }),
-      ),
-    )
-    return {
-      body,
-      http,
-      invalid: (message: string, cause?: unknown) =>
-        new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, http, cause }) }),
-      ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) =>
+/**
+ * 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.
+ */
+export const text = Effect.fn("MediaProtocol.text")(function* (
+  route: string,
+  name: string,
+  response: HttpClientResponse.HttpClientResponse,
+) {
+  const http = context(response)
+  const body = yield* response.text.pipe(
+    Effect.mapError(
+      (cause) =>
        new AIError({
-          reason:
-            status === "failed"
-              ? 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,
+          reason: new InvalidProviderOutputError({
+            route,
+            message: `Failed to read the ${name} response`,
            http,
+            cause,
          }),
        }),
-      contentPolicy: (message: string) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
-    }
-  })
-
-  /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
-  const decodeJson = <A>(schema: Schema.Codec<A, unknown>) => {
-    const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema))
-    return Effect.fn("MediaProtocol.decodeJson")(function* (response: HttpClientResponse.HttpClientResponse) {
-      const output = yield* text(response)
-      const value = yield* decode(output.body).pipe(
-        Effect.mapError((cause) => output.invalid(`${input.name} returned an invalid response`, cause)),
-      )
-      return { ...output, value }
-    })
-  }
-
+    ),
+  )
  return {
-    id: input.id,
-    name: input.name,
-    provider,
-    text,
-    decodeJson,
-    /** Decode a submission response into the token and first snapshot. */
-    decodeStarted: <A, Token>(schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => {
-      const decode = decodeJson(schema)
-      return (response: HttpClientResponse.HttpClientResponse) =>
-        decode(response).pipe(Effect.map((output) => started(output.value)))
-    },
-    /** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
-    decodeFrame: <A>(schema: Schema.Codec<A, unknown>) => {
-      const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema))
-      return (frame: string) =>
-        decode(frame).pipe(
-          Effect.mapError((cause) => frameError(`${input.name} sent an invalid stream event`, frame, cause)),
-        )
-    },
-    /** A stream-time failure; the frame stays on `reason.body`. */
-    frameError,
-    incomplete: () =>
+    body,
+    http,
+    invalid: (message: string, cause?: unknown) =>
+      new AIError({ reason: new InvalidProviderOutputError({ route, message, body, http, cause }) }),
+    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) =>
      new AIError({
-        reason: new InvalidProviderOutputError({
-          route: input.id,
-          message: "The provider response ended unexpectedly.",
-          classification: "incomplete-stream",
-        }),
+        reason:
+          status === "failed"
+            ? new ProviderInternalError({ message, body, http })
+            : new InvalidRequestError({ message, body, http }),
      }),
-    unsupported: (operation: string, message: string) =>
-      new AIError({ reason: new UnsupportedOperationError({ operation, provider, route: input.id, message }) }),
+    contentPolicy: (message: string) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
  }
+})
+
+export type Output = Effect.Success<ReturnType<typeof text>>
+
+/** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
+export const decodeJson = <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema))
+  return Effect.fn("MediaProtocol.decodeJson")(function* (response: HttpClientResponse.HttpClientResponse) {
+    const output = yield* text(route, name, response)
+    const value = yield* decode(output.body).pipe(
+      Effect.mapError((cause) => output.invalid(`${name} returned an invalid response`, cause)),
+    )
+    return { ...output, value }
+  })
 }

-export type Identity = ReturnType<typeof identity>
-
-export type Output = Effect.Success<ReturnType<Identity["text"]>>
+/** Decode a submission response into the token and first snapshot. */
+export const decodeStarted = <A, Token>(
+  route: string,
+  name: string,
+  schema: Schema.Codec<A, unknown>,
+  started: (value: A) => Started<Token>,
+) => {
+  const decode = decodeJson(route, name, schema)
+  return (response: HttpClientResponse.HttpClientResponse) =>
+    decode(response).pipe(Effect.map((output) => started(output.value)))
+}

 /** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
 export const status = <Table extends Record<string, Status>>(
@@ -299,8 +260,30 @@ export const status = <Table extends Record<string, Status>>(
  raw: string,
  output: Output,
 ): Effect.Effect<Status, AIError> => {
-  if (!Object.hasOwn(table, raw)) return Effect.fail(output.invalid(`Unknown generation status "${raw}"`))
-  return Effect.succeed(table[raw])
+  const normalized: Status | undefined = table[raw]
+  if (normalized === undefined) return Effect.fail(output.invalid(`Unknown generation status "${raw}"`))
+  return Effect.succeed(normalized)
+}
+
+export const frameError = (route: string, message: string, body?: string, cause?: unknown) =>
+  new AIError({ reason: new InvalidProviderOutputError({ route, message, body, cause }) })
+
+export const incomplete = (route: string) =>
+  new AIError({
+    reason: new InvalidProviderOutputError({
+      route,
+      message: "The provider response ended unexpectedly.",
+      classification: "incomplete-stream",
+    }),
+  })
+
+/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+export const decodeFrame = <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema))
+  return (frame: string) =>
+    decode(frame).pipe(
+      Effect.mapError((cause) => frameError(route, `${name} sent an invalid stream event`, frame, cause)),
+    )
 }

 /** A `url` asset whose provider-declared retention window starts now. */
@@ -2,21 +2,19 @@ import { Effect, Schema, Stream } from "effect"
 import { Headers, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import { Auth, type AuthInput } from "./auth.js"
 import { Endpoint } from "./endpoint.js"
-import { RequestExecutorService, type Interface } from "./executor-service.js"
+import type { Interface } from "./executor-service.js"
 import { RequestExecutor } from "./executor.js"
 import { MediaProtocol } from "./media-protocol.js"
-import { Generation, isTerminal } from "../generation.js"
-import type { Media } from "../media.js"
+import { Generation, type Route as GenerationRoute } from "../generation.js"
+import { ProviderShared } from "../protocols/shared.js"
 import {
  AIError,
  AIErrorReason,
  HttpOptions,
  InvalidRequestError,
  ProviderID,
-  UnsupportedOperationError,
  mergeHttpOptions,
 } from "../schema/index.js"
-import { encodeJson } from "../utils/json.js"
 import { sanitizeSurrogates } from "../utils/sanitize.js"

 export type Execute = Interface["execute"]
@@ -36,23 +34,12 @@ export interface ModelInput {
  readonly http?: HttpOptions
 }

-/** A provider facade's `configure(...)` input as the `ModelInput` every media selector shares, minus the model id. */
-export const deployment = (
-  input: { readonly baseURL?: string; readonly headers?: Record<string, string>; readonly http?: HttpOptions.Input },
-  auth: Auth.Definition,
-): Omit<ModelInput, "id"> => ({
-  auth,
-  baseURL: input.baseURL,
-  headers: input.headers,
-  http: HttpOptions.make(input.http),
-})
-
 // ---------------------------------------------------------------------------
 // Routes
 // ---------------------------------------------------------------------------

 /** One request, one response. */
-export interface InlineRoute<Request extends MediaRequest, Response> {
+export interface Route<Request extends MediaRequest, Response> {
  readonly kind: "inline"
  readonly id: string
  readonly provider: ProviderID
@@ -85,12 +72,9 @@ export interface StreamRoute<Request extends MediaRequest, Event, Response> {
  readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>
 }

-export type AnyRoute<Request extends MediaRequest, Event, Response> =
-  | InlineRoute<Request, Response>
-  | StreamRoute<Request, Event, Response>
-  | QueuedRoute<Request, Response>
-
 export interface Composition<Request extends MediaRequest> {
+  readonly id: string
+  readonly provider: string | ProviderID
  readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>
  readonly auth: Auth.Definition
  /** Deployment headers applied before transport authentication. */
@@ -119,12 +103,12 @@ export interface StreamInput<Request extends MediaRequest, Event, Response, Fram
 */
 export const inline = <Request extends MediaRequest, Response>(
  input: InlineInput<Request, Response>,
-): InlineRoute<Request, Response> => {
+): Route<Request, Response> => {
  const transport = makeTransport(input)
  return {
    kind: "inline",
-    id: input.protocol.id,
-    provider: input.protocol.provider,
+    id: input.id,
+    provider: transport.provider,
    protocol: input.protocol.id,
    generate: Effect.fn(`MediaRoute.generate`)(function* (request: Request, execute: Execute) {
      const submitted = yield* transport.submit(
@@ -152,8 +136,6 @@ export const queued = <Request extends MediaRequest, Response, Token>(
  const encodeToken = Schema.encodeSync(protocol.token)

  const generationRoute = (token: Token, http: HttpOptions | undefined, execute: Execute) => {
-    const materialize = (asset: Media.Asset) =>
-      asset.materialize().pipe(Effect.provideService(RequestExecutorService, { execute }))
    const poll = <A>(operation: {
      readonly path: (token: Token) => string
      readonly decode: (
@@ -163,21 +145,17 @@ 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)
+        .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth })))
    const cancel = protocol.cancel
-    const send =
-      cancel === undefined
-        ? undefined
-        : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid)
-    return {
-      status,
+    const route: GenerationRoute<Response> = {
+      status: poll(protocol.status),
      result: poll(protocol.result),
      cancel:
-        send !== undefined && cancel?.activeOnly
-          ? status.pipe(Effect.flatMap((snapshot) => (isTerminal(snapshot.status) ? Effect.void : send)))
-          : send,
+        cancel === undefined
+          ? undefined
+          : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid),
    }
+    return route
  }

  const start = Effect.fn("MediaRoute.start")(function* (request: Request, execute: Execute) {
@@ -201,7 +179,7 @@ export const queued = <Request extends MediaRequest, Response, Token>(
        (cause) =>
          new AIError({
            reason: new InvalidRequestError({
-              message: `${protocol.id} cannot resume a generation from this token`,
+              message: `${input.id} cannot resume a generation from this token`,
              cause,
            }),
          }),
@@ -211,7 +189,7 @@ export const queued = <Request extends MediaRequest, Response, Token>(
    return new Generation(route, encodeToken(token), yield* route.status)
  })

-  return { kind: "queued", id: protocol.id, provider: protocol.provider, protocol: protocol.id, start, resume }
+  return { kind: "queued", id: input.id, provider: transport.provider, protocol: protocol.id, start, resume }
 }

 /** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
@@ -263,8 +241,8 @@ export const stream = <Request extends MediaRequest, Event, Response, Frame, Sta
    )
  return {
    kind: "stream",
-    id: protocol.id,
-    provider: protocol.provider,
+    id: input.id,
+    provider: transport.provider,
    protocol: protocol.id,
    stream: (request, execute) => events(request, execute, "stream"),
    generate: (request, execute) =>
@@ -276,13 +254,12 @@ export const stream = <Request extends MediaRequest, Event, Response, Frame, Sta
 // Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------

-const makeTransport = <Request extends MediaRequest>(
-  input: Composition<Request> & { readonly protocol: { readonly id: string; readonly provider: ProviderID } },
-) => {
+const makeTransport = <Request extends MediaRequest>(input: Composition<Request>) => {
+  const provider = ProviderID.make(input.provider)
  const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers })
  const authorize = Auth.toEffect(input.auth)
-  const baseURL = (path: string) => new URL(`${Endpoint.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`)
-  /** `auth` is only what `Auth` added or changed, never untouched deployment headers. */
+  const baseURL = (path: string) => new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`)
+  /** `auth` is only what `Auth` added, never deployment headers. */
  const send = Effect.fn("MediaRoute.send")(function* (
    call: {
      readonly method: AuthInput["method"]
@@ -305,12 +282,10 @@ const makeTransport = <Request extends MediaRequest>(
    const response = yield* execute(
      encoded.apply(HttpClientRequest.make(call.method)(url).pipe(HttpClientRequest.setHeaders(headers))),
    )
-    return {
-      response,
-      auth: Object.fromEntries(Object.entries(headers).filter(([key, value]) => encoded.headers[key] !== value)),
-    }
+    return { response, auth: Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in call.headers))) }
  })
  return {
+    provider,
    /** Route and model overlays; `start` additionally merges the request's own `http`. */
    http: (model: MediaRequest["model"]) => mergeHttpOptions(routeHttp, model.http),
    /** POST the protocol body to the route endpoint. */
@@ -323,7 +298,7 @@ const makeTransport = <Request extends MediaRequest>(
      },
      execute: Execute,
    ) {
-      yield* rejectUnsupported(input.protocol.id, input.protocol.provider, request, protocol.unsupported)
+      yield* rejectUnsupported(input.id, provider, request, protocol.unsupported)
      const http = mergeHttpOptions(routeHttp, request.model.http, request.http)
      const headers = Headers.fromInput(http?.headers)
      const prepared =
@@ -368,7 +343,7 @@ const withQuery = (url: URL, query: MediaProtocol.Query | undefined) => {
 const encode = (body: MediaProtocol.Body | undefined, headers: Headers.Headers) => {
  if (body === undefined) return { text: "", headers, apply: (request: HttpClientRequest.HttpClientRequest) => request }
  if (body.type === "json") {
-    const text = encodeJson(body.value)
+    const text = ProviderShared.encodeJson(body.value)
    return { text, headers, apply: HttpClientRequest.bodyText(text, "application/json") }
  }
  if (body.type === "binary")
@@ -385,11 +360,7 @@ const encode = (body: MediaProtocol.Body | undefined, headers: Headers.Headers)
  }
 }

-/**
- * 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.
- */
+/** Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. */
 const rejectUnsupported = <Request extends object>(
  route: string,
  provider: ProviderID,
@@ -402,13 +373,11 @@ const rejectUnsupported = <Request extends object>(
  })
  if (present.length === 0) return Effect.void
  return Effect.fail(
-    new AIError({
-      reason: new UnsupportedOperationError({
-        operation: `media.${present[0]}`,
-        provider,
-        route,
-        message: `${provider}/${route} does not support ${present.join(", ")}`,
-      }),
+    ProviderShared.unsupportedOperation({
+      operation: `media.${present[0]}`,
+      provider,
+      route,
+      message: `${provider}/${route} does not support ${present.join(", ")}`,
    }),
  )
 }
@@ -1,5 +1,5 @@
 import { Schema, type Effect } from "effect"
-import type { AIError, LanguageModelSanitizerCompatibility, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js"
+import type { AIError, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js"

 /**
 * The semantic API contract of one model server family.
@@ -43,8 +43,6 @@ 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> {
--- a/Show More
+++ b/Show More