@opencode/ai 2.0.20 → 2.0.21

package/dist/cache-policy.js

@@ -48,6 +48,18 @@ const RESPECTS_INLINE_HINTS = new Set([
     "bedrock-converse",
     "openrouter",
 ]);
+// OpenRouter upstreams other than Anthropic and Alibaba Qwen cache without breakpoints. Gemini uses only the last
+// breakpoint, so a conversation-tail breakpoint writes a new cache every step and costs more than none. Qwen ignores
+// breakpoints on tool definitions and caches tools with the system prompt.
+const openRouterPolicy = (modelID) => {
+    // `~anthropic/claude-sonnet-latest` style IDs are OpenRouter aliases for the latest model in a family.
+    const id = modelID.replace(/^~/, "");
+    if (id.startsWith("anthropic/"))
+        return AUTO;
+    if (id.startsWith("qwen/"))
+        return { system: true, messages: { tail: 1 } };
+    return NONE;
+};
 const makeHint = (ttlSeconds) => ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" });
 const markLastTool = (tools, hint, budget) => {
     const target = tools.at(-1);
@@ -128,9 +140,9 @@ const countHints = (request) => countToolHints(request.tools) +
 export const applyCachePolicy = (request) => {
     if (!RESPECTS_INLINE_HINTS.has(request.model.route.id))
         return request;
-    if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto"))
-        return request;
-    const policy = resolve(request.cache);
+    const policy = request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")
+        ? openRouterPolicy(request.model.id)
+        : resolve(request.cache);
     if (!policy.tools && !policy.system && !policy.messages)
         return request;
     const hint = makeHint(policy.ttlSeconds);

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

@@ -80,15 +80,18 @@ export declare const protocol: Protocol<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -104,13 +107,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;

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

@@ -12,6 +12,7 @@ declare const OpenAIChatCacheControl: Schema.Struct<{
     readonly type: Schema.Literal<"ephemeral">;
     readonly ttl: Schema.optional<Schema.String>;
 }>;
+type OpenAIChatCacheControl = Schema.Schema.Type<typeof OpenAIChatCacheControl>;
 declare const ExtraContent: Schema.Struct<{
     readonly google: Schema.Struct<{
         readonly thought_signature: Schema.String;
@@ -94,7 +95,14 @@ export declare const bodyFields: {
         }>]>>]>;
     }>, Schema.StructWithRest<Schema.Struct<{
         readonly role: Schema.Literal<"assistant">;
-        readonly content: Schema.NullOr<Schema.String>;
+        readonly content: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>>]>>;
         readonly tool_calls: Schema.optional<Schema.$Array<Schema.Struct<{
             readonly id: Schema.String;
             readonly type: Schema.tag<"function">;
@@ -112,18 +120,17 @@ export declare const bodyFields: {
         readonly reasoning: Schema.optional<Schema.String>;
         readonly reasoning_text: Schema.optional<Schema.String>;
         readonly reasoning_details: Schema.optional<Schema.Unknown>;
-        readonly cache_control: Schema.optional<Schema.Struct<{
-            readonly type: Schema.Literal<"ephemeral">;
-            readonly ttl: Schema.optional<Schema.String>;
-        }>>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.Struct<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
-        readonly content: Schema.String;
-        readonly cache_control: Schema.optional<Schema.Struct<{
-            readonly type: Schema.Literal<"ephemeral">;
-            readonly ttl: Schema.optional<Schema.String>;
-        }>>;
+        readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>>]>;
     }>]>>;
     tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
@@ -207,7 +214,14 @@ declare const OpenAIChatBody: Schema.Struct<{
         }>]>>]>;
     }>, Schema.StructWithRest<Schema.Struct<{
         readonly role: Schema.Literal<"assistant">;
-        readonly content: Schema.NullOr<Schema.String>;
+        readonly content: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>>]>>;
         readonly tool_calls: Schema.optional<Schema.$Array<Schema.Struct<{
             readonly id: Schema.String;
             readonly type: Schema.tag<"function">;
@@ -225,18 +239,17 @@ declare const OpenAIChatBody: Schema.Struct<{
         readonly reasoning: Schema.optional<Schema.String>;
         readonly reasoning_text: Schema.optional<Schema.String>;
         readonly reasoning_details: Schema.optional<Schema.Unknown>;
-        readonly cache_control: Schema.optional<Schema.Struct<{
-            readonly type: Schema.Literal<"ephemeral">;
-            readonly ttl: Schema.optional<Schema.String>;
-        }>>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.Struct<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
-        readonly content: Schema.String;
-        readonly cache_control: Schema.optional<Schema.Struct<{
-            readonly type: Schema.Literal<"ephemeral">;
-            readonly ttl: Schema.optional<Schema.String>;
-        }>>;
+        readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>>]>;
     }>]>>;
     tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
@@ -360,7 +373,7 @@ export interface ParserState {
     readonly requireFinishReason: boolean;
 }
 interface LoweringOptions {
-    readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
+    readonly cacheControl?: (cache: CacheHint | undefined) => OpenAIChatCacheControl | undefined;
     readonly toolCallID?: (id: string) => string;
 }
 export declare const fromRequest: (request: LLMRequest<import("../schema/options.js").LanguageModel<{
@@ -425,15 +438,18 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -449,13 +465,16 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     tools: {
         readonly function: {
@@ -539,15 +558,18 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -563,13 +585,16 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     tools: {
         readonly function: {
@@ -646,15 +671,18 @@ export declare const protocol: Protocol<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -670,13 +698,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;
@@ -831,15 +862,18 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -855,13 +889,16 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;
@@ -947,15 +984,18 @@ export declare const route: Route<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -971,13 +1011,16 @@ export declare const route: Route<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;

package/dist/protocols/openai-chat.js

@@ -83,12 +83,13 @@ const ReasoningDetail = Schema.Union([
 ]);
 const decodeReasoningDetail = Schema.decodeUnknownOption(ReasoningDetail);
 const knownReasoningDetails = (details) => details.flatMap((detail) => Option.toArray(decodeReasoningDetail(detail)));
+const OpenAIChatTextContent = Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    cache_control: Schema.optional(OpenAIChatCacheControl),
+});
 const OpenAIChatUserContent = Schema.Union([
-    Schema.Struct({
-        type: Schema.Literal("text"),
-        text: Schema.String,
-        cache_control: Schema.optional(OpenAIChatCacheControl),
-    }),
+    OpenAIChatTextContent,
     Schema.Struct({
         type: Schema.Literal("image_url"),
         image_url: Schema.Struct({ url: Schema.String }),
@@ -109,19 +110,17 @@ const OpenAIChatMessage = Schema.Union([
     }),
     Schema.StructWithRest(Schema.Struct({
         role: Schema.Literal("assistant"),
-        content: Schema.NullOr(Schema.String),
+        content: Schema.NullOr(Schema.Union([Schema.String, Schema.Array(OpenAIChatTextContent)])),
         tool_calls: optionalArray(OpenAIChatAssistantToolCall),
         reasoning_content: Schema.optional(Schema.String),
         reasoning: Schema.optional(Schema.String),
         reasoning_text: Schema.optional(Schema.String),
         reasoning_details: Schema.optional(Schema.Unknown),
-        cache_control: Schema.optional(OpenAIChatCacheControl),
     }), [Schema.Record(Schema.String, Schema.Unknown)]),
     Schema.Struct({
         role: Schema.Literal("tool"),
         tool_call_id: Schema.String,
-        content: Schema.String,
-        cache_control: Schema.optional(OpenAIChatCacheControl),
+        content: Schema.Union([Schema.String, Schema.Array(OpenAIChatTextContent)]),
     }),
 ]).pipe(Schema.toTaggedUnion("role"));
 const OpenAIChatToolChoice = Schema.Union([
@@ -305,7 +304,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
         if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
             return yield* ProviderShared.unsupportedContent("OpenAI Chat", "assistant", ["text", "reasoning", "tool-call"]);
         if (part.type === "text") {
-            content.push(part);
+            content.push({ type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) });
             continue;
         }
         if (part.type === "reasoning") {
@@ -347,14 +346,17 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
             return nativeReasoning ?? (requireReasoning ? "" : undefined);
         return text;
     })();
-    const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined);
-    const cacheControl = options.cacheControl?.(cached && "cache" in cached ? cached.cache : undefined);
     const result = {
         role: "assistant",
-        content: content.length > 0 ? content.map((part) => part.text).join("") : toolCalls.length > 0 ? null : "",
+        content: (() => {
+            if (content.some((part) => part.cache_control !== undefined))
+                return content;
+            if (content.length === 0 && toolCalls.length > 0)
+                return null;
+            return content.map((part) => part.text).join("");
+        })(),
         ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
         ...(details !== undefined ? { reasoning_details: details } : {}),
-        ...(cacheControl !== undefined ? { cache_control: cacheControl } : {}),
     };
     if (field === undefined || reasoningText === undefined)
         return result;
@@ -367,27 +369,23 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
         if (!ProviderShared.supportsContent(part, ["tool-result"]))
             return yield* ProviderShared.unsupportedContent("OpenAI Chat", "tool", ["tool-result"]);
         if (part.result.type !== "content") {
-            messages.push({
-                role: "tool",
-                tool_call_id: options.toolCallID?.(part.id) ?? part.id,
-                content: ProviderShared.toolResultText(part),
-                cache_control: options.cacheControl?.(part.cache),
-            });
+            messages.push(toolMessage(options.toolCallID?.(part.id) ?? part.id, ProviderShared.toolResultText(part), options.cacheControl?.(part.cache)));
             continue;
         }
         const content = part.result.value;
         const text = content.filter((item) => item.type === "text").map((item) => item.text);
-        messages.push({
-            role: "tool",
-            tool_call_id: options.toolCallID?.(part.id) ?? part.id,
-            content: text.join("\n"),
-            cache_control: options.cacheControl?.(part.cache),
-        });
+        messages.push(toolMessage(options.toolCallID?.(part.id) ?? part.id, text.join("\n"), options.cacheControl?.(part.cache)));
         const files = content.filter((item) => item.type === "file");
         attachments.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))));
     }
     return { messages, attachments };
 });
+// Chat cache breakpoints belong on text content parts, not on the message itself.
+const toolMessage = (toolCallID, text, cacheControl) => ({
+    role: "tool",
+    tool_call_id: toolCallID,
+    content: cacheControl === undefined ? text : [{ type: "text", text, cache_control: cacheControl }],
+});
 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message, reasoningField, requireReasoning, options) {
     if (message.role === "user")
         return [yield* lowerUserMessage(message, options)];
@@ -452,24 +450,25 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
             bridgeTools();
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message);
+            const cacheControl = options.cacheControl?.(part.cache);
             if (pendingAttachments.length > 0) {
                 messages.push({
                     role: "user",
                     content: [
                         ...pendingAttachments.splice(0),
-                        { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
+                        { type: "text", text: part.text, cache_control: cacheControl },
                     ],
                 });
                 continue;
             }
             const previous = messages.at(-1);
             if (previous?.role === "user" && typeof previous.content === "string")
-                messages[messages.length - 1] = options.cacheControl?.(part.cache)
+                messages[messages.length - 1] = cacheControl
                     ? {
                         role: "user",
                         content: [
                             { type: "text", text: previous.content },
-                            { type: "text", text: part.text, cache_control: options.cacheControl(part.cache) },
+                            { type: "text", text: part.text, cache_control: cacheControl },
                         ],
                     }
                     : { role: "user", content: `${previous.content}\n${part.text}` };
@@ -478,14 +477,14 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
                     role: "user",
                     content: [
                         ...previous.content,
-                        { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
+                        { type: "text", text: part.text, cache_control: cacheControl },
                     ],
                 };
             else
-                messages.push(options.cacheControl?.(part.cache)
+                messages.push(cacheControl
                     ? {
                         role: "user",
-                        content: [{ type: "text", text: part.text, cache_control: options.cacheControl(part.cache) }],
+                        content: [{ type: "text", text: part.text, cache_control: cacheControl }],
                     }
                     : { role: "user", content: part.text });
             continue;

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

@@ -53,15 +53,18 @@ export declare const route: Route<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -77,13 +80,16 @@ export declare const route: Route<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;

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

@@ -69,15 +69,18 @@ export declare const protocol: Protocol<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -93,13 +96,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;

package/dist/provider-error.js

@@ -3,9 +3,13 @@ import { AuthenticationError, ContentPolicyError, InvalidRequestError, AIError,
 const patterns = [
     /prompt is too long/i,
     /input is too long for requested model/i,
+    // Cloudflare Workers AI reports this as HTTP 413.
+    /exceeded this model context window limit/i,
     /exceeds the context window/i,
     /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
     /input token count.*exceeds the maximum/i,
+    // Amazon Nova on Bedrock reports this as a mid-stream validationException.
+    /number of input tokens exceeds maximum length/i,
     /tokens in request more than max tokens allowed/i,
     /maximum prompt length is \d+/i,
     /reduce the length of the messages/i,