chore: update nix node_modules hashes

Co-authored-by: Brendan Allan <14191578+Brendonovich@users.noreply.github.com>

.github/workflows/publish.yml

@@ -281,7 +281,6 @@ jobs:
 
   build-electron:
     needs:
-      - build-cli
       - version
     if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
     continue-on-error: false
@@ -378,16 +377,14 @@ jobs:
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-          OPENCODE_CLI_ARTIFACT: ${{ (runner.os == 'Windows' && 'opencode-cli-windows') || 'opencode-cli' }}
           RUST_TARGET: ${{ matrix.settings.target }}
-          GH_TOKEN: ${{ github.token }}
-          GITHUB_RUN_ID: ${{ github.run_id }}
 
       - name: Build
         run: bun run build
         working-directory: packages/desktop
         env:
           NODE_OPTIONS: --max-old-space-size=4096
+          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: ${{ vars.SENTRY_ORG }}
@@ -405,8 +402,7 @@ jobs:
         env:
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           GH_TOKEN: ${{ steps.committer.outputs.token }}
-          CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
-          CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          CSC_KEYCHAIN: build.keychain
           APPLE_API_KEY: ${{ runner.temp }}/apple-api-key.p8
           APPLE_API_KEY_ID: ${{ secrets.APPLE_API_KEY }}
           APPLE_API_ISSUER: ${{ secrets.APPLE_API_ISSUER }}

.opencode/skills/rtl-aware-development/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: rtl-aware-development
+description: OpenCode Desktop should be RTL-aware. Use when implementing or reviewing RTL/LTR behavior in the web app, desktop app, CSS, menus, scrolling, resizing, icons, mixed-direction text, or Electron title bars.
+---
+
+# RTL-Aware Development
+
+Treat direction as independent from language. Test English in both directions as well as real RTL and mixed-script content.
+
+## Guidelines
+
+- Set `lang` and `dir` on the document, and propagate direction through component providers used by portaled menus and popovers. Do not change the selected locale merely to force RTL.
+- Keep DOM and focus order semantic. Flexbox and Grid already follow `dir`; do not add `row-reverse`, CSS `order`, or reversed markup just to mirror a layout.
+- Prefer logical CSS for semantic layout. Reserve physical coordinates for pointer positions, canvas geometry, native window controls, and other genuinely physical placement.
+
+```css
+/* Avoid */
+padding-left: 12px;
+right: 0;
+border-right: 1px solid;
+text-align: left;
+
+/* Prefer */
+padding-inline-start: 12px;
+inset-inline-end: 0;
+border-inline-end: 1px solid;
+text-align: start;
+```
+
+- Isolate mixed-direction text. Use `dir="auto"` or `<bdi>` for unknown text; keep code, URLs, IDs, and filesystem paths LTR without forcing the surrounding component LTR.
+
+```html
+<span class="file-row"><bdi dir="auto">README.md</bdi></span> <bdi dir="ltr"><code>C:\src\app.ts</code></bdi>
+```
+
+- Mirror directional meaning, not every image. Back/forward, previous/next, disclosure, indentation, and directional progress may need mirroring. Do not mirror brands, clocks, media controls, charts, or text. Reverse physical gradients, `translateX`, SVG transforms, and animation deltas explicitly.
+- Map interactions through direction. `clientX` remains physical; resizing a logical edge needs an RTL-aware delta. Logical previous/next keyboard controls may swap ArrowLeft/ArrowRight. Follow the relevant WAI-ARIA widget pattern.
+- Do not assume LTR scrolling. RTL `scrollLeft` can start at `0` and become negative. Prefer `scrollIntoView({ inline: "nearest" })` or a tested direction-normalizing helper.
+- For Electron title bars, prefer native caption controls and use `titleBarOverlay` plus `env(titlebar-area-*)` for the safe content rectangle. Keep Windows/macOS native-control avoidance and `trafficLightPosition` physical; keep app navigation inside that rectangle logical. Mark interactive titlebar children `app-region: no-drag`.
+- Verify behavior, not screenshots alone. Check computed styles, pseudo-element geometry, hit zones, focus order, keyboard behavior, submenu direction, zoom/scaling, and both LTR and RTL scroll endpoints.
+
+## Test Matrix
+
+- English + LTR
+- English + forced RTL
+- A real RTL locale + RTL
+- Mixed RTL/LTR content, long labels, numbers, code, and paths
+- Keyboard, pointer resize, scrolling, menus/submenus, and Electron titlebar controls in both directions
+
+## References
+
+- [RTL Styling 101, Ahmad Shadeed](https://rtlstyling.com/posts/rtl-styling/)
+- [CSS-Tricks: RTL Styling 101](https://css-tricks.com/rtl-styling-101/)
+- [CSS-Tricks: CSS Logical Properties and Values](https://css-tricks.com/css-logical-properties-and-values/)
+- [W3C: Structural markup and right-to-left text](https://www.w3.org/International/questions/qa-html-dir)
+- [W3C: Inline bidirectional markup](https://www.w3.org/International/articles/inline-bidi-markup/)
+- [MDN: CSS logical properties and values](https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Logical_properties_and_values)
+- [MDN: `dir`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/dir)
+- [MDN: `scrollLeft`](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft)
+- [web.dev: Logical properties](https://web.dev/learn/css/logical-properties/)
+- [Electron: Custom title bar](https://www.electronjs.org/docs/latest/tutorial/custom-title-bar)
+- [WAI-ARIA: Window splitter pattern](https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/)
+- [Kobalte: I18n Provider](https://kobalte.dev/docs/core/components/i18n-provider/)

CONTRIBUTING.md

@@ -252,33 +252,6 @@ These are not strictly enforced, they are just general guidelines:
 
 For net-new functionality, start with a design conversation. Open an issue describing the problem, your proposed approach (optional), and why it belongs in OpenCode. The core team will help decide whether it should move forward; please wait for that approval instead of opening a feature PR directly.
 
-## Trust & Vouch System
-
-This project uses [vouch](https://github.com/mitchellh/vouch) to manage contributor trust. The vouch list is maintained in [`.github/VOUCHED.td`](.github/VOUCHED.td).
-
-### How it works
-
-- **Vouched users** are explicitly trusted contributors.
-- **Denounced users** are explicitly blocked. Issues and pull requests from denounced users are automatically closed. If you have been denounced, you can request to be unvouched by reaching out to a maintainer on [Discord](https://opencode.ai/discord)
-- **Everyone else** can participate normally — you don't need to be vouched to open issues or PRs.
-
-### For maintainers
-
-Collaborators with write access can manage the vouch list by commenting on any issue:
-
-- `vouch` — vouch for the issue author
-- `vouch @username` — vouch for a specific user
-- `denounce` — denounce the issue author
-- `denounce @username` — denounce a specific user
-- `denounce @username <reason>` — denounce with a reason
-- `unvouch` / `unvouch @username` — remove someone from the list
-
-Changes are committed automatically to `.github/VOUCHED.td`.
-
-### Denouncement policy
-
-Denouncement is reserved for users who repeatedly submit low-quality AI-generated contributions, spam, or otherwise act in bad faith. It is not used for disagreements or honest mistakes.
-
 ## Issue Requirements
 
 All issues **must** use one of our issue templates:

infra/console.ts

@@ -288,8 +288,12 @@ new sst.cloudflare.x.SolidStart("Console", {
     server: {
       placement: { region: "aws:us-east-2" },
       transform: {
-        worker: {
-          tailConsumers: [{ service: logProcessor.nodes.worker.scriptName }],
+        worker: (args) => {
+          args.compatibilityFlags = $resolve(args.compatibilityFlags).apply((flags) => [
+            ...(flags ?? []),
+            "global_fetch_strictly_public",
+          ])
+          args.tailConsumers = [{ service: logProcessor.nodes.worker.scriptName }]
         },
       },
     },

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-RFek0QoEEjsgbqmTE/SxQAmPtYyzs0IPR2ugFn5Okrs=",
-    "aarch64-linux": "sha256-BmAxapY1YrAFn7mVq3/6A9+6Au5UIvSqBboHMkyJH3I=",
-    "aarch64-darwin": "sha256-Sx3bGWQqLlgoa/RudJxanjSzhFRNklckT2ffnO2I5F4=",
-    "x86_64-darwin": "sha256-CMOhiisHNowg06qadvgg4K+60zrynglwiT0qKYQ4NiA="
+    "x86_64-linux": "sha256-F/oXgpvv6R+pcgGDZreaGizTwgf9XBJRbssRdAPu+oc=",
+    "aarch64-linux": "sha256-i36RvDX3UTaJKVM9aVNwlBkyOak3BTaCUArBxmtagm0=",
+    "aarch64-darwin": "sha256-vyCB+fo8arL1f4BINZDychAvw+A/IBoHd99zRI1BGik=",
+    "x86_64-darwin": "sha256-JorAz8VIEzWGaNk5RJNvlR3w2JWRmosuHBKTgbEIv/k="
   }
 }

package.json

@@ -2,25 +2,18 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode",
   "description": "AI-powered development tool",
-  "version": "0.0.0",
   "private": true,
   "type": "module",
   "packageManager": "bun@1.3.14",
   "scripts": {
-    "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
-    "dev:live": "OPENCODE_TUI_CHANNEL=next OPENCODE_PASSWORD=\"$(opencode2 service get password)\" bun run dev --server \"$(opencode2 service status)\"",
+    "dev": "bun run --cwd packages/opencode --conditions=browser src/index.ts",
     "dev:desktop": "bun --cwd packages/desktop dev",
     "dev:web": "bun --cwd packages/app dev",
     "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
-    "dev:www": "bun run --cwd packages/www dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "lint": "oxlint",
-    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/util/src packages/core/src packages/server/src packages/protocol/src packages/cli/src",
-    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
-    "typecheck": "bun turbo typecheck --concurrency=3",
-    "typecheck:profile": "bun script/profile-typecheck.ts",
-    "typecheck:profile:packages": "bun script/profile-typecheck-packages.ts",
+    "typecheck": "bun turbo typecheck",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
     "prepare": "husky",
@@ -34,24 +27,25 @@
       "packages/*",
       "packages/console/*",
       "packages/stats/*",
+      "packages/sdk/js",
       "packages/slack"
     ],
     "catalog": {
-      "@effect/opentelemetry": "4.0.0-beta.101",
-      "@effect/platform-node": "4.0.0-beta.101",
-      "@effect/sql-sqlite-bun": "4.0.0-beta.101",
+      "@effect/opentelemetry": "4.0.0-beta.83",
+      "@effect/platform-node": "4.0.0-beta.83",
+      "@effect/sql-sqlite-bun": "4.0.0-beta.83",
       "@npmcli/arborist": "9.4.0",
       "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
+      "@standard-schema/spec": "1.0.0",
       "@opentui/core": "0.4.5",
       "@opentui/keymap": "0.4.5",
       "@opentui/solid": "0.4.5",
       "@tanstack/solid-virtual": "3.13.32",
       "@shikijs/stream": "4.2.0",
-      "@standard-schema/spec": "1.1.0",
       "ulid": "3.0.1",
       "@kobalte/core": "0.13.11",
       "@corvu/drawer": "0.2.4",
@@ -70,15 +64,14 @@
       "dompurify": "3.3.1",
       "drizzle-kit": "1.0.0-rc.2",
       "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-beta.101",
+      "effect": "4.0.0-beta.83",
       "ai": "6.0.168",
       "cross-spawn": "7.0.6",
       "hono": "4.10.7",
       "hono-openapi": "1.1.2",
       "fuzzysort": "3.1.0",
-      "get-east-asian-width": "1.6.0",
       "luxon": "3.6.1",
-      "marked": "17.0.6",
+      "marked": "18.0.7",
       "marked-shiki": "1.2.1",
       "remend": "1.3.0",
       "@playwright/test": "1.59.1",
@@ -87,11 +80,9 @@
       "@typescript/native-preview": "7.0.0-dev.20251207.1",
       "zod": "4.1.8",
       "remeda": "2.26.0",
-      "resolve.exports": "2.0.3",
       "sst": "4.13.1",
       "shiki": "4.2.0",
       "solid-list": "0.3.0",
-      "string-width": "7.2.0",
       "tailwindcss": "4.1.11",
       "vite": "7.1.4",
       "@solidjs/meta": "0.29.4",
@@ -100,15 +91,14 @@
       "@sentry/solid": "10.36.0",
       "@sentry/vite-plugin": "4.6.0",
       "solid-js": "1.9.10",
+      "solid-sonner": "0.3.1",
       "vite-plugin-solid": "2.11.10",
-      "@lydell/node-pty": "1.2.0-beta.12"
+      "@lydell/node-pty": "1.2.0-beta.12",
+      "resolve.exports": "2.0.3"
     }
   },
   "devDependencies": {
     "@actions/artifact": "5.0.1",
-    "@ast-grep/cli": "0.44.0",
-    "@types/react": "19.2.17",
-    "@types/react-dom": "19.2.3",
     "@tsconfig/bun": "catalog:",
     "@types/mime-types": "3.0.1",
     "@typescript/native-preview": "catalog:",
@@ -125,7 +115,7 @@
     "@aws-sdk/client-s3": "3.933.0",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/script": "workspace:*",
-    "@opencode-ai/sdk": "1.18.5",
+    "@opencode-ai/sdk": "workspace:*",
     "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
@@ -153,21 +143,24 @@
     "@opentui/keymap": "catalog:",
     "@opentui/solid": "catalog:",
     "@types/bun": "catalog:",
-    "@types/node": "catalog:",
-    "effect": "catalog:"
+    "@types/node": "catalog:"
   },
   "patchedDependencies": {
+    "@dnd-kit/dom@0.5.0": "patches/@dnd-kit%2Fdom@0.5.0.patch",
+    "@ff-labs/fff-bun@0.9.3": "patches/@ff-labs%2Ffff-bun@0.9.3.patch",
     "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
     "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
     "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
+    "@ai-sdk/xai@3.0.102": "patches/@ai-sdk%2Fxai@3.0.102.patch",
     "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
     "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
-    "effect@4.0.0-beta.101": "patches/effect@4.0.0-beta.101.patch",
-    "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch"
+    "effect@4.0.0-beta.83": "patches/effect@4.0.0-beta.83.patch",
+    "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
+    "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch"
   }
 }

packages/ai/AGENTS.md

@@ -1,343 +0,0 @@
-# AI Package Guide
-
-## Effect
-
-- Prefer `HttpClient.HttpClient` / `HttpClientResponse.HttpClientResponse` over web `fetch` / `Response` at package boundaries.
-- Use `Stream.Stream` for streaming data flow. Avoid ad hoc async generators or manual web reader loops unless an Effect `Stream` API cannot model the behavior.
-- Use Effect Schema codecs for JSON encode/decode (`Schema.fromJsonString(...)`) instead of direct `JSON.parse` / `JSON.stringify` in implementation code.
-- In `Effect.gen`, yield yieldable errors directly (`return yield* new MyError(...)`) instead of `Effect.fail(new MyError(...))`.
-- Use `Effect.void` instead of `Effect.succeed(undefined)` when the successful value is intentionally void.
-
-## Conventions
-
-Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `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.
-
-- Keep provider-defined string enums forward-compatible. Expose known values for autocomplete while accepting future values with `Known | (string & {})`; use `Schema.String` at runtime unless rejecting unknown values is required for correctness.
-
-## Tests
-
-- Use `testEffect(...)` from `test/lib/effect.ts` for tests requiring Effect layers.
-- Keep provider tests fixture-first. Live provider calls must stay behind `RECORD=true` and required API-key checks.
-
-## Architecture
-
-This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
-
-Primary in-repo integration point:
-
-- `packages/opencode/src/session/llm.ts` is the session-owned orchestration layer that decides whether a request uses AI SDK or this package's native route runtime.
-- `packages/opencode/src/session/llm/native-request.ts` is the lowering adapter from opencode's session/AI SDK-shaped data into this package's `LLMRequest` model.
-- `packages/opencode/src/session/llm/native-runtime.ts` is the execution adapter that calls raw `LLMClient.stream(request)` and bridges one provider turn of opencode tool calls through this package's typed dispatcher.
-- `packages/opencode/src/session/llm/ai-sdk.ts` keeps the default AI SDK path compatible by converting AI SDK stream parts into this package's shared `LLMEvent`s.
-
-Keep this package independent of session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in `packages/opencode/src/session/llm.ts` and its local adapters.
-
-### Request Flow
-
-The intended callsite is:
-
-```ts
-const request = LLM.request({
-  model: OpenAI.configure({ apiKey }).responses("gpt-4o-mini"),
-  system: "You are concise.",
-  prompt: "Say hello.",
-})
-
-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`.
-
-Use `LLMClient.stream(request)` when callers want incremental `LLMEvent`s. Use `LLMClient.generate(request)` when callers want those same events collected into an `LLMResponse`.
-
-Filter or narrow `LLMEvent` streams with `LLMEvent.is.*` (camelCase guards, e.g. `events.filter(LLMEvent.is.toolCall)`). The kebab-case `LLMEvent.guards["tool-call"]` form also works but prefer `is.*` in new code.
-
-### Routes
-
-A route is the registered, runnable composition of four orthogonal pieces:
-
-- **`Protocol`** (`src/route/protocol.ts`) — semantic API contract. Owns request body construction (`body.from`), the body schema (`body.schema`), the streaming-event schema (`stream.event`), and the event-to-`LLMEvent` state machine (`stream.step`). `Route.make(...)` validates and JSON-encodes the body from `body.schema` and decodes frames with `stream.event`. Examples: `OpenAIChat.protocol`, `OpenResponses.protocol`, `OpenAIResponses.protocol`, `AnthropicMessages.protocol`, `Gemini.protocol`, `BedrockConverse.protocol`.
-- **`Endpoint`** (`src/route/endpoint.ts`) — URL construction. The host, path, and route query live on the endpoint. `Endpoint.path("/chat/completions", { baseURL })` is the common case; pass a function for paths that embed the model id or a body field (e.g. `Endpoint.path(({ body }) => `/model/${body.modelId}/converse-stream`)`).
-- **`Auth`** (`src/route/auth.ts`) — per-request transport authentication. Provider facades configure credentials onto the route before model selection, usually via `Auth.bearer(apiKey)` or `Auth.header(name, apiKey)`. Routes that need per-request signing (Bedrock SigV4, future Vertex IAM, Azure AAD) implement `Auth` as a function that signs the body and merges signed headers into the result.
-- **`Framing`** (`src/route/framing.ts`) — bytes → frames. SSE (`Framing.sse`) is shared; Bedrock keeps its AWS event-stream framing as a typed `Framing<object>` value alongside its protocol.
-
-Compose them via `Route.make(...)`:
-
-```ts
-export const route = Route.make({
-  id: "openai-chat",
-  provider: "openai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", {
-    baseURL: "https://api.openai.com/v1",
-  }),
-  auth: Auth.bearer(),
-  framing: Framing.sse,
-})
-```
-
-Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
-
-The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
-
-When a provider ships a non-HTTP transport (OpenAI's WebSocket Responses backend, hypothetical bidirectional streaming APIs), the seam is `Transport` — `WebSocketTransport.jsonTransport.with(...)` constructs an IO template whose `prepare` receives the route endpoint/auth at compile time, builds a WebSocket URL and message, and whose `frames` yields decoded text from the socket. Same protocol and endpoint source, different transport.
-
-### URL Construction
-
-`Endpoint` owns `{ baseURL, path, query }`. Each protocol route includes a canonical endpoint when the provider has one (e.g. `https://api.openai.com/v1`); provider helpers override endpoint fields by configuring the route before selecting a model. Routes that have no canonical URL (OpenAI-compatible Chat, GitHub Copilot) require configuration before execution.
-
-For providers where the URL is derived from typed inputs (Azure resource name, Bedrock region), the provider helper configures the route endpoint before calling `.model(...)`. Use `AtLeastOne<T>` from `route/auth-options.ts` for inputs that accept either of two derivation paths (Azure: `resourceName` or `baseURL`).
-
-### 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:
-
-```ts
-const openai = OpenAI.configure({ apiKey, baseURL })
-const model = openai.responses("gpt-4o-mini")
-
-const azure = Azure.configure({ resourceName, apiKey, apiVersion: "v1" })
-const deployment = azure.responses("my-deployment")
-
-const gateway = CloudflareAIGateway.configure({ accountId, gatewayId, gatewayApiKey, apiKey })
-const proxied = gateway.model("openai/gpt-4o-mini")
-```
-
-Keep provider facades small and explicit:
-
-- Use branded `ProviderID.make(...)` and `ModelID.make(...)` where ids are constructed directly.
-- Use `model` for the default API path and named methods for provider-native alternatives such as OpenAI `responses`, `responsesWebSocket`, and `chat`.
-- Put provider-specific setup on `.configure(...)`; do not add `model(id, overrides)` as a duplicate construction path.
-- Export lower-level `routes` arrays separately only when advanced internal wiring needs them.
-- Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
-- Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
-- Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
-
-`Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
-
-### Provider Package Entrypoints
-
-Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
-
-```ts
-import { model } from "@opencode-ai/ai/providers/openai/responses"
-
-const selected = model("gpt-5", {
-  apiKey,
-  transport: "websocket",
-})
-```
-
-Keep semantic APIs as separate entrypoints, such as OpenAI `chat` and `responses`. Keep transport choices inside the semantic entrypoint settings, so OpenAI Responses HTTP and WebSocket share one entrypoint. Provider facades may still expose named selectors such as `responsesWebSocket` for direct typed call sites; the package-like contract maps its settings to those selectors before returning an executable `LanguageModel`.
-
-Do not expose `Route` in provider package settings. Route composition stays an implementation detail behind `model(...)`.
-
-### Folder layout
-
-```
-packages/ai/src/
-  schema/                   canonical Schema model, split by concern
-    ids.ts                  branded IDs, literal types, ProviderMetadata
-    options.ts              Generation/Provider/Http options, Limits, LanguageModel, cache policy
-    messages.ts             content parts, Message, ToolDefinition, LLMRequest
-    events.ts               Usage, individual events, LLMEvent, LLMResponse
-    errors.ts               error reasons, AIError, ToolFailure
-    index.ts                barrel
-  llm.ts                    request constructors and convenience helpers
-  route/
-    index.ts                @opencode-ai/ai/route advanced barrel
-    client.ts               Route.make + LLMClient.stream/generate
-    executor.ts             RequestExecutor service + transport error mapping
-    protocol.ts             Protocol type + Protocol.make
-    endpoint.ts             Endpoint type + Endpoint.path
-    auth.ts                 Auth type + Auth.bearer / Auth.apiKeyHeader / Auth.passthrough
-    auth-options.ts         ProviderAuthOption shape, AuthOptions.bearer, AtLeastOne helper
-    framing.ts              Framing type + Framing.sse
-    transport/              transport implementations
-      index.ts              Transport type + HttpTransport / WebSocketTransport namespaces
-      http.ts               HttpTransport.httpJson — POST + framing
-      websocket.ts          WebSocketTransport.json + WebSocketExecutor service
-  protocols/
-    shared.ts               ProviderShared toolkit used inside protocol impls
-    openai-chat.ts          protocol + route (compose OpenAIChat.protocol)
-    open-responses.ts         provider-neutral Responses protocol baseline
-    openai-responses.ts       OpenAI tools/events/transports composed over OpenResponses
-    anthropic-messages.ts
-    gemini.ts
-    bedrock-converse.ts
-    bedrock-event-stream.ts framing for AWS event-stream binary frames
-    openai-compatible-chat.ts route that reuses OpenAIChat.protocol, no canonical URL
-    openai-compatible-responses.ts deployment adapter that reuses OpenResponses.protocol, no canonical URL
-    utils/                  per-protocol helpers (auth, cache, media, tool-stream, ...)
-  providers/
-    openai-compatible.ts    generic Chat helper + family model helpers
-    openai-compatible-responses.ts generic Responses helper
-    openai-compatible-profile.ts family defaults (deepseek, togetherai, ...)
-    azure.ts / amazon-bedrock.ts / cloudflare.ts / github-copilot.ts / google.ts / xai.ts / openai.ts / anthropic.ts / openrouter.ts
-  tool.ts                   typed tool() helper
-  tool-runtime.ts           narrow one-call typed tool dispatcher
-```
-
-The dependency arrow points down: `providers/*.ts` files import protocol routes and auth-option utilities; protocol modules import `endpoint`, `auth`, `framing`, and transport pieces. Protocols do not import provider facades. Lower-level modules know nothing about provider catalog metadata. `OpenAIResponses` composes the provider-neutral `OpenResponses` protocol; the baseline never imports the OpenAI extension.
-
-### Shared protocol helpers
-
-`ProviderShared` exports a small toolkit used inside protocol implementations to keep them focused on provider-native shapes:
-
-- `joinText(parts)` — joins an array of `TextPart` (or anything with a `.text`) with newlines. Use this anywhere a protocol flattens text content into a single string for a provider field.
-- `parseToolInput(route, name, raw)` — Schema-decodes a tool-call argument string with the canonical "Invalid JSON input for `<route>` tool call `<name>`" error message. Treats empty input as `{}`.
-- `parseJson(route, raw, message)` — generic JSON-via-Schema decode for non-tool bodies.
-- `eventError(route, message, ...)` — typed `InvalidProviderOutput` constructor for stream-time decode failures.
-- `validateWith(decoder)` — maps Schema decode errors to `InvalidRequest`. `Route.make(...)` uses this for body validation; lower-level routes can reuse it.
-- `matchToolChoice(provider, choice, branches)` — branches over `LLMRequest["toolChoice"]` for provider-specific lowering.
-
-If you find yourself copying a 3-to-5-line snippet between two protocols, lift it into `ProviderShared` next to these helpers rather than duplicating.
-
-### Chronological System Updates
-
-`LLMRequest.system` is the initial privileged prompt that applies ahead of the conversation. `Message.system(...)` is a separate, provider-neutral chronological operator update inside `LLMRequest.messages`; it applies only from its position in history onward and accepts text content only.
-
-Native chronological system messages are route/model-specific. Anthropic Messages lowers them natively for Claude Opus 4.8 (`claude-opus-4-8`). Other routes and models intentionally lower the update in place into ordinary user-compatible text using this stable escaped representation:
-
-```text
-<system-update>
-...
-</system-update>
-```
-
-The wrapped-user fallback preserves ordering while visibly lowering authority. Never silently pass a raw chronological `role: "system"` through a route that might reject it. Do not insert raw retrieved documents, tool output, or web content into privileged chronological system updates; keep untrusted content in ordinary user/tool channels.
-
-### Tools
-
-Tool loops are represented in common messages and events:
-
-```ts
-const call = ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })
-const result = Message.tool({ id: "call_1", name: "lookup", result: { forecast: "sunny" } })
-
-const followUp = LLM.request({
-  model,
-  messages: [Message.user("Weather?"), Message.assistant([call]), result],
-})
-```
-
-Routes lower these into provider-native assistant tool-call messages and tool-result messages. Streaming providers should emit `tool-input-delta` events while arguments arrive, then a final `tool-call` event with parsed input.
-
-### Tool dispatch
-
-`LLM.stream(request)` and `LLM.generate(request)` each run exactly one provider turn. Add tool schemas to `request.tools` with `Tool.toDefinitions(tools)`. When a caller wants the package's typed one-call execution behavior, pass each canonical local `tool-call` event to `ToolRuntime.dispatch(tools, call)`.
-
-```ts
-const get_weather = tool({
-  description: "Get current weather for a city",
-  parameters: Schema.Struct({ city: Schema.String }),
-  success: Schema.Struct({ temperature: Schema.Number, condition: Schema.String }),
-  execute: ({ city }) =>
-    Effect.gen(function* () {
-      // city: string  — typed from parameters Schema
-      const data = yield* WeatherApi.fetch(city)
-      return { temperature: data.temp, condition: data.cond }
-      // return type checked against success Schema
-    }),
-})
-
-const tools = { get_weather, get_time, ... }
-const events = yield* LLM.stream(
-  LLMRequest.update(request, { tools: Tool.toDefinitions(tools) }),
-).pipe(Stream.runCollect)
-
-const call = Array.from(events).find(LLMEvent.is.toolCall)
-if (call && !call.providerExecuted) {
-  const dispatched = yield* ToolRuntime.dispatch(tools, call)
-  // Persist call + dispatched.result, then construct the next request explicitly.
-}
-```
-
-The dispatcher:
-
-- On `tool-call`: looks up the named tool, decodes input against `parameters` Schema, dispatches to the typed `execute`, encodes the result against `success` Schema, and returns canonical `tool-result` events.
-- Does not stream providers, construct Session events, schedule fibers, append history, count steps, or continue model rounds.
-- Leaves persistence and continuation to the enclosing product flow.
-
-Handler dependencies (services, permissions, plugin hooks, abort handling) are closed over by the consumer at tool-construction time. Build the tools record inside an `Effect.gen` once and reuse it across many dispatches.
-
-Errors must be expressed as `ToolFailure`. The runtime catches it and emits a `tool-error` event, then a `tool-result` of `type: "error"`, so the model can self-correct on the next step. Anything that is not a `ToolFailure` is treated as a defect and fails the stream. Three recoverable error paths produce `tool-error` events:
-
-- The model called an unknown tool name.
-- Input failed the `parameters` Schema.
-- The handler returned a `ToolFailure`.
-
-Provider-defined / hosted tools (Anthropic `web_search` / `code_execution` / `web_fetch`, OpenAI Responses `web_search_call` / `file_search_call` / `code_interpreter_call` / `mcp_call` / `local_shell_call` / `image_generation_call` / `computer_use_call`) pass through the runtime untouched:
-
-- Routes surface the model's call as a `tool-call` event with `providerExecuted: true`, and the provider's result as a matching `tool-result` event with `providerExecuted: true`.
-- Callers detect `providerExecuted` on `tool-call` and **skip local dispatch** — no handler is invoked and no `tool-error` is raised for "unknown tool". The provider already executed it.
-- Callers that continue should retain both events in explicit history when the protocol requires it. Anthropic encodes them back as `server_tool_use` + `web_search_tool_result` (or `code_execution_tool_result` / `web_fetch_tool_result`) blocks; OpenAI Responses callers typically use `previous_response_id` instead of resending hosted-tool items.
-
-Add provider-defined tools to `request.tools` (no runtime entry needed). The matching route must know how to lower the tool definition into the provider-native shape; right now Anthropic accepts `web_search` / `code_execution` / `web_fetch` and OpenAI Responses accepts the hosted tool names listed above.
-
-## Protocol File Style
-
-Protocol files should look self-similar. Provider quirks belong behind named helpers so a new route can be reviewed by comparing the same sections across files.
-
-### Section order
-
-Use this order for every protocol module:
-
-1. Public model input
-2. Request body schema
-3. Streaming event schema
-4. Parser state
-5. Request body construction (`fromRequest`)
-6. Stream parsing (`step` and per-event handlers)
-7. Protocol and route
-8. Protocol route export
-
-### Rules
-
-- Keep protocol files focused on the protocol. Move provider-specific projection, signing, media normalization, or other bulky transformations into `src/protocols/utils/*`.
-- 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.
-- Use shared helpers for repeated protocol policy such as text joining, usage totals, JSON parsing, and tool-call accumulation. `ToolStream` (`protocols/utils/tool-stream.ts`) accumulates streamed tool-call arguments uniformly.
-- Make intentional provider differences explicit in helper names or comments. If two protocol files differ visually, the reason should be obvious from the names.
-- Prefer dispatched per-event handlers (`onMessageStart`, `onContentBlockDelta`, ...) called from a small top-level `step` switch over a long if-chain. The dispatcher keeps the event surface visible at a glance.
-- Keep tests in the same conceptual order as the protocol: basic prepare, tools prepare, unsupported lowering, text/usage parsing, tool streaming, finish reasons, provider errors.
-
-### Review checklist
-
-- Can the file be skimmed side-by-side with `openai-chat.ts` without hunting for equivalent sections?
-- Are provider quirks named, isolated, and covered by focused tests?
-- Does request body construction validate unsupported common content at the protocol boundary?
-- Does stream parsing emit stable common events without leaking provider event order to callers?
-- Does `toolChoice: "none"` behavior read as intentional?
-
-## Recording Tests
-
-Recorded tests use one cassette file per scenario. A cassette holds an ordered array of `{ request, response }` interactions, so multi-step flows (tool loops, retries, polling) record into a single file. Use `recordedTests({ prefix, requires })` and let the helper derive cassette names from test names:
-
-```ts
-const recorded = recordedTests({ prefix: "openai-chat", requires: ["OPENAI_API_KEY"] })
-
-recorded.effect("streams text", () =>
-  Effect.gen(function* () {
-    // test body
-  }),
-)
-```
-
-Replay is the default. `RECORD=true` records fresh cassettes locally and requires the listed env vars; unset `CI` before recording because CI always forces replay. Cassettes are written as pretty-printed JSON so multi-interaction diffs stay reviewable.
-
-Pass `provider`, `protocol`, and optional `tags` to `recordedTests(...)` / `recorded.effect.with(...)` so cassettes carry searchable metadata. Use recorded-test filters to replay or record a narrow subset without rewriting a whole file:
-
-- `RECORDED_PROVIDER=openai` matches tests tagged with `provider:openai`; comma-separated values are allowed.
-- `RECORDED_PREFIX=openai-chat` matches cassette groups by `recordedTests({ prefix })`; comma-separated values are allowed.
-- `RECORDED_TAGS=tool` requires all listed tags to be present, e.g. `RECORDED_TAGS=provider:togetherai,tool`.
-- `RECORDED_TEST="streams text"` matches by test name, kebab-case test id, or cassette path.
-
-Filters apply in replay and record mode. Combine them with `RECORD=true` when refreshing only one provider or scenario.
-
-**Binary response bodies.** Most providers stream text (SSE, JSON). The recorder treats known textual media types (`text/*`, JSON/XML structured types, JavaScript, forms, YAML, and SVG) as text and stores every other response as base64 with `bodyEncoding: "base64"`. This preserves binary formats such as AWS event-stream frames without a lossy UTF-8 round trip.
-
-**Matching strategy.** A runtime request atomically claims the first unused recorded interaction that matches its method, URL, allow-listed headers, and canonical JSON body. Distinct requests may replay in any order or concurrently. Repeated identical requests consume their matching responses in cassette order, preserving deterministic retry and polling behavior. `scriptedResponses` (in `test/lib/http.ts`) is the deterministic counterpart for tests that don't need a live provider; it scripts response bodies in order without reading from disk.
-
-Do not blanket re-record an entire test file when adding one cassette. `RECORD=true` rewrites every recorded case that runs, and provider streams contain volatile IDs, timestamps, fingerprints, and obfuscation fields. Prefer deleting the one cassette you intend to refresh, or run a focused test pattern that only registers the scenario you want to record. Keep stable existing cassettes unchanged unless their request shape or expected behavior changed.

packages/ai/README.md

@@ -1,392 +0,0 @@
-# @opencode-ai/ai
-
-Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
-
-```ts
-import { Effect, Layer } from "effect"
-import { LLM, LLMClient } from "@opencode-ai/ai"
-import { RequestExecutor } from "@opencode-ai/ai/route"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
-
-const request = LLM.request({
-  model,
-  system: "You are concise.",
-  prompt: "Say hello in one short sentence.",
-  generation: { maxTokens: 40 },
-})
-
-const program = Effect.gen(function* () {
-  const response = yield* LLMClient.generate(request)
-  console.log(response.text)
-})
-
-const llmLayer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
-
-await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
-```
-
-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.
-
-## Image generation
-
-Use `Image.generate` with an image model for direct asset generation:
-
-```ts
-import { Image, ImageInput } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-const program = Effect.gen(function* () {
-  const response = yield* Image.generate({
-    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"),
-    prompt: "A robot tending a rooftop garden",
-    options: {
-      n: 2,
-      size: "1024x1024",
-      quality: "high", // inferred from the OpenAI image model
-      outputFormat: "webp",
-      future_option: true, // unknown native options pass through unchanged
-    },
-  })
-
-  return response.images // GeneratedImage[] with owned bytes or a provider URL
-})
-```
-
-Pass ordered image inputs to the same method for editing, composition, or image-conditioned generation:
-
-```ts
-const response =
-  yield *
-  Image.generate({
-    model,
-    prompt: "Combine these product photos into one studio scene",
-    images: [
-      ImageInput.bytes(firstBytes, "image/png"),
-      ImageInput.url("https://example.com/second.webp"),
-      ImageInput.file("file_123"),
-    ],
-    options,
-    http,
-  })
-```
-
-`ImageInput.fileUri(uri, mediaType)` represents provider file URIs such as Gemini Files. Raw strings are not
-accepted as image inputs, avoiding ambiguity between base64, URLs, and provider IDs. Empty or omitted `images`
-uses text-to-image generation; a non-empty array selects the provider's edit behavior without enforcing provider
-image-count limits locally. `images` is the only common image-editing field. OpenAI uses multipart for byte/data-URL
-edits and its JSON reference body for URL or file-ID edits. Its provider-specific `options.mask` accepts an
-`ImageInput` for inpainting:
-
-```ts
-yield *
-  Image.generate({
-    model: OpenAI.configure({ apiKey }).image("gpt-image-2"),
-    prompt,
-    images: [ImageInput.bytes(sourceBytes, "image/png")],
-    options: { mask: ImageInput.bytes(maskBytes, "image/png") },
-  })
-```
-
-The OpenAI adapter extracts this helper value into the edit request's native `mask` field rather than passing the
-tagged `ImageInput` object through as an ordinary option. On multipart requests, `http.body` can override option
-fields but not structural `model`, `prompt`, `image[]`, or `mask` fields, and the transport owns the multipart
-`Content-Type` boundary. For JSON requests, `http.body` remains the final raw-native overlay. Gemini does not fetch
-public HTTP URLs, and hosted Z.ai image generation does not accept image inputs. These cases fail with
-`InvalidRequest` before network I/O.
-
-Provider-native image options belong to each request. Raw `http.body` fields have final precedence over them:
-
-```ts
-const model = OpenAI.configure({ apiKey }).image("gpt-image-2")
-
-yield *
-  Image.generate({
-    model,
-    prompt,
-    options: { quality: "medium" },
-    http,
-  })
-```
-
-xAI image models use the same request API with xAI-native controls:
-
-```ts
-yield *
-  Image.generate({
-    model: XAI.configure({ apiKey }).image("any-model-id"),
-    prompt,
-    options: {
-      n: 2,
-      aspectRatio: "16:9",
-      resolution: "1k",
-      responseFormat: "b64_json",
-      future_option: true,
-    },
-    http,
-  })
-```
-
-Google's current Gemini image models use the same direct API:
-
-```ts
-import { Google } from "@opencode-ai/ai/providers"
-
-const googleProgram = Effect.gen(function* () {
-  const response = yield* Image.generate({
-    model: Google.configure({ apiKey }).image("any-model-id"),
-    prompt: "A robot tending a rooftop garden",
-    options: {
-      aspectRatio: "16:9",
-      imageSize: "2K",
-      seed: 42,
-      thinkingLevel: "HIGH",
-      includeThoughts: true,
-      futureOption: true,
-    },
-    http,
-  })
-
-  return response.images
-})
-```
-
-Google image options are request-scoped and inferred from the selected model. Known fields autocomplete while
-future string values and arbitrary native Gemini `generationConfig` fields remain available. Native fields override
-their mapped aliases, and `http.body` is the final deep overlay. The selected model ID is sent to Gemini
-`generateContent` without a local allowlist.
-
-Z.ai image models infer open Z.ai-native options from the selected model:
-
-```ts
-yield *
-  Image.generate({
-    model: ZAI.configure({ apiKey }).image("any-model-id"),
-    prompt,
-    options: {
-      quality: "hd",
-      userID: "user-123",
-      future_option: true,
-    },
-    http,
-  })
-```
-
-Z.ai does not include trustworthy MIME metadata for output URLs, so generated images use
-`application/octet-stream`. Output URLs expire after 30 days; download and persist them promptly if they must
-remain available.
-
-Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
-
-```ts
-const program = Effect.gen(function* () {
-  const response = yield* LLM.generate(
-    LLM.request({
-      model: OpenAI.configure({ apiKey }).responses("gpt-5"),
-      prompt: "Design a solarpunk rooftop garden, then show me.",
-      tools: [OpenAI.imageGeneration({ quality: "high" })],
-    }),
-  )
-
-  return response.message
-})
-```
-
-The hosted result is represented as a provider-executed tool call and tool result. Its image is a `file` content item with a data URI, so retaining `response.message` preserves the generated image for continuation.
-
-## Public API
-
-- **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
-- **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
-- **`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.generate({...})`** — generate images through a provider-neutral image request and response model.
-- **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
-
-## Testing
-
-Use the deterministic test client from `@opencode-ai/ai/testing` to script provider-neutral responses and inspect
-the requests sent by code under test:
-
-```ts
-import { Effect } from "effect"
-import { TestLLM } from "@opencode-ai/ai/testing"
-
-const testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
-const programWithTestClient = Effect.gen(function* () {
-  const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
-  return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
-```
-
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
-
-## Caching
-
-Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "auto"` unless the caller opts out with `cache: "none"`. Each protocol translates `CacheHint`s to its wire format (`cache_control` on Anthropic, `cachePoint` on Bedrock; OpenAI and Gemini do implicit caching server-side and don't need inline markers — auto is a no-op there).
-
-### Auto placement
-
-`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tools, the base agent, project instructions, and the active conversation. The rolling final-message boundary is the load-bearing detail in tool loops: it advances on every request so the previous cache entry stays within Anthropic's 20-block lookback.
-
-Tools precede every system and conversation block in the provider prefix, so tool definitions must remain byte-stable and deterministically ordered for downstream breakpoints to remain reusable.
-
-The math justifies the default: Anthropic's 5-minute cache write is 1.25× base, read is 0.1×, so a single reuse within 5 minutes already wins. One-shot completions below the per-model minimum-cacheable-token threshold silently no-op on the wire, so the worst case is harmless.
-
-### Opting out
-
-```ts
-LLM.request({
-  model,
-  system,
-  prompt: "one-off question",
-  cache: "none",
-})
-```
-
-### Granular policy
-
-```ts
-cache: {
-  tools?: boolean,
-  system?: boolean,
-  messages?: "latest-user-message" | "latest-assistant" | { tail: number },
-  ttlSeconds?: number,         // ≥ 3600 → 1h on Anthropic/Bedrock; else 5m
-}
-```
-
-### Manual hints
-
-Inline `CacheHint` on any text / system / tool / tool-result part overrides automatic placement. The auto policy preserves manual hints, counts them against Anthropic and Bedrock's four-breakpoint limit, and only fills the remaining slots.
-
-```ts
-LLM.request({
-  model,
-  system: [
-    { type: "text", text: "stable system prompt", cache: { type: "ephemeral" } },
-  ],
-  ...
-})
-```
-
-### Provider behavior table
-
-| Protocol                | `cache: "auto"`                                                           |
-| ----------------------- | ------------------------------------------------------------------------- |
-| Anthropic Messages      | emits up to 4 `cache_control` markers (4-breakpoint cap enforced)         |
-| Bedrock Converse        | emits up to 4 `cachePoint` blocks (4-breakpoint cap enforced)             |
-| OpenAI Chat / Responses | no-op (implicit caching above 1024 tokens)                                |
-| Gemini                  | no-op (implicit caching on 2.5+; explicit `CachedContent` is out-of-band) |
-
-Normalized cache usage is read back into `response.usage.cacheReadInputTokens` and `cacheWriteInputTokens` across every provider.
-
-## Providers
-
-Provider facades configure endpoint/auth/deployment details first, then expose model selectors that take only a model or deployment id. The selected model carries the executable route value used at runtime.
-
-```ts
-import { OpenAI, CloudflareAIGateway } from "@opencode-ai/ai/providers"
-
-const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
-const gateway = CloudflareAIGateway.configure({
-  accountId: process.env.CLOUDFLARE_ACCOUNT_ID,
-  gatewayApiKey: process.env.CLOUDFLARE_API_TOKEN,
-}).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
-```
-
-Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
-
-### Package-like entrypoints
-
-Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
-
-```ts
-import { model } from "@opencode-ai/ai/providers/openai/responses"
-
-const selected = model("gpt-5", {
-  apiKey: process.env.OPENAI_API_KEY,
-  transport: "websocket",
-  headers: { "x-application": "opencode" },
-  limits: { context: 200_000, output: 64_000 },
-})
-```
-
-OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
-
-- `@opencode-ai/ai/providers/openai/chat`
-- `@opencode-ai/ai/providers/openai/responses`
-- `@opencode-ai/ai/providers/openai-compatible/responses`
-- `@opencode-ai/ai/providers/anthropic-compatible`
-- `@opencode-ai/ai/providers/google-vertex/gemini`
-- `@opencode-ai/ai/providers/google-vertex/chat`
-- `@opencode-ai/ai/providers/google-vertex/responses`
-- `@opencode-ai/ai/providers/google-vertex/messages`
-
-Responses HTTP versus WebSocket is a scoped `transport` setting on the OpenAI Responses entrypoint, not another entrypoint. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; the Responses adapter at `providers/openai-compatible/responses` uses the provider-neutral Open Responses protocol. OpenAI Responses extends that baseline with OpenAI tools, event variants, metadata, defaults, and transports. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
-
-Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate API entrypoints. All accept `project`, `location`, and an optional `accessToken`; when no explicit token or auth override is supplied they lazily use Google Application Default Credentials. Vertex Gemini instead selects express mode when `apiKey` or `GOOGLE_VERTEX_API_KEY` is present. Vertex Chat targets MaaS models through the OpenAI-compatible Chat Completions endpoint, while Vertex Responses targets Grok models and defaults `store` to `false` as required by Vertex. `providers/google-vertex` remains the default alias for `providers/google-vertex/gemini`.
-
-Tuned Vertex Gemini deployments use model ids shaped like `endpoints/1234567890` and require OAuth or ADC; Vertex express-mode API keys support publisher models only.
-
-```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/gemini"
-
-model("gemini-3.5-flash", { project: "my-project", location: "global" })
-```
-
-```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/chat"
-
-model("deepseek-ai/deepseek-v3.2-maas", { project: "my-project", location: "global" })
-```
-
-```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/responses"
-
-model("xai/grok-4.20-reasoning", { project: "my-project", location: "global" })
-```
-
-```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
-
-model("claude-sonnet-4-6", { project: "my-project", location: "global" })
-```
-
-Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
-
-Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
-
-## Provider options & HTTP overlays
-
-Three escape hatches in order of stability:
-
-1. **`generation`** — portable knobs (`maxTokens`, `temperature`, `topP`, `topK`, penalties, seed, stop).
-2. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `promptCacheKey`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
-3. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
-
-Route/provider defaults are overridden by request-level values for each axis.
-
-## Routes
-
-Adding a new model or deployment is usually 5-15 lines using `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports are reusable IO templates that receive route endpoint/auth at compile time. Capability/catalog metadata lives outside this low-level package; unsupported request shapes fail during protocol lowering. See `AGENTS.md` for the architectural detail.
-
-## Effect
-
-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
-
-- `AGENTS.md` — architecture, route construction, contributor guide
-- `STATUS.md` — native provider parity status and AI SDK migration gaps
-- `example/tutorial.ts` — runnable end-to-end walkthrough
-- `test/provider/*.test.ts` — fixture-first protocol tests; `*.recorded.test.ts` files cover live cassettes

packages/ai/STATUS.md

@@ -1,108 +0,0 @@
-# LLM Provider Parity Status
-
-Last reviewed: 2026-07-24
-
-This file tracks the gap between the native `@opencode-ai/ai` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.
-
-## Existing Status Sources
-
-| File                                | What it tracks                                                          | Limitation                                              |
-| ----------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------- |
-| `packages/ai/DESIGN.md`             | Future clean-break API proposal for `@opencode-ai/ai`.                  | Not a provider parity tracker.                          |
-| `packages/ai/example/call-sites.md` | Route/value/provider-facade migration checklist and call-site sketches. | Architecture migration only; not AI SDK package parity. |
-
-## Current Implementation Snapshot
-
-| Native slice                       | Source                                                                                                                            | Current state                                                                                                                                                            | Main gaps                                                                                                                                                                                                                                                 |
-| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| OpenAI Chat                        | `src/protocols/openai-chat.ts`, `src/providers/openai.ts`                                                                         | Usable. Streams text, reasoning deltas, tool calls, usage, images, and common generation controls.                                                                       | No typed structured-output / `response_format` path. Limited typed OpenAI option surface compared with SDK escape hatches.                                                                                                                                |
-| OpenAI Responses HTTP              | `src/protocols/open-responses.ts`, `src/protocols/openai-responses.ts`, `src/providers/openai.ts`                                 | Usable. Extends the Open Responses baseline with hosted-tool event surfacing, reasoning replay metadata, GPT-5 defaults, and cache usage.                                | No explicit `previous_response_id` path. Typed options cover only a subset of Responses fields. Structured output is still mostly synthetic-tool based.                                                                                                   |
-| OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                                                           | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
-| OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                                                   | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
-| Open Responses-compatible          | `src/protocols/open-responses.ts`, `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the provider-neutral Open Responses protocol. The deployment adapter does not inherit OpenAI tools, events, metadata, or defaults. | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
-| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                                                    | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.     | No named compatible family profiles yet.                                                                                                                                                                                                                  |
-| Anthropic Messages                 | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic.ts`                                                               | Usable. Supports tools, thinking, cache control, images, server-hosted tool events, and usage.                                                                           | Provider option surface is small. Beta/header handling, metadata, and newer Messages fields need a typed parity pass.                                                                                                                                     |
-| Gemini Developer API               | `src/protocols/gemini.ts`, `src/providers/google.ts`                                                                              | Usable for Google API key flow. Supports text, images, tools, thinking signatures, and cache usage.                                                                      | This is not Vertex. Typed provider options are narrow; many Gemini request fields currently require raw `http.body` overlays.                                                                                                                             |
-| Vertex Gemini                      | `src/protocols/gemini.ts`, `src/providers/google-vertex.ts`                                                                       | Usable through API-key express mode, explicit OAuth tokens, or ADC with project/location endpoint derivation, including tuned `endpoints/...` deployments.               | Core runner/catalog mapping and recorded provider coverage are missing.                                                                                                                                                                                   |
-| Vertex Chat                        | `src/protocols/openai-chat.ts`, `src/providers/google-vertex-chat.ts`                                                             | Usable for MaaS models through OpenAI-compatible Chat Completions with explicit OAuth tokens or ADC and project/location endpoint derivation.                            | Core runner/catalog mapping and recorded provider coverage are missing; MaaS family-specific request parity needs review.                                                                                                                                 |
-| Vertex Responses                   | `src/protocols/open-responses.ts`, `src/providers/google-vertex-responses.ts`                                                     | Usable for Grok models through Open Responses with explicit OAuth tokens or ADC, project/location endpoint derivation, and an explicit `store: false` Vertex default.    | Core runner/catalog mapping and recorded provider coverage are missing; stateful continuation is not supported by Vertex.                                                                                                                                 |
-| Vertex Messages                    | `src/protocols/anthropic-messages.ts`, `src/providers/google-vertex-messages.ts`                                                  | Usable through explicit OAuth tokens or ADC, including global, regional, and `eu`/`us` multi-region endpoints.                                                           | Core runner/catalog mapping and recorded provider coverage are missing; Vertex-specific hosted-tool parity needs review.                                                                                                                                  |
-| Bedrock Converse                   | `src/protocols/bedrock-converse.ts`, `src/providers/amazon-bedrock.ts`                                                            | Partial but real. Supports AWS event-stream framing, SigV4 with supplied credentials, bearer auth, tools, reasoning signatures, media, cache points, and recorded tests. | Native facade does not mirror the AI SDK plugin's default AWS credential chain/profile behavior. Runner/catalog mapping is missing. Guardrails, inference profiles, region-specific model ID fixes, and model-specific request fields need a parity pass. |
-| Azure OpenAI                       | `src/providers/azure.ts` using OpenAI Chat/Responses protocols                                                                    | Partial. Supports resource/base URL setup, API key auth, API version query, Chat, and Responses selectors.                                                               | Core runner does not map `@ai-sdk/azure` to this native facade. AAD/token auth and Azure-specific endpoint variants need review.                                                                                                                          |
-| Cloudflare AI Gateway / Workers AI | `src/providers/cloudflare.ts`                                                                                                     | Present via OpenAI-compatible Chat routes.                                                                                                                               | Useful but not part of the critical AI SDK replacement set yet. Needs per-product recorded coverage before relying on it broadly.                                                                                                                         |
-| OpenRouter                         | `src/providers/openrouter.ts`                                                                                                     | Present with OpenRouter-specific usage/reasoning/prompt-cache options over Chat.                                                                                         | Responses-style OpenRouter support is absent.                                                                                                                                                                                                             |
-| xAI                                | `src/providers/xai.ts`                                                                                                            | Present with Responses and Chat selectors.                                                                                                                               | Needs package-parity review against the AI SDK xAI provider.                                                                                                                                                                                              |
-| GitHub Copilot                     | `src/providers/github-copilot.ts`                                                                                                 | Present as explicit-base-URL OpenAI Chat/Responses facade.                                                                                                               | Runtime/catalog integration remains specialized and should stay separate from public OpenAI-compatible defaults.                                                                                                                                          |
-
-## V2 Runner Status
-
-`packages/core/src/session/runner/model.ts` currently resolves only this native subset from catalog `aisdk` metadata:
-
-| Catalog API                                         | Native route used today      |
-| --------------------------------------------------- | ---------------------------- |
-| `aisdk:@ai-sdk/openai`                              | `OpenAIResponses.route`      |
-| `aisdk:@ai-sdk/anthropic`                           | `AnthropicMessages.route`    |
-| `aisdk:@ai-sdk/openai-compatible` with explicit URL | `OpenAICompatibleChat.route` |
-
-Other `aisdk:` packages, including Google Vertex, Azure, and Bedrock, currently fall back through the AI SDK loader in the production runner. The dependency-free resolver seam rejects them with `SessionRunnerModel.UnsupportedPackageError`; they are not native route mappings yet.
-
-## AI SDK Package Parity Matrix
-
-| AI SDK package                    | Intended native target                                         | Status           | Biggest gaps                                                                                                                                                                                                        |
-| --------------------------------- | -------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@ai-sdk/openai`                  | `OpenAI.chat`, `OpenAI.responses`, `OpenAI.responsesWebSocket` | Partial / usable | Add complete typed option coverage, structured output strategy, explicit Responses continuation support, and runner route selection between Chat/Responses/WebSocket.                                               |
-| `@ai-sdk/openai-compatible`       | Generic OpenAI-compatible Chat and Responses                   | Partial / usable | Decide per-family namespace/profile behavior and runner API selection for providers that support Responses versus Chat only.                                                                                        |
-| `@ai-sdk/anthropic`               | `AnthropicMessages`                                            | Partial / usable | Finish Messages API parity for headers/betas/metadata/newer fields and document hosted-tool continuation expectations.                                                                                              |
-| `@ai-sdk/google`                  | Gemini Developer API                                           | Partial / usable | Add typed options for safety, response schema/modalities, cached content, grounding/search/code execution, and non-text output modes where supported.                                                               |
-| `@ai-sdk/google-vertex`           | Vertex Gemini namespace/facade                                 | Partial / usable | Add runner/catalog mapping, recorded coverage, and broader provider-option parity.                                                                                                                                  |
-| `@ai-sdk/google-vertex/anthropic` | Anthropic Messages over Vertex namespace/facade                | Partial / usable | Add runner/catalog mapping, recorded coverage, and Vertex-specific hosted-tool parity.                                                                                                                              |
-| `@ai-sdk/google-vertex/maas`      | Vertex Chat                                                    | Partial / usable | Add runner/catalog mapping, recorded coverage, and MaaS family-specific request parity.                                                                                                                             |
-| `@ai-sdk/google-vertex/xai`       | Vertex Chat / Responses                                        | Partial / usable | Decide Chat/Responses selection for catalog models, add runner mapping and recorded coverage, and review xAI-specific request options.                                                                              |
-| `@ai-sdk/azure`                   | Azure OpenAI Chat/Responses facade                             | Partial          | Map runner/catalog metadata to native Azure, handle resourceName/baseURL/apiVersion variants, add AAD/token auth story, and verify Chat vs Responses deployment selection.                                          |
-| `@ai-sdk/amazon-bedrock`          | Bedrock Converse                                               | Partial          | Add default AWS credential chain/profile support, region/inference-profile model ID handling, provider option parity via `additionalModelRequestFields`, guardrails/performance config, and runner/catalog mapping. |
-| `@ai-sdk/amazon-bedrock/mantle`   | Bedrock Mantle OpenAI-compatible Chat/Responses namespace      | Partial / usable | Add default AWS credential chain/profile support; native catalog mapping currently requires bearer auth or explicit static credentials.                                                                             |
-
-## Highest-Risk Gaps
-
-1. Runner support is narrower than the LLM package. The package has native provider facades for Google, Azure, and Bedrock, but the V2 Session runner only maps OpenAI, Anthropic, and explicit OpenAI-compatible Chat from `aisdk` catalog metadata.
-2. The Open Responses adapter is available through a separate package entrypoint, but the V2 runner still maps `@ai-sdk/openai-compatible` to Chat only. Catalog selection must become API-aware before Responses deployments can use it.
-3. Bedrock native auth is not AI SDK parity. The AI SDK plugin uses the default AWS provider chain, profile, container credentials, and Bedrock bearer token env behavior. Native Bedrock currently expects explicit credentials or bearer auth on the facade.
-4. Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages now have native package entrypoints, but the core runner does not map catalog metadata to them yet and recorded provider coverage is still missing.
-5. Azure is only a provider facade, not a full runtime replacement. Native Azure exists, but the catalog runner does not select it, and token auth/resource variants need review.
-6. Provider option typing is uneven. OpenAI, Anthropic, Gemini, Bedrock, and OpenRouter each expose a small typed subset plus raw HTTP overlays; this is useful but not equivalent to AI SDK provider option coverage.
-7. Structured output is not provider-native yet. `LLM.generateObject` still uses a synthetic tool strategy, while the future design expects native structured output where reliable and tool fallback where needed.
-8. Package/namespace boundaries for the current native loading set are explicit in docs and exports. Other exported provider facades are not catalog package entrypoints until they implement the contract. Vertex xAI still needs catalog API selection.
-9. Recorded coverage is uneven. OpenAI, Anthropic, Gemini, Bedrock Converse, Bedrock Mantle, Cloudflare, OpenRouter, and several OpenAI-compatible Chat providers have cassettes. Azure and Vertex still need first-class recorded scenarios before switching defaults.
-
-## Native Namespace Shape
-
-These are implementation/API slices, not separate npm packages.
-
-| API slice                     | Package-like entrypoint                                     | Purpose                                                                      |
-| ----------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| OpenAI Chat                   | `@opencode-ai/ai/providers/openai/chat`                     | OpenAI `/chat/completions` semantics.                                        |
-| OpenAI Responses              | `@opencode-ai/ai/providers/openai/responses`                | OpenAI `/responses` semantics with HTTP/WebSocket selected through settings. |
-| OpenAI-compatible Chat        | `@opencode-ai/ai/providers/openai-compatible`               | Generic OpenAI-compatible `/chat/completions`.                               |
-| Open Responses-compatible     | `@opencode-ai/ai/providers/openai-compatible/responses`     | Generic provider-neutral `/responses`.                                       |
-| Anthropic-compatible Messages | `@opencode-ai/ai/providers/anthropic-compatible`            | Generic Anthropic-compatible `/messages`.                                    |
-| Anthropic Messages            | `@opencode-ai/ai/providers/anthropic`                       | Anthropic Messages API.                                                      |
-| Gemini Developer API          | `@opencode-ai/ai/providers/google`                          | Google AI Studio Gemini API.                                                 |
-| Vertex Gemini                 | `@opencode-ai/ai/providers/google-vertex/gemini`            | Vertex Gemini API; `providers/google-vertex` is the default alias.           |
-| Vertex Chat                   | `@opencode-ai/ai/providers/google-vertex/chat`              | Vertex OpenAI-compatible Chat Completions for MaaS models.                   |
-| Vertex Responses              | `@opencode-ai/ai/providers/google-vertex/responses`         | Vertex Open Responses for Grok models.                                       |
-| Vertex Messages               | `@opencode-ai/ai/providers/google-vertex/messages`          | Vertex-hosted Anthropic Messages API.                                        |
-| Bedrock Converse              | `@opencode-ai/ai/providers/amazon-bedrock`                  | AWS Bedrock Converse API.                                                    |
-| Bedrock Mantle Chat           | `@opencode-ai/ai/providers/amazon-bedrock/mantle/chat`      | AWS Bedrock Mantle OpenAI-compatible Chat API.                               |
-| Bedrock Mantle Responses      | `@opencode-ai/ai/providers/amazon-bedrock/mantle/responses` | AWS Bedrock Mantle OpenAI-compatible Responses API.                          |
-| Azure OpenAI Chat             | `@opencode-ai/ai/providers/azure/chat`                      | Azure specialization of OpenAI Chat.                                         |
-| Azure OpenAI Responses        | `@opencode-ai/ai/providers/azure/responses`                 | Azure specialization of OpenAI Responses.                                    |
-
-## Suggested Next Work Slices
-
-1. Add native runner/catalog mappings for `@ai-sdk/azure`, `@ai-sdk/google`, and `@ai-sdk/amazon-bedrock` where the existing native facades are already close.
-2. Add API-aware runner/catalog selection between OpenAI-compatible Chat and Responses.
-3. Bring Bedrock native auth/config to AI SDK parity: region, profile, default AWS credential chain, bearer token env, endpoint override, and cross-region inference profile handling.
-4. Add runner/catalog mappings and recorded scenarios for the native Vertex Gemini, Chat, Responses, and Messages entrypoints.
-5. Decide Chat/Responses selection for `@ai-sdk/google-vertex/xai` catalog models.
-6. Expand typed provider options from the existing V1 lowerer knowledge in `packages/core/src/v1/config/provider-options.ts` before adding more raw overlay examples.
-7. Add recorded provider tests for Azure, Vertex Gemini, Vertex Chat, Vertex Responses, Vertex Messages, and Bedrock credential-chain behavior before making native runtime the default for those packages.

packages/ai/package.json

@@ -1,38 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.17.20",
-  "name": "@opencode-ai/ai",
-  "type": "module",
-  "license": "MIT",
-  "scripts": {
-    "setup:recording-env": "bun run script/setup-recording-env.ts",
-    "test": "bun test --timeout 30000 --only-failures",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
-    "build": "tsc -p tsconfig.build.json"
-  },
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./testing": "./src/testing.ts",
-    "./*": "./src/*.ts"
-  },
-  "devDependencies": {
-    "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "catalog:",
-    "@opencode-ai/http-recorder": "workspace:*",
-    "@tsconfig/bun": "catalog:",
-    "@types/bun": "catalog:",
-    "@typescript/native-preview": "catalog:",
-    "typescript": "catalog:"
-  },
-  "dependencies": {
-    "@smithy/eventstream-codec": "4.2.14",
-    "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "workspace:*",
-    "aws4fetch": "1.0.20",
-    "effect": "catalog:",
-    "google-auth-library": "10.5.0"
-  }
-}

packages/ai/script/publish.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env bun
-import { Script } from "@opencode-ai/script"
-import { $ } from "bun"
-import { fileURLToPath } from "url"
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-process.chdir(dir)
-
-async function published(name: string, version: string) {
-  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
-}
-
-await $`bun run build`
-const originalText = await Bun.file("package.json").text()
-const pkg = JSON.parse(originalText) as {
-  name: string
-  version: string
-  exports: Record<string, string>
-}
-if (await published(pkg.name, pkg.version)) {
-  console.log(`already published ${pkg.name}@${pkg.version}`)
-} else {
-  for (const [key, value] of Object.entries(pkg.exports)) {
-    const file = value.replace("./src/", "./dist/").replace(".ts", "")
-    // @ts-ignore
-    pkg.exports[key] = {
-      import: file + ".js",
-      types: file + ".d.ts",
-    }
-  }
-  await Bun.write("package.json", JSON.stringify(pkg, null, 2))
-  try {
-    await $`bun pm pack`
-    await $`npm publish *.tgz --tag ${Script.channel} --access public`
-  } finally {
-    await Bun.write("package.json", originalText)
-  }
-}

packages/ai/src/cache-policy.ts

@@ -1,148 +0,0 @@
-// Apply an `LLMRequest.cache` policy by injecting `CacheHint`s onto the parts
-// the policy designates. Runs once at compile time, before the per-protocol
-// body builder, so the existing inline-hint lowering path handles the rest.
-//
-// The default `"auto"` shape places breakpoints at the last tool definition,
-// the first and last distinct system parts, and the conversation tail. This
-// exposes reusable tool, base-agent, project, and session prefixes while
-// advancing the tail after each tool result keeps the previous cache entry
-// within Anthropic's 20-block lookback during long agent turns.
-//
-// Manual `cache: CacheHint` placements on individual parts are preserved and
-// count against the four-breakpoint budget; auto only fills remaining slots.
-import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options"
-import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages"
-
-const AUTO: CachePolicyObject = {
-  tools: true,
-  system: true,
-  messages: { tail: 1 },
-}
-
-const NONE: CachePolicyObject = {}
-const BREAKPOINT_CAP = 4
-
-// Resolution rules:
-//   - undefined   → "auto" — caching is on by default. The math favors it:
-//                   Anthropic 5m-cache write is 1.25x base, read is 0.1x,
-//                   so a single reuse within 5 minutes already wins.
-//   - "auto"      → tools + first/last system + final message boundary.
-//   - "none"      → no auto placement; manual `CacheHint`s still flow.
-//   - object form → exactly what the caller asked for.
-const resolve = (policy: CachePolicy | undefined): CachePolicyObject => {
-  if (policy === undefined || policy === "auto") return AUTO
-  if (policy === "none") return NONE
-  return policy
-}
-
-// Protocols whose wire format ignores inline cache markers (OpenAI's implicit
-// prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
-// whole policy pass for these — emitting hints would be harmless but pointless.
-const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "bedrock-converse", "openrouter"])
-
-const makeHint = (ttlSeconds: number | undefined): CacheHint =>
-  ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" })
-
-interface Budget {
-  remaining: number
-}
-
-const markLastTool = (
-  tools: ReadonlyArray<ToolDefinition>,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<ToolDefinition> => {
-  if (tools.length === 0) return tools
-  const last = tools.length - 1
-  if (tools[last]!.cache || budget.remaining === 0) return tools
-  budget.remaining -= 1
-  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
-}
-
-const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
-  if (system.length === 0) return system
-  let changed = false
-  const next = system.map((part, index) => {
-    if ((index !== 0 && index !== system.length - 1) || part.cache || budget.remaining === 0) return part
-    budget.remaining -= 1
-    changed = true
-    return { ...part, cache: hint }
-  })
-  return changed ? next : system
-}
-
-const lastIndexOfRole = (messages: ReadonlyArray<Message>, role: Message["role"]): number =>
-  messages.findLastIndex((m) => m.role === role)
-
-// Mark the last text part of `messages[index]`. If no text part exists, mark
-// the last content part regardless of type — that's the breakpoint position
-// in tool-result-only messages too.
-const markMessageAt = (
-  messages: ReadonlyArray<Message>,
-  index: number,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<Message> => {
-  if (index < 0 || index >= messages.length) return messages
-  const target = messages[index]!
-  if (target.content.length === 0) return messages
-  const lastTextIndex = target.content.findLastIndex((part) => part.type === "text")
-  const markAt = lastTextIndex >= 0 ? lastTextIndex : target.content.length - 1
-  const existing = target.content[markAt]!
-  if (("cache" in existing && existing.cache) || budget.remaining === 0) return messages
-  budget.remaining -= 1
-  const nextContent = target.content.map((part, i) => (i === markAt ? ({ ...part, cache: hint } as ContentPart) : part))
-  const next = new Message({ ...target, content: nextContent })
-  // Single pass over `messages`, substituting the one updated entry. Long
-  // conversations call this on every request, so avoid `.map()` here — its
-  // closure dispatch and identity copies show up in profiling.
-  const result = messages.slice()
-  result[index] = next
-  return result
-}
-
-const markMessages = (
-  messages: ReadonlyArray<Message>,
-  strategy: NonNullable<CachePolicyObject["messages"]>,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<Message> => {
-  if (messages.length === 0) return messages
-  if (strategy === "latest-user-message")
-    return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget)
-  if (strategy === "latest-assistant")
-    return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget)
-  const start = Math.max(0, messages.length - strategy.tail)
-  let next = messages
-  for (let i = start; i < messages.length; i++) next = markMessageAt(next, i, hint, budget)
-  return next
-}
-
-const countHints = (request: LLMRequest) =>
-  request.tools.reduce((count, tool) => count + (tool.cache === undefined ? 0 : 1), 0) +
-  request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
-  request.messages.reduce(
-    (count, message) =>
-      count +
-      message.content.reduce(
-        (contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0),
-        0,
-      ),
-    0,
-  )
-
-export const applyCachePolicy = (request: LLMRequest): LLMRequest => {
-  if (!RESPECTS_INLINE_HINTS.has(request.model.route.id)) return request
-  if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")) return request
-  const policy = resolve(request.cache)
-  if (!policy.tools && !policy.system && !policy.messages) return request
-
-  const hint = makeHint(policy.ttlSeconds)
-  const budget = { remaining: Math.max(0, BREAKPOINT_CAP - countHints(request)) }
-  const tools = policy.tools ? markLastTool(request.tools, hint, budget) : request.tools
-  const system = policy.system ? markSystemBoundaries(request.system, hint, budget) : request.system
-  const messages = policy.messages ? markMessages(request.messages, policy.messages, hint, budget) : request.messages
-
-  if (tools === request.tools && system === request.system && messages === request.messages) return request
-  return LLMRequest.update(request, { tools, system, messages })
-}

packages/ai/src/image-client.ts

@@ -1,38 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { RequestExecutor } from "./route/executor"
-import type { ImageOptions, ImageRequest, ImageRequestFor, ImageResponse } from "./image"
-import type { AIError } from "./schema"
-
-export type Execute = RequestExecutor.Interface["execute"]
-
-export interface Interface {
-  readonly generate: <Options extends ImageOptions>(
-    request: ImageRequestFor<Options>,
-  ) => Effect.Effect<ImageResponse, AIError>
-}
-
-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 layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    return Service.of({
-      generate: (request) => request.model.route.generate(request, executor.execute),
-    })
-  }),
-)
-
-export const ImageClient = {
-  Service,
-  layer,
-  generate,
-} as const

packages/ai/src/image.ts

@@ -1,163 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpOptions, InvalidRequestReason, AIError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema"
-import { ImageClient, Service, type Execute as ImageExecute } from "./image-client"
-
-export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
-  readonly id: string
-  readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, AIError>
-}
-
-export type ImageOptions = Record<string, unknown>
-
-export class ImageModel<Options extends ImageOptions = ImageOptions> {
-  declare protected readonly _Options: (options: Options) => Options
-  readonly id: ModelID
-  readonly provider: ProviderID
-  readonly route: ImageRoute<Options>
-  readonly http?: HttpOptions
-
-  constructor(input: ImageModel.Input<Options>) {
-    this.id = input.id
-    this.provider = input.provider
-    this.route = input.route
-    this.http = input.http
-  }
-
-  static make<Options extends ImageOptions = ImageOptions>(input: ImageModel.MakeInput<Options>) {
-    return new ImageModel<Options>({
-      id: ModelID.make(input.id),
-      provider: ProviderID.make(input.provider),
-      route: input.route,
-      http: input.http,
-    })
-  }
-}
-
-export namespace ImageModel {
-  export interface Input<Options extends ImageOptions = ImageOptions> {
-    readonly id: ModelID
-    readonly provider: ProviderID
-    readonly route: ImageRoute<Options>
-    readonly http?: HttpOptions
-  }
-
-  export interface MakeInput<Options extends ImageOptions = ImageOptions>
-    extends Omit<Input<Options>, "id" | "provider"> {
-    readonly id: string | ModelID
-    readonly provider: string | ProviderID
-  }
-}
-
-export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
-  expected: "Image.Model",
-})
-
-const ImageBytesInput = Schema.Struct({
-  type: Schema.Literal("bytes"),
-  data: Schema.Uint8Array,
-  mediaType: Schema.String,
-})
-const ImageUrlInput = Schema.Struct({
-  type: Schema.Literal("url"),
-  url: Schema.String,
-})
-const ImageFileIDInput = Schema.Struct({
-  type: Schema.Literal("file-id"),
-  id: Schema.String,
-})
-const ImageFileURIInput = Schema.Struct({
-  type: Schema.Literal("file-uri"),
-  uri: Schema.String,
-  mediaType: Schema.String,
-})
-
-export const ImageInputSchema = Schema.Union([
-  ImageBytesInput,
-  ImageUrlInput,
-  ImageFileIDInput,
-  ImageFileURIInput,
-]).pipe(Schema.toTaggedUnion("type"))
-export type ImageInput = Schema.Schema.Type<typeof ImageInputSchema>
-
-export const ImageInput = {
-  bytes: (data: Uint8Array, mediaType: string): ImageInput => ({ type: "bytes", data, mediaType }),
-  url: (url: string): ImageInput => ({ type: "url", url }),
-  file: (id: string): ImageInput => ({ type: "file-id", id }),
-  fileUri: (uri: string, mediaType: string): ImageInput => ({ type: "file-uri", uri, mediaType }),
-} as const
-
-export class ImageRequest extends Schema.Class<ImageRequest>("Image.Request")({
-  model: ImageModelSchema,
-  prompt: Schema.String,
-  images: Schema.optional(Schema.Array(ImageInputSchema)),
-  options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  http: Schema.optional(HttpOptions),
-}) {
-  declare protected readonly _ImageRequest: void
-}
-
-export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<ImageRequest, "model" | "options"> & {
-  readonly model: ImageModel<Options>
-  readonly options?: Options
-}
-
-export type ImageModelOptions<Model> = Model extends ImageModel<infer Options> ? Options : never
-
-export type ImageRequestInput<Model extends object = ImageModel> = Omit<
-  ConstructorParameters<typeof ImageRequest>[0],
-  "model" | "options" | "http"
-> & {
-  readonly model: Model
-  readonly options?: NoInfer<ImageModelOptions<Model>>
-  readonly http?: HttpOptions.Input
-} & (Model extends ImageModel<ImageModelOptions<Model>> ? unknown : never)
-
-export class GeneratedImage extends Schema.Class<GeneratedImage>("Image.Generated")({
-  mediaType: Schema.String,
-  data: Schema.Union([Schema.String, Schema.Uint8Array]),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {}
-
-export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")({
-  images: Schema.Array(GeneratedImage),
-  usage: Schema.optional(Usage),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {
-  get image() {
-    return this.images[0]
-  }
-}
-
-export function request<const Model extends object>(
-  input: ImageRequestInput<Model>,
-): ImageRequestFor<ImageModelOptions<Model>>
-export function request(input: ImageRequest): ImageRequest
-export function request(input: ImageRequest | ImageRequestInput) {
-  if (input instanceof ImageRequest) return input
-  return new ImageRequest({
-    ...input,
-    model: input.model as unknown as ImageModel,
-    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-  })
-}
-
-export function generate<const Model extends object>(
-  input: ImageRequestInput<Model>,
-): Effect.Effect<ImageResponse, AIError, Service>
-export function generate(input: ImageRequest): Effect.Effect<ImageResponse, AIError, Service>
-export function generate(input: ImageRequest | ImageRequestInput) {
-  return Effect.try({
-    try: () => (input instanceof ImageRequest ? input : request(input)),
-    catch: (error) =>
-      new AIError({
-        module: "Image",
-        method: "generate",
-        reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
-      }),
-  }).pipe(Effect.flatMap((request) => ImageClient.generate(request as unknown as ImageRequestFor<ImageOptions>)))
-}
-
-export const Image = {
-  request,
-  generate,
-} as const

packages/ai/src/index.ts

@@ -1,39 +0,0 @@
-export { LLMClient } from "./route/client"
-export { ImageClient } from "./image-client"
-export { Auth } from "./route/auth"
-export { Provider } from "./provider"
-export { ProviderPackage } from "./provider-package"
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error"
-export type {
-  RouteLanguageModelInput,
-  RouteRoutedLanguageModelInput,
-  Interface as LLMClientShape,
-  Service as LLMClientService,
-} from "./route/client"
-export * from "./schema"
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image"
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image"
-export { Image } from "./image"
-export { Tool, ToolFailure, toDefinitions } from "./tool"
-export { ToolRuntime } from "./tool-runtime"
-export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime"
-export type {
-  AnyExecutableTool,
-  AnyTool,
-  ExecutableTool,
-  ExecutableTools,
-  Definition as ToolShape,
-  ToolExecute,
-  ToolExecuteContext,
-  ToolModelOutputInput,
-  Tools,
-  ToolSchema,
-  ToolToModelOutput,
-} from "./tool"
-export * as LLM from "./llm"
-export type {
-  Definition as ProviderDefinition,
-  LanguageModelFactory as ProviderLanguageModelFactory,
-  LanguageModelOptions as ProviderLanguageModelOptions,
-} from "./provider"
-export type { Definition as ProviderPackageDefinition, Settings as ProviderPackageSettings } from "./provider-package"

packages/ai/src/llm.ts

@@ -1,180 +0,0 @@
-import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient, Service } from "./route/client"
-import {
-  GenerationOptions,
-  HttpOptions,
-  InvalidProviderOutputReason,
-  AIError,
-  LLMEvent,
-  LLMRequest,
-  LLMResponse,
-  Message,
-  LanguageModel,
-  SystemPart,
-  ToolChoice,
-  ToolDefinition,
-  type ContentPart,
-  type LanguageModelProviderOptions,
-} from "./schema"
-import { make as makeTool, toDefinitions, type ToolSchema } from "./tool"
-
-/** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
-export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<
-  ConstructorParameters<typeof LLMRequest>[0],
-  "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"
-> & {
-  readonly model: SelectedLanguageModel
-  readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
-  readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
-  readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolDefinition.Input>
-  readonly toolChoice?: ToolChoice.Input
-  readonly generation?: GenerationOptions.Input
-  readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
-  readonly http?: HttpOptions.Input
-}
-
-export const generate = LLMClient.generate
-
-export const stream = LLMClient.stream
-
-export const request = <const SelectedLanguageModel extends LanguageModel>(
-  input: RequestInput<SelectedLanguageModel>,
-) => {
-  const {
-    system: requestSystem,
-    prompt,
-    messages,
-    tools,
-    toolChoice: requestToolChoice,
-    generation: requestGeneration,
-    providerOptions: requestProviderOptions,
-    http: requestHttp,
-    ...rest
-  } = input
-  return new LLMRequest({
-    ...rest,
-    system: SystemPart.content(requestSystem),
-    messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolDefinition.make) ?? [],
-    toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
-    generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
-    providerOptions: requestProviderOptions,
-    http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
-  })
-}
-
-const GENERATE_OBJECT_TOOL_NAME = "generate_object"
-
-const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool."
-
-type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<
-  RequestInput<SelectedLanguageModel>,
-  "tools" | "toolChoice"
->
-
-export class GenerateObjectResponse<T> {
-  constructor(
-    readonly object: T,
-    readonly response: LLMResponse,
-  ) {}
-
-  get events() {
-    return this.response.events
-  }
-
-  get usage() {
-    return this.response.usage
-  }
-}
-
-export interface GenerateObjectOptions<
-  S extends ToolSchema<any>,
-  SelectedLanguageModel extends LanguageModel = LanguageModel,
-> extends GenerateObjectBase<SelectedLanguageModel> {
-  readonly schema: S
-}
-
-export interface GenerateObjectDynamicOptions<SelectedLanguageModel extends LanguageModel = LanguageModel>
-  extends GenerateObjectBase<SelectedLanguageModel> {
-  /** Raw JSON Schema object describing the expected output shape. */
-  readonly jsonSchema: JsonSchema.JsonSchema
-}
-
-const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
-  options: GenerateObjectBase,
-  tool: ReturnType<typeof makeTool>,
-) {
-  const baseRequest = request(options)
-  const generateRequest = LLMRequest.update(baseRequest, {
-    tools: toDefinitions({ [GENERATE_OBJECT_TOOL_NAME]: tool }),
-    toolChoice: ToolChoice.named(GENERATE_OBJECT_TOOL_NAME),
-  })
-  const response = yield* LLMClient.generate(generateRequest)
-  const call = response.toolCalls.find(
-    (event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME,
-  )
-  if (!call || !LLMEvent.is.toolCall(call))
-    return yield* new AIError({
-      module: "LLM",
-      method: "generateObject",
-      reason: new InvalidProviderOutputReason({
-        message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
-      }),
-    })
-  const object = yield* tool._decode(call.input).pipe(
-    Effect.mapError(
-      (error) =>
-        new AIError({
-          module: "LLM",
-          method: "generateObject",
-          reason: new InvalidProviderOutputReason({
-            message: `generateObject: tool input failed schema decode: ${error.message}`,
-          }),
-        }),
-    ),
-  )
-  return new GenerateObjectResponse(object, response)
-})
-
-/**
- * Run a model and decode its output against `schema`. Works on every protocol
- * because it forces a synthetic tool call internally — provider-native JSON
- * modes are intentionally avoided so behaviour is uniform.
- *
- * Two input modes:
- *
- * 1. `schema: EffectSchema<T>` — `.object` is decoded and typed as `T`.
- *    Decode failures surface as `AIError`.
- * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
- *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
- */
-export function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(
-  options: GenerateObjectOptions<S, SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>
-export function generateObject<const SelectedLanguageModel extends LanguageModel>(
-  options: GenerateObjectDynamicOptions<SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>
-export function generateObject(options: GenerateObjectOptions<ToolSchema<any>> | GenerateObjectDynamicOptions) {
-  if ("schema" in options) {
-    const { schema, ...rest } = options
-    return runGenerateObject(
-      rest,
-      makeTool({
-        description: GENERATE_OBJECT_TOOL_DESCRIPTION,
-        parameters: schema,
-        success: Schema.Unknown as ToolSchema<unknown>,
-        execute: () => Effect.void,
-      }),
-    )
-  }
-  const { jsonSchema, ...rest } = options
-  return runGenerateObject(
-    rest,
-    makeTool({
-      description: GENERATE_OBJECT_TOOL_DESCRIPTION,
-      jsonSchema,
-      execute: () => Effect.void,
-    }),
-  )
-}

packages/ai/src/protocols.ts

@@ -1 +0,0 @@
-export * from "./protocols/index"

packages/ai/src/protocols/gemini.ts

@@ -1,614 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
-import {
-  LLMEvent,
-  Usage,
-  type FinishReason,
-  type JsonSchema,
-  type LLMRequest,
-  type MediaPart,
-  type ProviderOptions,
-  type ProviderMetadata,
-  type TextPart,
-  type ToolCallPart,
-  type ToolDefinition,
-} from "../schema"
-import { JsonObject, optionalArray, ProviderShared } from "./shared"
-import { GeminiToolSchema } from "./utils/gemini-tool-schema"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-
-const ADAPTER = "gemini"
-const MEDIA_MIMES = new Set<string>(ProviderShared.MEDIA_MIMES)
-export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
-
-export interface OptionsInput {
-  readonly [key: string]: unknown
-  readonly cachedContent?: string
-  readonly safetySettings?: ReadonlyArray<{
-    readonly category:
-      | "HARM_CATEGORY_UNSPECIFIED"
-      | "HARM_CATEGORY_HATE_SPEECH"
-      | "HARM_CATEGORY_DANGEROUS_CONTENT"
-      | "HARM_CATEGORY_HARASSMENT"
-      | "HARM_CATEGORY_SEXUALLY_EXPLICIT"
-      | "HARM_CATEGORY_CIVIC_INTEGRITY"
-      | (string & {})
-    readonly threshold:
-      | "HARM_BLOCK_THRESHOLD_UNSPECIFIED"
-      | "BLOCK_LOW_AND_ABOVE"
-      | "BLOCK_MEDIUM_AND_ABOVE"
-      | "BLOCK_ONLY_HIGH"
-      | "BLOCK_NONE"
-      | "OFF"
-      | (string & {})
-  }>
-  readonly serviceTier?: "standard" | "flex" | "priority" | (string & {})
-  readonly thinkingConfig?: {
-    readonly thinkingBudget?: number
-    readonly includeThoughts?: boolean
-    readonly thinkingLevel?: "minimal" | "low" | "medium" | "high" | (string & {})
-  }
-}
-
-export type ProviderOptionsInput = ProviderOptions & {
-  readonly gemini?: OptionsInput
-}
-
-// =============================================================================
-// Request Body Schema
-// =============================================================================
-const GeminiTextPart = Schema.Struct({
-  text: Schema.String,
-  thought: Schema.optional(Schema.Boolean),
-  thoughtSignature: Schema.optional(Schema.String),
-})
-
-const GeminiInlineDataPart = Schema.Struct({
-  inlineData: Schema.Struct({
-    mimeType: Schema.String,
-    data: Schema.String,
-  }),
-})
-type GeminiInlineDataPart = Schema.Schema.Type<typeof GeminiInlineDataPart>
-
-const GeminiFunctionCallPart = Schema.Struct({
-  functionCall: Schema.Struct({
-    id: Schema.optional(Schema.String),
-    name: Schema.String,
-    args: Schema.Unknown,
-  }),
-  thoughtSignature: Schema.optional(Schema.String),
-})
-
-const GeminiFunctionResponsePart = Schema.Struct({
-  functionResponse: Schema.Struct({
-    id: Schema.optional(Schema.String),
-    name: Schema.String,
-    response: Schema.Unknown,
-    parts: Schema.optional(Schema.Array(GeminiInlineDataPart)),
-  }),
-})
-
-const GeminiContentPart = Schema.Union([
-  GeminiTextPart,
-  GeminiInlineDataPart,
-  GeminiFunctionCallPart,
-  GeminiFunctionResponsePart,
-])
-
-const GeminiContent = Schema.Struct({
-  role: Schema.Literals(["user", "model"]),
-  parts: Schema.Array(GeminiContentPart),
-})
-type GeminiContent = Schema.Schema.Type<typeof GeminiContent>
-
-const GeminiSystemInstruction = Schema.Struct({
-  parts: Schema.Array(Schema.Struct({ text: Schema.String })),
-})
-
-const GeminiFunctionDeclaration = Schema.Struct({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: Schema.optional(JsonObject),
-})
-
-const GeminiTool = Schema.Struct({
-  functionDeclarations: Schema.Array(GeminiFunctionDeclaration),
-})
-
-const GeminiToolConfig = Schema.Struct({
-  functionCallingConfig: Schema.Struct({
-    mode: Schema.Literals(["AUTO", "NONE", "ANY"]),
-    allowedFunctionNames: optionalArray(Schema.String),
-  }),
-})
-
-const GeminiThinkingConfig = Schema.Struct({
-  thinkingBudget: Schema.optional(Schema.Number),
-  includeThoughts: Schema.optional(Schema.Boolean),
-  thinkingLevel: Schema.optional(Schema.String),
-})
-
-const GeminiSafetySetting = Schema.Struct({
-  category: Schema.String,
-  threshold: Schema.String,
-})
-
-const GeminiGenerationConfig = Schema.Struct({
-  maxOutputTokens: Schema.optional(Schema.Number),
-  temperature: Schema.optional(Schema.Number),
-  topP: Schema.optional(Schema.Number),
-  topK: Schema.optional(Schema.Number),
-  stopSequences: optionalArray(Schema.String),
-  thinkingConfig: Schema.optional(GeminiThinkingConfig),
-})
-
-const GeminiBodyFields = {
-  cachedContent: Schema.optional(Schema.String),
-  contents: Schema.Array(GeminiContent),
-  safetySettings: optionalArray(GeminiSafetySetting),
-  serviceTier: Schema.optional(Schema.String),
-  systemInstruction: Schema.optional(GeminiSystemInstruction),
-  tools: optionalArray(GeminiTool),
-  toolConfig: Schema.optional(GeminiToolConfig),
-  generationConfig: Schema.optional(GeminiGenerationConfig),
-}
-const GeminiBody = Schema.Struct(GeminiBodyFields)
-export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>
-
-const GeminiUsage = Schema.Struct({
-  cachedContentTokenCount: Schema.optional(Schema.Number),
-  thoughtsTokenCount: Schema.optional(Schema.Number),
-  promptTokenCount: Schema.optional(Schema.Number),
-  candidatesTokenCount: Schema.optional(Schema.Number),
-  totalTokenCount: Schema.optional(Schema.Number),
-})
-type GeminiUsage = Schema.Schema.Type<typeof GeminiUsage>
-
-const GeminiCandidate = Schema.Struct({
-  content: Schema.optional(GeminiContent),
-  finishReason: Schema.optional(Schema.String),
-})
-
-const GeminiEvent = Schema.Struct({
-  candidates: optionalArray(GeminiCandidate),
-  usageMetadata: Schema.optional(GeminiUsage),
-})
-type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>
-
-interface ParserState {
-  readonly finishReason?: string
-  readonly hasToolCalls: boolean
-  readonly nextToolCallId: number
-  readonly usage?: Usage
-  readonly lifecycle: Lifecycle.State
-  readonly reasoningSignature?: 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 objects, derive `nullable: true` from `type: [..., "null"]`,
-//    coerce `const` to `[const]` enum, recurse properties/items, propagate
-//    only an allowlisted set of keys (description, required, format, type,
-//    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
-// =============================================================================
-const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema) => ({
-  name: tool.name,
-  description: tool.description,
-  parameters: GeminiToolSchema.convert(inputSchema),
-})
-
-const lowerToolConfig = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
-  ProviderShared.matchToolChoice("Gemini", toolChoice, {
-    auto: () => ({ functionCallingConfig: { mode: "AUTO" as const } }),
-    none: () => ({ functionCallingConfig: { mode: "NONE" as const } }),
-    required: () => ({ functionCallingConfig: { mode: "ANY" as const } }),
-    tool: (name) => ({ functionCallingConfig: { mode: "ANY" as const, allowedFunctionNames: [name] } }),
-  })
-
-const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part: TextPart | MediaPart) {
-  if (part.type === "text") return { text: part.text }
-  const media = yield* ProviderShared.validateMedia("Gemini", part, MEDIA_MIMES)
-  return { inlineData: { mimeType: media.mime, data: media.base64 } }
-})
-
-const googleMetadata = (metadata: Record<string, unknown>): ProviderMetadata => ({ google: metadata })
-
-const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.thoughtSignature === "string"
-    ? google.thoughtSignature
-    : undefined
-}
-
-const functionCallId = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.functionCallId === "string"
-    ? google.functionCallId
-    : undefined
-}
-
-const lowerToolCall = (part: ToolCallPart) => ({
-  functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
-  thoughtSignature: thoughtSignature(part.providerMetadata),
-})
-
-const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
-  const contents: GeminiContent[] = []
-
-  for (const message of request.messages) {
-    if (message.role === "system") {
-      const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message)
-      const previous = contents.at(-1)
-      if (previous?.role === "user")
-        contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
-      else contents.push({ role: "user", parts: [{ text: part.text }] })
-      continue
-    }
-
-    if (message.role === "user") {
-      const parts: Array<Schema.Schema.Type<typeof GeminiContentPart>> = []
-      for (const part of message.content) {
-        if (!ProviderShared.supportsContent(part, ["text", "media"]))
-          return yield* ProviderShared.unsupportedContent("Gemini", "user", ["text", "media"])
-        parts.push(yield* lowerUserPart(part))
-      }
-      contents.push({ role: "user", parts })
-      continue
-    }
-
-    if (message.role === "assistant") {
-      const parts: Array<Schema.Schema.Type<typeof GeminiContentPart>> = []
-      for (const part of message.content) {
-        if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
-          return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
-        if (part.type === "text") {
-          parts.push({ text: part.text })
-          continue
-        }
-        if (part.type === "reasoning") {
-          parts.push({ text: part.text, thought: true, thoughtSignature: thoughtSignature(part.providerMetadata) })
-          continue
-        }
-        if (part.type === "tool-call") {
-          parts.push(lowerToolCall(part))
-          continue
-        }
-      }
-      contents.push({ role: "model", parts })
-      continue
-    }
-
-    const parts: Array<Schema.Schema.Type<typeof GeminiContentPart>> = []
-    for (const part of message.content) {
-      if (!ProviderShared.supportsContent(part, ["tool-result"]))
-        return yield* ProviderShared.unsupportedContent("Gemini", "tool", ["tool-result"])
-      if (part.result.type !== "content") {
-        parts.push({
-          functionResponse: {
-            id: functionCallId(part.providerMetadata),
-            name: part.name,
-            response: {
-              name: part.name,
-              content: ProviderShared.toolResultText(part),
-            },
-          },
-        })
-        continue
-      }
-      const content: ReadonlyArray<Tool.Content> = part.result.value
-      const text = content.filter((item) => item.type === "text").map((item) => item.text)
-      const media: GeminiInlineDataPart[] = []
-      for (const item of content) {
-        if (item.type === "text") continue
-        const value = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES)
-        media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
-      }
-      parts.push({
-        functionResponse: {
-          id: functionCallId(part.providerMetadata),
-          name: part.name,
-          response: {
-            name: part.name,
-            content: text.join("\n"),
-          },
-          parts: media.length > 0 ? media : undefined,
-        },
-      })
-    }
-    contents.push({ role: "user", parts })
-  }
-
-  return contents
-})
-
-const resolveOptions = (request: LLMRequest) => {
-  const input = request.providerOptions?.gemini
-  const value = input?.thinkingConfig
-  const thinkingConfig = {
-    thinkingBudget:
-      ProviderShared.isRecord(value) && typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined,
-    includeThoughts:
-      ProviderShared.isRecord(value) && typeof value.includeThoughts === "boolean"
-        ? value.includeThoughts
-        : ProviderShared.isRecord(value)
-          ? true
-          : undefined,
-    thinkingLevel:
-      ProviderShared.isRecord(value) && typeof value.thinkingLevel === "string" ? value.thinkingLevel : undefined,
-  }
-  return {
-    cachedContent: typeof input?.cachedContent === "string" ? input.cachedContent : undefined,
-    safetySettings: mapSafetySettings(input?.safetySettings),
-    serviceTier: typeof input?.serviceTier === "string" ? input.serviceTier : undefined,
-    thinkingConfig: Object.values(thinkingConfig).some((item) => item !== undefined) ? thinkingConfig : undefined,
-  }
-}
-
-function mapSafetySettings(value: unknown) {
-  if (!Array.isArray(value)) return undefined
-  const settings = value.flatMap((item) =>
-    ProviderShared.isRecord(item) && typeof item.category === "string" && typeof item.threshold === "string"
-      ? [{ category: item.category, threshold: item.threshold }]
-      : [],
-  )
-  return settings
-}
-
-const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const hasTools = request.tools.length > 0
-  const generation = request.generation
-  const options = resolveOptions(request)
-  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const generationConfig = {
-    maxOutputTokens: generation?.maxTokens,
-    temperature: generation?.temperature,
-    topP: generation?.topP,
-    topK: generation?.topK,
-    stopSequences: generation?.stop,
-    thinkingConfig: options.thinkingConfig,
-  }
-
-  return {
-    cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(request),
-    safetySettings: options.safetySettings,
-    serviceTier: options.serviceTier,
-    systemInstruction:
-      request.system.length === 0 ? undefined : { parts: [{ text: ProviderShared.joinText(request.system) }] },
-    tools: hasTools
-      ? [
-          {
-            functionDeclarations: request.tools.map((tool) =>
-              lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
-            ),
-          },
-        ]
-      : undefined,
-    toolConfig: hasTools && request.toolChoice ? yield* lowerToolConfig(request.toolChoice) : undefined,
-    generationConfig: Object.values(generationConfig).some((value) => value !== undefined)
-      ? generationConfig
-      : undefined,
-  }
-})
-
-// =============================================================================
-// Stream Parsing
-// =============================================================================
-// Gemini reports `promptTokenCount` (inclusive total) with a
-// `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
-// of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
-// to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage: GeminiUsage | undefined) => {
-  if (!usage) return undefined
-  const cached = usage.cachedContentTokenCount
-  const nonCached = ProviderShared.subtractTokens(usage.promptTokenCount, cached)
-  // `candidatesTokenCount` is visible-only; sum with thoughts to produce the
-  // inclusive `outputTokens` the contract expects. Only compute the total
-  // when the visible component is reported — otherwise we'd fabricate an
-  // inclusive number from a partial breakdown.
-  const outputTokens =
-    usage.candidatesTokenCount !== undefined ? usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0) : undefined
-  return new Usage({
-    inputTokens: usage.promptTokenCount,
-    outputTokens,
-    nonCachedInputTokens: nonCached,
-    cacheReadInputTokens: cached,
-    reasoningTokens: usage.thoughtsTokenCount,
-    totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
-    providerMetadata: { google: usage },
-  })
-}
-
-const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean): FinishReason => {
-  if (finishReason === undefined) return hasToolCalls ? "tool-calls" : "unknown"
-  if (finishReason === "STOP") return hasToolCalls ? "tool-calls" : "stop"
-  if (finishReason === "MAX_TOKENS") return "length"
-  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" ||
-    finishReason === "NO_IMAGE" ||
-    finishReason === "TOO_MANY_TOOL_CALLS" ||
-    finishReason === "MISSING_THOUGHT_SIGNATURE" ||
-    finishReason === "MALFORMED_RESPONSE"
-  )
-    return "error"
-  return "unknown"
-}
-
-const finish = (state: ParserState): ReadonlyArray<LLMEvent> =>
-  state.finishReason || state.usage
-    ? (() => {
-        const events: LLMEvent[] = []
-        const lifecycle = state.reasoningSignature
-          ? Lifecycle.reasoningEnd(
-              state.lifecycle,
-              events,
-              "reasoning-0",
-              googleMetadata({ thoughtSignature: state.reasoningSignature }),
-            )
-          : state.lifecycle
-        Lifecycle.finish(lifecycle, events, {
-          reason: {
-            normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
-            raw: state.finishReason,
-          },
-          usage: state.usage,
-        })
-        return events
-      })()
-    : []
-
-const step = (state: ParserState, event: GeminiEvent) => {
-  const nextState = {
-    ...state,
-    usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? state.usage) : state.usage,
-  }
-  const candidate = event.candidates?.[0]
-  if (!candidate?.content)
-    return Effect.succeed([
-      { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },
-      [],
-    ] as const)
-
-  const events: LLMEvent[] = []
-  let hasToolCalls = nextState.hasToolCalls
-  let lifecycle = nextState.lifecycle
-  let nextToolCallId = nextState.nextToolCallId
-  let reasoningSignature = nextState.reasoningSignature
-
-  for (const part of candidate.content.parts) {
-    if ("thoughtSignature" in part && part.thoughtSignature && "thought" in part && part.thought)
-      reasoningSignature = part.thoughtSignature
-    if ("text" in part && part.text.length > 0) {
-      if (part.thought) {
-        lifecycle = Lifecycle.reasoningDelta(
-          lifecycle,
-          events,
-          "reasoning-0",
-          part.text,
-          part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
-        )
-        continue
-      }
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text)
-      continue
-    }
-
-    if ("functionCall" in part) {
-      const input = part.functionCall.args
-      const id = `tool_${nextToolCallId++}`
-      const metadata = {
-        ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
-        ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
-      }
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
-      lifecycle = Lifecycle.stepStart(lifecycle, events)
-      events.push(
-        LLMEvent.toolCall({
-          id,
-          name: part.functionCall.name,
-          input,
-          providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
-        }),
-      )
-      hasToolCalls = true
-    }
-  }
-
-  return Effect.succeed([
-    {
-      ...nextState,
-      hasToolCalls,
-      lifecycle,
-      nextToolCallId,
-      reasoningSignature,
-      finishReason: candidate.finishReason ?? nextState.finishReason,
-    },
-    events,
-  ] as const)
-}
-
-// =============================================================================
-// Protocol And Gemini Route
-// =============================================================================
-/**
- * The Gemini protocol — request body construction, body schema, and the
- * streaming-event state machine. Used by Google AI Studio Gemini and (once
- * registered) Vertex Gemini.
- */
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: {
-    schema: GeminiBody,
-    from: fromRequest,
-  },
-  stream: {
-    event: Protocol.jsonEvent(GeminiEvent),
-    initial: () => ({ hasToolCalls: false, nextToolCallId: 0, lifecycle: Lifecycle.initial() }),
-    step,
-    onHalt: finish,
-  },
-})
-
-export const route = Route.make({
-  id: ADAPTER,
-  provider: "google",
-  providerMetadataKey: "google",
-  protocol,
-  // Gemini's path embeds the model id and pins SSE framing at the URL level.
-  endpoint: Endpoint.path(({ request }) => `/models/${request.model.id}:streamGenerateContent?alt=sse`, {
-    baseURL: DEFAULT_BASE_URL,
-  }),
-  auth: Auth.none,
-  framing: Framing.sse,
-})
-
-export * as Gemini from "./gemini"

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

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

packages/ai/src/protocols/index.ts

@@ -1,9 +0,0 @@
-export * as AnthropicMessages from "./anthropic-messages"
-export * as BedrockConverse from "./bedrock-converse"
-export * as Gemini from "./gemini"
-export * as OpenAIChat from "./openai-chat"
-export * as OpenAIImages from "./openai-images"
-export * as OpenAICompatibleChat from "./openai-compatible-chat"
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"
-export * as OpenAIResponses from "./openai-responses"
-export * as OpenResponses from "./open-responses"

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

@@ -1,884 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { HttpTransport } from "../route/transport"
-import { Protocol } from "../route/protocol"
-import {
-  AIError,
-  LLMEvent,
-  Usage,
-  type FinishReason,
-  type FinishReasonDetails,
-  type CacheHint,
-  type JsonSchema,
-  type LLMRequest,
-  type MediaPart,
-  type ReasoningPart,
-  type TextPart,
-  type ToolCallPart,
-  type ToolDefinition,
-} from "../schema"
-import { classifyProviderFailure } from "../provider-error"
-import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
-import { OpenAIOptions } from "./utils/openai-options"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
-
-const ADAPTER = "openai-chat"
-const IMAGE_MIMES = new Set<string>(ProviderShared.IMAGE_MIMES)
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"])
-export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
-export const PATH = "/chat/completions"
-
-// =============================================================================
-// Request Body Schema
-// =============================================================================
-// The body schema is the provider-native JSON body. `fromRequest` below builds
-// this shape from the common `LLMRequest`, then `Route.make` validates and
-// JSON-encodes it before transport.
-const OpenAIChatCacheControl = Schema.Struct({
-  type: Schema.Literal("ephemeral"),
-  ttl: Schema.optional(Schema.String),
-})
-
-const OpenAIChatFunction = Schema.Struct({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonObject,
-})
-
-const OpenAIChatTool = Schema.Struct({
-  type: Schema.tag("function"),
-  function: OpenAIChatFunction,
-  cache_control: Schema.optional(OpenAIChatCacheControl),
-})
-type OpenAIChatTool = Schema.Schema.Type<typeof OpenAIChatTool>
-
-const OpenAIChatAssistantToolCall = Schema.Struct({
-  id: Schema.String,
-  type: Schema.tag("function"),
-  function: Schema.Struct({
-    name: Schema.String,
-    arguments: Schema.String,
-  }),
-})
-type OpenAIChatAssistantToolCall = Schema.Schema.Type<typeof OpenAIChatAssistantToolCall>
-
-// Intentionally omit Gemini's provider-specific `extra_content.google.thought_signature`
-// extension until direct Google OpenAI-compatible routing is supported here:
-// https://github.com/vercel/ai/issues/11590
-// https://github.com/vercel/ai/pull/11745
-// https://ai.google.dev/gemini-api/docs/thought-signatures#openai
-
-const OpenAIChatUserContent = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("text"),
-    text: Schema.String,
-    cache_control: Schema.optional(OpenAIChatCacheControl),
-  }),
-  Schema.Struct({
-    type: Schema.Literal("image_url"),
-    image_url: Schema.Struct({ url: Schema.String }),
-  }),
-])
-
-const OpenAIChatMessage = Schema.Union([
-  Schema.Struct({
-    role: Schema.Literal("system"),
-    content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
-  }),
-  Schema.Struct({
-    role: Schema.Literal("user"),
-    content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
-  }),
-  Schema.StructWithRest(
-    Schema.Struct({
-      role: Schema.Literal("assistant"),
-      content: Schema.NullOr(Schema.String),
-      tool_calls: optionalArray(OpenAIChatAssistantToolCall),
-      reasoning_content: Schema.optional(Schema.String),
-      reasoning: Schema.optional(Schema.String),
-      reasoning_text: Schema.optional(Schema.String),
-      reasoning_details: Schema.optional(Schema.Unknown),
-      cache_control: Schema.optional(OpenAIChatCacheControl),
-    }),
-    [Schema.Record(Schema.String, Schema.Unknown)],
-  ),
-  Schema.Struct({
-    role: Schema.Literal("tool"),
-    tool_call_id: Schema.String,
-    content: Schema.String,
-    cache_control: Schema.optional(OpenAIChatCacheControl),
-  }),
-]).pipe(Schema.toTaggedUnion("role"))
-type OpenAIChatMessage = Schema.Schema.Type<typeof OpenAIChatMessage>
-
-const OpenAIChatToolChoice = Schema.Union([
-  Schema.Literals(["auto", "none", "required"]),
-  Schema.Struct({
-    type: Schema.tag("function"),
-    function: Schema.Struct({ name: Schema.String }),
-  }),
-])
-
-export const bodyFields = {
-  model: Schema.String,
-  messages: Schema.Array(OpenAIChatMessage),
-  tools: optionalArray(OpenAIChatTool),
-  tool_choice: Schema.optional(OpenAIChatToolChoice),
-  stream: Schema.Literal(true),
-  stream_options: Schema.optional(Schema.Struct({ include_usage: Schema.Boolean })),
-  store: Schema.optional(Schema.Boolean),
-  reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
-  max_completion_tokens: Schema.optional(Schema.Number),
-  max_tokens: Schema.optional(Schema.Number),
-  temperature: Schema.optional(Schema.Number),
-  top_p: Schema.optional(Schema.Number),
-  frequency_penalty: Schema.optional(Schema.Number),
-  presence_penalty: Schema.optional(Schema.Number),
-  seed: Schema.optional(Schema.Number),
-  stop: optionalArray(Schema.String),
-}
-const OpenAIChatBody = Schema.Struct(bodyFields)
-export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>
-
-// =============================================================================
-// Streaming Event Schema
-// =============================================================================
-// The event schema is one decoded SSE `data:` payload. `Framing.sse` splits the
-// byte stream into strings, then `Protocol.jsonEvent` decodes each string into
-// this provider-native event shape.
-const OpenAIChatUsage = Schema.StructWithRest(
-  Schema.Struct({
-    prompt_tokens: optionalNull(Schema.Number),
-    completion_tokens: optionalNull(Schema.Number),
-    total_tokens: optionalNull(Schema.Number),
-    prompt_tokens_details: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({
-          cached_tokens: optionalNull(Schema.Number),
-          cache_write_tokens: optionalNull(Schema.Number),
-        }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-    completion_tokens_details: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({
-          reasoning_tokens: optionalNull(Schema.Number),
-          accepted_prediction_tokens: optionalNull(Schema.Number),
-          rejected_prediction_tokens: optionalNull(Schema.Number),
-        }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-
-const OpenAIChatToolCallDeltaFunction = Schema.Struct({
-  name: optionalNull(Schema.String),
-  arguments: optionalNull(Schema.String),
-})
-
-const OpenAIChatToolCallDelta = Schema.Struct({
-  index: optionalNull(Schema.Number),
-  id: optionalNull(Schema.String),
-  function: optionalNull(OpenAIChatToolCallDeltaFunction),
-})
-type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta>
-
-const OpenAIChatDelta = Schema.StructWithRest(
-  Schema.Struct({
-    content: optionalNull(Schema.String),
-    reasoning_content: optionalNull(Schema.String),
-    reasoning: optionalNull(Schema.String),
-    reasoning_text: optionalNull(Schema.String),
-    reasoning_details: optionalNull(Schema.Unknown),
-    tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-
-const OpenAIChatChoice = Schema.Struct({
-  delta: optionalNull(OpenAIChatDelta),
-  finish_reason: optionalNull(Schema.String),
-  native_finish_reason: optionalNull(Schema.String),
-})
-
-const OpenAIChatError = Schema.Struct({
-  code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
-  message: Schema.String,
-})
-
-export const OpenAIChatEvent = Schema.Struct({
-  choices: optionalNull(Schema.Array(OpenAIChatChoice)),
-  usage: optionalNull(OpenAIChatUsage),
-  error: optionalNull(OpenAIChatError),
-})
-export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
-type OpenAIChatRequestMessage = LLMRequest["messages"][number]
-
-interface PendingToolDelta {
-  readonly id?: string
-  readonly name?: string
-  readonly input: string
-}
-
-export interface ParserState {
-  readonly tools: ToolStream.State<number>
-  readonly pendingTools: Partial<Record<number, PendingToolDelta>>
-  readonly toolCallEvents: ReadonlyArray<LLMEvent>
-  readonly usage?: Usage
-  readonly finishReason?: FinishReasonDetails
-  readonly lifecycle: Lifecycle.State
-  readonly reasoningField?: string
-  readonly reasoningDetails: Array<unknown>
-  readonly reasoningDetailsObserved: boolean
-  readonly reasoningEmitted: boolean
-  readonly latestToolIndex?: number
-  readonly nextToolIndex: number
-}
-
-// =============================================================================
-// Request Lowering
-// =============================================================================
-// Lowering is the only place that knows how common LLM messages map onto the
-// OpenAI Chat wire format. Keep provider quirks here instead of leaking native
-// fields into `LLMRequest`.
-interface LoweringOptions {
-  readonly cacheControl?: (
-    cache: CacheHint | undefined,
-  ) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined
-}
-
-const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema, options: LoweringOptions): OpenAIChatTool => ({
-  type: "function",
-  function: {
-    name: tool.name,
-    description: tool.description,
-    parameters: ToolSchemaProjection.openAI(inputSchema),
-  },
-  cache_control: options.cacheControl?.(tool.cache),
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
-  ProviderShared.matchToolChoice("OpenAI Chat", toolChoice, {
-    auto: () => "auto" as const,
-    none: () => "none" as const,
-    required: () => "required" as const,
-    tool: (name) => ({ type: "function" as const, function: { name } }),
-  })
-
-const lowerToolCall = (part: ToolCallPart): OpenAIChatAssistantToolCall => ({
-  id: part.id,
-  type: "function",
-  function: {
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-  },
-})
-
-const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart) {
-  const media = yield* ProviderShared.validateMedia("OpenAI Chat", part, IMAGE_MIMES)
-  return { type: "image_url" as const, image_url: { url: media.dataUrl } }
-})
-
-const openAICompatibleReasoningContent = (native: unknown) =>
-  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined
-
-const reasoningField = (part: ReasoningPart) => {
-  const field = part.providerMetadata?.openai?.reasoningField
-  return typeof field === "string" ? field : undefined
-}
-
-const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown) => {
-  const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.openai?.reasoningDetails
-    return Array.isArray(details) ? details : []
-  })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))) return observed
-  if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
-}
-
-const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  options: LoweringOptions,
-) {
-  const content: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
-  for (const part of message.content) {
-    if (part.type === "text") {
-      content.push({ type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) })
-      continue
-    }
-    if (part.type === "media") {
-      content.push(yield* lowerMedia(part))
-      continue
-    }
-    return yield* ProviderShared.unsupportedContent("OpenAI Chat", "user", ["text", "media"])
-  }
-  if (content.every((part) => part.type === "text" && part.cache_control === undefined))
-    return {
-      role: "user" as const,
-      content: content.map((part) => (part.type === "text" ? part.text : "")).join(""),
-    }
-  return { role: "user" as const, content }
-})
-
-const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  configuredField?: string,
-  options: LoweringOptions = {},
-) {
-  const content: TextPart[] = []
-  const reasoning: ReasoningPart[] = []
-  const toolCalls: OpenAIChatAssistantToolCall[] = []
-  for (const part of message.content) {
-    if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
-      return yield* ProviderShared.unsupportedContent("OpenAI Chat", "assistant", ["text", "reasoning", "tool-call"])
-    if (part.type === "text") {
-      content.push(part)
-      continue
-    }
-    if (part.type === "reasoning") {
-      reasoning.push(part)
-      continue
-    }
-    if (part.type === "tool-call") {
-      toolCalls.push(lowerToolCall(part))
-      continue
-    }
-  }
-  const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible)
-  const observedField = reasoning.map(reasoningField).find((value) => value !== undefined)
-  const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
-  const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))
-  const field = (() => {
-    if (configuredField !== undefined) return configuredField
-    if (reasoning.length === 0) return undefined
-    if (observedField !== undefined) return observedField
-    if (nativeReasoning !== undefined) return "reasoning_content"
-    if (!fullyStructured) return "reasoning_content"
-  })()
-  const reasoningText = (() => {
-    if (configuredField !== undefined) return reasoning.length === 0 ? (nativeReasoning ?? "") : text
-    if (reasoning.length === 0) return nativeReasoning
-    return text
-  })()
-  const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined)
-  const result = {
-    role: "assistant" as const,
-    content: content.length === 0 ? null : ProviderShared.joinText(content),
-    tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
-    reasoning_details: details,
-    cache_control: options.cacheControl?.(cached && "cache" in cached ? cached.cache : undefined),
-  }
-  if (field === undefined || reasoningText === undefined) return result
-  return { ...result, [field]: reasoningText }
-})
-
-const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
-  message: OpenAIChatRequestMessage,
-  options: LoweringOptions,
-) {
-  const messages: OpenAIChatMessage[] = []
-  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"])
-    if (part.result.type !== "content") {
-      messages.push({
-        role: "tool",
-        tool_call_id: part.id,
-        content: ProviderShared.toolResultText(part),
-        cache_control: options.cacheControl?.(part.cache),
-      })
-      continue
-    }
-    const content: ReadonlyArray<Tool.Content> = part.result.value
-    const text = content.filter((item) => item.type === "text").map((item) => item.text)
-    messages.push({
-      role: "tool",
-      tool_call_id: part.id,
-      content: text.join("\n"),
-      cache_control: options.cacheControl?.(part.cache),
-    })
-    const files = content.filter((item) => item.type === "file")
-    images.push(
-      ...(yield* Effect.forEach(files, (item) =>
-        lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }),
-      )),
-    )
-  }
-  return { messages, images }
-})
-
-const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  reasoningField?: string,
-  options: LoweringOptions = {},
-) {
-  if (message.role === "user") return [yield* lowerUserMessage(message, options)]
-  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField, options)]
-  return (yield* lowerToolMessages(message, options)).messages
-})
-
-const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request: LLMRequest, options: LoweringOptions) {
-  const system: OpenAIChatMessage[] =
-    request.system.length === 0
-      ? []
-      : request.system.some((part) => part.cache !== undefined) && options.cacheControl !== undefined
-        ? [
-            {
-              role: "system",
-              content: request.system.map((part) => ({
-                type: "text",
-                text: part.text,
-                cache_control: options.cacheControl?.(part.cache),
-              })),
-            },
-          ]
-        : [{ role: "system", content: ProviderShared.joinText(request.system) }]
-  const messages = [...system]
-  const pendingImages: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
-  const flushImages = () => {
-    if (pendingImages.length === 0) return
-    messages.push({ role: "user", content: pendingImages.splice(0) })
-  }
-  for (const message of request.messages) {
-    if (message.role === "system") {
-      const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message)
-      if (pendingImages.length > 0) {
-        messages.push({
-          role: "user",
-          content: [
-            ...pendingImages.splice(0),
-            { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
-          ],
-        })
-        continue
-      }
-      const previous = messages.at(-1)
-      if (previous?.role === "user" && typeof previous.content === "string")
-        messages[messages.length - 1] = options.cacheControl?.(part.cache)
-          ? {
-              role: "user",
-              content: [
-                { type: "text", text: previous.content },
-                { type: "text", text: part.text, cache_control: options.cacheControl(part.cache) },
-              ],
-            }
-          : { role: "user", content: `${previous.content}\n${part.text}` }
-      else if (previous?.role === "user" && Array.isArray(previous.content))
-        messages[messages.length - 1] = {
-          role: "user",
-          content: [
-            ...previous.content,
-            { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
-          ],
-        }
-      else
-        messages.push(
-          options.cacheControl?.(part.cache)
-            ? {
-                role: "user",
-                content: [{ type: "text", text: part.text, cache_control: options.cacheControl(part.cache) }],
-              }
-            : { role: "user", content: part.text },
-        )
-      continue
-    }
-    if (message.role === "tool") {
-      const lowered = yield* lowerToolMessages(message, options)
-      messages.push(...lowered.messages)
-      pendingImages.push(...lowered.images)
-      continue
-    }
-    flushImages()
-    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, options)))
-  }
-  flushImages()
-  return messages
-})
-
-const lowerOptions = (request: LLMRequest) => {
-  const options = OpenAIOptions.resolve(request)
-  return {
-    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
-  }
-}
-
-export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
-  request: LLMRequest,
-  options: LoweringOptions = {},
-) {
-  // `fromRequest` returns the provider body only. Endpoint, auth, framing,
-  // validation, and HTTP execution are composed by `Route.make`.
-  const reasoningField = request.model.compatibility?.reasoningField
-  if (reasoningField && RESERVED_REASONING_FIELDS.has(reasoningField))
-    return yield* ProviderShared.invalidRequest(
-      `OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`,
-    )
-  const generation = request.generation
-  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens"
-  return {
-    model: request.model.id,
-    messages: yield* lowerMessages(request, options),
-    tools:
-      request.tools.length === 0
-        ? undefined
-        : request.tools.map((tool) =>
-            lowerTool(
-              tool,
-              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
-              options,
-            ),
-          ),
-    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
-    stream: true as const,
-    stream_options: { include_usage: true },
-    ...(maxTokensField === "max_completion_tokens"
-      ? { max_completion_tokens: generation?.maxTokens }
-      : { max_tokens: generation?.maxTokens }),
-    temperature: generation?.temperature,
-    top_p: generation?.topP,
-    frequency_penalty: generation?.frequencyPenalty,
-    presence_penalty: generation?.presencePenalty,
-    seed: generation?.seed,
-    stop: generation?.stop,
-    ...lowerOptions(request),
-  }
-})
-
-// =============================================================================
-// Stream Parsing
-// =============================================================================
-// Streaming parsers are small state machines: every event returns a new state
-// plus the common `LLMEvent`s produced by that event. Tool calls are accumulated
-// because OpenAI streams JSON arguments across multiple deltas.
-const mapFinishReason = (reason: string | null | undefined): FinishReason => {
-  if (reason === "stop") return "stop"
-  if (reason === "length") return "length"
-  if (reason === "content_filter") return "content-filter"
-  if (reason === "function_call" || reason === "tool_calls") return "tool-calls"
-  if (reason === "error") return "error"
-  return "unknown"
-}
-
-// OpenAI Chat reports `prompt_tokens` (inclusive total) with a
-// cached-read and cache-write subsets, and `completion_tokens` (inclusive
-// total) with a `reasoning_tokens` subset. We pass the inclusive totals
-// through and derive the non-cached breakdown so the `AI.Usage` contract is
-// satisfied on both sides.
-const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
-  if (!usage) return undefined
-  const input = usage.prompt_tokens ?? undefined
-  const output = usage.completion_tokens ?? undefined
-  const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined
-  const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined
-  const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined
-  const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite))
-  return new Usage({
-    inputTokens: input,
-    outputTokens: output,
-    nonCachedInputTokens: nonCached,
-    cacheReadInputTokens: cached,
-    cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: reasoning,
-    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { openai: usage },
-  })
-}
-
-const toolIndexByID = (
-  tools: ParserState["tools"],
-  pendingTools: ParserState["pendingTools"],
-  id: string | undefined,
-) => {
-  if (!id) return undefined
-  const entry = Object.entries({ ...pendingTools, ...tools }).find(([, tool]) => tool?.id === id)
-  return entry ? Number(entry[0]) : undefined
-}
-
-const reasoningDelta = (
-  delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined,
-  configuredField?: string,
-) => {
-  if (!delta) return undefined
-  const fields = new Set([configuredField, "reasoning_content", "reasoning", "reasoning_text"])
-  for (const field of fields) {
-    if (field === undefined) continue
-    const text = delta[field]
-    if (typeof text === "string" && text.length > 0) return { field, text }
-  }
-  return undefined
-}
-
-const detailText = (details: ReadonlyArray<unknown>) => {
-  const text = details.flatMap((detail) => {
-    if (!isRecord(detail)) return []
-    if (detail.type === "reasoning.text" && typeof detail.text === "string" && detail.text) return [detail.text]
-    if (detail.type === "reasoning.summary" && typeof detail.summary === "string" && detail.summary)
-      return [detail.summary]
-    return []
-  })
-  if (text.length > 0) return text.join("")
-}
-
-const appendReasoningDetails = (result: Array<unknown>, details: ReadonlyArray<unknown>) => {
-  for (const detail of details) {
-    const previous = result.at(-1)
-    if (
-      !isRecord(previous) ||
-      previous.type !== "reasoning.text" ||
-      !isRecord(detail) ||
-      detail.type !== "reasoning.text" ||
-      conflictingReasoningTextDetails(previous, detail)
-    ) {
-      result.push(detail)
-      continue
-    }
-    result[result.length - 1] = {
-      ...previous,
-      ...Object.fromEntries(Object.entries(detail).filter((entry) => entry[1] !== undefined)),
-      text: `${typeof previous.text === "string" ? previous.text : ""}${typeof detail.text === "string" ? detail.text : ""}`,
-      signature: mergeDetailValue(previous.signature, detail.signature),
-      format: mergeDetailValue(previous.format, detail.format),
-    }
-  }
-}
-
-const mergeDetailValue = (previous: unknown, current: unknown) =>
-  previous || current || (previous !== undefined ? previous : current)
-
-const conflictingReasoningTextDetails = (previous: Record<string, unknown>, current: Record<string, unknown>) =>
-  conflictingDetailValue(previous.id, current.id) ||
-  conflictingDetailValue(previous.index, current.index) ||
-  conflictingDetailValue(previous.format, current.format) ||
-  (Boolean(previous.signature) && Boolean(current.signature) && previous.signature !== current.signature)
-
-const conflictingDetailValue = (previous: unknown, current: unknown) =>
-  previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current
-
-const reasoningMetadata = (field: ParserState["reasoningField"], details?: ReadonlyArray<unknown>) => ({
-  openai: {
-    ...(field ? { reasoningField: field } : {}),
-    ...(details ? { reasoningDetails: details } : {}),
-  },
-})
-
-const step = (state: ParserState, event: OpenAIChatEvent) =>
-  Effect.gen(function* () {
-    if (event.error)
-      return yield* new AIError({
-        module: ADAPTER,
-        method: "stream",
-        reason: classifyProviderFailure({
-          message: event.error.message,
-          code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
-          status: typeof event.error.code === "number" ? event.error.code : undefined,
-        }),
-      })
-    const events: LLMEvent[] = []
-    const usage = mapUsage(event.usage) ?? state.usage
-    const choice = event.choices?.[0]
-    const rawFinishReason = choice?.finish_reason
-    const finishReason =
-      rawFinishReason !== undefined && rawFinishReason !== null
-        ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }
-        : state.finishReason
-    const delta = choice?.delta
-    const toolDeltas = delta?.tool_calls ?? []
-    let tools = state.tools
-    let pendingTools = state.pendingTools
-    let latestToolIndex = state.latestToolIndex
-    let nextToolIndex = state.nextToolIndex
-
-    let lifecycle = state.lifecycle
-
-    const reasoning = reasoningDelta(delta, state.reasoningField)
-    const hasLateContent =
-      Boolean(delta?.content) ||
-      reasoning !== undefined ||
-      (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
-      toolDeltas.some(
-        (tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments),
-      )
-    if (state.finishReason !== undefined) {
-      if (hasLateContent)
-        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason")
-      return [{ ...state, usage }, events] as const
-    }
-
-    const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined)
-    const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
-    if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
-    const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined
-    const deltaMetadata = reasoningMetadata(reasoningField)
-    const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text
-    if (!state.lifecycle.text.has("text-0") && text !== undefined)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
-    else if (
-      reasoningDetailsObserved &&
-      !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || toolDeltas.length > 0)
-    )
-      lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
-    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
-
-    if (delta?.content) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
-    }
-
-    // Compatible providers may omit indexes. Prefer durable identity, then use
-    // batch position for parallel deltas or the latest call for sparse chunks.
-    for (const [position, tool] of toolDeltas.entries()) {
-      const matched = toolIndexByID(tools, pendingTools, tool.id || undefined)
-      const fallback = toolDeltas.length > 1 ? position : (latestToolIndex ?? position)
-      const fallbackTool = tools[fallback] ?? pendingTools[fallback]
-      const index =
-        tool.index ?? matched ??
-        (tool.id && fallbackTool?.id && fallbackTool.id !== tool.id ? nextToolIndex : fallback)
-      const current = tools[index]
-      const pending = pendingTools[index]
-      const id = current?.id ?? pending?.id ?? (tool.id || undefined)
-      const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined)
-      const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`
-      latestToolIndex = index
-      nextToolIndex = Math.max(nextToolIndex, index + 1)
-      if (!current && (!id || !name)) {
-        pendingTools = {
-          ...pendingTools,
-          [index]: { id: id || undefined, name: name || undefined, input: text },
-        }
-        continue
-      }
-      if (pending) {
-        pendingTools = { ...pendingTools }
-        delete pendingTools[index]
-      }
-      const result = ToolStream.appendOrStart(
-        ADAPTER,
-        tools,
-        index,
-        { id: id || undefined, name: name || undefined, text },
-        "OpenAI Chat tool call delta is missing id or name",
-      )
-      if (ToolStream.isError(result)) return yield* result
-      tools = result.tools
-      if (result.events.length) lifecycle = Lifecycle.stepStart(lifecycle, events)
-      events.push(...result.events)
-    }
-
-    if (finishReason !== undefined && state.finishReason === undefined && Object.keys(pendingTools).length > 0)
-      return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name")
-
-    // Finalize accumulated tool inputs eagerly when finish_reason arrives so
-    // valid calls and malformed local calls settle independently.
-    const finished =
-      finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
-        ? yield* ToolStream.finishAll(ADAPTER, tools)
-        : undefined
-
-    return [
-      {
-        tools: finished?.tools ?? tools,
-        pendingTools,
-        toolCallEvents: finished?.events ?? state.toolCallEvents,
-        usage,
-        finishReason,
-        lifecycle,
-        reasoningField,
-        reasoningDetails: state.reasoningDetails,
-        reasoningDetailsObserved,
-        reasoningEmitted,
-        latestToolIndex,
-        nextToolIndex,
-      },
-      events,
-    ] as const
-  })
-
-const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  const events: LLMEvent[] = []
-  const hasToolCalls = state.toolCallEvents.length > 0
-  const reason = state.finishReason
-    ? {
-        ...state.finishReason,
-        normalized:
-          state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
-      }
-    : undefined
-  const metadata = reasoningMetadata(
-    state.reasoningField,
-    state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
-  )
-  const started =
-    state.reasoningDetailsObserved && !state.reasoningEmitted
-      ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
-      : state.lifecycle
-  const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
-  const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
-  events.push(...state.toolCallEvents)
-  if (reason) Lifecycle.finish(lifecycle, events, { reason, usage: state.usage })
-  return events
-}
-
-// =============================================================================
-// Protocol And OpenAI Route
-// =============================================================================
-/**
- * The OpenAI Chat protocol — request body construction, body schema, and the
- * streaming-event state machine. Reused by every route that speaks OpenAI Chat
- * over HTTP+SSE: native OpenAI, DeepSeek, TogetherAI, Cerebras, Baseten,
- * Fireworks, DeepInfra, and (once added) Azure OpenAI Chat.
- */
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: {
-    schema: OpenAIChatBody,
-    from: fromRequest,
-  },
-  stream: {
-    event: Protocol.jsonEvent(OpenAIChatEvent),
-    initial: (request) => ({
-      tools: ToolStream.empty<number>(),
-      pendingTools: {},
-      toolCallEvents: [],
-      lifecycle: Lifecycle.initial(),
-      reasoningField: request.model.compatibility?.reasoningField,
-      reasoningDetails: [],
-      reasoningDetailsObserved: false,
-      reasoningEmitted: false,
-      nextToolIndex: 0,
-    }),
-    step,
-    onHalt: finishEvents,
-  },
-})
-
-export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>()
-
-export const route = Route.make({
-  id: ADAPTER,
-  provider: "openai",
-  providerMetadataKey: "openai",
-  protocol,
-  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
-  auth: Auth.none,
-  transport: httpTransport,
-})
-
-export * as OpenAIChat from "./openai-chat"

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

@@ -1,22 +0,0 @@
-import { Route, type RouteRoutedLanguageModelInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { OpenResponses } from "./open-responses"
-
-const ADAPTER = "openai-compatible-responses"
-
-export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageModelInput
-
-/**
- * Deployment adapter for providers that expose an Open Responses-compatible
- * `/responses` endpoint. Provider helpers configure identity, endpoint, and
- * auth while the semantic protocol remains provider-neutral.
- */
-export const route = Route.make({
-  id: ADAPTER,
-  providerMetadataKey: "openresponses",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
-})
-
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"

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

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

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

@@ -1,293 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { Protocol } from "../route/protocol"
-import { HttpTransport, WebSocketTransport } from "../route/transport"
-import { LLMEvent, LLMRequest, type JsonSchema, type ToolDefinition } from "../schema"
-import { OpenResponses } from "./open-responses"
-import { optionalArray, ProviderShared } from "./shared"
-import { Lifecycle } from "./utils/lifecycle"
-import { OpenAIImage } from "./utils/openai-image"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-
-const ADAPTER = "openai-responses"
-const NAME = "OpenAI Responses"
-export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
-export const PATH = OpenResponses.PATH
-
-const OpenAIResponsesImageGenerationTool = Schema.Struct({
-  type: Schema.tag("image_generation"),
-  action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
-  background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
-  input_fidelity: Schema.optional(Schema.Literals(["low", "high"])),
-  output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
-  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(OpenAIImage.Size),
-})
-
-const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
-
-const OpenAIResponsesToolChoice = Schema.Union([
-  OpenResponses.ToolChoice,
-  Schema.Struct({ type: Schema.tag("image_generation") }),
-])
-
-const OpenAIResponsesInputItem = Schema.Union([
-  Schema.Struct({
-    role: Schema.tag("assistant"),
-    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
-    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
-  }),
-  OpenResponses.InputItem,
-])
-
-const OpenAIResponsesCoreFields = {
-  ...OpenResponses.coreFields,
-  input: Schema.Array(OpenAIResponsesInputItem),
-  tools: optionalArray(OpenAIResponsesTools),
-  tool_choice: Schema.optional(OpenAIResponsesToolChoice),
-}
-
-const OpenAIResponsesBody = Schema.Struct({
-  ...OpenAIResponsesCoreFields,
-  stream: Schema.Literal(true),
-})
-export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
-
-const OpenAIResponsesWebSocketMessage = Schema.StructWithRest(
-  Schema.Struct({
-    type: Schema.tag("response.create"),
-    ...OpenAIResponsesCoreFields,
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-type OpenAIResponsesWebSocketMessage = Schema.Schema.Type<typeof OpenAIResponsesWebSocketMessage>
-const encodeWebSocketMessage = Schema.encodeSync(Schema.fromJsonString(OpenAIResponsesWebSocketMessage))
-
-const extension = {
-  id: ADAPTER,
-  name: NAME,
-  messagePhase: (value: unknown) => (value === null ? null : undefined),
-  lowerMedia: ({ part, media, request }) => {
-    if (request.model.provider !== "xai" || media.mime !== "application/pdf") return undefined
-    return {
-      type: "input_file",
-      filename: part.filename ?? "document.pdf",
-      file_data: media.base64,
-      mime_type: media.mime,
-    }
-  },
-} satisfies OpenResponses.Extension
-
-const nativeImageToolInput = (tool: ToolDefinition) => {
-  const native = tool.native?.openai
-  return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined
-}
-
-const nativeImageTool = (tool: ToolDefinition) => {
-  const native = nativeImageToolInput(tool)
-  return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined
-}
-
-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, inputSchema)
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
-  ProviderShared.matchToolChoice(NAME, toolChoice, {
-    auto: () => "auto" as const,
-    none: () => "none" as const,
-    required: () => "required" as const,
-    tool: (name) =>
-      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
-        ? ({ type: "image_generation" } as const)
-        : { type: "function" as const, name },
-  })
-
-const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const body = yield* OpenResponses.fromRequestWithExtension(
-    LLMRequest.update(request, { tools: [], toolChoice: undefined }),
-    extension,
-  )
-  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  return {
-    ...body,
-    tools:
-      request.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(request.tools, (tool) =>
-            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
-          ),
-    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
-  } satisfies OpenAIResponsesBody
-})
-
-type HostedToolData = OpenResponses.StreamItem & {
-  readonly id: string
-  readonly status?: string
-  readonly action?: unknown
-  readonly queries?: unknown
-  readonly results?: unknown
-  readonly code?: string
-  readonly container_id?: string
-  readonly outputs?: unknown
-  readonly server_label?: string
-  readonly output?: unknown
-  readonly result?: string
-  readonly output_format?: "png" | "jpeg" | "webp"
-  readonly error?: unknown
-}
-
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
-  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
-  code_interpreter_call: {
-    name: "code_interpreter",
-    input: (item) => ({ code: item.code, container_id: item.container_id }),
-  },
-  computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
-  image_generation_call: { name: "image_generation", input: () => ({}) },
-  mcp_call: {
-    name: "mcp",
-    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
-  },
-  local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
-} as const satisfies Record<string, { readonly name: string; readonly input: (item: HostedToolData) => unknown }>
-
-type HostedToolType = keyof typeof HOSTED_TOOLS
-type HostedToolItem = HostedToolData & { readonly type: HostedToolType }
-
-const isHostedToolItem = (item: OpenResponses.StreamItem): item is HostedToolItem =>
-  item.type in HOSTED_TOOLS && typeof item.id === "string" && item.id.length > 0
-
-const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: HostedToolItem) {
-  const isError = item.error !== undefined && item.error !== null
-  if (item.type === "image_generation_call" && item.result) {
-    yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-      Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")),
-    )
-    const format = item.output_format ?? "png"
-    return {
-      type: "content" as const,
-      value: [
-        {
-          type: "file" as const,
-          uri: `data:image/${format};base64,${item.result}`,
-          mime: `image/${format}`,
-        },
-      ],
-    }
-  }
-  return isError ? { type: "error" as const, value: item.error } : { type: "json" as const, value: item }
-})
-
-const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function* (
-  state: OpenResponses.ParserState,
-  item: HostedToolItem,
-) {
-  const tool = HOSTED_TOOLS[item.type]
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  events.push(
-    LLMEvent.toolCall({
-      id: item.id,
-      name: tool.name,
-      input: tool.input(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-    LLMEvent.toolResult({
-      id: item.id,
-      name: tool.name,
-      result: yield* hostedToolResult(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-  )
-  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
-})
-
-const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
-  if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
-    return onHostedToolDone(state, event.item)
-  return OpenResponses.step(state, event)
-}
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: {
-    schema: OpenAIResponsesBody,
-    from: fromRequest,
-  },
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, extension),
-    step,
-    terminal: OpenResponses.terminal,
-  },
-})
-
-const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BASE_URL })
-const auth = Auth.none
-
-export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
-
-export const route = Route.make({
-  id: ADAPTER,
-  provider: "openai",
-  providerMetadataKey: "openai",
-  protocol,
-  endpoint,
-  auth,
-  transport: httpTransport,
-  defaults: { providerOptions: { openai: { store: false } } },
-})
-
-const decodeWebSocketMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesWebSocketMessage))
-
-const webSocketMessage = (body: OpenAIResponsesBody | Record<string, unknown>) =>
-  Effect.gen(function* () {
-    if (!ProviderShared.isRecord(body))
-      return yield* ProviderShared.invalidRequest("OpenAI Responses WebSocket body must be a JSON object")
-    const { stream: _stream, ...message } = body
-    return yield* decodeWebSocketMessage({ ...message, type: "response.create" })
-  })
-
-export const webSocketTransport = WebSocketTransport.jsonTransport.with<
-  OpenAIResponsesBody,
-  OpenAIResponsesWebSocketMessage
->({
-  toMessage: webSocketMessage,
-  encodeMessage: encodeWebSocketMessage,
-})
-
-export const webSocketRoute = Route.make({
-  id: `${ADAPTER}-websocket`,
-  provider: "openai",
-  providerMetadataKey: "openai",
-  protocol,
-  endpoint,
-  auth,
-  transport: webSocketTransport,
-  defaults: { providerOptions: { openai: { store: false } } },
-})
-
-export * as OpenAIResponses from "./openai-responses"

packages/ai/src/protocols/shared.ts

@@ -1,327 +0,0 @@
-import { Buffer } from "node:buffer"
-import { Tool } from "@opencode-ai/schema/tool"
-import { Effect, Schema, Stream } from "effect"
-import * as Sse from "effect/unstable/encoding/Sse"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import {
-  InvalidProviderOutputReason,
-  InvalidRequestReason,
-  AIError,
-  type ContentPart,
-  type LLMRequest,
-  type MediaPart,
-  type TextPart,
-  type ToolResultPart,
-} from "../schema"
-import { isRecord } from "../utils/record"
-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))
-export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.NullOr(schema))
-
-/**
- * Streaming tool-call accumulator. Adapters that build a tool call across
- * multiple `tool-input-delta` chunks store the partial JSON input string here
- * and finalize it with `parseToolInput` once the call completes.
- */
-export interface ToolAccumulator {
-  readonly id: string
-  readonly name: string
-  readonly input: string
-}
-
-/**
- * `Usage.totalTokens` policy shared by every route. Honors a provider-
- * supplied total; otherwise falls back to `inputTokens + outputTokens` only
- * when at least one is defined. Returns `undefined` when neither input nor
- * output is known so routes don't publish a misleading `0`.
- *
- * Under the additive `AI.Usage` contract, `inputTokens` and `outputTokens`
- * are the non-cached input and visible output only. The provider-supplied
- * `total` is the source of truth when present; the computed fallback
- * under-counts cache and reasoning by design and exists mainly so
- * Anthropic-style providers (which don't surface a total) still get a
- * sensible aggregate on the input + output axes.
- */
-export const totalTokens = (
-  inputTokens: number | undefined,
-  outputTokens: number | undefined,
-  total: number | undefined,
-) => {
-  if (total !== undefined) return total
-  if (inputTokens === undefined && outputTokens === undefined) return undefined
-  return (inputTokens ?? 0) + (outputTokens ?? 0)
-}
-
-/**
- * Subtract `subtrahend` from `total`, clamping to zero if the provider
- * reports a non-sensical breakdown (e.g. `cached_tokens > prompt_tokens`).
- * Used by protocol mappers when deriving a non-overlapping breakdown field
- * from a provider's inclusive total — `nonCachedInputTokens` from
- * `inputTokens - cacheReadInputTokens - cacheWriteInputTokens`.
- *
- * If `total` is `undefined`, returns `undefined` (we don't fabricate
- * counts). If `subtrahend` is `undefined`, returns `total` unchanged. The
- * provider-native breakdown stays available on `Usage.native` for debugging.
- */
-export const subtractTokens = (total: number | undefined, subtrahend: number | undefined): number | undefined => {
-  if (total === undefined) return undefined
-  if (subtrahend === undefined) return total
-  return Math.max(0, total - subtrahend)
-}
-
-/**
- * Sum a list of optional token counts, returning `undefined` only when
- * every value is `undefined` (so we don't fabricate a `0`). Used by
- * protocol mappers to derive the inclusive `inputTokens` total from a
- * provider that natively reports a non-overlapping breakdown
- * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
- */
-export const sumTokens = (...values: ReadonlyArray<number | undefined>): number | undefined => {
-  if (values.every((value) => value === undefined)) return undefined
-  return values.reduce((acc: number, value) => acc + (value ?? 0), 0)
-}
-
-export const eventError = (route: string, message: string, raw?: string) =>
-  new AIError({
-    module: "ProviderShared",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({ route, message, raw }),
-  })
-
-export const parseJson = (route: string, input: string, message: string) =>
-  Effect.try({
-    try: () => decodeJson(input),
-    catch: () => eventError(route, message, input),
-  })
-
-/**
- * Join the `text` field of a list of parts with newlines. Used by routes
- * that flatten system / message content arrays into a single provider string
- * (OpenAI Chat `system` content, OpenAI Responses `system` content, Gemini
- * `systemInstruction.parts[].text`).
- */
-export const joinText = (parts: ReadonlyArray<{ readonly text: string }>) => parts.map((part) => part.text).join("\n")
-
-const escapeSystemUpdateText = (text: string) =>
-  text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
-
-/**
- * Stable fallback representation for chronological `Message.system(...)`
- * updates on routes that do not support that privileged role natively. The
- * wrapper remains visibly lower-authority user text, preserves the original
- * temporal position, and XML-escapes content so it cannot close the wrapper.
- */
-export const wrapSystemUpdate = (parts: ReadonlyArray<{ readonly text: string }>) =>
-  `<system-update>\n${escapeSystemUpdateText(joinText(parts))}\n</system-update>`
-
-/**
- * Chronological system updates deliberately accept text only. Do not insert
- * raw retrieved, tool, or web content into privileged updates: keep untrusted
- * data in ordinary user/tool messages instead.
- */
-export const systemUpdateText = Effect.fn("ProviderShared.systemUpdateText")(function* (
-  route: string,
-  message: LLMRequest["messages"][number],
-) {
-  const content: TextPart[] = []
-  for (const part of message.content) {
-    if (!supportsContent(part, ["text"])) return yield* unsupportedContent(route, "system", ["text"])
-    content.push(part)
-  }
-  return content
-})
-
-/** Lower an unsupported privileged update into visible, in-order user text. */
-export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate")(function* (
-  route: string,
-  message: LLMRequest["messages"][number],
-) {
-  const content = yield* systemUpdateText(route, message)
-  return { type: "text" as const, text: wrapSystemUpdate(content), cache: content.at(-1)?.cache }
-})
-
-/**
- * Parse the streamed JSON input of a tool call. Treats an empty string as
- * `"{}"` — providers occasionally finish a tool call without ever emitting
- * input deltas (e.g. zero-arg tools). The error message is uniform across
- * routes: `Invalid JSON input for <route> tool call <name>`.
- */
-export const parseToolInput = (route: string, name: string, raw: string) =>
-  parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`)
-
-export const IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"] as const
-export const VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"] as const
-export const AUDIO_MIMES = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"] as const
-export const PDF_MIMES = ["application/pdf"] as const
-export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES, ...PDF_MIMES] as const
-export const MAX_MEDIA_ENCODED_BYTES = 28 * 1024 * 1024
-export const MAX_MEDIA_DECODED_BYTES = 20 * 1024 * 1024
-
-const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
-
-export interface ValidatedMedia {
-  readonly mime: string
-  readonly base64: string
-  readonly dataUrl: string
-  readonly bytes: Uint8Array
-}
-
-export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function* (
-  route: string,
-  part: MediaPart,
-  supportedMimes: ReadonlySet<string>,
-) {
-  const mime = part.mediaType.toLowerCase()
-  if (!supportedMimes.has(mime)) return yield* invalidRequest(`${route} does not support media type ${part.mediaType}`)
-
-  let base64: string
-  if (typeof part.data !== "string") {
-    if (part.data.byteLength > MAX_MEDIA_DECODED_BYTES)
-      return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`)
-    base64 = Buffer.from(part.data).toString("base64")
-  } else if (part.data.startsWith("data:")) {
-    const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/s.exec(part.data)
-    if (!match) return yield* invalidRequest(`${route} media data URL must contain valid base64`)
-    if (match[1]!.toLowerCase() !== mime)
-      return yield* invalidRequest(`${route} media type ${part.mediaType} does not match data URL type ${match[1]}`)
-    base64 = match[2]!
-  } else {
-    base64 = part.data
-  }
-
-  if (Buffer.byteLength(base64, "utf8") > MAX_MEDIA_ENCODED_BYTES)
-    return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_ENCODED_BYTES} byte encoded limit`)
-  if (!base64 || base64.length % 4 !== 0 || !base64Pattern.test(base64))
-    return yield* invalidRequest(`${route} media must contain valid base64`)
-  const bytes = Buffer.from(base64, "base64")
-  if (bytes.byteLength > MAX_MEDIA_DECODED_BYTES)
-    return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`)
-  if (bytes.toString("base64") !== base64) return yield* invalidRequest(`${route} media must contain canonical base64`)
-  return { mime, base64, dataUrl: `data:${mime};base64,${base64}`, bytes } satisfies ValidatedMedia
-})
-
-export const validateToolFile = (route: string, part: Tool.FileContent, supportedMimes: ReadonlySet<string>) =>
-  validateMedia(route, { type: "media", mediaType: part.mime, data: part.uri, filename: part.name }, supportedMimes)
-
-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") {
-    const value = part.result.value
-    const prototype =
-      typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value)
-    const structured = Array.isArray(value) || prototype === Object.prototype || prototype === null
-    return structured && isJson(value) ? encodeJson(value) : String(value)
-  }
-  return encodeJson(part.result.value)
-}
-
-export const errorText = (error: unknown) => {
-  if (error instanceof Error) return error.message
-  if (typeof error === "string") return error
-  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return String(error)
-  if (error === null) return "null"
-  if (error === undefined) return "undefined"
-  return "Unknown stream error"
-}
-
-/**
- * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
- * `decodeChunk` sees one JSON string per element. The SSE channel emits a
- * `Retry` control event on its error channel; we drop it here (we don't
- * implement client-driven retries) so the public error channel stays
- * `AIError`.
- */
-export const sseFraming = (bytes: Stream.Stream<Uint8Array, AIError>): Stream.Stream<string, AIError> =>
-  bytes.pipe(
-    Stream.decodeText(),
-    Stream.pipeThroughChannel(Sse.decode()),
-    Stream.catchTag("Retry", () => Stream.empty),
-    Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"),
-    Stream.map((event) => event.data),
-  )
-
-/**
- * Canonical invalid-request constructor. Lift one-line `const invalid =
- * (message) => invalidRequest(message)` aliases out of every
- * route so the error constructor lives in one place. If we ever extend
- * `InvalidRequestReason` with route context or trace metadata, the change
- * lands here.
- */
-export const invalidRequest = (message: string) =>
-  new AIError({
-    module: "ProviderShared",
-    method: "request",
-    reason: new InvalidRequestReason({ message }),
-  })
-
-export const matchToolChoice = <Auto, None, Required, Tool>(
-  route: string,
-  toolChoice: NonNullable<LLMRequest["toolChoice"]>,
-  cases: {
-    readonly auto: () => Auto
-    readonly none: () => None
-    readonly required: () => Required
-    readonly tool: (name: string) => Tool
-  },
-) =>
-  Effect.gen(function* () {
-    if (toolChoice.type === "auto") return cases.auto()
-    if (toolChoice.type === "none") return cases.none()
-    if (toolChoice.type === "required") return cases.required()
-    if (!toolChoice.name) return yield* invalidRequest(`${route} tool choice requires a tool name`)
-    return cases.tool(toolChoice.name)
-  })
-
-type ContentType = ContentPart["type"]
-
-const formatContentTypes = (types: ReadonlyArray<ContentType>) => {
-  if (types.length <= 1) return types[0] ?? ""
-  if (types.length === 2) return `${types[0]} and ${types[1]}`
-  return `${types.slice(0, -1).join(", ")}, and ${types.at(-1)}`
-}
-
-export const supportsContent = <const Type extends ContentType>(
-  part: ContentPart,
-  types: ReadonlyArray<Type>,
-): part is Extract<ContentPart, { readonly type: Type }> => (types as ReadonlyArray<ContentType>).includes(part.type)
-
-export const unsupportedContent = (
-  route: string,
-  role: LLMRequest["messages"][number]["role"],
-  types: ReadonlyArray<ContentType>,
-) => invalidRequest(`${route} ${role} messages only support ${formatContentTypes(types)} content for now`)
-
-/**
- * Build a `validate` step from a Schema decoder. Replaces the per-route
- * lambda body `(payload) => decode(payload).pipe(Effect.mapError((e) =>
- * invalid(e.message)))`. Any decode error is translated into
- * `AIError` carrying the original parse-error message.
- */
-export const validateWith =
-  <A, I, E extends { readonly message: string }>(decode: (input: I) => Effect.Effect<A, E>) =>
-  (payload: I) =>
-    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)))
-
-/**
- * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
- * automatically after caller-supplied headers so routes cannot accidentally
- * send JSON with a stale content type. The body is passed pre-encoded so
- * routes can choose between
- * `Schema.encodeSync(payload)` and `ProviderShared.encodeJson(payload)`.
- */
-export const jsonPost = (input: { readonly url: string; readonly body: string; readonly headers?: Headers.Input }) =>
-  HttpClientRequest.post(input.url).pipe(
-    HttpClientRequest.setHeaders(Headers.set(Headers.fromInput(input.headers), "content-type", "application/json")),
-    HttpClientRequest.bodyText(input.body, "application/json"),
-  )
-
-export * as ProviderShared from "./shared"

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

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

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

@@ -1,105 +0,0 @@
-import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema"
-
-export interface State {
-  readonly stepStarted: boolean
-  readonly text: ReadonlySet<string>
-  readonly reasoning: ReadonlySet<string>
-}
-
-export const initial = (): State => ({ stepStarted: false, text: new Set(), reasoning: new Set() })
-
-export const stepStart = (state: State, events: LLMEvent[]): State => {
-  if (state.stepStarted) return state
-  events.push(LLMEvent.stepStart({ index: 0 }))
-  return { ...state, stepStarted: true }
-}
-
-export const textStart = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
-  if (state.text.has(id)) return state
-  const stepped = stepStart(state, events)
-  events.push(LLMEvent.textStart({ id, providerMetadata }))
-  return { ...stepped, text: new Set([...stepped.text, id]) }
-}
-
-export const textDelta = (state: State, events: LLMEvent[], id: string, text: string): State => {
-  const started = textStart(state, events, id)
-  events.push(LLMEvent.textDelta({ id, text }))
-  return started
-}
-
-export const reasoningStart = (
-  state: State,
-  events: LLMEvent[],
-  id: string,
-  providerMetadata?: ProviderMetadata,
-): State => {
-  if (state.reasoning.has(id)) return state
-  const stepped = stepStart(state, events)
-  events.push(LLMEvent.reasoningStart({ id, providerMetadata }))
-  return { ...stepped, reasoning: new Set([...stepped.reasoning, id]) }
-}
-
-export const reasoningDelta = (
-  state: State,
-  events: LLMEvent[],
-  id: string,
-  text: string,
-  providerMetadata?: ProviderMetadata,
-): State => {
-  const started = reasoningStart(state, events, id, providerMetadata)
-  events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }))
-  return started
-}
-
-export const reasoningEnd = (
-  state: State,
-  events: LLMEvent[],
-  id: string,
-  providerMetadata?: ProviderMetadata,
-): State => {
-  if (!state.reasoning.has(id)) return state
-  const stepped = stepStart(state, events)
-  events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
-  const reasoning = new Set(stepped.reasoning)
-  reasoning.delete(id)
-  return { ...stepped, reasoning }
-}
-
-export const textEnd = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
-  if (!state.text.has(id)) return state
-  const stepped = stepStart(state, events)
-  events.push(LLMEvent.textEnd({ id, providerMetadata }))
-  const text = new Set(stepped.text)
-  text.delete(id)
-  return { ...stepped, text }
-}
-
-const closeOpenBlocks = (state: State, events: LLMEvent[]): State => {
-  for (const id of state.reasoning) events.push(LLMEvent.reasoningEnd({ id }))
-  for (const id of state.text) events.push(LLMEvent.textEnd({ id }))
-  return { ...state, text: new Set(), reasoning: new Set() }
-}
-
-export const finish = (
-  state: State,
-  events: LLMEvent[],
-  input: {
-    readonly reason: FinishReasonDetails
-    readonly usage?: Usage
-    readonly providerMetadata?: ProviderMetadata
-  },
-): State => {
-  const stepped = closeOpenBlocks(stepStart(state, events), events)
-  events.push(
-    LLMEvent.stepFinish({
-      index: 0,
-      reason: input.reason,
-      usage: input.usage,
-      providerMetadata: input.providerMetadata,
-    }),
-    LLMEvent.finish(input),
-  )
-  return { ...stepped, stepStarted: false }
-}
-
-export * as Lifecycle from "./lifecycle"

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

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

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

@@ -1,20 +0,0 @@
-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

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

@@ -1,23 +0,0 @@
-import { ReasoningEfforts } from "../../schema"
-import { OpenResponsesOptions } from "./open-responses-options"
-
-export const OpenAIReasoningEfforts = ReasoningEfforts
-export type OpenAIReasoningEffort = string
-
-// Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
-// in lockstep with `openai-node/src/resources/responses/responses.ts`.
-export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables
-export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable
-export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers
-export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier
-
-export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort
-export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbositySchema
-export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema
-export const OpenAIServiceTier = OpenResponsesOptions.ServiceTierSchema
-
-export const isReasoningEffort = (effort: unknown): effort is OpenAIReasoningEffort => typeof effort === "string"
-
-export const resolve = OpenResponsesOptions.resolve
-
-export * as OpenAIOptions from "./openai-options"

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

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

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

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

packages/ai/src/provider-error.ts

@@ -1,163 +0,0 @@
-import { Option, Schema } from "effect"
-import {
-  AuthenticationReason,
-  ContentPolicyReason,
-  InvalidRequestReason,
-  AIError,
-  ProviderErrorEvent,
-  ProviderInternalReason,
-  QuotaExceededReason,
-  RateLimitReason,
-  UnknownProviderReason,
-  type HttpContext,
-  type HttpRateLimitDetails,
-  type ProviderMetadata,
-} from "./schema"
-
-const patterns = [
-  /prompt is too long/i,
-  /input is too long for requested model/i,
-  /exceeds the context window/i,
-  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
-  /input token count.*exceeds the maximum/i,
-  /tokens in request more than max tokens allowed/i,
-  /maximum prompt length is \d+/i,
-  /reduce the length of the messages/i,
-  /maximum context length is \d+ tokens/i,
-  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
-  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
-  /exceeds the limit of \d+/i,
-  /exceeds the available context size/i,
-  /greater than the context length/i,
-  /context window exceeds limit/i,
-  /exceeded model token limit/i,
-  /context[_ ]length[_ ]exceeded/i,
-  /context length is only \d+ tokens/i,
-  /input length.*exceeds.*context length/i,
-  /prompt too long; exceeded (?:max )?context length/i,
-  /too large for model with \d+ maximum context length/i,
-  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
-  /model_context_window_exceeded/i,
-  /too many tokens/i,
-  /token limit exceeded/i,
-]
-
-const payloadPatterns = [/request_too_large/i, /request entity too large/i, /payload too large/i, /request too large/i]
-
-const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i]
-
-export const isContextOverflow = (message: string) =>
-  !exclusions.some((pattern) => pattern.test(message)) &&
-  (patterns.some((pattern) => pattern.test(message)) || /^400\s*(status code)?\s*\(no body\)/i.test(message))
-
-export const isPayloadTooLarge = (message: string) => payloadPatterns.some((pattern) => pattern.test(message))
-
-export const isContextOverflowFailure = (failure: unknown) =>
-  failure instanceof AIError
-    ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
-    : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow"
-
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"])
-const SERVER_CODES = new Set([
-  "api_error",
-  "internal_error",
-  "internalserverexception",
-  "modelstreamerrorexception",
-  "overloaded_error",
-  "server_error",
-  "server_is_overloaded",
-  "serviceunavailableexception",
-])
-const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"])
-const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
-const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
-const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
-
-export interface ProviderFailure {
-  readonly message: string
-  readonly status?: number | undefined
-  readonly code?: string | undefined
-  readonly retryAfterMs?: number | undefined
-  readonly rateLimit?: HttpRateLimitDetails | undefined
-  readonly http?: HttpContext | undefined
-  readonly providerMetadata?: ProviderMetadata | undefined
-}
-
-// Keep HTTP failures and provider-reported stream failures on one typed path so
-// session retry policy never needs provider-specific string matching.
-export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
-  const body = input.http?.body ?? ""
-  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
-    .filter((code): code is string => code !== undefined)
-    .map((code) => code.toLowerCase())
-  const text = body || input.message
-  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
-  const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)
-
-  if (
-    clientScoped &&
-    (codes.includes("context_length_exceeded") ||
-      codes.includes("model_context_window_exceeded") ||
-      isContextOverflow(text))
-  )
-    return new InvalidRequestReason({ ...common, classification: "context-overflow" })
-  if (input.status === 413 || isPayloadTooLarge(text))
-    return new InvalidRequestReason({ ...common, classification: "payload-too-large" })
-  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
-  if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
-    return new QuotaExceededReason(common)
-  if (input.status === 401) return new AuthenticationReason({ ...common, kind: "invalid" })
-  if (input.status === 403) return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
-  if (codes.includes("authentication_error")) return new AuthenticationReason({ ...common, kind: "invalid" })
-  if (codes.includes("permission_error"))
-    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
-  if (
-    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
-  )
-    return new RateLimitReason({
-      ...common,
-      retryAfterMs: input.retryAfterMs,
-      rateLimit: input.rateLimit,
-    })
-  if (RATE_LIMIT_TEXT.test(text))
-    return new RateLimitReason({
-      ...common,
-      retryAfterMs: input.retryAfterMs,
-      rateLimit: input.rateLimit,
-    })
-  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-    return new ProviderInternalReason({
-      ...common,
-      status: input.status,
-      retryAfterMs: input.retryAfterMs,
-    })
-  if (input.status === 429) {
-    return new RateLimitReason({
-      ...common,
-      retryAfterMs: input.retryAfterMs,
-      rateLimit: input.rateLimit,
-    })
-  }
-  if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
-    return new ProviderInternalReason({
-      ...common,
-      status: input.status,
-      retryAfterMs: input.retryAfterMs,
-    })
-  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
-  if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
-    return new InvalidRequestReason(common)
-  return new UnknownProviderReason({ ...common, status: input.status })
-}
-
-function providerCodes(value: string) {
-  const decoded = Option.getOrUndefined(decodeJson(value))
-  if (!isRecord(decoded)) return []
-  const error = isRecord(decoded.error) ? decoded.error : undefined
-  return [decoded.code, error?.code, error?.type].filter((value): value is string => typeof value === "string")
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}

packages/ai/src/provider-package.ts

@@ -1,21 +0,0 @@
-import type { LanguageModel, ProviderOptions } from "./schema"
-
-export interface Settings extends Readonly<Record<string, unknown>> {
-  readonly baseURL?: string
-  readonly headers?: Readonly<Record<string, string>>
-  readonly body?: Readonly<Record<string, unknown>>
-  readonly limits?: {
-    readonly context: number
-    readonly input?: number
-    readonly output: number
-  }
-}
-
-export interface Definition<
-  ProviderSettings extends Settings = Settings,
-  Options extends ProviderOptions = ProviderOptions,
-> {
-  readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>
-}
-
-export * as ProviderPackage from "./provider-package"

packages/ai/src/provider.ts

@@ -1,36 +0,0 @@
-import type { LanguageModel, ModelID, ProviderID } from "./schema"
-
-export type LanguageModelOptions = Pick<LanguageModel.Input, "defaults" | "compatibility">
-
-/**
- * Advanced structural provider definition helper. Built-in providers should
- * prefer explicit `configure(options).model(id)` facades so deployment config is
- * chosen before model selection. The optional `apis` map remains for external
- * structural providers that expose multiple route selectors behind one provider.
- */
-export type LanguageModelFactory<Options extends LanguageModelOptions = LanguageModelOptions> = (
-  id: string | ModelID,
-  options?: Options,
-) => LanguageModel
-
-type AnyLanguageModelFactory = (...args: never[]) => LanguageModel
-
-export interface Definition<Factory extends AnyLanguageModelFactory = LanguageModelFactory> {
-  readonly id: ProviderID
-  readonly model: Factory
-  readonly apis?: Record<string, AnyLanguageModelFactory>
-}
-
-type DefinitionShape = {
-  readonly id: ProviderID
-  readonly model: (...args: never[]) => LanguageModel
-  readonly apis?: Record<string, (...args: never[]) => LanguageModel>
-}
-
-type NoExtraFields<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>
-
-export const make = <DefinitionType extends DefinitionShape>(
-  definition: NoExtraFields<DefinitionType, DefinitionShape>,
-) => definition
-
-export * as Provider from "./provider"

packages/ai/src/providers.ts

@@ -1 +0,0 @@
-export * from "./providers/index"

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

@@ -1,107 +0,0 @@
-import { Auth } from "../route/auth"
-import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
-import type { ProviderPackage } from "../provider-package"
-import { OpenAIChat } from "../protocols/openai-chat"
-import { OpenAIResponses } from "../protocols/openai-responses"
-import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth"
-import { ProviderID, type ModelID } from "../schema"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-
-export const id = ProviderID.make("amazon-bedrock")
-
-export type Config = RouteDefaultsInput & {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly credentials?: Credentials
-  readonly region?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly auth?: "bearer" | "sigv4"
-  readonly baseURL?: string
-  readonly credentials?: Credentials
-  readonly region?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-const responsesRoute = OpenAIResponses.route.with({
-  id: "bedrock-mantle-responses",
-  provider: id,
-})
-
-const chatRoute = OpenAIChat.route.with({
-  id: "bedrock-mantle-chat",
-  provider: id,
-})
-
-export const routes = [responsesRoute, chatRoute]
-
-const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config) => {
-  const region = input.region ?? input.credentials?.region ?? "us-east-1"
-  const credentials = input.credentials === undefined ? undefined : { ...input.credentials, region }
-  return route.with({
-    endpoint: { baseURL: input.baseURL ?? `https://bedrock-mantle.${region}.api.aws/v1` },
-    auth:
-      input.apiKey === undefined
-        ? BedrockAuth.sigV4(credentials, { service: "bedrock-mantle", name: "Bedrock Mantle" })
-        : Auth.bearer(input.apiKey),
-  })
-}
-
-const defaults = (input: Config) => {
-  const { apiKey: _, baseURL: _baseURL, credentials: _credentials, region: _region, ...rest } = input
-  return rest
-}
-
-export const configure = (input: Config = {}) => {
-  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
-  const configuredChatRoute = configuredRoute(chatRoute, input)
-  const modelDefaults = defaults(input)
-  const responses = (modelID: string | ModelID) =>
-    configuredResponsesRoute
-      .with(withOpenAIOptions(modelID, modelDefaults))
-      .model<OpenAIProviderOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    configuredChatRoute
-      .with(withOpenAIOptions(modelID, modelDefaults))
-      .model<OpenAIProviderOptionsInput>({ id: modelID })
-
-  return {
-    id,
-    model: chat,
-    chat,
-    responses,
-    configure,
-  }
-}
-
-export const provider = configure()
-
-const config = (settings: Settings): Config => {
-  if (settings.auth === "bearer" && settings.apiKey === undefined)
-    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
-  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
-  return {
-    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
-    baseURL: settings.baseURL,
-    credentials: settings.credentials,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-    region: settings.region,
-  }
-}
-
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).responses(modelID)
-export const model = chatModel

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

@@ -1,68 +0,0 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import * as BedrockConverse from "../protocols/bedrock-converse"
-import type { BedrockCredentials } from "../protocols/bedrock-converse"
-
-export const id = ProviderID.make("amazon-bedrock")
-
-export type Config = RouteDefaultsInput & {
-  readonly apiKey?: string
-  readonly headers?: Record<string, string>
-  readonly credentials?: BedrockCredentials
-  /** AWS region. Defaults to `us-east-1` when neither this nor `credentials.region` is set. */
-  readonly region?: string
-  /** Override the computed `https://bedrock-runtime.<region>.amazonaws.com` URL. */
-  readonly baseURL?: string
-}
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly auth?: "bearer" | "sigv4"
-  readonly baseURL?: string
-  readonly credentials?: BedrockCredentials
-  readonly region?: string
-  readonly topP?: number
-}
-export const routes = [BedrockConverse.route]
-
-const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
-
-const configuredRoute = (input: Config) => {
-  const { apiKey, credentials, region, baseURL, ...rest } = input
-  const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
-  return BedrockConverse.route.with({
-    ...rest,
-    provider: id,
-    endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
-    auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
-  })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
-  if (settings.auth === "bearer" && settings.apiKey === undefined)
-    throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
-    throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
-  return configure({
-    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
-    baseURL: settings.baseURL,
-    credentials: settings.credentials,
-    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    region: settings.region,
-  }).model(modelID)
-}

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

@@ -1,2 +0,0 @@
-export { chatModel as model } from "../amazon-bedrock-mantle"
-export type { Settings } from "../amazon-bedrock-mantle"

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

@@ -1,2 +0,0 @@
-export { chatModel as model } from "../../amazon-bedrock-mantle"
-export type { Settings } from "../../amazon-bedrock-mantle"

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

@@ -1,2 +0,0 @@
-export { responsesModel as model } from "../../amazon-bedrock-mantle"
-export type { Settings } from "../../amazon-bedrock-mantle"

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

@@ -1,77 +0,0 @@
-import type { ProviderPackage } from "../provider-package"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
-export const id = ProviderID.make("anthropic-compatible")
-
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly provider?: string
-    readonly baseURL: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  (
-    | { readonly apiKey?: string; readonly authToken?: never }
-    | { readonly apiKey?: never; readonly authToken?: string }
-  ) & {
-    readonly baseURL: string
-    readonly provider?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
-
-export const routes = [AnthropicMessages.route]
-
-const auth = (input: ProviderAuthOption<"optional">) => {
-  if ("auth" in input && input.auth) return input.auth
-  return Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key"))
-}
-
-export const configure = (input: Config) => {
-  if (!input.baseURL) throw new Error("Anthropic-compatible providers require a baseURL")
-  const provider = input.provider ?? "anthropic-compatible"
-  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
-  const route = AnthropicMessages.route.with({
-    ...rest,
-    provider,
-    endpoint: { baseURL },
-    auth: auth(input),
-  })
-  return {
-    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
-  return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}
-
-export * as AnthropicCompatible from "./anthropic-compatible"

packages/ai/src/providers/anthropic.ts

@@ -1,69 +0,0 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { AnthropicCompatible } from "./anthropic-compatible"
-
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
-export const id = ProviderID.make("anthropic")
-
-export const routes = [AnthropicMessages.route]
-
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  (
-    | { readonly apiKey?: string; readonly authToken?: never }
-    | { readonly apiKey?: never; readonly authToken?: string }
-  ) & {
-    readonly baseURL?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
-
-const auth = (options: ProviderAuthOption<"optional">) => {
-  if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("ANTHROPIC_API_KEY"))
-    .pipe(Auth.header("x-api-key"))
-}
-
-export const configure = (input: Config = {}) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  const compatible = AnthropicCompatible.configure({
-    ...rest,
-    auth: auth(input),
-    baseURL: baseURL ?? AnthropicMessages.DEFAULT_BASE_URL,
-    provider: id,
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => compatible.model(modelID),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic apiKey cannot be combined with authToken")
-  return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}

packages/ai/src/providers/azure.ts

@@ -1,147 +0,0 @@
-import { Auth } from "../route/auth"
-import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import * as OpenAIChat from "../protocols/openai-chat"
-import * as OpenAIResponses from "../protocols/openai-responses"
-import { ProviderShared } from "../protocols/shared"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-
-export const id = ProviderID.make("azure")
-const routeAuth = Auth.remove("authorization")
-
-// Azure needs the customer's resource URL; supply either `resourceName`
-// (helper builds the URL) or `baseURL` directly.
-type AzureURL = AtLeastOne<{ readonly resourceName: string; readonly baseURL: string }>
-
-export type LanguageModelOptions = AzureURL &
-  RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly apiVersion?: string
-    readonly queryParams?: Record<string, string>
-    readonly useDeploymentBasedUrls?: boolean
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-export type Config = LanguageModelOptions
-
-export type Settings = ProviderPackage.Settings &
-  AzureURL & {
-    readonly apiKey?: string
-    readonly apiVersion?: string
-    readonly queryParams?: Readonly<Record<string, string>>
-    readonly useDeploymentBasedUrls?: boolean
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
-
-const responsesRoute = OpenAIResponses.route.with({
-  id: "azure-openai-responses",
-  provider: id,
-  auth: routeAuth,
-})
-
-const chatRoute = OpenAIChat.route.with({
-  id: "azure-openai-chat",
-  provider: id,
-  auth: routeAuth,
-})
-
-export const routes = [responsesRoute, chatRoute]
-
-const defaults = (input: Config) => {
-  const {
-    apiKey: _,
-    apiVersion: _apiVersion,
-    resourceName: _resourceName,
-    useDeploymentBasedUrls: _useDeploymentBasedUrls,
-    baseURL: _baseURL,
-    queryParams: _queryParams,
-    ...rest
-  } = input
-  if ("auth" in rest) {
-    const { auth: _, ...withoutAuth } = rest
-    return withoutAuth
-  }
-  return rest
-}
-
-const auth = (input: Config) => {
-  if ("auth" in input && input.auth) return input.auth
-  return Auth.remove("authorization").andThen(
-    Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey")
-      .orElse(Auth.config("AZURE_OPENAI_API_KEY"))
-      .pipe(Auth.header("api-key")),
-  )
-}
-
-const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
-  route.with({
-    auth: auth(input),
-    endpoint: endpoint(input, modelID),
-  })
-
-function endpoint(input: Config, modelID: string | ModelID) {
-  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 }
-  if (input.baseURL !== undefined && !new URL(input.baseURL).hostname.endsWith(".openai.azure.com")) {
-    return { baseURL, query: input.queryParams }
-  }
-  return { baseURL: `${baseURL}/v1`, query }
-}
-
-export const configure = (input: Config) => {
-  const modelDefaults = defaults(input)
-
-  const responses = (modelID: string | ModelID) =>
-    configuredRoute(responsesRoute, input, modelID)
-      .with(withOpenAIOptions(modelID, modelDefaults))
-      .model<OpenAIProviderOptionsInput>({ id: modelID })
-
-  const chat = (modelID: string | ModelID) =>
-    configuredRoute(chatRoute, input, modelID)
-      .with(withOpenAIOptions(modelID, modelDefaults))
-      .model<OpenAIProviderOptionsInput>({ id: modelID })
-
-  return {
-    id,
-    model: responses,
-    responses,
-    chat,
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-const config = (settings: Settings): Config => {
-  const common = {
-    apiKey: settings.apiKey,
-    apiVersion: settings.apiVersion,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
-    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
-  }
-  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
-  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
-  throw new Error("Azure requires resourceName or baseURL")
-}
-
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).responses(modelID)
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
-export const model = responsesModel

packages/ai/src/providers/azure/chat.ts

@@ -1,2 +0,0 @@
-export { chatModel as model } from "../azure"
-export type { Settings } from "../azure"

packages/ai/src/providers/azure/responses.ts

@@ -1,2 +0,0 @@
-export { responsesModel as model } from "../azure"
-export type { Settings } from "../azure"

packages/ai/src/providers/cloudflare.ts

@@ -1,133 +0,0 @@
-import type { Config, Redacted } from "effect"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import { Auth } from "../route/auth"
-import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
-
-export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway")
-export const workersAIID = ProviderID.make("cloudflare-workers-ai")
-export const aiGatewayAuthEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
-export const workersAIAuthEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
-
-type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
-
-type GatewayURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}> & {
-  readonly gatewayId?: string
-}
-
-export type AIGatewayOptions = GatewayURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
-    readonly gatewayApiKey?: CloudflareSecret
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-type WorkersAIURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}>
-
-export type WorkersAIOptions = WorkersAIURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const aiGatewayBaseURL = (input: GatewayURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
-  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
-}
-
-const aiGatewayAuth = (input: AIGatewayOptions) => {
-  if ("auth" in input && input.auth) return input.auth
-  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
-    .orElse(Auth.config("CLOUDFLARE_API_TOKEN"))
-    .orElse(Auth.config("CF_AIG_TOKEN"))
-    .pipe(Auth.bearerHeader("cf-aig-authorization"))
-  if (!("apiKey" in input) || input.apiKey === undefined) return gateway
-  if (input.gatewayApiKey === undefined) return Auth.bearer(input.apiKey)
-  return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey))
-}
-
-export const workersAIBaseURL = (input: WorkersAIURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
-  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
-}
-
-const workersAIAuth = (input: WorkersAIOptions) => {
-  return AuthOptions.bearer(input, workersAIAuthEnvVars)
-}
-
-export const aiGatewayRoute = OpenAICompatibleChat.route.with({
-  id: "cloudflare-ai-gateway",
-  provider: aiGatewayID,
-})
-
-export const workersAIRoute = OpenAICompatibleChat.route.with({
-  id: "cloudflare-workers-ai",
-  provider: workersAIID,
-})
-
-export const routes = [aiGatewayRoute, workersAIRoute]
-
-const aiGatewayDefaults = (options: AIGatewayOptions) => {
-  const {
-    accountId: _accountId,
-    gatewayId: _gatewayId,
-    apiKey: _apiKey,
-    gatewayApiKey: _gatewayApiKey,
-    baseURL: _baseURL,
-    auth: _auth,
-    ...rest
-  } = options
-  return rest
-}
-
-const workersAIDefaults = (options: WorkersAIOptions) => {
-  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...rest } = options
-  return rest
-}
-
-const configureAIGateway = (options: AIGatewayOptions) => {
-  const route = aiGatewayRoute.with({
-    ...aiGatewayDefaults(options),
-    endpoint: { baseURL: aiGatewayBaseURL(options) },
-    auth: aiGatewayAuth(options),
-  })
-  return {
-    id: aiGatewayID,
-    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure: configureAIGateway,
-  }
-}
-
-const configureWorkersAI = (options: WorkersAIOptions) => {
-  const route = workersAIRoute.with({
-    ...workersAIDefaults(options),
-    endpoint: { baseURL: workersAIBaseURL(options) },
-    auth: workersAIAuth(options),
-  })
-  return {
-    id: workersAIID,
-    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure: configureWorkersAI,
-  }
-}
-
-export const CloudflareAIGateway = {
-  id: aiGatewayID,
-  configure: configureAIGateway,
-}
-
-export const CloudflareWorkersAI = {
-  id: workersAIID,
-  configure: configureWorkersAI,
-}

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

@@ -1,83 +0,0 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
-
-export const id = ProviderID.make("google-vertex")
-
-export type Config = RouteDefaultsInput &
-  GoogleVertexShared.OAuthOptions & {
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-const route = OpenAICompatibleChat.route.with({
-  id: "google-vertex-chat",
-  provider: id,
-})
-
-export const routes = [route]
-
-const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
-  const {
-    accessToken: _accessToken,
-    auth: _auth,
-    baseURL,
-    location: inputLocation,
-    project: inputProject,
-    ...rest
-  } = input
-  const location = GoogleVertexShared.location(inputLocation, "global")
-  const project = GoogleVertexShared.project(inputProject)
-  return route.with({
-    ...rest,
-    endpoint: {
-      baseURL:
-        baseURL ??
-        `https://aiplatform.googleapis.com/v1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}/endpoints/openapi`,
-    },
-    auth: GoogleVertexShared.oauth(input, project),
-  })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
-  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}

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

@@ -1,118 +0,0 @@
-import { Effect, Schema, Struct } from "effect"
-import type { ProviderPackage } from "../provider-package"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { Auth } from "../route/auth"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
-const VERSION = "vertex-2023-10-16" as const
-
-export const id = ProviderID.make("google-vertex")
-
-export type Config = RouteDefaultsInput &
-  GoogleVertexShared.OAuthOptions & {
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-}
-
-const route = Route.make({
-  id: "google-vertex-messages",
-  provider: id,
-  providerMetadataKey: "anthropic",
-  protocol: Protocol.make({
-    id: AnthropicMessages.protocol.id,
-    body: {
-      schema: Schema.Struct({
-        ...Struct.omit(AnthropicMessages.AnthropicMessagesBody.fields, ["model"]),
-        anthropic_version: Schema.Literal(VERSION),
-      }),
-      from: (request) =>
-        AnthropicMessages.protocol.body.from(request).pipe(
-          Effect.map((body) => ({
-            ...Struct.omit(body, ["model"]),
-            anthropic_version: VERSION,
-          })),
-        ),
-    },
-    stream: AnthropicMessages.protocol.stream,
-  }),
-  endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
-  auth: Auth.none,
-  framing: Framing.sse,
-})
-
-export const routes = [route]
-
-const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Messages does not support API keys")
-  const {
-    accessToken: _accessToken,
-    auth: _auth,
-    baseURL,
-    location: inputLocation,
-    project: inputProject,
-    ...rest
-  } = input
-  const location = GoogleVertexShared.location(inputLocation, "global")
-  const project = GoogleVertexShared.project(inputProject)
-  return route.with({
-    ...rest,
-    endpoint: {
-      baseURL:
-        baseURL ??
-        `https://${GoogleVertexShared.host(location)}/v1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}/publishers/anthropic/models`,
-    },
-    auth: GoogleVertexShared.oauth(input, project),
-  })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
-  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}

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

@@ -1,88 +0,0 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"
-
-export const id = ProviderID.make("google-vertex")
-
-export type Config = RouteDefaultsInput &
-  GoogleVertexShared.OAuthOptions & {
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-    readonly providerOptions?: OpenResponsesProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
-
-const route = OpenAICompatibleResponses.route.with({
-  id: "google-vertex-responses",
-  provider: id,
-  providerOptions: { openresponses: { store: false } },
-})
-
-export const routes = [route]
-
-const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Responses does not support API keys")
-  const {
-    accessToken: _accessToken,
-    auth: _auth,
-    baseURL,
-    location: inputLocation,
-    project: inputProject,
-    ...rest
-  } = input
-  const location = GoogleVertexShared.location(inputLocation, "global")
-  const project = GoogleVertexShared.project(inputProject)
-  return route.with({
-    ...rest,
-    endpoint: {
-      baseURL:
-        baseURL ??
-        `https://aiplatform.googleapis.com/v1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}/endpoints/openapi`,
-    },
-    auth: GoogleVertexShared.oauth(input, project),
-  })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model<OpenResponsesProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
-  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}

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

@@ -1,77 +0,0 @@
-import type { AnyAuthClient } from "google-auth-library"
-import { Effect, Redacted } from "effect"
-import { Auth, MissingCredentialError } from "../route/auth"
-
-const SCOPE = "https://www.googleapis.com/auth/cloud-platform"
-
-export type OAuthOptions =
-  | { readonly accessToken?: string; readonly auth?: never }
-  | { readonly accessToken?: never; readonly auth?: Auth.Definition }
-
-export type ApiKeyOptions =
-  | (OAuthOptions & { readonly apiKey?: never })
-  | { readonly accessToken?: never; readonly apiKey?: string; readonly auth?: never }
-
-export const project = (value?: string) =>
-  value ??
-  process.env.GOOGLE_VERTEX_PROJECT ??
-  process.env.GOOGLE_CLOUD_PROJECT ??
-  process.env.GCP_PROJECT ??
-  process.env.GCLOUD_PROJECT
-
-export const location = (value: string | undefined, fallback: string) =>
-  value ??
-  process.env.GOOGLE_VERTEX_LOCATION ??
-  process.env.GOOGLE_CLOUD_LOCATION ??
-  process.env.VERTEX_LOCATION ??
-  fallback
-
-export const host = (location: string) => {
-  if (location === "global") return "aiplatform.googleapis.com"
-  // Jurisdictional multi-regions use Regional Endpoint Platform domains.
-  if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`
-  return `${location}-aiplatform.googleapis.com`
-}
-
-export const requireProject = (value: string | undefined) => {
-  if (value) return value
-  throw new Error("Google Vertex requires a project when baseURL is not configured")
-}
-
-export const apiKey = (input: ApiKeyOptions) => {
-  if (input.apiKey !== undefined && (input.accessToken !== undefined || input.auth !== undefined))
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
-  if (input.accessToken !== undefined || input.auth !== undefined) return undefined
-  return input.apiKey ?? process.env.GOOGLE_VERTEX_API_KEY
-}
-
-const adc = (project?: string) => {
-  let client: Promise<AnyAuthClient> | undefined
-  const loadClient = () => {
-    if (client) return client
-    client = import("google-auth-library").then(({ GoogleAuth }) =>
-      new GoogleAuth({ projectId: project, scopes: [SCOPE] }).getClient(),
-    )
-    return client
-  }
-  return Auth.effect(
-    Effect.tryPromise({
-      try: async () => {
-        const token = await (await loadClient()).getAccessToken()
-        if (!token.token) throw new Error("Google ADC returned an empty access token")
-        return Redacted.make(token.token)
-      },
-      catch: () => new MissingCredentialError("Google Application Default Credentials"),
-    }),
-  ).bearer()
-}
-
-export const oauth = (input: OAuthOptions, project?: string) => {
-  if (input.accessToken !== undefined && input.auth !== undefined)
-    throw new Error("Google Vertex accessToken cannot be combined with auth")
-  if (input.auth) return input.auth
-  if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
-  return adc(project)
-}
-
-export * as GoogleVertexShared from "./google-vertex-shared"

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

@@ -1,106 +0,0 @@
-import type { ProviderPackage } from "../provider-package"
-import { Gemini } from "../protocols/gemini"
-import { Auth } from "../route/auth"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-
-export type GeminiOptionsInput = Gemini.OptionsInput
-export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput
-
-export const id = ProviderID.make("google-vertex")
-
-export type Config = RouteDefaultsInput &
-  GoogleVertexShared.ApiKeyOptions & {
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  (
-    | { readonly accessToken?: string; readonly apiKey?: never }
-    | { readonly accessToken?: never; readonly apiKey?: string }
-  ) & {
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
-  }
-
-const route = Route.make({
-  id: "google-vertex-gemini",
-  provider: id,
-  providerMetadataKey: "google",
-  protocol: Gemini.protocol,
-  endpoint: Endpoint.path(({ request }) => {
-    const model = String(request.model.id)
-    return `/${model.startsWith("endpoints/") ? model : `models/${model}`}:streamGenerateContent?alt=sse`
-  }),
-  auth: Auth.none,
-  framing: Framing.sse,
-})
-
-export const routes = [route]
-
-const configuredRoute = (input: Config, modelID: string | ModelID) => {
-  const {
-    accessToken: _accessToken,
-    apiKey: _apiKey,
-    auth: _auth,
-    baseURL,
-    location: inputLocation,
-    project: inputProject,
-    ...rest
-  } = input
-  const apiKey = GoogleVertexShared.apiKey(input)
-  const endpointModel = String(modelID).startsWith("endpoints/")
-  if (apiKey !== undefined && endpointModel)
-    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
-  const location = GoogleVertexShared.location(inputLocation, "us-central1")
-  const project = GoogleVertexShared.project(inputProject)
-  const endpoint =
-    baseURL ??
-    (apiKey
-      ? "https://aiplatform.googleapis.com/v1/publishers/google"
-      : `https://${GoogleVertexShared.host(location)}/v1beta1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}${endpointModel ? "" : "/publishers/google"}`)
-  return route.with({
-    ...rest,
-    endpoint: { baseURL: endpoint },
-    auth: apiKey === undefined ? GoogleVertexShared.oauth(input, project) : Auth.header("x-goog-api-key", apiKey),
-  })
-}
-
-export const configure = (input: Config = {}) => {
-  return {
-    id,
-    model: (modelID: string | ModelID) =>
-      configuredRoute(input, modelID).model<Gemini.ProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined && settings.accessToken !== undefined)
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
-  return configure({
-    ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-}

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

@@ -1,2 +0,0 @@
-export { model } from "../google-vertex-chat"
-export type { Settings } from "../google-vertex-chat"

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

@@ -1,2 +0,0 @@
-export { model } from "../google-vertex"
-export type { Settings } from "../google-vertex"

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

@@ -1,2 +0,0 @@
-export { model } from "../google-vertex-messages"
-export type { Settings } from "../google-vertex-messages"

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

@@ -1,2 +0,0 @@
-export { model } from "../google-vertex-responses"
-export type { Settings } from "../google-vertex-responses"

packages/ai/src/providers/google.ts

@@ -1,70 +0,0 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema"
-import { Gemini } from "../protocols/gemini"
-import { GoogleImages } from "../protocols/google-images"
-
-export type { GoogleImageOptions } from "../protocols/google-images"
-export type GeminiOptionsInput = Gemini.OptionsInput
-export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput
-
-export const id = ProviderID.make("google")
-
-export const routes = [Gemini.route]
-
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Gemini.ProviderOptionsInput
-}
-
-const auth = (options: ProviderAuthOption<"optional">) => {
-  if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
-    .pipe(Auth.header("x-goog-api-key"))
-}
-
-const configuredRoute = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return Gemini.route.with({ ...rest, endpoint: { baseURL }, auth: auth(input) })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  const image = (modelID: string | ModelID) =>
-    GoogleImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL,
-      headers: input.headers,
-      http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http)),
-    })
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model<Gemini.ProviderOptionsInput>({ id: modelID }),
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export const image = provider.image

packages/ai/src/providers/index.ts

@@ -1,19 +0,0 @@
-export * as Anthropic from "./anthropic"
-export * as AnthropicCompatible from "./anthropic-compatible"
-export * as AmazonBedrock from "./amazon-bedrock"
-export * as AmazonBedrockMantle from "./amazon-bedrock-mantle"
-export * as Azure from "./azure"
-export * as Cloudflare from "./cloudflare"
-export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare"
-export * as GitHubCopilot from "./github-copilot"
-export * as Google from "./google"
-export * as GoogleVertex from "./google-vertex"
-export * as GoogleVertexChat from "./google-vertex-chat"
-export * as GoogleVertexMessages from "./google-vertex-messages"
-export * as GoogleVertexResponses from "./google-vertex-responses"
-export * as OpenAI from "./openai"
-export * as OpenAICompatible from "./openai-compatible"
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"
-export * as OpenRouter from "./openrouter"
-export * as XAI from "./xai"
-export * as ZAI from "./zai"

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

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

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

@@ -1,61 +0,0 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"
-
-export type { OpenResponsesOptionsInput, OpenResponsesProviderOptionsInput } from "./open-responses-options"
-
-export const id = ProviderID.make("openai-compatible")
-
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly provider?: string
-    readonly baseURL: string
-    readonly providerOptions?: OpenResponsesProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
-
-export const routes = [OpenAICompatibleResponses.route]
-
-export const configure = (input: Config) => {
-  const provider = input.provider ?? "openai-compatible"
-  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
-  const route = OpenAICompatibleResponses.route.with({
-    ...rest,
-    provider,
-    endpoint: { baseURL },
-    auth: AuthOptions.bearer(input, []),
-  })
-  return {
-    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model<OpenResponsesProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)

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

@@ -1,86 +0,0 @@
-import { ProviderID, type ModelID } from "../schema"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import type { RouteDefaultsInput } from "../route/client"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
-
-export const id = ProviderID.make("openai-compatible")
-
-type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly provider?: string
-    readonly baseURL: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-}
-
-export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const routes = [OpenAICompatibleChat.route]
-
-export const configure = (input: GenericModelOptions) => {
-  const provider = input.provider ?? "openai-compatible"
-  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
-  const route = OpenAICompatibleChat.route.with({
-    ...rest,
-    provider,
-    endpoint: { baseURL },
-    auth: AuthOptions.bearer(input, []),
-  })
-  return {
-    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) =>
-      route.model<OpenAIProviderOptionsInput>({ id: modelID, provider: ProviderID.make(provider) }),
-    configure,
-  }
-}
-
-const define = (profile: OpenAICompatibleProfile) => {
-  const configureProfile = (input: FamilyModelOptions = {}) => {
-    const facade = configure({
-      ...input,
-      baseURL: input.baseURL ?? profile.baseURL,
-      provider: profile.provider,
-    })
-    return {
-      id: ProviderID.make(profile.provider),
-      model: facade.model,
-      configure: configureProfile,
-    }
-  }
-  return configureProfile()
-}
-
-export const provider = {
-  id,
-  configure,
-}
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    provider: settings.provider,
-  }).model(modelID)
-
-export const baseten = define(profiles.baseten)
-export const cerebras = define(profiles.cerebras)
-export const deepinfra = define(profiles.deepinfra)
-export const deepseek = define(profiles.deepseek)
-export const fireworks = define(profiles.fireworks)
-export const groq = define(profiles.groq)
-export const togetherai = define(profiles.togetherai)

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

@@ -1 +0,0 @@
-export * from "../openai-compatible-responses"

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

@@ -1,71 +0,0 @@
-import type { ProviderOptions } from "../schema"
-import { mergeProviderOptions } from "../schema"
-import type { OpenResponsesOptionsInput } from "./open-responses-options"
-
-export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options"
-
-export type OpenAIOptionsInput = OpenResponsesOptionsInput
-
-export type OpenAIProviderOptionsInput = ProviderOptions & {
-  readonly openai?: OpenAIOptionsInput
-}
-
-const definedEntries = (input: Record<string, unknown>) =>
-  Object.entries(input).filter((entry) => entry[1] !== undefined)
-
-const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): ProviderOptions | undefined => {
-  const openai = Object.fromEntries(
-    definedEntries({
-      store: options?.store,
-      promptCacheKey: options?.promptCacheKey,
-      reasoningEffort: options?.reasoningEffort,
-      reasoningSummary: options?.reasoningSummary,
-      include: options?.include,
-      textVerbosity: options?.textVerbosity,
-      serviceTier: options?.serviceTier,
-    }),
-  )
-  if (Object.keys(openai).length === 0) return undefined
-  return { openai }
-}
-
-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({
-    reasoningEffort: "medium",
-    reasoningSummary: "auto",
-    // GPT-5 reasoning models are configured stateless (`store: false`) by
-    // `openAIDefaultOptions` below, so the only way a follow-up turn can
-    // carry reasoning state is via the encrypted reasoning include. Without
-    // this, callers using the default model facade get reasoning summaries
-    // they cannot replay statelessly.
-    include: ["reasoning.encrypted_content"],
-    textVerbosity:
-      options.textVerbosity === true && id.includes("gpt-5.") && !id.includes("codex") && !id.includes("-chat")
-        ? "low"
-        : undefined,
-  })
-}
-
-export const openAIDefaultOptions = (
-  modelID: string,
-  options: { readonly textVerbosity?: boolean } = {},
-): ProviderOptions | undefined =>
-  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID, options))
-
-export const withOpenAIOptions = <Options extends { readonly providerOptions?: OpenAIProviderOptionsInput }>(
-  modelID: string,
-  options: Options,
-  defaults: { readonly textVerbosity?: boolean } = {},
-): Omit<Options, "providerOptions"> & { readonly providerOptions?: ProviderOptions } => {
-  return {
-    ...options,
-    providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID, defaults), options.providerOptions),
-  }
-}
-
-export * as OpenAIProviderOptions from "./openai-options"

packages/ai/src/providers/openai.ts

@@ -1,154 +0,0 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { Route, RouteDefaultsInput } from "../route/client"
-import type { ProviderPackage } from "../provider-package"
-import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema"
-import * as OpenAIChat from "../protocols/openai-chat"
-import * as OpenAIResponses from "../protocols/openai-responses"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-import { OpenAIImages, type OpenAIImageString } from "../protocols/openai-images"
-
-export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options"
-export type { OpenAIImageOptions } from "../protocols/openai-images"
-
-export const id = ProviderID.make("openai")
-
-export const routes = [OpenAIResponses.route, OpenAIResponses.webSocketRoute, OpenAIChat.route]
-
-// This provider facade wraps the lower-level Responses and Chat model factories
-// with OpenAI-specific conveniences: typed options, API-key sugar, env fallback,
-// and default option normalization.
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly queryParams?: Record<string, string>
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface ImageGenerationOptions {
-  readonly action?: OpenAIImageString<"auto" | "generate" | "edit">
-  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
-  readonly inputFidelity?: OpenAIImageString<"low" | "high">
-  readonly outputCompression?: number
-  readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">
-  readonly partialImages?: number
-  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
-  readonly size?: OpenAIImageString<
-    "auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792"
-  >
-}
-
-export const imageGeneration = (options: ImageGenerationOptions = {}) =>
-  ToolDefinition.make({
-    name: "image_generation",
-    description: "Generate or edit an image using OpenAI's hosted image generation tool.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      openai: {
-        type: "image_generation",
-        action: options.action,
-        background: options.background,
-        input_fidelity: options.inputFidelity,
-        output_compression: options.outputCompression,
-        output_format: options.outputFormat,
-        partial_images: options.partialImages,
-        quality: options.quality,
-        size: options.size,
-      },
-    },
-  })
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly organization?: string
-  readonly project?: string
-  readonly queryParams?: Readonly<Record<string, string>>
-  readonly transport?: "http" | "websocket"
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
-
-const defaults = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input
-  return rest
-}
-
-const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
-  route.with({
-    auth: auth(input),
-    endpoint: { baseURL: input.baseURL, query: input.queryParams },
-  })
-
-export const configure = (input: Config = {}) => {
-  const responsesRoute = configuredRoute(OpenAIResponses.route, input)
-  const responsesWebSocketRoute = configuredRoute(OpenAIResponses.webSocketRoute, input)
-  const chatRoute = configuredRoute(OpenAIChat.route, input)
-  const modelDefaults = defaults(input)
-  const responses = (id: string | ModelID) =>
-    responsesRoute
-      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
-      .model<OpenAIProviderOptionsInput>({ id })
-  const responsesWebSocket = (id: string | ModelID) =>
-    responsesWebSocketRoute
-      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
-      .model<OpenAIProviderOptionsInput>({ id })
-  const chat = (id: string | ModelID) =>
-    chatRoute.with(withOpenAIOptions(id, modelDefaults)).model<OpenAIProviderOptionsInput>({ id })
-  const image = (modelID: string | ModelID) =>
-    OpenAIImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL,
-      headers: input.headers,
-      http: mergeHttpOptions(
-        input.http === undefined ? undefined : HttpOptions.make(input.http),
-        input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }),
-      ),
-    })
-
-  return {
-    id,
-    model: responses,
-    responses,
-    responsesWebSocket,
-    chat,
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-
-const config = (settings: Settings): Config => {
-  const headers = {
-    ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
-    ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
-    ...settings.headers,
-  }
-  return {
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: Object.keys(headers).length === 0 ? undefined : headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
-  }
-}
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  const configured = configure(config(settings))
-  if (settings.transport === undefined || settings.transport === "http") return configured.responses(modelID)
-  if (settings.transport === "websocket") return configured.responsesWebSocket(modelID)
-  throw new Error(`Unsupported OpenAI Responses transport: ${String(settings.transport)}`)
-}
-
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
-export const responses = provider.responses
-export const responsesWebSocket = provider.responsesWebSocket
-export const chat = provider.chat
-export const image = provider.image

packages/ai/src/providers/openai/chat.ts

@@ -1,2 +0,0 @@
-export { chatModel as model } from "../openai"
-export type { Settings } from "../openai"

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

@@ -1,2 +0,0 @@
-export { model } from "../openai"
-export type { Settings } from "../openai"

packages/ai/src/providers/openrouter.ts

@@ -1,208 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import { ProviderID, type CacheHint, type ModelID, type ProviderOptions } from "../schema"
-import type { ProviderPackage } from "../provider-package"
-import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
-import * as OpenAIChat from "../protocols/openai-chat"
-import { newBreakpoints, ttlBucket } from "../protocols/utils/cache"
-import { isRecord } from "../protocols/shared"
-
-export const profile = OpenAICompatibleProfiles.profiles.openrouter
-export const id = ProviderID.make(profile.provider)
-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?: OpenRouterString<"allow" | "deny">
-  readonly only?: ReadonlyArray<string>
-  readonly ignore?: ReadonlyArray<string>
-  readonly quantizations?: ReadonlyArray<string>
-  readonly sort?: OpenRouterString<"price" | "throughput" | "latency">
-  readonly max_price?: Readonly<{
-    prompt?: number | string
-    completion?: number | string
-    image?: number | string
-    audio?: number | string
-    request?: number | string
-  }>
-  readonly zdr?: boolean
-}
-
-export type OpenRouterPlugin =
-  | Readonly<{
-      id: "web"
-      max_results?: number
-      search_prompt?: string
-      engine?: OpenRouterString<"native" | "exa">
-    }>
-  | Readonly<{ id: "file-parser"; max_files?: number; pdf?: { engine?: string } }>
-  | Readonly<{ id: "moderation" }>
-  | Readonly<{ id: "response-healing" }>
-  | Readonly<{ id: "auto-router"; allowed_models?: ReadonlyArray<string> }>
-  | Readonly<{ id: string & {}; [key: string]: unknown }>
-
-export interface OpenRouterOptions {
-  readonly [key: string]: unknown
-  readonly debug?: Readonly<{ echo_upstream_body?: boolean }>
-  readonly models?: ReadonlyArray<string>
-  readonly plugins?: ReadonlyArray<OpenRouterPlugin>
-  readonly promptCacheKey?: string
-  readonly provider?: OpenRouterProviderRouting
-  readonly reasoning?: Readonly<{
-    enabled?: boolean
-    exclude?: boolean
-    effort?: OpenRouterString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">
-    max_tokens?: number
-  }>
-  readonly usage?: boolean | Readonly<{ include: boolean }>
-  readonly user?: string
-  readonly web_search_options?: Readonly<{
-    max_results?: number
-    search_prompt?: string
-    engine?: OpenRouterString<"native" | "exa">
-  }>
-}
-
-export type OpenRouterProviderOptionsInput = ProviderOptions & {
-  readonly openrouter?: OpenRouterOptions
-}
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenRouterProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenRouterProviderOptionsInput
-}
-
-const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
-  Schema.Record(Schema.String, Schema.Any),
-])
-export type OpenRouterBody = Schema.Schema.Type<typeof OpenRouterBody>
-
-export const protocol = Protocol.make({
-  id: "openrouter-chat",
-  body: {
-    schema: OpenRouterBody,
-    from: (request) =>
-      OpenAIChat.fromRequest(request, { cacheControl: cacheControl() }).pipe(
-        Effect.map((body) => {
-          const sourceAssistants = request.messages.filter((message) => message.role === "assistant")
-          let assistantIndex = 0
-          const messages = body.messages.map((message) => {
-            if (message.role !== "assistant") return message
-            const source = sourceAssistants[assistantIndex++]
-            const reasoning = source?.content
-              .filter((part) => part.type === "reasoning")
-              .map((part) => part.text)
-              .join("")
-            const reasoningDetails = Array.isArray(message.reasoning_details) ? message.reasoning_details : undefined
-            return {
-              ...message,
-              reasoning_content: undefined,
-              reasoning_text: undefined,
-              reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
-              reasoning_details: reasoningDetails,
-            }
-          })
-          return {
-            ...body,
-            messages,
-            ...bodyOptions(request.providerOptions?.openrouter),
-          } as OpenRouterBody
-        }),
-      ),
-  },
-  stream: OpenAIChat.protocol.stream,
-})
-
-const cacheControl = () => {
-  const breakpoints = newBreakpoints(4)
-  return (cache: CacheHint | undefined) => {
-    if (cache === undefined || breakpoints.remaining === 0) return undefined
-    breakpoints.remaining -= 1
-    return {
-      type: "ephemeral" as const,
-      ...(ttlBucket(cache.ttlSeconds) === "1h" ? { ttl: "1h" } : {}),
-    }
-  }
-}
-
-const bodyOptions = (input: unknown) => {
-  const openrouter = isRecord(input) ? input : {}
-  const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } =
-    openrouter
-  return {
-    ...options,
-    ...(usage === undefined || usage === true
-      ? { usage: { include: true } }
-      : usage === false
-        ? { usage: { include: false } }
-        : isRecord(usage)
-          ? { usage }
-          : {}),
-    ...(Array.isArray(models) ? { models } : {}),
-    ...(isRecord(provider) ? { provider } : {}),
-    ...(Array.isArray(plugins) ? { plugins } : {}),
-    ...(isRecord(web_search_options) ? { web_search_options } : {}),
-    ...(isRecord(debug) ? { debug } : {}),
-    ...(typeof user === "string" ? { user } : {}),
-    ...(isRecord(reasoning) ? { reasoning } : {}),
-    ...(typeof promptCacheKey === "string" ? { prompt_cache_key: promptCacheKey } : {}),
-  }
-}
-
-export const route = Route.make({
-  id: ADAPTER,
-  provider: profile.provider,
-  protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
-  framing: Framing.sse,
-})
-
-export const routes = [route]
-
-const configuredRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return route.with({
-    ...rest,
-    endpoint: { baseURL: baseURL ?? profile.baseURL },
-    auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
-  })
-}
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model<OpenRouterProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)

packages/ai/src/providers/xai.ts

@@ -1,109 +0,0 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { HttpOptions, ProviderID, type ModelID, type ProviderOptions } from "../schema"
-import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import * as OpenAIChat from "../protocols/openai-chat"
-import * as OpenAIResponses from "../protocols/openai-responses"
-import { XAIImages } from "../protocols/xai-images"
-import type { OpenAIOptionsInput } from "./openai-options"
-import type { ProviderPackage } from "../provider-package"
-
-export const id = ProviderID.make("xai")
-
-export type XAIProviderOptionsInput = ProviderOptions & {
-  readonly xai?: OpenAIOptionsInput
-}
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: XAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: XAIProviderOptionsInput
-}
-
-export type { XAIImageOptions } from "../protocols/xai-images"
-
-const responsesRoute = Route.make({
-  id: "openai-responses",
-  provider: id,
-  providerMetadataKey: "xai",
-  protocol: OpenAIResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAIResponses.httpTransport,
-  defaults: { providerOptions: { xai: { store: false } } },
-})
-
-const chatRoute = Route.make({
-  id: "openai-compatible-chat",
-  provider: id,
-  providerMetadataKey: "xai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAICompatibleChat.route.transport,
-})
-
-export const routes = [responsesRoute, chatRoute]
-
-const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
-
-const configuredResponsesRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return responsesRoute.with({
-    ...rest,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
-    auth: auth(input),
-  })
-}
-
-const configuredChatRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return chatRoute.with({
-    ...rest,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
-    auth: auth(input),
-  })
-}
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const responsesRoute = configuredResponsesRoute(input)
-  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 image = (modelID: string | ModelID) =>
-    XAIImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
-      headers: input.headers,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
-  return {
-    id,
-    model: responses,
-    responses,
-    chat,
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-export const responses = provider.responses
-export const chat = provider.chat
-export const image = provider.image

packages/ai/src/providers/zai.ts

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

packages/ai/src/route.ts

@@ -1 +0,0 @@
-export * from "./route/index"

packages/ai/src/route/auth-options.ts

@@ -1,64 +0,0 @@
-import type { Config, Redacted } from "effect"
-import { Auth } from "./auth"
-
-export type ApiKeyMode = "optional" | "required"
-
-export type AuthOverride = {
-  readonly auth: Auth.Definition
-  readonly apiKey?: never
-}
-
-export type OptionalApiKeyAuth = {
-  readonly apiKey?: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>>
-  readonly auth?: never
-}
-
-export type RequiredApiKeyAuth = {
-  readonly apiKey: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>>
-  readonly auth?: never
-}
-
-export type ProviderAuthOption<Mode extends ApiKeyMode> =
-  | AuthOverride
-  | (Mode extends "optional" ? OptionalApiKeyAuth : RequiredApiKeyAuth)
-
-export type LanguageModelOptions<Base, Mode extends ApiKeyMode> = Omit<Base, "apiKey" | "auth"> &
-  ProviderAuthOption<Mode>
-
-export type LanguageModelArgs<Base, Mode extends ApiKeyMode> = Mode extends "optional"
-  ? readonly [options?: LanguageModelOptions<Base, Mode>]
-  : readonly [options: LanguageModelOptions<Base, Mode>]
-
-export type LanguageModelFactory<Base, Mode extends ApiKeyMode, LanguageModel> = (
-  id: string,
-  ...args: LanguageModelArgs<Base, Mode>
-) => LanguageModel
-
-/**
- * Require at least one of the keys in `T`. Use for option shapes where any
- * subset of fields is acceptable but at least one must be present (e.g. Azure
- * accepts `resourceName` or `baseURL`).
- */
-export type AtLeastOne<T> = {
-  [K in keyof T]: Required<Pick<T, K>> & Partial<Omit<T, K>>
-}[keyof T]
-
-/**
- * Standard bearer-auth resolution for providers: honor an explicit `auth`
- * override, otherwise resolve `apiKey` (option > config var) and apply it as
- * a bearer token.
- */
-export const bearer = (
-  options: ProviderAuthOption<"optional">,
-  envVar: string | ReadonlyArray<string>,
-): Auth.Definition => {
-  if ("auth" in options && options.auth) return options.auth
-  return (Array.isArray(envVar) ? envVar : [envVar])
-    .reduce(
-      (auth, name) => auth.orElse(Auth.config(name)),
-      Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey"),
-    )
-    .bearer()
-}
-
-export * as AuthOptions from "./auth-options"

packages/ai/src/route/auth.ts

@@ -1,156 +0,0 @@
-import { Config, Effect, Redacted } from "effect"
-import { Headers } from "effect/unstable/http"
-import { AuthenticationReason, InvalidRequestReason, AIError, type HttpOptions } from "../schema"
-
-export class MissingCredentialError extends Error {
-  readonly _tag = "MissingCredentialError"
-
-  constructor(readonly source: string) {
-    super(`Missing auth credential: ${source}`)
-  }
-}
-
-export type CredentialError = MissingCredentialError | Config.ConfigError
-export type AuthError = CredentialError | AIError
-type Secret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
-
-export interface AuthInput {
-  readonly request: { readonly http?: HttpOptions }
-  readonly method: "POST" | "GET"
-  readonly url: string
-  readonly body: string
-  readonly headers: Headers.Headers
-}
-
-export interface Credential {
-  readonly load: Effect.Effect<Redacted.Redacted, CredentialError>
-  readonly orElse: (that: Credential) => Credential
-  readonly bearer: () => Definition
-  readonly header: (name: string) => Definition
-  readonly pipe: <A>(f: (self: Credential) => A) => A
-}
-
-export interface Definition {
-  readonly apply: (input: AuthInput) => Effect.Effect<Headers.Headers, AuthError>
-  readonly andThen: (that: Definition) => Definition
-  readonly orElse: (that: Definition) => Definition
-  readonly pipe: <A>(f: (self: Definition) => A) => A
-}
-
-export const isAuth = (input: unknown): input is Definition =>
-  typeof input === "object" && input !== null && "apply" in input && typeof input.apply === "function"
-
-const credential = (load: Effect.Effect<Redacted.Redacted, CredentialError>): Credential => {
-  const self: Credential = {
-    load,
-    orElse: (that) => credential(load.pipe(Effect.catch(() => that.load))),
-    bearer: () => fromCredential(self, (secret) => ({ authorization: `Bearer ${secret}` })),
-    header: (name) => fromCredential(self, (secret) => ({ [name]: secret })),
-    pipe: (f) => f(self),
-  }
-  return self
-}
-
-const auth = (apply: Definition["apply"]): Definition => {
-  const self: Definition = {
-    apply,
-    andThen: (that) =>
-      auth((input) => apply(input).pipe(Effect.flatMap((headers) => that.apply({ ...input, headers })))),
-    orElse: (that) => auth((input) => apply(input).pipe(Effect.catch(() => that.apply(input)))),
-    pipe: (f) => f(self),
-  }
-  return self
-}
-
-const fromCredential = (source: Credential, render: (secret: string) => Headers.Input) =>
-  auth((input) =>
-    source.load.pipe(Effect.map((secret) => Headers.setAll(input.headers, render(Redacted.value(secret))))),
-  )
-
-const secretEffect = (secret: string | Redacted.Redacted, source: string) => {
-  const redacted = typeof secret === "string" ? Redacted.make(secret) : secret
-  if (Redacted.value(redacted) === "") return Effect.fail(new MissingCredentialError(source))
-  return Effect.succeed(redacted)
-}
-
-const credentialFromSecret = (secret: Secret, source: string) => {
-  if (typeof secret === "string" || Redacted.isRedacted(secret)) return credential(secretEffect(secret, source))
-  return credential(
-    Effect.gen(function* () {
-      return yield* secretEffect(yield* secret, source)
-    }),
-  )
-}
-
-export const value = (secret: string, source = "value") => credentialFromSecret(secret, source)
-
-export const optional = (secret: Secret | undefined, source = "optional value") =>
-  secret === undefined
-    ? credential(Effect.fail(new MissingCredentialError(source)))
-    : credentialFromSecret(secret, source)
-
-export const config = (name: string) => credentialFromSecret(Config.redacted(name), name)
-
-export const effect = (load: Effect.Effect<Redacted.Redacted, CredentialError>) => credential(load)
-
-export const none = auth((input) => Effect.succeed(input.headers))
-
-export const headers = (input: Headers.Input) =>
-  auth((inputAuth) => Effect.succeed(Headers.setAll(inputAuth.headers, input)))
-
-export const remove = (name: string) => auth((input) => Effect.succeed(Headers.remove(input.headers, name)))
-
-export const custom = (apply: (input: AuthInput) => Effect.Effect<Headers.Headers, AIError>) => auth(apply)
-
-export const passthrough = none
-
-const credentialInput = (source: Secret | Credential) =>
-  typeof source === "string" || Redacted.isRedacted(source) || Config.isConfig(source)
-    ? credentialFromSecret(source, "value")
-    : source
-
-export function bearer(source: Secret | Credential): Definition
-export function bearer(source: Secret | Credential) {
-  return credentialInput(source).bearer()
-}
-
-export const apiKey = bearer
-
-export function header(name: string): (source: Secret | Credential) => Definition
-export function header(name: string, source: Secret | Credential): Definition
-export function header(name: string, source?: Secret | Credential) {
-  if (source === undefined) {
-    return (next: Secret | Credential) => credentialInput(next).header(name)
-  }
-  return credentialInput(source).header(name)
-}
-
-export function bearerHeader(name: string): (source: Secret | Credential) => Definition
-export function bearerHeader(name: string, source: Secret | Credential): Definition
-export function bearerHeader(name: string, source?: Secret | Credential) {
-  const render = (input: Secret | Credential) =>
-    fromCredential(credentialInput(input), (secret) => ({ [name]: `Bearer ${secret}` }))
-  if (source === undefined) return render
-  return render(source)
-}
-
-const toAIError = (error: AuthError): AIError => {
-  if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
-    return new AIError({
-      module: "Auth",
-      method: "apply",
-      reason:
-        error instanceof MissingCredentialError
-          ? new AuthenticationReason({ message: error.message, kind: "missing" })
-          : new InvalidRequestReason({ message: `Failed to resolve auth config: ${error.message}` }),
-    })
-  }
-  return error
-}
-
-export const toEffect =
-  (input: Definition) =>
-  (authInput: AuthInput): Effect.Effect<Headers.Headers, AIError> =>
-    input.apply(authInput).pipe(Effect.mapError(toAIError))
-
-export * as Auth from "./auth"

packages/ai/src/route/client.ts

@@ -1,473 +0,0 @@
-import { Cause, Context, Effect, Layer, Schema, Stream } from "effect"
-import * as Option from "effect/Option"
-import { Auth } from "./auth"
-import { Endpoint, type EndpointPatch } from "./endpoint"
-import { RequestExecutor } from "./executor"
-import { Framing } from "./framing"
-import { HttpTransport } from "./transport"
-import type { HttpMiddleware, Transport, TransportRuntime } from "./transport"
-import { WebSocketExecutor } from "./transport"
-import type { Protocol } from "./protocol"
-import { applyCachePolicy } from "../cache-policy"
-import * as ProviderShared from "../protocols/shared"
-import type { ProtocolID, ProviderOptions } from "../schema"
-import {
-  AIError,
-  GenerationOptions,
-  HttpOptions,
-  LLMRequest,
-  LLMResponse,
-  LanguageModel,
-  LanguageModelLimits,
-  LLMEvent,
-  InvalidProviderOutputReason,
-  ProviderID,
-  mergeGenerationOptions,
-  mergeHttpOptions,
-  mergeProviderOptions,
-} from "../schema"
-
-export interface RouteBody<Body> {
-  /** Schema for the validated provider-native body sent as the JSON request. */
-  readonly schema: Schema.Codec<Body, unknown>
-  /** Build the provider-native body from a common `LLMRequest`. */
-  readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>
-}
-
-export interface Route<Body, Prepared = unknown> {
-  readonly id: string
-  readonly provider?: ProviderID
-  /** ProviderMetadata namespace emitted and consumed by this route. */
-  readonly providerMetadataKey?: string
-  readonly protocol: ProtocolID
-  readonly endpoint: Endpoint.Definition<Body>
-  readonly auth: Auth.Definition
-  readonly transport: Transport<Body, Prepared, unknown>
-  readonly defaults: RouteDefaults
-  readonly body: RouteBody<Body>
-  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
-  readonly model: <Options extends ProviderOptions = ProviderOptions>(
-    input: RouteMappedLanguageModelInput,
-  ) => LanguageModel<Options>
-  readonly prepareTransport: (
-    body: Body,
-    request: LLMRequest,
-    options?: StreamOptions,
-  ) => Effect.Effect<Prepared, AIError>
-  readonly streamPrepared: (
-    prepared: Prepared,
-    request: LLMRequest,
-    runtime: TransportRuntime,
-  ) => Stream.Stream<LLMEvent, AIError>
-}
-
-// Route registries intentionally erase body generics after construction.
-// Normal call sites use `OpenAIChat.route`; callers only need body types
-// when preparing a request with a protocol-specific type assertion.
-// oxlint-disable-next-line typescript-eslint/no-explicit-any
-export type AnyRoute = Route<any, any>
-
-export type HttpOptionsInput = HttpOptions.Input
-
-export type RouteLanguageModelInput = Omit<LanguageModel.Input, "provider" | "route">
-
-export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">
-
-export interface RouteDefaults {
-  readonly headers?: Record<string, string>
-  readonly limits?: LanguageModelLimits
-  readonly generation?: GenerationOptions
-  readonly providerOptions?: ProviderOptions
-  readonly http?: HttpOptions
-}
-
-export interface RouteDefaultsInput {
-  readonly headers?: Record<string, string>
-  readonly limits?: LanguageModelLimits.Input
-  readonly generation?: GenerationOptions.Input
-  readonly providerOptions?: ProviderOptions
-  readonly http?: HttpOptions.Input
-}
-
-export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
-  readonly id?: string
-  readonly provider?: string | ProviderID
-  readonly auth?: Auth.Definition
-  readonly transport?: Transport<Body, Prepared, unknown>
-  readonly endpoint?: EndpointPatch<Body>
-}
-
-type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput
-
-const makeRouteLanguageModel = <Options extends ProviderOptions = ProviderOptions>(
-  route: AnyRoute,
-  mapped: RouteMappedLanguageModelInput,
-) => {
-  const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
-  if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
-  if (!endpointBaseURL(route.endpoint))
-    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return LanguageModel.make<Options>({
-    ...mapped,
-    provider,
-    route,
-  })
-}
-
-const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefaultsInput): RouteDefaults => {
-  const headers = mergeHeaders(base?.headers, patch.headers)
-  return {
-    ...base,
-    ...patch,
-    headers,
-    limits: patch.limits === undefined ? base?.limits : LanguageModelLimits.make(patch.limits),
-    generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
-    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
-    http: mergeHttpOptions(
-      base?.http,
-      httpOptions(patch.http),
-      headers === undefined ? undefined : new HttpOptions({ headers }),
-    ),
-  }
-}
-
-const endpointBaseURL = <Body>(endpoint: Endpoint.Definition<Body>) =>
-  typeof endpoint.baseURL === "string" ? endpoint.baseURL : undefined
-
-const mergeHeaders = (...items: ReadonlyArray<Record<string, string> | undefined>) => {
-  const entries = items.flatMap((item) =>
-    item === undefined ? [] : Object.entries(item).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  )
-  if (entries.length === 0) return undefined
-  return Object.fromEntries(entries)
-}
-
-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 stream: StreamMethod
-  readonly generate: GenerateMethod
-}
-
-export interface StreamOptions {
-  readonly http?: HttpMiddleware
-}
-
-export interface StreamMethod {
-  (request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError>
-}
-
-export interface GenerateMethod {
-  (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
-
-const resolveRequestOptions = (request: LLMRequest) => {
-  const routeDefaults = request.model.route.defaults
-  const modelDefaults = request.model.defaults
-  const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, request.generation)
-  return LLMRequest.update(request, {
-    generation: generation ?? new GenerationOptions({}),
-    providerOptions: mergeProviderOptions(
-      routeDefaults.providerOptions,
-      modelDefaults?.providerOptions,
-      request.providerOptions,
-    ),
-    http: mergeHttpOptions(routeDefaults.http, modelDefaults?.http, request.http),
-  })
-}
-
-export interface MakeInput<Body, Frame, Event, State> {
-  /** Route id used in diagnostics and prepared request metadata. */
-  readonly id: string
-  /** Provider identity for route-owned model construction. */
-  readonly provider?: string | ProviderID
-  /** ProviderMetadata namespace emitted and consumed by this route. */
-  readonly providerMetadataKey?: string
-  /** Semantic API contract — owns body construction, body schema, and parsing. */
-  readonly protocol: Protocol<Body, Frame, Event, State>
-  /** Where the request is sent. */
-  readonly endpoint: Endpoint.Definition<Body>
-  /** Per-request transport auth. Provider facades override this via `route.with(...)`. */
-  readonly auth?: Auth.Definition
-  /** Stream framing — bytes -> frames before `protocol.stream.event` decoding. */
-  readonly framing: Framing.Definition<Frame>
-  /** Static / per-request headers added before `auth` runs. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  /** Route/request defaults used when compiling requests for this route. */
-  readonly defaults?: RouteDefaultsInput
-}
-
-export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  /** Route id used in diagnostics and prepared request metadata. */
-  readonly id: string
-  /** Provider identity for route-owned model construction. */
-  readonly provider?: string | ProviderID
-  /** ProviderMetadata namespace emitted and consumed by this route. */
-  readonly providerMetadataKey?: string
-  /** Semantic API contract — owns body construction, body schema, and parsing. */
-  readonly protocol: Protocol<Body, Frame, Event, State>
-  /** Where the request is sent. */
-  readonly endpoint: Endpoint.Definition<Body>
-  /** Per-request transport auth. Provider facades override this via `route.with(...)`. */
-  readonly auth?: Auth.Definition
-  /** Static / per-request headers added before `auth` runs. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  /** Runnable transport route. */
-  readonly transport: Transport<Body, Prepared, Frame>
-  /** Route/request defaults used when compiling requests for this route. */
-  readonly defaults?: RouteDefaultsInput
-}
-
-const streamError = (route: string, message: string, cause: Cause.Cause<unknown>) => {
-  const failed = cause.reasons.find(Cause.isFailReason)?.error
-  if (failed instanceof AIError) return failed
-  return ProviderShared.eventError(route, message, Cause.pretty(cause))
-}
-
-const incompleteStreamError = (route: string) =>
-  new AIError({
-    module: "LLMClient",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({
-      classification: "incomplete-stream",
-      message: "The provider response ended unexpectedly.",
-      route,
-    }),
-  })
-
-const requireTerminalEvent = (route: string) => (events: Stream.Stream<LLMEvent, AIError>) =>
-  Stream.suspend(() => {
-    let terminal = false
-    return events.pipe(
-      Stream.mapEffect((event) => {
-        if (terminal)
-          return Effect.fail(
-            ProviderShared.eventError(route, `Provider emitted ${event.type} after the terminal event`),
-          )
-        if (LLMEvent.is.finish(event) || LLMEvent.is.providerError(event)) terminal = true
-        return Effect.succeed(event)
-      }),
-      Stream.onEnd(
-        Effect.suspend(() =>
-          terminal
-            ? Effect.void
-            : Effect.fail(incompleteStreamError(route)),
-        ),
-      ),
-    )
-  })
-
-function makeFromTransport<Body, Prepared, Frame, Event, State>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
-): Route<Body, Prepared> {
-  const protocol = input.protocol
-  const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema))
-  const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event)
-  const decodeEvent = (route: string) => (frame: Frame) =>
-    decodeEventEffect(frame).pipe(
-      Effect.mapError(() =>
-        ProviderShared.eventError(
-          input.id,
-          `Invalid ${route} stream event`,
-          typeof frame === "string" ? frame : ProviderShared.encodeJson(frame),
-        ),
-      ),
-    )
-
-  type BuiltRouteInput = Omit<MakeTransportInput<Body, Prepared, Frame, Event, State>, "defaults"> & {
-    readonly defaults?: RouteDefaults
-  }
-
-  const build = (routeInput: BuiltRouteInput): Route<Body, Prepared> => {
-    const route: Route<Body, Prepared> = {
-      id: routeInput.id,
-      provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
-      providerMetadataKey: routeInput.providerMetadataKey,
-      protocol: protocol.id,
-      endpoint: routeInput.endpoint,
-      auth: routeInput.auth ?? Auth.none,
-      transport: routeInput.transport,
-      defaults: routeInput.defaults ?? {},
-      body: protocol.body,
-      with: (patch: RoutePatch<Body, Prepared>) => {
-        const { id, provider, auth, transport, endpoint, ...defaults } = patch
-        return build({
-          ...routeInput,
-          id: id ?? routeInput.id,
-          provider: provider ?? routeInput.provider,
-          auth: auth ?? routeInput.auth,
-          endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
-          transport: (transport as Transport<Body, Prepared, Frame> | undefined) ?? routeInput.transport,
-          defaults: mergeRouteDefaults(route.defaults, defaults),
-        })
-      },
-      model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) =>
-        makeRouteLanguageModel<Options>(route, input),
-      prepareTransport: (body, request, options) =>
-        routeInput.transport.prepare({
-          body,
-          request,
-          endpoint: routeInput.endpoint,
-          auth: routeInput.auth ?? Auth.none,
-          encodeBody,
-          headers: routeInput.headers,
-          middleware: options?.http,
-        }),
-      streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
-        const route = `${request.model.provider}/${request.model.route.id}`
-        const events = routeInput.transport
-          .frames(prepared, request, runtime)
-          .pipe(
-            Stream.mapEffect(decodeEvent(route)),
-            protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream,
-          )
-        return events.pipe(
-          Stream.mapAccumEffect(
-            () => protocol.stream.initial(request),
-            protocol.stream.step,
-            protocol.stream.onHalt ? { onHalt: protocol.stream.onHalt } : undefined,
-          ),
-          Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))),
-          requireTerminalEvent(route),
-        )
-      },
-    } satisfies Route<Body, Prepared>
-    return route
-  }
-
-  return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
-}
-
-export function make<Body, Prepared, Frame, Event, State>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
-): Route<Body, Prepared>
-/**
- * Build a `Route` by composing the four orthogonal pieces of a deployment:
- *
- * - `Protocol` — what is the API I'm speaking?
- * - `Endpoint` — where do I send the request?
- * - `Auth` — how do I authenticate it?
- * - `Framing` — how do I cut the response stream into protocol frames?
- *
- * Plus optional `headers` for cross-cutting deployment concerns (provider
- * version pins, per-deployment quirks).
- *
- * This is the canonical route constructor. If a new route does not fit
- * this four-axis model, add a purpose-built constructor rather than widening
- * the public surface preemptively.
- */
-export function make<Body, Frame, Event, State>(
-  input: MakeInput<Body, Frame, Event, State>,
-): Route<Body, HttpTransport.HttpPrepared<Frame>>
-export function make<Body, Prepared, Frame, Event, State>(
-  input: MakeInput<Body, Frame, Event, State> | MakeTransportInput<Body, Prepared, Frame, Event, State>,
-): Route<Body, Prepared> | Route<Body, HttpTransport.HttpPrepared<Frame>> {
-  if ("transport" in input) return makeFromTransport(input)
-  const protocol = input.protocol
-  return makeFromTransport({
-    id: input.id,
-    provider: input.provider,
-    providerMetadataKey: input.providerMetadataKey,
-    protocol,
-    endpoint: input.endpoint,
-    auth: input.auth,
-    headers: input.headers,
-    transport: HttpTransport.httpJson({ framing: input.framing }),
-    defaults: input.defaults,
-  })
-}
-
-const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
-  const resolved = applyCachePolicy(resolveRequestOptions(request))
-  const route = resolved.model.route
-
-  const body = yield* route.body
-    .from(resolved)
-    .pipe(Effect.flatMap(ProviderShared.validateWith(Schema.decodeUnknownEffect(route.body.schema))))
-  const prepared = yield* route.prepareTransport(body, resolved, options)
-
-  return {
-    request: resolved,
-    route,
-    body,
-    prepared,
-  }
-})
-
-/** @internal Test-only projection of the execution compiler; not exported from package barrels. */
-export const compileRequest = Effect.fn("LLM.compileRequest")(function* (request: LLMRequest) {
-  const compiled = yield* compile(request)
-  return {
-    id: compiled.request.id ?? "request",
-    route: compiled.route.id,
-    protocol: compiled.route.protocol,
-    model: compiled.request.model,
-    body: compiled.body,
-    metadata: { transport: compiled.route.transport.id },
-  }
-})
-
-const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest, options?: StreamOptions) =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const compiled = yield* compile(request, options)
-      return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime)
-    }),
-  )
-
-const generateWith = (stream: Interface["stream"]) =>
-  Effect.fn("LLM.generate")(function* (request: LLMRequest, options?: StreamOptions) {
-    const state = yield* stream(request, options).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce))
-    const response = LLMResponse.complete(state)
-    if (response) return response
-    return yield* incompleteStreamError(`${request.model.provider}/${request.model.route.id}`)
-  })
-
-export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service> {
-  return Stream.unwrap(
-    Effect.gen(function* () {
-      return (yield* Service).stream(request, options)
-    }),
-  )
-}
-
-export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service> {
-  return Effect.gen(function* () {
-    return yield* (yield* Service).generate(request, options)
-  })
-}
-
-export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      return (yield* Service).stream(request, options)
-    }),
-  )
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const stream = streamRequestWith({
-      http: yield* RequestExecutor.Service,
-      webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
-    })
-    return Service.of({ stream, generate: generateWith(stream) })
-  }),
-)
-
-export const Route = { make } as const
-
-export const LLMClient = {
-  Service,
-  layer,
-  stream,
-  generate,
-} as const

packages/ai/src/route/executor.ts

@@ -1,317 +0,0 @@
-import { Cause, Context, Effect, Layer } from "effect"
-import {
-  FetchHttpClient,
-  Headers,
-  HttpClient,
-  HttpClientError,
-  HttpClientRequest,
-  HttpClientResponse,
-} from "effect/unstable/http"
-import {
-  HttpContext,
-  HttpRateLimitDetails,
-  HttpRequestDetails,
-  HttpResponseDetails,
-  AIError,
-  TransportReason,
-} from "../schema"
-import { classifyProviderFailure } from "../provider-error"
-
-export interface Interface {
-  readonly execute: (
-    request: HttpClientRequest.HttpClientRequest,
-    middleware?: HttpMiddleware,
-  ) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>
-}
-
-export type HttpHandler = (
-  request: HttpClientRequest.HttpClientRequest,
-) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>
-export type HttpMiddleware = (
-  request: HttpClientRequest.HttpClientRequest,
-  handler: HttpHandler,
-) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/AI/RequestExecutor") {}
-
-const BODY_LIMIT = 16_384
-const REDACTED = "<redacted>"
-
-// One source of truth for what counts as a sensitive name across headers,
-// URL query keys, and field names embedded inside request/response bodies.
-//
-// `SENSITIVE_NAME` is used as both a substring matcher (for free-form header
-// names like `Authorization` / `X-API-Key`) and as the body-field alternation
-// list. `SHORT_QUERY_NAME` covers anchored short keys like `?key=…` / `?sig=…`
-// that are too generic to redact substring-style without false positives.
-const SENSITIVE_NAME_SOURCE =
-  "authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|credential|signature|x-amz-signature"
-const SENSITIVE_NAME = new RegExp(SENSITIVE_NAME_SOURCE, "i")
-const SHORT_QUERY_NAME = /^(key|sig)$/i
-const SENSITIVE_BODY_FIELD = new RegExp(`(?:${SENSITIVE_NAME_SOURCE}|key)`, "i")
-const REDACT_JSON_FIELD = new RegExp(`("(?:${SENSITIVE_BODY_FIELD.source})"\\s*:\\s*)"[^"]*"`, "gi")
-const REDACT_QUERY_FIELD = new RegExp(`((?:${SENSITIVE_BODY_FIELD.source})=)[^&\\s"]+`, "gi")
-
-const isSensitiveHeaderName = (name: string) => SENSITIVE_NAME.test(name)
-
-const isSensitiveQueryName = (name: string) => isSensitiveHeaderName(name) || SHORT_QUERY_NAME.test(name)
-
-const redactHeaders = (headers: Headers.Headers, redactedNames: ReadonlyArray<string | RegExp>) =>
-  Object.fromEntries(
-    Object.entries(Headers.redact(headers, [...redactedNames, SENSITIVE_NAME])).map(([name, value]) => [
-      name,
-      String(value),
-    ]),
-  )
-
-const redactUrl = (value: string) => {
-  if (!URL.canParse(value)) return REDACTED
-  const url = new URL(value)
-  url.searchParams.forEach((_, key) => {
-    if (isSensitiveQueryName(key)) url.searchParams.set(key, REDACTED)
-  })
-  return url.toString()
-}
-
-const normalizedHeaders = (headers: Headers.Headers) =>
-  Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]))
-
-const requestId = (headers: Record<string, string>) => {
-  return (
-    headers["x-request-id"] ??
-    headers["request-id"] ??
-    headers["x-amzn-requestid"] ??
-    headers["x-amz-request-id"] ??
-    headers["x-goog-request-id"] ??
-    headers["cf-ray"]
-  )
-}
-
-const retryAfterMs = (headers: Record<string, string>) => {
-  const millis = Number(headers["retry-after-ms"])
-  if (Number.isFinite(millis)) return Math.max(0, millis)
-
-  const value = headers["retry-after"]
-  if (!value) return undefined
-
-  const seconds = Number(value)
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
-
-  const date = Date.parse(value)
-  if (!Number.isNaN(date)) return Math.max(0, date - Date.now())
-  return undefined
-}
-
-const addRateLimitValue = (target: Record<string, string>, key: string, value: string) => {
-  if (key.length > 0) target[key] = value
-}
-
-const rateLimitDetails = (headers: Record<string, string>, retryAfter: number | undefined) => {
-  const limit: Record<string, string> = {}
-  const remaining: Record<string, string> = {}
-  const reset: Record<string, string> = {}
-
-  Object.entries(headers).forEach(([name, value]) => {
-    const openaiLimit = /^x-ratelimit-limit-(.+)$/.exec(name)?.[1]
-    if (openaiLimit) return addRateLimitValue(limit, openaiLimit, value)
-
-    const openaiRemaining = /^x-ratelimit-remaining-(.+)$/.exec(name)?.[1]
-    if (openaiRemaining) return addRateLimitValue(remaining, openaiRemaining, value)
-
-    const openaiReset = /^x-ratelimit-reset-(.+)$/.exec(name)?.[1]
-    if (openaiReset) return addRateLimitValue(reset, openaiReset, value)
-
-    const anthropic = /^anthropic-ratelimit-(.+)-(limit|remaining|reset)$/.exec(name)
-    if (!anthropic) return
-    if (anthropic[2] === "limit") return addRateLimitValue(limit, anthropic[1], value)
-    if (anthropic[2] === "remaining") return addRateLimitValue(remaining, anthropic[1], value)
-    return addRateLimitValue(reset, anthropic[1], value)
-  })
-
-  if (
-    retryAfter === undefined &&
-    Object.keys(limit).length === 0 &&
-    Object.keys(remaining).length === 0 &&
-    Object.keys(reset).length === 0
-  )
-    return undefined
-
-  return new HttpRateLimitDetails({
-    retryAfterMs: retryAfter,
-    limit: Object.keys(limit).length === 0 ? undefined : limit,
-    remaining: Object.keys(remaining).length === 0 ? undefined : remaining,
-    reset: Object.keys(reset).length === 0 ? undefined : reset,
-  })
-}
-
-const requestDetails = (request: HttpClientRequest.HttpClientRequest, redactedNames: ReadonlyArray<string | RegExp>) =>
-  new HttpRequestDetails({
-    method: request.method,
-    url: redactUrl(request.url),
-    headers: redactHeaders(request.headers, redactedNames),
-  })
-
-const responseDetails = (
-  response: HttpClientResponse.HttpClientResponse,
-  redactedNames: ReadonlyArray<string | RegExp>,
-) =>
-  new HttpResponseDetails({
-    status: response.status,
-    headers: redactHeaders(response.headers, redactedNames),
-  })
-
-const secretValues = (request: HttpClientRequest.HttpClientRequest) => {
-  const values = new Set<string>()
-  const add = (value: string) => {
-    if (value.length < 4) return
-    values.add(value)
-    values.add(encodeURIComponent(value))
-  }
-
-  Object.entries(request.headers).forEach(([name, value]) => {
-    if (!isSensitiveHeaderName(name)) return
-    add(value)
-    const bearer = /^Bearer\s+(.+)$/i.exec(value)?.[1]
-    if (bearer) add(bearer)
-  })
-
-  if (!URL.canParse(request.url)) return values
-  new URL(request.url).searchParams.forEach((value, key) => {
-    if (isSensitiveQueryName(key)) add(value)
-  })
-  return values
-}
-
-// Two passes: structural (redact `"name": "value"` and `name=value` patterns
-// for any field name that looks sensitive) plus literal (replace any actual
-// secret values we sent in the request, in case the response echoes one back).
-const redactBody = (body: string, request: HttpClientRequest.HttpClientRequest) =>
-  Array.from(secretValues(request)).reduce(
-    (text, secret) => text.split(secret).join(REDACTED),
-    body.replace(REDACT_JSON_FIELD, `$1"${REDACTED}"`).replace(REDACT_QUERY_FIELD, `$1${REDACTED}`),
-  )
-
-const responseBody = (body: string | void, request: HttpClientRequest.HttpClientRequest) => {
-  if (body === undefined) return {}
-  const redacted = redactBody(body, request)
-  if (redacted.length <= BODY_LIMIT) return { body: redacted }
-  return { body: redacted.slice(0, BODY_LIMIT), bodyTruncated: true }
-}
-
-const providerMessage = (status: number, body: { readonly body?: string }) => {
-  if (body.body && body.body.length <= 500) return `Provider request failed with HTTP ${status}: ${body.body}`
-  return `Provider request failed with HTTP ${status}`
-}
-
-const responseHttp = (input: {
-  readonly request: HttpClientRequest.HttpClientRequest
-  readonly response: HttpClientResponse.HttpClientResponse
-  readonly redactedNames: ReadonlyArray<string | RegExp>
-  readonly body: ReturnType<typeof responseBody>
-  readonly requestId?: string | undefined
-  readonly rateLimit?: HttpRateLimitDetails | undefined
-}) =>
-  new HttpContext({
-    request: requestDetails(input.request, input.redactedNames),
-    response: responseDetails(input.response, input.redactedNames),
-    ...input.body,
-    requestId: input.requestId,
-    rateLimit: input.rateLimit,
-  })
-
-const statusError =
-  (request: HttpClientRequest.HttpClientRequest, redactedNames: ReadonlyArray<string | RegExp>) =>
-  (response: HttpClientResponse.HttpClientResponse) =>
-    Effect.gen(function* () {
-      if (response.status < 400) return response
-      const body = yield* response.text.pipe(Effect.catch(() => Effect.void))
-      const headers = normalizedHeaders(response.headers)
-      const retryAfter = retryAfterMs(headers)
-      const rateLimit = rateLimitDetails(headers, retryAfter)
-      const details = responseBody(body, request)
-      return yield* new AIError({
-        module: "RequestExecutor",
-        method: "execute",
-        reason: classifyProviderFailure({
-          status: response.status,
-          message: providerMessage(response.status, details),
-          retryAfterMs: retryAfter,
-          rateLimit,
-          http: responseHttp({
-            request,
-            response,
-            redactedNames,
-            body: details,
-            requestId: requestId(headers),
-            rateLimit,
-          }),
-        }),
-      })
-    })
-
-const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
-  const transportError = (input: {
-    readonly message: string
-    readonly kind?: string | undefined
-    readonly request?: HttpClientRequest.HttpClientRequest | undefined
-  }) =>
-    new AIError({
-      module: "RequestExecutor",
-      method: "execute",
-      reason: new TransportReason({
-        message: input.message,
-        kind: input.kind,
-        url: input.request ? redactUrl(input.request.url) : undefined,
-        http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
-      }),
-    })
-
-  if (Cause.isTimeoutError(error)) {
-    return transportError({ message: error.message, kind: "Timeout" })
-  }
-  if (!HttpClientError.isHttpClientError(error)) {
-    return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" })
-  }
-  const request = "request" in error ? error.request : undefined
-  if (error.reason._tag === "TransportError") {
-    return transportError({
-      message: error.reason.description ?? "HTTP transport failed",
-      kind: error.reason._tag,
-      request,
-    })
-  }
-  return transportError({
-    message: `HTTP transport failed: ${error.reason._tag}`,
-    kind: error.reason._tag,
-    request,
-  })
-}
-
-export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
-      Effect.gen(function* () {
-        const redactedNames = yield* Headers.CurrentRedactedNames
-        if (!middleware)
-          return yield* http
-            .execute(request)
-            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
-
-        const response = yield* middleware(request, (input) =>
-          http
-            .execute(input)
-            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
-        ).pipe(Effect.mapError(toHttpError(redactedNames)))
-        return yield* statusError(response.request, redactedNames)(response)
-      })
-    return Service.of({
-      execute: executeOnce,
-    })
-  }),
-)
-
-export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer))
-
-export * as RequestExecutor from "./executor"

packages/ai/src/route/index.ts

@@ -1,26 +0,0 @@
-export { Route, LLMClient } from "./client"
-export type {
-  Route as RouteShape,
-  RouteLanguageModelInput,
-  RouteRoutedLanguageModelInput,
-  RouteDefaults,
-  RouteDefaultsInput,
-  AnyRoute,
-  Interface as LLMClientShape,
-  Service as LLMClientService,
-  StreamOptions,
-} from "./client"
-export * from "./executor"
-export { Auth } from "./auth"
-export { AuthOptions } from "./auth-options"
-export { Endpoint } from "./endpoint"
-export { Framing } from "./framing"
-export { Protocol } from "./protocol"
-export { HttpTransport, WebSocketExecutor, WebSocketTransport } from "./transport"
-export * as Transport from "./transport"
-export type { Definition as AuthShape, AuthInput, Credential, CredentialError } from "./auth"
-export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-options"
-export type { Definition as EndpointFn, EndpointInput } from "./endpoint"
-export type { Definition as FramingDef } from "./framing"
-export type { Protocol as ProtocolDef } from "./protocol"
-export type { HttpHandler, HttpMiddleware, Transport as TransportDef, TransportRuntime } from "./transport"

packages/ai/src/route/transport/http.ts

@@ -1,114 +0,0 @@
-import { Effect, Stream } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { Auth } from "../auth"
-import { render as renderEndpoint } from "../endpoint"
-import { Framing } from "../framing"
-import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index"
-import * as ProviderShared from "../../protocols/shared"
-import { mergeJsonRecords, type LLMRequest } from "../../schema"
-
-export type JsonRequestInput<Body> = TransportPrepareInput<Body>
-
-export interface JsonRequestParts<Body = unknown> {
-  readonly url: string
-  readonly jsonBody: Body | Record<string, unknown>
-  readonly bodyText: string
-  readonly headers: Headers.Headers
-}
-
-export interface HttpPrepared<Frame> {
-  readonly request: HttpClientRequest.HttpClientRequest
-  readonly framing: Framing.Definition<Frame>
-  readonly middleware?: HttpMiddleware
-}
-
-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-const bodyWithOverlay = <Body>(body: Body, request: LLMRequest, encodeBody: (body: Body) => string) =>
-  Effect.gen(function* () {
-    if (request.http?.body === undefined) return { jsonBody: body, bodyText: encodeBody(body) }
-    if (ProviderShared.isRecord(body)) {
-      const overlaid = mergeJsonRecords(body, request.http.body) ?? {}
-      return { jsonBody: overlaid, bodyText: ProviderShared.encodeJson(overlaid) }
-    }
-    return yield* ProviderShared.invalidRequest("http.body can only overlay JSON object request bodies")
-  })
-
-export const jsonRequestParts = <Body>(input: JsonRequestInput<Body>) =>
-  Effect.gen(function* () {
-    const url = applyQuery(
-      renderEndpoint(input.endpoint, { request: input.request, body: input.body }).toString(),
-      input.request.http?.query,
-    )
-    const body = yield* bodyWithOverlay(input.body, input.request, input.encodeBody)
-    const headers = yield* Auth.toEffect(input.auth)({
-      request: input.request,
-      method: "POST",
-      url,
-      body: body.bodyText,
-      headers: Headers.fromInput({
-        ...input.headers?.({ request: input.request }),
-        ...input.request.http?.headers,
-      }),
-    })
-    return { url, jsonBody: body.jsonBody, bodyText: body.bodyText, headers }
-  })
-
-export interface HttpJsonInput<_Body, Frame> {
-  readonly framing: Framing.Definition<Frame>
-}
-
-export type HttpJsonPatch<Body, Frame> = Partial<HttpJsonInput<Body, Frame>>
-
-export interface HttpJsonTransport<Body, Frame> extends Transport<Body, HttpPrepared<Frame>, Frame> {
-  readonly with: (patch: HttpJsonPatch<Body, Frame>) => HttpJsonTransport<Body, Frame>
-}
-
-export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJsonTransport<Body, Frame> => ({
-  id: "http-json",
-  with: (patch) => httpJson({ ...input, ...patch }),
-  prepare: (prepareInput) =>
-    Effect.gen(function* () {
-      const parts = yield* jsonRequestParts({ ...prepareInput })
-      const request = ProviderShared.jsonPost({
-        url: parts.url,
-        body: parts.bodyText,
-        headers: parts.headers,
-      })
-      return {
-        request,
-        framing: input.framing,
-        middleware: prepareInput.middleware,
-      }
-    }),
-  frames: (prepared, request, runtime) =>
-    Stream.unwrap(
-      runtime.http
-        .execute(prepared.request, prepared.middleware)
-        .pipe(
-          Effect.map((response) =>
-            prepared.framing.frame(
-              response.stream.pipe(
-                Stream.mapError((error) =>
-                  ProviderShared.eventError(
-                    `${request.model.provider}/${request.model.route.id}`,
-                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
-                    ProviderShared.errorText(error),
-                  ),
-                ),
-              ),
-            ),
-          ),
-        ),
-    ),
-})
-
-export const sseJson = {
-  id: "http-json/sse",
-  with: <Body>() => httpJson<Body, string>({ framing: Framing.sse }),
-} as const

packages/ai/src/route/transport/index.ts

@@ -1,31 +0,0 @@
-import type { Effect, Stream } from "effect"
-import { Endpoint } from "../endpoint"
-import { Auth } from "../auth"
-import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor"
-import type { Interface as WebSocketExecutorInterface } from "./websocket"
-import type { AIError, LLMRequest } from "../../schema"
-
-export interface TransportRuntime {
-  readonly http: RequestExecutorInterface
-  readonly webSocket?: WebSocketExecutorInterface
-}
-
-export interface Transport<Body, Prepared, Frame> {
-  readonly id: string
-  readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, AIError>
-  readonly frames: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<Frame, AIError>
-}
-
-export interface TransportPrepareInput<Body> {
-  readonly body: Body
-  readonly request: LLMRequest
-  readonly endpoint: Endpoint.Definition<Body>
-  readonly auth: Auth.Definition
-  readonly encodeBody: (body: Body) => string
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  readonly middleware?: HttpMiddleware
-}
-
-export * as HttpTransport from "./http"
-export type { HttpHandler, HttpMiddleware } from "../executor"
-export { WebSocketExecutor, WebSocketTransport } from "./websocket"

packages/ai/src/route/transport/websocket.ts

@@ -1,280 +0,0 @@
-import { Cause, Context, Effect, Layer, Queue, Stream } from "effect"
-import { Headers } from "effect/unstable/http"
-import { AIError, TransportReason } from "../../schema"
-import * as HttpTransport from "./http"
-import type { Transport } from "./index"
-
-export interface WebSocketRequest {
-  readonly url: string
-  readonly headers: Headers.Headers
-}
-
-export interface WebSocketConnection {
-  readonly sendText: (message: string) => Effect.Effect<void, AIError>
-  readonly messages: Stream.Stream<string | Uint8Array, AIError>
-  readonly close: Effect.Effect<void, never>
-}
-
-export interface Interface {
-  readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>
-}
-
-type WebSocketConstructorWithHeaders = new (
-  url: string,
-  options?: { readonly headers?: Headers.Headers },
-) => globalThis.WebSocket
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/AI/WebSocketExecutor") {}
-
-const transportError = (
-  method: string,
-  message: string,
-  input: { readonly url?: string; readonly kind?: string } = {},
-) =>
-  new AIError({
-    module: "WebSocketExecutor",
-    method,
-    reason: new TransportReason({ message, url: input.url, kind: input.kind }),
-  })
-
-const eventMessage = (event: Event) => {
-  if ("message" in event && typeof event.message === "string") return event.message
-  return event.type
-}
-
-const binaryMessage = (data: unknown) => {
-  if (data instanceof Uint8Array) return data
-  if (data instanceof ArrayBuffer) return new Uint8Array(data)
-  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-  return undefined
-}
-
-const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
-  if (ws.readyState === globalThis.WebSocket.OPEN) return Effect.void
-  if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
-    return Effect.fail(
-      transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
-        url: input.url,
-        kind: "open",
-      }),
-    )
-  }
-  return Effect.callback<void, AIError>((resume, signal) => {
-    const cleanup = () => {
-      ws.removeEventListener("open", onOpen)
-      ws.removeEventListener("error", onError)
-      ws.removeEventListener("close", onClose)
-      signal.removeEventListener("abort", onAbort)
-    }
-    const onAbort = () => {
-      cleanup()
-      if (ws.readyState !== globalThis.WebSocket.CLOSED && ws.readyState !== globalThis.WebSocket.CLOSING)
-        ws.close(1000)
-    }
-    const onOpen = () => {
-      cleanup()
-      resume(Effect.void)
-    }
-    const onError = (event: Event) => {
-      cleanup()
-      resume(
-        Effect.fail(
-          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, { url: input.url, kind: "open" }),
-        ),
-      )
-    }
-    const onClose = (event: CloseEvent) => {
-      cleanup()
-      resume(
-        Effect.fail(
-          transportError("open", `WebSocket closed before opening with code ${event.code}`, {
-            url: input.url,
-            kind: "open",
-          }),
-        ),
-      )
-    }
-    ws.addEventListener("open", onOpen, { once: true })
-    ws.addEventListener("error", onError, { once: true })
-    ws.addEventListener("close", onClose, { once: true })
-    signal.addEventListener("abort", onAbort, { once: true })
-  })
-}
-
-const webSocketUrl = (value: string) =>
-  Effect.try({
-    try: () => {
-      const url = new URL(value)
-      if (url.protocol === "https:") {
-        url.protocol = "wss:"
-        return url.toString()
-      }
-      if (url.protocol === "http:") {
-        url.protocol = "ws:"
-        return url.toString()
-      }
-      throw new Error(`Unsupported WebSocket URL protocol ${url.protocol}`)
-    },
-    catch: (error) =>
-      transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
-        url: value,
-        kind: "websocket",
-      }),
-  })
-
-export const open = (input: WebSocketRequest) =>
-  Effect.try({
-    try: () =>
-      new (globalThis.WebSocket as unknown as WebSocketConstructorWithHeaders)(input.url, { headers: input.headers }),
-    catch: (error) =>
-      transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
-        url: input.url,
-        kind: "open",
-      }),
-  }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)))
-
-export const layer: Layer.Layer<Service> = Layer.succeed(Service, Service.of({ open }))
-
-export const fromWebSocket = (
-  ws: globalThis.WebSocket,
-  input: WebSocketRequest,
-): Effect.Effect<WebSocketConnection, AIError> =>
-  Effect.gen(function* () {
-    yield* waitOpen(ws, input)
-    const messages = yield* Queue.bounded<string | Uint8Array, AIError | Cause.Done<void>>(128)
-
-    const onMessage = (event: MessageEvent) => {
-      if (typeof event.data === "string") return Queue.offerUnsafe(messages, event.data)
-      const binary = binaryMessage(event.data)
-      if (binary) return Queue.offerUnsafe(messages, binary)
-      Queue.failCauseUnsafe(
-        messages,
-        Cause.fail(
-          transportError("message", "Unsupported WebSocket message payload", { url: input.url, kind: "message" }),
-        ),
-      )
-    }
-    const onError = (event: Event) => {
-      Queue.failCauseUnsafe(
-        messages,
-        Cause.fail(
-          transportError("message", `WebSocket error: ${eventMessage(event)}`, { url: input.url, kind: "message" }),
-        ),
-      )
-    }
-    const onClose = (event: CloseEvent) => {
-      if (event.code === 1000 || event.code === 1005) return Queue.endUnsafe(messages)
-      Queue.failCauseUnsafe(
-        messages,
-        Cause.fail(
-          transportError("message", `WebSocket closed with code ${event.code}`, { url: input.url, kind: "close" }),
-        ),
-      )
-    }
-    const cleanup = Effect.sync(() => {
-      ws.removeEventListener("message", onMessage)
-      ws.removeEventListener("error", onError)
-      ws.removeEventListener("close", onClose)
-    }).pipe(Effect.andThen(Queue.shutdown(messages)))
-
-    ws.addEventListener("message", onMessage)
-    ws.addEventListener("error", onError)
-    ws.addEventListener("close", onClose)
-
-    return {
-      sendText: (message) =>
-        Effect.try({
-          try: () => ws.send(message),
-          catch: (error) =>
-            transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
-              url: input.url,
-              kind: "write",
-            }),
-        }),
-      messages: Stream.fromQueue(messages),
-      close: cleanup.pipe(
-        Effect.andThen(
-          Effect.sync(() => {
-            if (ws.readyState === globalThis.WebSocket.CLOSED || ws.readyState === globalThis.WebSocket.CLOSING) return
-            ws.close(1000)
-          }),
-        ),
-      ),
-    }
-  })
-
-export const messageText = (message: string | Uint8Array, decoder: TextDecoder) =>
-  typeof message === "string" ? message : decoder.decode(message)
-
-export interface JsonPrepared {
-  readonly url: string
-  readonly headers: Headers.Headers
-  readonly message: string
-}
-
-export interface JsonInput<Body, Message> {
-  readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, AIError>
-  readonly encodeMessage: (message: Message) => string
-}
-
-export type JsonPatch<Body, Message> = Partial<JsonInput<Body, Message>>
-
-export interface JsonTransport<Body, Message> extends Transport<Body, JsonPrepared, string> {
-  readonly with: (patch: JsonPatch<Body, Message>) => JsonTransport<Body, Message>
-}
-
-export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransport<Body, Message> => ({
-  id: "websocket-json",
-  with: (patch) => json({ ...input, ...patch }),
-  prepare: (prepareInput) =>
-    Effect.gen(function* () {
-      const parts = yield* HttpTransport.jsonRequestParts({
-        ...prepareInput,
-      })
-      return {
-        url: yield* webSocketUrl(parts.url),
-        headers: parts.headers,
-        message: input.encodeMessage(yield* input.toMessage(parts.jsonBody)),
-      }
-    }),
-  frames: (prepared, _request, runtime) => {
-    const webSocket = runtime.webSocket
-    if (!webSocket) {
-      return Stream.fail(
-        transportError("json", "WebSocket JSON transport requires WebSocketExecutor.Service", {
-          url: prepared.url,
-          kind: "websocket",
-        }),
-      )
-    }
-    const decoder = new TextDecoder()
-    return Stream.unwrap(
-      Effect.gen(function* () {
-        const connection = yield* Effect.acquireRelease(
-          webSocket.open({ url: prepared.url, headers: prepared.headers }),
-          (connection) => connection.close,
-        )
-        yield* connection.sendText(prepared.message)
-        return connection.messages.pipe(Stream.map((message) => messageText(message, decoder)))
-      }),
-    )
-  },
-})
-
-export const jsonTransport = {
-  id: "websocket-json",
-  with: json,
-} as const
-
-export const WebSocketExecutor = {
-  Service,
-  layer,
-  open,
-  fromWebSocket,
-  messageText,
-} as const
-
-export const WebSocketTransport = {
-  json,
-  jsonTransport,
-} as const

packages/ai/src/schema/errors.ts

@@ -1,157 +0,0 @@
-import { Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
-import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids"
-
-export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
-export type ProviderFailureClassification = typeof ProviderFailureClassification.Type
-
-export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("AI.HttpRequestDetails")({
-  method: Schema.String,
-  url: Schema.String,
-  headers: Schema.Record(Schema.String, Schema.String),
-}) {}
-
-export class HttpResponseDetails extends Schema.Class<HttpResponseDetails>("AI.HttpResponseDetails")({
-  status: Schema.Number,
-  headers: Schema.Record(Schema.String, Schema.String),
-}) {}
-
-export class HttpRateLimitDetails extends Schema.Class<HttpRateLimitDetails>("AI.HttpRateLimitDetails")({
-  retryAfterMs: Schema.optional(Schema.Number),
-  limit: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  remaining: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
-  request: HttpRequestDetails,
-  response: Schema.optional(HttpResponseDetails),
-  body: Schema.optional(Schema.String),
-  bodyTruncated: Schema.optional(Schema.Boolean),
-  requestId: Schema.optional(Schema.String),
-  rateLimit: Schema.optional(HttpRateLimitDetails),
-}) {}
-
-export class InvalidRequestReason extends Schema.Class<InvalidRequestReason>("AI.Error.InvalidRequest")({
-  _tag: Schema.tag("InvalidRequest"),
-  message: Schema.String,
-  parameter: Schema.optional(Schema.String),
-  classification: Schema.optional(ProviderFailureClassification),
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class NoRouteReason extends Schema.Class<NoRouteReason>("AI.Error.NoRoute")({
-  _tag: Schema.tag("NoRoute"),
-  route: RouteID,
-  provider: ProviderID,
-  model: ModelID,
-}) {
-  get message() {
-    return `No AI route for ${this.provider}/${this.model} using ${this.route}`
-  }
-}
-
-export class AuthenticationReason extends Schema.Class<AuthenticationReason>("AI.Error.Authentication")({
-  _tag: Schema.tag("Authentication"),
-  message: Schema.String,
-  kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class RateLimitReason extends Schema.Class<RateLimitReason>("AI.Error.RateLimit")({
-  _tag: Schema.tag("RateLimit"),
-  message: Schema.String,
-  retryAfterMs: Schema.optional(Schema.Number),
-  rateLimit: Schema.optional(HttpRateLimitDetails),
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class QuotaExceededReason extends Schema.Class<QuotaExceededReason>("AI.Error.QuotaExceeded")({
-  _tag: Schema.tag("QuotaExceeded"),
-  message: Schema.String,
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class ContentPolicyReason extends Schema.Class<ContentPolicyReason>("AI.Error.ContentPolicy")({
-  _tag: Schema.tag("ContentPolicy"),
-  message: Schema.String,
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>("AI.Error.ProviderInternal")({
-  _tag: Schema.tag("ProviderInternal"),
-  message: Schema.String,
-  status: Schema.optional(Schema.Number),
-  retryAfterMs: Schema.optional(Schema.Number),
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Transport")({
-  _tag: Schema.tag("Transport"),
-  message: Schema.String,
-  kind: Schema.optional(Schema.String),
-  url: Schema.optional(Schema.String),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOutputReason>(
-  "AI.Error.InvalidProviderOutput",
-)({
-  _tag: Schema.tag("InvalidProviderOutput"),
-  message: Schema.String,
-  classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
-  route: Schema.optional(Schema.String),
-  raw: Schema.optional(Schema.String),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {}
-
-export class UnknownProviderReason extends Schema.Class<UnknownProviderReason>("AI.Error.UnknownProvider")({
-  _tag: Schema.tag("UnknownProvider"),
-  message: Schema.String,
-  status: Schema.optional(Schema.Number),
-  providerMetadata: Schema.optional(ProviderMetadata),
-  http: Schema.optional(HttpContext),
-}) {}
-
-export const AIErrorReason = Schema.Union([
-  InvalidRequestReason,
-  NoRouteReason,
-  AuthenticationReason,
-  RateLimitReason,
-  QuotaExceededReason,
-  ContentPolicyReason,
-  ProviderInternalReason,
-  TransportReason,
-  InvalidProviderOutputReason,
-  UnknownProviderReason,
-]).pipe(Schema.toTaggedUnion("_tag"))
-export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>
-
-export class AIError extends Schema.TaggedErrorClass<AIError>()("AI.Error", {
-  module: Schema.String,
-  method: Schema.String,
-  reason: AIErrorReason,
-}) {
-  override readonly cause = this.reason
-
-  override get message() {
-    return `${this.module}.${this.method}: ${this.reason.message}`
-  }
-}
-
-/**
- * Failure type for tool execute handlers. Handlers must map their internal
- * errors to this shape; the runtime catches `ToolFailure`s and surfaces them
- * as `tool-error` events plus a `tool-result` of `type: "error"` so the model
- * can self-correct.
- *
- * Anything thrown or yielded by a handler that is not a `ToolFailure` is
- * treated as a defect and fails the stream.
- */
-export class ToolFailure extends Tool.Error {}

packages/ai/src/schema/messages.ts

@@ -1,303 +0,0 @@
-import { Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
-import { JsonSchema, MessageRole, ProviderMetadata } from "./ids"
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, LanguageModelSchema, ProviderOptions } from "./options"
-import { isRecord } from "../utils/record"
-
-const systemPartSchema = Schema.Struct({
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  cache: Schema.optional(CacheHint),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}).annotate({ identifier: "LLM.SystemPart" })
-export type SystemPart = Schema.Schema.Type<typeof systemPartSchema>
-
-const makeSystemPart = (text: string): SystemPart => ({ type: "text", text })
-
-export const SystemPart = Object.assign(systemPartSchema, {
-  make: makeSystemPart,
-  content: (input?: string | SystemPart | ReadonlyArray<SystemPart>) => {
-    if (input === undefined) return []
-    return typeof input === "string" ? [makeSystemPart(input)] : Array.isArray(input) ? [...input] : [input]
-  },
-})
-
-export const TextPart = Schema.Struct({
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  cache: Schema.optional(CacheHint),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}).annotate({ identifier: "LLM.Content.Text" })
-export type TextPart = Schema.Schema.Type<typeof TextPart>
-
-export const MediaPart = Schema.Struct({
-  type: Schema.Literal("media"),
-  mediaType: Schema.String,
-  data: Schema.Union([Schema.String, Schema.Uint8Array]),
-  filename: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}).annotate({ identifier: "LLM.Content.Media" })
-export type MediaPart = Schema.Schema.Type<typeof MediaPart>
-
-const isToolResultValue = (value: unknown): value is ToolResultValue =>
-  isRecord(value) &&
-  (value.type === "text" || value.type === "json" || value.type === "error" || value.type === "content") &&
-  "value" in value
-
-export const ToolResultValue = Object.assign(
-  Schema.Union([
-    Schema.Struct({
-      type: Schema.Literal("json"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("text"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("error"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("content"),
-      value: Schema.Array(Tool.Content),
-    }),
-  ]).annotate({ identifier: "LLM.ToolResult" }),
-  {
-    is: isToolResultValue,
-    make: (value: unknown, type: ToolResultValue["type"] = "json"): ToolResultValue => {
-      if (isToolResultValue(value)) return value
-      if (type === "content") return { type, value: Array.isArray(value) ? value : [] }
-      return { type, value }
-    },
-  },
-)
-export type ToolResultValue = Schema.Schema.Type<typeof ToolResultValue>
-
-export interface ToolOutput {
-  readonly structured: unknown
-  readonly content: ReadonlyArray<Tool.Content>
-}
-
-export const ToolOutput = Object.assign(
-  Schema.Struct({
-    structured: Schema.Unknown,
-    content: Schema.Array(Tool.Content),
-  }).annotate({ identifier: "LLM.ToolOutput" }),
-  {
-    make: (structured: unknown, content: ReadonlyArray<Tool.Content> = []): ToolOutput => ({ structured, content }),
-    fromResultValue: (result: ToolResultValue): ToolOutput | undefined => {
-      switch (result.type) {
-        case "json":
-          return { structured: result.value, content: [] }
-        case "text":
-          return { structured: {}, content: [{ type: "text", text: toolResultText(result.value) }] }
-        case "content":
-          return { structured: {}, content: result.value }
-        case "error":
-          return undefined
-      }
-    },
-    toResultValue: (output: ToolOutput): ToolResultValue => {
-      if (output.content.length === 0) return { type: "json", value: output.structured }
-      if (output.content.length === 1 && output.content[0]?.type === "text")
-        return { type: "text", value: output.content[0].text }
-      return { type: "content", value: output.content }
-    },
-  },
-)
-
-const toolResultText = (value: unknown) => {
-  if (typeof value === "string") return value
-  try {
-    return JSON.stringify(value) ?? String(value)
-  } catch {
-    return String(value)
-  }
-}
-
-export const ToolCallPart = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("tool-call"),
-    id: Schema.String,
-    name: Schema.String,
-    input: Schema.Unknown,
-    providerExecuted: Schema.optional(Schema.Boolean),
-    cache: Schema.optional(CacheHint),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    providerMetadata: Schema.optional(ProviderMetadata),
-  }).annotate({ identifier: "LLM.Content.ToolCall" }),
-  {
-    make: (input: Omit<ToolCallPart, "type">): ToolCallPart => ({ type: "tool-call", ...input }),
-  },
-)
-export type ToolCallPart = Schema.Schema.Type<typeof ToolCallPart>
-
-export const ToolResultPart = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("tool-result"),
-    id: Schema.String,
-    name: Schema.String,
-    result: ToolResultValue,
-    providerExecuted: Schema.optional(Schema.Boolean),
-    cache: Schema.optional(CacheHint),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    providerMetadata: Schema.optional(ProviderMetadata),
-  }).annotate({ identifier: "LLM.Content.ToolResult" }),
-  {
-    make: (
-      input: Omit<ToolResultPart, "type" | "result"> & {
-        readonly result: unknown
-        readonly resultType?: ToolResultValue["type"]
-      },
-    ): ToolResultPart => ({
-      type: "tool-result",
-      id: input.id,
-      name: input.name,
-      result: ToolResultValue.make(input.result, input.resultType),
-      providerExecuted: input.providerExecuted,
-      cache: input.cache,
-      metadata: input.metadata,
-      providerMetadata: input.providerMetadata,
-    }),
-  },
-)
-export type ToolResultPart = Schema.Schema.Type<typeof ToolResultPart>
-
-export const ReasoningPart = Schema.Struct({
-  type: Schema.Literal("reasoning"),
-  text: Schema.String,
-  encrypted: Schema.optional(Schema.String),
-  cache: Schema.optional(CacheHint),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}).annotate({ identifier: "LLM.Content.Reasoning" })
-export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
-
-export const ContentPart = Schema.Union([TextPart, MediaPart, ToolCallPart, ToolResultPart, ReasoningPart]).pipe(
-  Schema.toTaggedUnion("type"),
-)
-export type ContentPart = Schema.Schema.Type<typeof ContentPart>
-
-export class Message extends Schema.Class<Message>("LLM.Message")({
-  id: Schema.optional(Schema.String),
-  role: MessageRole,
-  content: Schema.Array(ContentPart),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {}
-
-export namespace Message {
-  export type ContentInput = string | ContentPart | ReadonlyArray<ContentPart>
-  export type SystemContentInput = string | TextPart | ReadonlyArray<TextPart>
-  export type Input = Omit<ConstructorParameters<typeof Message>[0], "content"> & {
-    readonly content: ContentInput
-  }
-
-  export const text = (value: string): ContentPart => ({ type: "text", text: value })
-
-  export const content = (input: ContentInput) =>
-    typeof input === "string" ? [text(input)] : Array.isArray(input) ? [...input] : [input]
-
-  export const make = (input: Message | Input) => {
-    if (input instanceof Message) return input
-    return new Message({ ...input, content: content(input.content) })
-  }
-
-  export const user = (content: ContentInput) => make({ role: "user", content })
-
-  export const assistant = (content: ContentInput) => make({ role: "assistant", content })
-
-  /**
-   * Add an operator-authored instruction at this chronological point in the
-   * conversation. This is distinct from the initial `LLMRequest.system`
-   * prompt. Keep raw retrieved, tool, and web content out of privileged system
-   * updates; pass that untrusted content through ordinary user/tool channels.
-   */
-  export const system = (content: SystemContentInput) => make({ role: "system", content })
-
-  export const tool = (result: ToolResultPart | Parameters<typeof ToolResultPart.make>[0]) =>
-    make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
-}
-
-export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
-  name: Schema.String,
-  description: Schema.String,
-  inputSchema: JsonSchema,
-  outputSchema: Schema.optional(JsonSchema),
-  cache: Schema.optional(CacheHint),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {}
-
-export namespace ToolDefinition {
-  export type Input = ToolDefinition | ConstructorParameters<typeof ToolDefinition>[0]
-
-  /** Normalize tool definition input into the canonical `ToolDefinition` class. */
-  export const make = (input: Input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input))
-}
-
-export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
-  type: Schema.Literals(["auto", "none", "required", "tool"]),
-  name: Schema.optional(Schema.String),
-}) {}
-
-export namespace ToolChoice {
-  export type Mode = Exclude<ToolChoice["type"], "tool">
-  export type Input = ToolChoice | ConstructorParameters<typeof ToolChoice>[0] | ToolDefinition | string
-
-  const isMode = (value: string): value is Mode => value === "auto" || value === "none" || value === "required"
-
-  /** Select a specific named tool. */
-  export const named = (value: string) => new ToolChoice({ type: "tool", name: value })
-
-  /** Normalize ergonomic tool-choice inputs into the canonical `ToolChoice` class. */
-  export const make = (input: Input) => {
-    if (input instanceof ToolChoice) return input
-    if (input instanceof ToolDefinition) return named(input.name)
-    if (typeof input === "string") return isMode(input) ? new ToolChoice({ type: input }) : named(input)
-    return new ToolChoice(input)
-  }
-}
-
-export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
-  id: Schema.optional(Schema.String),
-  model: LanguageModelSchema,
-  system: Schema.Array(SystemPart),
-  messages: Schema.Array(Message),
-  tools: Schema.Array(ToolDefinition),
-  toolChoice: Schema.optional(ToolChoice),
-  generation: Schema.optional(GenerationOptions),
-  providerOptions: Schema.optional(ProviderOptions),
-  http: Schema.optional(HttpOptions),
-  cache: Schema.optional(CachePolicy),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {}
-
-export namespace LLMRequest {
-  export type Input = ConstructorParameters<typeof LLMRequest>[0]
-
-  export const input = (request: LLMRequest): Input => ({
-    id: request.id,
-    model: request.model,
-    system: request.system,
-    messages: request.messages,
-    tools: request.tools,
-    toolChoice: request.toolChoice,
-    generation: request.generation,
-    providerOptions: request.providerOptions,
-    http: request.http,
-    cache: request.cache,
-    metadata: request.metadata,
-  })
-
-  export const update = (request: LLMRequest, patch: Partial<Input>) => {
-    if (Object.keys(patch).length === 0) return request
-    return new LLMRequest({
-      ...input(request),
-      ...patch,
-      model: patch.model ?? request.model,
-    })
-  }
-}

packages/ai/src/schema/options.ts

@@ -1,295 +0,0 @@
-import { Schema } from "effect"
-import { JsonSchema, ModelID, ProviderID } from "./ids"
-import type { AnyRoute } from "../route/client"
-import { isRecord } from "../utils/record"
-
-export const mergeJsonRecords = (
-  ...items: ReadonlyArray<Record<string, unknown> | undefined>
-): Record<string, unknown> | undefined => {
-  const defined = items.filter((item): item is Record<string, unknown> => item !== undefined)
-  if (defined.length === 0) return undefined
-  if (defined.length === 1 && Object.values(defined[0]).every((value) => value !== undefined)) return defined[0]
-  const result: Record<string, unknown> = {}
-  for (const item of defined) {
-    for (const [key, value] of Object.entries(item)) {
-      if (value === undefined) continue
-      result[key] = isRecord(result[key]) && isRecord(value) ? mergeJsonRecords(result[key], value) : value
-    }
-  }
-  return Object.keys(result).length === 0 ? undefined : result
-}
-
-const mergeStringRecords = (
-  ...items: ReadonlyArray<Record<string, string> | undefined>
-): Record<string, string> | undefined => {
-  const defined = items.filter((item): item is Record<string, string> => item !== undefined)
-  if (defined.length === 0) return undefined
-  if (defined.length === 1) return defined[0]
-  const result = Object.fromEntries(
-    defined.flatMap((item) =>
-      Object.entries(item).filter((entry): entry is [string, string] => entry[1] !== undefined),
-    ),
-  )
-  return Object.keys(result).length === 0 ? undefined : result
-}
-
-export const ProviderOptions = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))
-export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>
-
-export const mergeProviderOptions = (
-  ...items: ReadonlyArray<ProviderOptions | undefined>
-): ProviderOptions | undefined => {
-  const result: Record<string, Record<string, unknown>> = {}
-  for (const item of items) {
-    if (!item) continue
-    for (const [provider, options] of Object.entries(item)) {
-      const merged = mergeJsonRecords(result[provider], options)
-      if (merged) result[provider] = merged
-    }
-  }
-  return Object.keys(result).length === 0 ? undefined : result
-}
-
-export class HttpOptions extends Schema.Class<HttpOptions>("AI.HttpOptions")({
-  body: Schema.optional(JsonSchema),
-  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  query: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-export namespace HttpOptions {
-  export type Input = HttpOptions | ConstructorParameters<typeof HttpOptions>[0]
-
-  /** Normalize HTTP option input into the canonical `HttpOptions` class. */
-  export const make = (input: Input) => (input instanceof HttpOptions ? input : new HttpOptions(input))
-}
-
-export const mergeHttpOptions = (...items: ReadonlyArray<HttpOptions | undefined>): HttpOptions | undefined => {
-  const body = mergeJsonRecords(...items.map((item) => item?.body))
-  const headers = mergeStringRecords(...items.map((item) => item?.headers))
-  const query = mergeStringRecords(...items.map((item) => item?.query))
-  if (!body && !headers && !query) return undefined
-  return new HttpOptions({ body, headers, query })
-}
-
-export class GenerationOptions extends Schema.Class<GenerationOptions>("LLM.GenerationOptions")({
-  maxTokens: Schema.optional(Schema.Number),
-  temperature: Schema.optional(Schema.Number),
-  topP: Schema.optional(Schema.Number),
-  topK: Schema.optional(Schema.Number),
-  frequencyPenalty: Schema.optional(Schema.Number),
-  presencePenalty: Schema.optional(Schema.Number),
-  seed: Schema.optional(Schema.Number),
-  stop: Schema.optional(Schema.Array(Schema.String)),
-}) {}
-
-export namespace GenerationOptions {
-  export type Input = GenerationOptions | ConstructorParameters<typeof GenerationOptions>[0]
-
-  /** Normalize generation option input into the canonical `GenerationOptions` class. */
-  export const make = (input: Input = {}) => (input instanceof GenerationOptions ? input : new GenerationOptions(input))
-}
-
-export type GenerationOptionsFields = {
-  readonly maxTokens?: number
-  readonly temperature?: number
-  readonly topP?: number
-  readonly topK?: number
-  readonly frequencyPenalty?: number
-  readonly presencePenalty?: number
-  readonly seed?: number
-  readonly stop?: ReadonlyArray<string>
-}
-
-export type GenerationOptionsInput = GenerationOptions | GenerationOptionsFields
-
-const latestGeneration = <Key extends keyof GenerationOptionsFields>(
-  items: ReadonlyArray<GenerationOptionsInput | undefined>,
-  key: Key,
-) => items.findLast((item) => item?.[key] !== undefined)?.[key]
-
-export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptionsInput | undefined>) => {
-  const result = new GenerationOptions({
-    maxTokens: latestGeneration(items, "maxTokens"),
-    temperature: latestGeneration(items, "temperature"),
-    topP: latestGeneration(items, "topP"),
-    topK: latestGeneration(items, "topK"),
-    frequencyPenalty: latestGeneration(items, "frequencyPenalty"),
-    presencePenalty: latestGeneration(items, "presencePenalty"),
-    seed: latestGeneration(items, "seed"),
-    stop: latestGeneration(items, "stop"),
-  })
-  return Object.values(result).some((value) => value !== undefined) ? result : undefined
-}
-
-export class LanguageModelLimits extends Schema.Class<LanguageModelLimits>("LLM.LanguageModelLimits")({
-  context: Schema.optional(Schema.Number),
-  input: Schema.optional(Schema.Number),
-  output: Schema.optional(Schema.Number),
-}) {}
-
-export namespace LanguageModelLimits {
-  export type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0]
-
-  /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
-  export const make = (input: Input | undefined) =>
-    input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {})
-}
-
-export class LanguageModelDefaults extends Schema.Class<LanguageModelDefaults>("LLM.LanguageModelDefaults")({
-  limits: Schema.optional(LanguageModelLimits),
-  generation: Schema.optional(GenerationOptions),
-  providerOptions: Schema.optional(ProviderOptions),
-  http: Schema.optional(HttpOptions),
-}) {}
-
-export namespace LanguageModelDefaults {
-  export type Input =
-    | LanguageModelDefaults
-    | {
-        readonly limits?: LanguageModelLimits.Input
-        readonly generation?: GenerationOptions.Input
-        readonly providerOptions?: ProviderOptions
-        readonly http?: HttpOptions.Input
-      }
-
-  /** Normalize selected-model request defaults without applying precedence. */
-  export const make = (input: Input) => {
-    if (input instanceof LanguageModelDefaults) return input
-    return new LanguageModelDefaults({
-      limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
-      generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
-      providerOptions: input.providerOptions,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
-  }
-}
-
-export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"])
-export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>
-
-export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"])
-export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<
-  typeof LanguageModelMaxTokensFieldCompatibility
->
-
-export class LanguageModelCompatibility extends Schema.Class<LanguageModelCompatibility>(
-  "LLM.LanguageModelCompatibility",
-)({
-  toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
-  reasoningField: Schema.optional(Schema.String),
-  maxTokensField: Schema.optional(LanguageModelMaxTokensFieldCompatibility),
-  requireFinishReason: Schema.optional(Schema.Boolean),
-}) {}
-
-export namespace LanguageModelCompatibility {
-  export type Input = LanguageModelCompatibility | ConstructorParameters<typeof LanguageModelCompatibility>[0]
-
-  /** Normalize model/upstream compatibility metadata without projecting requests. */
-  export const make = (input: Input) =>
-    input instanceof LanguageModelCompatibility ? input : new LanguageModelCompatibility(input)
-}
-
-export class LanguageModel<Options extends ProviderOptions = ProviderOptions> {
-  declare protected readonly _ProviderOptions: Options
-  readonly id: ModelID
-  readonly provider: ProviderID
-  readonly route: AnyRoute
-  readonly defaults?: LanguageModelDefaults
-  readonly compatibility?: LanguageModelCompatibility
-
-  constructor(input: LanguageModel.ConstructorInput) {
-    this.id = input.id
-    this.provider = input.provider
-    this.route = input.route
-    this.defaults = input.defaults
-    this.compatibility = input.compatibility
-  }
-
-  static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input) {
-    return new LanguageModel<Options>({
-      id: ModelID.make(input.id),
-      provider: ProviderID.make(input.provider),
-      route: input.route,
-      defaults: input.defaults === undefined ? undefined : LanguageModelDefaults.make(input.defaults),
-      compatibility:
-        input.compatibility === undefined ? undefined : LanguageModelCompatibility.make(input.compatibility),
-    })
-  }
-
-  static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput {
-    return {
-      id: model.id,
-      provider: model.provider,
-      route: model.route,
-      defaults: model.defaults,
-      compatibility: model.compatibility,
-    }
-  }
-
-  static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>) {
-    if (Object.keys(patch).length === 0) return model
-    return LanguageModel.make<Options>({
-      ...LanguageModel.input(model),
-      ...patch,
-    })
-  }
-}
-
-export namespace LanguageModel {
-  export type ConstructorInput = {
-    readonly id: ModelID
-    readonly provider: ProviderID
-    readonly route: AnyRoute
-    readonly defaults?: LanguageModelDefaults
-    readonly compatibility?: LanguageModelCompatibility
-  }
-
-  export type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
-    readonly id: string | ModelID
-    readonly provider: string | ProviderID
-    readonly defaults?: LanguageModelDefaults.Input
-    readonly compatibility?: LanguageModelCompatibility.Input
-  }
-}
-
-export type LanguageModelInput = LanguageModel.Input
-
-export type LanguageModelProviderOptions<SelectedModel> =
-  SelectedModel extends LanguageModel<infer Options> ? Options : never
-
-export const LanguageModelSchema = Schema.declare((value): value is LanguageModel => value instanceof LanguageModel, {
-  expected: "LLM.LanguageModel",
-})
-
-export class CacheHint extends Schema.Class<CacheHint>("LLM.CacheHint")({
-  type: Schema.Literals(["ephemeral", "persistent"]),
-  ttlSeconds: Schema.optional(Schema.Number),
-}) {}
-
-// Auto-placement policy for prompt caching. The protocol-neutral lowering step
-// reads this and injects `CacheHint`s at the configured boundaries; the
-// per-protocol body builders then translate those hints into wire markers as
-// usual. `"auto"` is the recommended default for agent loops — it places
-// breakpoints at the last tool definition, the first and last distinct system
-// parts, and the conversation tail. The rolling message breakpoint keeps a
-// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
-// tool loops.
-//
-// Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular
-// object form to override individual choices.
-export const CachePolicyObject = Schema.Struct({
-  tools: Schema.optional(Schema.Boolean),
-  system: Schema.optional(Schema.Boolean),
-  messages: Schema.optional(
-    Schema.Union([
-      Schema.Literal("latest-user-message"),
-      Schema.Literal("latest-assistant"),
-      Schema.Struct({ tail: Schema.Number }),
-    ]),
-  ),
-  ttlSeconds: Schema.optional(Schema.Number),
-})
-export type CachePolicyObject = Schema.Schema.Type<typeof CachePolicyObject>
-
-export const CachePolicy = Schema.Union([Schema.Literal("auto"), Schema.Literal("none"), CachePolicyObject])
-export type CachePolicy = Schema.Schema.Type<typeof CachePolicy>

packages/ai/src/testing.ts

@@ -1,156 +0,0 @@
-export * as TestLLM from "./testing"
-
-import { LLMClient, type Interface as LLMClientShape } from "./route/client"
-import {
-  LLMEvent,
-  LLMResponse,
-  type FinishReasonDetails,
-  type AIError,
-  type LLMRequest,
-  type UsageInput,
-} from "./schema"
-import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect"
-
-export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>
-
-export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>
-
-export interface Interface {
-  readonly requests: LLMRequest[]
-  readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
-  readonly always: (response: Response) => Effect.Effect<void>
-  readonly wait: (count: number) => Effect.Effect<void>
-  readonly gate: Effect.Effect<Gate, never, Scope.Scope>
-  readonly client: LLMClientShape
-}
-
-export interface LayerOptions {
-  readonly transformRequest?: (request: LLMRequest) => LLMRequest
-  /** Used after the one-shot response queue is exhausted. Omit to defect on unexpected requests. */
-  readonly fallback?: Response
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ai/TestLLM") {}
-
-export const complete = (
-  options: { readonly reason: FinishReasonDetails; readonly usage?: UsageInput },
-  ...events: readonly LLMEvent[]
-) => [
-  LLMEvent.stepStart({ index: 0 }),
-  ...events,
-  LLMEvent.stepFinish({ index: 0, reason: options.reason, usage: options.usage }),
-  LLMEvent.finish({ reason: options.reason }),
-]
-
-export const stop = (...events: readonly LLMEvent[]) => complete({ reason: { normalized: "stop" } }, ...events)
-
-export const toolCalls = (...events: readonly LLMEvent[]) =>
-  complete({ reason: { normalized: "tool-calls" } }, ...events)
-
-const textEvents = (value: string, id: string) => [
-  LLMEvent.textStart({ id }),
-  LLMEvent.textDelta({ id, text: value }),
-  LLMEvent.textEnd({ id }),
-]
-
-export const text = (value: string, id: string) => stop(...textEvents(value, id))
-
-export const textWithUsage = (value: string, id: string, inputTokens: number) =>
-  complete(
-    { reason: { normalized: "stop" }, usage: { inputTokens, nonCachedInputTokens: inputTokens } },
-    ...textEvents(value, id),
-  )
-
-export const tool = (id: string, name: string, input: unknown) => toolCalls(LLMEvent.toolCall({ id, name, input }))
-
-export const failAfter = (error: AIError, ...events: readonly LLMEvent[]) =>
-  Stream.fromIterable(events).pipe(Stream.concat(Stream.fail(error)))
-
-export const hangAfter = (...events: readonly LLMEvent[]) => Stream.concat(Stream.fromIterable(events), Stream.never)
-
-const toStream = (response: Response) => (Stream.isStream(response) ? response : Stream.fromIterable(response))
-
-export const layer = (options: LayerOptions = {}) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const requests: LLMRequest[] = []
-      const responses: Response[] = []
-      let started = Deferred.makeUnsafe<void>()
-      let fallback = options.fallback
-      let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
-      const wait = (count: number): Effect.Effect<void> =>
-        Effect.suspend(() =>
-          requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
-        )
-
-      const stream = ((request: LLMRequest) => {
-        requests.push(options.transformRequest?.(request) ?? request)
-        const waiting = started
-        started = Deferred.makeUnsafe()
-        Deferred.doneUnsafe(waiting, Effect.void)
-        const response = responses.shift() ?? fallback
-        if (!response) return Stream.die(new Error(`TestLLM has no response for request ${requests.length}`))
-        const streamed = toStream(response)
-        const gate = activeGate
-        if (!gate) return streamed
-        return Stream.unwrap(
-          Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
-        )
-      }) as LLMClientShape["stream"]
-      const client = LLMClient.Service.of({
-        stream,
-        generate: (request) =>
-          stream(request).pipe(
-            Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
-            Effect.flatMap((state) => {
-              const response = LLMResponse.complete(state)
-              if (response) return Effect.succeed(response)
-              return Effect.die("TestLLM response ended without a terminal finish event")
-            }),
-          ),
-      })
-
-      return Service.of({
-        requests,
-        push: (...input) =>
-          Effect.sync(() => {
-            responses.push(...input)
-          }),
-        always: (response) =>
-          Effect.sync(() => {
-            fallback = response
-          }),
-        wait,
-        gate: Effect.gen(function* () {
-          const gate = {
-            started: yield* Effect.acquireRelease(Queue.unbounded<void>(), Queue.shutdown),
-            release: yield* Latch.make(),
-          }
-          activeGate = gate
-          const release = Effect.sync(() => {
-            if (activeGate === gate) activeGate = undefined
-          }).pipe(Effect.andThen(gate.release.open), Effect.asVoid)
-          yield* Effect.addFinalizer(() => release)
-          return {
-            started: Queue.take(gate.started),
-            release,
-          }
-        }),
-        client,
-      })
-    }),
-  )
-
-export const clientLayer = Layer.effect(
-  LLMClient.Service,
-  Effect.map(Service, (service) => service.client),
-)
-
-export const push = (...responses: readonly Response[]) => Service.use((service) => service.push(...responses))
-
-export const always = (response: Response) => Service.use((service) => service.always(response))
-
-export const wait = (count: number) => Service.use((service) => service.wait(count))
-
-export const gate = Service.use((service) => service.gate)

packages/ai/src/tool-runtime.ts

@@ -1,97 +0,0 @@
-import { Effect } from "effect"
-import {
-  LLMEvent,
-  type ToolCallPart,
-  ToolFailure,
-  ToolOutput,
-  ToolResultValue,
-  type ToolOutput as ToolOutputType,
-  type ToolResultValue as ToolResultValueType,
-} from "./schema"
-import { type AnyTool, type Tools } from "./tool"
-
-export interface ToolSettlement {
-  readonly result: ToolResultValueType
-  readonly output?: ToolOutputType
-}
-
-export interface DispatchResult extends ToolSettlement {
-  readonly events: ReadonlyArray<LLMEvent>
-}
-
-/** Execute one canonical tool call without owning provider IO or continuation. */
-export const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<DispatchResult> => {
-  const tool = tools[call.name]
-  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${call.name}` }))
-  if (!tool.execute)
-    return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${call.name}` }))
-
-  return decodeAndExecute(tool, call).pipe(
-    Effect.map((value) => result(call, value)),
-    Effect.catchTag("Tool.Error", (failure) =>
-      Effect.succeed(result(call, { type: "error", value: failure.message }, failure.error)),
-    ),
-  )
-}
-
-const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<ToolSettlement, ToolFailure> =>
-  tool._decode(call.input).pipe(
-    Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })),
-    Effect.flatMap((decoded) =>
-      tool.execute!(decoded, { id: call.id, name: call.name }).pipe(
-        Effect.flatMap((value) =>
-          tool._encode(value).pipe(
-            Effect.mapError(
-              (error) =>
-                new ToolFailure({
-                  message: `Tool returned an invalid value for its success schema: ${error.message}`,
-                }),
-            ),
-          ),
-        ),
-        Effect.map((encoded) => {
-          if (tool._legacyResult && ToolResultValue.is(encoded))
-            return { result: encoded, output: ToolOutput.fromResultValue(encoded) }
-          const output = tool._project(decoded, call.id, encoded)
-          const result = ToolOutput.toResultValue(output)
-          return result.type === "error" ? { result } : { result, output }
-        }),
-      ),
-    ),
-  )
-
-const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement, error?: unknown): DispatchResult => {
-  const settlement = ToolResultValue.is(value) ? { result: value } : value
-  return {
-    result: settlement.result,
-    output: settlement.output,
-    events:
-      settlement.result.type === "error"
-        ? [
-            LLMEvent.toolError({
-              id: call.id,
-              name: call.name,
-              message: String(settlement.result.value),
-              error,
-              providerMetadata: call.providerMetadata,
-            }),
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              providerMetadata: call.providerMetadata,
-            }),
-          ]
-        : [
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              output: settlement.output,
-              providerMetadata: call.providerMetadata,
-            }),
-          ],
-  }
-}
-
-export const ToolRuntime = { dispatch } as const

packages/ai/src/tool.ts

@@ -1,253 +0,0 @@
-import { Effect, JsonSchema, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
-import type {
-  ToolCallPart,
-  ToolDefinition as ToolDefinitionClass,
-  ToolOutput as ToolOutputType,
-} from "./schema"
-import { ToolDefinition, ToolFailure, ToolOutput } from "./schema"
-
-/**
- * Schema constraint for tool parameters / success values: no decoding or
- * encoding services are allowed. Tools should be self-contained — anything
- * beyond pure data conversion belongs in the handler closure.
- */
-export type ToolSchema<T> = Schema.Codec<T, any, never, never>
-export interface ToolExecuteContext {
-  readonly id: ToolCallPart["id"]
-  readonly name: ToolCallPart["name"]
-}
-
-export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (
-  params: Schema.Schema.Type<Parameters>,
-  context?: ToolExecuteContext,
-) => Effect.Effect<Schema.Schema.Type<Success>, ToolFailure>
-
-export interface ToolModelOutputInput<Parameters, Output> {
-  readonly id: ToolCallPart["id"]
-  readonly parameters: Parameters
-  readonly output: Output
-}
-
-export type ToolToModelOutput<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (
-  input: ToolModelOutputInput<Schema.Schema.Type<Parameters>, Success["Encoded"]>,
-) => ReadonlyArray<Tool.Content>
-
-/**
- * A type-safe LLM tool. Each tool bundles its own description, parameter
- * Schema and success Schema. The execute handler is optional: omit it when you
- * only want to expose a tool schema to the model and handle tool calls outside
- * this package.
- *
- * Errors must be expressed as `ToolFailure`. Unmapped errors and defects fail
- * the stream.
- *
- * Internally each tool also carries memoized codecs and a precomputed
- * `ToolDefinition` so callers do not rebuild them per invocation.
- */
-export interface Definition<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> {
-  readonly description: string
-  readonly parameters: Parameters
-  readonly success: Success
-  readonly execute?: ToolExecute<Parameters, Success>
-  readonly toModelOutput?: ToolToModelOutput<Parameters, Success>
-  readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown
-  /** @internal */
-  readonly _decode: (input: unknown) => Effect.Effect<Schema.Schema.Type<Parameters>, Schema.SchemaError>
-  /** @internal */
-  readonly _encode: (value: Schema.Schema.Type<Success>) => Effect.Effect<unknown, Schema.SchemaError>
-  /** @internal */
-  readonly _project: (
-    parameters: Schema.Schema.Type<Parameters>,
-    id: ToolCallPart["id"],
-    output: unknown,
-  ) => ToolOutputType
-  /** @internal */
-  readonly _legacyResult: boolean
-  /** @internal */
-  readonly _definition: ToolDefinitionClass
-}
-
-export type AnyTool = Definition<any, any>
-
-export type ExecutableTool<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = Definition<
-  Parameters,
-  Success
-> & {
-  readonly execute: ToolExecute<Parameters, Success>
-}
-
-export type AnyExecutableTool = ExecutableTool<any, any>
-
-export type ExecutableTools = Record<string, AnyExecutableTool>
-
-type TypedToolConfig = {
-  readonly description: string
-  readonly parameters: ToolSchema<any>
-  readonly success: ToolSchema<any>
-  readonly execute?: ToolExecute<ToolSchema<any>, ToolSchema<any>>
-  readonly toModelOutput?: ToolToModelOutput<ToolSchema<any>, ToolSchema<any>>
-  readonly toStructuredOutput?: (output: unknown) => unknown
-}
-
-type DynamicToolConfig = {
-  readonly description: string
-  readonly jsonSchema: JsonSchema.JsonSchema
-  readonly outputSchema?: JsonSchema.JsonSchema
-  readonly execute?: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
-  readonly toModelOutput?: (input: ToolModelOutputInput<unknown, unknown>) => ReadonlyArray<Tool.Content>
-  readonly toStructuredOutput?: (output: unknown) => unknown
-}
-
-/**
- * Constructs a tool. Two input modes:
- *
- * 1. **Typed** — pass Effect `parameters` and `success` Schemas; inputs and
- *    outputs are statically typed and decoded/encoded automatically.
- *
- *    ```ts
- *    Tool.make({
- *      description: "Get current weather",
- *      parameters: Schema.Struct({ city: Schema.String }),
- *      success: Schema.Struct({ temperature: Schema.Number }),
- *      execute: ({ city }) => Effect.succeed({ temperature: 22 }),
- *    })
- *    ```
- *
- * 2. **Dynamic** — pass raw JSON Schema as `jsonSchema`. Use this when the
- *    schema comes from an external source (MCP server, plugin manifest,
- *    dynamic config) and is not known at compile time. Inputs are typed as
- *    `unknown`; the handler is responsible for any validation it needs.
- *
- *    ```ts
- *    Tool.make({
- *      description: "Look something up",
- *      jsonSchema: { type: "object", properties: { ... } },
- *      execute: (params) => Effect.succeed(...),
- *    })
- *    ```
- *
- * In both modes the produced tool flows through `toDefinitions(...)`
- * identically.
- */
-export function make<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>>(config: {
-  readonly description: string
-  readonly parameters: Parameters
-  readonly success: Success
-  readonly execute: ToolExecute<Parameters, Success>
-  readonly toModelOutput?: ToolToModelOutput<Parameters, Success>
-  readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown
-}): ExecutableTool<Parameters, Success>
-export function make<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>>(config: {
-  readonly description: string
-  readonly parameters: Parameters
-  readonly success: Success
-  readonly execute?: undefined
-  readonly toModelOutput?: ToolToModelOutput<Parameters, Success>
-  readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown
-}): Definition<Parameters, Success>
-export function make(config: {
-  readonly description: string
-  readonly jsonSchema: JsonSchema.JsonSchema
-  readonly outputSchema?: JsonSchema.JsonSchema
-  readonly execute: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
-  readonly toModelOutput?: (input: ToolModelOutputInput<unknown, unknown>) => ReadonlyArray<Tool.Content>
-  readonly toStructuredOutput?: (output: unknown) => unknown
-}): AnyExecutableTool
-export function make(config: {
-  readonly description: string
-  readonly jsonSchema: JsonSchema.JsonSchema
-  readonly outputSchema?: JsonSchema.JsonSchema
-  readonly execute?: undefined
-  readonly toModelOutput?: (input: ToolModelOutputInput<unknown, unknown>) => ReadonlyArray<Tool.Content>
-  readonly toStructuredOutput?: (output: unknown) => unknown
-}): AnyTool
-export function make(config: TypedToolConfig | DynamicToolConfig): AnyTool {
-  if ("jsonSchema" in config) {
-    return {
-      description: config.description,
-      parameters: Schema.Unknown as ToolSchema<unknown>,
-      success: Schema.Unknown as ToolSchema<unknown>,
-      execute: config.execute,
-      toModelOutput: config.toModelOutput,
-      toStructuredOutput: config.toStructuredOutput,
-      _decode: Effect.succeed,
-      _encode: Effect.succeed,
-      _project: (parameters, id, output) =>
-        project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
-      _legacyResult: config.toModelOutput === undefined && config.toStructuredOutput === undefined,
-      _definition: new ToolDefinition({
-        name: "",
-        description: config.description,
-        inputSchema: config.jsonSchema,
-        outputSchema: config.outputSchema,
-      }),
-    }
-  }
-  return {
-    description: config.description,
-    parameters: config.parameters,
-    success: config.success,
-    execute: config.execute,
-    toModelOutput: config.toModelOutput,
-    toStructuredOutput: config.toStructuredOutput,
-    _decode: Schema.decodeUnknownEffect(config.parameters),
-    _encode: Schema.encodeEffect(config.success),
-    _project: (parameters, id, output) =>
-      project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
-    _legacyResult: false,
-    _definition: new ToolDefinition({
-      name: "",
-      description: config.description,
-      inputSchema: toJsonSchema(config.parameters),
-      outputSchema: toJsonSchema(config.success),
-    }),
-  }
-}
-
-/**
- * A record of named tools. The record key becomes the tool name on the wire.
- */
-export type Tools = Record<string, AnyTool>
-
-/**
- * Convert a tools record into the `ToolDefinition[]` shape that
- * `LLMRequest.tools` expects.
- *
- * Tool names come from the record keys, so the per-tool cached
- * `_definition` is rebuilt with the correct name here. The JSON Schema body
- * is reused.
- */
-export const toDefinitions = (tools: Tools): ReadonlyArray<ToolDefinitionClass> =>
-  Object.entries(tools).map(
-    ([name, item]) =>
-      new ToolDefinition({
-        name,
-        description: item._definition.description,
-        inputSchema: item._definition.inputSchema,
-        outputSchema: item._definition.outputSchema,
-      }),
-  )
-
-const toJsonSchema = (schema: Schema.Top): JsonSchema.JsonSchema => {
-  const document = Schema.toJsonSchemaDocument(schema)
-  if (Object.keys(document.definitions).length === 0) return document.schema
-  return { ...document.schema, $defs: document.definitions }
-}
-
-const project = (
-  toModelOutput: ((input: ToolModelOutputInput<any, any>) => ReadonlyArray<Tool.Content>) | undefined,
-  toStructuredOutput: ((output: unknown) => unknown) | undefined,
-  parameters: unknown,
-  id: ToolCallPart["id"],
-  output: unknown,
-): ToolOutputType =>
-  ToolOutput.make(
-    toStructuredOutput?.(output) ?? output,
-    toModelOutput?.({ id, parameters, output }) ??
-      (typeof output === "string" ? [{ type: "text", text: output }] : []),
-  )
-
-export { ToolFailure }
-
-export * as Tool from "./tool"

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

@@ -1,276 +0,0 @@
-import { Config } from "effect"
-import { Auth } from "../src/route"
-import type { LanguageModelFactory } from "../src/route/auth-options"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import * as AmazonBedrock from "../src/providers/amazon-bedrock"
-import * as Anthropic from "../src/providers/anthropic"
-import * as AnthropicCompatible from "../src/providers/anthropic-compatible"
-import * as Azure from "../src/providers/azure"
-import * as Cloudflare from "../src/providers/cloudflare"
-import * as GitHubCopilot from "../src/providers/github-copilot"
-import * as Google from "../src/providers/google"
-import * as GoogleVertex from "../src/providers/google-vertex"
-import * as GoogleVertexChat from "../src/providers/google-vertex-chat"
-import * as GoogleVertexMessages from "../src/providers/google-vertex-messages"
-import * as GoogleVertexResponses from "../src/providers/google-vertex-responses"
-import * as OpenAI from "../src/providers/openai"
-import * as OpenAICompatible from "../src/providers/openai-compatible"
-import * as OpenRouter from "../src/providers/openrouter"
-import * as XAI from "../src/providers/xai"
-
-type BaseOptions = {
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-}
-
-type LanguageModel = {
-  readonly id: string
-}
-
-declare const auth: Auth.Definition
-declare const optionalAuthModel: LanguageModelFactory<BaseOptions, "optional", LanguageModel>
-declare const requiredAuthModel: LanguageModelFactory<BaseOptions, "required", LanguageModel>
-const configApiKey = Config.redacted("OPENAI_API_KEY")
-
-OpenAIChat.route.model({ id: "gpt-4.1-mini" })
-
-// @ts-expect-error route model selection does not configure endpoints.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", baseURL: "https://gateway.example.com/v1" })
-
-// @ts-expect-error route model selection does not configure query params.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", queryParams: { debug: "1" } })
-
-// @ts-expect-error route model selection does not configure auth.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", auth })
-
-// @ts-expect-error route model selection does not configure api keys.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", apiKey: "sk-test" })
-
-optionalAuthModel("gpt-4.1-mini")
-optionalAuthModel("gpt-4.1-mini", {})
-optionalAuthModel("gpt-4.1-mini", { apiKey: "sk-test" })
-optionalAuthModel("gpt-4.1-mini", { apiKey: configApiKey })
-optionalAuthModel("gpt-4.1-mini", { auth })
-optionalAuthModel("gpt-4.1-mini", { auth, baseURL: "https://gateway.example.com/v1" })
-optionalAuthModel("gpt-4.1-mini", { apiKey: "sk-test", headers: { "x-source": "test" } })
-
-// @ts-expect-error auth is an override, so apiKey cannot be supplied with it.
-optionalAuthModel("gpt-4.1-mini", { apiKey: "sk-test", auth })
-
-requiredAuthModel("custom-model", { apiKey: "key" })
-requiredAuthModel("custom-model", { apiKey: configApiKey })
-requiredAuthModel("custom-model", { auth })
-requiredAuthModel("custom-model", { auth, headers: { "x-tenant-id": "tenant" } })
-
-// @ts-expect-error providers without config fallback need apiKey or auth.
-requiredAuthModel("custom-model")
-
-// @ts-expect-error providers without config fallback need apiKey or auth.
-requiredAuthModel("custom-model", {})
-
-// @ts-expect-error auth is an override, so apiKey cannot be supplied with it.
-requiredAuthModel("custom-model", { apiKey: "key", auth })
-
-OpenAI.responses("gpt-4.1-mini")
-OpenAI.configure({}).responses("gpt-4.1-mini")
-OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini")
-OpenAI.configure({ apiKey: configApiKey }).responses("gpt-4.1-mini")
-OpenAI.configure({ auth: Auth.bearer("oauth-token") }).responses("gpt-4.1-mini")
-OpenAI.configure({
-  auth: Auth.headers({ authorization: "Bearer gateway" }),
-  baseURL: "https://gateway.example.com/v1",
-}).responses("gpt-4.1-mini")
-OpenAI.configure({
-  generation: { maxTokens: 100 },
-  providerOptions: { openai: { store: false } },
-}).responses("gpt-4.1-mini")
-
-// @ts-expect-error OpenAI model selectors only accept model ids.
-OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini", {})
-
-// @ts-expect-error apiKey only accepts string, Redacted<string>, or Config<string | Redacted<string>>.
-OpenAI.configure({ apiKey: 123 })
-
-// @ts-expect-error provider helpers reject unknown top-level options.
-OpenAI.configure({ bogus: true })
-
-// @ts-expect-error common generation options remain typed.
-OpenAI.configure({ generation: { maxTokens: "many" } })
-
-// @ts-expect-error provider-native options remain typed.
-OpenAI.configure({ providerOptions: { openai: { store: "false" } } })
-
-// @ts-expect-error auth is an override, so OpenAI rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: Auth.bearer("oauth-token") })
-
-OpenAI.chat("gpt-4.1-mini")
-OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini")
-OpenAI.configure({ apiKey: configApiKey }).chat("gpt-4.1-mini")
-OpenAI.configure({ auth: Auth.bearer("oauth-token") }).chat("gpt-4.1-mini")
-
-// @ts-expect-error OpenAI chat selectors only accept model ids.
-OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini", {})
-
-// @ts-expect-error auth is an override, so OpenAI Chat rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: Auth.bearer("oauth-token") })
-
-// @ts-expect-error Azure requires at least one of `resourceName` or `baseURL`.
-Azure.configure()
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment")
-Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).responses("deployment")
-Azure.configure({ auth: Auth.header("api-key", "azure-key"), resourceName: "resource" }).responses("deployment")
-
-// @ts-expect-error Azure model selectors only accept deployment ids.
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment", {})
-
-// @ts-expect-error auth is an override, so Azure rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: Auth.header("api-key", "override") })
-
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment")
-Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).chat("deployment")
-Azure.configure({ auth: Auth.header("api-key", "azure-key"), resourceName: "resource" }).chat("deployment")
-
-// @ts-expect-error Azure chat model selectors only accept deployment ids.
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment", {})
-
-// @ts-expect-error auth is an override, so Azure Chat rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: Auth.header("api-key", "override") })
-
-Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku")
-Anthropic.configure({
-  apiKey: "anthropic-key",
-  providerOptions: {
-    anthropic: { thinking: { type: "enabled", budgetTokens: 1_024 }, effort: "high" },
-  },
-}).model("claude-haiku")
-// @ts-expect-error Anthropic model selectors only accept model ids.
-Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku", {})
-// @ts-expect-error Anthropic package settings accept only one auth source.
-Anthropic.model("claude-sonnet-4-6", { apiKey: "anthropic-key", authToken: "anthropic-token" })
-// @ts-expect-error Enabled Anthropic thinking requires a token budget.
-Anthropic.configure({ providerOptions: { anthropic: { thinking: { type: "enabled" } } } })
-// @ts-expect-error Anthropic thinking budgets must be numbers.
-Anthropic.configure({ providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: "large" } } } })
-
-AnthropicCompatible.configure({
-  apiKey: "messages-key",
-  baseURL: "https://messages.example.com/v1",
-  provider: "example",
-  providerOptions: { anthropic: { thinking: { type: "disabled" } } },
-}).model("compatible-model")
-// @ts-expect-error Anthropic-compatible providers require a base URL.
-AnthropicCompatible.configure({ apiKey: "messages-key" })
-// @ts-expect-error Anthropic-compatible model selectors only accept model ids.
-AnthropicCompatible.configure({ baseURL: "https://messages.example.com/v1" }).model("compatible-model", {})
-// @ts-expect-error Anthropic-compatible package settings accept only one auth source.
-AnthropicCompatible.model("compatible-model", {
-  apiKey: "messages-key",
-  authToken: "messages-token",
-  baseURL: "https://messages.example.com/v1",
-})
-
-Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash")
-Google.configure({
-  apiKey: "google-key",
-  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 0, includeThoughts: false } } },
-}).model("gemini-2.5-flash")
-// @ts-expect-error Google model selectors only accept model ids.
-Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash", {})
-// @ts-expect-error Gemini thinking budgets must be numbers.
-Google.configure({ providerOptions: { gemini: { thinkingConfig: { thinkingBudget: "large" } } } })
-
-GoogleVertex.configure({
-  apiKey: "vertex-key",
-  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 1_024 } } },
-}).model("gemini-3.5-flash")
-GoogleVertex.configure({ accessToken: "vertex-token", project: "project" }).model("gemini-3.5-flash")
-GoogleVertex.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("gemini-3.5-flash")
-// @ts-expect-error Vertex Gemini model selectors only accept model ids.
-GoogleVertex.configure({ apiKey: "vertex-key" }).model("gemini-3.5-flash", {})
-// @ts-expect-error Vertex Gemini config accepts only one auth source.
-GoogleVertex.configure({ accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
-// @ts-expect-error Vertex Gemini package settings accept only one auth source.
-GoogleVertex.model("gemini-3.5-flash", { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
-
-GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model("deepseek-ai/deepseek-v3.2-maas")
-GoogleVertexChat.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
-  "deepseek-ai/deepseek-v3.2-maas",
-)
-// @ts-expect-error Vertex Chat package settings do not accept API keys.
-GoogleVertexChat.model("deepseek-ai/deepseek-v3.2-maas", { apiKey: "vertex-key", project: "project" })
-GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model(
-  "deepseek-ai/deepseek-v3.2-maas",
-  // @ts-expect-error Vertex Chat model selectors only accept model ids.
-  {},
-)
-GoogleVertexChat.configure({
-  accessToken: "vertex-token",
-  // @ts-expect-error Vertex Chat config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
-  project: "project",
-})
-
-GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project" }).model("xai/grok-4.20-reasoning")
-GoogleVertexResponses.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
-  "xai/grok-4.20-reasoning",
-)
-// @ts-expect-error Vertex Responses package settings do not accept API keys.
-GoogleVertexResponses.model("xai/grok-4.20-reasoning", { apiKey: "vertex-key", project: "project" })
-GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project" }).model(
-  "xai/grok-4.20-reasoning",
-  // @ts-expect-error Vertex Responses model selectors only accept model ids.
-  {},
-)
-GoogleVertexResponses.configure({
-  accessToken: "vertex-token",
-  // @ts-expect-error Vertex Responses config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
-  project: "project",
-})
-
-GoogleVertexMessages.configure({
-  accessToken: "vertex-token",
-  project: "project",
-  providerOptions: { anthropic: { thinking: { type: "adaptive", display: "omitted" }, effort: "low" } },
-}).model("claude-sonnet-4-6")
-// @ts-expect-error Vertex Messages package settings do not accept API keys.
-GoogleVertexMessages.model("claude-sonnet-4-6", { apiKey: "vertex-key", project: "project" })
-GoogleVertexMessages.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("claude-sonnet-4-6")
-GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project" }).model(
-  "claude-sonnet-4-6",
-  // @ts-expect-error Vertex Messages model selectors only accept model ids.
-  {},
-)
-GoogleVertexMessages.configure({
-  accessToken: "vertex-token",
-  // @ts-expect-error Vertex Messages config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
-  project: "project",
-})
-
-AmazonBedrock.configure({ apiKey: "bedrock-key" }).model("anthropic.claude")
-// @ts-expect-error Bedrock model selectors only accept model ids.
-AmazonBedrock.configure({ apiKey: "bedrock-key" }).model("anthropic.claude", {})
-
-OpenRouter.configure({ apiKey: "openrouter-key" }).model("openai/gpt-4o-mini")
-// @ts-expect-error OpenRouter model selectors only accept model ids.
-OpenRouter.configure({ apiKey: "openrouter-key" }).model("openai/gpt-4o-mini", {})
-
-XAI.configure({ apiKey: "xai-key" }).responses("grok-4")
-XAI.configure({ apiKey: "xai-key" }).chat("grok-4")
-// @ts-expect-error xAI Responses selectors only accept model ids.
-XAI.configure({ apiKey: "xai-key" }).responses("grok-4", {})
-// @ts-expect-error xAI Chat selectors only accept model ids.
-XAI.configure({ apiKey: "xai-key" }).chat("grok-4", {})
-
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
-// @ts-expect-error OpenAI-compatible family selectors only accept model ids.
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
-
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
-// @ts-expect-error Cloudflare Workers AI model selectors only accept model ids.
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})
-
-GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1")
-// @ts-expect-error GitHub Copilot model selectors only accept model ids.
-GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1", {})

packages/ai/test/auth.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect } from "bun:test"
-import { ConfigProvider, Effect } from "effect"
-import { Headers } from "effect/unstable/http"
-import { LLM } from "../src"
-import { Auth } from "../src/route/auth"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import { LanguageModel } from "../src/schema"
-import { it } from "./lib/effect"
-
-const request = LLM.request({
-  id: "req_auth",
-  model: LanguageModel.make({ id: "fake-model", provider: "fake", route: OpenAIChat.route }),
-  prompt: "hello",
-})
-
-const input = {
-  request,
-  method: "POST" as const,
-  url: "https://example.test/v1/chat",
-  body: "{}",
-  headers: Headers.fromInput({ "x-existing": "yes" }),
-}
-
-const withEnv = (env: Record<string, string>) => Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env })))
-
-describe("Auth", () => {
-  it.effect("renders a config credential as bearer auth", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.config("OPENAI_API_KEY")
-        .bearer()
-        .apply(input)
-        .pipe(withEnv({ OPENAI_API_KEY: "sk-test" }))
-
-      expect(headers.authorization).toBe("Bearer sk-test")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("falls back between credential sources before rendering", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.config("PRIMARY_KEY")
-        .orElse(Auth.value("fallback-key"))
-        .pipe(Auth.header("x-api-key"))
-        .apply(input)
-        .pipe(withEnv({}))
-
-      expect(headers["x-api-key"]).toBe("fallback-key")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("composes header auth in sequence", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.headers({ "x-tenant-id": "tenant-1" })
-        .andThen(Auth.bearer("gateway-token"))
-        .apply(input)
-
-      expect(headers["x-tenant-id"]).toBe("tenant-1")
-      expect(headers.authorization).toBe("Bearer gateway-token")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("renders a direct secret as a custom header", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.header("api-key", "direct-key").apply(input)
-
-      expect(headers["api-key"]).toBe("direct-key")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("renders bearer auth into a custom header", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.bearerHeader("cf-aig-authorization", "gateway-token").apply(input)
-
-      expect(headers["cf-aig-authorization"]).toBe("Bearer gateway-token")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("falls back between full auth values", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.config("OPENAI_API_KEY")
-        .bearer()
-        .orElse(Auth.headers({ authorization: "Bearer supplied" }))
-        .apply(input)
-        .pipe(withEnv({}))
-
-      expect(headers.authorization).toBe("Bearer supplied")
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-
-  it.effect("can intentionally leave auth untouched", () =>
-    Effect.gen(function* () {
-      const headers = yield* Auth.none.apply(input)
-
-      expect(headers.authorization).toBeUndefined()
-      expect(headers["x-existing"]).toBe("yes")
-    }),
-  )
-})

packages/ai/test/cache-policy.test.ts

@@ -1,323 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CacheHint, LLM, Message } from "../src"
-import { Auth } from "../src/route"
-import { compileRequest } from "../src/route/client"
-import { AmazonBedrock } from "../src/providers"
-import * as AnthropicMessages from "../src/protocols/anthropic-messages"
-import * as Gemini from "../src/protocols/gemini"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import { applyCachePolicy } from "../src/cache-policy"
-import { it } from "./lib/effect"
-
-const anthropicModel = AnthropicMessages.route
-  .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
-  .model({ id: "claude-sonnet-4-5" })
-
-const bedrockModel = AmazonBedrock.configure({
-  credentials: { region: "us-east-1", accessKeyId: "fixture", secretAccessKey: "fixture" },
-}).model("anthropic.claude-3-5-sonnet-20241022-v2:0")
-
-const openaiModel = OpenAIChat.route
-  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-  .model({ id: "gpt-4o-mini" })
-
-const geminiModel = Gemini.route
-  .with({
-    endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
-    auth: Auth.header("x-goog-api-key", "test"),
-  })
-  .model({ id: "gemini-2.5-flash" })
-
-describe("applyCachePolicy", () => {
-  it.effect("undefined cache resolves to 'auto' (the recommended default)", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: "You are concise.",
-          prompt: "hi",
-        }),
-      )
-
-      // A single system block is both the first and last boundary, so the auto
-      // policy deduplicates it and still marks the conversation tail.
-      expect(prepared.body).toMatchObject({
-        system: [{ type: "text", text: "You are concise.", cache_control: { type: "ephemeral" } }],
-        messages: [{ role: "user", content: [{ type: "text", text: "hi", cache_control: { type: "ephemeral" } }] }],
-      })
-    }),
-  )
-
-  it.effect("'auto' marks the last tool, first and last system parts, and final message boundary on Anthropic", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: [
-            { type: "text", text: "Base agent" },
-            { type: "text", text: "Project instructions" },
-          ],
-          tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-          messages: [
-            Message.user("first user"),
-            Message.assistant("assistant reply"),
-            Message.user("latest user message"),
-          ],
-          cache: "auto",
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        tools: [{ name: "t1", cache_control: { type: "ephemeral" } }],
-        system: [
-          { type: "text", text: "Base agent", cache_control: { type: "ephemeral" } },
-          { type: "text", text: "Project instructions", cache_control: { type: "ephemeral" } },
-        ],
-        messages: [
-          { role: "user", content: [{ type: "text", text: "first user" }] },
-          { role: "assistant", content: [{ type: "text", text: "assistant reply" }] },
-          {
-            role: "user",
-            content: [{ type: "text", text: "latest user message", cache_control: { type: "ephemeral" } }],
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("'auto' is a no-op on OpenAI (implicit caching protocol)", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: openaiModel,
-          system: "Sys",
-          prompt: "hi",
-          cache: "auto",
-        }),
-      )
-
-      const body = prepared.body as { messages: Array<{ content: unknown }> }
-      // OpenAI doesn't accept cache_control on messages — policy must skip.
-      const flat = JSON.stringify(body)
-      expect(flat).not.toContain("cache_control")
-      expect(flat).not.toContain("cachePoint")
-    }),
-  )
-
-  it.effect("'auto' is a no-op on Gemini (out-of-band caching protocol)", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: geminiModel,
-          system: "Sys",
-          prompt: "hi",
-          cache: "auto",
-        }),
-      )
-
-      const flat = JSON.stringify(prepared.body)
-      expect(flat).not.toContain("cache_control")
-      expect(flat).not.toContain("cachePoint")
-    }),
-  )
-
-  it.effect("'auto' on Bedrock emits cachePoint markers in the right places", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: bedrockModel,
-          system: [
-            { type: "text", text: "Base agent" },
-            { type: "text", text: "Project instructions" },
-          ],
-          tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-          messages: [Message.user("first user"), Message.assistant("reply"), Message.user("latest user")],
-          cache: "auto",
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        toolConfig: {
-          tools: [{ toolSpec: { name: "t1" } }, { cachePoint: { type: "default" } }],
-        },
-        system: [
-          { text: "Base agent" },
-          { cachePoint: { type: "default" } },
-          { text: "Project instructions" },
-          { cachePoint: { type: "default" } },
-        ],
-        messages: [
-          { role: "user", content: [{ text: "first user" }] },
-          { role: "assistant", content: [{ text: "reply" }] },
-          { role: "user", content: [{ text: "latest user" }, { cachePoint: { type: "default" } }] },
-        ],
-      })
-    }),
-  )
-
-  it.effect("'none' disables auto placement even when manual hints exist", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: "Sys",
-          tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-          prompt: "hi",
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        tools: [{ name: "t1", cache_control: undefined }],
-        system: [{ type: "text", text: "Sys", cache_control: undefined }],
-      })
-    }),
-  )
-
-  it.effect("granular object form: tools-only marks just tools", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: "Sys",
-          tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-          prompt: "hi",
-          cache: { tools: true },
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        tools: [{ name: "t1", cache_control: { type: "ephemeral" } }],
-        system: [{ type: "text", text: "Sys", cache_control: undefined }],
-      })
-    }),
-  )
-
-  it.effect("auto policy preserves manual CacheHints on other parts", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: [
-            { type: "text", text: "first system", cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3600 }) },
-            { type: "text", text: "last system" },
-          ],
-          prompt: "hi",
-          cache: "auto",
-        }),
-      )
-
-      const body = prepared.body as {
-        system: Array<{ text: string; cache_control?: unknown }>
-        messages: Array<{ content: Array<{ cache_control?: unknown }> }>
-      }
-      expect(body.system[0]?.cache_control).toEqual({ type: "ephemeral", ttl: "1h" })
-      expect(body.system[1]?.cache_control).toEqual({ type: "ephemeral" })
-      expect(body.messages[0]?.content[0]?.cache_control).toEqual({ type: "ephemeral" })
-    }),
-  )
-
-  it.effect("auto policy stays within the four-breakpoint cap when preserving manual hints", () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model: anthropicModel,
-        system: [
-          { type: "text", text: "Base agent" },
-          {
-            type: "text",
-            text: "Manual context",
-            cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3600 }),
-          },
-          { type: "text", text: "Project instructions" },
-        ],
-        tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-        prompt: "hi",
-        cache: "auto",
-      })
-      const applied = applyCachePolicy(request)
-      expect(applied.tools[0]?.cache).toBeDefined()
-      expect(applied.system.map((part) => part.cache !== undefined)).toEqual([true, true, true])
-      const tail = applied.messages[0]!.content[0]!
-      expect("cache" in tail ? tail.cache : undefined).toBeUndefined()
-      expect(applyCachePolicy(applied)).toBe(applied)
-
-      const prepared = yield* compileRequest(request)
-
-      const body = prepared.body as {
-        tools: Array<{ cache_control?: unknown }>
-        system: Array<{ cache_control?: unknown }>
-        messages: Array<{ content: Array<{ cache_control?: unknown }> }>
-      }
-      const marked = [
-        ...body.tools.map((tool) => tool.cache_control),
-        ...body.system.map((part) => part.cache_control),
-        ...body.messages.flatMap((message) => message.content.map((part) => part.cache_control)),
-      ].filter((cache) => cache !== undefined)
-      expect(marked).toHaveLength(4)
-      expect(body.system[1]?.cache_control).toEqual({ type: "ephemeral", ttl: "1h" })
-      expect(body.messages[0]?.content[0]?.cache_control).toBeUndefined()
-    }),
-  )
-
-  it.effect("ttlSeconds in the policy flows through to wire markers", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          system: "Sys",
-          prompt: "hi",
-          cache: { system: true, ttlSeconds: 3600 },
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        system: [{ type: "text", text: "Sys", cache_control: { type: "ephemeral", ttl: "1h" } }],
-      })
-    }),
-  )
-
-  it.effect("messages: { tail: 2 } marks the last 2 message boundaries", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2"), Message.assistant("a2")],
-          cache: { messages: { tail: 2 } },
-        }),
-      )
-
-      const body = prepared.body as { messages: Array<{ content: Array<{ cache_control?: unknown }> }> }
-      expect(body.messages[0]?.content[0]?.cache_control).toBeUndefined()
-      expect(body.messages[1]?.content[0]?.cache_control).toBeUndefined()
-      expect(body.messages[2]?.content[0]?.cache_control).toEqual({ type: "ephemeral" })
-      expect(body.messages[3]?.content[0]?.cache_control).toEqual({ type: "ephemeral" })
-    }),
-  )
-
-  it.effect("'latest-assistant' marks the last assistant message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2")],
-          cache: { messages: "latest-assistant" },
-        }),
-      )
-
-      const body = prepared.body as { messages: Array<{ content: Array<{ cache_control?: unknown }> }> }
-      expect(body.messages[0]?.content[0]?.cache_control).toBeUndefined()
-      expect(body.messages[1]?.content[0]?.cache_control).toEqual({ type: "ephemeral" })
-      expect(body.messages[2]?.content[0]?.cache_control).toBeUndefined()
-    }),
-  )
-
-  test("returns the same request reference when policy is a no-op (pure function)", () => {
-    const request = LLM.request({
-      model: anthropicModel,
-      prompt: "hi",
-      cache: "none",
-    })
-    expect(applyCachePolicy(request)).toBe(request)
-  })
-})

packages/ai/test/compile.test.ts

@@ -1,296 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect, Ref, Schema } from "effect"
-import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLM, mergeProviderOptions } from "../src"
-import { AnthropicMessages, OpenAIChat } from "../src/protocols"
-import { Auth, LLMClient } from "../src/route"
-import { compileRequest } from "../src/route/client"
-import { it } from "./lib/effect"
-import { dynamicResponse } from "./lib/http"
-import { deltaChunk } from "./lib/openai-chunks"
-import { sseEvents } from "./lib/sse"
-
-const TargetJson = Schema.fromJsonString(Schema.Unknown)
-const decodeJson = Schema.decodeUnknownSync(TargetJson)
-
-describe("request option precedence", () => {
-  test("deep-merges provider option records and replaces arrays, primitives, and null", () => {
-    const merged = mergeProviderOptions(
-      {
-        openai: {
-          include: ["route"],
-          metadata: { route: true, shared: "route" },
-          nullable: "route",
-          primitive: "route",
-        },
-      },
-      {
-        openai: {
-          include: ["model"],
-          metadata: { model: true, shared: "model" },
-          nullable: null,
-          primitive: "model",
-        },
-      },
-      { openai: { metadata: { request: true }, primitive: false } },
-    )
-
-    expect(merged).toEqual({
-      openai: {
-        include: ["model"],
-        metadata: { route: true, model: true, request: true, shared: "model" },
-        nullable: null,
-        primitive: false,
-      },
-    })
-  })
-
-  it.effect("compiles bodies with route defaults, model defaults, and call options in order", () =>
-    Effect.gen(function* () {
-      const route = OpenAIChat.route.with({
-        endpoint: { baseURL: "https://api.openai.test/v1/" },
-        auth: Auth.bearer("test"),
-        generation: { maxTokens: 10, temperature: 1, stop: ["route"] },
-        providerOptions: { openai: { store: false, reasoningEffort: "low" } },
-      })
-      const model = route.model({
-        id: "gpt-4o-mini",
-        defaults: {
-          generation: { maxTokens: 20, temperature: 0.5, frequencyPenalty: 0.25, stop: ["model"] },
-          providerOptions: { openai: { reasoningEffort: "medium" } },
-        },
-      })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          prompt: "Say hello.",
-          generation: { maxTokens: 30, topP: 0.9, stop: ["request"] },
-          providerOptions: { openai: { store: true } },
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        model: "gpt-4o-mini",
-        stream: true,
-        max_tokens: 30,
-        temperature: 0.5,
-        top_p: 0.9,
-        frequency_penalty: 0.25,
-        store: true,
-        reasoning_effort: "medium",
-      })
-      expect(prepared.body.stop).toEqual(["request"])
-    }),
-  )
-
-  it.effect("applies model HTTP defaults before request HTTP overlays", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({
-            endpoint: { baseURL: "https://api.openai.test/v1/" },
-            auth: Auth.bearer("fresh-key"),
-            http: {
-              body: { metadata: { route: true, shared: "route" }, value: "route" },
-              headers: { "x-route": "route", "x-shared": "route" },
-              query: { route: "1", shared: "route" },
-            },
-          })
-          .model({
-            id: "gpt-4o-mini",
-            defaults: {
-              http: {
-                body: { metadata: { model: true, shared: "model" }, value: "model" },
-                headers: { "x-model": "model", "x-shared": "model" },
-                query: { model: "1", shared: "model" },
-              },
-            },
-          }),
-        prompt: "Say hello.",
-        http: {
-          body: { metadata: { request: true }, value: null },
-          headers: { "x-request": "request" },
-          query: { request: "1" },
-        },
-      }),
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-            expect(web.url).toBe("https://api.openai.test/v1/chat/completions?route=1&shared=model&model=1&request=1")
-            expect(web.headers.get("authorization")).toBe("Bearer fresh-key")
-            expect(web.headers.get("x-route")).toBe("route")
-            expect(web.headers.get("x-model")).toBe("model")
-            expect(web.headers.get("x-request")).toBe("request")
-            expect(web.headers.get("x-shared")).toBe("model")
-            expect(decodeJson(input.text)).toMatchObject({
-              metadata: { route: true, model: true, request: true, shared: "model" },
-              value: null,
-            })
-            return input.respond(sseEvents(deltaChunk({}, "stop")), {
-              headers: { "content-type": "text/event-stream" },
-            })
-          }),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("transforms the final HTTP request after serialization and authentication", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("fresh-key") })
-          .model({ id: "gpt-4o-mini" }),
-        prompt: "Say hello.",
-      }),
-      {
-        http: (request, handler) =>
-          Effect.gen(function* () {
-            return yield* handler(
-              request.pipe(
-                HttpClientRequest.setUrl("https://proxy.test/v1/chat/completions"),
-                HttpClientRequest.setMethod("PUT"),
-                HttpClientRequest.setHeader("x-plugin", "transformed"),
-                HttpClientRequest.bodyText(JSON.stringify({ transformed: true }), "application/custom+json"),
-              ),
-            )
-          }),
-      },
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-            expect(web.url).toBe("https://proxy.test/v1/chat/completions")
-            expect(web.method).toBe("PUT")
-            expect(web.headers.get("x-plugin")).toBe("transformed")
-            expect(web.headers.get("content-type")).toBe("application/custom+json")
-            expect(decodeJson(input.text)).toEqual({ transformed: true })
-            return input.respond(sseEvents(deltaChunk({}, "stop")), {
-              headers: { "content-type": "text/event-stream" },
-            })
-          }),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("transforms the HTTP response before protocol decoding", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const response = yield* handler(request)
-              return HttpClientResponse.fromWeb(
-                response.request,
-                new Response((yield* response.text).replace("network", "hooked"), {
-                  status: response.status,
-                  headers: response.headers,
-                }),
-              )
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.succeed(
-              input.respond(sseEvents(deltaChunk({ content: "network" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              }),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("hooked")
-    }),
-  )
-
-  it.effect("can inspect an error response and retry the native request", () =>
-    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("stale") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const response = yield* handler(request)
-              expect(response.status).toBe(401)
-              return yield* handler(HttpClientRequest.setHeader(request, "authorization", "Bearer refreshed"))
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              yield* Ref.update(attempts, (value) => value + 1)
-              if (input.request.headers.authorization !== "Bearer refreshed")
-                return input.respond("unauthorized", { status: 401 })
-              return input.respond(sseEvents(deltaChunk({ content: "retried" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              })
-            }),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("retried")
-      expect(yield* Ref.get(attempts)).toBe(2)
-    }),
-  )
-
-  it.effect("applies raw body overlays after protocol lowering", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-          .model({ id: "gpt-4o-mini" }),
-        prompt: "Say hello.",
-        http: { body: { model: "gpt-5", messages: [], tools: [] } },
-      }),
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            expect(decodeJson(input.text)).toMatchObject({ model: "gpt-5", messages: [], tools: [] })
-            return input.respond(sseEvents(deltaChunk({}, "stop")), {
-              headers: { "content-type": "text/event-stream" },
-            })
-          }),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("uses model output limits after route limits and before call maxTokens", () =>
-    Effect.gen(function* () {
-      const route = AnthropicMessages.route.with({
-        endpoint: { baseURL: "https://api.anthropic.test/v1/" },
-        auth: Auth.header("x-api-key", "test"),
-        limits: { output: 128 },
-      })
-      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
-      const withoutMaxTokens = yield* compileRequest(LLM.request({ model, prompt: "Say hello.", cache: "none" }))
-      const withMaxTokens = yield* compileRequest(
-        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 32 } }),
-      )
-
-      expect(withoutMaxTokens.body.max_tokens).toBe(64)
-      expect(withMaxTokens.body.max_tokens).toBe(32)
-    }),
-  )
-})

packages/ai/test/executor.test.ts

@@ -1,415 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer, Ref } from "effect"
-import { Headers, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLM, AIError } from "../src"
-import { LLMClient, RequestExecutor } from "../src/route"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import { dynamicResponse } from "./lib/http"
-import { deltaChunk } from "./lib/openai-chunks"
-import { sseRaw } from "./lib/sse"
-import { it } from "./lib/effect"
-
-const request = HttpClientRequest.post("https://provider.test/v1/chat?api_key=secret&key=secret&debug=1").pipe(
-  HttpClientRequest.setHeaders(Headers.fromInput({ authorization: "Bearer secret", "x-safe": "visible" })),
-)
-
-const secretRequest = HttpClientRequest.post("https://provider.test/v1/chat?api_key=query-secret-123&debug=1").pipe(
-  HttpClientRequest.setHeaders(Headers.fromInput({ authorization: "Bearer header-secret-456" })),
-)
-
-const responsesLayer = (responses: ReadonlyArray<Response>) =>
-  RequestExecutor.layer.pipe(
-    Layer.provide(
-      Layer.unwrap(
-        Effect.gen(function* () {
-          const cursor = yield* Ref.make(0)
-          return Layer.succeed(
-            HttpClient.HttpClient,
-            HttpClient.make((request) =>
-              Effect.gen(function* () {
-                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
-                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
-              }),
-            ),
-          )
-        }),
-      ),
-    ),
-  )
-
-const countedResponsesLayer = (attempts: Ref.Ref<number>, responses: ReadonlyArray<Response>) =>
-  RequestExecutor.layer.pipe(
-    Layer.provide(
-      Layer.unwrap(
-        Effect.gen(function* () {
-          const cursor = yield* Ref.make(0)
-          return Layer.succeed(
-            HttpClient.HttpClient,
-            HttpClient.make((request) =>
-              Effect.gen(function* () {
-                yield* Ref.update(attempts, (value) => value + 1)
-                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
-                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
-              }),
-            ),
-          )
-        }),
-      ),
-    ),
-  )
-
-const expectAIError = (error: unknown) => {
-  expect(error).toBeInstanceOf(AIError)
-  if (!(error instanceof AIError)) throw new Error("expected AIError")
-  return error
-}
-
-const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
-
-describe("RequestExecutor", () => {
-  it.effect("preserves middleware error messages", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor
-        .execute(request, () => Effect.fail(new Error("plugin rejected request")))
-        .pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason.message).toBe("plugin rejected request")
-    }).pipe(Effect.provide(responsesLayer([]))),
-  )
-
-  it.effect("classifies context overflow responses", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", classification: "context-overflow" })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response('{"error":{"code":"context_length_exceeded","message":"prompt too long"}}', {
-            status: 400,
-          }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("classifies generic HTTP 413 payload errors", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidRequest",
-        classification: "payload-too-large",
-        http: { response: { status: 413 } },
-      })
-    }).pipe(Effect.provide(responsesLayer([new Response("request too large", { status: 413 })]))),
-  )
-
-  it.effect("does not classify ordinary invalid requests as context overflow", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
-    }).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
-  )
-
-  it.effect("classifies provider rate limits hidden behind HTTP 400", () =>
-    Effect.gen(function* () {
-      const classify = (body: string) =>
-        Effect.gen(function* () {
-          const executor = yield* RequestExecutor.Service
-          const error = yield* executor.execute(request).pipe(Effect.flip)
-
-          expectAIError(error)
-          expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
-
-      yield* classify("Request rate increased too quickly")
-      yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
-      yield* classify('{"type":"error","error":{"code":"rate_limit_exceeded"}}')
-    }),
-  )
-
-  it.effect("classifies provider overloads hidden behind HTTP 400", () =>
-    Effect.gen(function* () {
-      const classify = (body: string) =>
-        Effect.gen(function* () {
-          const executor = yield* RequestExecutor.Service
-          const error = yield* executor.execute(request).pipe(Effect.flip)
-
-          expectAIError(error)
-          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
-
-      yield* classify('{"code":"resource_exhausted"}')
-      yield* classify('{"code":"service_unavailable"}')
-    }),
-  )
-
-  it.effect("returns redacted diagnostics for rate limits", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error).toMatchObject({
-        reason: {
-          _tag: "RateLimit",
-          retryAfterMs: 0,
-          rateLimit: { retryAfterMs: 0 },
-          http: {
-            requestId: "req_123",
-            request: {
-              method: "POST",
-              url: "https://provider.test/v1/chat?api_key=%3Credacted%3E&key=%3Credacted%3E&debug=1",
-              headers: { authorization: "<redacted>", "x-safe": "visible" },
-            },
-            response: {
-              status: 429,
-              headers: {
-                "retry-after-ms": "0",
-                "x-request-id": "req_123",
-                "x-api-key": "<redacted>",
-              },
-            },
-          },
-        },
-      })
-      expect(errorHttp(error)?.body).toBe("rate limited")
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response("rate limited", {
-            status: 429,
-            headers: { "retry-after-ms": "0", "x-request-id": "req_123", "x-api-key": "secret" },
-          }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("honors current redacted header names in diagnostics", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(errorHttp(error)?.request.headers["x-safe"]).toBe("<redacted>")
-      expect(errorHttp(error)?.response?.headers["x-safe"]).toBe("<redacted>")
-    }).pipe(
-      Effect.provide(responsesLayer([new Response("bad", { status: 400, headers: { "x-safe": "response-secret" } })])),
-      Effect.provideService(Headers.CurrentRedactedNames, ["x-safe"]),
-    ),
-  )
-
-  it.effect("extracts OpenAI-style rate-limit diagnostics", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-      expect(error.reason._tag === "RateLimit" ? error.reason.rateLimit : undefined).toEqual({
-        retryAfterMs: 0,
-        limit: { requests: "500", tokens: "30000" },
-        remaining: { requests: "499", tokens: "29900" },
-        reset: { requests: "1s", tokens: "10s" },
-      })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response("rate limited", {
-            status: 429,
-            headers: {
-              "retry-after-ms": "0",
-              "x-ratelimit-limit-requests": "500",
-              "x-ratelimit-limit-tokens": "30000",
-              "x-ratelimit-remaining-requests": "499",
-              "x-ratelimit-remaining-tokens": "29900",
-              "x-ratelimit-reset-requests": "1s",
-              "x-ratelimit-reset-tokens": "10s",
-            },
-          }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("extracts Anthropic-style rate-limit diagnostics", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(errorHttp(error)?.rateLimit).toEqual({
-        retryAfterMs: 0,
-        limit: { requests: "100", "input-tokens": "10000" },
-        remaining: { requests: "12", "input-tokens": "9000" },
-        reset: { requests: "2026-05-06T12:00:00Z", "input-tokens": "2026-05-06T12:00:10Z" },
-      })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response("overloaded", {
-            status: 529,
-            headers: {
-              "retry-after-ms": "0",
-              "anthropic-ratelimit-requests-limit": "100",
-              "anthropic-ratelimit-requests-remaining": "12",
-              "anthropic-ratelimit-requests-reset": "2026-05-06T12:00:00Z",
-              "anthropic-ratelimit-input-tokens-limit": "10000",
-              "anthropic-ratelimit-input-tokens-remaining": "9000",
-              "anthropic-ratelimit-input-tokens-reset": "2026-05-06T12:00:10Z",
-            },
-          }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("returns provider status failures without retrying", () =>
-    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const error = yield* Effect.gen(function* () {
-        const executor = yield* RequestExecutor.Service
-        return yield* executor.execute(request).pipe(Effect.flip)
-      }).pipe(
-        Effect.provide(
-          countedResponsesLayer(attempts, [
-            new Response("busy", { status: 503, headers: { "retry-after-ms": "0" } }),
-            new Response("ok", { status: 200 }),
-          ]),
-        ),
-      )
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status: 503 })
-      expect(yield* Ref.get(attempts)).toBe(1)
-    }),
-  )
-
-  it.effect("marks 504 and 529 status responses as provider-internal", () =>
-    Effect.gen(function* () {
-      const failWith = (status: number) =>
-        Effect.gen(function* () {
-          const executor = yield* RequestExecutor.Service
-          const error = yield* executor.execute(request).pipe(Effect.flip)
-
-          expectAIError(error)
-          expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status })
-        }).pipe(
-          Effect.provide(
-            responsesLayer([
-              new Response("provider failure", {
-                status,
-                headers: { "retry-after-ms": "0" },
-              }),
-            ]),
-          ),
-        )
-
-      yield* failWith(504)
-      yield* failWith(529)
-    }),
-  )
-
-  it.effect("truncates large authentication error bodies", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "Authentication" })
-      expect(errorHttp(error)?.bodyTruncated).toBe(true)
-      expect(errorHttp(error)?.body).toHaveLength(16_384)
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response("x".repeat(20_000), { status: 401 }),
-          new Response("should not retry", { status: 200 }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("redacts common secret fields in response bodies", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(request).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(errorHttp(error)?.body).toContain('"key":"<redacted>"')
-      expect(errorHttp(error)?.body).toContain("api_key=<redacted>")
-      expect(errorHttp(error)?.body).not.toContain("body-secret")
-      expect(errorHttp(error)?.body).not.toContain("query-secret")
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}', {
-            status: 400,
-          }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("redacts echoed request secret values in response bodies", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.execute(secretRequest).pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(errorHttp(error)?.body).toContain("provider echoed <redacted>")
-      expect(errorHttp(error)?.body).toContain("authorization <redacted>")
-      expect(errorHttp(error)?.body).not.toContain("query-secret-123")
-      expect(errorHttp(error)?.body).not.toContain("header-secret-456")
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response("provider echoed query-secret-123 and authorization header-secret-456", { status: 400 }),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("does not re-execute after a successful response reaches stream parsing", () =>
-    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const model = OpenAIChat.route
-        .with({ endpoint: { baseURL: "https://api.openai.test/v1" } })
-        .model({ id: "gpt-4o-mini" })
-      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Ref.update(attempts, (value) => value + 1).pipe(
-              Effect.as(
-                input.respond(
-                  sseRaw(
-                    `data: ${JSON.stringify(deltaChunk({ role: "assistant", content: "Hello" }))}`,
-                    "data: not-json",
-                  ),
-                  { headers: { "content-type": "text/event-stream" } },
-                ),
-              ),
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
-      expect(yield* Ref.get(attempts)).toBe(1)
-    }),
-  )
-})

packages/ai/test/exports.test.ts

@@ -1,92 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { AIError, ImageInput, LanguageModel, LLM, LLMClient, Provider } from "@opencode-ai/ai"
-import { Route, Protocol } from "@opencode-ai/ai/route"
-import { Provider as ProviderSubpath } from "@opencode-ai/ai/provider"
-import {
-  CloudflareAIGateway,
-  CloudflareWorkersAI,
-  OpenAI,
-  OpenAICompatible,
-  OpenRouter,
-  XAI,
-} from "@opencode-ai/ai/providers"
-import * as GitHubCopilot from "@opencode-ai/ai/providers/github-copilot"
-import {
-  OpenAIChat,
-  OpenAICompatibleChat,
-  OpenAICompatibleResponses,
-  OpenAIResponses,
-  OpenResponses,
-} from "@opencode-ai/ai/protocols"
-import * as AnthropicMessages from "@opencode-ai/ai/protocols/anthropic-messages"
-import { TestLLM } from "@opencode-ai/ai/testing"
-
-describe("public exports", () => {
-  test("root exposes app-facing runtime APIs", () => {
-    expect(LLM.request).toBeFunction()
-    expect(LLMClient.Service).toBeFunction()
-    expect(LLMClient.layer).toBeDefined()
-    expect(AIError).toBeFunction()
-    expect(LanguageModel.make).toBeFunction()
-    expect(ImageInput.bytes).toBeFunction()
-    expect(Provider.make).toBeFunction()
-    expect(ProviderSubpath.make).toBe(Provider.make)
-    expect(TestLLM.layer).toBeFunction()
-  })
-
-  test("route barrel exposes route-authoring APIs", () => {
-    expect(Route.make).toBeFunction()
-    expect(Protocol.make).toBeFunction()
-  })
-
-  test("provider barrels expose user-facing facades", async () => {
-    const { OpenAICompatibleResponses } = await import("@opencode-ai/ai/providers")
-
-    expect(OpenAI.model).toBeFunction()
-    expect(OpenAI.provider.responses).toBe(OpenAI.responses)
-    expect(OpenAI.provider.responsesWebSocket).toBe(OpenAI.responsesWebSocket)
-    expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
-    expect(OpenAICompatible.deepseek.model).toBeFunction()
-    expect(
-      OpenAICompatibleResponses.configure({ baseURL: "https://responses.test/v1" }).model("fixture").route.id,
-    ).toBe("openai-compatible-responses")
-    expect(CloudflareAIGateway.configure).toBeFunction()
-    expect(CloudflareAIGateway.configure({ accountId: "fixture", gatewayApiKey: "fixture" }).model).toBeFunction()
-    expect(CloudflareWorkersAI.configure).toBeFunction()
-    expect(CloudflareWorkersAI.configure({ accountId: "fixture", apiKey: "fixture" }).model).toBeFunction()
-    expect(OpenRouter.model).toBeFunction()
-    expect(XAI.model).toBeFunction()
-    expect(XAI.provider.responses).toBe(XAI.responses)
-    expect(XAI.provider.chat).toBe(XAI.chat)
-    expect(XAI.configure({ apiKey: "fixture" }).responses("grok-4.3").route.id).toBe("openai-responses")
-    expect(XAI.configure({ apiKey: "fixture" }).chat("grok-4.3").route.id).toBe("openai-compatible-chat")
-    expect(
-      GitHubCopilot.configure({ baseURL: "https://api.githubcopilot.test", apiKey: "fixture" }).model,
-    ).toBeFunction()
-    expect(
-      GitHubCopilot.configure({
-        baseURL: "https://api.githubcopilot.test",
-        apiKey: "fixture",
-        endpoint: "responses",
-      }).model("mai-code-1-flash-picker").route.id,
-    ).toBe("openai-responses")
-    expect(
-      GitHubCopilot.configure({
-        baseURL: "https://api.githubcopilot.test",
-        apiKey: "fixture",
-        endpoint: "chat",
-      }).model("gpt-5").route.id,
-    ).toBe("openai-chat")
-  })
-
-  test("protocol barrels expose supported low-level routes", () => {
-    expect(OpenAIChat.route.id).toBe("openai-chat")
-    expect(OpenAICompatibleChat.route.id).toBe("openai-compatible-chat")
-    expect(OpenResponses.protocol.id).toBe("open-responses")
-    expect(OpenAICompatibleResponses.route.id).toBe("openai-compatible-responses")
-    expect(OpenAICompatibleResponses.route.protocol).toBe("open-responses")
-    expect(OpenAIResponses.route.id).toBe("openai-responses")
-    expect(OpenAIResponses.webSocketRoute.id).toBe("openai-responses-websocket")
-    expect(AnthropicMessages.route.id).toBe("anthropic-messages")
-  })
-})

packages/ai/test/fixtures/recordings/anthropic-compatible-messages/minimax-m3-anthropic-compatible-text.json

@@ -1,40 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "text",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-text",
-    "recordedAt": "2026-07-18T03:42:22.893Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"You are concise.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Reply exactly with: Hello!\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"1a0b363d0882af316faebcec4d4855a8\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":53,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Hello\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"!\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":53,\"output_tokens\":2,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-call.json

@@ -1,41 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-call",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-call",
-    "recordedAt": "2026-07-18T03:42:23.876Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Call tools exactly as requested.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Call get_weather with city exactly Paris.\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"tool\",\"name\":\"get_weather\"},\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"6731ecc323233459d1792df9a733dd98\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":404,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_vkxtif4epmvm_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":290,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-loop.json

@@ -1,60 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-loop",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-loop",
-    "recordedAt": "2026-07-18T03:42:25.248Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"3807fa12f9ecb9357df511e099da6da0\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":417,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":303,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{\"city\":\"Paris\"}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_function_yr64rwmre4gr_1\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"92f8a1e86f29946eb2699d40a088fc08\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":41,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" is sunny.\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":41,\"output_tokens\":4,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}