@opencode-ai/ai 0.0.0-beta-17639 → 0.0.0-beta-17728

package/dist/protocols/utils/open-responses-options.d.ts

@@ -1,25 +1,56 @@
 import { Schema } from "effect";
-import { TextVerbosity, type LLMRequest } from "../../schema/index.js";
+import type { LLMRequest } from "../../schema/index.js";
+export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {});
+export declare const ReasoningEffort: Schema.declare<ReasoningEffort, ReasoningEffort>;
+export declare const TextVerbosities: readonly ["low", "medium", "high"];
+export type TextVerbosity = (typeof TextVerbosities)[number] | (string & {});
+export declare const TextVerbosity: Schema.declare<TextVerbosity, TextVerbosity>;
 export declare const ResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
-export type ResponseIncludable = (typeof ResponseIncludables)[number];
+export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {});
 export declare const ServiceTiers: readonly ["auto", "default", "flex", "priority"];
 export type ServiceTier = (typeof ServiceTiers)[number];
 export declare const Truncations: readonly ["auto", "disabled"];
 export type Truncation = (typeof Truncations)[number];
-export declare const ReasoningEffort: Schema.String;
-export declare const TextVerbositySchema: Schema.Literals<readonly ["low", "medium", "high"]>;
-export declare const ResponseIncludableSchema: Schema.Literals<readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"]>;
+export declare const TextVerbositySchema: Schema.declare<TextVerbosity, TextVerbosity>;
+export declare const ResponseIncludableSchema: Schema.declare<ResponseIncludable, ResponseIncludable>;
 export declare const ServiceTierSchema: Schema.Literals<readonly ["auto", "default", "flex", "priority"]>;
 export declare const TruncationSchema: Schema.Literals<readonly ["auto", "disabled"]>;
-export interface Resolved {
-    readonly instructions?: string;
-    readonly store?: boolean;
-    readonly reasoningEffort?: string;
-    readonly reasoningSummary?: "auto" | "concise" | "detailed";
-    readonly include?: ReadonlyArray<ResponseIncludable>;
-    readonly textVerbosity?: Schema.Schema.Type<typeof TextVerbosity>;
-    readonly serviceTier?: ServiceTier;
-    readonly truncation?: Truncation;
-}
+export declare const AllowedTools: Schema.Struct<{
+    readonly toolNames: Schema.$Array<Schema.String>;
+    readonly mode: Schema.optional<Schema.Literals<readonly ["auto", "none", "required"]>>;
+}>;
+export type AllowedTools = typeof AllowedTools.Type;
+export declare const StreamOptions: Schema.Struct<{
+    readonly includeObfuscation: Schema.optional<Schema.Boolean>;
+}>;
+export declare const Options: Schema.Struct<{
+    readonly instructions: Schema.optional<Schema.String>;
+    readonly store: Schema.optional<Schema.Boolean>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly safetyIdentifier: Schema.optional<Schema.String>;
+    readonly streamOptions: Schema.optional<Schema.Struct<{
+        readonly includeObfuscation: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly topLogprobs: Schema.optional<Schema.Int>;
+    readonly reasoningEffort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+    readonly reasoningSummary: Schema.optional<Schema.Literals<readonly ["auto", "concise", "detailed"]>>;
+    readonly include: Schema.optional<Schema.$Array<Schema.declare<ResponseIncludable, ResponseIncludable>>>;
+    readonly textVerbosity: Schema.optional<Schema.declare<TextVerbosity, TextVerbosity>>;
+    readonly serviceTier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
+    readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
+    readonly allowedTools: Schema.optional<Schema.Struct<{
+        readonly toolNames: Schema.$Array<Schema.String>;
+        readonly mode: Schema.optional<Schema.Literals<readonly ["auto", "none", "required"]>>;
+    }>>;
+    readonly maxToolCalls: Schema.optional<Schema.Int>;
+    readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
+}>;
+export type Options = typeof Options.Type;
+export type Resolved = Omit<Options, "allowedTools"> & {
+    readonly allowedTools?: AllowedTools & {
+        readonly mode: NonNullable<AllowedTools["mode"]>;
+    };
+};
 export declare const resolve: (request: LLMRequest) => Resolved;
 export * as OpenResponsesOptions from "./open-responses-options.js";

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

@@ -1,5 +1,8 @@
-import { Schema } from "effect";
-import { TextVerbosity } from "../../schema/index.js";
+import { Option, Schema } from "effect";
+export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
+export const TextVerbosities = ["low", "medium", "high"];
+export const TextVerbosity = Schema.declare((value) => typeof value === "string", { title: "TextVerbosity" });
 export const ResponseIncludables = [
     "file_search_call.results",
     "web_search_call.results",
@@ -12,35 +15,45 @@ export const ResponseIncludables = [
 ];
 export const ServiceTiers = ["auto", "default", "flex", "priority"];
 export const Truncations = ["auto", "disabled"];
-const TEXT_VERBOSITY = new Set(["low", "medium", "high"]);
-const INCLUDABLES = new Set(ResponseIncludables);
-const SERVICE_TIERS = new Set(ServiceTiers);
-const TRUNCATIONS = new Set(Truncations);
-const isTextVerbosity = (value) => typeof value === "string" && TEXT_VERBOSITY.has(value);
-const isServiceTier = (value) => typeof value === "string" && SERVICE_TIERS.has(value);
-const isTruncation = (value) => typeof value === "string" && TRUNCATIONS.has(value);
-export const ReasoningEffort = Schema.String;
 export const TextVerbositySchema = TextVerbosity;
-export const ResponseIncludableSchema = Schema.Literals(ResponseIncludables);
+export const ResponseIncludableSchema = Schema.declare((value) => typeof value === "string", { title: "ResponseIncludable" });
 export const ServiceTierSchema = Schema.Literals(ServiceTiers);
 export const TruncationSchema = Schema.Literals(Truncations);
+export const AllowedTools = Schema.Struct({
+    toolNames: Schema.Array(Schema.String),
+    mode: Schema.optional(Schema.Literals(["auto", "none", "required"])),
+});
+export const StreamOptions = Schema.Struct({
+    includeObfuscation: Schema.optional(Schema.Boolean),
+});
+export const Options = Schema.Struct({
+    instructions: Schema.optional(Schema.String),
+    store: Schema.optional(Schema.Boolean),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    safetyIdentifier: Schema.optional(Schema.String),
+    streamOptions: Schema.optional(StreamOptions),
+    topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
+    reasoningEffort: Schema.optional(ReasoningEffort),
+    reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
+    include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
+    textVerbosity: Schema.optional(TextVerbositySchema),
+    serviceTier: Schema.optional(ServiceTierSchema),
+    truncation: Schema.optional(TruncationSchema),
+    allowedTools: Schema.optional(AllowedTools),
+    maxToolCalls: Schema.optional(Schema.Int),
+    parallelToolCalls: Schema.optional(Schema.Boolean),
+});
+const decodeOptions = Schema.decodeUnknownOption(Options);
 export const resolve = (request) => {
-    const input = request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"];
-    const include = Array.isArray(input?.include)
-        ? input.include.filter((entry) => INCLUDABLES.has(entry))
-        : [];
-    const reasoningSummary = input?.reasoningSummary;
+    const input = Option.getOrUndefined(decodeOptions(request.providerOptions));
+    if (!input)
+        return {};
     return {
-        instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
-        store: typeof input?.store === "boolean" ? input.store : undefined,
-        reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
-        reasoningSummary: reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
-            ? reasoningSummary
+        ...input,
+        include: input.include?.length ? input.include : undefined,
+        allowedTools: input.allowedTools && input.allowedTools.toolNames.length > 0
+            ? { ...input.allowedTools, mode: input.allowedTools.mode ?? "auto" }
             : undefined,
-        include: include.length > 0 ? include : undefined,
-        textVerbosity: isTextVerbosity(input?.textVerbosity) ? input.textVerbosity : undefined,
-        serviceTier: isServiceTier(input?.serviceTier) ? input.serviceTier : undefined,
-        truncation: isTruncation(input?.truncation) ? input.truncation : undefined,
     };
 };
 export * as OpenResponsesOptions from "./open-responses-options.js";

package/dist/protocols/utils/openai-options.d.ts

@@ -1,14 +1,16 @@
 import { OpenResponsesOptions } from "./open-responses-options.js";
 export declare const OpenAIReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type OpenAIReasoningEffort = string;
+export type OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+export declare const OpenAITextVerbosities: readonly ["low", "medium", "high"];
+export type OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
 export declare const OpenAIResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
 export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable;
 export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority"];
 export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier;
-export declare const OpenAIReasoningEffort: import("effect/Schema").String;
-export declare const OpenAITextVerbosity: import("effect/Schema").Literals<readonly ["low", "medium", "high"]>;
-export declare const OpenAIResponseIncludable: import("effect/Schema").Literals<readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"]>;
+export declare const OpenAIReasoningEffort: import("effect/Schema").declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
+export declare const OpenAITextVerbosity: import("effect/Schema").declare<OpenResponsesOptions.TextVerbosity, OpenResponsesOptions.TextVerbosity>;
+export declare const OpenAIResponseIncludable: import("effect/Schema").declare<OpenResponsesOptions.ResponseIncludable, OpenResponsesOptions.ResponseIncludable>;
 export declare const OpenAIServiceTier: import("effect/Schema").Literals<readonly ["auto", "default", "flex", "priority"]>;
 export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
-export declare const resolve: (request: import("../../schema/messages.js").LLMRequest) => OpenResponsesOptions.Resolved;
+export declare const resolve: (request: import("../../index.js").LLMRequest) => OpenResponsesOptions.Resolved;
 export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/openai-options.js

@@ -1,12 +1,12 @@
-import { ReasoningEfforts } from "../../schema/index.js";
 import { OpenResponsesOptions } from "./open-responses-options.js";
-export const OpenAIReasoningEfforts = ReasoningEfforts;
+export const OpenAIReasoningEfforts = OpenResponsesOptions.ReasoningEfforts;
+export const OpenAITextVerbosities = OpenResponsesOptions.TextVerbosities;
 // Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
 // in lockstep with `openai-node/src/resources/responses/responses.ts`.
 export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables;
 export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers;
 export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
-export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbositySchema;
+export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
 export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema;
 export const OpenAIServiceTier = OpenResponsesOptions.ServiceTierSchema;
 export const isReasoningEffort = (effort) => typeof effort === "string";

package/dist/provider-package.d.ts

@@ -3,11 +3,6 @@ export interface Settings extends Readonly<Record<string, unknown>> {
     readonly baseURL?: string;
     readonly headers?: Readonly<Record<string, string>>;
     readonly body?: Readonly<Record<string, unknown>>;
-    readonly limits?: {
-        readonly context: number;
-        readonly input?: number;
-        readonly output: number;
-    };
 }
 export interface Definition<ProviderSettings extends Settings = Settings, Options extends ProviderOptions = ProviderOptions> {
     readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>;

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

@@ -81,7 +81,6 @@ export declare const routes: (RouteDef<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -98,9 +97,10 @@ export declare const routes: (RouteDef<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -112,7 +112,7 @@ export declare const routes: (RouteDef<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>> | RouteDef<{
@@ -148,17 +148,20 @@ export declare const routes: (RouteDef<{
             readonly text: string;
         })[];
     } | {
+        readonly type: "message";
         readonly content: readonly {
             readonly type: "output_text";
             readonly text: string;
         }[];
         readonly role: "assistant";
+        readonly id?: string | undefined;
         readonly phase?: "commentary" | "final_answer" | undefined;
     } | {
         readonly type: "function_call";
-        readonly call_id: string;
         readonly name: string;
         readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
     } | {
         readonly type: "function_call_output";
         readonly call_id: string;
@@ -175,19 +178,24 @@ export declare const routes: (RouteDef<{
             readonly text: string;
         })[];
     } | {
+        readonly type: "message";
         readonly content: readonly {
             readonly type: "output_text";
             readonly text: string;
         }[];
         readonly role: "assistant";
+        readonly id?: string | undefined;
         readonly phase?: "commentary" | "final_answer" | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: string | undefined;
+        readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";
@@ -202,50 +210,66 @@ export declare const routes: (RouteDef<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
     })[] | undefined;
     readonly text?: {
-        readonly verbosity?: "low" | "medium" | "high" | undefined;
+        readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
     } | {
         readonly type: "image_generation";
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly include?: readonly ("file_search_call.results" | "web_search_call.results" | "web_search_call.action.sources" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "code_interpreter_call.outputs" | "reasoning.encrypted_content" | "message.output_text.logprobs")[] | undefined;
     readonly store?: boolean | undefined;
+    readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
     readonly prompt_cache_key?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
     readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
     readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
 }, 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-mantle.js

@@ -58,7 +58,6 @@ const config = (settings) => {
         credentials: settings.credentials,
         headers: settings.headers === undefined ? undefined : { ...settings.headers },
         http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-        limits: settings.limits,
         providerOptions: settings.providerOptions,
         region: settings.region,
     };

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/amazon-bedrock.js

@@ -35,7 +35,6 @@ export const model = (modelID, settings) => {
         generation: settings.topP === undefined ? undefined : { topP: settings.topP },
         headers: settings.headers === undefined ? undefined : { ...settings.headers },
         http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-        limits: settings.limits,
         region: settings.region,
     }).model(modelID);
 };

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

@@ -159,14 +159,6 @@ export declare const routes: import("../route/client.js").Route<{
         }[];
     })[];
     readonly stream: true;
-    readonly system?: readonly {
-        readonly type: "text";
-        readonly text: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: "1h" | "5m" | undefined;
-        } | undefined;
-    }[] | undefined;
     readonly tools?: readonly {
         readonly description: string;
         readonly name: string;
@@ -178,6 +170,14 @@ export declare const routes: import("../route/client.js").Route<{
             readonly ttl?: "1h" | "5m" | undefined;
         } | undefined;
     }[] | undefined;
+    readonly system?: readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
     readonly temperature?: number | undefined;
     readonly thinking?: {
         readonly type: "enabled";
@@ -189,7 +189,7 @@ export declare const routes: import("../route/client.js").Route<{
         readonly type: "disabled";
     } | undefined;
     readonly tool_choice?: {
-        readonly type: "none" | "auto" | "any";
+        readonly type: "auto" | "none" | "any";
     } | {
         readonly type: "tool";
         readonly name: string;
@@ -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-compatible.js

@@ -37,7 +37,6 @@ export const model = (modelID, settings) => {
         baseURL: settings.baseURL,
         headers: settings.headers === undefined ? undefined : { ...settings.headers },
         http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-        limits: settings.limits,
         provider: settings.provider,
         providerOptions: settings.providerOptions,
     }).model(modelID);

package/dist/providers/anthropic.d.ts

@@ -143,14 +143,6 @@ export declare const routes: import("../route/client.js").Route<{
         }[];
     })[];
     readonly stream: true;
-    readonly system?: readonly {
-        readonly type: "text";
-        readonly text: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: "1h" | "5m" | undefined;
-        } | undefined;
-    }[] | undefined;
     readonly tools?: readonly {
         readonly description: string;
         readonly name: string;
@@ -162,6 +154,14 @@ export declare const routes: import("../route/client.js").Route<{
             readonly ttl?: "1h" | "5m" | undefined;
         } | undefined;
     }[] | undefined;
+    readonly system?: readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
     readonly temperature?: number | undefined;
     readonly thinking?: {
         readonly type: "enabled";
@@ -173,7 +173,7 @@ export declare const routes: import("../route/client.js").Route<{
         readonly type: "disabled";
     } | undefined;
     readonly tool_choice?: {
-        readonly type: "none" | "auto" | "any";
+        readonly type: "auto" | "none" | "any";
     } | {
         readonly type: "tool";
         readonly name: string;
@@ -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/anthropic.js

@@ -34,7 +34,6 @@ export const model = (modelID, settings) => {
         baseURL: settings.baseURL,
         headers: settings.headers === undefined ? undefined : { ...settings.headers },
         http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-        limits: settings.limits,
         providerOptions: settings.providerOptions,
     }).model(modelID);
 };