@opencode/ai 2.0.27 → 2.0.29

package/README.md

@@ -182,7 +182,7 @@ console.log(response.answers.department.choice)
 console.log(response.answers.refund.probability)
 ```
 
-`TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCodeZen` exposes the same selector and reads
+`TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCode` exposes the same selector and reads
 `OPENCODE_API_KEY`. OpenRouter and Vercel AI Gateway use the same provider shape:
 
 ```ts

package/dist/cache-policy.js

@@ -143,17 +143,7 @@ const countHints = (request) => countToolHints(request.tools) +
     request.messages.reduce((count, message) => count +
         message.content.reduce((contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0), 0), 0);
 export const applyCachePolicy = (request) => {
-    const route = request.model.route.id;
-    if (!RESPECTS_INLINE_HINTS.has(route))
-        return request;
-    const policy = (route === "openrouter" || route === "vercel-ai-gateway-messages") &&
-        (request.cache === undefined || request.cache === "auto")
-        ? gatewayPolicy(request.model.id)
-        : route === "alibaba-chat" && (request.cache === undefined || request.cache === "auto")
-            ? request.model.id.toLowerCase().startsWith("qwen")
-                ? QWEN
-                : NONE
-            : resolve(request.cache);
+    const policy = selectPolicy(request);
     if (!policy.tools && !policy.system && !policy.messages)
         return request;
     const hint = makeHint(policy.ttlSeconds);
@@ -165,3 +155,22 @@ export const applyCachePolicy = (request) => {
         return request;
     return LLMRequest.update(request, { tools, system, messages });
 };
+// A declared cache format overrides the route allowlist and its model-ID heuristics.
+const selectPolicy = (request) => {
+    const format = request.model.compatibility?.cacheFormat;
+    const route = request.model.route.id;
+    const auto = request.cache === undefined || request.cache === "auto";
+    if (format === "alibaba")
+        return auto ? QWEN : { ...resolve(request.cache), tools: false };
+    if (format === "anthropic")
+        return resolve(request.cache);
+    if (!RESPECTS_INLINE_HINTS.has(route))
+        return NONE;
+    if (!auto)
+        return resolve(request.cache);
+    if (route === "openrouter" || route === "vercel-ai-gateway-messages")
+        return gatewayPolicy(request.model.id);
+    if (route === "alibaba-chat")
+        return request.model.id.toLowerCase().startsWith("qwen") ? QWEN : NONE;
+    return AUTO;
+};

package/dist/media.d.ts

@@ -100,12 +100,12 @@ export declare class Asset {
         };
         info: {
             readonly format?: string | undefined;
+            readonly encoding?: string | undefined;
             readonly width?: number | undefined;
             readonly height?: number | undefined;
             readonly durationSeconds?: number | undefined;
             readonly sampleRate?: number | undefined;
             readonly channels?: number | undefined;
-            readonly encoding?: string | undefined;
         } | undefined;
         providerMetadata: {
             readonly [x: string]: {

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

@@ -10,7 +10,7 @@ declare const Options: Schema.Struct<{
     readonly preserveThinking: Schema.optional<Schema.Boolean>;
     readonly clearThinking: Schema.optional<Schema.Boolean>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"disabled" | (string & {}) | "adaptive", "disabled" | (string & {}) | "adaptive">;
+        readonly type: Schema.declare<(string & {}) | "disabled" | "adaptive", (string & {}) | "disabled" | "adaptive">;
     }>>;
     readonly toolStream: Schema.optional<Schema.Boolean>;
     readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
@@ -140,7 +140,7 @@ export declare const protocol: Protocol<{
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
     readonly thinking?: {
-        readonly type: "disabled" | (string & {}) | "adaptive";
+        readonly type: (string & {}) | "disabled" | "adaptive";
     } | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";

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

@@ -5,7 +5,7 @@ import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 declare const Options: Schema.Struct<{
     readonly effort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"enabled" | "disabled" | (string & {}), "enabled" | "disabled" | (string & {})>;
+        readonly type: Schema.declare<(string & {}) | "enabled" | "disabled", (string & {}) | "enabled" | "disabled">;
         readonly budgetTokens: Schema.optional<Schema.Int>;
         readonly budget_tokens: Schema.optional<Schema.Int>;
     }>>;

package/dist/protocols/gemini.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
+import { HttpTransport, type Transport, type TransportPrepareInput } from "../route/transport/index.js";
 import { type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
@@ -100,8 +101,54 @@ declare const GeminiBody: Schema.Struct<{
             readonly thinkingLevel: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">, import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">>>;
         }>>;
     }>>;
+    continuationToken: Schema.optional<Schema.String>;
 }>;
 export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>;
+declare const GeminiUsage: Schema.Struct<{
+    readonly cachedContentTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly thoughtsTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly promptTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly candidatesTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly totalTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+}>;
+type GeminiUsage = Schema.Schema.Type<typeof GeminiUsage>;
+declare const GeminiPromptFeedback: Schema.StructWithRest<Schema.Struct<{
+    readonly blockReason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly blockReasonMessage: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly safetyRatings: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>;
+interface ParserState {
+    readonly route: string;
+    readonly providerMetadataKey: string;
+    readonly finishReason?: string;
+    readonly hasToolCalls: boolean;
+    readonly promptFeedback?: GeminiPromptFeedback;
+    readonly usage?: GeminiUsage;
+    /** Usage of the earlier requests of a response Gemini continued across requests. */
+    readonly continuedUsage?: ReadonlyArray<GeminiUsage>;
+    readonly lifecycle: Lifecycle.State;
+    readonly reasoningSignature?: string;
+    readonly textSignature?: string;
+    readonly reasoningId?: string;
+    readonly textId?: string;
+    readonly nextReasoningId: number;
+    readonly nextTextId: number;
+    readonly seenCallIds?: ReadonlySet<string>;
+}
+/** Marks where the transport starts another request for the same response; provider JSON can never match it. */
+declare class NextRequest {
+}
+export interface Prepared {
+    readonly http: HttpTransport.HttpPrepared<string>;
+    readonly input: TransportPrepareInput<GeminiBody>;
+}
+/**
+ * SSE transport that continues responses Gemini splits across requests. Chunks carry `continuationToken` checkpoints,
+ * and a request that reaches its output cap finishes with `CONTINUATION`. The transport resends the original body with
+ * the latest token, which also resumes a request that ended or dropped before finishing.
+ */
+export declare const transport: Transport<GeminiBody, Prepared, unknown>;
 /**
  * The Gemini protocol — request body construction, body schema, and the
  * streaming-event state machine shared by Google AI Studio and Vertex Gemini.
@@ -190,7 +237,8 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, string, {
+    readonly continuationToken?: string | undefined;
+}, NextRequest | {
     readonly error?: unknown;
     readonly candidates?: readonly {
         readonly content?: {
@@ -213,13 +261,28 @@ export declare const protocol: Protocol<{
         readonly thoughtsTokenCount?: number | null | undefined;
     } | null | undefined;
 }, {
-    route: string;
-    providerMetadataKey: string;
-    hasToolCalls: boolean;
-    lifecycle: Lifecycle.State;
-    nextReasoningId: number;
-    nextTextId: number;
-}>;
+    readonly error?: unknown;
+    readonly candidates?: readonly {
+        readonly content?: {
+            readonly parts?: readonly unknown[] | null | undefined;
+            readonly role?: "model" | "user" | null | undefined;
+        } | null | undefined;
+        readonly finishReason?: string | null | undefined;
+    }[] | null | undefined;
+    readonly promptFeedback?: {
+        readonly [x: string]: unknown;
+        readonly blockReason?: string | null | undefined;
+        readonly blockReasonMessage?: string | null | undefined;
+        readonly safetyRatings?: unknown;
+    } | null | undefined;
+    readonly usageMetadata?: {
+        readonly promptTokenCount?: number | null | undefined;
+        readonly candidatesTokenCount?: number | null | undefined;
+        readonly totalTokenCount?: number | null | undefined;
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
+    } | null | undefined;
+} | NextRequest, ParserState>;
 export declare const route: Route<{
     readonly contents: readonly {
         readonly parts?: readonly ({
@@ -304,5 +367,6 @@ export declare const route: Route<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
+    readonly continuationToken?: string | undefined;
+}, Prepared, import("../route/client.js").CompactionOperations | undefined>;
 export * as Gemini from "./gemini.js";

package/dist/protocols/gemini.js

@@ -1,10 +1,10 @@
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Schema, Stream } from "effect";
 import { Tool } from "@opencode/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
+import { HttpTransport, } from "../route/transport/index.js";
 import { AIError, LLMEvent, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { Media } from "../media.js";
@@ -12,6 +12,7 @@ import { JsonObject, knownString, lenient, optionalArray, optionalNull, Provider
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 const ADAPTER = "gemini";
+const CONTINUATION = "CONTINUATION";
 // Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
 const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
 // Gemini 2.5 rejects a budget under the model's minimum: 512 on Flash-Lite, the highest, and 128 on Pro.
@@ -162,6 +163,7 @@ const GeminiBodyFields = {
     tools: optionalArray(GeminiTool),
     toolConfig: Schema.optional(GeminiToolConfig),
     generationConfig: Schema.optional(GeminiGenerationConfig),
+    continuationToken: Schema.optional(Schema.String),
 };
 const GeminiBody = Schema.Struct(GeminiBodyFields);
 const GeminiUsage = Schema.Struct({
@@ -403,7 +405,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
 // `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
 // of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
 // to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage, metadataKey) => {
+const mapUsage = (usage, metadataKey, metadata = usage ?? {}) => {
     if (!usage)
         return undefined;
     // Explicit provider nulls decode as `null`; normalize to `undefined` so the
@@ -425,7 +427,26 @@ const mapUsage = (usage, metadataKey) => {
         cacheReadInputTokens: cached,
         reasoningTokens: thoughts,
         totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
-        providerMetadata: providerMetadata(metadataKey, usage),
+        providerMetadata: providerMetadata(metadataKey, metadata),
+    });
+};
+// Each continued request re-bills the output so far as input. Reporting the first request's input with all output keeps
+// input plus output equal to the response's final context size, under-reporting billed input; the summed billed counts
+// remain in provider metadata.
+const mapContinuedUsage = (requests, metadataKey) => {
+    const sum = (field) => ProviderShared.sumTokens(...requests.map((usage) => usage[field] ?? undefined));
+    return mapUsage({
+        promptTokenCount: requests[0].promptTokenCount,
+        cachedContentTokenCount: requests[0].cachedContentTokenCount,
+        candidatesTokenCount: sum("candidatesTokenCount"),
+        thoughtsTokenCount: sum("thoughtsTokenCount"),
+    }, metadataKey, {
+        promptTokenCount: sum("promptTokenCount"),
+        cachedContentTokenCount: sum("cachedContentTokenCount"),
+        candidatesTokenCount: sum("candidatesTokenCount"),
+        thoughtsTokenCount: sum("thoughtsTokenCount"),
+        totalTokenCount: sum("totalTokenCount"),
+        requests: requests.length,
     });
 };
 const mapFinishReason = (finishReason, hasToolCalls) => {
@@ -451,7 +472,7 @@ const finish = (state) => {
     // the "nothing to finish" check below keeps its meaning.
     const promptBlockReason = state.finishReason === undefined ? (state.promptFeedback?.blockReason ?? undefined) : undefined;
     const finishReason = state.finishReason ?? promptBlockReason;
-    if (finishReason === undefined && state.usage === undefined)
+    if (finishReason === undefined && state.usage === undefined && state.continuedUsage === undefined)
         return [];
     const events = [];
     let lifecycle = state.lifecycle;
@@ -468,7 +489,9 @@ const finish = (state) => {
             normalized: promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
             raw: finishReason,
         },
-        usage: state.usage,
+        usage: state.continuedUsage === undefined
+            ? mapUsage(state.usage, state.providerMetadataKey)
+            : mapContinuedUsage([...state.continuedUsage, state.usage ?? {}], state.providerMetadataKey),
         providerMetadata: state.promptFeedback === undefined
             ? undefined
             : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
@@ -476,6 +499,18 @@ const finish = (state) => {
     return events;
 };
 const step = (state, event) => {
+    // Usage is cumulative within one request, so the next request of the same response counts from zero.
+    if (event instanceof NextRequest)
+        return Effect.succeed([
+            {
+                ...state,
+                finishReason: undefined,
+                promptFeedback: undefined,
+                usage: undefined,
+                continuedUsage: [...(state.continuedUsage ?? []), state.usage ?? {}],
+            },
+            [],
+        ]);
     if (ProviderShared.isRecord(event.error)) {
         const body = ProviderShared.encodeJson(event);
         return Effect.fail(new AIError({
@@ -492,21 +527,17 @@ const step = (state, event) => {
     }
     if ("error" in event)
         return Effect.fail(ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)));
+    const candidate = event.candidates?.[0];
     const nextState = {
         ...state,
         promptFeedback: event.promptFeedback ?? state.promptFeedback,
-        usage: event.usageMetadata
-            ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
-            : state.usage,
+        usage: event.usageMetadata ?? state.usage,
+        finishReason: candidate?.finishReason ?? state.finishReason,
     };
-    const candidate = event.candidates?.[0];
     if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
         return Effect.fail(ProviderShared.eventError(state.route, `Gemini stopped with ${candidate.finishReason}`, ProviderShared.encodeJson(event)));
     if (!candidate?.content)
-        return Effect.succeed([
-            { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },
-            [],
-        ]);
+        return Effect.succeed([nextState, []]);
     const events = [];
     let hasToolCalls = nextState.hasToolCalls;
     let lifecycle = nextState.lifecycle;
@@ -625,12 +656,75 @@ const step = (state, event) => {
             nextReasoningId,
             nextTextId,
             seenCallIds,
-            finishReason: candidate.finishReason ?? nextState.finishReason,
         },
         events,
     ]);
 };
 // =============================================================================
+// Transport
+// =============================================================================
+const GeminiCheckpoint = Schema.Struct({
+    candidates: optionalNull(Schema.Array(Schema.Struct({
+        finishReason: optionalNull(Schema.String),
+        continuationToken: optionalNull(Schema.String),
+    }))),
+});
+const decodeCheckpoint = Schema.decodeUnknownOption(GeminiCheckpoint);
+/** Marks where the transport starts another request for the same response; provider JSON can never match it. */
+class NextRequest {
+}
+const sse = HttpTransport.sseJson.with();
+/**
+ * SSE transport that continues responses Gemini splits across requests. Chunks carry `continuationToken` checkpoints,
+ * and a request that reaches its output cap finishes with `CONTINUATION`. The transport resends the original body with
+ * the latest token, which also resumes a request that ended or dropped before finishing.
+ */
+export const transport = {
+    id: sse.id,
+    prepare: (input) => sse.prepare(input).pipe(Effect.map((http) => ({ http, input }))),
+    execute: (prepared, request, runtime) => Effect.gen(function* () {
+        const route = request.model.route.id;
+        const label = `${request.model.provider}/${route}`;
+        // Frames are parsed once here, so errors recover each frame's raw text for their body.
+        const raw = new WeakMap();
+        const respond = (execution) => Stream.suspend(() => {
+            let token;
+            let finishReason;
+            let dropped;
+            return execution.frames.pipe(Stream.mapEffect((frame) => ProviderShared.parseJson(route, frame, `Invalid ${label} stream event`).pipe(Effect.map((event) => {
+                if (typeof event === "object" && event !== null)
+                    raw.set(event, frame);
+                const candidate = Option.getOrUndefined(decodeCheckpoint(event))?.candidates?.[0];
+                token = candidate?.continuationToken ?? (candidate?.finishReason ? undefined : token);
+                finishReason = candidate?.finishReason ?? finishReason;
+                return event;
+            }))), Stream.catchIf(
+            // A connection failure may resume; a timeout keeps its meaning and ends the response.
+            (error) => error.reason._tag === "Transport" && error.reason.code !== "Timeout", (error) => {
+                dropped = error;
+                return Stream.empty;
+            }), Stream.concat(Stream.suspend(() => {
+                if (token !== undefined && (finishReason === undefined || finishReason === CONTINUATION))
+                    return Stream.concat(Stream.succeed(new NextRequest()), next(token));
+                if (dropped)
+                    return Stream.fail(dropped);
+                if (finishReason === CONTINUATION)
+                    return Stream.fail(ProviderShared.eventError(label, "Gemini continued the response without a token"));
+                return Stream.empty;
+            })));
+        });
+        const next = (continuationToken) => Stream.unwrap(sse
+            .prepare({ ...prepared.input, body: { ...prepared.input.body, continuationToken } })
+            .pipe(Effect.flatMap((continued) => sse.execute(continued, request, runtime)), Effect.map(respond)));
+        const first = yield* sse.execute(prepared.http, request, runtime);
+        return {
+            frames: respond(first),
+            http: first.http,
+            body: (frame) => (typeof frame === "object" && frame !== null ? raw.get(frame) : undefined),
+        };
+    }),
+};
+// =============================================================================
 // Protocol And Gemini Route
 // =============================================================================
 /**
@@ -646,7 +740,7 @@ export const protocol = Protocol.make({
     // Gemini's schema rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
     sanitizer: "gemini",
     stream: {
-        event: Protocol.jsonEvent(GeminiEvent),
+        event: Schema.Union([Schema.instanceOf(NextRequest), GeminiEvent]),
         initial: (request) => ({
             route: `${request.model.provider}/${request.model.route.id}`,
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
@@ -669,6 +763,6 @@ export const route = Route.make({
         baseURL: DEFAULT_BASE_URL,
     }),
     auth: Auth.none,
-    framing: Framing.sse,
+    transport,
 });
 export * as Gemini from "./gemini.js";

package/dist/protocols/mistral-chat.js

@@ -317,7 +317,9 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         frequency_penalty: request.generation?.frequencyPenalty,
         presence_penalty: request.generation?.presencePenalty,
         stop: request.generation?.stop,
-        prompt_cache_key: request.cache === "none" ? undefined : (options.promptCacheKey ?? request.promptCacheKey),
+        prompt_cache_key: ProviderShared.sendsPromptCacheKey(request)
+            ? (options.promptCacheKey ?? request.promptCacheKey)
+            : undefined,
         safe_prompt: options.safePrompt,
         document_image_limit: options.documentImageLimit,
         document_page_limit: options.documentPageLimit,

package/dist/protocols/open-responses-channel.js

@@ -106,7 +106,12 @@ export const transport = (options) => {
                 });
             return {
                 http: {
-                    request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
+                    request: ProviderShared.jsonPost({
+                        url: parts.url,
+                        body: parts.bodyText,
+                        headers: parts.headers,
+                        encoding: input.request.http?.encoding,
+                    }),
                     framing: Framing.sse,
                     middleware: input.middleware,
                 },

package/dist/protocols/openai-chat.js

@@ -9,6 +9,7 @@ import { Protocol } from "../route/protocol.js";
 import { AIError, AIErrorReason, InvalidProviderOutputError, LLMEvent, ProviderInternalError, UnknownProviderError, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
+import { cacheControl } from "./utils/cache.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
@@ -646,14 +647,15 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
     const zaiToolStream = request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id);
     const hasHistory = hasToolHistory(request.messages);
     const hasActiveTools = flattened.tools.length > 0;
+    const lowering = { ...options, cacheControl: options.cacheControl ?? declaredCacheControl(request) };
     return {
         model: request.model.id,
-        messages: yield* lowerMessages(flattened.request, options),
+        messages: yield* lowerMessages(flattened.request, lowering),
         tools: flattened.tools.length === 0
             ? hasHistory
                 ? []
                 : undefined
-            : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
+            : flattened.tools.map((tool) => lowerTool(tool, lowering, supportsStrictMode)),
         tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
         ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
@@ -670,6 +672,8 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
         ...lowerOptions(request, supportsStore),
     };
 });
+// Provider wrappers that pass their own marker writer keep it; otherwise a declared cache format adds one.
+const declaredCacheControl = (request) => request.model.compatibility?.cacheFormat === undefined ? undefined : cacheControl();
 // =============================================================================
 // Stream Parsing
 // =============================================================================

package/dist/protocols/shared.d.ts

@@ -2,7 +2,7 @@ import { Tool } from "@opencode/schema/tool";
 import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/http";
 import { Media } from "../media.js";
-import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type OpenString, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
+import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type OpenString, type ProviderID, type RequestEncoding, type ToolEntry, type ToolResultPart } from "../schema/index.js";
 import { Json, decodeJson, encodeJson } from "../utils/json.js";
 import { isRecord } from "../utils/record.js";
 export { Json, decodeJson, encodeJson, isRecord };
@@ -14,6 +14,7 @@ export declare const lenient: <const S extends Schema.Top>(schema: S) => Schema.
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
 export declare const knownString: <Known extends string>() => Schema.declare<OpenString<Known>, OpenString<Known>>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+export declare const sendsPromptCacheKey: (request: LLMRequest) => boolean;
 export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
@@ -192,10 +193,13 @@ export declare const validateWith: <A, I, E extends {
  * send JSON with a stale content type. The body is passed pre-encoded so
  * routes can choose between
  * `Schema.encodeSync(payload)` and `ProviderShared.encodeJson(payload)`.
+ * A `zstd` or `gzip` encoding compresses the body and sets `content-encoding`;
+ * it falls back to plain JSON when the runtime has no zlib.
  */
 export declare const jsonPost: (input: {
     readonly url: string;
     readonly body: string;
     readonly headers?: Headers.Input;
+    readonly encoding?: RequestEncoding;
 }) => HttpClientRequest.HttpClientRequest;
 export * as ProviderShared from "./shared.js";

package/dist/protocols/shared.js

@@ -17,10 +17,13 @@ export const knownString = () => Schema.declare((value) => typeof value === "str
     expected: "string",
 });
 export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+// Body-level `prompt_cache_key` is off when caching is disabled or the model
+// explicitly rejects the field. Header-based affinity is unaffected.
+export const sendsPromptCacheKey = (request) => request.cache !== "none" && request.model.compatibility?.supportsPromptCacheKey !== false;
 // 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 promptCacheKey = (request) => {
-    if (request.cache === "none" || request.promptCacheKey === undefined)
+    if (!sendsPromptCacheKey(request) || request.promptCacheKey === undefined)
         return undefined;
     const chars = Array.from(request.promptCacheKey);
     if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
@@ -279,6 +282,29 @@ export const validateWith = (decode) => (payload) => decode(payload).pipe(Effect
  * send JSON with a stale content type. The body is passed pre-encoded so
  * routes can choose between
  * `Schema.encodeSync(payload)` and `ProviderShared.encodeJson(payload)`.
+ * A `zstd` or `gzip` encoding compresses the body and sets `content-encoding`;
+ * it falls back to plain JSON when the runtime has no zlib.
  */
-export const jsonPost = (input) => HttpClientRequest.post(input.url).pipe(HttpClientRequest.setHeaders(Headers.set(Headers.fromInput(input.headers), "content-type", "application/json")), HttpClientRequest.bodyText(input.body, "application/json"));
+export const jsonPost = (input) => {
+    const headers = Headers.set(Headers.fromInput(input.headers), "content-type", "application/json");
+    const compressed = compressBody(input.body, input.encoding);
+    if (!compressed)
+        return HttpClientRequest.post(input.url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(input.body, "application/json"));
+    return HttpClientRequest.post(input.url).pipe(HttpClientRequest.setHeaders(Headers.set(headers, "content-encoding", compressed.encoding)), HttpClientRequest.bodyUint8Array(compressed.body, "application/json"));
+};
+function compressBody(text, encoding) {
+    if (encoding === undefined || encoding === "none")
+        return undefined;
+    // Looked up at call time instead of imported: a runtime without node:zlib or its zstd export
+    // (browsers, older Node, some workerd setups) sends plain JSON rather than failing to load this module.
+    const zlib = globalThis.process?.getBuiltinModule?.("node:zlib");
+    try {
+        const body = encoding === "zstd" ? zlib?.zstdCompressSync?.(text) : zlib?.gzipSync(text);
+        return body && { encoding, body };
+    }
+    catch {
+        // Compression is an optimization, so a failure sends plain JSON instead of failing the request.
+        return undefined;
+    }
+}
 export * as ProviderShared from "./shared.js";

package/dist/protocols/utils/responses-compaction.js

@@ -87,7 +87,12 @@ export const make = (adapter, lowerTools) => Effect.fn("ResponsesCompaction.exec
         auth: route.auth,
         encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
     });
-    const response = yield* executor.execute(ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }), options?.http);
+    const response = yield* executor.execute(ProviderShared.jsonPost({
+        url: parts.url,
+        body: parts.bodyText,
+        headers: parts.headers,
+        encoding: request.http?.encoding,
+    }), options?.http);
     const text = yield* RequestExecutor.responseStream(response).pipe(Stream.decodeText(), Stream.runFold(() => "", (text, chunk) => text + chunk));
     const invalid = (message, cause) => new AIError({
         reason: new InvalidProviderOutputError({

package/dist/providers/alibaba.d.ts

@@ -129,7 +129,7 @@ export declare const routes: (Route<{
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
     readonly thinking?: {
-        readonly type: "disabled" | (string & {}) | "adaptive";
+        readonly type: (string & {}) | "disabled" | "adaptive";
     } | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
@@ -611,7 +611,7 @@ export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<{
         readonly thinking?: {
-            readonly type: "disabled" | (string & {}) | "adaptive";
+            readonly type: (string & {}) | "disabled" | "adaptive";
         } | undefined;
         readonly thinkingBudget?: number | undefined;
         readonly parallelToolCalls?: boolean | undefined;
@@ -636,7 +636,7 @@ export declare const configure: (input: Config) => {
     }, import("../route/client.js").CompactionOperations | undefined>;
     chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<{
         readonly thinking?: {
-            readonly type: "disabled" | (string & {}) | "adaptive";
+            readonly type: (string & {}) | "disabled" | "adaptive";
         } | undefined;
         readonly thinkingBudget?: number | undefined;
         readonly parallelToolCalls?: boolean | undefined;
@@ -675,7 +675,7 @@ export declare const provider: {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<{
             readonly thinking?: {
-                readonly type: "disabled" | (string & {}) | "adaptive";
+                readonly type: (string & {}) | "disabled" | "adaptive";
             } | undefined;
             readonly thinkingBudget?: number | undefined;
             readonly parallelToolCalls?: boolean | undefined;
@@ -700,7 +700,7 @@ export declare const provider: {
         }, import("../route/client.js").CompactionOperations | undefined>;
         chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<{
             readonly thinking?: {
-                readonly type: "disabled" | (string & {}) | "adaptive";
+                readonly type: (string & {}) | "disabled" | "adaptive";
             } | undefined;
             readonly thinkingBudget?: number | undefined;
             readonly parallelToolCalls?: boolean | undefined;

package/dist/providers/google-vertex.d.ts

@@ -109,7 +109,8 @@ export declare const routes: Route<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
+    readonly continuationToken?: string | undefined;
+}, Gemini.Prepared, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiOptionsInput, import("../route/client.js").CompactionOperations | undefined>;

package/dist/providers/google-vertex.js

@@ -4,7 +4,6 @@ import { ProviderShared } from "../protocols/shared.js";
 import { Auth } from "../route/auth.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
 import { GoogleVertexShared } from "./google-vertex-shared.js";
 export const id = ProviderID.make("google-vertex");
@@ -37,7 +36,7 @@ const route = Route.make({
         const serviceTier = request.providerOptions?.serviceTier;
         return typeof serviceTier === "string" ? { "x-vertex-ai-llm-shared-request-type": serviceTier } : {};
     },
-    framing: Framing.sse,
+    transport: Gemini.transport,
 });
 export const routes = [route];
 const configuredRoute = (input, modelID) => {

package/dist/providers/google.d.ts

@@ -96,7 +96,8 @@ export declare const routes: (import("../route/client.js").Route<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | import("../route/client.js").Route<{
+    readonly continuationToken?: string | undefined;
+}, Gemini.Prepared, import("../route/client.js").CompactionOperations | undefined> | import("../route/client.js").Route<{
     readonly input: readonly ({
         readonly type: "user_input" | "model_output";
         readonly content: readonly ({

package/dist/providers/index.d.ts

@@ -34,7 +34,7 @@ export * as Moonshot from "./moonshot.js";
 export * as OpenAI from "./openai.js";
 export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";
 export * as OpenRouter from "./openrouter.js";
 export * as Replicate from "./replicate.js";
 export * as Runway from "./runway.js";

package/dist/providers/index.js

@@ -34,7 +34,7 @@ export * as Moonshot from "./moonshot.js";
 export * as OpenAI from "./openai.js";
 export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";
 export * as OpenRouter from "./openrouter.js";
 export * as Replicate from "./replicate.js";
 export * as Runway from "./runway.js";

package/dist/providers/{opencode-zen.d.ts → opencode.d.ts}

@@ -29,4 +29,4 @@ export declare const provider: {
 export declare const experimental: {
     evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
 };
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";

package/dist/providers/{opencode-zen.js → opencode.js}

@@ -2,7 +2,7 @@ import { HttpOptions, ProviderID } from "../schema/index.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { SystemOne } from "../experimental/system-one.js";
 export const id = ProviderID.make("opencode");
-const baseURL = "https://opencode.ai/zen/v1";
+const baseURL = "https://opencode.ai/inference/v1";
 export const configure = (input = {}) => {
     const evaluation = (modelID) => SystemOne.model({
         id: modelID,
@@ -17,4 +17,4 @@ export const configure = (input = {}) => {
 };
 export const provider = configure();
 export const experimental = provider.experimental;
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";

package/dist/route/transport/http.js

@@ -4,7 +4,7 @@ import { Auth } from "../auth.js";
 import { render as renderEndpoint } from "../endpoint.js";
 import { Framing } from "../framing.js";
 import * as ProviderShared from "../../protocols/shared.js";
-import { AIError, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
+import { AIError, DEFAULT_CHUNK_TIMEOUT_MS, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
 import { RequestExecutor } from "../executor.js";
 const applyQuery = (url, query) => {
     if (!query)
@@ -46,6 +46,7 @@ export const httpJson = (input) => ({
             url: parts.url,
             body: parts.bodyText,
             headers: parts.headers,
+            encoding: prepareInput.request.http?.encoding,
         });
         return {
             request,
@@ -75,7 +76,7 @@ export const httpJson = (input) => ({
         const remaining = Duration.subtract(total, Duration.millis((yield* Clock.currentTimeMillis) - started));
         return {
             frames: prepared.framing.frame(RequestExecutor.responseStream(response).pipe(Stream.timeoutOrElse({
-                duration: timeoutDuration(request.http?.chunkTimeout),
+                duration: timeoutDuration(request.http?.chunkTimeout, DEFAULT_CHUNK_TIMEOUT_MS),
                 orElse: () => Stream.fail(timeout("read", "Timed out waiting for response data", http)),
             }), Stream.interruptWhen(Effect.sleep(remaining).pipe(Effect.andThen(Effect.fail(timeout("read", "Timed out waiting for the response to complete", http))))))),
             http,
@@ -83,7 +84,7 @@ export const httpJson = (input) => ({
         };
     }),
 });
-const timeoutDuration = (value) => value === false ? Duration.infinity : Duration.millis(value ?? DEFAULT_HTTP_TIMEOUT_MS);
+const timeoutDuration = (value, fallback = DEFAULT_HTTP_TIMEOUT_MS) => value === false ? Duration.infinity : Duration.millis(value ?? fallback);
 export const sseJson = {
     id: "http-json/sse",
     with: () => httpJson({ framing: Framing.sse }),

package/dist/schema/options.d.ts

@@ -12,8 +12,16 @@ export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOpti
 /** Milliseconds for an HTTP timeout, or `false` to disable it. */
 export declare const HttpTimeout: Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>;
 export type HttpTimeout = Schema.Schema.Type<typeof HttpTimeout>;
-/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+/** Applied to `headerTimeout` when a request leaves it unset. */
 export declare const DEFAULT_HTTP_TIMEOUT_MS = 300000;
+/**
+ * Applied to `chunkTimeout` when a request leaves it unset. Some providers, such as DeepSeek, have specifically asked
+ * clients to allow at least 15 minutes, because their models can stream nothing for minutes while they reason.
+ */
+export declare const DEFAULT_CHUNK_TIMEOUT_MS = 900000;
+/** `Content-Encoding` for JSON request bodies; `none` sends plain JSON. */
+export declare const RequestEncoding: Schema.Literals<readonly ["zstd", "gzip", "none"]>;
+export type RequestEncoding = Schema.Schema.Type<typeof RequestEncoding>;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -24,6 +32,8 @@ declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly headerTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
     /** Time allowed between streamed response chunks once headers have arrived. */
     readonly chunkTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
+    /** Compression for JSON request bodies. Only set it for endpoints known to decode it. */
+    readonly encoding: Schema.optional<Schema.Literals<readonly ["zstd", "gzip", "none"]>>;
 }>, {}>;
 export declare class HttpOptions extends HttpOptions_base {
 }
@@ -89,6 +99,8 @@ export declare const LanguageModelSanitizerCompatibility: Schema.Literals<readon
 export type LanguageModelSanitizerCompatibility = Schema.Schema.Type<typeof LanguageModelSanitizerCompatibility>;
 export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
 export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
+export declare const LanguageModelCacheFormatCompatibility: Schema.Literals<readonly ["anthropic", "alibaba"]>;
+export type LanguageModelCacheFormatCompatibility = Schema.Schema.Type<typeof LanguageModelCacheFormatCompatibility>;
 declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
     readonly sanitizer: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot", "none"]>>;
     readonly reasoningField: Schema.optional<Schema.String>;
@@ -101,6 +113,8 @@ declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompati
     readonly supportsUsageInStreaming: Schema.optional<Schema.Boolean>;
     readonly supportsStrictMode: Schema.optional<Schema.Boolean>;
     readonly supportsPromptCacheKey: Schema.optional<Schema.Boolean>;
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    readonly cacheFormat: Schema.optional<Schema.Literals<readonly ["anthropic", "alibaba"]>>;
     readonly zaiToolStream: Schema.optional<Schema.Boolean>;
     readonly requireSignature: Schema.optional<Schema.Boolean>;
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */

package/dist/schema/options.js

@@ -34,8 +34,15 @@ export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schem
 export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
 /** Milliseconds for an HTTP timeout, or `false` to disable it. */
 export const HttpTimeout = Schema.Union([Schema.Number.check(Schema.isGreaterThan(0)), Schema.Literal(false)]);
-/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+/** Applied to `headerTimeout` when a request leaves it unset. */
 export const DEFAULT_HTTP_TIMEOUT_MS = 300_000;
+/**
+ * Applied to `chunkTimeout` when a request leaves it unset. Some providers, such as DeepSeek, have specifically asked
+ * clients to allow at least 15 minutes, because their models can stream nothing for minutes while they reason.
+ */
+export const DEFAULT_CHUNK_TIMEOUT_MS = 900_000;
+/** `Content-Encoding` for JSON request bodies; `none` sends plain JSON. */
+export const RequestEncoding = Schema.Literals(["zstd", "gzip", "none"]);
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -46,6 +53,8 @@ export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     headerTimeout: Schema.optional(HttpTimeout),
     /** Time allowed between streamed response chunks once headers have arrived. */
     chunkTimeout: Schema.optional(HttpTimeout),
+    /** Compression for JSON request bodies. Only set it for endpoints known to decode it. */
+    encoding: Schema.optional(RequestEncoding),
 }) {
 }
 (function (HttpOptions) {
@@ -63,9 +72,16 @@ export const mergeHttpOptions = (...items) => {
     const timeout = items.findLast((item) => item?.timeout !== undefined)?.timeout;
     const headerTimeout = items.findLast((item) => item?.headerTimeout !== undefined)?.headerTimeout;
     const chunkTimeout = items.findLast((item) => item?.chunkTimeout !== undefined)?.chunkTimeout;
-    if (!body && !headers && !query && timeout === undefined && headerTimeout === undefined && chunkTimeout === undefined)
+    const encoding = items.findLast((item) => item?.encoding !== undefined)?.encoding;
+    if (!body &&
+        !headers &&
+        !query &&
+        timeout === undefined &&
+        headerTimeout === undefined &&
+        chunkTimeout === undefined &&
+        encoding === undefined)
         return undefined;
-    return new HttpOptions({ body, headers, query, timeout, headerTimeout, chunkTimeout });
+    return new HttpOptions({ body, headers, query, timeout, headerTimeout, chunkTimeout, encoding });
 };
 export class GenerationOptions extends Schema.Class("LLM.GenerationOptions")({
     maxTokens: Schema.optional(Schema.Number),
@@ -119,6 +135,7 @@ export const ReasoningEffort = Schema.declare((value) => typeof value === "strin
 /** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
 export const LanguageModelSanitizerCompatibility = Schema.Literals(["gemini", "moonshot", "none"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
+export const LanguageModelCacheFormatCompatibility = Schema.Literals(["anthropic", "alibaba"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
     sanitizer: Schema.optional(LanguageModelSanitizerCompatibility),
     reasoningField: Schema.optional(Schema.String),
@@ -130,9 +147,12 @@ 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.
+    // Accepts `prompt_cache_key` in the request body. Chat omits the key unless
+    // this is true; other protocols omit it only when this is false.
+    // Session-affinity headers still flow regardless.
     supportsPromptCacheKey: Schema.optional(Schema.Boolean),
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    cacheFormat: Schema.optional(LanguageModelCacheFormatCompatibility),
     zaiToolStream: Schema.optional(Schema.Boolean),
     requireSignature: Schema.optional(Schema.Boolean),
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */

package/package.json

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