@opencode-ai/ai 0.0.0-beta-17595 → 0.0.0-beta-17727

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.d.ts

@@ -1,21 +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 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 Truncations: readonly ["auto", "disabled"];
+export type Truncation = (typeof Truncations)[number];
+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 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;
-}
+export declare const TruncationSchema: Schema.Literals<readonly ["auto", "disabled"]>;
+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",
@@ -11,31 +14,46 @@ export const ResponseIncludables = [
     "message.output_text.logprobs",
 ];
 export const ServiceTiers = ["auto", "default", "flex", "priority"];
-const TEXT_VERBOSITY = new Set(["low", "medium", "high"]);
-const INCLUDABLES = new Set(ResponseIncludables);
-const SERVICE_TIERS = new Set(ServiceTiers);
-const isTextVerbosity = (value) => typeof value === "string" && TEXT_VERBOSITY.has(value);
-const isServiceTier = (value) => typeof value === "string" && SERVICE_TIERS.has(value);
-export const ReasoningEffort = Schema.String;
+export const Truncations = ["auto", "disabled"];
 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,
     };
 };
 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<{
@@ -130,6 +130,9 @@ export declare const routes: (RouteDef<{
     } | {
         readonly role: "system";
         readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
     } | {
         readonly role: "user";
         readonly content: readonly ({
@@ -145,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;
@@ -172,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";
@@ -199,49 +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;
     };
 };