@opencode-ai/ai 0.0.0-next-16420 → 0.0.0-next-16473

package/README.md

@@ -196,7 +196,6 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
-- **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
 - **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.

package/dist/llm.d.ts

@@ -1,21 +1,22 @@
 import { Effect, JsonSchema, Schema } from "effect";
-import { GenerationOptions, HttpOptions, LLMError, LLMRequest, LLMResponse, Message, SystemPart, ToolChoice, ToolDefinition, type ContentPart } from "./schema";
+import { GenerationOptions, HttpOptions, LLMError, LLMRequest, LLMResponse, Message, Model, SystemPart, ToolChoice, ToolDefinition, type ContentPart, type ModelProviderOptions } from "./schema";
 import { type ToolSchema } from "./tool";
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
-export type RequestInput = Omit<ConstructorParameters<typeof LLMRequest>[0], "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
+export type RequestInput<SelectedModel extends Model = Model> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
+    readonly model: SelectedModel;
     readonly system?: string | SystemPart | ReadonlyArray<SystemPart>;
     readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>;
     readonly messages?: ReadonlyArray<Message | Message.Input>;
     readonly tools?: ReadonlyArray<ToolDefinition.Input>;
     readonly toolChoice?: ToolChoice.Input;
     readonly generation?: GenerationOptions.Input;
-    readonly providerOptions?: ConstructorParameters<typeof LLMRequest>[0]["providerOptions"];
+    readonly providerOptions?: NoInfer<ModelProviderOptions<SelectedModel>>;
     readonly http?: HttpOptions.Input;
 };
 export declare const generate: typeof import("./route/client").generate;
 export declare const stream: typeof import("./route/client").stream;
-export declare const request: (input: RequestInput) => LLMRequest;
-type GenerateObjectBase = Omit<RequestInput, "tools" | "toolChoice">;
+export declare const request: <const SelectedModel extends Model>(input: RequestInput<SelectedModel>) => LLMRequest;
+type GenerateObjectBase<SelectedModel extends Model = Model> = Omit<RequestInput<SelectedModel>, "tools" | "toolChoice">;
 export declare class GenerateObjectResponse<T> {
     readonly object: T;
     readonly response: LLMResponse;
@@ -204,10 +205,10 @@ export declare class GenerateObjectResponse<T> {
     })[];
     get usage(): import("./schema").Usage | undefined;
 }
-export interface GenerateObjectOptions<S extends ToolSchema<any>> extends GenerateObjectBase {
+export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedModel extends Model = Model> extends GenerateObjectBase<SelectedModel> {
     readonly schema: S;
 }
-export interface GenerateObjectDynamicOptions extends GenerateObjectBase {
+export interface GenerateObjectDynamicOptions<SelectedModel extends Model = Model> extends GenerateObjectBase<SelectedModel> {
     /** Raw JSON Schema object describing the expected output shape. */
     readonly jsonSchema: JsonSchema.JsonSchema;
 }
@@ -223,6 +224,6 @@ export interface GenerateObjectDynamicOptions extends GenerateObjectBase {
  * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
  *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
  */
-export declare function generateObject<S extends ToolSchema<any>>(options: GenerateObjectOptions<S>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, LLMError>;
-export declare function generateObject(options: GenerateObjectDynamicOptions): Effect.Effect<GenerateObjectResponse<unknown>, LLMError>;
+export declare function generateObject<const SelectedModel extends Model, S extends ToolSchema<any>>(options: GenerateObjectOptions<S, SelectedModel>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, LLMError>;
+export declare function generateObject<const SelectedModel extends Model>(options: GenerateObjectDynamicOptions<SelectedModel>): Effect.Effect<GenerateObjectResponse<unknown>, LLMError>;
 export {};

package/dist/llm.js

@@ -1,6 +1,6 @@
 import { Effect, JsonSchema, Schema } from "effect";
 import { LLMClient } from "./route/client";
-import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, LLMError, LLMEvent, LLMRequest, LLMResponse, Message, SystemPart, ToolChoice, ToolDefinition, } from "./schema";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, LLMError, LLMEvent, LLMRequest, LLMResponse, Message, Model, SystemPart, ToolChoice, ToolDefinition, } from "./schema";
 import { make as makeTool, toDefinitions } from "./tool";
 export const generate = LLMClient.generate;
 export const stream = LLMClient.stream;

package/dist/provider-package.d.ts

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

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

@@ -145,15 +145,27 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<object>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<{
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        }>;
         configure: /*elided*/ any;
     };
 };

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

@@ -203,16 +203,16 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"];
 export * as AnthropicCompatible from "./anthropic-compatible";

package/dist/providers/anthropic.d.ts

@@ -201,16 +201,16 @@ export type Settings = ProviderPackage.Settings & ({
 };
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"];

package/dist/providers/azure.d.ts

@@ -196,22 +196,22 @@ export declare const routes: (RouteDef<{
 }, import("../route/transport/http").HttpPrepared<string>>)[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
-    responses: (modelID: string | ModelID) => import("..").Model;
-    chat: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
-        responses: (modelID: string | ModelID) => import("..").Model;
-        chat: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const responsesModel: ProviderPackage.Definition<Settings>["model"];
-export declare const chatModel: ProviderPackage.Definition<Settings>["model"];
-export declare const model: (modelID: string, settings: Settings) => import("..").Model;
+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("..").Model<OpenAIProviderOptionsInput>;
 export {};

package/dist/providers/azure.js

@@ -54,8 +54,12 @@ export const configure = (input) => {
     const configuredResponsesRoute = configuredRoute(responsesRoute, input);
     const configuredChatRoute = configuredRoute(chatRoute, input);
     const modelDefaults = defaults(input);
-    const responses = (modelID) => configuredResponsesRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID });
-    const chat = (modelID) => configuredChatRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID });
+    const responses = (modelID) => configuredResponsesRoute
+        .with(withOpenAIOptions(modelID, modelDefaults))
+        .model({ id: modelID });
+    const chat = (modelID) => configuredChatRoute
+        .with(withOpenAIOptions(modelID, modelDefaults))
+        .model({ id: modelID });
     return {
         id,
         model: (modelID) => (input.useCompletionUrls === true ? chat(modelID) : responses(modelID)),

package/dist/providers/cloudflare.d.ts

@@ -2,6 +2,7 @@ import type { Config, Redacted } from "effect";
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options";
 import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
+import type { OpenAIProviderOptionsInput } from "./openai-options";
 export declare const aiGatewayID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export declare const workersAIID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export declare const aiGatewayAuthEnvVars: readonly ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"];
@@ -13,15 +14,18 @@ type GatewayURL = AtLeastOne<{
 }> & {
     readonly gatewayId?: string;
 };
-export type AIGatewayOptions = GatewayURL & RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+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 & RouteDefaultsInput & ProviderAuthOption<"optional">;
+export type WorkersAIOptions = WorkersAIURL & Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+};
 export declare const aiGatewayBaseURL: (input: GatewayURL) => string;
 export declare const workersAIBaseURL: (input: WorkersAIURL) => string;
 export declare const aiGatewayRoute: import("../route").Route<{
@@ -229,7 +233,7 @@ export declare const CloudflareAIGateway: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (options: AIGatewayOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
@@ -237,7 +241,7 @@ export declare const CloudflareWorkersAI: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (options: WorkersAIOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/github-copilot.d.ts

@@ -184,18 +184,18 @@ export declare const routes: (import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>)[];
 export declare const configure: (options: ModelOptions) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
-    responses: (modelID: string | ModelID) => import("..").Model;
-    chat: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (options: ModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (options: ModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
-        responses: (modelID: string | ModelID) => import("..").Model;
-        chat: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/github-copilot.js

@@ -31,7 +31,9 @@ const configuredChatRoute = (options) => chatRoute.with({
 export const configure = (options) => {
     const responsesRoute = configuredResponsesRoute(options);
     const chatRoute = configuredChatRoute(options);
-    const responses = (modelID) => responsesRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID });
+    const responses = (modelID) => responsesRoute
+        .with(withOpenAIOptions(modelID, defaults(options)))
+        .model({ id: modelID });
     const chat = (modelID) => chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID });
     return {
         id,

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

@@ -1,12 +1,14 @@
 import type { ProviderPackage } from "../provider-package";
 import type { RouteDefaultsInput } from "../route/client";
-import { type ModelID, type ProviderOptions } from "../schema";
+import { type ModelID } from "../schema";
 import { GoogleVertexShared } from "./google-vertex-shared";
+import type { OpenAIProviderOptionsInput } from "./openai-options";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export interface Settings extends ProviderPackage.Settings {
     readonly accessToken?: string;
@@ -14,7 +16,7 @@ export interface Settings extends ProviderPackage.Settings {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: ProviderOptions;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 }
 export declare const routes: import("../route").Route<{
     readonly model: string;
@@ -85,15 +87,15 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];

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

@@ -201,15 +201,15 @@ export declare const routes: Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"];

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

@@ -1,12 +1,14 @@
 import type { ProviderPackage } from "../provider-package";
 import type { RouteDefaultsInput } from "../route/client";
-import { type ModelID, type ProviderOptions } from "../schema";
+import { type ModelID } from "../schema";
 import { GoogleVertexShared } from "./google-vertex-shared";
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
+    readonly providerOptions?: OpenResponsesProviderOptionsInput;
 };
 export interface Settings extends ProviderPackage.Settings {
     readonly accessToken?: string;
@@ -14,7 +16,7 @@ export interface Settings extends ProviderPackage.Settings {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: ProviderOptions;
+    readonly providerOptions?: OpenResponsesProviderOptionsInput;
 }
 export declare const routes: import("../route").Route<{
     readonly input: readonly ({
@@ -106,15 +108,15 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenResponsesProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenResponsesProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"];

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

@@ -91,15 +91,15 @@ export declare const routes: Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];

package/dist/providers/google.d.ts

@@ -83,20 +83,20 @@ export interface Settings extends ProviderPackage.Settings {
 }
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
 export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;

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

@@ -106,15 +106,15 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenResponsesProviderOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenResponsesProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"];

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

@@ -2,18 +2,21 @@ import { type ModelID } from "../schema";
 import type { RouteDefaultsInput } from "../route/client";
 import { type ProviderAuthOption } from "../route/auth-options";
 import type { ProviderPackage } from "../provider-package";
+import type { OpenAIProviderOptionsInput } from "./openai-options";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-type GenericModelOptions = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly provider?: string;
     readonly baseURL: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export interface Settings extends ProviderPackage.Settings {
     readonly apiKey?: string;
     readonly baseURL: string;
     readonly provider?: string;
 }
-export type FamilyModelOptions = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export declare const routes: import("../route").Route<{
     readonly model: string;
@@ -84,51 +87,51 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input: GenericModelOptions) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input: GenericModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     configure: (input: GenericModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const baseten: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const cerebras: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepinfra: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepseek: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const fireworks: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const groq: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const togetherai: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     configure: (input?: FamilyModelOptions) => /*elided*/ any;
 };
 export {};

package/dist/providers/openai.d.ts

@@ -313,33 +313,33 @@ export interface Settings extends ProviderPackage.Settings {
 }
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (id: string | ModelID) => import("..").Model;
-    responses: (id: string | ModelID) => import("..").Model;
-    responsesWebSocket: (id: string | ModelID) => import("..").Model;
-    chat: (id: string | ModelID) => import("..").Model;
+    model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (id: string | ModelID) => import("..").Model;
-    responses: (id: string | ModelID) => import("..").Model;
-    responsesWebSocket: (id: string | ModelID) => import("..").Model;
-    chat: (id: string | ModelID) => import("..").Model;
+    model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (id: string | ModelID) => import("..").Model;
-        responses: (id: string | ModelID) => import("..").Model;
-        responsesWebSocket: (id: string | ModelID) => import("..").Model;
-        chat: (id: string | ModelID) => import("..").Model;
+        model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings>["model"];
-export declare const chatModel: ProviderPackage.Definition<Settings>["model"];
-export declare const responses: (id: string | ModelID) => import("..").Model;
-export declare const responsesWebSocket: (id: string | ModelID) => import("..").Model;
-export declare const chat: (id: string | ModelID) => import("..").Model;
+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("..").Model<OpenAIProviderOptionsInput>;
+export declare const responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+export declare const chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;

package/dist/providers/openai.js

@@ -38,8 +38,12 @@ export const configure = (input = {}) => {
     const responsesWebSocketRoute = configuredRoute(OpenAIResponses.webSocketRoute, input);
     const chatRoute = configuredRoute(OpenAIChat.route, input);
     const modelDefaults = defaults(input);
-    const responses = (id) => responsesRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id });
-    const responsesWebSocket = (id) => responsesWebSocketRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id });
+    const responses = (id) => responsesRoute
+        .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+        .model({ id });
+    const responsesWebSocket = (id) => responsesWebSocketRoute
+        .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+        .model({ id });
     const chat = (id) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({ id });
     const image = (modelID) => OpenAIImages.model({
         id: modelID,

package/dist/providers/openrouter.d.ts

@@ -330,17 +330,17 @@ export declare const routes: Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: ModelOptions) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
     configure: (input?: ModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
     configure: (input?: ModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: (modelID: string | ModelID) => import("..").Model;
+export declare const model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
 export {};

package/dist/providers/xai.d.ts

@@ -1,9 +1,11 @@
 import { type ProviderAuthOption } from "../route/auth-options";
 import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
+import type { OpenAIProviderOptionsInput } from "./openai-options";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-export type ModelOptions = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export type { XAIImageOptions } from "../protocols/xai-images";
 export declare const routes: (import("../route").Route<{
@@ -181,28 +183,28 @@ export declare const routes: (import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>)[];
 export declare const configure: (input?: ModelOptions) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
-    responses: (modelID: string | ModelID) => import("..").Model;
-    chat: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model;
-    responses: (modelID: string | ModelID) => import("..").Model;
-    chat: (modelID: string | ModelID) => import("..").Model;
+    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model;
-        responses: (modelID: string | ModelID) => import("..").Model;
-        chat: (modelID: string | ModelID) => import("..").Model;
+        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: (modelID: string | ModelID) => import("..").Model;
-export declare const responses: (modelID: string | ModelID) => import("..").Model;
-export declare const chat: (modelID: string | ModelID) => import("..").Model;
+export declare const model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+export declare const responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+export declare const chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;

package/dist/route/client.d.ts

@@ -6,7 +6,7 @@ import { Framing } from "./framing";
 import { HttpTransport } from "./transport";
 import type { Transport, TransportRuntime } from "./transport";
 import type { Protocol } from "./protocol";
-import type { LLMError, PreparedRequestOf, ProtocolID, ProviderOptions } from "../schema";
+import type { LLMError, ProtocolID, ProviderOptions } from "../schema";
 import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMEvent, ProviderID } from "../schema";
 export interface RouteBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */
@@ -26,7 +26,7 @@ export interface Route<Body, Prepared = unknown> {
     readonly defaults: RouteDefaults;
     readonly body: RouteBody<Body>;
     readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>;
-    readonly model: (input: RouteMappedModelInput) => Model;
+    readonly model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) => Model<Options>;
     readonly prepareTransport: (body: Body, request: LLMRequest) => Effect.Effect<Prepared, LLMError>;
     readonly streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<LLMEvent, LLMError>;
 }
@@ -59,17 +59,6 @@ type RouteMappedModelInput = RouteModelInput | RouteRoutedModelInput;
 export declare const generationOptions: (input: GenerationOptions.Input | undefined) => GenerationOptions | undefined;
 export declare const httpOptions: (input: HttpOptionsInput | undefined) => HttpOptions | undefined;
 export interface Interface {
-    /**
-     * Compile a request through protocol body construction, validation, and HTTP
-     * preparation without sending it. Returns the prepared request including the
-     * provider-native body.
-     *
-     * Pass a `Body` type argument to statically expose the route's body
-     * shape (e.g. `prepare<OpenAIChatBody>(...)`) — the runtime body is
-     * identical, so this is a type-level assertion the caller makes about which
-     * route the request will resolve to.
-     */
-    readonly prepare: <Body = unknown>(request: LLMRequest) => Effect.Effect<PreparedRequestOf<Body>, LLMError>;
     readonly stream: StreamMethod;
     readonly generate: GenerateMethod;
 }
@@ -143,7 +132,21 @@ export declare function make<Body, Prepared, Frame, Event, State>(input: MakeTra
  * the public surface preemptively.
  */
 export declare function make<Body, Frame, Event, State>(input: MakeInput<Body, Frame, Event, State>): Route<Body, HttpTransport.HttpPrepared<Frame>>;
-export declare const prepare: <Body = unknown>(request: LLMRequest) => Effect.Effect<PreparedRequestOf<Body>, LLMError>;
+/** @internal Test-only projection of the execution compiler; not exported from package barrels. */
+export declare const compileRequest: (request: LLMRequest) => Effect.Effect<{
+    id: string;
+    route: string;
+    protocol: string;
+    model: Model<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>;
+    body: any;
+    metadata: {
+        transport: string;
+    };
+}, LLMError, never>;
 export declare function stream(request: LLMRequest): Stream.Stream<LLMEvent, LLMError>;
 export declare function generate(request: LLMRequest): Effect.Effect<LLMResponse, LLMError>;
 export declare const streamRequest: (request: LLMRequest) => Stream.Stream<{
@@ -335,7 +338,6 @@ export declare const Route: {
 export declare const LLMClient: {
     readonly Service: typeof Service;
     readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly prepare: <Body = unknown>(request: LLMRequest) => Effect.Effect<PreparedRequestOf<Body>, LLMError>;
     readonly stream: typeof stream;
     readonly generate: typeof generate;
 };

package/dist/route/client.js

@@ -8,7 +8,7 @@ import { HttpTransport } from "./transport";
 import { WebSocketExecutor } from "./transport";
 import { applyCachePolicy } from "../cache-policy";
 import * as ProviderShared from "../protocols/shared";
-import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMError as LLMErrorClass, LLMEvent, PreparedRequest, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema";
+import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMError as LLMErrorClass, LLMEvent, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema";
 const makeRouteModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
     if (!provider)
@@ -141,9 +141,6 @@ export function make(input) {
         defaults: input.defaults,
     });
 }
-// `compile` is the important boundary: it turns a common `LLMRequest` into a
-// validated provider body plus transport-private prepared data, but does not
-// execute transport.
 const compile = Effect.fn("LLM.compile")(function* (request) {
     const resolved = applyCachePolicy(resolveRequestOptions(request));
     const route = resolved.model.route;
@@ -158,16 +155,17 @@ const compile = Effect.fn("LLM.compile")(function* (request) {
         prepared,
     };
 });
-const prepareWith = Effect.fn("LLMClient.prepare")(function* (request) {
+/** @internal Test-only projection of the execution compiler; not exported from package barrels. */
+export const compileRequest = Effect.fn("LLM.compileRequest")(function* (request) {
     const compiled = yield* compile(request);
-    return new PreparedRequest({
+    return {
         id: compiled.request.id ?? "request",
         route: compiled.route.id,
         protocol: compiled.route.protocol,
         model: compiled.request.model,
         body: compiled.body,
         metadata: { transport: compiled.route.transport.id },
-    });
+    };
 });
 const streamRequestWith = (runtime) => (request) => Stream.unwrap(Effect.gen(function* () {
     const compiled = yield* compile(request);
@@ -180,7 +178,6 @@ const generateWith = (stream) => Effect.fn("LLM.generate")(function* (request) {
         return response;
     return yield* ProviderShared.eventError(`${request.model.provider}/${request.model.route.id}`, "Provider stream ended without a terminal finish event");
 });
-export const prepare = (request) => prepareWith(request);
 export function stream(request) {
     return Stream.unwrap(Effect.gen(function* () {
         return (yield* Service).stream(request);
@@ -199,13 +196,12 @@ export const layer = Layer.effect(Service, Effect.gen(function* () {
         http: yield* RequestExecutor.Service,
         webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
     });
-    return Service.of({ prepare: prepareWith, stream, generate: generateWith(stream) });
+    return Service.of({ stream, generate: generateWith(stream) });
 }));
 export const Route = { make };
 export const LLMClient = {
     Service,
     layer,
-    prepare,
     stream,
     generate,
 };

package/dist/schema/events.d.ts

@@ -2446,29 +2446,6 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>;
-declare const PreparedRequest_base: Schema.Class<PreparedRequest, Schema.Struct<{
-    readonly id: Schema.String;
-    readonly route: Schema.String;
-    readonly protocol: Schema.String;
-    readonly model: Schema.declare<import("./options").Model, import("./options").Model>;
-    readonly body: Schema.Unknown;
-    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
-}>, {}>;
-export declare class PreparedRequest extends PreparedRequest_base {
-}
-/**
- * A `PreparedRequest` whose `body` is typed as `Body`. Use with the generic
- * on `LLMClient.prepare<Body>(...)` when the caller knows which route their
- * request will resolve to and wants its native shape statically exposed
- * (debug UIs, request previews, plan rendering).
- *
- * The runtime body is identical — the route still emits `body: unknown` — so
- * this is a type-level assertion the caller makes about what they expect to
- * find. The prepare runtime does not validate the assertion.
- */
-export type PreparedRequestOf<Body> = Omit<PreparedRequest, "body"> & {
-    readonly body: Body;
-};
 interface ContentAssembly {
     readonly contentIndex: number;
     readonly text: string;

package/dist/schema/events.js

@@ -1,6 +1,5 @@
 import { Schema } from "effect";
-import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids";
-import { ModelSchema } from "./options";
+import { ContentBlockID, FinishReason, ProviderMetadata, ToolCallID } from "./ids";
 import { Message, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue } from "./messages";
 import { ProviderFailureClassification } from "./errors";
 /**
@@ -255,15 +254,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
         providerError: llmEventTagged.guards["provider-error"],
     },
 });
-export class PreparedRequest extends Schema.Class("LLM.PreparedRequest")({
-    id: Schema.String,
-    route: RouteID,
-    protocol: ProtocolID,
-    model: ModelSchema,
-    body: Schema.Unknown,
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {
-}
 const responseText = (events) => events
     .filter(LLMEvent.is.textDelta)
     .map((event) => event.text)

package/dist/schema/messages.d.ts

@@ -330,7 +330,15 @@ 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").Model, import("./options").Model>;
+    readonly model: Schema.declare<import("./options").Model<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>, import("./options").Model<{
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    }>>;
     readonly system: Schema.$Array<Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;

package/dist/schema/options.d.ts

@@ -89,16 +89,17 @@ export declare namespace ModelCompatibility {
     /** Normalize model/upstream compatibility metadata without projecting requests. */
     const make: (input: Input) => ModelCompatibility;
 }
-export declare class Model {
+export declare class Model<Options extends ProviderOptions = ProviderOptions> {
+    protected readonly _ProviderOptions: Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
     readonly route: AnyRoute;
     readonly defaults?: ModelDefaults;
     readonly compatibility?: ModelCompatibility;
     constructor(input: Model.ConstructorInput);
-    static make(input: Model.Input): Model;
-    static input(model: Model): Model.ConstructorInput;
-    static update(model: Model, patch: Partial<Model.Input>): Model;
+    static make<Options extends ProviderOptions = ProviderOptions>(input: Model.Input): Model<Options>;
+    static input<Options extends ProviderOptions>(model: Model<Options>): Model.ConstructorInput;
+    static update<Options extends ProviderOptions>(model: Model<Options>, patch: Partial<Model.Input>): Model<Options>;
 }
 export declare namespace Model {
     type ConstructorInput = {
@@ -116,7 +117,16 @@ export declare namespace Model {
     };
 }
 export type ModelInput = Model.Input;
-export declare const ModelSchema: Schema.declare<Model, Model>;
+export type ModelProviderOptions<SelectedModel> = SelectedModel extends Model<infer Options> ? Options : never;
+export declare const ModelSchema: Schema.declare<Model<{
+    readonly [x: string]: {
+        readonly [x: string]: unknown;
+    };
+}>, Model<{
+    readonly [x: string]: {
+        readonly [x: string]: unknown;
+    };
+}>>;
 declare const CacheHint_base: Schema.Class<CacheHint, Schema.Struct<{
     readonly type: Schema.Literals<readonly ["ephemeral", "persistent"]>;
     readonly ttlSeconds: Schema.optional<Schema.Number>;

package/dist/testing.js

@@ -45,7 +45,6 @@ export const layer = (options = {}) => Layer.effect(Service, Effect.gen(function
         return Stream.unwrap(Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)));
     });
     const client = LLMClient.Service.of({
-        prepare: () => Effect.die("TestLLM does not prepare provider-native requests"),
         stream,
         generate: (request) => stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce), Effect.flatMap((state) => {
             const response = LLMResponse.complete(state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16420",
+  "version": "0.0.0-next-16473",
   "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.101",
-    "@opencode-ai/http-recorder": "0.0.0-next-16420",
+    "@opencode-ai/http-recorder": "0.0.0-next-16473",
     "@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-next-16420",
+    "@opencode-ai/schema": "0.0.0-next-16473",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.101",
     "google-auth-library": "10.5.0"