test: update server and sdk fixtures to context options bag

Titles will get a dedicated hook. The context event's kind excludes
"title" so plugins cannot branch on a value they never receive.

.changeset/directory-page-heading.md

@@ -1,5 +1,5 @@
 ---
-"@opencode/core": patch
+"@opencode-ai/core": patch
 ---
 
 Correct directory page headings when the read offset is zero.

.github/workflows/deploy-files.yml

@@ -1,34 +0,0 @@
-name: deploy-files
-
-on:
-  push:
-    branches:
-      - dev
-      - v2
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-files-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'v2')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Typecheck
-        working-directory: services/files
-        run: bun typecheck
-
-      - name: Deploy
-        working-directory: services/files
-        run: bun run deploy --env ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/deploy-www.yml

@@ -24,13 +24,13 @@ jobs:
       - uses: ./.github/actions/setup-bun
 
       - name: Build
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run build
         env:
           CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
 
       - name: Deploy
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/nix-hashes.yml

@@ -11,7 +11,6 @@ on:
       - "bun.lock"
       - "package.json"
       - "packages/*/package.json"
-      - "services/*/package.json"
       - "flake.lock"
       - "nix/node_modules.nix"
       - "nix/scripts/**"

.github/workflows/publish.yml

@@ -48,7 +48,7 @@ jobs:
 
       - name: Deploy update service
         if: github.ref_name == 'v2'
-        working-directory: services/updates
+        working-directory: packages/updates
         run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -91,7 +91,7 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
         with:
-          bun-version: 1.4.2
+          bun-version: 1.4.0
 
       - name: Setup git committer
         id: committer
@@ -113,7 +113,7 @@ jobs:
         id: build
         run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
-          BUN_COMPILE_RELEASE: bun-v1.4.2
+          BUN_COMPILE_RELEASE: bun-v1.4.0
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
           GH_REPO: ${{ needs.version.outputs.repo }}
@@ -670,6 +670,19 @@ jobs:
           git config --global user.name "opencode"
           ssh-keyscan -H aur.archlinux.org >> ~/.ssh/known_hosts || true
 
+      - name: Upload desktop release assets
+        if: needs.version.outputs.release
+        env:
+          GH_TOKEN: ${{ steps.committer.outputs.token }}
+        run: |
+          shopt -s nullglob
+          files=(/tmp/desktop/*.{exe,blockmap,dmg,zip,AppImage,deb,rpm} /tmp/desktop/*.app.tar.gz)
+          if (( ${#files[@]} == 0 )); then
+            echo "No desktop release assets found"
+            exit 1
+          fi
+          gh release upload "v${{ needs.version.outputs.version }}" "${files[@]}" --clobber --repo "${{ needs.version.outputs.repo }}"
+
       - run: ./script/publish.ts
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
@@ -681,6 +694,3 @@ jobs:
           LATEST_YML_DIR: /tmp/latest-yml
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          OPENCODE_DESKTOP_DIST: /tmp/desktop
-          CLOUDFLARE_ACCOUNT_ID: 15d29c8639fd3733b1b5486a2acfd968
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/test.yml

@@ -49,7 +49,7 @@ jobs:
             echo "app=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi
-          bun x turbo@2.10.2 ls --affected --filter=@opencode/app --output=json > affected.json
+          bun x turbo@2.10.2 ls --affected --filter=@opencode-ai/app --output=json > affected.json
           bun -e 'const result = await Bun.file("affected.json").json(); console.log(`app=${result.packages.count > 0}`)' >> "$GITHUB_OUTPUT"
 
   unit:
@@ -132,10 +132,10 @@ jobs:
         timeout-minutes: 15
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            bun turbo verify:package --filter=@opencode/sdk
+            bun turbo verify:package --filter=@opencode-ai/sdk
             exit 0
           fi
-          bun turbo verify:package --affected --filter=@opencode/sdk
+          bun turbo verify:package --affected --filter=@opencode-ai/sdk
         env:
           TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
           TURBO_SCM_HEAD: ${{ github.sha }}
@@ -173,7 +173,7 @@ jobs:
 
       - name: Check generated documentation
         if: runner.os == 'Linux'
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run check:generated
 
   e2e:

.opencode/tool/github-pr-search.ts

@@ -1,5 +1,5 @@
 /// <reference path="../env.d.ts" />
-import { tool } from "@opencode/plugin"
+import { tool } from "@opencode-ai/plugin"
 async function githubFetch(endpoint: string, options: RequestInit = {}) {
   const response = await fetch(`https://api.github.com${endpoint}`, {
     ...options,

.opencode/tool/github-triage.ts

@@ -1,5 +1,5 @@
 /// <reference path="../env.d.ts" />
-import { tool } from "@opencode/plugin"
+import { tool } from "@opencode-ai/plugin"
 
 const TEAM = {
   tui: ["kommander", "simonklee"],

AGENTS.md

@@ -84,9 +84,9 @@ const { a, b } = obj
 ### Imports
 
 - Never alias imports. Do not use `import { foo as bar } from "..."` or renamed imports like `resolve as pathResolve`.
-- Never use type-position `import("...")` references such as `Schema.declare<import("@opencode/plugin/effect/plugin").Plugin["effect"]>`. Only when two imports genuinely collide on a name and no other option exists, an aliased type import (`import type { Plugin as PluginDefinition } from "..."`) is permitted as a last resort — still strongly preferred not to.
+- Never use type-position `import("...")` references such as `Schema.declare<import("@opencode-ai/plugin/effect/plugin").Plugin["effect"]>`. Only when two imports genuinely collide on a name and no other option exists, an aliased type import (`import type { Plugin as PluginDefinition } from "..."`) is permitted as a last resort — still strongly preferred not to.
 - Never use star imports. Do not use `import * as Foo from "..."` or `import type * as Foo from "..."`.
-- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode/core/project"`, then reference `Project.ID`.
+- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode-ai/core/project"`, then reference `Project.ID`.
 - Prefer dynamic imports for heavy modules that are only needed in selected code paths, especially in startup-sensitive entrypoints. Destructure dynamic import bindings near the top of the narrowest scope that needs them so they read like normal imports. Avoid inline chains such as `await import("./module").then((mod) => mod.value())` or `(await import("./module")).value()`. Keep branch-specific imports inside the branch that needs them to preserve lazy loading.
 
 ### Variables
@@ -183,7 +183,7 @@ const table = sqliteTable("session", {
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
-- Keep delivery vocabulary explicit. Prompts steer by default. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
+- Keep delivery vocabulary explicit. Prompts steer by default. Steers deliver in enqueue order at safe step boundaries, stopping before compaction or move control items. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 - One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
 - Keep event replay ownership separate from clustered Session execution ownership.
 - Keep the Instructions algebra and built-ins in `src/instructions`; keep instruction producers with their observed domains, and keep Session History selection plus `InstructionState` and `InstructionEntry` persistence Session-owned. `InstructionDiscovery` observes ambient global and upward-project instructions. The runner composes built-ins, discovery, guidance, and entries explicitly in `loadInstructions`; there is no instruction registry.

bunfig.toml

@@ -2,7 +2,7 @@
 exact = true
 # Only install newly resolved package versions published at least 3 days ago.
 minimumReleaseAge = 259200
-minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]
+minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]
 
 [test]
 root = "./do-not-run-tests-from-root"

infra/console.ts

@@ -235,7 +235,6 @@ const bucketNew = new sst.cloudflare.Bucket("ZenDataNew")
 const DISCORD_INCIDENT_WEBHOOK_URL = new sst.Secret("DISCORD_INCIDENT_WEBHOOK_URL")
 const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID")
 const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY")
-const ENTERPRISE_SALES_INBOX_EMAIL = new sst.Secret("ENTERPRISE_SALES_INBOX_EMAIL")
 
 const SALESFORCE_CLIENT_ID = new sst.Secret("SALESFORCE_CLIENT_ID")
 const SALESFORCE_CLIENT_SECRET = new sst.Secret("SALESFORCE_CLIENT_SECRET")
@@ -264,7 +263,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     EMAILOCTOPUS_API_KEY,
     AWS_SES_ACCESS_KEY_ID,
     AWS_SES_SECRET_ACCESS_KEY,
-    ENTERPRISE_SALES_INBOX_EMAIL,
     SALESFORCE_CLIENT_ID,
     SALESFORCE_CLIENT_SECRET,
     SALESFORCE_INSTANCE_URL,

install

@@ -165,30 +165,22 @@ else
         exit 1
     fi
 
-    package_scope="@opencode"
     if [ -z "$requested_version" ]; then
-        metadata=$(curl -fsSL https://opencode.ai/update/api/beta/cli/npm || true)
+        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/beta || true)
         specific_version=$(echo "$metadata" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
-        package=$(echo "$metadata" | sed -n 's/.*"package":"\([^"]*\)".*/\1/p')
 
-        if [ -z "$specific_version" ] || [ -z "$package" ]; then
+        if [ -z "$specific_version" ]; then
             echo -e "${RED}Failed to fetch version information${NC}"
             exit 1
         fi
-        package_scope="${package%/cli}"
     else
         # Strip leading 'v' if present
         requested_version="${requested_version#v}"
         specific_version=$requested_version
     fi
 
-    package_name="$package_scope/cli-$target"
-    http_status=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/$package_scope%2fcli-$target/$specific_version" || true)
-    # Older clients install the minimum release before they can migrate package names.
-    if [ "$http_status" = "404" ] && [ -n "$requested_version" ]; then
-        package_name="@opencode-ai/cli-$target"
-        http_status=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/@opencode-ai%2fcli-$target/$specific_version" || true)
-    fi
+    package_name="@opencode-ai/cli-$target"
+    http_status=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/@opencode-ai%2fcli-$target/$specific_version" || true)
     if [ "$http_status" = "404" ]; then
         echo -e "${RED}Error: Version ${specific_version} is not available for $target${NC}"
         echo -e "${MUTED}Available versions: https://www.npmjs.com/package/$package_name?activeTab=versions${NC}"

nix/desktop.nix

@@ -88,7 +88,7 @@ stdenv.mkDerivation (finalAttrs: {
     cd packages/desktop
 
     export OPENCODE_CLI_DIST="$TMPDIR/desktop-cli"
-    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode/", ""))')
+    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode-ai/", ""))')
     mkdir -p "$OPENCODE_CLI_DIST/$cli_package/bin"
     cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode2"
 

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-gW+1JbPQnt+PZzHfGijjnwch6X6pyaBnPTxAc47yiQw=",
-    "aarch64-linux": "sha256-qI6CtJkmh20ouWeiQRR1zp+YjHootkN23VFJCwqnf0A=",
-    "aarch64-darwin": "sha256-oyEhVcjbKq3+BCCxVBl0TZYmKJv1BBLWPVs0Vw6Fbac=",
-    "x86_64-darwin": "sha256-UhLZjG3NlkoXRWNn8SK/pLm5eDR3saU+TgEgfX592vQ="
+    "x86_64-linux": "sha256-I2sHU46Bdp1DmW/ygNKKxF6U53oNIeVeAS8TmMdtvzw=",
+    "aarch64-linux": "sha256-aQUEBmfHhaR/YdsRyw0u6hsEo0TEmXHBMyiGnOFRCeI=",
+    "aarch64-darwin": "sha256-40Y3HYSjs8S0M3SFNUrU8lMYaHy7vpmiW+7b6Y9pKzs=",
+    "x86_64-darwin": "sha256-7iGegI/1pXcR5W0UBX0wAWAga+F34fhj9lbAHotVwEo="
   }
 }

nix/node_modules.nix

@@ -27,12 +27,11 @@ stdenvNoCC.mkDerivation {
     fileset = lib.fileset.intersection (lib.fileset.fromSource (lib.sources.cleanSource ../.)) (
       lib.fileset.unions [
         ../packages
-        ../services
         ../bun.lock
         ../package.json
         ../patches
         ../install # required by desktop build (cli.rs include_str!)
-        ../.github/TEAM_MEMBERS # required by @opencode/script
+        ../.github/TEAM_MEMBERS # required by @opencode-ai/script
       ]
     );
   };

package.json

@@ -5,15 +5,15 @@
   "version": "0.0.0",
   "private": true,
   "type": "module",
-  "packageManager": "bun@1.4.2",
+  "packageManager": "bun@1.4.0",
   "scripts": {
-    "dev": "bun run --cwd packages/cli src/index.ts",
+    "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
     "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" exec bun run dev \"$@\" --server \"$(opencode2 service status)\"' --",
     "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 services/www dev",
+    "dev:www": "bun run --cwd packages/www dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "bench:devex": "bun run --cwd packages/app test:bench:devex",
     "lint": "oxlint",
@@ -34,7 +34,6 @@
   "workspaces": {
     "packages": [
       "packages/*",
-      "services/*",
       "packages/console/*",
       "packages/stats/*"
     ],
@@ -44,7 +43,7 @@
       "@effect/platform-node-shared": "4.0.0-rc.112",
       "@effect/sql-sqlite-bun": "4.0.0-rc.112",
       "@npmcli/arborist": "9.4.0",
-      "@types/bun": "1.4.0",
+      "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
@@ -129,8 +128,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.933.0",
-    "@opencode/plugin": "workspace:*",
-    "@opencode/script": "workspace:*",
+    "@opencode-ai/plugin": "workspace:*",
+    "@opencode-ai/script": "workspace:*",
     "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
@@ -147,6 +146,10 @@
     "esbuild",
     "node-pty",
     "protobufjs",
+    "tree-sitter",
+    "tree-sitter-bash",
+    "tree-sitter-powershell",
+    "web-tree-sitter",
     "electron"
   ],
   "overrides": {
@@ -156,7 +159,6 @@
     "@effect/platform-node-shared": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "bun-types": "1.4.2",
     "effect": "catalog:",
     "solid-js": "catalog:"
   },

packages/ai/AGENTS.md

@@ -81,7 +81,7 @@ export const route = Route.make({
 
 Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
 
-The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider owns a small `Route.make(...)` composition instead of a protocol clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
+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 supports multiple physical transports, selection remains execution policy below its semantic route. `OpenResponsesChannel.transport(...)` owns the provider-neutral Responses WebSocket concept: it prepares one final request, executes HTTP by default, strips WebSocket-disallowed fields, and passes a generic channel exchange to a per-call `WebSocketChannelExecutor` when supplied. Provider-specific Responses routes opt in with handshake and connection-age policy. `Route.streamPrepared` owns decoding and acknowledges channel completion only after successful full consumption.
 
@@ -115,16 +115,15 @@ Keep provider facades small and explicit:
 - 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`.
-- Give every named provider its own file and top-level export. Keep its endpoint, auth defaults, and route setup in that file. Compose shared protocols directly; do not nest named provider presets under generic compatible facades or keep their endpoints in a shared provider profile registry.
 
 `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`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
 
 ```ts
-import { model } from "@opencode/ai/providers/openai/responses"
+import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey,

packages/ai/README.md

@@ -1,12 +1,12 @@
-# @opencode/ai
+# @opencode-ai/ai
 
-Schema-first language model and image-generation APIs built with Effect.
+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"
-import { RequestExecutor } from "@opencode/ai/route"
-import { OpenAI } from "@opencode/ai/providers"
+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")
 
@@ -29,123 +29,13 @@ 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.
 
-## MiniMax
-
-MiniMax defaults to its Messages API and reads `MINIMAX_API_KEY` when `apiKey` is omitted:
-
-```ts
-import { Effect, Layer } from "effect"
-import { LLM, LLMClient } from "@opencode/ai"
-import { MiniMax } from "@opencode/ai/providers"
-import { RequestExecutor } from "@opencode/ai/route"
-
-const minimax = MiniMax.configure({ apiKey: process.env.MINIMAX_API_KEY })
-const request = LLM.request({
-  model: minimax.model("MiniMax-M3"), // also minimax.messages("MiniMax-M3")
-  prompt: "What is 173 multiplied by 219?",
-  providerOptions: { thinking: { type: "adaptive" } },
-  generation: { maxTokens: 1536 },
-})
-
-const layer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
-const response = await Effect.runPromise(LLMClient.generate(request).pipe(Effect.provide(layer)))
-console.log(response.text)
-```
-
-Select `minimax.chat("MiniMax-M3")` or `minimax.responses("MiniMax-M3")` for MiniMax's native Chat Completions
-and Responses APIs. The matching package entrypoints are `@opencode/ai/providers/minimax/messages`,
-`@opencode/ai/providers/minimax/chat`, and `@opencode/ai/providers/minimax/responses`.
-
-- **Messages:** M3 thinking defaults off. Set `thinking: { type: "adaptive" }` to enable it or
-  `thinking: { type: "disabled" }` to disable it.
-- **Chat:** M3 thinking defaults on and uses the same `thinking` control. The provider enables `reasoning_split`
-  by default so reasoning is separate from answer text; `reasoningSplit: false` selects native `<think>`-tagged text.
-- **Responses:** M3 reasoning defaults off. `reasoningEffort: "none"` disables it; `"minimal"`, `"low"`,
-  `"medium"`, and `"high"` enable reasoning without changing its depth.
-
-M2.x models always think, even when a disabling option is supplied. For tool continuations, retain the complete
-`response.message` in history before adding `Message.tool(...)` results; this preserves reasoning and any signatures.
-
-The default API bases are `https://api.minimax.io/anthropic/v1` for Messages and `https://api.minimax.io/v1` for
-Chat and Responses. `configure({ baseURL })` replaces the selected API's base, including its version prefix.
-
-## Meta
-
-Use Meta's direct [Model API](https://dev.meta.ai/docs/overview) with `META_API_KEY`:
-
-```ts
-import { Meta } from "@opencode/ai/providers"
-
-const meta = Meta.configure() // or Meta.configure({ apiKey })
-const request = LLM.request({
-  model: meta.responses("muse-spark-1.3"), // meta.model(...) also selects Responses
-  prompt: "What is 173 multiplied by 219? Reply with the integer.",
-  providerOptions: { reasoningEffort: "low" },
-  generation: { maxTokens: 1024 },
-})
-```
-
-`meta.chat("muse-spark-1.3")` selects Chat Completions; `meta.messages("muse-spark-1.3")` selects
-the Anthropic-compatible Messages API. All use `https://api.meta.ai/v1`. The package entrypoints
-`@opencode/ai/providers/meta/responses`, `meta/chat`, and `meta/messages` expose `model(modelID, settings)`.
-
-[Muse Spark](https://dev.meta.ai/docs/models) supports `minimal`, `low`, `medium`, `high`, and
-`xhigh` reasoning effort; standard-tier 1.3 also supports `max`. Omitting effort uses the model's
-default. Muse Spark always reasons and rejects `none`. The output-token budget includes private reasoning.
-
-Responses defaults to `store: false` and `include: ["reasoning.encrypted_content"]`. Preserve
-`response.message` along with matching `Message.tool(...)` results in subsequent requests to replay
-reasoning through tool loops. Optional `reasoningSummary: "auto"` requests a readable summary.
-For server-managed history, override `store: true, include: []` and send the response ID through
-`http: { body: { previous_response_id: responseID } }` with only the new input.
-Chat Completions redacts private reasoning and cannot carry it between calls.
-Responses and Chat support only `toolChoice: "auto"` (the default). Messages also accepts `"none"`;
-its documented forced `"any"` choice currently returns HTTP 400. Messages defaults to adaptive thinking
-with `display: "omitted"`, preserving encrypted `redacted_thinking` in `response.message`. Use
-`providerOptions: { effort: "low" }` for depth or `thinking: { type: "enabled", budgetTokens: 1024 }`
-for budget compatibility (with `generation.maxTokens > 1024`).
-
-Add `tools: [Meta.webSearch()]` to a Spark Responses or Messages request for hosted web search.
-Responses exposes hosted results and URL citations in text-part `providerMetadata.meta.annotations`.
-To include search result lists, set `include: ["reasoning.encrypted_content", "web_search_call.results"]`.
-Messages exposes hosted search calls; the recorded Messages API stream does not supply structured
-citations or separate result blocks. Retain `response.message` for either API's continuation.
-
-Use `Image.generate` for one-off generation or editing:
-
-```ts
-import { Image, ImageInput } from "@opencode/ai"
-
-const generation = Image.generate({
-  model: meta.image("muse-image-1.0"),
-  prompt: "A flat black square on a white background.",
-  options: { n: 1, reasoningStrength: "low" },
-})
-
-const edit = Image.generate({
-  model: meta.image("muse-image-1.0"),
-  prompt: "Make the square purple.",
-  images: [ImageInput.bytes(imageBytes, "image/webp")],
-  options: { outputFormat: "png", reasoningStrength: "low" },
-})
-```
-
-The default image format is WEBP; `outputFormat` also accepts PNG/JPEG and `responseFormat: "url"`
-returns a signed URL. `size` is an aspect-ratio hint. For conversational images, select
-`meta.responses("muse-image-1.0")` with `tools: [Meta.imageGeneration({ reasoningStrength: "low" })]`.
-Generated images are provider-executed tool results with file content. Retain `response.message` to
-replay the signed image handle on the next request. Muse Image accepts only the `image_generation` tool.
-
-Meta Responses is explicitly HTTP/SSE-only and does not use WebSockets, even when a caller supplies
-`StreamOptions.webSocket`. The public `/v1/responses` endpoint rejects WebSocket upgrades with HTTP 405 (`Allow: POST`).
-
 ## Image generation
 
 Use `Image.generate` with an image model for direct asset generation:
 
 ```ts
-import { Image, ImageInput } from "@opencode/ai"
-import { OpenAI } from "@opencode/ai/providers"
+import { Image, ImageInput } from "@opencode-ai/ai"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 const program = Effect.gen(function* () {
   const response = yield* Image.generate({
@@ -241,7 +131,7 @@ yield *
 Google's current Gemini image models use the same direct API:
 
 ```ts
-import { Google } from "@opencode/ai/providers"
+import { Google } from "@opencode-ai/ai/providers"
 
 const googleProgram = Effect.gen(function* () {
   const response = yield* Image.generate({
@@ -317,12 +207,12 @@ The hosted result is represented as a provider-executed tool call and tool resul
 
 ## Testing
 
-Use the deterministic test client from `@opencode/ai/testing` to script provider-neutral responses and inspect
+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/testing"
+import { TestLLM } from "@opencode-ai/ai/testing"
 
 const programWithTestClient = Effect.gen(function* () {
   const test = yield* TestLLM.Test
@@ -357,21 +247,19 @@ it does not repair or truncate them.
 
 For explicit compaction, script a `CompactionResponse` through `push`, `always`, or `serve`. Its `replacement` contains the next context window, including retained user messages. The client returns that result and usage directly, with the same lazy request recording and gates. Generation and compaction reject fixtures for the wrong operation instead of converting between response shapes.
 
-For `compact(request, { mechanism: "trigger" })`, script a `CompactionCheckpointResponse` instead. It carries `checkpoint`, `responseID`, and optional `usage`. Endpoint and trigger calls reject each other's fixtures; both share the same queue, gates, lazy recording, and fallback controls.
-
 The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
 over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
 `testLayer`.
 
 ## Provider compaction
 
-Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
+Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider. Bedrock compaction is deferred to a separate follow-up.
 
 This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
 
 ### Explicit compaction
 
-`LLMClient.compact(request)` (equivalently, `{ mechanism: "endpoint" }`) is the caller-controlled operation for OpenAI, Azure, and xAI Responses. It performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` with `replacement: Message[]` and optional `usage`, not a normal generation response. This mechanism does not accept a WebSocket executor.
+`LLMClient.compact(request)` is the caller-controlled operation for OpenAI, Azure, and xAI Responses. It performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` with `replacement: Message[]` and optional `usage`, not a normal generation response.
 
 Prefer this operation, where supported, when the application owns compaction policy and durable context updates.
 
@@ -391,41 +279,6 @@ Generation-only body overlays such as `stream` and `store` are not sent to the c
 
 The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. Anthropic does not expose this operation in this package; its in-band compaction remains available below. Compatible routes do not inherit an explicit compact endpoint simply because they use a Responses protocol.
 
-### Streamed checkpoint compaction
-
-OpenAI Responses also exposes a separate, explicitly selected mechanism:
-
-```ts
-const result =
-  yield *
-  LLMClient.compact(request, {
-    mechanism: "trigger",
-    webSocket, // Optional: without it, the request uses HTTP/SSE.
-  })
-
-result.checkpoint // Successful encrypted CompactionPart.
-result.responseID
-result.usage
-```
-
-This appends a native `compaction_trigger` control item to the full input and sends a normal Responses request, with tools and instructions retained, `stream: true`, `store: false`, and parallel tool calls enabled. It removes normal-answer text/output-format controls, forced tool choices, output-token/tool-call limits, and automatic `context_management`. Body overlays cannot replace `input` or supply `previous_response_id`/`conversation`; the complete canonical history is required for safe stateless replay. Request metadata, auth, headers, query parameters, service tier, and supported prompt-cache settings are preserved.
-
-Only a successful `response.completed` with a response ID and exactly one logical encrypted checkpoint succeeds. Repeated item events are correlated by ID/output slot, including ID-less checkpoints. Other output is ignored, not returned as assistant text or dispatched as tools. Failed, incomplete, malformed, and interrupted responses return errors rather than partial checkpoints.
-
-The result is **not a replacement window**. The caller selects retained history, combines it with `result.checkpoint`, and durably installs it before continuing. The operation does not choose a retention budget, prune messages, or modify the original request.
-
-The supplied WebSocket executor can reuse a compatible append baseline for the compaction request. On completion the protocol supplies no continuation checkpoint, clearing the old baseline so the next generation sends the newly installed window in full. Validation occurs before transport completion is acknowledged. There is no operation-level retry or fallback to `/responses/compact`; existing safe transport fallback may use SSE, with full history and no connection-local response ID.
-
-Trigger support is separate from endpoint support. Only the OpenAI Responses route advertises it; Azure, xAI, Chat, and compatible Responses routes do not inherit it. Untyped calls still fail before sending: missing route capabilities return `UnsupportedOperation`, while unknown mechanism names and invalid inputs return `InvalidRequest`. Dynamic callers must narrow for the selected mechanism:
-
-```ts
-if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
-  const result = yield * LLMClient.compact(request, { mechanism: "trigger" })
-}
-```
-
-This capability describes protocol implementation, **not universal availability on OpenAI API deployments**. The host application owns subscription/deployment eligibility, OAuth, endpoint selection, and deployment-specific headers. Local protocol/socket tests do not establish live provider support.
-
 ### Advanced: in-band compaction
 
 `providerOptions.contextManagement` lets the provider decide when to compact during an ordinary `generate` or `stream` call. This is an advanced option for callers that own persistence and recovery: persist the complete assistant message, including its checkpoint, before continuing. Enabling the option does not provide durable checkpoint storage, interruption recovery, or model-switch policy. Keep the prior context until a successful checkpoint has been persisted.
@@ -433,8 +286,8 @@ This capability describes protocol implementation, **not universal availability
 Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
 
 ```ts
-import { LLM, LLMClient, LLMRequest, Message } from "@opencode/ai"
-import { OpenAI } from "@opencode/ai/providers"
+import { LLM, LLMClient, LLMRequest, Message } from "@opencode-ai/ai"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 const request = LLM.request({
   model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
@@ -454,7 +307,7 @@ const next = LLMRequest.update(request, {
 A compaction part has `provider` and exactly one representation: `encrypted` for Responses, or `text` for Anthropic. Responses also preserves the optional checkpoint `id`. These fields survive message serialization without becoming visible assistant text. Sending a checkpoint to another provider or an incompatible API fails rather than silently losing context.
 
 ```ts
-import { CompactionPart, ProviderID } from "@opencode/ai"
+import { CompactionPart, ProviderID } from "@opencode-ai/ai"
 
 CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
 CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
@@ -482,7 +335,9 @@ providerOptions: {
 - Anthropic can return a compaction block with `content: null` when summarization fails. This becomes a compaction part with `text: null`, which is **not** a successful replacement for prior history. The package never prunes history automatically.
 - `Usage` totals include all reported Anthropic `usage.iterations`, including compaction. `contextTokens` separately reports the final message iteration's inclusive input size, when available. A compaction-only pause does not report a post-compaction context size. Raw iteration usage remains in `providerMetadata`.
 
-### Recording tests
+### Ownership and verification
+
+The AI package transports options and typed conversation parts. It does not schedule compaction, persist Session checkpoints, select history, switch providers, or replace Core's existing local compaction policy. Native compaction is not enabled for OpenCode Sessions by this feature; Session integration must persist these parts before enabling it. The AI SDK bridge rejects native compaction parts rather than dropping them. Provider-executed tool APIs and persistence changes are a separate follow-up.
 
 Tests cover serialized round trips, real local HTTP plus a tool loop, WebSocket recovery, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
 
@@ -501,7 +356,7 @@ Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "aut
 
 ### 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 tool definitions, system instructions, and the active conversation. The rolling final-message boundary advances on every request so recent conversation prefixes remain reusable during tool loops.
+`"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 advances on every request so recent conversation prefixes remain reusable during tool loops.
 
 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.
 
@@ -560,7 +415,7 @@ Normalized cache usage is read back into `response.usage.cacheReadInputTokens` a
 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/providers"
+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({
@@ -569,42 +424,31 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
+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.
 
-Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
+### Package-like entrypoints
+
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
 
 ```ts
-import { DeepSeek, Fireworks } from "@opencode/ai/providers"
-
-const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
-const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
-```
-
-The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `.fireworks`, `.groq`, and `.togetherai` presets are replaced by the top-level `Baseten`, `Cerebras`, `DeepInfra`, `DeepSeek`, `Fireworks`, `Groq`, and `TogetherAI` exports. Use `CloudflareAIGateway` and `CloudflareWorkersAI` directly; each has its own module. `OpenAICompatible` configures generic endpoints with an explicit `baseURL`.
-
-### Provider entrypoints
-
-Provider modules are available through dedicated exports from `@opencode/ai`. Each LLM entrypoint exports `model(modelID, settings)`, where `settings` contains provider configuration plus common `headers` and `body` overlays.
-
-```ts
-import { model } from "@opencode/ai/providers/openai/responses"
+import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey: process.env.OPENAI_API_KEY,
-  headers: { "x-application": "example" },
+  headers: { "x-application": "opencode" },
 })
 ```
 
-APIs have separate entrypoints:
+OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
 
-- `@opencode/ai/providers/openai/chat`
-- `@opencode/ai/providers/openai/responses`
-- `@opencode/ai/providers/openai-compatible/responses`
-- `@opencode/ai/providers/anthropic-compatible`
-- `@opencode/ai/providers/google-vertex/gemini`
-- `@opencode/ai/providers/google-vertex/chat`
-- `@opencode/ai/providers/google-vertex/responses`
-- `@opencode/ai/providers/google-vertex/messages`
+- `@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`
 
 OpenAI Responses has one semantic route and uses HTTP by default. Advanced callers may supply a per-call WebSocket channel executor through `StreamOptions`; transport policy does not change provider settings, model identity, or route identity. The provider-neutral Open Responses implementation owns the reusable WebSocket request and event contract, while each provider opts in with its own handshake and connection policy. 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, and defaults. 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.
 
@@ -613,36 +457,32 @@ Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate A
 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/providers/google-vertex/gemini"
+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/providers/google-vertex/chat"
+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/providers/google-vertex/responses"
+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/providers/google-vertex/messages"
+import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
 
 model("claude-sonnet-4-6", { project: "my-project", location: "global" })
 ```
 
-Additional provider entrypoints include:
+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.
 
-- `@opencode/ai/providers/baseten`
-- `@opencode/ai/providers/deepseek`
-- `@opencode/ai/providers/fireworks`
-- `@opencode/ai/providers/cloudflare-ai-gateway`
-- `@opencode/ai/providers/cloudflare-workers-ai`
+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
 
@@ -669,7 +509,7 @@ LLM.request({
 
 ## Routes
 
-Compose a route with `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports receive the route's endpoint and auth when preparing requests. Unsupported request shapes fail during protocol lowering.
+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
 

packages/ai/example/tutorial.ts

@@ -1,7 +1,7 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
-import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode/ai"
-import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode/ai/route"
-import { OpenAI } from "@opencode/ai/providers"
+import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
+import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode-ai/ai/route"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 /**
  * A runnable walkthrough of the LLM package use-site API.

packages/ai/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "version": "1.17.20",
-  "name": "@opencode/ai",
+  "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -21,17 +21,16 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "catalog:",
-    "@opencode/http-recorder": "workspace:*",
+    "@opencode-ai/http-recorder": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",
     "typescript": "catalog:"
   },
   "dependencies": {
-    "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "aws4fetch": "1.0.20",
     "effect": "catalog:",
     "google-auth-library": "10.5.0"

packages/ai/script/publish.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { Script } from "@opencode/script"
+import { Script } from "@opencode-ai/script"
 import { $ } from "bun"
 import { fileURLToPath } from "url"
 

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

@@ -7,8 +7,7 @@ import { AwsV4Signer } from "aws4fetch"
 import { Config, ConfigProvider, Effect, FileSystem, PlatformError, Redacted } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import * as ProviderShared from "../src/protocols/shared"
-import { CloudflareAIGateway } from "../src/providers/cloudflare-ai-gateway.js"
-import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"
+import * as Cloudflare from "../src/providers/cloudflare"
 
 type Provider = {
   readonly id: string
@@ -121,11 +120,11 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${CloudflareAIGateway.baseURL({
+        url: `${Cloudflare.aiGatewayBaseURL({
           accountId: env.CLOUDFLARE_ACCOUNT_ID,
           gatewayId: env.CLOUDFLARE_GATEWAY_ID || undefined,
         })}/chat/completions`,
-        token: Redacted.make(envValue(env, CloudflareAIGateway.authEnvVars)),
+        token: Redacted.make(envValue(env, Cloudflare.aiGatewayAuthEnvVars)),
         tokenHeader: "cf-aig-authorization",
         model: "workers-ai/@cf/meta/llama-3.1-8b-instruct",
       }),
@@ -141,8 +140,8 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${CloudflareWorkersAI.baseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
-        token: Redacted.make(envValue(env, CloudflareWorkersAI.authEnvVars)),
+        url: `${Cloudflare.workersAIBaseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
+        token: Redacted.make(envValue(env, Cloudflare.workersAIAuthEnvVars)),
         model: "@cf/meta/llama-3.1-8b-instruct",
       }),
   },

packages/ai/src/cache-policy.ts

@@ -11,7 +11,7 @@
 // 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.js"
-import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -50,24 +50,18 @@ interface Budget {
   remaining: number
 }
 
-const markLastTool = (tools: ReadonlyArray<ToolEntry>, hint: CacheHint, budget: Budget): ReadonlyArray<ToolEntry> => {
-  const target = tools.at(-1)
-  if (target === undefined) return tools
-  if (target.type === "namespace") {
-    const nested = markLastTool(target.tools, hint, budget)
-    return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }]
-  }
-  if (target.cache || budget.remaining === 0) return tools
+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.slice(0, -1), new ToolDefinition({ ...target, cache: hint })]
+  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
 }
 
-const countToolHints = (tools: ReadonlyArray<ToolEntry>): number =>
-  tools.reduce(
-    (count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)),
-    0,
-  )
-
 const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
   if (system.length === 0) return system
   let changed = false
@@ -128,7 +122,7 @@ const markMessages = (
 }
 
 const countHints = (request: LLMRequest) =>
-  countToolHints(request.tools) +
+  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) =>

packages/ai/src/llm.ts

@@ -12,10 +12,9 @@ import {
   LanguageModel,
   SystemPart,
   ToolChoice,
-  ToolEntry,
+  ToolDefinition,
   type ContentPart,
   type LanguageModelProviderOptions,
-  type ToolEntryInput,
 } from "./schema/index.js"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
 
@@ -28,7 +27,7 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
   readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
   readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
   readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolEntryInput>
+  readonly tools?: ReadonlyArray<ToolDefinition.Input>
   readonly toolChoice?: ToolChoice.Input
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
@@ -57,7 +56,7 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
     ...rest,
     system: SystemPart.content(requestSystem),
     messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolEntry.make) ?? [],
+    tools: tools?.map(ToolDefinition.make) ?? [],
     toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
     generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
     providerOptions: requestProviderOptions,

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

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer"
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -1067,11 +1067,10 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
-  const flattened = ProviderShared.flattenToolRequest(request)
   const tools =
-    flattened.tools.length === 0
+    request.tools.length === 0
       ? undefined
-      : flattened.tools.map((tool) =>
+      : request.tools.map((tool) =>
           lowerTool(
             breakpoints,
             tool,
@@ -1089,7 +1088,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
           text: part.text,
           cache_control: cacheControl(breakpoints, part.cache),
         }))
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,

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

@@ -424,22 +424,21 @@ const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArra
 
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
   const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   const generation = request.generation
   // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
   // tools → system → messages order to favour the highest-impact prefixes.
-  const breakpoints = BedrockCache.breakpoints(request.model.id)
+  const breakpoints = BedrockCache.breakpoints()
   const toolConfig = (() => {
-    if (flattened.tools.length === 0) return undefined
+    if (request.tools.length === 0) return undefined
     return {
-      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
       // Converse has no native "none". Keep definitions stable for prompt
       // caching and omit only the unsupported choice.
       toolChoice,
     }
   })()
   const system = lowerSystem(breakpoints, request.system)
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`,

packages/ai/src/protocols/gemini.ts

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -465,8 +465,7 @@ function mapSafetySettings(value: unknown) {
 }
 
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const flattened = ProviderShared.flattenToolRequest(request)
-  const hasTools = flattened.tools.length > 0
+  const hasTools = request.tools.length > 0
   const generation = request.generation
   const options = resolveOptions(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -484,7 +483,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 
   return {
     cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(flattened.request),
+    contents: yield* lowerMessages(request),
     safetySettings: options.safetySettings,
     serviceTier: options.serviceTier,
     systemInstruction:
@@ -492,7 +491,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     tools: hasTools
       ? [
           {
-            functionDeclarations: flattened.tools.map((tool) =>
+            functionDeclarations: request.tools.map((tool) =>
               lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
             ),
           },
@@ -639,14 +638,6 @@ const step = (state: ParserState, event: GeminiEvent) => {
       : state.usage,
   }
   const candidate = event.candidates?.[0]
-  if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
-    return Effect.fail(
-      ProviderShared.eventError(
-        state.route,
-        `Gemini stopped with ${candidate.finishReason}`,
-        ProviderShared.encodeJson(event),
-      ),
-    )
   if (!candidate?.content)
     return Effect.succeed([
       { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },

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

@@ -1,133 +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.js"
-import { Auth } from "../route/auth.js"
-import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
-import { JsonObject, ProviderShared, optionalNull } from "./shared.js"
-import { ImageInputs } from "./utils/image-input.js"
-
-type OpenString<Known extends string> = Known | (string & {})
-export type ImageOptions = {
-  readonly n?: number
-  /** Aspect ratio hint, not an exact output resolution. */
-  readonly size?: string
-  readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">
-  readonly responseFormat?: OpenString<"b64_json" | "url">
-  readonly reasoningStrength?: OpenString<"low" | "high">
-  readonly toolEnablement?: {
-    readonly enable_image_search?: boolean
-    readonly enable_web_search?: boolean
-    readonly enable_shell?: boolean
-  }
-  readonly [key: string]: unknown
-}
-
-const Body = Schema.StructWithRest(
-  Schema.Struct({
-    model: Schema.String,
-    prompt: Schema.String,
-    images: Schema.optional(Schema.Array(JsonObject)),
-    n: Schema.optional(Schema.Number),
-    size: Schema.optional(Schema.String),
-    output_format: Schema.optional(Schema.String),
-    response_format: Schema.optional(Schema.String),
-    reasoning_strength: Schema.optional(Schema.String),
-    tool_enablement: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
-  }),
-  [JsonObject],
-)
-
-const Response = Schema.Struct({
-  data: Schema.Array(Schema.Struct({ b64_json: optionalNull(Schema.String), url: optionalNull(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),
-    }),
-  ),
-})
-
-export const model = (input: {
-  readonly id: string
-  readonly auth: Auth.Definition
-  readonly baseURL: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}) => {
-  const route: ImageRoute<ImageOptions> = {
-    id: "meta-images",
-    generate: Effect.fn("MetaImages.generate")(function* (request: ImageRequestFor<ImageOptions>, execute) {
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const images = yield* Effect.forEach(request.images ?? [], (image) => {
-        if (image.type === "bytes") return Effect.succeed({ image_url: ImageInputs.dataUrl(image) })
-        if (image.type === "url") return Effect.succeed({ image_url: image.url })
-        return ImageInputs.invalid("Meta Images accepts image bytes and URLs")
-      })
-      const { outputFormat, responseFormat, reasoningStrength, toolEnablement, ...native } = request.options ?? {}
-      const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-        mergeJsonRecords(
-          {
-            model: request.model.id,
-            prompt: request.prompt,
-            images: images.length === 0 ? undefined : images,
-            output_format: outputFormat,
-            response_format: responseFormat,
-            reasoning_strength: reasoningStrength,
-            tool_enablement: toolEnablement,
-          },
-          native,
-          http?.body,
-        ),
-      )
-      const body = ProviderShared.encodeJson(payload)
-      const url = new URL(`${input.baseURL.replace(/\/$/, "")}/images/${images.length === 0 ? "generations" : "edits"}`)
-      Object.entries(http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value))
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url: url.toString(),
-        body,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url.toString()).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(body, "application/json"),
-        ),
-      )
-      const output = yield* ProviderShared.imageResponse("meta-images", "Meta Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Meta Images returned an invalid response", cause)),
-      )
-      const format = decoded.output_format ?? payload.output_format ?? "webp"
-      const generated = yield* Effect.forEach(decoded.data, (item, index) => {
-        if (item.b64_json)
-          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError((cause) => output.invalid(`Meta Images result ${index} contains invalid base64`, cause)),
-            Effect.map((data) => new GeneratedImage({ mediaType: `image/${format}`, data })),
-          )
-        if (item.url) return Effect.succeed(new GeneratedImage({ mediaType: `image/${format}`, data: item.url }))
-        return output.invalid(`Meta Images result ${index} has neither image data nor a URL`)
-      })
-      if (generated.length === 0) return yield* output.invalid("Meta Images returned no images")
-      return new ImageResponse({
-        images: generated,
-        usage:
-          decoded.usage === undefined
-            ? undefined
-            : new Usage({
-                inputTokens: decoded.usage.input_tokens,
-                outputTokens: decoded.usage.output_tokens,
-                totalTokens: decoded.usage.total_tokens,
-                providerMetadata: { meta: decoded.usage },
-              }),
-        providerMetadata: { meta: { outputFormat: format } },
-      })
-    }),
-  }
-  return ImageModel.make<ImageOptions>({ id: input.id, provider: "meta", route, http: input.http })
-}
-
-export * as MetaImages from "./meta-images.js"

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

@@ -1,52 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import type { LLMRequest } from "../schema/index.js"
-import { AnthropicMessages } from "./anthropic-messages.js"
-import { MetaResponses } from "./meta-responses.js"
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
-
-const WebSearch = Schema.Struct({
-  type: Schema.Literal("web_search"),
-  name: Schema.Literal("web_search"),
-  user_location: MetaResponses.WebSearch.fields.user_location,
-})
-const Body = Schema.Struct({
-  ...AnthropicMessages.AnthropicMessagesBody.fields,
-  tools: optionalArray(
-    Schema.Union([
-      Schema.Struct({ name: Schema.String, description: Schema.String, input_schema: JsonObject }),
-      WebSearch,
-    ]),
-  ),
-})
-
-const fromRequest = Effect.fn("MetaMessages.fromRequest")(function* (request: LLMRequest) {
-  const projected = ProviderShared.flattenToolRequest(request)
-  const body = yield* AnthropicMessages.protocol.body.from(projected.request)
-  return {
-    ...body,
-    tools:
-      body.tools === undefined
-        ? undefined
-        : yield* Effect.forEach(body.tools, (tool, index) =>
-            Effect.gen(function* () {
-              const native = projected.tools[index]?.native
-              if (native === undefined) return tool
-              const search = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MetaResponses.WebSearch))(
-                native.meta,
-              )
-              if (search.search_context_size !== undefined)
-                return yield* ProviderShared.invalidRequest("Meta Messages does not support searchContextSize")
-              return { type: "web_search" as const, name: "web_search" as const, user_location: search.user_location }
-            }),
-          ),
-  }
-})
-
-export const protocol = Protocol.make({
-  id: "meta-messages",
-  body: { schema: Body, from: fromRequest },
-  stream: AnthropicMessages.protocol.stream,
-})
-
-export * as MetaMessages from "./meta-messages.js"

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

@@ -1,238 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import { HttpTransport } from "../route/transport/index.js"
-import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.js"
-import { OpenResponses } from "./open-responses.js"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
-import { MetaImage } from "./utils/meta-image.js"
-
-const ADAPTER = "meta-responses"
-const NAME = "Meta Responses"
-
-export const WebSearch = Schema.Struct({
-  type: Schema.Literal("web_search"),
-  search_context_size: Schema.optional(Schema.String),
-  user_location: Schema.optional(
-    Schema.Struct({
-      type: Schema.Literal("approximate"),
-      city: Schema.optional(Schema.String),
-      region: Schema.optional(Schema.String),
-      country: Schema.optional(Schema.String),
-      timezone: Schema.optional(Schema.String),
-    }),
-  ),
-})
-
-export const ImageGeneration = Schema.Struct({
-  type: Schema.Literal("image_generation"),
-  size: Schema.optional(Schema.String),
-  output_format: Schema.optional(Schema.String),
-  reasoning_strength: Schema.optional(Schema.String),
-  enable_image_search: Schema.optional(Schema.Boolean),
-  enable_web_search: Schema.optional(Schema.Boolean),
-  enable_shell: Schema.optional(Schema.Boolean),
-})
-
-const NativeTool = Schema.Union([WebSearch, ImageGeneration])
-const ImageItem = Schema.Struct({
-  type: Schema.Literal("image_generation_call"),
-  id: Schema.String,
-  status: Schema.optional(Schema.String),
-  result: optionalNull(Schema.String),
-  output_format: Schema.optional(Schema.String),
-  error: Schema.optional(Schema.Unknown),
-})
-
-const Body = Schema.Struct({
-  ...OpenResponses.coreFields,
-  input: Schema.Array(Schema.Union([OpenResponses.InputItem, ImageItem])),
-  tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
-  stream: Schema.Literal(true),
-})
-
-const MessageAnnotations = Schema.Struct({
-  content: Schema.Array(Schema.Struct({ annotations: optionalArray(JsonObject) })),
-})
-
-interface ParserState extends OpenResponses.ParserState {
-  readonly completedItems: ReadonlySet<string>
-}
-
-const adapter = {
-  id: ADAPTER,
-  name: NAME,
-  restoreHostedToolItem: (item: unknown) => (Schema.is(ImageItem)(item) ? item : undefined),
-} satisfies OpenResponses.ProviderAdapter
-
-const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request: LLMRequest) {
-  const key = request.model.route.providerMetadataKey ?? String(request.model.provider)
-  const projected = ProviderShared.flattenToolRequest(
-    LLMRequest.update(request, {
-      messages: request.messages.map((message) =>
-        Message.make({
-          ...message,
-          content: message.content.map((part) => {
-            if (
-              part.type !== "tool-result" ||
-              !part.providerExecuted ||
-              part.name !== "image_generation" ||
-              part.result.type !== "content" ||
-              part.providerMetadata?.[key]?.itemId !== part.id
-            )
-              return part
-            // Meta's signed image ID carries edit state; replay the handle, not the image bytes as a user message.
-            return ToolResultPart.make({
-              ...part,
-              result: {
-                type: "json",
-                value: { type: "image_generation_call", id: part.id, status: "completed", result: null },
-              },
-            })
-          }),
-        }),
-      ),
-    }),
-  )
-  return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
-    ...(yield* OpenResponses.lowerConversation(projected.request, adapter)),
-    ...OpenResponses.lowerGeneration(request),
-    tools:
-      projected.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
-            Effect.gen(function* () {
-              if (tool.native === undefined)
-                return yield* OpenResponses.lowerTool(
-                  NAME,
-                  tool,
-                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model.compatibility?.toolSchema),
-                )
-              return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta)
-            }),
-          ),
-    tool_choice:
-      OpenResponses.allowedToolChoice(request) ??
-      (request.toolChoice ? yield* OpenResponses.lowerToolChoice(NAME, request.toolChoice) : undefined),
-  })
-})
-
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  image_generation_call: {
-    name: "image_generation",
-    input: () => ({}),
-    result: Effect.fn("MetaResponses.imageResult")(function* (raw: ResponsesHostedTools.Item) {
-      const item = yield* Schema.decodeUnknownEffect(ImageItem)(raw).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(
-            ADAPTER,
-            "Meta returned an invalid image item",
-            ProviderShared.encodeJson(raw),
-            cause,
-          ),
-        ),
-      )
-      if (item.error !== undefined && item.error !== null) return { type: "error" as const, value: item.error }
-      if (!item.result)
-        return yield* ProviderShared.eventError(
-          ADAPTER,
-          "Meta returned an image without data",
-          ProviderShared.encodeJson(raw),
-        )
-      const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(
-            ADAPTER,
-            "Meta returned invalid image base64",
-            ProviderShared.encodeJson(raw),
-            cause,
-          ),
-        ),
-      )
-      const mime = MetaImage.mediaType(data, item.output_format)
-      return {
-        type: "content" as const,
-        value: [{ type: "file" as const, uri: `data:${mime};base64,${item.result}`, mime }],
-      }
-    }),
-  },
-} satisfies ResponsesHostedTools.Definitions
-
-const onEvent = Effect.fn("MetaResponses.onEvent")(function* (
-  state: OpenResponses.ParserState,
-  input: OpenResponses.Event,
-) {
-  const event = OpenResponses.normalize(state, input)
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return yield* ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
-  const result = yield* OpenResponses.step(state, event)
-  if (event.type !== "response.output_item.done" || event.item?.type !== "message") return result
-  const message = yield* Schema.decodeUnknownEffect(MessageAnnotations)(event.item).pipe(
-    Effect.mapError((cause) =>
-      ProviderShared.eventError(
-        ADAPTER,
-        "Meta returned invalid message annotations",
-        ProviderShared.encodeJson(event),
-        cause,
-      ),
-    ),
-  )
-  const annotations = message.content.flatMap((part) => part.annotations ?? [])
-  if (annotations.length === 0) return result
-  return [
-    result[0],
-    result[1].map((item) =>
-      LLMEvent.is.textEnd(item)
-        ? LLMEvent.textEnd({
-            ...item,
-            providerMetadata: {
-              ...item.providerMetadata,
-              [state.providerMetadataKey]: { ...item.providerMetadata?.[state.providerMetadataKey], annotations },
-            },
-          })
-        : item,
-    ),
-  ] satisfies OpenResponses.StepResult
-})
-
-const step = Effect.fn("MetaResponses.step")(function* (state: ParserState, input: OpenResponses.Event) {
-  const completedItems = new Set(state.completedItems)
-  const event = OpenResponses.normalize(state, input)
-  if (event.type === "response.output_item.done" && event.item && completedItems.has(event.item.id))
-    return [state, []] as const
-  const events: LLMEvent[] = []
-  let current: OpenResponses.ParserState = state
-  // Muse Image delivers its image and optional summary only in response.completed.
-  // Recover terminal-only items in order, without duplicating Spark's streamed items.
-  if (event.type === "response.completed") {
-    for (const [index, item] of (event.response?.output ?? []).entries()) {
-      const done = OpenResponses.normalize(current, { type: "response.output_item.done", item, output_index: index })
-      // Spark changes reasoning IDs in the terminal snapshot; output indices still identify the streamed items.
-      if (!done.item || completedItems.has(done.item.id) || completedItems.has(state.outputItems[index] ?? "")) continue
-      const result = yield* onEvent(current, done)
-      current = result[0]
-      events.push(...result[1])
-      completedItems.add(done.item.id)
-    }
-  }
-  const result = yield* onEvent(current, event)
-  if (event.type === "response.output_item.done" && event.item) completedItems.add(event.item.id)
-  return [{ ...result[0], completedItems }, [...events, ...result[1]]] as const
-})
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: { schema: Body, from: fromRequest },
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (request): ParserState => ({ ...OpenResponses.initial(request, adapter), completedItems: new Set() }),
-    step,
-    terminal: OpenResponses.terminal,
-  },
-})
-
-export const httpTransport = HttpTransport.sseJson.with<Schema.Schema.Type<typeof Body>>()
-
-export * as MetaResponses from "./meta-responses.js"

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

@@ -9,8 +9,6 @@ import {
   AIError,
   InvalidProviderOutputError,
   LLMEvent,
-  ProviderInternalError,
-  UnknownProviderError,
   Usage,
   type FinishReasonDetails,
   type LLMRequest,
@@ -416,11 +414,10 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         tool: (name) => ({ type: "function" as const, function: { name } }),
       })
     : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request),
-    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+    messages: yield* lowerMessages(request),
+    tools: request.tools.length > 0 ? request.tools.map(lowerTool) : undefined,
     tool_choice: toolChoice,
     stream: true as const,
     max_tokens: request.generation?.maxTokens,
@@ -702,16 +699,6 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     normalized: mapFinishReason(choice.finish_reason),
     raw: choice.finish_reason,
   }
-  if (finishReason.normalized === "error") {
-    const details = {
-      message: `Mistral Chat stopped with ${finishReason.raw}`,
-      body: ProviderShared.encodeJson(event),
-    }
-    return yield* new AIError({
-      reason:
-        finishReason.raw === "network_error" ? new ProviderInternalError(details) : new UnknownProviderError(details),
-    })
-  }
   const incomplete = finishReason.normalized === "length" || finishReason.normalized === "content-filter"
   if (!incomplete && Object.keys(withTools.pendingTools).length > 0)
     return yield* ProviderShared.eventError(

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

@@ -113,8 +113,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
           responseID = created
           return { type: "frame", frame }
         }
-        // Keepalives and provider notifications carry no response state and may precede response.created.
-        if (!event.type.startsWith("response.")) return { type: "frame", frame }
+        // Keepalives carry no response state and may arrive before response.created.
+        if (event.type === "keepalive") return { type: "frame", frame }
         if (!responseID)
           return yield* ProviderShared.eventError(
             options.id,

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

@@ -42,7 +42,6 @@ const canonical = (value: unknown): string => {
   if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`
   if (!ProviderShared.isRecord(value)) return ProviderShared.encodeJson(value)
   return `{${Object.keys(value)
-    .filter((key) => value[key] !== undefined)
     .sort()
     .map((key) => `${ProviderShared.encodeJson(key)}:${canonical(value[key])}`)
     .join(",")}}`
@@ -58,12 +57,7 @@ const comparable = (value: unknown) => {
   if (value.type === "message" && value.role === "assistant")
     return {
       role: "assistant",
-      // Annotations and logprobs describe the response, not the text replayed in model input.
-      content: Array.isArray(value.content)
-        ? value.content.map((part) =>
-            ProviderShared.isRecord(part) && part.type === "output_text" ? { type: part.type, text: part.text } : part,
-          )
-        : value.content,
+      content: value.content,
       ...(value.phase === undefined ? {} : { phase: value.phase }),
     }
   if (value.type === "function_call")
@@ -127,7 +121,7 @@ const rejected = (
 
 export const driver = (input: DriverInput): WebSocketChannelDriver => {
   const { previous_response_id: _previousResponseID, ...request } = input.request
-  let output: OpenResponses.StreamItem[] = []
+  let output: unknown[] = []
   return {
     create: (checkpoint) =>
       Effect.sync(() => {
@@ -155,12 +149,6 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
           if (rejection === "websocket_connection_limit_reached") return rejected(observation, "rotate-and-retry-full")
         }
         if (observation.type !== "completed") return observation
-        // A trigger installs a different context window. Clear the append baseline, retaining the socket.
-        if (
-          Array.isArray(request.input) &&
-          request.input.some((item) => ProviderShared.isRecord(item) && item.type === "compaction_trigger")
-        )
-          return observation
         const responseID = event.response?.id
         if (!responseID || responseID.trim().length === 0) return observation
         return {
@@ -171,14 +159,7 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
               version: VERSION,
               responseID,
               request,
-              // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
-              output: event.response?.output
-                ? event.response.output.map((item) =>
-                    item.type === "reasoning" && item.id !== undefined
-                      ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
-                      : item,
-                  )
-                : output.slice(),
+              output: event.response?.output ? [...event.response.output] : output.slice(),
             } satisfies CheckpointValue,
           },
         }

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

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import type { Content } from "@opencode/schema/tool"
+import type { Content } from "@opencode-ai/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
@@ -189,7 +189,6 @@ export const InputItem = Schema.Union([
     id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
   }),
   Schema.Struct({
@@ -316,7 +315,6 @@ export const StreamItem = Schema.StructWithRest(
     id: Schema.optional(Schema.String),
     call_id: Schema.optional(Schema.String),
     name: Schema.optional(Schema.String),
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
   }),
@@ -490,7 +488,6 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     ...(id === undefined ? {} : { id }),
     call_id: part.id,
     name: part.name,
-    namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
   }
 }
@@ -810,15 +807,14 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
   request: LLMRequest,
   adapter: ProviderAdapter,
 ) {
-  const projected = ProviderShared.flattenToolRequest(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(projected.request, adapter)),
+    ...(yield* lowerConversation(request, adapter)),
     ...lowerGeneration(request),
     tools:
-      projected.tools.length === 0
+      request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
+        : yield* Effect.forEach(request.tools, (tool) =>
             lowerTool(
               adapter.name,
               tool,
@@ -923,7 +919,7 @@ const joinReasoningText = (parts: ReadonlyArray<string | undefined>) => {
   return parts.filter((part) => part !== undefined).join("\n\n")
 }
 
-const outputItemID = (state: Pick<ParserState, "outputItems">, event: Event) =>
+const outputItemID = (state: ParserState, event: Event) =>
   event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)
 
 const ITEM_ID_PREFIX: Readonly<Record<string, string>> = {
@@ -935,11 +931,7 @@ const ITEM_ID_PREFIX: Readonly<Record<string, string>> = {
 
 // An item without an id adopts the id already open in its output slot,
 // otherwise it gets a locally minted one.
-const resolveItem = (
-  state: Pick<ParserState, "outputItems">,
-  item: StreamItem,
-  index: number | undefined,
-): OutputItem => ({
+const resolveItem = (state: ParserState, item: StreamItem, index: number | undefined): OutputItem => ({
   ...item,
   id:
     item.id ??
@@ -949,7 +941,7 @@ const resolveItem = (
 
 // Registered output slots are authoritative for `item_id` routing, and items
 // are resolved here so everything downstream can rely on `item.id`.
-export const normalize = (state: Pick<ParserState, "outputItems">, input: Event): NormalizedEvent => ({
+export const normalize = (state: ParserState, input: Event): NormalizedEvent => ({
   ...input,
   item_id: input.item_id === undefined ? undefined : outputItemID(state, input),
   item: input.item ? resolveItem(state, input.item, input.output_index) : input.item,
@@ -1102,20 +1094,11 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       tools: ToolStream.start(state.tools, item.id, {
         id: item.call_id,
         name: item.name ?? "",
-        namespace: item.namespace,
         input: item.arguments ?? "",
         providerMetadata: metadata,
       }),
     },
-    [
-      ...events,
-      LLMEvent.toolInputStart({
-        id: item.call_id,
-        name: item.name ?? "",
-        namespace: item.namespace,
-        providerMetadata: metadata,
-      }),
-    ],
+    [...events, LLMEvent.toolInputStart({ id: item.call_id, name: item.name ?? "", providerMetadata: metadata })],
   ]
 }
 
@@ -1234,12 +1217,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const registered = state.tools[item.id] !== undefined
     const tools = registered
       ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          namespace: item.namespace,
-          providerMetadata: metadata,
-        })
+      : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name, providerMetadata: metadata })
     const result =
       item.arguments === undefined
         ? yield* ToolStream.finish(state.id, tools, item.id)
@@ -1250,15 +1228,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const resultEvents =
       registered || finished.length === 0
         ? finished
-        : [
-            LLMEvent.toolInputStart({
-              id: item.call_id,
-              name: item.name,
-              namespace: item.namespace,
-              providerMetadata: metadata,
-            }),
-            ...finished,
-          ]
+        : [LLMEvent.toolInputStart({ id: item.call_id, name: item.name, providerMetadata: metadata }), ...finished]
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [

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

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -736,7 +736,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
     )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const flattened = ProviderShared.flattenToolRequest(request)
   const provider = String(request.model.provider)
   const baseURL = request.model.route.endpoint.baseURL
   const detectedMaxTokensField = detectMaxTokensField(provider, baseURL)
@@ -749,16 +748,16 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const zaiToolStream =
     request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
   const hasHistory = hasToolHistory(request.messages)
-  const hasActiveTools = flattened.tools.length > 0
+  const hasActiveTools = request.tools.length > 0
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request, options),
+    messages: yield* lowerMessages(request, options),
     tools:
-      flattened.tools.length === 0
+      request.tools.length === 0
         ? hasHistory
           ? []
           : undefined
-        : flattened.tools.map((tool) =>
+        : request.tools.map((tool) =>
             lowerTool(
               tool,
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),

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

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import { LLMRequest, mergeJsonRecords, type JsonSchema, type ToolDefinition, type ToolEntry } from "../schema/index.js"
+import type { LLMRequest, JsonSchema, ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
@@ -13,7 +13,6 @@ import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
 import { ResponsesCompaction } from "./utils/responses-compaction.js"
-import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -76,18 +75,7 @@ const OpenAIResponsesHostedToolItem = Schema.Union([
   ),
 ])
 
-const OpenAIResponsesNamespace = Schema.Struct({
-  type: Schema.tag("namespace"),
-  name: Schema.String,
-  description: Schema.String,
-  tools: Schema.Array(OpenResponses.Tool),
-})
-
-const OpenAIResponsesTools = Schema.Union([
-  OpenResponses.Tool,
-  OpenAIResponsesNamespace,
-  OpenAIResponsesImageGenerationTool,
-])
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
 
 const OpenAIResponsesToolChoice = Schema.Union([
   OpenResponses.ToolChoice,
@@ -115,18 +103,6 @@ const OpenAIResponsesBody = Schema.Struct({
 })
 export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 
-/** Request control, never conversation content. */
-export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compaction_trigger") })
-const CheckpointBody = Schema.Struct({
-  ...OpenAIResponsesBody.fields,
-  input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem, CompactionTrigger])),
-  store: Schema.Literal(false),
-  prompt_cache_retention: optionalNull(Schema.String),
-  prompt_cache_options: optionalNull(
-    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
-  ),
-})
-
 const adapter = {
   id: ADAPTER,
   name: NAME,
@@ -152,33 +128,13 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDe
   return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })
 
-// Native namespaces hold only function tools, so deeper levels flatten into
-// the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
-  tool: ToolEntry,
-  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
-) {
-  if (tool.type === "tool")
-    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
-  // OpenAI requires a namespace description; fall back to a generic one so a
-  // missing description never blocks the request.
-  return {
-    type: "namespace" as const,
-    name: tool.name,
-    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
-      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
-    ),
-  }
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
+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.type === "tool" && tool.name === name && nativeImageTool(tool) !== undefined)
+      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
         ? ({ type: "image_generation" } as const)
         : { type: "function" as const, name },
   })
@@ -197,42 +153,15 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
     tools:
       request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
+        : yield* Effect.forEach(request.tools, (tool) =>
+            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
+          ),
     tool_choice:
       OpenResponses.allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
-const checkpointBody = {
-  schema: CheckpointBody,
-  from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request: LLMRequest) {
-    const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }))
-    const overlay = request.http?.body
-    // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
-    if (
-      overlay?.input !== undefined ||
-      overlay?.previous_response_id !== undefined ||
-      overlay?.conversation !== undefined
-    )
-      return yield* ProviderShared.invalidRequest(
-        "Trigger compaction requires complete canonical history, not an input or continuation override",
-      )
-    return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
-      ...mergeJsonRecords(native, overlay),
-      input: [...native.input, { type: "compaction_trigger" }],
-      stream: true,
-      store: false,
-      parallel_tool_calls: true,
-      tool_choice: undefined,
-      context_management: undefined,
-      text: undefined,
-      max_output_tokens: undefined,
-      max_tool_calls: undefined,
-    })
-  }),
-}
-
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: ResponsesHostedTools.Item) {
   const isError = item.error !== undefined && item.error !== null
   if (item.type === "image_generation_call" && item.result) {
@@ -310,7 +239,7 @@ export const transport = channelTransport({
 })
 
 export const route = Route.make({
-  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
+  compact: ResponsesCompaction.make(adapter),
   id: ADAPTER,
   provider: "openai",
   providerMetadataKey: "openai",

packages/ai/src/protocols/shared.ts

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import * as Sse from "effect/unstable/encoding/Sse"
 import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
@@ -9,14 +9,11 @@ import {
   UnsupportedOperationError,
   AIError,
   HttpContext,
-  LLMRequest,
-  Message,
-  ToolDefinition,
   type ContentPart,
+  type LLMRequest,
   type MediaPart,
   type ProviderID,
   type TextPart,
-  type ToolEntry,
   type ToolResultPart,
 } from "../schema/index.js"
 import { isRecord } from "../utils/record.js"
@@ -49,7 +46,6 @@ export const promptCacheKey = (request: LLMRequest): string | undefined => {
 export interface ToolAccumulator {
   readonly id: string
   readonly name: string
-  readonly namespace?: string
   readonly input: string
 }
 
@@ -283,38 +279,6 @@ export const unsupportedOperation = (input: {
     }),
   })
 
-/**
- * Lower namespaces to flat definitions for protocols without a native
- * namespace construct. Leaf names join their namespace path with `_` because
- * `.` is not broadly accepted in provider tool names.
- */
-export const flattenTools = (tools: ReadonlyArray<ToolEntry>, path: ReadonlyArray<string> = []) => {
-  const flat = tools.flatMap((tool): ReadonlyArray<ToolDefinition> => {
-    if (tool.type === "namespace") return flattenTools(tool.tools, [...path, tool.name])
-    if (path.length === 0) return [tool]
-    return [new ToolDefinition({ ...tool, name: [...path, tool.name].join("_") })]
-  })
-  return [...new Map(flat.map((tool) => [tool.name, tool])).values()]
-}
-
-export const flattenToolRequest = (request: LLMRequest) => {
-  const messages = request.messages.map((message) => {
-    const content = message.content.map((part) => {
-      if ((part.type !== "tool-call" && part.type !== "tool-result") || part.namespace === undefined) return part
-      return { ...part, name: `${part.namespace}_${part.name}`, namespace: undefined }
-    })
-    return content.every((part, index) => part === message.content[index])
-      ? message
-      : new Message({ ...message, content })
-  })
-  return {
-    tools: flattenTools(request.tools),
-    request: messages.every((message, index) => message === request.messages[index])
-      ? request
-      : LLMRequest.update(request, { messages }),
-  }
-}
-
 export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
   route: string,
   name: string,

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

@@ -2,12 +2,13 @@ import { AwsV4Signer } from "aws4fetch"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Auth, type AuthInput } from "../../route/auth.js"
-import { AIError, AuthenticationError } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"
 
 /**
  * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
- * which provider facades configure as route auth instead of SigV4.
+ * which provider facades configure as route auth instead of SigV4. STS-vended
+ * credentials should be refreshed by the consumer (rebuild the model) before
+ * they expire; the route does not refresh.
  */
 export interface Credentials {
   readonly region: string
@@ -16,44 +17,6 @@ export interface Credentials {
   readonly sessionToken?: string
 }
 
-/** Static credentials or an effect resolved before every request. */
-export type CredentialSource = Credentials | Effect.Effect<Credentials, AIError>
-
-export interface DefaultChainOptions {
-  readonly region: string
-  /** Shared config profile passed to the AWS default chain. */
-  readonly profile?: string
-}
-
-/**
- * Resolve credentials through the AWS default provider chain: environment
- * variables, shared config and SSO caches, web identity tokens, process
- * credentials, and container or instance metadata. A fresh chain runs on every
- * request so credentials rotated on disk without an expiration (for example
- * shared-config keys rewritten by a corporate SSO tool) are always re-read;
- * the SDK's own memoization would otherwise pin them for the process lifetime.
- */
-export const defaultChain = (options: DefaultChainOptions): Effect.Effect<Credentials, AIError> =>
-  Effect.tryPromise({
-    try: async () => {
-      const { fromNodeProviderChain } = await import("@aws-sdk/credential-providers")
-      const identity = await fromNodeProviderChain(options.profile === undefined ? {} : { profile: options.profile })()
-      return {
-        region: options.region,
-        accessKeyId: identity.accessKeyId,
-        secretAccessKey: identity.secretAccessKey,
-        ...(identity.sessionToken === undefined ? {} : { sessionToken: identity.sessionToken }),
-      }
-    },
-    catch: (error) =>
-      new AIError({
-        reason: new AuthenticationError({
-          message: `AWS default credential chain failed: ${ProviderShared.errorText(error)}`,
-          cause: error,
-        }),
-      }),
-  })
-
 const signRequest = (input: {
   readonly url: string
   readonly body: string
@@ -85,17 +48,16 @@ const signRequest = (input: {
 
 /** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
 export const sigV4 = (
-  source: CredentialSource | undefined,
+  credentials: Credentials | undefined,
   options: { readonly service?: string; readonly name?: string } = {},
 ) =>
   Auth.custom((input: AuthInput) => {
     return Effect.gen(function* () {
-      if (!source) {
+      if (!credentials) {
         return yield* ProviderShared.invalidRequest(
           `${options.name ?? "Bedrock Converse"} requires either route bearer auth or AWS credentials configured on the route`,
         )
       }
-      const credentials = Effect.isEffect(source) ? yield* source : source
       const headersForSigning = Headers.set(input.headers, "content-type", "application/json")
       const signed = yield* signRequest({
         url: input.url,
@@ -112,35 +74,4 @@ export const sigV4 = (
 /** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
 export const auth = sigV4(undefined)
 
-export const resolveRegion = (input: {
-  readonly region?: string
-  readonly credentials?: { readonly region: string }
-}) =>
-  input.region ?? input.credentials?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1"
-
-export interface ResolveAuthInput {
-  readonly apiKey?: string
-  readonly credentials?: Credentials
-  readonly profile?: string
-}
-
-export interface ResolveAuthOptions {
-  readonly service?: string
-  readonly name?: string
-  /** `sigv4` ignores an ambient `AWS_BEARER_TOKEN_BEDROCK`; `bearer` is validated by the caller. */
-  readonly mode?: "bearer" | "sigv4"
-}
-
-/**
- * Bearer wins over SigV4 and explicit static credentials win over the default
- * chain, matching the AWS SDK's own precedence for `AWS_BEARER_TOKEN_BEDROCK`.
- * The region is applied to the SigV4 scope so it always matches the endpoint host.
- */
-export const resolveAuth = (input: ResolveAuthInput, region: string, options: ResolveAuthOptions = {}) => {
-  const apiKey = options.mode === "sigv4" ? undefined : (input.apiKey ?? process.env.AWS_BEARER_TOKEN_BEDROCK)
-  if (apiKey !== undefined) return Auth.bearer(apiKey)
-  if (input.credentials !== undefined) return sigV4({ ...input.credentials, region }, options)
-  return sigV4(defaultChain({ region, profile: input.profile }), options)
-}
-
 export * as BedrockAuth from "./bedrock-auth.js"

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

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import type { CacheHint } from "../../schema/index.js"
-import { newBreakpoints, ttlBucket } from "./cache.js"
+import { newBreakpoints, ttlBucket, type Breakpoints } from "./cache.js"
 
 // Bedrock cache markers are positional: emit a `cachePoint` block immediately
 // after the content the caller wants treated as a cacheable prefix. Bedrock
@@ -13,46 +13,24 @@ export const CachePointBlock = Schema.Struct({
 })
 export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>
 
-const LEGACY_CLAUDE = ["anthropic.claude-instant", "anthropic.claude-v1", "anthropic.claude-v2", "anthropic.claude-3-"]
-
-// These legacy Claude releases support explicit caching, but only for five minutes.
-const CLAUDE_5M = [
-  "anthropic.claude-3-5-sonnet-20241022-v2:0",
-  "anthropic.claude-3-5-haiku-20241022-v1:0",
-  "anthropic.claude-3-7-sonnet-20250219-v1:0",
-  "anthropic.claude-sonnet-4-20250514-v1:0",
-  "anthropic.claude-opus-4-20250514-v1:0",
-  "anthropic.claude-opus-4-1-20250805-v1:0",
-]
-
-// Callers share the four-breakpoint budget across system, messages, and tools.
+// Callers pass a shared counter through every `block()` call site so the
+// four-breakpoint budget is respected across `system`, `messages`, and `tools`.
 export const BEDROCK_BREAKPOINT_CAP = 4
 
-export const breakpoints = (modelID: string) => {
-  // Substring matching also handles regional prefixes and model-bearing ARNs.
-  const short = CLAUDE_5M.some((id) => modelID.includes(id))
-  return {
-    ...newBreakpoints(BEDROCK_BREAKPOINT_CAP),
-    // Assume modern Claude releases retain caching support; older generations need an explicit exception.
-    // Other model families use implicit caching where available.
-    supported: modelID.includes("anthropic.claude-") && (short || !LEGACY_CLAUDE.some((id) => modelID.includes(id))),
-    ttl1h: !short,
-  }
-}
-export type Breakpoints = ReturnType<typeof breakpoints>
+export type { Breakpoints } from "./cache.js"
+export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP)
 
 const DEFAULT_5M: CachePointBlock = { cachePoint: { type: "default" } }
 const DEFAULT_1H: CachePointBlock = { cachePoint: { type: "default", ttl: "1h" } }
 
 export const block = (breakpoints: Breakpoints, cache: CacheHint | undefined): CachePointBlock | undefined => {
-  if (!breakpoints.supported) return undefined
   if (cache?.type !== "ephemeral" && cache?.type !== "persistent") return undefined
   if (breakpoints.remaining <= 0) {
     breakpoints.dropped += 1
     return undefined
   }
   breakpoints.remaining -= 1
-  return breakpoints.ttl1h && ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
+  return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
 }
 
 export * as BedrockCache from "./bedrock-cache.js"

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

@@ -1,11 +0,0 @@
-// Responses image items can omit output_format, including when PNG/JPEG was requested.
-export const mediaType = (data: Uint8Array, format?: string) => {
-  if (format !== undefined) return `image/${format}`
-  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png"
-  if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg"
-  if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
-    return "image/webp"
-  return "application/octet-stream"
-}
-
-export * as MetaImage from "./meta-image.js"

packages/ai/src/protocols/utils/responses-checkpoint.ts

@@ -1,122 +0,0 @@
-import { Effect, Schema, Stream } from "effect"
-import { Route, type RouteBody, type TriggerCompactOperation } from "../../route/client.js"
-import { Protocol } from "../../route/protocol.js"
-import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { ProviderShared } from "../shared.js"
-
-interface State {
-  readonly parser: Pick<OpenResponses.ParserState, "id" | "provider" | "outputItems">
-  readonly checkpoints: Readonly<Record<string, CompactionCheckpointResponse["checkpoint"]>>
-  readonly responseID?: string
-}
-
-const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (
-  state: State,
-  input: OpenResponses.Event,
-) {
-  const event = OpenResponses.normalize(state.parser, input)
-  const item = event.item
-  if (!item) return state
-  const parser =
-    event.output_index === undefined || state.parser.outputItems[event.output_index] === item.id
-      ? state.parser
-      : { ...state.parser, outputItems: { ...state.parser.outputItems, [event.output_index]: item.id } }
-  const next = parser === state.parser ? state : { ...state, parser }
-  if (event.type === "response.output_item.added" || item.type !== "compaction") return next
-  if (
-    event.output_index !== undefined &&
-    Object.entries(state.parser.outputItems).some(
-      ([index, id]) => id === item.id && Number(index) !== event.output_index,
-    )
-  )
-    return yield* ProviderShared.eventError(parser.id, "Compaction checkpoint appeared in multiple output slots")
-  if (!item.encrypted_content)
-    return yield* ProviderShared.eventError(parser.id, "Compaction output is missing its encrypted content")
-  const previous = state.checkpoints[item.id]
-  if (previous && previous.encrypted !== item.encrypted_content)
-    return yield* ProviderShared.eventError(parser.id, "Compaction output changed after completion")
-  if (previous) return next
-  return {
-    ...next,
-    checkpoints: {
-      ...state.checkpoints,
-      [item.id]: { type: "compaction", provider: parser.provider, id: item.id, encrypted: item.encrypted_content },
-    },
-  } satisfies State
-})
-
-/** Collect a trigger response before acknowledging transport completion. No generation output escapes. */
-export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
-  Effect.fn("ResponsesCheckpoint.execute")(function* (request, executor, options) {
-    const source = request.model.route
-    let result: CompactionCheckpointResponse | undefined
-    // Route registries erase the frame type. The codec validates that boundary before parsing.
-    const event: Schema.Codec<OpenResponses.Event, unknown> = OpenResponses.protocol.stream.event
-    const protocol = Protocol.make({
-      id: source.protocol,
-      body,
-      stream: {
-        event,
-        initial: (request: LLMRequest): State => ({
-          parser: { id: source.id, provider: request.model.provider, outputItems: {} },
-          checkpoints: {},
-        }),
-        terminal: OpenResponses.terminal,
-        step: Effect.fn("ResponsesCheckpoint.step")(function* (state: State, event: OpenResponses.Event) {
-          if (event.response?.id && state.responseID && event.response.id !== state.responseID)
-            return yield* ProviderShared.eventError(source.id, "Compaction response ID changed during execution")
-          if (event.type === "response.created") return [{ ...state, responseID: event.response?.id }, []] as const
-          if (event.type === "error" || event.type === "response.failed")
-            return yield* OpenResponses.providerFailure(event, "Compaction request failed")
-          if (event.type === "response.incomplete")
-            return yield* ProviderShared.eventError(source.id, "Compaction response was incomplete")
-          if (event.type === "response.output_item.added" || event.type === "response.output_item.done")
-            return [yield* onOutputItem(state, event), []] as const
-          if (event.type !== "response.completed") return [state, []] as const
-          const responseID = event.response?.id
-          if (!responseID?.trim())
-            return yield* ProviderShared.eventError(source.id, "Compaction response is missing its response ID")
-          if (event.response?.status !== undefined && event.response.status !== "completed")
-            return yield* ProviderShared.eventError(source.id, "Compaction response did not complete successfully")
-          let next = state
-          for (const [index, item] of (event.response?.output ?? []).entries()) {
-            next = yield* onOutputItem(next, { type: "response.output_item.done", output_index: index, item })
-          }
-          const checkpoints = Object.values(next.checkpoints)
-          const checkpoint = checkpoints[0]
-          if (checkpoints.length !== 1 || !checkpoint)
-            return yield* ProviderShared.eventError(
-              source.id,
-              "Compaction response must contain exactly one checkpoint",
-            )
-          result = new CompactionCheckpointResponse({
-            checkpoint,
-            responseID,
-            usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
-          })
-          return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]] as const
-        }),
-      },
-    })
-    const route = Route.make({
-      id: source.id,
-      provider: source.provider,
-      providerMetadataKey: source.providerMetadataKey,
-      protocol,
-      endpoint: source.endpoint,
-      auth: source.auth,
-      transport: source.transport,
-    })
-    const native = yield* body.from(request)
-    // The body builder already applied and validated overlays. Do not let transport reapply them.
-    const preparedRequest = LLMRequest.update(request, {
-      http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-    })
-    const prepared = yield* route.prepareTransport(native, preparedRequest, options)
-    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain)
-    if (!result) return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint")
-    return result
-  })
-
-export * as ResponsesCheckpoint from "./responses-checkpoint.js"

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

@@ -55,7 +55,6 @@ const inputStart = (tool: PendingTool) =>
   LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
   })
@@ -64,7 +63,6 @@ const inputDelta = (tool: PendingTool, text: string) =>
   LLMEvent.toolInputDelta({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     text,
     input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
   })
@@ -87,7 +85,6 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
         LLMEvent.toolCall({
           id: tool.id,
           name: tool.name,
-          namespace: tool.namespace,
           input,
           providerExecuted: tool.providerExecuted ? true : undefined,
           providerMetadata: tool.providerMetadata,
@@ -97,12 +94,7 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
 }
 
 const finishEvents = (tool: PendingTool, event: ToolCall): ReadonlyArray<LLMEvent> => [
-  LLMEvent.toolInputEnd({
-    id: tool.id,
-    name: tool.name,
-    namespace: tool.namespace,
-    providerMetadata: tool.providerMetadata,
-  }),
+  LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
   event,
 ]
 
@@ -158,7 +150,6 @@ export const appendOrStart = <K extends StreamKey>(
   const tool = {
     id,
     name,
-    namespace: current?.namespace,
     input: `${current?.input ?? ""}${delta.text}`,
     providerExecuted: current?.providerExecuted,
     providerMetadata: current?.providerMetadata,

packages/ai/src/provider-package.ts

@@ -1,5 +1,5 @@
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
-import type { CompactionOperations } from "./route/client.js"
+import type { CompactOperation } from "./route/client.js"
 
 export interface Settings extends Readonly<Record<string, unknown>> {
   readonly baseURL?: string
@@ -10,7 +10,7 @@ export interface Settings extends Readonly<Record<string, unknown>> {
 export interface Definition<
   ProviderSettings extends Settings = Settings,
   Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
+  Compact extends CompactOperation | undefined = CompactOperation | undefined,
 > {
   readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options, Compact>
 }

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

@@ -1,3 +1,4 @@
+import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
@@ -9,15 +10,9 @@ import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-opt
 export const id = ProviderID.make("amazon-bedrock")
 
 export type Config = RouteDefaultsInput & {
-  /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
   readonly apiKey?: string
-  /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
-  readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
-  /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
   readonly credentials?: Credentials
-  /** Shared config profile for the default credential chain. */
-  readonly profile?: string
   readonly region?: string
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
@@ -27,7 +22,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
   readonly credentials?: Credentials
-  readonly profile?: string
   readonly region?: string
   readonly topP?: number
   readonly providerOptions?: OpenAIProviderOptionsInput
@@ -53,35 +47,23 @@ const chatRoute = OpenAIChat.route.with({
 export const routes = [responsesRoute, chatRoute]
 
 const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) => {
-  const region = BedrockAuth.resolveRegion(input)
+  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: BedrockAuth.resolveAuth(input, region, {
-      service: "bedrock-mantle",
-      name: "Bedrock Mantle",
-      mode: input.auth,
-    }),
+    auth:
+      input.apiKey === undefined
+        ? BedrockAuth.sigV4(credentials, { service: "bedrock-mantle", name: "Bedrock Mantle" })
+        : Auth.bearer(input.apiKey),
   })
 }
 
 const defaults = (input: Config) => {
-  const {
-    apiKey: _,
-    auth: _auth,
-    baseURL: _baseURL,
-    credentials: _credentials,
-    profile: _profile,
-    region: _region,
-    ...rest
-  } = input
+  const { apiKey: _, baseURL: _baseURL, credentials: _credentials, region: _region, ...rest } = input
   return rest
 }
 
 export const configure = (input: Config = {}) => {
-  if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
-  if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   const configuredResponsesRoute = configuredRoute(responsesRoute, input)
   const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)
@@ -105,26 +87,29 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const fromSettings = (settings: Settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    auth: settings.auth,
+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,
     generation: settings.topP === undefined ? undefined : { topP: settings.topP },
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    profile: settings.profile,
     providerOptions: settings.providerOptions,
     region: settings.region,
-  })
+  }
+}
 
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,
-) => fromSettings(settings).chat(modelID)
+) => configure(config(settings)).chat(modelID)
 export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,
-) => fromSettings(settings).responses(modelID)
+) => configure(config(settings)).responses(modelID)
 export const model = responsesModel

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

@@ -1,23 +1,17 @@
 import type { RouteDefaultsInput } from "../route/client.js"
+import { Auth } from "../route/auth.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
-import { BedrockAuth } from "../protocols/utils/bedrock-auth.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 
 export type Config = RouteDefaultsInput & {
-  /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
   readonly apiKey?: string
-  /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
-  readonly auth?: "bearer" | "sigv4"
   readonly headers?: Record<string, string>
-  /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
   readonly credentials?: BedrockCredentials
-  /** Shared config profile for the default credential chain. */
-  readonly profile?: string
-  /** AWS region. Falls back to `credentials.region`, `AWS_REGION`, `AWS_DEFAULT_REGION`, then `us-east-1`. */
+  /** 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
@@ -28,7 +22,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
   readonly credentials?: BedrockCredentials
-  readonly profile?: string
   readonly region?: string
   readonly topP?: number
 }
@@ -37,17 +30,14 @@ export const routes = [BedrockConverse.route]
 const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
 
 const configuredRoute = (input: Config) => {
-  const { apiKey, auth, credentials, profile, region, baseURL, ...rest } = input
-  if (auth === "bearer" && apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (auth === "sigv4" && apiKey !== undefined) throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
-  const resolvedRegion = BedrockAuth.resolveRegion(input)
+  const { apiKey, credentials, region, baseURL, ...rest } = input
+  const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
   return BedrockConverse.route.with({
     ...rest,
     provider: id,
     providerMetadataKey: "bedrock",
     endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
-    auth: BedrockAuth.resolveAuth({ apiKey, credentials, profile }, resolvedRegion, { mode: auth }),
+    auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
   })
 }
 
@@ -61,15 +51,18 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    auth: settings.auth,
+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 } },
-    profile: settings.profile,
     region: settings.region,
   }).model(modelID)
+}

packages/ai/src/providers/azure.ts

@@ -1,7 +1,7 @@
 import { Headers } from "effect/unstable/http"
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
+import type { Route, RouteDefaultsInput, CompactOperation } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -39,7 +39,6 @@ export type Settings = ProviderPackage.Settings &
 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
 
 const responsesRoute = OpenAIResponses.route.with({
-  compact: { endpoint: OpenAIResponses.route.compact.endpoint },
   id: "azure-openai-responses",
   provider: id,
   auth: routeAuth,
@@ -103,7 +102,7 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactionOperations | undefined>(
+const configuredRoute = <Body, Prepared, Compact extends CompactOperation | undefined>(
   route: Route<Body, Prepared, Compact>,
   input: Config,
   modelID: string | ModelID,
@@ -169,7 +168,7 @@ const config = (settings: Settings): Config => {
 export const responsesModel: ProviderPackage.Definition<
   Settings,
   OpenAIProviderOptionsInput,
-  typeof responsesRoute.compact
+  CompactOperation
 >["model"] = (modelID, settings) => configure(config(settings)).responses(modelID)
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,

packages/ai/src/providers/baseten.ts

@@ -1,60 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("baseten")
-const baseURL = "https://inference.baseten.co/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "baseten-chat",
-  provider: id,
-  providerMetadataKey: "baseten",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "BASETEN_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = 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 } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Baseten from "./baseten.js"

packages/ai/src/providers/cerebras.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cerebras")
-const baseURL = "https://api.cerebras.ai/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,22 +20,19 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "cerebras-chat",
   provider: id,
-  providerMetadataKey: "cerebras",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.cerebras.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.cerebras.baseURL },
     auth: AuthOptions.bearer(input, "CEREBRAS_API_KEY"),
   })
   return {

packages/ai/src/providers/cloudflare-ai-gateway.ts

@@ -1,98 +0,0 @@
-import type { Config, Redacted } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { Auth } from "../route/auth.js"
-import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("cloudflare-ai-gateway")
-export const authEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
-
-type GatewayURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}> & {
-  readonly gatewayId?: string
-}
-
-export type LanguageModelOptions = GatewayURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
-    readonly gatewayApiKey?: string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  GatewayURL & {
-    readonly apiKey?: string
-    readonly gatewayApiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const baseURL = (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 auth = (input: LanguageModelOptions) => {
-  if ("auth" in input && input.auth) return input.auth
-  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
-    .orElse(Auth.config(authEnvVars[0]))
-    .orElse(Auth.config(authEnvVars[1]))
-    .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 route = Route.make({
-  id: "cloudflare-ai-gateway",
-  provider: id,
-  providerMetadataKey: "cloudflare-ai-gateway",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions) => {
-  const {
-    accountId: _accountId,
-    gatewayId: _gatewayId,
-    apiKey: _apiKey,
-    gatewayApiKey: _gatewayApiKey,
-    baseURL: _baseURL,
-    auth: _auth,
-    ...defaults
-  } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: baseURL(input) },
-    auth: auth(input),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = { id, configure }
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    gatewayApiKey: settings.gatewayApiKey,
-    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"

packages/ai/src/providers/cloudflare-workers-ai.ts

@@ -1,71 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("cloudflare-workers-ai")
-export const authEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
-
-type WorkersAIURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}>
-
-export type LanguageModelOptions = WorkersAIURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  WorkersAIURL & {
-    readonly apiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const baseURL = (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`
-}
-
-export const route = Route.make({
-  id: "cloudflare-workers-ai",
-  provider: id,
-  providerMetadataKey: "cloudflare-workers-ai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions) => {
-  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: baseURL(input) },
-    auth: AuthOptions.bearer(input, authEnvVars),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = { id, configure }
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"

packages/ai/src/providers/cloudflare.ts

@@ -0,0 +1,133 @@
+import type { Config, Redacted } from "effect"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import { Auth } from "../route/auth.js"
+import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+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/deepinfra.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("deepinfra")
-const baseURL = "https://api.deepinfra.com/v1/openai"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,24 +20,21 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "deepinfra-chat",
   provider: id,
-  providerMetadataKey: "deepinfra",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.deepinfra.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const root = endpoint?.replace(/\/+$/, "")
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const root = baseURL?.replace(/\/+$/, "")
   const configured = route.with({
     ...defaults,
     endpoint: {
-      baseURL: root === undefined ? baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
+      baseURL: root === undefined ? profiles.deepinfra.baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
     },
     auth: AuthOptions.bearer(input, "DEEPINFRA_API_KEY"),
   })

packages/ai/src/providers/deepseek.ts

@@ -1,64 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("deepseek")
-const baseURL = "https://api.deepseek.com/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "deepseek-chat",
-  provider: id,
-  providerMetadataKey: "deepseek",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "DEEPSEEK_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) =>
-      configured.model<OpenAIProviderOptionsInput>({
-        id: modelID,
-        compatibility: { maxTokensField: "max_tokens", supportsStore: false },
-      }),
-    configure,
-  }
-}
-
-export const provider = 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 } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as DeepSeek from "./deepseek.js"

packages/ai/src/providers/fireworks.ts

@@ -1,60 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("fireworks")
-const baseURL = "https://api.fireworks.ai/inference/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "fireworks-chat",
-  provider: id,
-  providerMetadataKey: "fireworks",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "FIREWORKS_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = 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 } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Fireworks from "./fireworks.js"

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

@@ -1,7 +1,6 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
@@ -25,13 +24,10 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-const route = Route.make({
+const route = OpenAICompatibleChat.route.with({
   id: "google-vertex-chat",
   provider: id,
   providerMetadataKey: "vertex",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]

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

@@ -1,7 +1,6 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
@@ -25,14 +24,11 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenResponsesProviderOptionsInput
 }
 
-const route = Route.make({
+const route = OpenAICompatibleResponses.route.with({
   id: "google-vertex-responses",
   provider: id,
   providerMetadataKey: "vertex",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+  providerOptions: { store: false },
 })
 
 export const routes = [route]

packages/ai/src/providers/groq.ts

@@ -7,10 +7,10 @@ import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID, type LLMRequest } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("groq")
-const baseURL = "https://api.groq.com/openai/v1"
 
 export type ProviderOptions = Pick<OpenAIProviderOptionsInput, "reasoningEffort"> & {
   /** Controls visible reasoning on GPT-OSS; other models always use parsed reasoning. */
@@ -73,15 +73,15 @@ export const route = Route.make({
   provider: id,
   providerMetadataKey: "openai",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.groq.baseURL },
     auth: AuthOptions.bearer(input, "GROQ_API_KEY"),
   })
   return {

packages/ai/src/providers/index.ts

@@ -3,21 +3,16 @@ export * as AnthropicCompatible from "./anthropic-compatible.js"
 export * as AmazonBedrock from "./amazon-bedrock.js"
 export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js"
 export * as Azure from "./azure.js"
-export * as Baseten from "./baseten.js"
 export * as Cerebras from "./cerebras.js"
-export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
-export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"
+export * as Cloudflare from "./cloudflare.js"
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js"
 export * as DeepInfra from "./deepinfra.js"
-export * as DeepSeek from "./deepseek.js"
-export * as Fireworks from "./fireworks.js"
 export * as Google from "./google.js"
 export * as GoogleVertex from "./google-vertex.js"
 export * as GoogleVertexChat from "./google-vertex-chat.js"
 export * as GoogleVertexMessages from "./google-vertex-messages.js"
 export * as GoogleVertexResponses from "./google-vertex-responses.js"
 export * as Groq from "./groq.js"
-export * as Meta from "./meta.js"
-export * as MiniMax from "./minimax.js"
 export * as Mistral from "./mistral.js"
 export * as OpenAI from "./openai.js"
 export * as OpenAICompatible from "./openai-compatible.js"

packages/ai/src/providers/meta.ts

@@ -1,182 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { MetaResponses } from "../protocols/meta-responses.js"
-import { MetaMessages } from "../protocols/meta-messages.js"
-import { MetaImages } from "../protocols/meta-images.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { HttpOptions, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
-
-export const id = ProviderID.make("meta")
-const baseURL = "https://api.meta.ai/v1"
-
-export type ProviderOptionsInput = OpenResponsesProviderOptionsInput &
-  Pick<AnthropicMessages.OptionsInput, "thinking" | "effort">
-export type MessagesOptionsInput = Pick<
-  AnthropicMessages.OptionsInput,
-  "thinking" | "effort" | "outputConfig" | "output_config" | "serviceTier" | "service_tier" | "metadata"
-> & { readonly [key: string]: unknown }
-export type ImageOptions = MetaImages.ImageOptions
-
-export interface WebSearchOptions {
-  readonly searchContextSize?: "low" | "medium" | "high" | (string & {})
-  readonly userLocation?: {
-    readonly city?: string
-    readonly region?: string
-    readonly country?: string
-    readonly timezone?: string
-  }
-}
-
-export const webSearch = (options: WebSearchOptions = {}) =>
-  ToolDefinition.make({
-    name: "web_search",
-    description: "Search the web with Meta's hosted search tool.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      meta: {
-        type: "web_search",
-        search_context_size: options.searchContextSize,
-        user_location:
-          options.userLocation === undefined ? undefined : { type: "approximate", ...options.userLocation },
-      },
-    },
-  })
-
-export interface ImageGenerationOptions {
-  readonly size?: string
-  readonly outputFormat?: "webp" | "png" | "jpeg" | (string & {})
-  readonly reasoningStrength?: "low" | "high" | (string & {})
-  readonly enableImageSearch?: boolean
-  readonly enableWebSearch?: boolean
-  readonly enableShell?: boolean
-}
-
-export const imageGeneration = (options: ImageGenerationOptions = {}) =>
-  ToolDefinition.make({
-    name: "image_generation",
-    description: "Generate or edit an image with Muse Image.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      meta: {
-        type: "image_generation",
-        size: options.size,
-        output_format: options.outputFormat,
-        reasoning_strength: options.reasoningStrength,
-        enable_image_search: options.enableImageSearch,
-        enable_web_search: options.enableWebSearch,
-        enable_shell: options.enableShell,
-      },
-    },
-  })
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: ProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptionsInput
-}
-
-const responsesRoute = Route.make({
-  id: "meta-responses",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: MetaResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL }),
-  // Meta Responses does not support WebSocket upgrades; always use HTTP/SSE.
-  transport: MetaResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
-})
-
-const chatRoute = Route.make({
-  id: "meta-chat",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-const messagesRoute = Route.make({
-  id: "meta-messages",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: MetaMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL }),
-  framing: AnthropicMessages.framing,
-  defaults: { providerOptions: { thinking: { type: "adaptive", display: "omitted" } } },
-})
-
-export const routes = [responsesRoute, chatRoute, messagesRoute]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const options = {
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "META_API_KEY"),
-  }
-  const configuredResponses = responsesRoute.with(options)
-  const configuredChat = chatRoute.with(options)
-  const configuredMessages = messagesRoute.with(options)
-  const responses = (modelID: string | ModelID) =>
-    configuredResponses.model<OpenResponsesProviderOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    configuredChat.model<OpenResponsesProviderOptionsInput>({
-      id: modelID,
-      compatibility: { maxTokensField: "max_completion_tokens", supportsStore: false },
-    })
-  const messages = (modelID: string | ModelID) =>
-    configuredMessages.model<MessagesOptionsInput>({
-      id: modelID,
-      compatibility: { requireSignature: false },
-    })
-  const image = (modelID: string | ModelID) =>
-    MetaImages.model({
-      id: modelID,
-      baseURL: endpoint ?? baseURL,
-      auth: options.auth,
-      headers: input.headers,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
-  return { id, model: responses, responses, chat, messages, image, configure }
-}
-
-export const provider = configure()
-export const responses = provider.responses
-export const chat = provider.chat
-export const messages = provider.messages
-export const image = provider.image
-
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => fromSettings(settings).responses(modelID)
-
-export const chatModel: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => fromSettings(settings).chat(modelID)
-
-export const messagesModel: ProviderPackage.Definition<Settings, MessagesOptionsInput>["model"] = (modelID, settings) =>
-  fromSettings(settings).messages(modelID)
-
-function fromSettings(settings: Settings) {
-  return configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  })
-}
-
-export * as Meta from "./meta.js"

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

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

packages/ai/src/providers/meta/messages.ts

@@ -1,2 +0,0 @@
-export { messagesModel as model } from "../meta.js"
-export type { Settings } from "../meta.js"

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

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

packages/ai/src/providers/minimax.ts

@@ -1,144 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { ProviderShared } from "../protocols/shared.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { Framing } from "../route/framing.js"
-import { Protocol } from "../route/protocol.js"
-import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
-
-export const id = ProviderID.make("minimax")
-
-export type MessagesOptionsInput = {
-  /** M3 defaults to disabled; M2.x always thinks. */
-  readonly thinking?: { readonly type: "adaptive" | "disabled" }
-  readonly metadata?: AnthropicMessages.OptionsInput["metadata"]
-}
-
-export type ChatOptionsInput = {
-  /** M3 defaults to adaptive; M2.x always thinks. */
-  readonly thinking?: { readonly type: "adaptive" | "disabled" | (string & {}) }
-  /** Separates reasoning from text. Defaults to true. */
-  readonly reasoningSplit?: boolean
-}
-
-export type ResponsesOptionsInput = {
-  /** M3 defaults to none. Other supported values enable thinking without changing its depth. */
-  readonly reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | (string & {})
-}
-
-export type ProviderOptionsInput = MessagesOptionsInput | ChatOptionsInput | ResponsesOptionsInput
-
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Overrides the selected API's base URL, including its version prefix. */
-    readonly baseURL?: string
-    readonly providerOptions?: ProviderOptionsInput
-  }
-
-export interface Settings<Options = MessagesOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
-
-const ChatOptions = Schema.Struct({
-  thinking: Schema.optional(Schema.Struct({ type: Schema.String })),
-  reasoningSplit: Schema.optional(Schema.Boolean),
-})
-
-const chatProtocol = Protocol.make({
-  id: "minimax-chat",
-  body: {
-    schema: Schema.Struct({
-      ...OpenAIChat.bodyFields,
-      thinking: ChatOptions.fields.thinking,
-      reasoning_split: Schema.Boolean,
-    }),
-    from: Effect.fn("MiniMax.chatFromRequest")(function* (request: LLMRequest) {
-      const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(ChatOptions))(
-        request.providerOptions ?? {},
-      )
-      return {
-        ...(yield* OpenAIChat.protocol.body.from(request)),
-        thinking: options.thinking,
-        // MiniMax otherwise embeds <think> tags in ordinary assistant text.
-        reasoning_split: options.reasoningSplit ?? true,
-      }
-    }),
-  },
-  stream: OpenAIChat.protocol.stream,
-})
-
-const messagesRoute = Route.make({
-  id: "minimax-messages",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: AnthropicMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL: "https://api.minimax.io/anthropic/v1" }),
-  framing: AnthropicMessages.framing,
-  headers: () => ({ "anthropic-version": "2023-06-01" }),
-})
-
-const chatRoute = Route.make({
-  id: "minimax-chat",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: chatProtocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.minimax.io/v1" }),
-  framing: OpenAIChat.framing,
-})
-
-const responsesRoute = Route.make({
-  id: "minimax-responses",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: "https://api.minimax.io/v1" }),
-  framing: Framing.sse,
-})
-
-export const routes = [messagesRoute, chatRoute, responsesRoute]
-
-export const configure = (input: Config = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
-  const defaults = {
-    ...rest,
-    endpoint: baseURL === undefined ? undefined : { baseURL },
-    auth: AuthOptions.bearer(input, "MINIMAX_API_KEY"),
-  }
-  const messages = (modelID: string | ModelID) =>
-    messagesRoute.with(defaults).model<MessagesOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(defaults).model<ChatOptionsInput>({
-      id: modelID,
-      compatibility: { supportsStore: false, supportsStrictMode: false },
-    })
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute.with(defaults).model<ResponsesOptionsInput>({ id: modelID })
-  return { id, model: messages, messages, chat, responses, configure }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings<MessagesOptionsInput>, MessagesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export const messages = provider.messages
-export const chat = provider.chat
-export const responses = provider.responses
-
-export * as MiniMax from "./minimax.js"

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

@@ -1,13 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { MiniMax } from "../minimax.js"
-
-export type Settings = MiniMax.Settings<MiniMax.ChatOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, MiniMax.ChatOptionsInput>["model"] = (modelID, settings) =>
-  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).chat(modelID)

packages/ai/src/providers/minimax/messages.ts

@@ -1 +0,0 @@
-export { model, type Settings, type MessagesOptionsInput } from "../minimax.js"

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

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { MiniMax } from "../minimax.js"
-
-export type Settings = MiniMax.Settings<MiniMax.ResponsesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, MiniMax.ResponsesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).responses(modelID)

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

@@ -0,0 +1,20 @@
+export interface OpenAICompatibleProfile {
+  readonly provider: string
+  readonly baseURL: string
+}
+
+export const profiles = {
+  baseten: { provider: "baseten", baseURL: "https://inference.baseten.co/v1" },
+  cerebras: { provider: "cerebras", baseURL: "https://api.cerebras.ai/v1" },
+  deepinfra: { provider: "deepinfra", baseURL: "https://api.deepinfra.com/v1/openai" },
+  deepseek: { provider: "deepseek", baseURL: "https://api.deepseek.com/v1" },
+  fireworks: { provider: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1" },
+  groq: { provider: "groq", baseURL: "https://api.groq.com/openai/v1" },
+  openrouter: { provider: "openrouter", baseURL: "https://openrouter.ai/api/v1" },
+  togetherai: { provider: "togetherai", baseURL: "https://api.together.xyz/v1" },
+  xai: { provider: "xai", baseURL: "https://api.x.ai/v1" },
+} as const satisfies Record<string, OpenAICompatibleProfile>
+
+export const byProvider: Record<string, OpenAICompatibleProfile> = Object.fromEntries(
+  Object.values(profiles).map((profile) => [profile.provider, profile]),
+)

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

@@ -1,8 +1,9 @@
 import { ProviderID, type ModelID } from "../schema/index.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
+import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("openai-compatible")
@@ -21,6 +22,12 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
+export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
 export const routes = [OpenAICompatibleChat.route]
 
 export const configure = (input: GenericModelOptions) => {
@@ -40,6 +47,22 @@ export const configure = (input: GenericModelOptions) => {
   }
 }
 
+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,
@@ -55,4 +78,10 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
     providerOptions: settings.providerOptions,
   }).model(modelID)
 
-export * as OpenAICompatible from "./openai-compatible.js"
+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.ts

@@ -1,5 +1,5 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
+import type { Route, RouteDefaultsInput, CompactOperation } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -73,7 +73,7 @@ const defaults = (input: Config) => {
   return rest
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactionOperations | undefined>(
+const configuredRoute = <Body, Prepared, Compact extends CompactOperation | undefined>(
   route: Route<Body, Prepared, Compact>,
   input: Config,
 ) =>
@@ -132,11 +132,10 @@ const config = (settings: Settings): Config => {
   }
 }
 
-export const model: ProviderPackage.Definition<
-  Settings,
-  OpenAIProviderOptionsInput,
-  typeof OpenAIResponses.route.compact
->["model"] = (modelID, settings) => {
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput, CompactOperation>["model"] = (
+  modelID,
+  settings,
+) => {
   return configure(config(settings)).responses(modelID)
 }
 

packages/ai/src/providers/openrouter.ts

@@ -5,12 +5,13 @@ import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
+import * as OpenAIChat from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
 import { isRecord } from "../protocols/shared.js"
 
-export const id = ProviderID.make("openrouter")
-const baseURL = "https://openrouter.ai/api/v1"
+export const profile = OpenAICompatibleProfiles.profiles.openrouter
+export const id = ProviderID.make(profile.provider)
 const ADAPTER = "openrouter"
 
 type OpenRouterString<Known extends string> = Known | (string & {})
@@ -161,20 +162,20 @@ const bodyOptions = (input: unknown) => {
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: id,
+  provider: profile.provider,
   providerMetadataKey: "openrouter",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 const configuredRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return route.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profile.baseURL },
     auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
   })
 }

packages/ai/src/providers/togetherai.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("togetherai")
-const baseURL = "https://api.together.xyz/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,22 +20,19 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "togetherai-chat",
   provider: id,
-  providerMetadataKey: "togetherai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.togetherai.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.togetherai.baseURL },
     auth: AuthOptions.bearer(input, ["TOGETHER_API_KEY", "TOGETHER_AI_API_KEY"]),
   })
   return {

packages/ai/src/providers/xai.ts

@@ -1,8 +1,10 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Route, type RouteDefaultsInput, type CompactOperation } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import * as OpenAIChat from "../protocols/openai-chat.js"
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
 import { XAIResponses } from "../protocols/xai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
@@ -10,7 +12,6 @@ import type { OpenAIOptionsInput } from "./openai-options.js"
 import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
-const baseURL = "https://api.x.ai/v1"
 
 export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
 
@@ -31,12 +32,12 @@ export type { XAIImageOptions } from "../protocols/xai-images.js"
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
-  compact: { endpoint: XAIResponses.compact },
+  compact: XAIResponses.compact,
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",
   protocol: XAIResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL }),
+  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
   transport: OpenResponsesChannel.transport({
     id: "openai-responses",
     name: "xAI Responses",
@@ -50,8 +51,8 @@ const chatRoute = Route.make({
   provider: id,
   providerMetadataKey: "xai",
   protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
+  transport: OpenAICompatibleChat.route.transport,
   headers: ({ request }): Record<string, string> =>
     request.promptCacheKey ? { "x-grok-conv-id": request.promptCacheKey } : {},
 })
@@ -61,19 +62,19 @@ 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: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return responsesRoute.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
 }
 
 const configuredChatRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return chatRoute.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
 }
@@ -87,7 +88,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
     XAIImages.model({
       id: modelID,
       auth: auth(input),
-      baseURL: input.baseURL ?? baseURL,
+      baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
       headers: input.headers,
       http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     })
@@ -102,11 +103,10 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<
-  Settings,
-  XAIProviderOptionsInput,
-  typeof responsesRoute.compact
->["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput, CompactOperation>["model"] = (
+  modelID,
+  settings,
+) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,

packages/ai/src/route/client.ts

@@ -14,7 +14,6 @@ import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
   AIError,
   CompactionResponse,
-  CompactionCheckpointResponse,
   AIErrorReason,
   GenerationOptions,
   HttpOptions,
@@ -39,7 +38,7 @@ export interface RouteBody<Body> {
 export interface Route<
   Body,
   Prepared = unknown,
-  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
+  Compact extends CompactOperation | undefined = CompactOperation | undefined,
 > {
   readonly compact: Compact
   readonly id: string
@@ -54,15 +53,7 @@ export interface Route<
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
-  readonly with: {
-    <Next extends CompactionOperations | undefined>(
-      patch: RoutePatch<Body, Prepared> & { readonly compact: Next },
-    ): Route<Body, Prepared, Next>
-    (
-      patch: Omit<RoutePatch<Body, Prepared>, "compact"> & { readonly compact?: undefined },
-    ): Route<Body, Prepared, Compact>
-    (patch: RoutePatch<Body, Prepared>): Route<Body, Prepared>
-  }
+  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared, Compact>
   readonly model: <Options extends ProviderOptions = ProviderOptions>(
     input: RouteMappedLanguageModelInput,
   ) => LanguageModel<Options, Compact>
@@ -83,7 +74,7 @@ export interface Route<
 // 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<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = Route<
+export type AnyRoute<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Route<
   any,
   any,
   Compact
@@ -110,7 +101,6 @@ export interface RouteDefaultsInput {
 }
 
 export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
-  readonly compact?: CompactionOperations
   readonly id?: string
   readonly provider?: string | ProviderID
   readonly providerMetadataKey?: string
@@ -121,7 +111,7 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 
 type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput
 
-const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
+const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
   route: AnyRoute<Compact>,
   mapped: RouteMappedLanguageModelInput,
 ) => {
@@ -172,7 +162,10 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }
 
 export interface Interface {
-  readonly compact: CompactMethod
+  readonly compact: (
+    request: CompactionRequest,
+    options?: Pick<StreamOptions, "http">,
+  ) => Effect.Effect<CompactionResponse, AIError>
   readonly stream: StreamMethod
   readonly generate: GenerateMethod
 }
@@ -196,64 +189,12 @@ export type CompactOperation = (
   options?: Pick<StreamOptions, "http">,
 ) => Effect.Effect<CompactionResponse, AIError>
 
-export type TriggerCompactOperation = (
-  request: LLMRequest,
-  executor: RequestExecutor.Interface,
-  options: TriggerCompactOptions,
-) => Effect.Effect<CompactionCheckpointResponse, AIError>
-
-/** Protocol capabilities, not deployment/model eligibility. */
-export interface CompactionOperations {
-  readonly endpoint?: CompactOperation
-  readonly trigger?: TriggerCompactOperation
-}
-
-export interface EndpointCompactOptions extends Pick<StreamOptions, "http"> {
-  readonly mechanism?: "endpoint"
-  readonly webSocket?: never
-}
-
-export interface TriggerCompactOptions extends StreamOptions {
-  readonly mechanism: "trigger"
-}
-
-// Keep the required route shape explicit: the schema class's self type erases its model parameter in assignability.
 export type CompactionRequest = LLMRequest & {
-  readonly model: LanguageModel<ProviderOptions, { readonly endpoint: CompactOperation }>
-}
-export type CheckpointRequest = LLMRequest & {
-  readonly model: LanguageModel<ProviderOptions, { readonly trigger: TriggerCompactOperation }>
+  readonly model: LanguageModel<ProviderOptions, CompactOperation>
 }
 
-export interface CompactMethod<R = never> {
-  (request: CheckpointRequest, options: TriggerCompactOptions): Effect.Effect<CompactionCheckpointResponse, AIError, R>
-  (request: CompactionRequest, options?: EndpointCompactOptions): Effect.Effect<CompactionResponse, AIError, R>
-}
-
-export function canCompact(
-  request: LLMRequest,
-  options?: { readonly mechanism?: "endpoint" },
-): request is CompactionRequest
-export function canCompact(
-  request: LLMRequest,
-  options: { readonly mechanism: "trigger" },
-): request is CheckpointRequest
-export function canCompact(request: LLMRequest, options?: { readonly mechanism?: string }) {
-  if (options?.mechanism === "trigger") return request.model.route.compact?.trigger !== undefined
-  if (options?.mechanism !== undefined && options.mechanism !== "endpoint") return false
-  return request.model.route.compact?.endpoint !== undefined
-}
-
-const unsupportedCompaction = (request: LLMRequest, mechanism: string | undefined) => {
-  if (mechanism !== undefined && mechanism !== "endpoint" && mechanism !== "trigger")
-    return ProviderShared.invalidRequest(`Unknown compaction mechanism: ${mechanism}`)
-  return ProviderShared.unsupportedOperation({
-    operation: mechanism === "trigger" ? "compact.trigger" : "compact",
-    provider: request.model.provider,
-    route: request.model.route.id,
-    message: `${request.model.provider}/${request.model.route.id} does not support ${mechanism === "trigger" ? "trigger" : "explicit"} compaction`,
-  })
-}
+export const canCompact = (request: LLMRequest): request is CompactionRequest =>
+  request.model.route.compact !== undefined
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
@@ -275,7 +216,7 @@ const resolveRequestOptions = (request: LLMRequest) => {
 }
 
 export interface MakeInput<Body, Frame, Event, State> {
-  readonly compact?: CompactionOperations
+  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -297,7 +238,7 @@ export interface MakeInput<Body, Frame, Event, State> {
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  readonly compact?: CompactionOperations
+  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -385,10 +326,9 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
       with: (patch: RoutePatch<Body, Prepared>) => {
-        const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
+        const { id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
         return build({
           ...routeInput,
-          compact: "compact" in patch ? compact : routeInput.compact,
           id: id ?? routeInput.id,
           provider: provider ?? routeInput.provider,
           providerMetadataKey:
@@ -403,7 +343,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         })
       },
       model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) =>
-        makeRouteLanguageModel<Options, CompactionOperations | undefined>(route, input),
+        makeRouteLanguageModel<Options, CompactOperation | undefined>(route, input),
       prepareTransport: (body, request, options) =>
         routeInput.transport.prepare({
           body,
@@ -500,12 +440,12 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
 }
 
-export function make<Body, Prepared, Frame, Event, State, Compact extends CompactionOperations>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State> & { readonly compact: Compact },
-): Route<Body, Prepared, Compact>
-export function make<Body, Frame, Event, State, Compact extends CompactionOperations>(
-  input: MakeInput<Body, Frame, Event, State> & { readonly compact: Compact },
-): Route<Body, HttpTransport.HttpPrepared<Frame>, Compact>
+export function make<Body, Prepared, Frame, Event, State>(
+  input: MakeTransportInput<Body, Prepared, Frame, Event, State> & { readonly compact: CompactOperation },
+): Route<Body, Prepared, CompactOperation>
+export function make<Body, Frame, Event, State>(
+  input: MakeInput<Body, Frame, Event, State> & { readonly compact: CompactOperation },
+): Route<Body, HttpTransport.HttpPrepared<Frame>, CompactOperation>
 export function make<Body, Prepared, Frame, Event, State>(
   input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
 ): Route<Body, Prepared>
@@ -547,14 +487,10 @@ export function make<Body, Prepared, Frame, Event, State>(
 }
 
 const prepareRequest = (request: LLMRequest) => {
-  const original = resolveRequestOptions(request)
+  const original = applyCachePolicy(resolveRequestOptions(request))
   const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
-  // Deduplicate per sibling level; a tool and a namespace may share a name.
-  const dedupe = (tools: LLMRequest["tools"]): LLMRequest["tools"] =>
-    [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) =>
-      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
-    )
-  const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }))
+  const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
+  const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
   const headers = resolved.model.route.headers?.({ request: resolved })
   return headers === undefined
     ? resolved
@@ -621,23 +557,14 @@ export function generate(request: LLMRequest, options?: StreamOptions): Effect.E
   })
 }
 
-export function compact(
-  request: CheckpointRequest,
-  options: TriggerCompactOptions,
-): Effect.Effect<CompactionCheckpointResponse, AIError, Service>
-export function compact(
+export const compact = (
   request: CompactionRequest,
-  options?: EndpointCompactOptions,
-): Effect.Effect<CompactionResponse, AIError, Service>
-export function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) {
-  return Effect.gen(function* () {
+  options?: Pick<StreamOptions, "http">,
+): Effect.Effect<CompactionResponse, AIError, Service> =>
+  Effect.gen(function* () {
     const client = yield* Service
-    if (options?.mechanism === "trigger" && canCompact(request, options)) return yield* client.compact(request, options)
-    if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
-      return yield* client.compact(request, options)
-    return yield* unsupportedCompaction(request, options?.mechanism)
+    return yield* client.compact(request, options)
   })
-}
 
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
   Stream.unwrap(
@@ -651,27 +578,21 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
   Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service
     const stream = streamRequestWith({ http: executor })
-    function compact(
-      request: CompactionRequest,
-      options?: EndpointCompactOptions,
-    ): Effect.Effect<CompactionResponse, AIError>
-    function compact(
-      request: CheckpointRequest,
-      options: TriggerCompactOptions,
-    ): Effect.Effect<CompactionCheckpointResponse, AIError>
-    function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) {
-      return Effect.suspend((): Effect.Effect<CompactionResponse | CompactionCheckpointResponse, AIError> => {
-        if (options?.mechanism === "trigger" && canCompact(request, options))
-          return request.model.route.compact.trigger(prepareRequest(request), executor, options)
-        if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
-          return request.model.route.compact.endpoint(prepareRequest(request), executor, options)
-        return unsupportedCompaction(request, options?.mechanism)
-      })
-    }
     return Service.of({
       stream,
       generate: generateWith(stream),
-      compact,
+      compact: (request, options) =>
+        Effect.suspend(() => {
+          const operation = request.model.route.compact
+          if (!operation)
+            return ProviderShared.unsupportedOperation({
+              operation: "compact",
+              provider: request.model.provider,
+              route: request.model.route.id,
+              message: `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
+            })
+          return operation(prepareRequest(request), executor, options)
+        }),
     })
   }),
 )

packages/ai/src/route/index.ts

@@ -9,12 +9,6 @@ export type {
   Interface as LLMClientShape,
   Service as LLMClientService,
   StreamOptions,
-  CompactMethod,
-  CompactionOperations,
-  CompactionRequest,
-  CheckpointRequest,
-  EndpointCompactOptions,
-  TriggerCompactOptions,
 } from "./client.js"
 export * from "./executor.js"
 export { Auth } from "./auth.js"

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

@@ -20,7 +20,7 @@ export interface WebSocketChannelExchange {
   readonly connect: {
     readonly url: string
     readonly headers: Headers.Headers
-    /** Provider-safe connection age after which the channel executor should reconnect before sending. */
+    /** Provider-safe connection age after which Core should rotate before sending. */
     readonly rotateAfterMs?: number
   }
   readonly fallback: () => Stream.Stream<string, AIError>

packages/ai/src/schema/errors.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { ModelID, ProviderID, RouteID } from "./ids.js"
 
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])

packages/ai/src/schema/events.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { LLM } from "@opencode/schema/llm"
+import { LLM } from "@opencode-ai/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
   Message,
@@ -97,21 +97,6 @@ export class CompactionResponse extends Schema.Class<CompactionResponse>("LLM.Co
   usage: Schema.optional(Usage),
 }) {}
 
-/** A checkpoint only; retained history and replacement-window construction belong to the caller. */
-export class CompactionCheckpointResponse extends Schema.Class<CompactionCheckpointResponse>(
-  "LLM.CompactionCheckpointResponse",
-)({
-  checkpoint: CompactionPart.pipe(
-    Schema.refine(
-      (part): part is CompactionPart & { readonly encrypted: string; readonly text?: never } =>
-        part.encrypted !== undefined && part.encrypted.length > 0,
-      { message: "A checkpoint response requires encrypted compaction content" },
-    ),
-  ),
-  responseID: Schema.String.check(Schema.isPattern(/\S/)),
-  usage: Schema.optional(Usage),
-}) {}
-
 export const StepStart = Schema.Struct({
   type: Schema.tag("step-start"),
   index: Schema.Number,
@@ -170,7 +155,6 @@ export const ToolInputStart = Schema.Struct({
   type: Schema.tag("tool-input-start"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
@@ -180,7 +164,6 @@ export const ToolInputDelta = Schema.Struct({
   type: Schema.tag("tool-input-delta"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   text: Schema.String,
   /** Best-effort parse of all input fragments received through this delta. */
   input: Schema.optional(Schema.Unknown),
@@ -191,7 +174,6 @@ export const ToolInputEnd = Schema.Struct({
   type: Schema.tag("tool-input-end"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>
@@ -201,7 +183,6 @@ export const ToolInputError = Schema.Struct({
   type: Schema.tag("tool-input-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   raw: Schema.String,
 }).annotate({ identifier: "LLM.Event.ToolInputError" })
 export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
@@ -210,7 +191,6 @@ export const ToolCall = Schema.Struct({
   type: Schema.tag("tool-call"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   input: Schema.Unknown,
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -221,7 +201,6 @@ export const ToolResult = Schema.Struct({
   type: Schema.tag("tool-result"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   result: ToolResultValue,
   output: Schema.optional(ToolOutput),
   providerExecuted: Schema.optional(Schema.Boolean),
@@ -233,7 +212,6 @@ export const ToolError = Schema.Struct({
   type: Schema.tag("tool-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   message: Schema.String,
   error: Schema.optional(Schema.Defect()),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -407,7 +385,6 @@ interface ContentAssembly {
 
 interface ToolInputAssembly {
   readonly name: string
-  readonly namespace?: string
   readonly text: string
   readonly providerMetadata?: ProviderMetadata
 }
@@ -545,17 +522,12 @@ const reduceToolInputStart = (state: ResponseState, event: ToolInputStart): Resp
   ...state,
   toolInputs: {
     ...state.toolInputs,
-    [event.id]: {
-      name: event.name,
-      namespace: event.namespace,
-      text: "",
-      providerMetadata: event.providerMetadata,
-    },
+    [event.id]: { name: event.name, text: "", providerMetadata: event.providerMetadata },
   },
 })
 
 const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: { ...state.toolInputs, [event.id]: { ...current, text: current.text + event.text } },
@@ -563,7 +535,7 @@ const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): Resp
 }
 
 const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: {
@@ -571,7 +543,6 @@ const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): Response
       [event.id]: {
         ...current,
         name: event.name,
-        namespace: event.namespace,
         providerMetadata: event.providerMetadata ?? current.providerMetadata,
       },
     },
@@ -582,7 +553,6 @@ const toolCallContent = (event: ToolCall): ContentPart =>
   ToolCallPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     input: event.input,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),
@@ -592,7 +562,6 @@ const toolResultContent = (event: ToolResult): ContentPart =>
   ToolResultPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     result: event.result,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),

packages/ai/src/schema/messages.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import {
   CacheHint,
   CachePolicy,
@@ -135,7 +135,6 @@ export const ToolCallPart = Object.assign(
     type: Schema.Literal("tool-call"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     input: Schema.Unknown,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -153,7 +152,6 @@ export const ToolResultPart = Object.assign(
     type: Schema.Literal("tool-result"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     result: ToolResultValue,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -170,7 +168,6 @@ export const ToolResultPart = Object.assign(
       type: "tool-result",
       id: input.id,
       name: input.name,
-      namespace: input.namespace,
       result: ToolResultValue.make(input.result, input.resultType),
       providerExecuted: input.providerExecuted,
       cache: input.cache,
@@ -269,7 +266,7 @@ export namespace Message {
     make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
 }
 
-const toolDefinitionFields = {
+export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
   name: Schema.String,
   description: Schema.String,
   inputSchema: JsonSchema,
@@ -277,71 +274,15 @@ const toolDefinitionFields = {
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}
-
-export type ToolDefinitionInput = Schema.Struct.Type<typeof toolDefinitionFields>
-
-export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
-  type: Schema.Literal("tool"),
-  ...toolDefinitionFields,
-}) {
-  constructor(input: ToolDefinitionInput) {
-    super({ ...input, type: "tool" })
-  }
-}
+}) {}
 
 export namespace ToolDefinition {
-  export type Input = ToolDefinition | ToolDefinitionInput
+  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 type ToolNamespace = {
-  readonly type: "namespace"
-  readonly name: string
-  readonly description?: string
-  readonly tools: ReadonlyArray<ToolEntry>
-}
-
-export type ToolNamespaceInput = Omit<ToolNamespace, "type" | "tools"> & {
-  readonly tools: ReadonlyArray<ToolEntryInput>
-}
-export type ToolNamespaceEntryInput = ToolNamespaceInput & { readonly type: "namespace" }
-
-export const ToolNamespace: Schema.Codec<ToolNamespace> & {
-  readonly make: (input: ToolNamespace | ToolNamespaceInput) => ToolNamespace
-} = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("namespace"),
-    name: Schema.String,
-    description: Schema.optional(Schema.UndefinedOr(Schema.String)),
-    tools: Schema.Array(Schema.suspend((): Schema.Codec<ToolEntry> => ToolEntry)),
-  }).annotate({ identifier: "LLM.ToolNamespace" }),
-  {
-    make: (input: ToolNamespace | ToolNamespaceInput): ToolNamespace => ({
-      ...input,
-      type: "namespace",
-      tools: input.tools.map(ToolEntry.make),
-    }),
-  },
-)
-
-export type ToolEntry = ToolDefinition | ToolNamespace
-export type ToolEntryInput = ToolDefinition.Input | ToolNamespaceEntryInput
-export const ToolEntry: Schema.Codec<ToolEntry> & {
-  readonly make: (input: ToolEntryInput) => ToolEntry
-} = Object.assign(
-  Schema.Union([ToolDefinition, ToolNamespace]).pipe(
-    Schema.toTaggedUnion("type"),
-    Schema.annotate({ identifier: "LLM.ToolEntry" }),
-  ),
-  {
-    make: (input: ToolEntryInput): ToolEntry =>
-      "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
-  },
-)
-
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
@@ -371,7 +312,7 @@ const requestSchema = Schema.Struct({
   model: LanguageModelSchema,
   system: Schema.Array(SystemPart),
   messages: Schema.Array(Message),
-  tools: Schema.Array(ToolEntry),
+  tools: Schema.Array(ToolDefinition),
   toolChoice: Schema.optional(ToolChoice),
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),

packages/ai/src/schema/options.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { ModelID, ProviderID } from "./ids.js"
-import type { AnyRoute, CompactionOperations } from "../route/client.js"
+import type { AnyRoute, CompactOperation } from "../route/client.js"
 import { isRecord } from "../utils/record.js"
 
 export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown)
@@ -175,7 +175,7 @@ export namespace LanguageModelCompatibility {
 
 export class LanguageModel<
   Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
+  Compact extends CompactOperation | undefined = CompactOperation | undefined,
 > {
   declare protected readonly _ProviderOptions: Options
   readonly id: ModelID
@@ -194,7 +194,7 @@ export class LanguageModel<
 
   static make<
     Options extends ProviderOptions = ProviderOptions,
-    Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
+    Compact extends CompactOperation | undefined = CompactOperation | undefined,
   >(input: LanguageModel.Input<Compact>) {
     return new LanguageModel<Options, Compact>({
       id: ModelID.make(input.id),
@@ -206,7 +206,7 @@ export class LanguageModel<
     })
   }
 
-  static input<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
+  static input<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
     model: LanguageModel<Options, Compact>,
   ): LanguageModel.ConstructorInput<Compact> {
     return {
@@ -218,11 +218,11 @@ export class LanguageModel<
     }
   }
 
-  static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
+  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
     model: LanguageModel<Options>,
     patch: Partial<LanguageModel.Input<Compact>> & { readonly route: AnyRoute<Compact> },
   ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
+  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
     model: LanguageModel<Options, Compact>,
     patch: Partial<Omit<LanguageModel.Input, "route">> & { readonly route?: undefined },
   ): LanguageModel<Options, Compact>
@@ -241,7 +241,7 @@ export class LanguageModel<
 }
 
 export namespace LanguageModel {
-  export type ConstructorInput<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = {
+  export type ConstructorInput<Compact extends CompactOperation | undefined = CompactOperation | undefined> = {
     readonly id: ModelID
     readonly provider: ProviderID
     readonly route: AnyRoute<Compact>
@@ -249,7 +249,7 @@ export namespace LanguageModel {
     readonly compatibility?: LanguageModelCompatibility
   }
 
-  export type Input<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = Omit<
+  export type Input<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Omit<
     ConstructorInput<Compact>,
     "id" | "provider" | "defaults" | "compatibility"
   > & {

packages/ai/src/testing.ts

@@ -1,17 +1,10 @@
 export * as TestLLM from "./testing.js"
 
-import {
-  LLMClient,
-  type CompactionRequest,
-  type CheckpointRequest,
-  type EndpointCompactOptions,
-  type TriggerCompactOptions,
-} from "./route/client.js"
+import { LLMClient } from "./route/client.js"
 import {
   LLMEvent,
   LLMResponse,
   CompactionResponse,
-  CompactionCheckpointResponse,
   type FinishReasonDetails,
   type AIError,
   type LLMRequest,
@@ -20,11 +13,7 @@ import {
 } from "./schema/index.js"
 import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect"
 
-export type Response =
-  | readonly LLMEvent[]
-  | Stream.Stream<LLMEvent, AIError>
-  | CompactionResponse
-  | CompactionCheckpointResponse
+export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError> | CompactionResponse
 
 export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>
 
@@ -143,38 +132,21 @@ const make = (options: LayerOptions) =>
       Stream.unwrap(
         take(request).pipe(
           Effect.map((response) => {
-            if (response instanceof CompactionResponse || response instanceof CompactionCheckpointResponse)
+            if (response instanceof CompactionResponse)
               return Stream.die("TestLLM generation requires an event response")
             return Stream.isStream(response) ? response : Stream.fromIterable(response)
           }),
         ),
       )
-    function compact(
-      request: CompactionRequest,
-      options?: EndpointCompactOptions,
-    ): Effect.Effect<CompactionResponse, AIError>
-    function compact(
-      request: CheckpointRequest,
-      options: TriggerCompactOptions,
-    ): Effect.Effect<CompactionCheckpointResponse, AIError>
-    function compact(
-      request: LLMRequest,
-      options?: EndpointCompactOptions | TriggerCompactOptions,
-    ): Effect.Effect<CompactionResponse | CompactionCheckpointResponse, AIError> {
-      return take(request).pipe(
-        Effect.flatMap((response): Effect.Effect<CompactionResponse | CompactionCheckpointResponse> => {
-          if (options?.mechanism === "trigger")
-            return response instanceof CompactionCheckpointResponse
-              ? Effect.succeed(response)
-              : Effect.die("TestLLM trigger compaction requires a CompactionCheckpointResponse")
-          return response instanceof CompactionResponse
-            ? Effect.succeed(response)
-            : Effect.die("TestLLM compaction requires a CompactionResponse")
-        }),
-      )
-    }
     const test = Test.of({
-      compact,
+      compact: (request) =>
+        take(request).pipe(
+          Effect.flatMap((response) =>
+            response instanceof CompactionResponse
+              ? Effect.succeed(response)
+              : Effect.die("TestLLM compaction requires a CompactionResponse"),
+          ),
+        ),
       stream,
       generate: (request) =>
         stream(request).pipe(

packages/ai/src/tool-history.ts

@@ -37,13 +37,7 @@ function missingToolResults(calls: Iterable<ToolCallPart>) {
   return new Message({
     role: "tool",
     content: [...calls].map((call) =>
-      ToolResultPart.make({
-        id: call.id,
-        name: call.name,
-        namespace: call.namespace,
-        result: MISSING_TOOL_RESULT,
-        resultType: "error",
-      }),
+      ToolResultPart.make({ id: call.id, name: call.name, result: MISSING_TOOL_RESULT, resultType: "error" }),
     ),
   })
 }
@@ -53,7 +47,7 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
     if (part.type !== "tool-result" || part.providerExecuted === true) return part
     const call = pending.get(part.id)
     if (call) pending.delete(part.id)
-    return normalizeToolResult(part, call)
+    return normalizeToolResult(part, call?.name ?? part.name)
   })
   if (content.length === 0) return undefined
   if (content.every((part, index) => part === message.content[index])) return message
@@ -67,11 +61,8 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
   })
 }
 
-function normalizeToolResult(part: ToolResultPart, call: ToolCallPart | undefined): ToolResultPart {
-  const named =
-    call === undefined || (part.name === call.name && part.namespace === call.namespace)
-      ? part
-      : { ...part, name: call.name, namespace: call.namespace }
+function normalizeToolResult(part: ToolResultPart, name: string): ToolResultPart {
+  const named = part.name === name ? part : { ...part, name }
   if (named.result.type === "text" && named.result.value === "")
     return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } }
   if (named.result.type === "error" && named.result.value === "")

packages/ai/src/tool-runtime.ts

@@ -21,11 +21,10 @@ export interface DispatchResult extends ToolSettlement {
 
 /** Execute one canonical tool call without owning provider IO or continuation. */
 export const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<DispatchResult> => {
-  const name = call.namespace === undefined ? call.name : `${call.namespace}.${call.name}`
-  const tool = tools[name]
-  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${name}` }))
+  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: ${name}` }))
+    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)),
@@ -39,11 +38,7 @@ const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<Tool
   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,
-        namespace: call.namespace,
-      }).pipe(
+      tool.execute!(decoded, { id: call.id, name: call.name }).pipe(
         Effect.flatMap((value) =>
           tool._encode(value).pipe(
             Effect.mapError(
@@ -76,7 +71,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolError({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               message: String(settlement.result.value),
               error,
               providerMetadata: call.providerMetadata,
@@ -84,7 +78,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               providerMetadata: call.providerMetadata,
             }),
@@ -93,7 +86,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               output: settlement.output,
               providerMetadata: call.providerMetadata,

packages/ai/src/tool.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import type {
   ToolCallPart,
   ToolDefinition as ToolDefinitionClass,
@@ -16,7 +16,6 @@ export type ToolSchema<T> = Schema.Codec<T, any, never, never>
 export interface ToolExecuteContext {
   readonly id: ToolCallPart["id"]
   readonly name: ToolCallPart["name"]
-  readonly namespace?: ToolCallPart["namespace"]
 }
 
 export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (

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

@@ -6,8 +6,7 @@ import * as AmazonBedrock from "../src/providers/amazon-bedrock.js"
 import * as Anthropic from "../src/providers/anthropic.js"
 import * as AnthropicCompatible from "../src/providers/anthropic-compatible.js"
 import * as Azure from "../src/providers/azure.js"
-import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"
-import { DeepSeek } from "../src/providers/deepseek.js"
+import * as Cloudflare from "../src/providers/cloudflare.js"
 import * as Google from "../src/providers/google.js"
 import * as GoogleVertex from "../src/providers/google-vertex.js"
 import * as GoogleVertexChat from "../src/providers/google-vertex-chat.js"
@@ -264,10 +263,10 @@ 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", {})
 
-DeepSeek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
+OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
 // @ts-expect-error OpenAI-compatible family selectors only accept model ids.
-DeepSeek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
+OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
 
-CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
+Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
 // @ts-expect-error Cloudflare Workers AI model selectors only accept model ids.
-CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})
+Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})

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

@@ -215,35 +215,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  it.effect("deduplicates tools before counting cache hints", () =>
-    Effect.gen(function* () {
-      const manual = new CacheHint({ type: "ephemeral" })
-      const duplicate = (description: string) => ({
-        name: "lookup",
-        description,
-        inputSchema: { type: "object" },
-        cache: manual,
-      })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          tools: [
-            duplicate("first"),
-            duplicate("second"),
-            duplicate("third"),
-            duplicate("fourth"),
-            { name: "lookup", description: "final", inputSchema: { type: "object" } },
-          ],
-          cache: { tools: true },
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        expect.objectContaining({ name: "lookup", description: "final", cache_control: { type: "ephemeral" } }),
-      ])
-    }),
-  )
-
   it.effect("auto policy preserves manual CacheHints on other parts", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -310,30 +281,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  test("marks the final leaf inside a tool namespace", () => {
-    const request = LLM.request({
-      model: anthropicModel,
-      tools: [
-        {
-          type: "namespace",
-          name: "crm",
-          tools: [
-            { name: "lookup", description: "lookup", inputSchema: {} },
-            { name: "orders", description: "orders", inputSchema: {} },
-          ],
-        },
-      ],
-      cache: { tools: true },
-    })
-    const applied = applyCachePolicy(request)
-    const namespace = applied.tools[0]
-
-    expect(namespace?.type).toBe("namespace")
-    if (namespace?.type !== "namespace") throw new Error("Expected namespace")
-    expect(namespace.tools[0]).not.toHaveProperty("cache")
-    expect(namespace.tools[1]).toHaveProperty("cache", { type: "ephemeral" })
-  })
-
   it.effect("ttlSeconds in the policy flows through to wire markers", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/compile.test.ts

@@ -1,16 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Ref, Schema } from "effect"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import {
-  LLM,
-  LLMRequest,
-  Message,
-  ToolCallPart,
-  ToolDefinition,
-  ToolNamespace,
-  mergeProviderOptions,
-} from "../src/index.js"
-import { AnthropicMessages, OpenAIChat, OpenAIResponses } from "../src/protocols.js"
+import { LLM, LLMRequest, Message, ToolCallPart, ToolDefinition, mergeProviderOptions } from "../src/index.js"
+import { AnthropicMessages, OpenAIChat } from "../src/protocols.js"
 import { Auth, LLMClient } from "../src/route.js"
 import { compileRequest } from "../src/route/client.js"
 import { it } from "./lib/effect.js"
@@ -114,58 +106,6 @@ describe("request option precedence", () => {
     }),
   )
 
-  it.effect("deduplicates tools within each namespace", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenAIResponses.route.model({ id: "gpt-5.4" }),
-          tools: [
-            ToolDefinition.make({ name: "crm", description: "Top-level CRM tool", inputSchema: {} }),
-            ToolNamespace.make({
-              name: "crm",
-              description: "CRM tools",
-              tools: [
-                ToolDefinition.make({ name: "lookup", description: "old", inputSchema: {} }),
-                ToolDefinition.make({ name: "search", description: "search", inputSchema: {} }),
-                ToolDefinition.make({ name: "lookup", description: "new", inputSchema: {} }),
-              ],
-            }),
-            ToolNamespace.make({
-              name: "support",
-              description: "Support tools",
-              tools: [ToolDefinition.make({ name: "lookup", description: "support", inputSchema: {} })],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          name: "crm",
-          description: "Top-level CRM tool",
-          parameters: {},
-          strict: false,
-        },
-        {
-          type: "namespace",
-          name: "crm",
-          description: "CRM tools",
-          tools: [
-            { type: "function", name: "lookup", description: "new", parameters: {}, strict: false },
-            { type: "function", name: "search", description: "search", parameters: {}, strict: false },
-          ],
-        },
-        {
-          type: "namespace",
-          name: "support",
-          description: "Support tools",
-          tools: [{ type: "function", name: "lookup", description: "support", parameters: {}, strict: false }],
-        },
-      ])
-    }),
-  )
-
   it.effect("normalizes tool history before protocol lowering", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/exports.test.ts

@@ -1,18 +1,15 @@
 import { describe, expect, test } from "bun:test"
-import { AIError, ImageInput, LanguageModel, LLM, LLMClient, Provider } from "@opencode/ai"
-import { Route, Protocol, WebSocketTransport } from "@opencode/ai/route"
-import { Provider as ProviderSubpath } from "@opencode/ai/provider"
+import { AIError, ImageInput, LanguageModel, LLM, LLMClient, Provider } from "@opencode-ai/ai"
+import { Route, Protocol, WebSocketTransport } from "@opencode-ai/ai/route"
+import { Provider as ProviderSubpath } from "@opencode-ai/ai/provider"
 import {
-  Baseten,
   CloudflareAIGateway,
   CloudflareWorkersAI,
-  DeepSeek,
-  Fireworks,
   OpenAI,
   OpenAICompatible,
   OpenRouter,
   XAI,
-} from "@opencode/ai/providers"
+} from "@opencode-ai/ai/providers"
 import {
   OpenAIChat,
   OpenAICompatibleChat,
@@ -20,9 +17,9 @@ import {
   OpenAIResponses,
   OpenResponses,
   OpenResponsesChannel,
-} from "@opencode/ai/protocols"
-import * as AnthropicMessages from "@opencode/ai/protocols/anthropic-messages"
-import { TestLLM } from "@opencode/ai/testing"
+} 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", () => {
@@ -46,18 +43,12 @@ describe("public exports", () => {
   })
 
   test("provider barrels expose user-facing facades", async () => {
-    const { OpenAICompatibleResponses } = await import("@opencode/ai/providers")
+    const { OpenAICompatibleResponses } = await import("@opencode-ai/ai/providers")
 
     expect(OpenAI.model).toBeFunction()
     expect(OpenAI.provider.responses).toBe(OpenAI.responses)
     expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
-    for (const provider of [Baseten, DeepSeek, Fireworks]) {
-      expect(provider.configure).toBeFunction()
-      expect(provider.model).toBeFunction()
-    }
-    for (const name of ["baseten", "cerebras", "deepinfra", "deepseek", "fireworks", "groq", "togetherai"]) {
-      expect(OpenAICompatible).not.toHaveProperty(name)
-    }
+    expect(OpenAICompatible.deepseek.model).toBeFunction()
     expect(
       OpenAICompatibleResponses.configure({ baseURL: "https://responses.test/v1" }).model("fixture").route.id,
     ).toBe("openai-compatible-responses")

packages/ai/test/fixtures/recordings/meta-chat/continues-a-generated-tool-call.json

@@ -1,56 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": [
-      "prefix:meta-chat",
-      "provider:meta",
-      "protocol:openai-chat",
-      "tool",
-      "tool-loop",
-      "reasoning",
-      "usage",
-      "effort:low"
-    ],
-    "name": "meta-chat/continues-a-generated-tool-call",
-    "recordedAt": "2026-09-07T16:54:19.772Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"Look up the current weather in Paris using lookup_weather before answering. After receiving the result, report Paris's weather in one short sentence.\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":\"auto\",\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"content\":\"I'll look up the current weather in Paris now.\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"\"}}]},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}]},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{},\"finish_reason\":\"tool_calls\",\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":139,\"prompt_tokens\":570,\"total_tokens\":709,\"completion_tokens_details\":{\"reasoning_tokens\":70},\"prompt_tokens_details\":{\"cached_tokens\":497}}}\n\ndata: [DONE]\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"Look up the current weather in Paris using lookup_weather before answering. After receiving the result, report Paris's weather in one short sentence.\"},{\"role\":\"assistant\",\"content\":\"I'll look up the current weather in Paris now.\",\"tool_calls\":[{\"id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}]},{\"role\":\"tool\",\"tool_call_id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"content\":\"{\\\"condition\\\":\\\"sunny\\\",\\\"temperature\\\":\\\"18C\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":\"auto\",\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\"Paris is currently sunny with a\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\" temperature of 18°C\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\".\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":91,\"prompt_tokens\":666,\"total_tokens\":757,\"completion_tokens_details\":{\"reasoning_tokens\":69},\"prompt_tokens_details\":{\"cached_tokens\":497}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-default-reasoning.json

@@ -1,37 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": [
-      "prefix:meta-chat",
-      "provider:meta",
-      "protocol:openai-chat",
-      "text",
-      "reasoning",
-      "usage",
-      "effort:default"
-    ],
-    "name": "meta-chat/streams-text-with-default-reasoning",
-    "recordedAt": "2026-09-07T16:55:12.540Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07ccb-8ae3-72b3-b321-b5163dda0714\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800109,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07ccb-8ae3-72b3-b321-b5163dda0714\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800109,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":363,\"prompt_tokens\":23,\"total_tokens\":386,\"completion_tokens_details\":{\"reasoning_tokens\":351},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-high-reasoning.json

@@ -1,29 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:high"],
-    "name": "meta-chat/streams-text-with-high-reasoning",
-    "recordedAt": "2026-09-07T16:53:30.276Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"high\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cc9-fe49-7773-b7f3-0be27454d3c3\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800007,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-fe49-7773-b7f3-0be27454d3c3\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800007,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":324,\"prompt_tokens\":23,\"total_tokens\":347,\"completion_tokens_details\":{\"reasoning_tokens\":312},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-low-reasoning.json

@@ -1,29 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:low"],
-    "name": "meta-chat/streams-text-with-low-reasoning",
-    "recordedAt": "2026-09-07T16:53:23.751Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cc9-eb39-7ef3-b886-5d4215128b1d\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-eb39-7ef3-b886-5d4215128b1d\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":157,\"prompt_tokens\":23,\"total_tokens\":180,\"completion_tokens_details\":{\"reasoning_tokens\":145},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-max-reasoning.json

@@ -1,29 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:max"],
-    "name": "meta-chat/streams-text-with-max-reasoning",
-    "recordedAt": "2026-09-07T16:53:33.749Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"max\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cca-10dd-7793-999d-e037320a91de\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800012,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-10dd-7793-999d-e037320a91de\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800012,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":195,\"prompt_tokens\":23,\"total_tokens\":218,\"completion_tokens_details\":{\"reasoning_tokens\":183},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-medium-reasoning.json

@@ -1,37 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": [
-      "prefix:meta-chat",
-      "provider:meta",
-      "protocol:openai-chat",
-      "text",
-      "reasoning",
-      "usage",
-      "effort:medium"
-    ],
-    "name": "meta-chat/streams-text-with-medium-reasoning",
-    "recordedAt": "2026-09-07T16:53:27.292Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"medium\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cc9-f131-7fb0-8895-9f0c3e79220c\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800004,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-f131-7fb0-8895-9f0c3e79220c\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800004,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":273,\"prompt_tokens\":23,\"total_tokens\":296,\"completion_tokens_details\":{\"reasoning_tokens\":261},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-minimal-reasoning.json

@@ -1,37 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": [
-      "prefix:meta-chat",
-      "provider:meta",
-      "protocol:openai-chat",
-      "text",
-      "reasoning",
-      "usage",
-      "effort:minimal"
-    ],
-    "name": "meta-chat/streams-text-with-minimal-reasoning",
-    "recordedAt": "2026-09-07T16:53:22.460Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"minimal\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cc9-e817-7bb1-8dc5-5197d9a4c73e\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-e817-7bb1-8dc5-5197d9a4c73e\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":75,\"prompt_tokens\":23,\"total_tokens\":98,\"completion_tokens_details\":{\"reasoning_tokens\":63},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-chat/streams-text-with-xhigh-reasoning.json

@@ -1,29 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:xhigh"],
-    "name": "meta-chat/streams-text-with-xhigh-reasoning",
-    "recordedAt": "2026-09-07T16:53:32.103Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"xhigh\",\"max_completion_tokens\":1024}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"id\":\"chatcmpl-01a07cca-09de-7083-a0cc-2100de752456\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800010,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-09de-7083-a0cc-2100de752456\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800010,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":253,\"prompt_tokens\":23,\"total_tokens\":276,\"completion_tokens_details\":{\"reasoning_tokens\":241},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/meta-messages/replays-encrypted-thinking-through-a-tool-loop.json

@@ -1,47 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "muse-spark-1.3",
-    "tags": ["prefix:meta-messages", "provider:meta", "protocol:meta-messages", "tool", "tool-loop", "reasoning"],
-    "name": "meta-messages/replays-encrypted-thinking-through-a-tool-loop",
-    "recordedAt": "2026-09-07T17:27:03.540Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Look up the current weather in Paris using lookup_weather. After receiving the result, report Paris's weather in one short sentence.\"}]}],\"tools\":[{\"name\":\"lookup_weather\",\"description\":\"Look up current weather\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"auto\"},\"stream\":true,\"max_tokens\":1024,\"thinking\":{\"type\":\"adaptive\",\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3e5a96d9a155dd4463b\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgGyJ4hIKk41uslnSV0PGvrTkwJ5D-t5skfjtkIt-ABXsehMcLKJJ8RJHRKW2-XhkpPrex0aOkIdqWl99vpCgtOHIFFaSc4b3oGxA8XDx4T_2aKANfYrR1DYwYzGe6ZZ-DQnU0bnpVUzCcXkghkLdyTcJr2p8cvVo1rymFpB0wZsbQRBhxCMR6PrY4i0aOTe8_waq_Po1a4l3YzKnzZIIvYP090o5kltv7MAwqChXjQeTJlKq7ECFa6HVeoTa43oiLmoD2Bzih0VfvBvQfbSh2uDypRM7-f65sp35-VuZfwsM33ZTvefzDbd8zd0D50I6wcybsj8gulDhWWpY7cxoN1Xasy-ImvisACGeppIN66maIFq5dMT2s8_CQ8a2EQ0hw9kwJaIiygZCdRofs-T1yaGWvnQxL6MpNh6SXux9T1ZfuexNrXOhz5cR3_s1euhq3-hI3GDCUDLAtkjiigSE3w6PExrwHTHnvkuAOTP0Lw7DH4NtKv-RFFeZaQOk_0Bi2EV43tR0Hq_chtEDiSpoezDjexPWfdZvhRIaO6PwyJaQ8jVOaLUr6bh6jQ3IM19lv6R7lY4Neno8fLxMwTbf7v7q02lfhOaZe3jR1fqOFUq8e4VXV76_rJBgzThqPNqO8OI_betgX5d2KMcwWAkaZjmrP3rxA7g5xp_Q7bkFiBaaTd3HbYIk_cKbtLOS6TIIphb4SX6ADA2qJ0zoo98P2NOceZODT2WrLjKCHl5dT6b9l2feH9m21pW576ULfKhVSMzuy0cmmWI7rv2P4q-2Fw2klsDVJAc6q22bFjfDgzhybKuhuM_p1SYb8aswNrgggV-cqHWDpF1FdVpL5fHMO74l1uD8Sj_9wuuD0asMQustuvsnYq2EdI0lLvONFMApWCU0s3QA8_P0Iyf0YoCZOm5QGnA7l3O5nAPkFF4kxLSsgRe9zuP6A4oKBDLN8EHwZ3pB4WZGWpUT12cJxplmT3_n8xKaMgaz13qs27uvUm3wMI1seyfpkMwUPHmt1ftpk9f_1OAg3fvQgIkWPTp6K9NzVzEry6SP7zbPfls8yn529Qrbki7ZM_oz3xEvDg367ZCe97eVnjiqRrYsYM2MmDsQq9lUwkgXb84kpK6a4pEzX9NDvhTqhw7RI6RL9E-2Ki4ciUfHv5LVTZ0rNweCo6SYXC11f8FCeObIW_Esr2mqYpORFS4SDMU-4I1HQfD9z6cPjL22APpv9a7Pp1phI8x_aQZkPU7LkyBWyVNDeusI7wq_LC0UgJ0vCAguKcAvN7gxwpCo5MEEZivRuYBldEMwRo4he2WQQke9KEokqREdlPF3Lvaav0fqPfXqhJyHAq8bYBHWdzMjDJ_dJwhdbLQ-iNLmrK5JNg2vPDglWSznBXbrSX4iyMFk1Ni2Y1SQUIOOxS_InIwCg\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"I'll look up the current weather in Paris.\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"input\":{},\"name\":\"lookup_weather\",\"type\":\"tool_use\"},\"index\":2,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"partial_json\":\"{\\\"city\\\":\\\"Paris\\\"}\",\"type\":\"input_json_delta\"},\"index\":2,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":2,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":113,\"input_tokens\":451,\"output_tokens\":155,\"output_tokens_details\":{\"thinking_tokens\":87}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.meta.ai/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Look up the current weather in Paris using lookup_weather. After receiving the result, report Paris's weather in one short sentence.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"redacted_thinking\",\"data\":\"Q-PaDgGyJ4hIKk41uslnSV0PGvrTkwJ5D-t5skfjtkIt-ABXsehMcLKJJ8RJHRKW2-XhkpPrex0aOkIdqWl99vpCgtOHIFFaSc4b3oGxA8XDx4T_2aKANfYrR1DYwYzGe6ZZ-DQnU0bnpVUzCcXkghkLdyTcJr2p8cvVo1rymFpB0wZsbQRBhxCMR6PrY4i0aOTe8_waq_Po1a4l3YzKnzZIIvYP090o5kltv7MAwqChXjQeTJlKq7ECFa6HVeoTa43oiLmoD2Bzih0VfvBvQfbSh2uDypRM7-f65sp35-VuZfwsM33ZTvefzDbd8zd0D50I6wcybsj8gulDhWWpY7cxoN1Xasy-ImvisACGeppIN66maIFq5dMT2s8_CQ8a2EQ0hw9kwJaIiygZCdRofs-T1yaGWvnQxL6MpNh6SXux9T1ZfuexNrXOhz5cR3_s1euhq3-hI3GDCUDLAtkjiigSE3w6PExrwHTHnvkuAOTP0Lw7DH4NtKv-RFFeZaQOk_0Bi2EV43tR0Hq_chtEDiSpoezDjexPWfdZvhRIaO6PwyJaQ8jVOaLUr6bh6jQ3IM19lv6R7lY4Neno8fLxMwTbf7v7q02lfhOaZe3jR1fqOFUq8e4VXV76_rJBgzThqPNqO8OI_betgX5d2KMcwWAkaZjmrP3rxA7g5xp_Q7bkFiBaaTd3HbYIk_cKbtLOS6TIIphb4SX6ADA2qJ0zoo98P2NOceZODT2WrLjKCHl5dT6b9l2feH9m21pW576ULfKhVSMzuy0cmmWI7rv2P4q-2Fw2klsDVJAc6q22bFjfDgzhybKuhuM_p1SYb8aswNrgggV-cqHWDpF1FdVpL5fHMO74l1uD8Sj_9wuuD0asMQustuvsnYq2EdI0lLvONFMApWCU0s3QA8_P0Iyf0YoCZOm5QGnA7l3O5nAPkFF4kxLSsgRe9zuP6A4oKBDLN8EHwZ3pB4WZGWpUT12cJxplmT3_n8xKaMgaz13qs27uvUm3wMI1seyfpkMwUPHmt1ftpk9f_1OAg3fvQgIkWPTp6K9NzVzEry6SP7zbPfls8yn529Qrbki7ZM_oz3xEvDg367ZCe97eVnjiqRrYsYM2MmDsQq9lUwkgXb84kpK6a4pEzX9NDvhTqhw7RI6RL9E-2Ki4ciUfHv5LVTZ0rNweCo6SYXC11f8FCeObIW_Esr2mqYpORFS4SDMU-4I1HQfD9z6cPjL22APpv9a7Pp1phI8x_aQZkPU7LkyBWyVNDeusI7wq_LC0UgJ0vCAguKcAvN7gxwpCo5MEEZivRuYBldEMwRo4he2WQQke9KEokqREdlPF3Lvaav0fqPfXqhJyHAq8bYBHWdzMjDJ_dJwhdbLQ-iNLmrK5JNg2vPDglWSznBXbrSX4iyMFk1Ni2Y1SQUIOOxS_InIwCg\"},{\"type\":\"text\",\"text\":\"I'll look up the current weather in Paris.\"},{\"type\":\"tool_use\",\"id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"name\":\"lookup_weather\",\"input\":{\"city\":\"Paris\"}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"content\":\"{\\\"condition\\\":\\\"sunny\\\"}\"}]}],\"tools\":[{\"name\":\"lookup_weather\",\"description\":\"Look up current weather\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"none\"},\"stream\":true,\"max_tokens\":1024,\"thinking\":{\"type\":\"adaptive\",\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3e77f6ef36fdd8f4925\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgH-GUZkiqnb_seFaP70it_GxAEIUjt2BLllpyzfckiBOUVwr72xGQsSnj0y9aOhoaQ24A_HB0MHh4XWyYziVdRgq6lDPLHkJlmMzbusZxUZUx7D7B8kD8HrBbiTeIFbFlHaM9MiZW_PpYY9fpkdc7aeuX0mORdK8XTT3JPjvW1HPp4Qqp_iEOl9G2iM2Y6xno8SqeTcbc4EQs1LePaKrq86dBPmXBjkgQbYfvIw57o0SBEyelcudtnzJnaluOyOQdV2Ytk_r_xrYSCoBwgbf2KBCOFjdeQyruuwVZZ32JJdVOpWLw8eopUwAo2xYOZP0g8S8hTmOFvDKuzXipm1OoAXwD8Swm6ED3IIo0hHA5xSfMygDCee47nd-EpShNPamkCKodfX1QvePEJsIQK2iTgkh8IGUeEEne5dxgLuXvEAbeqGDvEy6T7IoSgZnc-KPtH6SoWM_kgc_eF_oN73Nxg2prMyCqTUNg5Qs2WLPjA9wSLmmnCoiDr1bYNIuQyn6adgv0-nZZXETJoRAHJBj65Asa8kbLyCYesb192178xCj2aBSdwyj-jc0i328sa9STS7mUSI7KvOt0Yi3kllLs1aSnHW-ogsUJUM7tTf83VO9fRRU_aW4H6qr4OAr8jbBKSD3bxE0AekDd24ZS-8YIjiP1tMOAPZ2JGQrNqbxnaeqhCZzD2nl-E8TMXaAJIk4L3oZtV80xJiUW7mLEf_jQBPAWhph4ujbkDaufGvNrl4FXyBJ-XpKMIA5z0jAYU2b3ul5-Qn5Km7Oc8fPu1M_0XGAOKG-pF9ppr4y-an4B4mKDYoAiSHp3cjv-fW57D87wBfQPaJRjOzWhzqENO-5MlB0CEsnDtrLveE2ui8wSECszParUNk5SEaeSYvrXLY0QkaE7CTK9ljwTKjJM34r1a8o16KFxGuzMrloNlxIYIaO_suM9CDuf8wNwe8KkAV2Kt28g9LwkL5b3mtI7ZSjTdHYOOhFFMzs-sjXboQoGAJGOhMnCQNc3E5-goSzvOzEIXehSTs8Mzyq8d3C2k5F9PSgdO6ZouHVURDgbEXTqWqoqjQ8huk5AbrUX16QwhJambd6P-3i--Idz9CbIVuWIqiMm80TvYlMttobYxTyFDIJrKJTrVA0PkAOFvOMfYt27d7z2ZMrTf6Vtm_DNniuhVbvVU3ZcWbb4LO-XkwH3bfHB-sckpwURP34KzOMvogaqWaMAZlabdd-lQKCc7tMhmo9BrYwHHvLxAELD2qQnyym43Yo1iJNAyrqoUAFk6K029fDon7h9ybmKZdBxRtS3arUesY_91Xep0tA0Y1UYUKo8zKjK3Op_DbVyC5OoR8rxpumKiqk2PtG7RPf-WjEXGkleGqZtxix7ILSkQXxW6McY1r_6LAh2Nv0nUzqS019tTb7mx2OLyt2g\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"It's sunny in Paris.\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"input_tokens\":210,\"output_tokens\":50,\"output_tokens_details\":{\"thinking_tokens\":35}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}