@opencode-ai/ai 0.0.0-beta-17963 → 0.0.0-beta-18045

package/dist/protocols/open-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, ProviderInternalReason, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -234,7 +234,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         type: "function",
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.responses(inputSchema),
+        parameters: inputSchema,
         // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
@@ -290,7 +290,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, reques
         return {
             type: "input_file",
             filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-            ...(url ? { file_url: url } : { file_data: media.base64 }),
+            ...(url ? { file_url: url } : { file_data: media.dataUrl }),
         };
     }
     return { type: "input_image", image_url: url ?? media.dataUrl };
@@ -416,8 +416,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     const id = itemID(part.providerMetadata, providerMetadataKey);
                     if (store !== false && id && !hostedToolReferences.has(id))
                         input.push({ type: "item_reference", id });
-                    if (store === false && part.result.type === "content") {
-                        const content = part.result.value;
+                    if (store === false) {
+                        // The server is not storing this exchange, so the tool outcome has to
+                        // travel in the input. Non-content results degrade to their text form.
+                        const content = part.result.type === "content"
+                            ? part.result.value
+                            : [{ type: "text", text: ProviderShared.toolResultText(part) }];
                         input.push({
                             role: "user",
                             content: yield* Effect.forEach(content, (item) => lowerHostedToolResultContentItem(item, request, extension)),
@@ -456,6 +460,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 });
 const lowerOptions = (request) => {
     const options = OpenResponsesOptions.resolve(request);
+    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
         ...(options.store !== undefined ? { store: options.store } : {}),
@@ -465,7 +470,7 @@ const lowerOptions = (request) => {
             ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
             : {}),
         ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
-        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+        ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
         ...(options.include ? { include: options.include } : {}),
         ...(options.reasoningEffort || options.reasoningSummary
             ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }
@@ -856,11 +861,18 @@ export const providerFailure = (id, event, fallback) => {
         : typeof event.status_code === "number"
             ? event.status_code
             : undefined;
+    const reason = event.type === "error" &&
+        event.error === undefined &&
+        event.response === undefined &&
+        summary === undefined &&
+        status === undefined
+        ? new ProviderInternalReason({ message })
+        : classifyProviderFailure({ message, code, status, rawBody: body });
     return new AIError({
         module: id,
         method: "stream",
         body,
-        reason: classifyProviderFailure({ message, code, status, rawBody: body }),
+        reason,
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);

package/dist/protocols/openai-chat.d.ts

@@ -201,7 +201,7 @@ declare const OpenAIChatBody: Schema.Struct<{
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
 export declare const OpenAIChatEvent: Schema.Struct<{
-    readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+    readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly refusal: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -220,11 +220,29 @@ export declare const OpenAIChatEvent: Schema.Struct<{
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
         readonly native_finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>>>>;
+        readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+            readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+                readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+            readonly completion_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+                readonly reasoning_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly accepted_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>>;
     readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
             readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
@@ -566,6 +584,8 @@ export declare const protocol: Protocol<{
         readonly prompt_tokens?: number | null | undefined;
         readonly completion_tokens?: number | null | undefined;
         readonly total_tokens?: number | null | undefined;
+        readonly cached_tokens?: number | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
@@ -579,6 +599,7 @@ export declare const protocol: Protocol<{
         } | null | undefined;
     } | null | undefined;
     readonly choices?: readonly {
+        readonly [x: string]: unknown;
         readonly delta?: {
             readonly [x: string]: unknown;
             readonly reasoning?: string | null | undefined;
@@ -596,6 +617,25 @@ export declare const protocol: Protocol<{
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly cached_tokens?: number | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
         readonly finish_reason?: string | null | undefined;
         readonly native_finish_reason?: string | null | undefined;
     }[] | null | undefined;

package/dist/protocols/openai-chat.js

@@ -123,6 +123,9 @@ const OpenAIChatUsage = Schema.StructWithRest(Schema.Struct({
     prompt_tokens: optionalNull(Schema.Number),
     completion_tokens: optionalNull(Schema.Number),
     total_tokens: optionalNull(Schema.Number),
+    // Zai reports cache hits as top-level `cached_tokens`; DeepSeek uses `prompt_cache_hit_tokens`.
+    cached_tokens: optionalNull(Schema.Number),
+    prompt_cache_hit_tokens: optionalNull(Schema.Number),
     prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
         cached_tokens: optionalNull(Schema.Number),
         cache_write_tokens: optionalNull(Schema.Number),
@@ -151,11 +154,13 @@ const OpenAIChatDelta = Schema.StructWithRest(Schema.Struct({
     reasoning_details: optionalNull(Schema.Unknown),
     tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const OpenAIChatChoice = Schema.Struct({
+const OpenAIChatChoice = Schema.StructWithRest(Schema.Struct({
     delta: optionalNull(OpenAIChatDelta),
     finish_reason: optionalNull(Schema.String),
     native_finish_reason: optionalNull(Schema.String),
-});
+    // Moonshot streams usage on `choice.usage` instead of top-level `usage`.
+    usage: optionalNull(OpenAIChatUsage),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const OpenAIChatError = Schema.Struct({
     code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
     message: Schema.String,
@@ -170,7 +175,7 @@ const lowerTool = (tool, inputSchema, options) => ({
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.openAI(inputSchema),
+        parameters: inputSchema,
     },
     cache_control: options.cacheControl?.(tool.cache),
 });
@@ -396,11 +401,24 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
     flushImages();
     return messages;
 });
+// Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
+// whenever the conversation history contains tool calls/results. Send an
+// explicit empty array when we have history but no active tools.
+const hasToolHistory = (messages) => {
+    for (const message of messages) {
+        if (message.role === "tool")
+            return true;
+        if (message.role === "assistant" && message.content.some((part) => part.type === "tool-call"))
+            return true;
+    }
+    return false;
+};
 const lowerOptions = (request) => {
     const options = OpenAIOptions.resolve(request);
+    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
     return {
         ...(options.store !== undefined ? { store: options.store } : {}),
-        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+        ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
         ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
     };
 };
@@ -413,11 +431,14 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens";
+    const hasHistory = hasToolHistory(request.messages);
     return {
         model: request.model.id,
         messages: yield* lowerMessages(request, options),
         tools: request.tools.length === 0
-            ? undefined
+            ? hasHistory
+                ? []
+                : undefined
             : request.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options)),
         tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
@@ -458,12 +479,18 @@ const mapFinishReason = (reason) => {
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
 // through and derive the non-cached breakdown so the `AI.Usage` contract is
 // satisfied on both sides.
+// Providers differ on cache-hit location: OpenAI uses
+// `prompt_tokens_details.cached_tokens`, DeepSeek uses
+// `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
 const mapUsage = (usage) => {
     if (!usage)
         return undefined;
     const input = usage.prompt_tokens ?? undefined;
     const output = usage.completion_tokens ?? undefined;
-    const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined;
+    const cached = (usage.prompt_tokens_details?.cached_tokens ??
+        usage.prompt_cache_hit_tokens ??
+        usage.cached_tokens ??
+        undefined);
     const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined;
     const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined;
     const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite));
@@ -554,8 +581,11 @@ const step = (state, event) => Effect.gen(function* () {
             }),
         });
     const events = [];
-    const usage = mapUsage(event.usage) ?? state.usage;
     const choice = event.choices?.[0];
+    // Moonshot (and a few other OpenAI-compatible providers) attach usage to
+    // `choice.usage` instead of the top-level `usage` field.
+    const choiceUsage = choice?.usage;
+    const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage;
     const rawFinishReason = choice?.finish_reason;
     const finishReason = rawFinishReason !== undefined && rawFinishReason !== null
         ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }

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

@@ -117,7 +117,7 @@ export declare const route: Route<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/protocols/openai-responses.d.ts

@@ -112,7 +112,7 @@ declare const OpenAIResponsesBody: Schema.Struct<{
     }>>;
     readonly top_logprobs: Schema.optional<Schema.Int>;
     readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
-    readonly service_tier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
+    readonly service_tier: Schema.optional<Schema.declare<import("./utils/open-responses-options.js").ServiceTier, import("./utils/open-responses-options.js").ServiceTier>>;
     readonly prompt_cache_key: Schema.optional<Schema.String>;
     readonly include: Schema.optional<Schema.$Array<Schema.declare<import("./utils/open-responses-options.js").ResponseIncludable, import("./utils/open-responses-options.js").ResponseIncludable>>>;
     readonly reasoning: Schema.optional<Schema.Struct<{
@@ -255,7 +255,7 @@ export declare const protocol: Protocol<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -438,7 +438,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -567,7 +567,7 @@ export declare const channelTransport: (options: import("./open-responses-channe
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -696,7 +696,7 @@ export declare const transport: import("../route/transport/index.js").Transport<
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -825,7 +825,7 @@ export declare const route: Route<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/protocols/openai-responses.js

@@ -109,13 +109,12 @@ const HOSTED_TOOLS = {
         name: "code_interpreter",
         input: (item) => ({ code: item.code, container_id: item.container_id }),
     },
-    computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
+    computer_call: { name: "computer_use", input: (item) => item.action ?? {} },
     image_generation_call: { name: "image_generation", input: () => ({}), result: hostedToolResult },
     mcp_call: {
         name: "mcp",
         input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
     },
-    local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
 };
 const step = (state, event) => {
     if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")

package/dist/protocols/shared.d.ts

@@ -10,6 +10,8 @@ export declare const encodeJson: (input: unknown, options?: import("effect/Schem
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
+export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+export declare const clampPromptCacheKey: (key: string | undefined) => string | undefined;
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
  * multiple `tool-input-delta` chunks store the partial JSON input string here

package/dist/protocols/shared.js

@@ -13,6 +13,17 @@ const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
 export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
+export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+// OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
+// limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.
+export const clampPromptCacheKey = (key) => {
+    if (key === undefined)
+        return undefined;
+    const chars = Array.from(key);
+    if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
+        return key;
+    return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+};
 /**
  * `Usage.totalTokens` policy shared by every route. Honors a provider-
  * supplied total; otherwise falls back to `inputTokens + outputTokens` only

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

@@ -9,12 +9,13 @@ 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] | (string & {});
 export declare const ServiceTiers: readonly ["auto", "default", "flex", "priority"];
-export type ServiceTier = (typeof ServiceTiers)[number];
+export type ServiceTier = (typeof ServiceTiers)[number] | (string & {});
+export declare const ServiceTier: Schema.declare<ServiceTier, ServiceTier>;
 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 declare const ServiceTierSchema: Schema.declare<ServiceTier, ServiceTier>;
 export declare const TruncationSchema: Schema.Literals<readonly ["auto", "disabled"]>;
 export declare const AllowedTools: Schema.Struct<{
     readonly toolNames: Schema.$Array<Schema.String>;
@@ -37,7 +38,7 @@ export declare const Options: Schema.Struct<{
     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 serviceTier: Schema.optional<Schema.declare<ServiceTier, ServiceTier>>;
     readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
     readonly allowedTools: Schema.optional<Schema.Struct<{
         readonly toolNames: Schema.$Array<Schema.String>;

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

@@ -14,10 +14,11 @@ export const ResponseIncludables = [
     "message.output_text.logprobs",
 ];
 export const ServiceTiers = ["auto", "default", "flex", "priority"];
+export const ServiceTier = Schema.declare((value) => typeof value === "string", { title: "ServiceTier" });
 export const Truncations = ["auto", "disabled"];
 export const TextVerbositySchema = TextVerbosity;
 export const ResponseIncludableSchema = Schema.declare((value) => typeof value === "string", { title: "ResponseIncludable" });
-export const ServiceTierSchema = Schema.Literals(ServiceTiers);
+export const ServiceTierSchema = ServiceTier;
 export const TruncationSchema = Schema.Literals(Truncations);
 export const AllowedTools = Schema.Struct({
     toolNames: Schema.Array(Schema.String),

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

@@ -5,12 +5,12 @@ 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 OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority", "scale"];
+export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number] | (string & {});
 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 OpenAIServiceTier: import("effect/Schema").declare<OpenResponsesOptions.ServiceTier, OpenResponsesOptions.ServiceTier>;
 export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
 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

@@ -4,7 +4,7 @@ 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 OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale"];
 export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
 export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
 export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema;

package/dist/protocols/utils/tool-schema.js

@@ -1,20 +1,5 @@
 import { isRecord } from "../../utils/record.js";
 import { GeminiToolSchema } from "./gemini-tool-schema.js";
-const removeNullSchemas = (value) => {
-    if (Array.isArray(value))
-        return value.map(removeNullSchemas);
-    if (!isRecord(value))
-        return value;
-    const fields = Object.fromEntries(Object.entries(value)
-        .filter(([key]) => key !== "anyOf")
-        .map(([key, field]) => [key, removeNullSchemas(field)]));
-    if (!Array.isArray(value.anyOf))
-        return fields;
-    const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas);
-    if (variants.length === 1 && isRecord(variants[0]))
-        return { ...fields, ...variants[0] };
-    return { ...fields, anyOf: variants };
-};
 const tupleItemsSchema = (items) => {
     const projected = items.map(moonshotNode);
     if (projected.length === 0)
@@ -47,19 +32,7 @@ const moonshot = (schema) => {
     const projected = moonshotNode(schema);
     return isRecord(projected) ? projected : {};
 };
-const openAI = (schema) => {
-    const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : [];
-    const flattened = variants.length === 0
-        ? { ...schema, type: "object" }
-        : {
-            ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
-            type: "object",
-            properties: variants.reduce((properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }), {}),
-            additionalProperties: false,
-        };
-    const normalized = removeNullSchemas(flattened);
-    return isRecord(normalized) ? normalized : { type: "object" };
-};
+const openAI = (schema) => schema;
 const responses = openAI;
 const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
 const modelCompatibility = (schema, compatibility) => {

package/dist/protocols/xai-responses.d.ts

@@ -112,7 +112,7 @@ export declare const protocol: Protocol<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

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

@@ -239,31 +239,31 @@ export declare const routes: (RouteDef<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | 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<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>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
     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<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>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        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>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
         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<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;

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

@@ -182,6 +182,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/anthropic.d.ts

@@ -166,6 +166,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/azure.d.ts

@@ -242,29 +242,29 @@ export declare const routes: (RouteDef<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | 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<import("./open-responses-options.js").OpenResponsesOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
     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<import("./open-responses-options.js").OpenResponsesOptionsInput>;
-        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput>;
 export {};