@opencode/ai 2.0.3 → 2.0.4

package/dist/providers/openrouter.d.ts

@@ -166,7 +166,7 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
     }>>;
     store: Schema.optional<Schema.Boolean>;
     prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.declare<import("../protocols/utils/open-responses-options.js").ReasoningEffort, import("../protocols/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>;
@@ -271,7 +271,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("../protocols/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;
@@ -438,7 +438,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("../protocols/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;
@@ -538,7 +538,7 @@ export declare const routes: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../protocols/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/providers/openrouter.js

@@ -100,7 +100,7 @@ export const configure = (input = {}) => {
     const route = configuredRoute(input);
     return {
         id,
-        model: (modelID) => route.model({ id: modelID }),
+        model: (modelID) => route.model({ id: modelID, compatibility: { supportsPromptCacheKey: true } }),
         configure,
     };
 };

package/dist/providers/togetherai.d.ts

@@ -104,7 +104,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("../protocols/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;
@@ -203,7 +203,7 @@ export declare const routes: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../protocols/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/providers/xai.d.ts

@@ -111,7 +111,7 @@ export declare const routes: (Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../protocols/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/providers/zai-coding-plan.d.ts

@@ -70,12 +70,15 @@ export declare const routes: (Route<{
         readonly encrypted_content: string;
         readonly id?: string | null | undefined;
     } | {
+        readonly type: "message";
         readonly role: "system";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly role: "developer";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly content: readonly ({
             readonly type: "input_image";
             readonly image_url: string;
@@ -92,7 +95,6 @@ export declare const routes: (Route<{
         })[];
         readonly role: "user";
         readonly id?: string | undefined;
-        readonly type?: "message" | undefined;
         readonly status?: string | undefined;
     } | {
         readonly type: "message";
@@ -140,7 +142,7 @@ export declare const routes: (Route<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly {
         readonly type: "function";
@@ -279,7 +281,7 @@ export declare const routes: (Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../protocols/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;
@@ -466,7 +468,6 @@ export declare const routes: (Route<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -475,6 +476,10 @@ export declare const routes: (Route<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

package/dist/providers/zai.d.ts

@@ -111,7 +111,7 @@ export declare const routes: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../protocols/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/route/client.d.ts

@@ -30,6 +30,7 @@ export interface Route<Body, Prepared = unknown, Compact extends CompactionOpera
     readonly transport: Transport<Body, Prepared, unknown>;
     readonly defaults: RouteDefaults;
     readonly body: RouteBody<Body>;
+    readonly supportsEffortUpdates?: (request: LLMRequest) => boolean;
     readonly with: {
         <Next extends CompactionOperations | undefined>(patch: RoutePatch<Body, Prepared> & {
             readonly compact: Next;

package/dist/route/client.js

@@ -5,6 +5,7 @@ import { RequestExecutor } from "./executor.js";
 import { Framing } from "./framing.js";
 import { HttpTransport } from "./transport/index.js";
 import { applyCachePolicy } from "../cache-policy.js";
+import { applyEffortUpdates } from "../effort-updates.js";
 import { normalizeToolHistory } from "../tool-history.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
@@ -120,6 +121,7 @@ function makeFromTransport(input) {
             transport: routeInput.transport,
             defaults: routeInput.defaults ?? {},
             body: protocol.body,
+            supportsEffortUpdates: protocol.supportsEffortUpdates,
             with: (patch) => {
                 const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch;
                 return build({
@@ -212,7 +214,7 @@ const prepareRequest = (request) => {
     const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }));
     // Deduplicate per sibling level; a tool and a namespace may share a name.
     const dedupe = (tools) => [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) => tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) });
-    const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }));
+    const resolved = applyCachePolicy(applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })));
     const headers = resolved.model.route.headers?.({ request: resolved });
     return headers === undefined
         ? resolved

package/dist/route/protocol.d.ts

@@ -40,6 +40,8 @@ export interface Protocol<Body, Frame, Event, State> {
     readonly body: ProtocolBody<Body>;
     /** Response side: streaming state machine. */
     readonly stream: ProtocolStream<Frame, Event, State>;
+    /** Whether `body.from` lowers `Message.effort(...)` markers; wrappers around another `body.from` must forward it. */
+    readonly supportsEffortUpdates?: (request: LLMRequest) => boolean;
 }
 export interface ProtocolBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */

package/dist/schema/messages.d.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode/schema/tool";
-import { CacheHint, GenerationOptions, HttpOptions, type LanguageModel } from "./options.js";
+import { CacheHint, GenerationOptions, HttpOptions, type LanguageModel, ReasoningEffort } from "./options.js";
 export declare const MessageRole: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>;
 export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
@@ -247,6 +247,13 @@ export declare const CompactionPart: Schema.refine<{
 }>> & {
     make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
 };
+/** Reasoning effort changed here, from `previous` to `effort`; `undefined` is the model default. */
+export declare const EffortPart: Schema.Struct<{
+    readonly type: Schema.Literal<"effort">;
+    readonly effort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+    readonly previous: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+}>;
+export type EffortPart = Schema.Schema.Type<typeof EffortPart>;
 export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
     readonly type: Schema.Literal<"text">;
     readonly text: Schema.String;
@@ -353,7 +360,11 @@ export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.
     readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
 }>> & {
     make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
-}]>;
+}, Schema.Struct<{
+    readonly type: Schema.Literal<"effort">;
+    readonly effort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+    readonly previous: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+}>]>;
 export type ContentPart = Schema.Schema.Type<typeof ContentPart>;
 declare const Message_base: Schema.Class<Message, Schema.Struct<{
     readonly id: Schema.optional<Schema.String>;
@@ -464,7 +475,11 @@ declare const Message_base: Schema.Class<Message, Schema.Struct<{
         readonly text: Schema.optional<Schema.NullOr<Schema.String>>;
     }>> & {
         make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent) => CompactionPart;
-    }]>>;
+    }, Schema.Struct<{
+        readonly type: Schema.Literal<"effort">;
+        readonly effort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+        readonly previous: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+    }>]>>;
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
     readonly native: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
@@ -489,6 +504,10 @@ export declare namespace Message {
      * updates; pass that untrusted content through ordinary user/tool channels.
      */
     const system: (content: SystemContentInput) => Message;
+    const effort: (input: {
+        readonly effort?: ReasoningEffort;
+        readonly previous?: ReasoningEffort;
+    }) => Message;
     const tool: (result: ToolResultPart | Parameters<typeof ToolResultPart.make>[0]) => Message;
 }
 declare const toolDefinitionFields: {

package/dist/schema/messages.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode/schema/tool";
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderOptions, } from "./options.js";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderOptions, ReasoningEffort, } from "./options.js";
 import { ProviderID } from "./ids.js";
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
 export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
@@ -158,6 +158,12 @@ const compactionPartSchema = Schema.Struct({
 export const CompactionPart = Object.assign(compactionPartSchema, {
     make: (input) => Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
 });
+/** Reasoning effort changed here, from `previous` to `effort`; `undefined` is the model default. */
+export const EffortPart = Schema.Struct({
+    type: Schema.Literal("effort"),
+    effort: Schema.optional(ReasoningEffort),
+    previous: Schema.optional(ReasoningEffort),
+}).annotate({ identifier: "LLM.Content.Effort" });
 export const ContentPart = Schema.Union([
     TextPart,
     MediaPart,
@@ -165,6 +171,7 @@ export const ContentPart = Schema.Union([
     ToolResultPart,
     ReasoningPart,
     CompactionPart,
+    EffortPart,
 ]).pipe(Schema.toTaggedUnion("type"));
 export class Message extends Schema.Class("LLM.Message")({
     id: Schema.optional(Schema.String),
@@ -192,6 +199,7 @@ export class Message extends Schema.Class("LLM.Message")({
      * updates; pass that untrusted content through ordinary user/tool channels.
      */
     Message.system = (content) => Message.make({ role: "system", content });
+    Message.effort = (input) => Message.make({ role: "system", content: [{ type: "effort", effort: input.effort, previous: input.previous }] });
     Message.tool = (result) => Message.make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] });
 })(Message || (Message = {}));
 const toolDefinitionFields = {

package/dist/schema/options.d.ts

@@ -65,6 +65,9 @@ export declare namespace LanguageModelDefaults {
     /** Normalize selected-model request defaults without applying precedence. */
     const make: (input: Input) => LanguageModelDefaults;
 }
+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 LanguageModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
 export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>;
 export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
@@ -80,10 +83,13 @@ declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompati
     readonly supportsStore: Schema.optional<Schema.Boolean>;
     readonly supportsUsageInStreaming: Schema.optional<Schema.Boolean>;
     readonly supportsStrictMode: Schema.optional<Schema.Boolean>;
+    readonly supportsPromptCacheKey: Schema.optional<Schema.Boolean>;
     readonly zaiToolStream: Schema.optional<Schema.Boolean>;
     readonly requireSignature: Schema.optional<Schema.Boolean>;
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
     readonly supportsThinkingBlockBinding: Schema.optional<Schema.Boolean>;
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    readonly supportsEffortUpdates: Schema.optional<Schema.Boolean>;
 }>, {}>;
 export declare class LanguageModelCompatibility extends LanguageModelCompatibility_base {
 }

package/dist/schema/options.js

@@ -94,6 +94,8 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
         });
     };
 })(LanguageModelDefaults || (LanguageModelDefaults = {}));
+export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
 export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
@@ -107,10 +109,15 @@ export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelC
     supportsStore: Schema.optional(Schema.Boolean),
     supportsUsageInStreaming: Schema.optional(Schema.Boolean),
     supportsStrictMode: Schema.optional(Schema.Boolean),
+    // Accepts `prompt_cache_key` in the Chat Completions body. Chat omits the
+    // key unless this is set; session-affinity headers still flow regardless.
+    supportsPromptCacheKey: Schema.optional(Schema.Boolean),
     zaiToolStream: Schema.optional(Schema.Boolean),
     requireSignature: Schema.optional(Schema.Boolean),
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
     supportsThinkingBlockBinding: Schema.optional(Schema.Boolean),
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    supportsEffortUpdates: Schema.optional(Schema.Boolean),
 }) {
 }
 (function (LanguageModelCompatibility) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.3",
+    "@opencode/http-recorder": "2.0.4",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,7 +40,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.3",
+    "@opencode/schema": "2.0.4",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"