@opencode/ai 0.0.0-dev-19594 → 0.0.0-dev-19596

package/dist/cache-policy.js

@@ -12,6 +12,7 @@
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint } from "./schema/options.js";
 import { LLMRequest, Message, ToolDefinition } from "./schema/messages.js";
+import { effortUpdate } from "./effort-updates.js";
 const AUTO = {
     tools: true,
     system: true,
@@ -100,10 +101,17 @@ const markMessages = (messages, strategy, hint, budget) => {
         return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget);
     if (strategy === "latest-assistant")
         return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget);
-    const start = Math.max(0, messages.length - strategy.tail);
+    let start = messages.length;
+    let remaining = strategy.tail;
+    while (remaining > 0 && start > 0) {
+        start -= 1;
+        if (effortUpdate(messages[start]) === undefined)
+            remaining -= 1;
+    }
     let next = messages;
     for (let i = start; i < messages.length; i++)
-        next = markMessageAt(next, i, hint, budget);
+        if (effortUpdate(messages[i]) === undefined)
+            next = markMessageAt(next, i, hint, budget);
     return next;
 };
 const countHints = (request) => countToolHints(request.tools) +

package/dist/effort-updates.d.ts

@@ -0,0 +1,12 @@
+import { LLMRequest, type EffortPart, type Message } from "./schema/messages.js";
+export declare const effortUpdate: (message: Message) => EffortPart | undefined;
+export declare const stripEffortUpdates: (request: LLMRequest) => LLMRequest<import("./index.js").LanguageModel<{
+    readonly [x: string]: unknown;
+}, import("./route.js").CompactionOperations | undefined>>;
+export declare const applyEffortUpdates: (request: LLMRequest) => LLMRequest;
+export declare const resolveEffortUpdates: (request: LLMRequest, current: string | undefined) => {
+    request: LLMRequest<import("./index.js").LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("./route.js").CompactionOperations | undefined>>;
+    effort: string | undefined;
+};

package/dist/effort-updates.js

@@ -0,0 +1,23 @@
+// Changing the top-level reasoning effort invalidates the provider prompt cache. Protocols with a native
+// per-message update keep it frozen and lower `Message.effort(...)` markers instead; other routes strip them.
+import { LLMRequest } from "./schema/messages.js";
+export const effortUpdate = (message) => {
+    if (message.role !== "system" || message.content.length !== 1)
+        return undefined;
+    const part = message.content[0];
+    return part.type === "effort" ? part : undefined;
+};
+export const stripEffortUpdates = (request) => {
+    const messages = request.messages.filter((message) => effortUpdate(message) === undefined);
+    return messages.length === request.messages.length ? request : LLMRequest.update(request, { messages });
+};
+export const applyEffortUpdates = (request) => request.model.route.supportsEffortUpdates?.(request) ? request : stripEffortUpdates(request);
+// Reverted or forked history can leave the last marker disagreeing with the requested effort.
+export const resolveEffortUpdates = (request, current) => {
+    const updates = request.messages.flatMap((message) => effortUpdate(message) ?? []);
+    if (updates.length === 0)
+        return { request, effort: current };
+    if (updates.at(-1)?.effort !== current)
+        return { request: stripEffortUpdates(request), effort: current };
+    return { request, effort: updates[0]?.previous };
+};

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

@@ -187,7 +187,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -196,6 +195,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

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

@@ -286,6 +286,9 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
         }>>;
+        readonly output_config: Schema.optional<Schema.Struct<{
+            readonly effort: Schema.String;
+        }>>;
     }>]>>;
     tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
@@ -529,7 +532,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -538,6 +540,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {
@@ -883,7 +889,6 @@ export declare const route: Route<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -892,6 +897,10 @@ export declare const route: Route<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

package/dist/protocols/anthropic-messages.js

@@ -11,6 +11,7 @@ import { HttpTransport } from "../route/transport/index.js";
 import { AIError, HttpOptions, LLMRequest, LLMEvent, mergeJsonRecords, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
+import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
@@ -19,6 +20,7 @@ const ADAPTER = "anthropic-messages";
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export const PATH = "/messages";
 export const DEFAULT_MAX_TOKENS = 32_000;
+const DEFAULT_EFFORT = "high";
 const SSE_EVENTS = new Set([
     "message",
     "message_start",
@@ -183,7 +185,11 @@ const AnthropicAssistantBlock = Schema.Union([
 const AnthropicMessage = Schema.Union([
     Schema.Struct({ role: Schema.Literal("user"), content: Schema.Array(AnthropicUserBlock) }),
     Schema.Struct({ role: Schema.Literal("assistant"), content: Schema.Array(AnthropicAssistantBlock) }),
-    Schema.Struct({ role: Schema.Literal("system"), content: Schema.Array(AnthropicTextBlock) }),
+    Schema.Struct({
+        role: Schema.Literal("system"),
+        content: Schema.Array(AnthropicTextBlock),
+        output_config: Schema.optional(Schema.Struct({ effort: Schema.String })),
+    }),
 ]).pipe(Schema.toTaggedUnion("role"));
 const AnthropicTool = Schema.Struct({
     name: Schema.String,
@@ -697,6 +703,12 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     for (const [index, message] of request.messages.entries()) {
         if (message.role === "system") {
+            const update = effortUpdate(message);
+            if (update) {
+                // Accepted at any position, so the text-update placement rules do not apply.
+                messages.push({ role: "system", content: [], output_config: { effort: update.effort ?? DEFAULT_EFFORT } });
+                continue;
+            }
             if (splitsLocalToolResults(request.messages, index))
                 return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result");
             if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request, index)) {
@@ -842,17 +854,11 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
     const outputConfigFormat = ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
         ? rawOutputConfig.format
         : undefined;
-    const output_config = outputConfigEffort === undefined && outputConfigFormat === undefined
-        ? undefined
-        : {
-            ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
-            ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
-        };
     const thinking = yield* resolveThinking(input?.thinking);
     return {
         thinking: applyThinkingBindingDefault(request.model, thinking),
         effort: outputConfigEffort,
-        output_config,
+        format: outputConfigFormat,
         service_tier,
         metadata,
         container,
@@ -860,17 +866,32 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
         cache_control,
     };
 });
+// Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+const claudeVersion = (id) => {
+    const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(id.toLowerCase())?.groups;
+    if (!match)
+        return undefined;
+    return { family: match.family, major: Number(match.major), minor: Number(match.minor ?? 0) };
+};
 const supportsThinkingBlockBinding = (model) => {
     const override = model.compatibility?.supportsThinkingBlockBinding;
     if (override !== undefined)
         return override;
-    // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-    const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups;
-    if (!version)
+    const version = claudeVersion(model.id);
+    return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1));
+};
+const supportsEffortUpdates = (model) => {
+    const override = model.compatibility?.supportsEffortUpdates;
+    if (override !== undefined)
+        return override;
+    const version = claudeVersion(model.id);
+    if (version === undefined)
         return false;
-    const major = Number(version.major);
-    const minor = Number(version.minor ?? 0);
-    return major > 5 || (major === 5 && minor >= 1);
+    if (version.family === "opus")
+        return version.major >= 5;
+    if (version.family !== "fable" && version.family !== "mythos")
+        return false;
+    return version.major > 5 || (version.major === 5 && version.minor >= 1);
 };
 const applyThinkingBindingDefault = (model, thinking) => {
     if (thinking?.type === "disabled")
@@ -909,13 +930,15 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
+    const options = yield* resolveOptions(request);
+    const updates = resolveEffortUpdates(request, options.effort);
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     // Allocate the 4-breakpoint budget in invalidation order: tools → system →
     // messages. Tools live highest in the cache hierarchy, so when callers
     // over-mark we keep their tool hints and shed the message-tail ones first.
     const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP);
-    const flattened = ProviderShared.flattenToolRequest(request);
+    const flattened = ProviderShared.flattenToolRequest(updates.request);
     const tools = flattened.tools.length === 0
         ? undefined
         : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)));
@@ -933,7 +956,12 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     if (breakpoints.dropped > 0) {
         yield* Effect.logWarning(`Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`);
     }
-    const options = yield* resolveOptions(request);
+    const output_config = updates.effort === undefined && options.format === undefined
+        ? undefined
+        : {
+            ...(updates.effort === undefined ? {} : { effort: updates.effort }),
+            ...(options.format === undefined ? {} : { format: options.format }),
+        };
     const body = {
         model: request.model.id,
         system,
@@ -947,7 +975,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         top_k: generation?.topK,
         stop_sequences: generation?.stop,
         thinking: options.thinking,
-        output_config: options.output_config,
+        output_config,
         // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
         cache_control: options.cache_control,
         container: options.container,
@@ -1404,6 +1432,7 @@ export const protocol = Protocol.make({
         }),
         step,
     },
+    supportsEffortUpdates: (request) => supportsEffortUpdates(request.model),
 });
 export const transport = () => {
     const http = HttpTransport.httpJson({ framing });
@@ -1440,6 +1469,8 @@ function requiredBetaHeaders(body) {
     const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
     if (requestsCompaction || replaysCompaction)
         betas.push("compact-2026-01-12");
+    if (body.messages.some((message) => message.role === "system" && message.output_config !== undefined))
+        betas.push("mid-conversation-output-config-2026-07-01");
     const thinking = body.thinking;
     if (thinking && thinking.type !== "disabled" && thinking.block_binding)
         betas.push("thinking-binding-controls-2026-08-01");

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

@@ -175,7 +175,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -184,6 +183,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

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

@@ -153,7 +153,7 @@ export declare const protocol: Protocol<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";
@@ -409,7 +409,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";

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

@@ -90,6 +90,13 @@ export declare const CompactionItem: Schema.Struct<{
     readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
     readonly encrypted_content: Schema.String;
 }>;
+export declare const ConfigurationUpdate: Schema.Struct<{
+    readonly type: Schema.Literal<"configuration_update">;
+    readonly reasoning: Schema.Struct<{
+        readonly effort: Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
+    }>;
+}>;
+type ConfigurationUpdate = Schema.Schema.Type<typeof ConfigurationUpdate>;
 export declare const InputItem: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"compaction">;
     readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -198,7 +205,7 @@ export type HostedToolReplayItem = {
     readonly id: string;
     readonly [key: string]: unknown;
 };
-type LoweredInputItem = OpenResponsesInputItem | HostedToolReplayItem | {
+type LoweredInputItem = OpenResponsesInputItem | HostedToolReplayItem | ConfigurationUpdate | {
     readonly type: "message";
     readonly id?: string;
     readonly role: "assistant";
@@ -845,7 +852,7 @@ export declare const lowerConversation: (request: LLMRequest<import("../schema/o
     model: string & import("effect/Brand").Brand<"AI.ModelID">;
     input: LoweredInputItem[];
 }, AIError, never>;
-export declare const lowerGeneration: (request: LLMRequest) => {
+export declare const lowerGeneration: (request: LLMRequest, options?: OpenResponsesOptions.Resolved) => {
     truncation?: "auto" | "disabled" | undefined;
     parallel_tool_calls?: boolean | undefined;
     max_tool_calls?: number | undefined;

package/dist/protocols/open-responses.js

@@ -4,6 +4,7 @@ import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
+import { effortUpdate } from "../effort-updates.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
@@ -117,6 +118,11 @@ export const CompactionItem = Schema.Struct({
     id: optionalNull(Schema.String),
     encrypted_content: Schema.String,
 });
+// Kept out of the baseline `InputItem` union: only the OpenAI extension accepts it.
+export const ConfigurationUpdate = Schema.Struct({
+    type: Schema.Literal("configuration_update"),
+    reasoning: Schema.Struct({ effort: OpenResponsesOptions.ReasoningEffort }),
+});
 export const InputItem = Schema.Union([
     CompactionItem,
     Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
@@ -423,12 +429,22 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (part, request, adapte
     const content = part.result.value;
     return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, adapter));
 });
+const DEFAULT_EFFORT = "medium";
 const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request, adapter) {
     const input = [];
     const providerMetadataKey = metadataKey(request.model);
     for (const message of request.messages) {
         const metadata = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)))(message.providerMetadata?.[providerMetadataKey]);
         if (message.role === "system") {
+            const update = effortUpdate(message);
+            if (update) {
+                // Consecutive updates are rejected, so a newer one replaces its predecessor.
+                const last = input.at(-1);
+                if (last !== undefined && "type" in last && last.type === "configuration_update")
+                    input.pop();
+                input.push({ type: "configuration_update", reasoning: { effort: update.effort ?? DEFAULT_EFFORT } });
+                continue;
+            }
             input.push({
                 role: "developer",
                 content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(adapter.name, message)),
@@ -561,8 +577,7 @@ export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(fu
         ...(instructions ? { instructions } : {}),
     };
 });
-export const lowerGeneration = (request) => {
-    const options = OpenResponsesOptions.resolve(request);
+export const lowerGeneration = (request, options = OpenResponsesOptions.resolve(request)) => {
     const generation = request.generation;
     const cacheKey = ProviderShared.promptCacheKey(request);
     const parallelToolCalls = resolveParallelToolCalls(request);

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

@@ -97,7 +97,7 @@ export declare const bodyFields: {
     }>>;
     store: Schema.optional<Schema.Boolean>;
     prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.declare<import("./utils/open-responses-options.js").ReasoningEffort, import("./utils/open-responses-options.js").ReasoningEffort>>;
+    reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
     tool_stream: Schema.optional<Schema.Boolean>;
     max_completion_tokens: Schema.optional<Schema.Number>;
     max_tokens: Schema.optional<Schema.Number>;
@@ -193,7 +193,7 @@ declare const OpenAIChatBody: Schema.Struct<{
     }>>;
     store: Schema.optional<Schema.Boolean>;
     prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.declare<import("./utils/open-responses-options.js").ReasoningEffort, import("./utils/open-responses-options.js").ReasoningEffort>>;
+    reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
     tool_stream: Schema.optional<Schema.Boolean>;
     max_completion_tokens: Schema.optional<Schema.Number>;
     max_tokens: Schema.optional<Schema.Number>;
@@ -292,7 +292,7 @@ interface LoweringOptions {
 export declare const fromRequest: (request: LLMRequest<import("../schema/options.js").LanguageModel<{
     readonly [x: string]: unknown;
 }, import("../route/client.js").CompactionOperations | undefined>>, options?: LoweringOptions | undefined) => Effect.Effect<{
-    reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     prompt_cache_key?: string | undefined;
     store?: boolean | undefined;
     temperature: number | undefined;
@@ -389,7 +389,7 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
     } | undefined;
     stream: true;
 } | {
-    reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     prompt_cache_key?: string | undefined;
     store?: boolean | undefined;
     temperature: number | undefined;
@@ -584,7 +584,7 @@ export declare const protocol: Protocol<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
@@ -751,7 +751,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
@@ -850,7 +850,7 @@ export declare const route: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;

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

@@ -99,7 +99,7 @@ export declare const route: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly reasoning_effort?: import("../index.js").ReasoningEffort | undefined;
     readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;

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

@@ -126,7 +126,7 @@ export declare const route: Route<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../index.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly {
         readonly type: "function";