@opencode/ai 2.0.21 → 2.0.23

package/dist/protocols/venice-chat.js

@@ -0,0 +1,283 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { AIError, LLMEvent } from "../schema/index.js";
+import { classifyProviderFailure } from "../provider-error.js";
+import { OpenAIChat } from "./openai-chat.js";
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
+import { cacheControl } from "./utils/cache.js";
+const Parameters = Schema.Struct({
+    enableWebSearch: Schema.optional(Schema.String),
+    enableWebScraping: Schema.optional(Schema.Boolean),
+    enableWebCitations: Schema.optional(Schema.Boolean),
+    enableXSearch: Schema.optional(Schema.Boolean),
+    stripThinkingResponse: Schema.optional(Schema.Boolean),
+    disableThinking: Schema.optional(Schema.Boolean),
+    includeVeniceSystemPrompt: Schema.optional(Schema.Boolean),
+    characterSlug: Schema.optional(Schema.String),
+    includeSearchResultsInStream: Schema.optional(Schema.Boolean),
+    returnSearchResultsAsDocuments: Schema.optional(Schema.Boolean),
+});
+const Reasoning = Schema.Struct({
+    effort: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    summary: Schema.optional(Schema.String),
+});
+const Options = Schema.Struct({
+    reasoningEffort: Schema.optional(Schema.String),
+    reasoning: Schema.optional(Reasoning),
+    veniceParameters: Schema.optional(Parameters),
+    promptCacheKey: Schema.optional(Schema.String),
+    promptCacheRetention: Schema.optional(Schema.String),
+    parallelToolCalls: Schema.optional(Schema.Boolean),
+    maxCompletionTokens: Schema.optional(Schema.Number),
+    maxTokens: Schema.optional(Schema.Number),
+    minP: Schema.optional(Schema.Number),
+    repetitionPenalty: Schema.optional(Schema.Number),
+    stopTokenIds: Schema.optional(Schema.Array(Schema.Number)),
+    logprobs: Schema.optional(Schema.Boolean),
+    topLogprobs: Schema.optional(Schema.Number),
+    maxTemp: Schema.optional(Schema.Number),
+    minTemp: Schema.optional(Schema.Number),
+    responseFormat: Schema.optional(JsonObject),
+    user: Schema.optional(Schema.String),
+});
+const ToolCall = Schema.Struct({
+    ...OpenAIChat.OpenAIChatAssistantToolCall.fields,
+    thought_signature: Schema.optional(Schema.String),
+});
+const Assistant = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatMessage.cases.assistant.schema.fields,
+    tool_calls: optionalArray(ToolCall),
+    thought_signature: Schema.optional(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Messages = Schema.Array(Schema.Union([
+    OpenAIChat.OpenAIChatMessage.cases.system,
+    OpenAIChat.OpenAIChatMessage.cases.user,
+    Assistant,
+    OpenAIChat.OpenAIChatMessage.cases.tool,
+]));
+const Body = Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    messages: Messages,
+    reasoning: Schema.optional(Reasoning),
+    venice_parameters: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Boolean])),
+    prompt_cache_retention: Options.fields.promptCacheRetention,
+    parallel_tool_calls: Options.fields.parallelToolCalls,
+    min_p: Options.fields.minP,
+    top_k: Schema.optional(Schema.Number),
+    repetition_penalty: Options.fields.repetitionPenalty,
+    stop_token_ids: Options.fields.stopTokenIds,
+    logprobs: Options.fields.logprobs,
+    top_logprobs: Options.fields.topLogprobs,
+    max_temp: Options.fields.maxTemp,
+    min_temp: Options.fields.minTemp,
+    response_format: Options.fields.responseFormat,
+    user: Options.fields.user,
+});
+// ---------------------------------------------------------------------------
+// Streaming schemas and state
+// ---------------------------------------------------------------------------
+const ToolDelta = Schema.Struct({
+    ...OpenAIChat.OpenAIChatToolCallDelta.fields,
+    thought_signature: optionalNull(Schema.String),
+});
+const Delta = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatDelta.schema.fields,
+    tool_calls: optionalNull(Schema.Array(ToolDelta)),
+    thought_signature: optionalNull(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Choice = Schema.StructWithRest(Schema.Struct({ ...OpenAIChat.OpenAIChatChoice.schema.fields, delta: optionalNull(Delta) }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Usage = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatUsage.schema.fields,
+    prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
+        cached_tokens: optionalNull(Schema.Number),
+        cache_write_tokens: optionalNull(Schema.Number),
+        cache_creation_input_tokens: optionalNull(Schema.Number),
+    }), [Schema.Record(Schema.String, Schema.Unknown)])),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Event = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatEvent.schema.fields,
+    choices: optionalNull(Schema.Array(Choice)),
+    usage: optionalNull(Usage),
+    error: optionalNull(Schema.Union([Schema.String, OpenAIChat.OpenAIChatEvent.schema.fields.error.schema])),
+    issues: optionalArray(Schema.Struct({
+        message: Schema.String,
+        path: Schema.optional(Schema.Array(Schema.Union([Schema.String, Schema.Number]))),
+    })),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const MARKER = "__ENCRYPTED_REASONING__";
+// ---------------------------------------------------------------------------
+// Request lowering
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("VeniceChat.fromRequest")(function* (request) {
+    const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {});
+    const body = yield* OpenAIChat.fromRequest(request, {
+        cacheControl: cacheControl(),
+        assistant: (source, message) => {
+            if (message.role !== "assistant")
+                return message;
+            const parts = source.content.filter((part) => part.type === "text" || part.type === "reasoning" || part.type === "tool-call");
+            const calls = source.content.filter((part) => part.type === "tool-call");
+            const signature = parts
+                .map((part) => part.providerMetadata?.venice?.messageThoughtSignature)
+                .find((value) => typeof value === "string");
+            const raw = parts
+                .map((part) => part.providerMetadata?.venice?.encryptedReasoningContent)
+                .find((value) => typeof value === "string");
+            return {
+                ...message,
+                ...(signature === undefined ? {} : { thought_signature: signature }),
+                ...(raw === undefined ? {} : { reasoning_content: raw }),
+                tool_calls: message.tool_calls?.map((call, index) => {
+                    const signature = calls[index]?.providerMetadata?.venice?.thoughtSignature;
+                    return { ...call, ...(typeof signature === "string" ? { thought_signature: signature } : {}) };
+                }),
+            };
+        },
+    });
+    return {
+        ...body,
+        max_completion_tokens: options.maxCompletionTokens ?? options.maxTokens ?? request.generation?.maxTokens,
+        reasoning_effort: undefined,
+        reasoning: options.reasoningEffort === undefined
+            ? options.reasoning
+            : { ...options.reasoning, effort: options.reasoningEffort },
+        // Match the previous Venice SDK default, not the gateway's added prompt.
+        venice_parameters: Object.fromEntries(Object.entries({
+            ...options.veniceParameters,
+            includeVeniceSystemPrompt: options.veniceParameters?.includeVeniceSystemPrompt ?? false,
+        })
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`), value])),
+        prompt_cache_retention: options.promptCacheRetention,
+        parallel_tool_calls: options.parallelToolCalls,
+        min_p: options.minP,
+        top_k: request.generation?.topK,
+        repetition_penalty: options.repetitionPenalty,
+        stop_token_ids: options.stopTokenIds,
+        logprobs: options.logprobs,
+        top_logprobs: options.topLogprobs,
+        max_temp: options.maxTemp,
+        min_temp: options.minTemp,
+        response_format: options.responseFormat,
+        user: options.user,
+    };
+});
+// ---------------------------------------------------------------------------
+// Venice normalization around the shared Chat state machine
+// ---------------------------------------------------------------------------
+const step = Effect.fn("VeniceChat.step")(function* (state, event) {
+    if (typeof event.error === "string")
+        return yield* new AIError({
+            reason: classifyProviderFailure({
+                message: [
+                    event.error,
+                    ...(event.issues ?? []).map((issue) => `${issue.path?.length ? `${issue.path.join(".")}: ` : ""}${issue.message}`),
+                ].join("; "),
+                rawBody: ProviderShared.encodeJson(event),
+            }),
+        });
+    const delta = event.choices?.[0]?.delta;
+    const scalar = delta?.reasoning_content ?? "";
+    const text = state.pending + scalar;
+    const marker = text.indexOf(MARKER);
+    const pending = marker >= 0 || state.encrypted
+        ? 0
+        : (Array.from({ length: Math.min(text.length, MARKER.length - 1) }, (_, index) => index + 1)
+            .filter((length) => text.endsWith(MARKER.slice(0, length)))
+            .at(-1) ?? 0);
+    const visible = state.encrypted ? "" : marker >= 0 ? text.slice(0, marker) : text.slice(0, text.length - pending);
+    const result = yield* OpenAIChat.protocol.stream.step(state.shared, {
+        ...event,
+        error: event.error,
+        usage: event.usage
+            ? {
+                ...event.usage,
+                prompt_tokens_details: event.usage.prompt_tokens_details
+                    ? {
+                        ...event.usage.prompt_tokens_details,
+                        cache_write_tokens: event.usage.prompt_tokens_details.cache_write_tokens ??
+                            event.usage.prompt_tokens_details.cache_creation_input_tokens,
+                    }
+                    : event.usage.prompt_tokens_details,
+            }
+            : event.usage,
+        choices: event.choices?.map((choice, index) => index === 0 && choice.delta
+            ? {
+                ...choice,
+                delta: {
+                    ...choice.delta,
+                    reasoning_content: visible || undefined,
+                    // Opaque-only scalar reasoning still needs a canonical part for replay.
+                    reasoning_details: choice.delta.reasoning_details ?? (marker >= 0 ? [] : undefined),
+                },
+            }
+            : choice),
+    });
+    const tools = { ...state.tools };
+    for (const call of delta?.tool_calls ?? []) {
+        if (!call.thought_signature)
+            continue;
+        const index = call.index ?? result[0].latestToolIndex;
+        const id = call.id ?? (index === undefined ? undefined : (result[0].tools[index]?.id ?? result[0].pendingTools[index]?.id));
+        if (id)
+            tools[id] = call.thought_signature;
+    }
+    return [
+        {
+            shared: result[0],
+            pending: pending ? text.slice(-pending) : "",
+            reasoning: state.reasoning + scalar,
+            encrypted: state.encrypted || marker >= 0,
+            signature: delta?.thought_signature ?? state.signature,
+            tools,
+        },
+        result[1],
+    ];
+});
+const onHalt = Effect.fn("VeniceChat.onHalt")(function* (state) {
+    const events = yield* OpenAIChat.finishEvents(state.shared);
+    return events.flatMap((event) => {
+        if (event.type !== "reasoning-end" &&
+            event.type !== "text-end" &&
+            event.type !== "tool-call" &&
+            event.type !== "tool-input-end")
+            return [event];
+        const signature = event.type === "tool-call" || event.type === "tool-input-end" ? state.tools[event.id] : undefined;
+        const providerMetadata = {
+            ...event.providerMetadata,
+            venice: {
+                ...event.providerMetadata?.venice,
+                ...(state.signature ? { messageThoughtSignature: state.signature } : {}),
+                ...(signature ? { thoughtSignature: signature } : {}),
+                ...(event.type === "reasoning-end" && state.encrypted ? { encryptedReasoningContent: state.reasoning } : {}),
+            },
+        };
+        if (event.type === "reasoning-end" && state.pending)
+            return [LLMEvent.reasoningDelta({ id: event.id, text: state.pending }), { ...event, providerMetadata }];
+        return [{ ...event, providerMetadata }];
+    });
+});
+export const compatibility = {
+    maxTokensField: "max_completion_tokens",
+    supportsStore: false,
+    supportsPromptCacheKey: true,
+};
+export const protocol = Protocol.make({
+    id: "venice-chat",
+    body: { schema: Body, from: fromRequest },
+    stream: {
+        event: Schema.Union([Schema.Literal("[DONE]"), Protocol.jsonEvent(Event)]),
+        initial: (request) => ({
+            shared: OpenAIChat.protocol.stream.initial(request),
+            pending: "",
+            reasoning: "",
+            encrypted: false,
+            tools: {},
+        }),
+        step: (state, event) => (event === "[DONE]" ? Effect.succeed([state, []]) : step(state, event)),
+        terminal: (event) => event === "[DONE]",
+        onHalt,
+    },
+});
+export * as VeniceChat from "./venice-chat.js";

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

@@ -38,6 +38,15 @@ export declare const protocol: Protocol<{
         readonly error?: unknown;
         readonly arguments?: string | undefined;
         readonly server_label?: string | undefined;
+    } | {
+        readonly type: "configuration_update";
+        readonly reasoning: {
+            readonly effort: import("../schema/options.js").ReasoningEffort;
+        };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -114,21 +123,6 @@ export declare const protocol: Protocol<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "x_search_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly error?: unknown;
-        readonly result?: unknown;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -140,7 +134,10 @@ export declare const protocol: Protocol<{
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
+        readonly [x: string]: unknown;
+        readonly type: string;
+    } | {
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -148,7 +145,7 @@ export declare const protocol: Protocol<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    }[] | undefined;
+    })[] | undefined;
     readonly text?: {
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
@@ -168,9 +165,10 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -178,7 +176,6 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, string, {
     readonly [x: string]: unknown;
@@ -198,8 +195,8 @@ export declare const protocol: Protocol<{
             readonly name?: string | undefined;
             readonly namespace?: string | undefined;
             readonly arguments?: string | undefined;
-            readonly encrypted_content?: string | null | undefined;
             readonly call_id?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
@@ -226,8 +223,8 @@ export declare const protocol: Protocol<{
         readonly name?: string | undefined;
         readonly namespace?: string | undefined;
         readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
     } | null | undefined;
     readonly delta?: string | undefined;
     readonly arguments?: string | undefined;

package/dist/protocols/xai-responses.js

@@ -21,17 +21,11 @@ const XAIResponsesHostedToolItem = Schema.Union([
         error: Schema.optional(Schema.Unknown),
     }), [JsonObject]),
 ]);
-const XAIResponsesBody = Schema.Struct({
-    ...OpenResponses.coreFields,
-    input: Schema.Array(Schema.Union([OpenResponses.InputItem, XAIResponsesHostedToolItem])),
-    stream: Schema.Literal(true),
-});
 const adapter = {
     id: ADAPTER,
     name: NAME,
     restoreHostedToolItem: (item) => (Schema.is(XAIResponsesHostedToolItem)(item) ? item : undefined),
 };
-const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody));
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request) {
     if (request.providerOptions?.contextManagement !== undefined)
         return yield* ProviderShared.unsupportedOperation({
@@ -40,7 +34,7 @@ const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request) {
             route: request.model.route.id,
             message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
         });
-    return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter));
+    return yield* OpenResponses.fromRequestWithAdapter(request, adapter);
 });
 const HOSTED_TOOLS = {
     web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
@@ -67,7 +61,7 @@ const step = (state, input) => {
 export const protocol = Protocol.make({
     id: ADAPTER,
     body: {
-        schema: XAIResponsesBody,
+        schema: OpenResponses.OpenResponsesBody,
         from: fromRequest,
     },
     stream: {

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

@@ -142,9 +142,9 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
@@ -163,16 +163,18 @@ export declare const protocol: Protocol<{
     } | null | undefined;
     readonly usage?: {
         readonly [x: string]: unknown;
+        readonly cache_read_input_tokens?: number | null | undefined;
         readonly cached_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens?: number | null | undefined;
         readonly completion_tokens?: number | null | undefined;
-        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
             readonly cache_write_tokens?: number | null | undefined;
         } | null | undefined;
         readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly cache_created_input_tokens?: number | null | undefined;
         readonly completion_tokens_details?: {
             readonly [x: string]: unknown;
             readonly reasoning_tokens?: number | null | undefined;
@@ -202,16 +204,18 @@ export declare const protocol: Protocol<{
         } | null | undefined;
         readonly usage?: {
             readonly [x: string]: unknown;
+            readonly cache_read_input_tokens?: number | null | undefined;
             readonly cached_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens?: number | null | undefined;
             readonly completion_tokens?: number | null | undefined;
-            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly cached_tokens?: number | null | undefined;
                 readonly cache_write_tokens?: number | null | undefined;
             } | null | undefined;
             readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly cache_created_input_tokens?: number | null | undefined;
             readonly completion_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | null | undefined;

package/dist/protocols/zai-chat.js

@@ -19,15 +19,18 @@ const Body = Schema.Struct({
     request_id: Options.fields.requestID,
     user_id: Options.fields.userID,
 });
+// Tool streaming was introduced in GLM-4.6; later versions inherit support.
+const supportsToolStreaming = (modelID) => {
+    const match = /(?:^|\/)glm-(\d+)(?:\.(\d+))?(?:-|$)/i.exec(modelID);
+    return match !== null && (Number(match[1]) > 4 || (Number(match[1]) === 4 && Number(match[2] ?? 0) >= 6));
+};
 const fromRequest = Effect.fn("ZAIChat.fromRequest")(function* (request) {
     const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {});
     const body = yield* OpenAIChat.protocol.body.from(request);
     return {
         ...body,
         thinking: options.thinking,
-        // Tool streaming was introduced in GLM-4.6; older models must not receive the opt-in.
-        tool_stream: options.toolStream ??
-            (body.tools?.length && /^glm-(?:4\.[67]|5(?:[.-]|$))/i.test(request.model.id) ? true : undefined),
+        tool_stream: options.toolStream ?? (body.tools?.length && supportsToolStreaming(request.model.id) ? true : undefined),
         do_sample: options.doSample,
         response_format: options.responseFormat,
         request_id: options.requestID,

package/dist/provider-error.js

@@ -13,18 +13,24 @@ const patterns = [
     /tokens in request more than max tokens allowed/i,
     /maximum prompt length is \d+/i,
     /reduce the length of the messages/i,
+    // DeepInfra
+    /requested input length \d+ exceeds maximum input length/i,
     /maximum context length is \d+ tokens/i,
     /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
-    /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+    // Novita omits the token counts.
+    /input(?: \(\d+ tokens\))? is longer than the model'?s context length/i,
     /exceeds the limit of \d+/i,
     /exceeds the available context size/i,
     /greater than the context length/i,
+    // Hugging Face Text Generation Inference, e.g. Together
+    /`inputs` tokens \+ `max_new_tokens` must be <= \d+/i,
     /context window exceeds limit/i,
     /exceeded model token limit/i,
     /context[_ ]length[_ ]exceeded/i,
     /context length is only \d+ tokens/i,
     /input length.*exceeds.*context length/i,
-    /prompt too long; exceeded (?:max )?context length/i,
+    // Z.ai code 1261 arrives as `Prompt too long` or `Prompt 超长`.
+    /prompt (?:too long|超长)/i,
     /too large for model with \d+ maximum context length/i,
     /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
     /model_context_window_exceeded/i,
@@ -34,7 +40,13 @@ const patterns = [
     /request_too_large/i,
 ];
 const payloadPatterns = [/request entity too large/i, /payload too large/i, /request too large/i];
-const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i];
+const exclusions = [
+    /^(throttling error|service unavailable):/i,
+    /rate limit/i,
+    /too many requests/i,
+    // Cohere reports an output limit above the model maximum as "too many tokens"; compaction cannot fix it.
+    /max[_ ]tokens must be less than/i,
+];
 export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
     (patterns.some((pattern) => pattern.test(message)) || /^4(?:00|13)\s*(status code)?\s*\(no body\)/i.test(message));
 export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) => pattern.test(message));
@@ -92,7 +104,8 @@ const QUOTA_CODES = new Set([
     "creditlimitexceeded",
 ]);
 // Google reports an invalid API key as HTTP 400 INVALID_ARGUMENT with this `details[].reason`.
-const AUTH_CODES = new Set(["authentication_error", "permission_error", "api_key_invalid"]);
+// Z.ai's Responses API reports account and plan rejections mid-stream as `permission_denied`.
+const AUTH_CODES = new Set(["authentication_error", "permission_error", "permission_denied", "api_key_invalid"]);
 const SERVER_CODES = new Set([
     "api_error",
     "internal_error",
@@ -106,6 +119,7 @@ const SERVER_CODES = new Set([
 ]);
 // `invalid_request` is the Vercel AI Gateway's code for an upstream request rejection.
 const INVALID_REQUEST_CODES = new Set([
+    "model_not_found",
     "invalid_prompt",
     "invalid_request",
     "invalid_request_error",
@@ -125,14 +139,17 @@ const CONTENT_POLICY_CODES = new Set([
 // OpenCode Zen replaces upstream codes outside its allow-list but keeps the original
 // as a `[code]` label at the start of the rewritten message.
 const GATEWAY_CODE_LABEL = /^[^:\n]+: \[([A-Za-z0-9_.-]+)\]/;
+// xAI reports an invalid API key as HTTP 400 with the generic `invalid-argument` code.
+const AUTH_TEXT = /incorrect api key provided/i;
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i;
 // Only consulted on 429, where throttles and account caps share a status.
-const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded|budget exceeded|usage limit/i;
+// Z.ai reports balance, plan expiry, plan limits, and plan model access on 429.
+const QUOTA_TEXT = /insufficient[-_\s]?(?:quota|balance)|quota[-_\s]?exceeded|budget exceeded|usage limit|limit exhausted|package has expired|plan does not yet include/i;
 // Policy rejections without a dedicated code, matched against the provider's own
 // explanation only. OpenAI reuses `invalid_prompt` for usage-policy rejections while
 // Bedrock Mantle reuses it for schema validation; Anthropic reports blocked output
 // under `invalid_request_error`.
-const CONTENT_POLICY_TEXT = /violating our usage policy|blocked by content filtering policy|content[-_\s]?policy|rejected as a result of our safety system/i;
+const CONTENT_POLICY_TEXT = /violating our usage policy|blocked by content filtering policy|content[-_\s]?policy|rejected as a result of our safety system|detected potentially unsafe or sensitive content/i;
 const SERVER_ERROR_TEXT = /\b(?:try again|(?:please |you can )?retry (?:the |this |your )?request|try (?:the |this |your )?request again|(?:currently |temporarily )?at capacity|overloaded|temporarily unavailable|service[-_\s]?unavailable|(?:server|internal)[-_\s]?error|server (?:is )?busy|provider returned (?:an )?error|resource[-_\s]?exhausted|upstream (?:connect|connection|request)|request buffer limit while retrying upstream)\b/i;
 const Message = Schema.String.check(Schema.isPattern(/\S/));
 const messageAt = (fields, message) => Schema.Struct(fields).pipe(Schema.decodeTo(Schema.String, {
@@ -185,7 +202,10 @@ export function classifyProviderFailure(input) {
         codes.some((code) => QUOTA_CODES.has(code)) ||
         (input.status === 429 && QUOTA_TEXT.test(text)))
         return new QuotaExceededError(details);
-    if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
+    if (input.status === 401 ||
+        input.status === 403 ||
+        codes.some((code) => AUTH_CODES.has(code)) ||
+        (input.status === 400 && AUTH_TEXT.test(text)))
         return new AuthenticationError(details);
     if (input.status === 429 ||
         codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception") ||