@opencode-ai/ai 0.0.0-dev-17681 → 0.0.0-dev-17684

package/README.md

@@ -237,11 +237,11 @@ 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 tools, the base agent, project instructions, and the active conversation. The rolling final-message boundary is the load-bearing detail in tool loops: it advances on every request so the previous cache entry stays within Anthropic's 20-block lookback.
+`"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.
 
-The math justifies the default: Anthropic's 5-minute cache write is 1.25× base, read is 0.1×, so a single reuse within 5 minutes already wins. One-shot completions below the per-model minimum-cacheable-token threshold silently no-op on the wire, so the worst case is harmless.
+Requests below a provider's minimum cacheable size simply do not produce a reusable cache entry.
 
 ### Opting out
 
@@ -285,6 +285,7 @@ LLM.request({
 | ----------------------- | ------------------------------------------------------------------------- |
 | Anthropic Messages      | emits up to 4 `cache_control` markers (4-breakpoint cap enforced)         |
 | Bedrock Converse        | emits up to 4 `cachePoint` blocks (4-breakpoint cap enforced)             |
+| OpenRouter              | emits up to 4 `cache_control` markers                                     |
 | OpenAI Chat / Responses | no-op (implicit caching above 1024 tokens)                                |
 | Gemini                  | no-op (implicit caching on 2.5+; explicit `CachedContent` is out-of-band) |
 
@@ -371,11 +372,23 @@ Request options in order of stability:
 
 1. **`generation`** — portable knobs (`maxTokens`, `temperature`, `topP`, `topK`, penalties, seed, stop).
 2. **`promptCacheKey`** — stable cache affinity lowered by every protocol that supports it.
-3. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `store`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
+3. **`providerOptions: { ... }`** — flat options inferred from the selected model (OpenAI `store`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
 4. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
 
 Route/provider defaults are overridden by request-level values for each axis.
 
+The selected model supplies the provider-specific option type, so per-request overrides stay flat while the canonical runtime request remains provider-neutral:
+
+```ts
+LLM.request({
+  model,
+  prompt,
+  providerOptions: {
+    reasoningEffort: "low",
+  },
+})
+```
+
 ## Routes
 
 Adding a new model or deployment is usually 5-15 lines using `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports are reusable IO templates that receive route endpoint/auth at compile time. Capability/catalog metadata lives outside this low-level package; unsupported request shapes fail during protocol lowering. See `AGENTS.md` for the architectural detail.
@@ -387,6 +400,5 @@ This package is built on Effect. Public methods return `Effect` or `Stream`; pro
 ## See also
 
 - `AGENTS.md` — architecture, route construction, contributor guide
-- `STATUS.md` — native provider parity status and AI SDK migration gaps
 - `example/tutorial.ts` — runnable end-to-end walkthrough
 - `test/provider/*.test.ts` — fixture-first protocol tests; `*.recorded.test.ts` files cover live cassettes

package/dist/cache-policy.js

@@ -5,8 +5,8 @@
 // The default `"auto"` shape places breakpoints at the last tool definition,
 // the first and last distinct system parts, and the conversation tail. This
 // exposes reusable tool, base-agent, project, and session prefixes while
-// advancing the tail after each tool result keeps the previous cache entry
-// within Anthropic's 20-block lookback during long agent turns.
+// advancing the tail after each tool result keeps recent conversation prefixes
+// reusable during long agent runs.
 //
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
@@ -20,9 +20,7 @@ const AUTO = {
 const NONE = {};
 const BREAKPOINT_CAP = 4;
 // Resolution rules:
-//   - undefined   → "auto" — caching is on by default. The math favors it:
-//                   Anthropic 5m-cache write is 1.25x base, read is 0.1x,
-//                   so a single reuse within 5 minutes already wins.
+//   - undefined   → "auto" — caching is on by default.
 //   - "auto"      → tools + first/last system + final message boundary.
 //   - "none"      → no auto placement; manual `CacheHint`s still flow.
 //   - object form → exactly what the caller asked for.

package/dist/protocols/anthropic-messages.d.ts

@@ -1,7 +1,6 @@
 import { Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
-import { type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
@@ -25,9 +24,7 @@ export interface OptionsInput {
     readonly thinking?: ThinkingInput;
     readonly effort?: string;
 }
-export type ProviderOptionsInput = ProviderOptions & {
-    readonly anthropic?: OptionsInput;
-};
+export type ProviderOptionsInput = OptionsInput;
 export declare const AnthropicMessagesBody: Schema.Struct<{
     model: Schema.String;
     system: Schema.optional<Schema.$Array<Schema.Struct<{
@@ -207,8 +204,8 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>;
 /**
  * The Anthropic Messages protocol — request body construction, body schema,
- * and the streaming-event state machine. Used by native Anthropic Cloud and
- * (once registered) Vertex Anthropic / Bedrock-hosted Anthropic passthrough.
+ * and the streaming-event state machine shared by Anthropic-compatible and
+ * Vertex-hosted Messages routes.
  */
 export declare const protocol: Protocol<{
     readonly max_tokens: number;

package/dist/protocols/anthropic-messages.js

@@ -468,7 +468,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     return messages;
 });
 const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request) {
-    const input = request.providerOptions?.anthropic;
+    const input = request.providerOptions;
     return {
         thinking: yield* resolveThinking(input?.thinking),
         effort: typeof input?.effort === "string" ? input.effort : undefined,
@@ -844,8 +844,8 @@ const step = (state, event) => {
 // =============================================================================
 /**
  * The Anthropic Messages protocol — request body construction, body schema,
- * and the streaming-event state machine. Used by native Anthropic Cloud and
- * (once registered) Vertex Anthropic / Bedrock-hosted Anthropic passthrough.
+ * and the streaming-event state machine shared by Anthropic-compatible and
+ * Vertex-hosted Messages routes.
  */
 export const protocol = Protocol.make({
     id: ADAPTER,

package/dist/protocols/gemini.d.ts

@@ -1,7 +1,6 @@
 import { Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
-import { type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 export interface OptionsInput {
@@ -18,9 +17,7 @@ export interface OptionsInput {
         readonly thinkingLevel?: "minimal" | "low" | "medium" | "high" | (string & {});
     };
 }
-export type ProviderOptionsInput = ProviderOptions & {
-    readonly gemini?: OptionsInput;
-};
+export type ProviderOptionsInput = OptionsInput;
 declare const GeminiBody: Schema.Struct<{
     cachedContent: Schema.optional<Schema.String>;
     contents: Schema.$Array<Schema.Struct<{
@@ -98,8 +95,7 @@ declare const GeminiBody: Schema.Struct<{
 export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>;
 /**
  * The Gemini protocol — request body construction, body schema, and the
- * streaming-event state machine. Used by Google AI Studio Gemini and (once
- * registered) Vertex Gemini.
+ * streaming-event state machine shared by Google AI Studio and Vertex Gemini.
  */
 export declare const protocol: Protocol<{
     readonly contents: readonly {

package/dist/protocols/gemini.js

@@ -293,7 +293,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     return contents;
 });
 const resolveOptions = (request) => {
-    const input = request.providerOptions?.gemini;
+    const input = request.providerOptions;
     const value = input?.thinkingConfig;
     const thinkingConfig = {
         thinkingBudget: ProviderShared.isRecord(value) && typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined,
@@ -491,8 +491,7 @@ const step = (state, event) => {
 // =============================================================================
 /**
  * The Gemini protocol — request body construction, body schema, and the
- * streaming-event state machine. Used by Google AI Studio Gemini and (once
- * registered) Vertex Gemini.
+ * streaming-event state machine shared by Google AI Studio and Vertex Gemini.
  */
 export const protocol = Protocol.make({
     id: ADAPTER,

package/dist/protocols/open-responses.js

@@ -214,7 +214,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         name: tool.name,
         description: tool.description,
         parameters: ToolSchemaProjection.responses(inputSchema),
-        // TODO: Read this from Responses tool options so direct LLM callers can opt into strict schemas.
+        // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
 });

package/dist/protocols/openai-responses.js

@@ -203,6 +203,6 @@ export const route = Route.make({
     endpoint,
     auth,
     transport,
-    defaults: { providerOptions: { openai: { store: false } } },
+    defaults: { providerOptions: { store: false } },
 });
 export * as OpenAIResponses from "./openai-responses.js";

package/dist/protocols/shared.d.ts

@@ -26,12 +26,10 @@ export interface ToolAccumulator {
  * when at least one is defined. Returns `undefined` when neither input nor
  * output is known so routes don't publish a misleading `0`.
  *
- * Under the additive `AI.Usage` contract, `inputTokens` and `outputTokens`
- * are the non-cached input and visible output only. The provider-supplied
- * `total` is the source of truth when present; the computed fallback
- * under-counts cache and reasoning by design and exists mainly so
- * Anthropic-style providers (which don't surface a total) still get a
- * sensible aggregate on the input + output axes.
+ * Under the inclusive `AI.Usage` contract, `inputTokens` includes cached input
+ * and `outputTokens` includes reasoning. Protocol mappers normalize those
+ * inclusive values before calling this helper. The provider-supplied total is
+ * the source of truth when present; otherwise their sum is the canonical total.
  */
 export declare const totalTokens: (inputTokens: number | undefined, outputTokens: number | undefined, total: number | undefined) => number | undefined;
 /**
@@ -43,7 +41,7 @@ export declare const totalTokens: (inputTokens: number | undefined, outputTokens
  *
  * If `total` is `undefined`, returns `undefined` (we don't fabricate
  * counts). If `subtrahend` is `undefined`, returns `total` unchanged. The
- * provider-native breakdown stays available on `Usage.native` for debugging.
+ * provider-native breakdown stays available on `Usage.providerMetadata` for debugging.
  */
 export declare const subtractTokens: (total: number | undefined, subtrahend: number | undefined) => number | undefined;
 /**
@@ -117,19 +115,15 @@ export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
- * `decodeChunk` sees one JSON string per element. The SSE channel emits a
+ * decoder, and drops empty / `[DONE]` keep-alive events so the protocol event
+ * schema sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
  * implement client-driven retries). Decoder failures become provider output
  * errors so the public error channel stays `AIError`.
  */
 export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<string, AIError>;
 /**
- * Canonical invalid-request constructor. Lift one-line `const invalid =
- * (message) => invalidRequest(message)` aliases out of every
- * route so the error constructor lives in one place. If we ever extend
- * `InvalidRequestReason` with route context or trace metadata, the change
- * lands here.
+ * Canonical invalid-request constructor shared by protocol lowering.
  */
 export declare const invalidRequest: (message: string) => AIError;
 export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {

package/dist/protocols/shared.js

@@ -19,12 +19,10 @@ export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
  * when at least one is defined. Returns `undefined` when neither input nor
  * output is known so routes don't publish a misleading `0`.
  *
- * Under the additive `AI.Usage` contract, `inputTokens` and `outputTokens`
- * are the non-cached input and visible output only. The provider-supplied
- * `total` is the source of truth when present; the computed fallback
- * under-counts cache and reasoning by design and exists mainly so
- * Anthropic-style providers (which don't surface a total) still get a
- * sensible aggregate on the input + output axes.
+ * Under the inclusive `AI.Usage` contract, `inputTokens` includes cached input
+ * and `outputTokens` includes reasoning. Protocol mappers normalize those
+ * inclusive values before calling this helper. The provider-supplied total is
+ * the source of truth when present; otherwise their sum is the canonical total.
  */
 export const totalTokens = (inputTokens, outputTokens, total) => {
     if (total !== undefined)
@@ -42,7 +40,7 @@ export const totalTokens = (inputTokens, outputTokens, total) => {
  *
  * If `total` is `undefined`, returns `undefined` (we don't fabricate
  * counts). If `subtrahend` is `undefined`, returns `total` unchanged. The
- * provider-native breakdown stays available on `Usage.native` for debugging.
+ * provider-native breakdown stays available on `Usage.providerMetadata` for debugging.
  */
 export const subtractTokens = (total, subtrahend) => {
     if (total === undefined)
@@ -151,19 +149,15 @@ export const errorText = (error) => {
 };
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
- * `decodeChunk` sees one JSON string per element. The SSE channel emits a
+ * decoder, and drops empty / `[DONE]` keep-alive events so the protocol event
+ * schema sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
  * implement client-driven retries). Decoder failures become provider output
  * errors so the public error channel stays `AIError`.
  */
 export const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipeThroughChannel(Sse.decode()), Stream.catchTag("Retry", () => Stream.empty), Stream.catchTag("SseError", (error) => Stream.fail(eventError("sse", error.message))), Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"), Stream.map((event) => event.data));
 /**
- * Canonical invalid-request constructor. Lift one-line `const invalid =
- * (message) => invalidRequest(message)` aliases out of every
- * route so the error constructor lives in one place. If we ever extend
- * `InvalidRequestReason` with route context or trace metadata, the change
- * lands here.
+ * Canonical invalid-request constructor shared by protocol lowering.
  */
 export const invalidRequest = (message) => new AIError({
     module: "ProviderShared",

package/dist/protocols/utils/bedrock-cache.js

@@ -2,16 +2,15 @@ import { Schema } from "effect";
 import { newBreakpoints, ttlBucket } 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
-// accepts optional `ttl: "5m" | "1h"` on cachePoint, mirroring Anthropic.
+// accepts optional `ttl: "5m" | "1h"` on cachePoint.
 export const CachePointBlock = Schema.Struct({
     cachePoint: Schema.Struct({
         type: Schema.tag("default"),
         ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
     }),
 });
-// Bedrock-Claude enforces the same 4-breakpoint cap as the Anthropic Messages
-// API. Callers pass a shared counter through every `block()` call site so the
-// budget is respected 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 = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP);
 const DEFAULT_5M = { cachePoint: { type: "default" } };

package/dist/protocols/utils/cache.js

@@ -1,8 +1,5 @@
-// Shared helpers for provider cache-marker lowering. Anthropic and Bedrock
-// both enforce a 4-breakpoint cap per request and accept the same `5m`/`1h`
-// TTL buckets, so the counter and TTL mapping live here.
+// Shared counter and TTL mapping for provider cache-marker lowering.
 export const newBreakpoints = (cap) => ({ remaining: cap, dropped: 0 });
-// Returns `"1h"` for any `ttlSeconds >= 3600`, otherwise `undefined` (the
-// provider default 5m). Anthropic & Bedrock both treat anything shorter than
-// an hour as 5m.
+// Requests of at least one hour use the explicit `"1h"` bucket; shorter
+// requests omit the wire TTL and use the provider default.
 export const ttlBucket = (ttlSeconds) => ttlSeconds !== undefined && ttlSeconds >= 3600 ? "1h" : undefined;

package/dist/protocols/utils/open-responses-options.js

@@ -38,7 +38,7 @@ export const Options = Schema.Struct({
 });
 const decodeOptions = Schema.decodeUnknownOption(Options);
 export const resolve = (request) => {
-    const input = Option.getOrUndefined(decodeOptions(request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"]));
+    const input = Option.getOrUndefined(decodeOptions(request.providerOptions));
     if (!input)
         return {};
     return {

package/dist/providers/amazon-bedrock-mantle.d.ts

@@ -237,24 +237,24 @@ export declare const routes: (RouteDef<{
 }, import("../protocols/open-responses-channel.js").Prepared>)[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;

package/dist/providers/amazon-bedrock.d.ts

@@ -146,25 +146,19 @@ export declare const routes: import("../route/client.js").Route<{
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
+            readonly [x: string]: unknown;
         }>;
         configure: /*elided*/ any;
     };

package/dist/providers/anthropic-compatible.d.ts

@@ -203,14 +203,14 @@ export declare const routes: import("../route/client.js").Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/anthropic.d.ts

@@ -201,15 +201,15 @@ export type Settings = ProviderPackage.Settings & ({
 };
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/azure.d.ts

@@ -240,22 +240,22 @@ export declare const routes: (RouteDef<{
 }, import("../protocols/open-responses-channel.js").Prepared>)[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
 export {};

package/dist/providers/cloudflare.d.ts

@@ -323,7 +323,7 @@ export declare const CloudflareAIGateway: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (options: AIGatewayOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };
@@ -331,7 +331,7 @@ export declare const CloudflareWorkersAI: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (options: WorkersAIOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-chat.d.ts

@@ -117,14 +117,14 @@ export declare const routes: import("../route/client.js").Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-messages.d.ts

@@ -201,14 +201,14 @@ export declare const routes: Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.OptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-responses.d.ts

@@ -121,14 +121,14 @@ export declare const routes: import("../route/client.js").Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenResponsesProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenResponsesProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-responses.js

@@ -5,7 +5,7 @@ export const id = ProviderID.make("google-vertex");
 const route = OpenAICompatibleResponses.route.with({
     id: "google-vertex-responses",
     provider: id,
-    providerOptions: { openresponses: { store: false } },
+    providerOptions: { store: false },
 });
 export const routes = [route];
 const configuredRoute = (input) => {

package/dist/providers/google-vertex.d.ts

@@ -1,14 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js";
 import { Gemini } from "../protocols/gemini.js";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
-import { type ModelID, type ProviderOptions } from "../schema/index.js";
+import { type ModelID } from "../schema/index.js";
 import { GoogleVertexShared } from "./google-vertex-shared.js";
 export interface GeminiOptionsInput extends Gemini.OptionsInput {
     readonly labels?: Readonly<Record<string, string>>;
 }
-export type GeminiProviderOptionsInput = ProviderOptions & {
-    readonly gemini?: GeminiOptionsInput;
-};
+export type GeminiProviderOptionsInput = GeminiOptionsInput;
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.ApiKeyOptions & {
     readonly baseURL?: string;
@@ -108,14 +106,14 @@ export declare const routes: Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex.js

@@ -10,7 +10,7 @@ import { GoogleVertexShared } from "./google-vertex-shared.js";
 export const id = ProviderID.make("google-vertex");
 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request) {
     const body = yield* Gemini.protocol.body.from(request);
-    const value = request.providerOptions?.gemini?.labels;
+    const value = request.providerOptions?.labels;
     const labels = ProviderShared.isRecord(value)
         ? Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"))
         : undefined;

package/dist/providers/google.d.ts

@@ -96,17 +96,17 @@ export interface Settings extends ProviderPackage.Settings {
 }
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
         configure: /*elided*/ any;
     };

package/dist/providers/open-responses-options.d.ts

@@ -1,9 +1,6 @@
 import type { Options } from "../protocols/utils/open-responses-options.js";
-import type { ProviderOptions } from "../schema/index.js";
 export type OpenResponsesOptionsInput = Options & {
     readonly [key: string]: unknown;
 };
-export type OpenResponsesProviderOptionsInput = ProviderOptions & {
-    readonly openresponses?: OpenResponsesOptionsInput;
-};
+export type OpenResponsesProviderOptionsInput = OpenResponsesOptionsInput;
 export * as OpenResponsesProviderOptions from "./open-responses-options.js";

package/dist/providers/openai-compatible-responses.d.ts

@@ -119,14 +119,14 @@ export declare const routes: import("../route/client.js").Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenResponsesProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenResponsesProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/openai-compatible.d.ts

@@ -118,51 +118,51 @@ export declare const routes: import("../route/client.js").Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input: GenericModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input: GenericModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: GenericModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const baseten: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const cerebras: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepinfra: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepseek: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const fireworks: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const groq: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const togetherai: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export {};

package/dist/providers/openai-options.d.ts

@@ -1,10 +1,8 @@
-import type { ProviderOptions } from "../schema/index.js";
+import { type ProviderOptions } from "../schema/index.js";
 import type { OpenResponsesOptionsInput } from "./open-responses-options.js";
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js";
 export type OpenAIOptionsInput = OpenResponsesOptionsInput;
-export type OpenAIProviderOptionsInput = ProviderOptions & {
-    readonly openai?: OpenAIOptionsInput;
-};
+export type OpenAIProviderOptionsInput = OpenAIOptionsInput;
 export declare const gpt5DefaultOptions: (modelID: string, options?: {
     readonly textVerbosity?: boolean;
 }) => ProviderOptions | undefined;

package/dist/providers/openai-options.js

@@ -1,7 +1,7 @@
 import { mergeProviderOptions } from "../schema/index.js";
 const definedEntries = (input) => Object.entries(input).filter((entry) => entry[1] !== undefined);
 const openAIProviderOptions = (options) => {
-    const openai = Object.fromEntries(definedEntries({
+    const result = Object.fromEntries(definedEntries({
         store: options?.store,
         reasoningEffort: options?.reasoningEffort,
         reasoningSummary: options?.reasoningSummary,
@@ -9,9 +9,9 @@ const openAIProviderOptions = (options) => {
         textVerbosity: options?.textVerbosity,
         serviceTier: options?.serviceTier,
     }));
-    if (Object.keys(openai).length === 0)
+    if (Object.keys(result).length === 0)
         return undefined;
-    return { openai };
+    return result;
 };
 export const gpt5DefaultOptions = (modelID, options = {}) => {
     const id = modelID.toLowerCase();

package/dist/providers/openai.d.ts

@@ -249,29 +249,29 @@ export interface Settings extends ProviderPackage.Settings {
 }
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-    chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-        chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
-export declare const chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+export declare const responses: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+export declare const chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;

package/dist/providers/openrouter.d.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { type ModelID, type ProviderOptions } from "../schema/index.js";
+import { type ModelID } from "../schema/index.js";
 import type { ProviderPackage } from "../provider-package.js";
 import * as OpenAIChat from "../protocols/openai-chat.js";
 export declare const profile: {
@@ -76,9 +76,7 @@ export interface OpenRouterOptions {
         engine?: OpenRouterString<"native" | "exa">;
     }>;
 }
-export type OpenRouterProviderOptionsInput = ProviderOptions & {
-    readonly openrouter?: OpenRouterOptions;
-};
+export type OpenRouterProviderOptionsInput = OpenRouterOptions;
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: OpenRouterProviderOptionsInput;
@@ -521,15 +519,15 @@ export declare const routes: Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions>;
     configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions>;
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/openrouter.js

@@ -42,7 +42,7 @@ export const protocol = Protocol.make({
             return {
                 ...body,
                 messages,
-                ...bodyOptions(request.providerOptions?.openrouter),
+                ...bodyOptions(request.providerOptions),
                 ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
             };
         })),

package/dist/providers/xai.d.ts

@@ -1,12 +1,10 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
-import { type ModelID, type ProviderOptions } from "../schema/index.js";
+import { type ModelID } from "../schema/index.js";
 import type { OpenAIOptionsInput } from "./openai-options.js";
 import type { ProviderPackage } from "../provider-package.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-export type XAIProviderOptionsInput = ProviderOptions & {
-    readonly xai?: OpenAIOptionsInput;
-};
+export type XAIProviderOptionsInput = OpenAIOptionsInput;
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: XAIProviderOptionsInput;
@@ -235,28 +233,28 @@ export declare const routes: (Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>)[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
     configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"];
-export declare const responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+export declare const responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;

package/dist/providers/xai.js

@@ -15,7 +15,7 @@ const responsesRoute = Route.make({
     protocol: OpenAIResponses.protocol,
     endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
     transport: OpenAIResponses.httpTransport,
-    defaults: { providerOptions: { xai: { store: false } } },
+    defaults: { providerOptions: { store: false } },
 });
 const chatRoute = Route.make({
     id: "openai-compatible-chat",

package/dist/route/client.d.ts

@@ -142,9 +142,7 @@ export declare const compileRequest: (request: LLMRequest) => Effect.Effect<{
     route: string;
     protocol: string;
     model: LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>;
     body: any;
     metadata: {

package/dist/route/framing.d.ts

@@ -11,8 +11,8 @@ import type { AIError } from "../schema/index.js";
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
- * The frame type is opaque to this layer; the protocol's `decode` step turns
- * a frame into a typed chunk.
+ * The frame type is opaque to this layer; the protocol's event schema decodes
+ * each frame before its state machine handles it.
  */
 export interface Definition<Frame> {
     readonly id: string;

package/dist/route/protocol.d.ts

@@ -69,8 +69,7 @@ export interface ProtocolStream<Frame, Event, State> {
  *
  * Provider implementations should usually call `Protocol.make({ ... })`
  * without explicit type arguments; the schemas and parser functions are the
- * source of truth. The constructor remains as the public seam for future
- * cross-cutting concerns such as tracing or instrumentation.
+ * source of truth.
  */
 export declare const make: <Body, Frame, Event, State>(input: Protocol<Body, Frame, Event, State>) => Protocol<Body, Frame, Event, State>;
 export declare const jsonEvent: <const S extends Schema.Top>(schema: S) => Schema.fromJsonString<S>;

package/dist/route/protocol.js

@@ -9,8 +9,7 @@ import { Schema } from "effect";
  *
  * Provider implementations should usually call `Protocol.make({ ... })`
  * without explicit type arguments; the schemas and parser functions are the
- * source of truth. The constructor remains as the public seam for future
- * cross-cutting concerns such as tracing or instrumentation.
+ * source of truth.
  */
 export const make = (input) => input;
 export const jsonEvent = (schema) => Schema.fromJsonString(schema);

package/dist/schema/messages.d.ts

@@ -362,13 +362,9 @@ export declare namespace ToolChoice {
 declare const LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
     readonly id: Schema.optional<Schema.String>;
     readonly model: Schema.declare<import("./options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>, import("./options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>>;
     readonly system: Schema.$Array<Schema.Struct<{
         readonly type: Schema.Literal<"text">;
@@ -383,7 +379,7 @@ declare const LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
     readonly tools: Schema.$Array<typeof ToolDefinition>;
     readonly toolChoice: Schema.optional<typeof ToolChoice>;
     readonly generation: Schema.optional<typeof GenerationOptions>;
-    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly http: Schema.optional<typeof HttpOptions>;
     readonly cache: Schema.optional<Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<"none">, Schema.Struct<{
         readonly tools: Schema.optional<Schema.Boolean>;

package/dist/schema/options.d.ts

@@ -4,7 +4,7 @@ import type { AnyRoute } from "../route/client.js";
 export declare const JsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
 export type JsonSchema = Schema.Schema.Type<typeof JsonSchema>;
 export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
-export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.Unknown>;
 export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
 export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
@@ -64,7 +64,7 @@ export declare namespace LanguageModelLimits {
 declare const LanguageModelDefaults_base: Schema.Class<LanguageModelDefaults, Schema.Struct<{
     readonly limits: Schema.optional<typeof LanguageModelLimits>;
     readonly generation: Schema.optional<typeof GenerationOptions>;
-    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly http: Schema.optional<typeof HttpOptions>;
 }>, {}>;
 export declare class LanguageModelDefaults extends LanguageModelDefaults_base {
@@ -126,13 +126,9 @@ export declare namespace LanguageModel {
 export type LanguageModelInput = LanguageModel.Input;
 export type LanguageModelProviderOptions<SelectedModel> = SelectedModel extends LanguageModel<infer Options> ? Options : never;
 export declare const LanguageModelSchema: Schema.declare<LanguageModel<{
-    readonly [x: string]: {
-        readonly [x: string]: unknown;
-    };
+    readonly [x: string]: unknown;
 }>, LanguageModel<{
-    readonly [x: string]: {
-        readonly [x: string]: unknown;
-    };
+    readonly [x: string]: unknown;
 }>>;
 declare const CacheHint_base: Schema.Class<CacheHint, Schema.Struct<{
     readonly type: Schema.Literals<readonly ["ephemeral", "persistent"]>;

package/dist/schema/options.js

@@ -27,20 +27,8 @@ const mergeStringRecords = (...items) => {
     const result = Object.fromEntries(defined.flatMap((item) => Object.entries(item).filter((entry) => entry[1] !== undefined)));
     return Object.keys(result).length === 0 ? undefined : result;
 };
-export const ProviderOptions = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown));
-export const mergeProviderOptions = (...items) => {
-    const result = {};
-    for (const item of items) {
-        if (!item)
-            continue;
-        for (const [provider, options] of Object.entries(item)) {
-            const merged = mergeJsonRecords(result[provider], options);
-            if (merged)
-                result[provider] = merged;
-        }
-    }
-    return Object.keys(result).length === 0 ? undefined : result;
-};
+export const ProviderOptions = Schema.Record(Schema.String, Schema.Unknown);
+export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -182,10 +170,9 @@ export class CacheHint extends Schema.Class("LLM.CacheHint")({
 // Auto-placement policy for prompt caching. The protocol-neutral lowering step
 // reads this and injects `CacheHint`s at the configured boundaries; the
 // per-protocol body builders then translate those hints into wire markers as
-// usual. `"auto"` is the recommended default for agent loops — it places
+// usual. `"auto"` is the default for agent loops — it places
 // breakpoints at the last tool definition, the first and last distinct system
-// parts, and the conversation tail. The rolling message breakpoint keeps a
-// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
+// parts, and the conversation tail so recent prefixes remain reusable during
 // tool loops.
 //
 // Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-17681",
+  "version": "0.0.0-dev-17684",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.107",
-    "@opencode-ai/http-recorder": "0.0.0-dev-17681",
+    "@opencode-ai/http-recorder": "0.0.0-dev-17684",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-dev-17681",
+    "@opencode-ai/schema": "0.0.0-dev-17684",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.107",
     "google-auth-library": "10.5.0"