@opencode/ai 0.0.0-beta-19289 → 0.0.0-beta-19365

package/README.md

@@ -29,6 +29,134 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+## Z.AI
+
+`ZAI` uses the standard API. Chat Completions is the default language-model API;
+the existing `.image(...)` selector provides image generation.
+
+```ts
+import { LLM } from "@opencode/ai"
+import { ZAI, ZAICodingPlan } from "@opencode/ai/providers"
+
+const zai = ZAI.configure({ apiKey: process.env.ZAI_API_KEY })
+const request = LLM.request({
+  model: zai.model("glm-5.3"), // also zai.chat("glm-5.3")
+  prompt: "Explain this design.",
+  providerOptions: {
+    reasoningEffort: "high",
+    thinking: { type: "enabled", clear_thinking: false },
+  },
+})
+
+const coding = ZAICodingPlan.configure({ apiKey: process.env.ZAI_API_KEY })
+const messages = LLM.request({
+  model: coding.messages("glm-5.3"),
+  prompt: "Explain this design.",
+  providerOptions: { effort: "high" },
+})
+```
+
+The products have distinct provider identities and endpoints:
+
+| Provider                            | Selector                    | Default base URL                      |
+| ----------------------------------- | --------------------------- | ------------------------------------- |
+| `ZAI` (`zai`)                       | `.model`, `.chat`, `.image` | `https://api.z.ai/api/paas/v4`        |
+| `ZAICodingPlan` (`zai-coding-plan`) | `.model`, `.chat`           | `https://api.z.ai/api/coding/paas/v4` |
+| `ZAICodingPlan`                     | `.messages`                 | `https://api.z.ai/api/anthropic/v1`   |
+| `ZAICodingPlan`                     | `.responses`                | `https://api.z.ai/api/v1`             |
+
+Both read `ZAI_API_KEY` when `apiKey` is omitted and support an explicit `auth` override.
+Coding Plan requires an active subscription. `baseURL` overrides the selected API's
+complete base, including its version prefix. Language-model routes use HTTP/SSE.
+
+Options retain the selected API's native semantics:
+
+- Chat `reasoningEffort` lowers to `reasoning_effort`; Responses lowers it to `reasoning.effort`.
+  Messages `effort` lowers to `output_config.effort`. Omission preserves provider defaults.
+- Chat `thinking` passes `type` and `clear_thinking` through unchanged. Set
+  `clear_thinking: false` and replay complete `response.message` values to preserve reasoning
+  across user messages and tool loops. The standard API defaults to clearing historical thinking;
+  Coding Plan documents preservation by default.
+- Messages accepts `thinking: { type: "enabled" | "adaptive" | "disabled" }` without requiring
+  an Anthropic token budget. Coding Plan documents a disabled toggle as low-effort thinking
+  for GLM-5.3, with explicit effort taking precedence.
+- Chat also offers `toolStream`, `doSample`, `responseFormat`, `requestID`, and `userID`.
+  Tool-argument streaming is enabled when tools are present on GLM-4.6/4.7/5.x;
+  `toolStream: false` explicitly disables it. Older model families omit the opt-in.
+- Effort and thinking values remain forward-compatible strings. Their meaning is model-specific:
+  GLM-5.3 accepts `low`, `high`, and `max` effort and rejects disabled thinking with HTTP 400;
+  the direct GLM-5.2 recordings returned reasoning even with `none` and `minimal` effort,
+  whereas explicit `thinking.type: "disabled"` disabled it on GLM-5.2 and GLM-4.7.
+
+Standard API recordings cover GLM-5.3 efforts and a full preserved-reasoning tool loop with
+a subsequent user follow-up, GLM-5.2 efforts, older-model thinking toggles, GLM-4.5 tool calls,
+GLM-5.3-Flash image input, and JSON output. Coding Plan has unit coverage for routing,
+request options, and reasoning replay; successful live recordings are pending.
+
+Package entrypoints are `@opencode/ai/providers/zai`, `zai/chat`, `zai-coding-plan`,
+`zai-coding-plan/chat`, `zai-coding-plan/messages`, and `zai-coding-plan/responses`.
+
+## Moonshot
+
+Moonshot defaults to Chat Completions, with Messages and Responses selectors for Kimi K3:
+
+```ts
+import { LLM } from "@opencode/ai"
+import { Moonshot } from "@opencode/ai/providers"
+
+const moonshot = Moonshot.configure({ apiKey: process.env.MOONSHOT_API_KEY })
+
+const request = LLM.request({
+  model: moonshot.model("kimi-k3"), // also moonshot.chat("kimi-k3")
+  prompt: "Explain the tradeoffs in this design.",
+  providerOptions: { reasoningEffort: "high" },
+})
+
+const messages = LLM.request({
+  model: moonshot.messages("kimi-k3"),
+  prompt: "Explain the tradeoffs in this design.",
+  providerOptions: { effort: "high" },
+})
+
+const responses = LLM.request({
+  model: moonshot.responses("kimi-k3"),
+  prompt: "Explain the tradeoffs in this design.",
+  providerOptions: { reasoningEffort: "high" },
+})
+```
+
+When `apiKey` is omitted, authentication reads `MOONSHOT_API_KEY`, then `MOONSHOTAI_API_KEY`.
+Chat and Responses use `https://api.moonshot.ai/v1`; Messages uses
+`https://api.moonshot.ai/anthropic/v1`. `baseURL` overrides the selected API's complete base,
+including the version prefix, for regional endpoints or gateways. Each endpoint requires its own valid credentials.
+All three routes use HTTP/SSE.
+
+Reasoning options stay native to the selected API and model:
+
+| Model/API                   | Provider options                                                                        |
+| --------------------------- | --------------------------------------------------------------------------------------- |
+| K3 Chat / Responses         | `reasoningEffort: "low" \| "high" \| "max"`; default is `max`                           |
+| K3 Messages                 | `effort: "low" \| "high" \| "max"`; default is `max`                                    |
+| K2.6 Chat                   | `thinking: { type: "enabled" \| "disabled", keep?: "all" \| null }`; default is enabled |
+| K2.7 Code / high-speed Chat | Omit `thinking` to use always-on, preserved reasoning                                   |
+
+Omitting options preserves the model's defaults. K3 uses effort rather than the K2.x `thinking`
+parameter. Known effort values have autocomplete while future strings remain accepted.
+For K2.6, `thinking.keep: "all"` enables preservation of reasoning across user messages.
+K3 and both K2.7 Code variants always preserve reasoning. Continue with the returned
+`response.message` and matching tool results so reasoning content and any Messages signatures are retained.
+Leave sampling options such as `temperature` unset to use these models' fixed defaults.
+
+The recorded suite covers all three K3 APIs, default and explicit efforts, K2.6 thinking modes,
+both K2.7 Code variants, generated tool loops with a subsequent user follow-up, required/disabled
+tool choice, image-byte input, and native structured output through `http.body` overlays.
+K3 Chat and Messages accept required and disabled tool choice. Responses supports automatic tool
+choice only; explicit `required` and `none` produce a provider `InvalidRequest` error, also covered by recordings.
+The provider targets the Moonshot Open Platform; Kimi Code is a separate product and endpoint.
+
+Package entrypoints are `@opencode/ai/providers/moonshot`, `moonshot/chat`, `moonshot/messages`,
+and `moonshot/responses`; each exports `model(modelID, settings)`.
+
 ## MiniMax
 
 MiniMax defaults to its Messages API and reads `MINIMAX_API_KEY` when `apiKey` is omitted:

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

@@ -10,14 +10,19 @@ export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export declare const PATH = "/messages";
 export declare const DEFAULT_MAX_TOKENS = 32000;
 export declare const framing: Framing.Definition<string>;
+export type ThinkingBlockBinding = {
+    readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {});
+};
 export type ThinkingInput = {
     readonly type: "adaptive";
     readonly display?: "summarized" | "omitted";
+    readonly block_binding?: ThinkingBlockBinding;
 } | {
     readonly type: "disabled";
 } | ({
     readonly type: "enabled";
     readonly display?: "summarized" | "omitted";
+    readonly block_binding?: ThinkingBlockBinding;
 } & ({
     readonly budgetTokens: number;
     readonly budget_tokens?: number;
@@ -309,9 +314,15 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"adaptive">;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"disabled">;
     }>]>>;
@@ -556,9 +567,15 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
@@ -684,7 +701,7 @@ export declare const protocol: Protocol<{
     reasoningSignatures: {};
     lifecycle: Lifecycle.State;
 }>;
-export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
+export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">>() => {
     prepare: (input: Parameters<(input: import("../route/transport/index.js").TransportPrepareInput<Body>) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>>[0]) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>;
     with: (patch: Partial<HttpTransport.HttpJsonInput<Body, string>>) => HttpTransport.HttpJsonTransport<Body, string>;
     id: string;
@@ -904,9 +921,15 @@ export declare const route: Route<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

package/dist/protocols/anthropic-messages.js

@@ -202,15 +202,20 @@ const AnthropicToolChoice = Schema.Union([
         disable_parallel_tool_use: Schema.optional(Schema.Boolean),
     }),
 ]);
+const AnthropicThinkingBlockBinding = Schema.Struct({
+    prefix_mismatch_behavior: Schema.optional(Schema.String),
+});
 const AnthropicThinking = Schema.Union([
     Schema.Struct({
         type: Schema.tag("enabled"),
         budget_tokens: Schema.Number,
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("adaptive"),
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("disabled"),
@@ -843,8 +848,9 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
             ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
             ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
         };
+    const thinking = yield* resolveThinking(input?.thinking);
     return {
-        thinking: yield* resolveThinking(input?.thinking),
+        thinking: applyThinkingBindingDefault(request.model, thinking),
         effort: outputConfigEffort,
         output_config,
         service_tier,
@@ -854,18 +860,44 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
         cache_control,
     };
 });
+const supportsThinkingBlockBinding = (model) => {
+    const override = model.compatibility?.supportsThinkingBlockBinding;
+    if (override !== undefined)
+        return override;
+    // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+    const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups;
+    if (!version)
+        return false;
+    const major = Number(version.major);
+    const minor = Number(version.minor ?? 0);
+    return major > 5 || (major === 5 && minor >= 1);
+};
+const applyThinkingBindingDefault = (model, thinking) => {
+    if (thinking?.type === "disabled")
+        return thinking;
+    if (!supportsThinkingBlockBinding(model))
+        return thinking;
+    return {
+        ...(thinking ?? { type: "adaptive" }),
+        block_binding: {
+            prefix_mismatch_behavior: "drop_block",
+            ...thinking?.block_binding,
+        },
+    };
+};
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
     if (!ProviderShared.isRecord(input))
         return undefined;
+    if (input.type === "disabled")
+        return { type: "disabled" };
+    if (input.type !== "adaptive" && input.type !== "enabled")
+        return undefined;
+    const block_binding = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)))(input.block_binding);
     const display = input.display === "summarized" || input.display === "omitted"
         ? input.display
         : undefined;
     if (input.type === "adaptive")
-        return { type: "adaptive", ...(display === undefined ? {} : { display }) };
-    if (input.type === "disabled")
-        return { type: "disabled" };
-    if (input.type !== "enabled")
-        return undefined;
+        return { type: "adaptive", display, block_binding };
     const budget = typeof input.budgetTokens === "number"
         ? input.budgetTokens
         : typeof input.budget_tokens === "number"
@@ -873,7 +905,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
             : undefined;
     if (budget === undefined)
         return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget, ...(display === undefined ? {} : { display }) };
+    return { type: "enabled", budget_tokens: budget, display, block_binding };
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
@@ -1378,15 +1410,15 @@ export const transport = () => {
     return {
         ...http,
         prepare: (input) => {
-            if (!input.body.context_management?.edits.length &&
-                !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction")))
+            const requiredBetas = requiredBetaHeaders(input.body);
+            if (requiredBetas.length === 0)
                 return http.prepare(input);
             const headers = Headers.fromInput(input.request.http?.headers);
-            const betas = new Set((headers["anthropic-beta"] ?? "")
+            const existingBetas = (headers["anthropic-beta"] ?? "")
                 .split(",")
                 .map((item) => item.trim())
-                .filter(Boolean));
-            betas.add("compact-2026-01-12");
+                .filter(Boolean);
+            const betas = new Set([...existingBetas, ...requiredBetas]);
             return http.prepare({
                 ...input,
                 request: LLMRequest.update(input.request, {
@@ -1399,6 +1431,17 @@ export const transport = () => {
         },
     };
 };
+function requiredBetaHeaders(body) {
+    const betas = [];
+    const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0;
+    const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
+    if (requestsCompaction || replaysCompaction)
+        betas.push("compact-2026-01-12");
+    const thinking = body.thinking;
+    if (thinking && thinking.type !== "disabled" && thinking.block_binding)
+        betas.push("thinking-binding-controls-2026-08-01");
+    return betas;
+}
 export const route = Route.make({
     id: ADAPTER,
     provider: "anthropic",

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

@@ -219,9 +219,15 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

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

@@ -0,0 +1,202 @@
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | (string & {});
+export type OptionsInput = {
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly thinking?: {
+        readonly type?: "enabled" | "disabled" | (string & {});
+        /** False retains historical reasoning; omission preserves the endpoint's default. */
+        readonly clear_thinking?: boolean;
+    };
+    readonly toolStream?: boolean;
+    readonly doSample?: boolean;
+    readonly responseFormat?: {
+        readonly type: "text" | "json_object" | (string & {});
+    };
+    readonly requestID?: string;
+    readonly userID?: string;
+};
+export declare const compatibility: {
+    maxTokensField: "max_tokens";
+    supportsStore: false;
+    supportsStrictMode: false;
+    reasoningField: string;
+    zaiToolStream: false;
+};
+export declare const protocol: Protocol<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | 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 id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | 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 stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly thinking?: {
+        readonly type?: string | undefined;
+        readonly clear_thinking?: boolean | undefined;
+    } | undefined;
+    readonly user_id?: string | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+    readonly response_format?: {
+        readonly type: string;
+    } | undefined;
+    readonly do_sample?: boolean | undefined;
+    readonly request_id?: string | undefined;
+}, string, "[DONE]" | {
+    readonly [x: string]: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly [x: string]: unknown;
+        readonly cached_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 completion_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly reasoning_tokens?: number | null | undefined;
+            readonly accepted_prediction_tokens?: number | null | undefined;
+            readonly rejected_prediction_tokens?: number | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
+        readonly [x: string]: unknown;
+        readonly delta?: {
+            readonly [x: string]: unknown;
+            readonly reasoning?: string | null | undefined;
+            readonly reasoning_content?: string | null | undefined;
+            readonly reasoning_text?: string | null | undefined;
+            readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
+            readonly tool_calls?: readonly {
+                readonly function?: {
+                    readonly name?: string | null | undefined;
+                    readonly arguments?: string | null | undefined;
+                } | null | undefined;
+                readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
+            }[] | null | undefined;
+            readonly reasoning_details?: unknown;
+        } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly cached_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 completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
+}, OpenAIChat.ParserState>;
+export * as ZAIChat from "./zai-chat.js";

package/dist/protocols/zai-chat.js

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+import { ProviderShared } from "./shared.js";
+const Options = Schema.Struct({
+    reasoningEffort: Schema.optional(Schema.String),
+    thinking: Schema.optional(Schema.Struct({ type: Schema.optional(Schema.String), clear_thinking: Schema.optional(Schema.Boolean) })),
+    toolStream: Schema.optional(Schema.Boolean),
+    doSample: Schema.optional(Schema.Boolean),
+    responseFormat: Schema.optional(Schema.Struct({ type: Schema.String })),
+    requestID: Schema.optional(Schema.String),
+    userID: Schema.optional(Schema.String),
+});
+const Body = Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    thinking: Options.fields.thinking,
+    do_sample: Options.fields.doSample,
+    response_format: Options.fields.responseFormat,
+    request_id: Options.fields.requestID,
+    user_id: Options.fields.userID,
+});
+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),
+        do_sample: options.doSample,
+        response_format: options.responseFormat,
+        request_id: options.requestID,
+        user_id: options.userID,
+    };
+});
+export const compatibility = {
+    maxTokensField: "max_tokens",
+    supportsStore: false,
+    supportsStrictMode: false,
+    reasoningField: "reasoning_content",
+    zaiToolStream: false,
+};
+export const protocol = Protocol.make({
+    id: "zai-chat",
+    body: { schema: Body, from: fromRequest },
+    stream: OpenAIChat.protocol.stream,
+});
+export * as ZAIChat from "./zai-chat.js";