@arnilo/prism-provider-zai 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -5,7 +5,24 @@ All notable changes to @arnilo/prism-provider-zai will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.0.6] - 2026-07-19
+
+### Added
+
+- Caller-gated `listZaiModels()` / `mapZaiModel()` (OpenAI-compatible `GET /models`).
+- Official `clear_thinking` + Preserved Thinking (`reasoning_content` replay).
+- Featured catalog refreshed to official GLM-5.x / 4.7 / 4.6 / 4.5 ids.
+
+### Changed
+
+- Default base URL is official international `https://api.z.ai/api/paas/v4`.
+- Docs aligned to official thinking / reasoning_effort / tool_stream fields (removed obsolete compat docs names).
+- Resolved `thinking` / `reasoning_effort` / `tool_stream` win over raw compat spreads.
+
+## [0.0.5] - 2026-07-16
+
+- Pinned the required `@arnilo/prism` peer and package metadata to 0.0.5; runtime behavior is unchanged.
+
 
 ## [0.0.4] - 2026-07-14
 

package/README.md

@@ -1,25 +1,32 @@
 # @arnilo/prism-provider-zai
 
-Z.AI GLM provider package for Prism.
+Z.AI GLM Chat Completions provider package for Prism.
 
 ```ts
-import { createZaiProviderPackage } from "@arnilo/prism-provider-zai";
+import { createZaiProviderPackage, listZaiModels } from "@arnilo/prism-provider-zai";
 
 api.registerProviderPackage(createZaiProviderPackage({ apiKey: "fake-zai-key" }));
+
+// Optional caller-gated discovery (never runs during setup):
+const models = await listZaiModels({ apiKey: "fake-zai-key" });
+api.registerProviderPackage(createZaiProviderPackage({ apiKey: "fake-zai-key", models }));
 ```
 
 Exports:
-- `createZaiProviderPackage()`
-- `createZaiProvider()`
-- `defineZaiModel()`
-- `zaiModels`
+- `createZaiProviderPackage()` / `createZaiProvider()`
+- `defineZaiModel()` / `zaiModels` (featured offline bootstrap)
+- `listZaiModels()` / `mapZaiModel()` (caller-gated OpenAI-compatible `GET /models`)
+- `zaiThinking` / `zaiReasoningEffort` / `zaiToolStream` / `zaiClearThinking` / `zaiPreserveThinking`
+- `ZAI_DEFAULT_BASE_URL` (`https://api.z.ai/api/paas/v4`)
 
 Security defaults:
 - No network calls during import, setup, build, or default tests.
 - No automatic environment, file, keychain, or shell credential lookup.
-- API keys are resolved per request from caller-supplied values or resolvers.
+- API keys are resolved per request from caller-supplied values or resolvers and redacted from errors.
 
-Cache behavior:
-- `kind: "implicit"` — GLM context caching is automatic; no explicit cache payload sent regardless of cache options.
-- `prompt_tokens_details.cached_tokens`/`cache_write_tokens` map to `Usage.cacheReadTokens`/`cacheWriteTokens`.
+Thinking / cache:
+- Official body fields: `thinking` (`{ type: "enabled" | "disabled", clear_thinking? }`), `reasoning_effort` (GLM-5.2+), `tool_stream` (GLM-4.6+).
+- Per-turn `options.compat` wins over `model.compat`.
+- Preserved Thinking: set `clear_thinking: false` (and optionally `preserveThinking: true`) so prior thinking is replayed as `reasoning_content`.
+- `kind: "implicit"` — GLM context caching is automatic; no explicit cache payload. `prompt_tokens_details.cached_tokens` / `cache_write_tokens` map to usage.
 - Provider-owned headers (`content-type`, `authorization`) win over caller headers.

package/dist/index.d.ts

@@ -7,5 +7,6 @@ export interface ZaiProviderPackageOptions {
     readonly models?: readonly ModelConfig[];
 }
 export declare function createZaiProviderPackage(options?: ZaiProviderPackageOptions): ProviderPackage;
-export { defineZaiModel, zaiModels, type ZaiModelConfig } from "./models.js";
-export { createZaiProvider, zaiBody, zaiEvents, type ZaiProviderOptions } from "./provider.js";
+export { defineZaiModel, listZaiModels, mapZaiModel, zaiModels, type ListZaiModelsOptions, type ZaiModelConfig, type ZaiModelEntry, } from "./models.js";
+export { createZaiProvider, toZaiMessage, zaiBody, zaiEvents, ZAI_DEFAULT_BASE_URL, type ZaiProviderOptions, } from "./provider.js";
+export { zaiClearThinking, zaiPreserveThinking, zaiReasoningEffort, zaiThinking, zaiToolStream, } from "./thinking.js";

package/dist/index.js

@@ -15,6 +15,7 @@ export function createZaiProviderPackage(options = {}) {
         },
     });
 }
-export { defineZaiModel, zaiModels } from "./models.js";
-export { createZaiProvider, zaiBody, zaiEvents } from "./provider.js";
+export { defineZaiModel, listZaiModels, mapZaiModel, zaiModels, } from "./models.js";
+export { createZaiProvider, toZaiMessage, zaiBody, zaiEvents, ZAI_DEFAULT_BASE_URL, } from "./provider.js";
+export { zaiClearThinking, zaiPreserveThinking, zaiReasoningEffort, zaiThinking, zaiToolStream, } from "./thinking.js";
 //# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -1,11 +1,61 @@
-import type { JsonObject, ModelConfig } from "@arnilo/prism";
+import { type CredentialValueSource, type JsonObject, type ModelConfig } from "@arnilo/prism";
 export interface ZaiModelConfig extends Omit<ModelConfig, "provider" | "compat"> {
     readonly provider?: "zai";
     readonly compat?: JsonObject & {
+        /** Official deep-thinking switch (`boolean` or `{ type, clear_thinking? }`). */
         readonly thinking?: boolean | JsonObject;
+        /** Official GLM-5.2+ effort: max | xhigh | high | medium | low | minimal | none. */
         readonly reasoning_effort?: string;
+        /** Official GLM-4.6+ streaming tool-call arguments. */
         readonly tool_stream?: boolean;
+        /** Official nested `thinking.clear_thinking` (also accepted at compat root). */
+        readonly clear_thinking?: boolean;
+        /** Prism-local: replay prior thinking as `reasoning_content` when not clearing. */
+        readonly preserveThinking?: boolean;
     };
 }
+export interface ListZaiModelsOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    /** Defaults to official international `https://api.z.ai/api/paas/v4`. */
+    readonly baseUrl?: string;
+    readonly signal?: AbortSignal;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly provider?: string;
+}
+/**
+ * Sparse OpenAI-compatible `/models` entry. Z.AI does not publish a first-class
+ * list-models API page; this helper follows the OpenAI-compatible convention
+ * used by the Chat Completions base (`GET {baseUrl}/models`). Prefer featured
+ * `zaiModels` (docs-verified) when discovery is unavailable.
+ * @see https://docs.z.ai/api-reference/llm/chat-completion
+ * @see https://docs.z.ai/guides/overview/overview
+ */
+export interface ZaiModelEntry {
+    readonly id: string;
+    readonly object?: string;
+    readonly created?: number;
+    readonly owned_by?: string;
+}
 export declare function defineZaiModel(config: ZaiModelConfig): ModelConfig;
-export declare const zaiModels: readonly [ModelConfig, ModelConfig];
+/**
+ * Caller-gated Z.AI model discovery via OpenAI-compatible `GET /models`.
+ * Never invoked by `createZaiProviderPackage` — hosts call this and pass results
+ * via `models:` (or register themselves). Official docs list model codes on the
+ * Chat Completions page / overview; use featured `zaiModels` as offline bootstrap.
+ */
+export declare function listZaiModels(options?: ListZaiModelsOptions): Promise<ModelConfig[]>;
+/**
+ * Map a sparse OpenAI-compatible `/models` entry to Prism `ModelConfig`.
+ * Limits / thinking defaults are inferred from official Chat Completions model codes.
+ */
+export declare function mapZaiModel(entry: ZaiModelEntry, options?: {
+    readonly provider?: string;
+}): ModelConfig;
+/**
+ * Featured offline bootstrap aliases — official Chat Completions model codes from
+ * https://docs.z.ai/api-reference/llm/chat-completion and overview context sizes.
+ * Refresh live ids via `listZaiModels()` when the OpenAI-compatible list endpoint
+ * is available to the account.
+ */
+export declare const zaiModels: readonly [ModelConfig, ModelConfig, ModelConfig, ModelConfig, ModelConfig, ModelConfig, ModelConfig];

package/dist/models.js

@@ -1,20 +1,189 @@
+import { redactSecrets, resolveCredentialValue, } from "@arnilo/prism";
+import { readBoundedResponseText } from "@arnilo/prism/providers/transport";
 export function defineZaiModel(config) {
-    return { ...config, provider: "zai", capabilities: { input: ["text"], output: ["text"], reasoning: true, tools: true, streaming: true, structuredOutput: "json_schema", ...config.capabilities } };
+    return {
+        ...config,
+        provider: "zai",
+        capabilities: {
+            input: ["text"],
+            output: ["text"],
+            reasoning: true,
+            tools: true,
+            streaming: true,
+            structuredOutput: "json_schema",
+            ...config.capabilities,
+        },
+        cache: config.cache ?? { kind: "implicit" },
+    };
 }
+/**
+ * Caller-gated Z.AI model discovery via OpenAI-compatible `GET /models`.
+ * Never invoked by `createZaiProviderPackage` — hosts call this and pass results
+ * via `models:` (or register themselves). Official docs list model codes on the
+ * Chat Completions page / overview; use featured `zaiModels` as offline bootstrap.
+ */
+export async function listZaiModels(options = {}) {
+    const provider = options.provider ?? "zai";
+    const baseUrl = (options.baseUrl ?? "https://api.z.ai/api/paas/v4").replace(/\/$/, "");
+    const token = await resolveCredentialValue(options.apiKey, { provider, name: "apiKey" });
+    const response = await (options.fetch ?? fetch)(`${baseUrl}/models`, {
+        method: "GET",
+        headers: { ...options.headers, ...(token ? { authorization: `Bearer ${token}` } : {}) },
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        const body = await readBoundedResponseText(response, { secrets: [token] });
+        throw new Error(`Z.AI model discovery failed: ${response.status} ${redactSecrets(body, [token])}`);
+    }
+    const payload = (await response.json());
+    if (!Array.isArray(payload.data))
+        throw new Error("Z.AI model discovery response missing data array");
+    return payload.data.map((entry) => mapZaiModel(entry, { provider }));
+}
+/**
+ * Map a sparse OpenAI-compatible `/models` entry to Prism `ModelConfig`.
+ * Limits / thinking defaults are inferred from official Chat Completions model codes.
+ */
+export function mapZaiModel(entry, options = {}) {
+    if (!entry || typeof entry.id !== "string" || entry.id.length === 0) {
+        throw new Error("Z.AI model entry missing id");
+    }
+    const id = entry.id;
+    const limits = limitsForZaiModel(id);
+    const reasoning = looksLikeReasoningModel(id);
+    return defineZaiModel({
+        provider: options.provider ?? "zai",
+        model: id,
+        displayName: id,
+        capabilities: {
+            input: looksLikeVisionModel(id) ? ["text", "image"] : ["text"],
+            output: ["text"],
+            reasoning,
+            tools: true,
+            streaming: true,
+            structuredOutput: "json_schema",
+        },
+        limits,
+        cache: { kind: "implicit" },
+        compat: cleanJson({
+            ...thinkingDefaultsForModel(id),
+            zai: cleanJson({
+                owned_by: entry.owned_by,
+                created: entry.created,
+            }),
+        }),
+    });
+}
+/**
+ * Featured offline bootstrap aliases — official Chat Completions model codes from
+ * https://docs.z.ai/api-reference/llm/chat-completion and overview context sizes.
+ * Refresh live ids via `listZaiModels()` when the OpenAI-compatible list endpoint
+ * is available to the account.
+ */
 export const zaiModels = [
+    defineZaiModel({
+        model: "glm-5.2",
+        displayName: "GLM-5.2",
+        limits: { contextWindow: 1_000_000, maxOutputTokens: 128_000 },
+        cache: { kind: "implicit" },
+        compat: { thinking: true, reasoning_effort: "max", tool_stream: true },
+    }),
+    defineZaiModel({
+        model: "glm-5.1",
+        displayName: "GLM-5.1",
+        limits: { contextWindow: 200_000, maxOutputTokens: 128_000 },
+        cache: { kind: "implicit" },
+        compat: { thinking: true, tool_stream: true },
+    }),
+    defineZaiModel({
+        model: "glm-5",
+        displayName: "GLM-5",
+        limits: { contextWindow: 200_000, maxOutputTokens: 128_000 },
+        cache: { kind: "implicit" },
+        compat: { thinking: true, tool_stream: true },
+    }),
+    defineZaiModel({
+        model: "glm-5-turbo",
+        displayName: "GLM-5-Turbo",
+        limits: { contextWindow: 200_000, maxOutputTokens: 128_000 },
+        cache: { kind: "implicit" },
+        compat: { thinking: true, tool_stream: true },
+    }),
     defineZaiModel({
         model: "glm-4.7",
         displayName: "GLM-4.7",
-        limits: { contextWindow: 128_000, maxOutputTokens: 32_000 },
+        limits: { contextWindow: 200_000, maxOutputTokens: 128_000 },
+        cache: { kind: "implicit" },
+        // Official: GLM-4.7 forced thinking when enabled; tool_stream supported (4.6+).
+        compat: { thinking: true, tool_stream: true },
+    }),
+    defineZaiModel({
+        model: "glm-4.6",
+        displayName: "GLM-4.6",
+        limits: { contextWindow: 200_000, maxOutputTokens: 128_000 },
         cache: { kind: "implicit" },
-        compat: { thinking: true, reasoning_effort: "medium", tool_stream: true },
+        compat: { thinking: true, tool_stream: true },
     }),
     defineZaiModel({
         model: "glm-4.5",
         displayName: "GLM-4.5",
-        limits: { contextWindow: 128_000, maxOutputTokens: 32_000 },
+        limits: { contextWindow: 128_000, maxOutputTokens: 96_000 },
         cache: { kind: "implicit" },
-        compat: { thinking: true, reasoning_effort: "medium", tool_stream: true },
+        compat: { thinking: true },
     }),
 ];
+function thinkingDefaultsForModel(modelId) {
+    const id = modelId.toLowerCase();
+    if (!looksLikeReasoningModel(id))
+        return {};
+    const compat = { thinking: true };
+    if (supportsToolStream(id))
+        compat.tool_stream = true;
+    // Official: reasoning_effort only for GLM-5.2+.
+    if (supportsReasoningEffort(id))
+        compat.reasoning_effort = "max";
+    return compat;
+}
+function limitsForZaiModel(modelId) {
+    const id = modelId.toLowerCase();
+    if (id.includes("glm-5.2") || id.includes("glm-5-2")) {
+        return { contextWindow: 1_000_000, maxOutputTokens: 128_000 };
+    }
+    if (id.includes("glm-5") || id.includes("glm-4.7") || id.includes("glm-4.6")) {
+        return { contextWindow: 200_000, maxOutputTokens: 128_000 };
+    }
+    if (id.includes("glm-4.5v")) {
+        return { contextWindow: 64_000, maxOutputTokens: 16_000 };
+    }
+    if (id.includes("glm-4.5")) {
+        return { contextWindow: 128_000, maxOutputTokens: 96_000 };
+    }
+    if (id.includes("glm-4-32b") || id.includes("128k")) {
+        return { contextWindow: 128_000, maxOutputTokens: 16_000 };
+    }
+    return undefined;
+}
+function looksLikeReasoningModel(modelId) {
+    const id = modelId.toLowerCase();
+    return (id.includes("glm-5")
+        || id.includes("glm-4.7")
+        || id.includes("glm-4.6")
+        || id.includes("glm-4.5"));
+}
+function looksLikeVisionModel(modelId) {
+    const id = modelId.toLowerCase();
+    return id.includes("glm-5v") || id.includes("glm-4.6v") || id.includes("glm-4.5v") || id.endsWith("v");
+}
+function supportsToolStream(modelId) {
+    const id = modelId.toLowerCase();
+    // Official: tool_stream supported by GLM-4.6 and above.
+    return id.includes("glm-5") || id.includes("glm-4.7") || id.includes("glm-4.6");
+}
+function supportsReasoningEffort(modelId) {
+    const id = modelId.toLowerCase();
+    return id.includes("glm-5.2") || id.includes("glm-5-2");
+}
+function cleanJson(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
 //# sourceMappingURL=models.js.map

package/dist/provider.d.ts

@@ -1,5 +1,7 @@
-import type { AIProvider, JsonObject, ProviderEvent, ProviderRequest } from "@arnilo/prism";
+import type { AIProvider, JsonObject, Message, ModelConfig, ProviderEvent, ProviderRequest } from "@arnilo/prism";
 import { type CredentialValueSource } from "@arnilo/prism";
+/** Official international Chat Completions base (China `open.bigmodel.cn` remains overridable). */
+export declare const ZAI_DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
 export interface ZaiProviderOptions {
     readonly id?: string;
     readonly baseUrl?: string;
@@ -9,3 +11,10 @@ export interface ZaiProviderOptions {
 export declare function createZaiProvider(options?: ZaiProviderOptions): AIProvider;
 export declare function zaiBody(request: ProviderRequest): JsonObject;
 export declare function zaiEvents(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+/**
+ * Serialize Prism messages for Z.AI Chat Completions.
+ * Prior thinking blocks become `reasoning_content` when Preserved Thinking is active;
+ * otherwise they are dropped (never flattened into visible text).
+ * @see https://docs.z.ai/guides/capabilities/thinking-mode
+ */
+export declare function toZaiMessage(message: Message, model: ModelConfig, preserveThinking?: boolean): JsonObject;

package/dist/provider.js

@@ -1,10 +1,12 @@
-import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
-import { applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "@arnilo/prism/providers/openai";
+import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent, } from "@arnilo/prism";
+import { applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAITool, } from "@arnilo/prism/providers/openai";
 import { parseJsonObjectArguments, readBoundedResponseText, readSseData, } from "@arnilo/prism/providers/transport";
-import { zaiReasoningEffort, zaiThinking, zaiToolStream } from "./thinking.js";
+import { zaiPreserveThinking, zaiReasoningEffort, zaiThinking, zaiToolStream, } from "./thinking.js";
+/** Official international Chat Completions base (China `open.bigmodel.cn` remains overridable). */
+export const ZAI_DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
 export function createZaiProvider(options = {}) {
     const id = options.id ?? "zai";
-    const baseUrl = (options.baseUrl ?? "https://open.bigmodel.cn/api/paas/v4").replace(/\/$/, "");
+    const baseUrl = (options.baseUrl ?? ZAI_DEFAULT_BASE_URL).replace(/\/$/, "");
     return {
         id,
         async *generate(request) {
@@ -15,7 +17,11 @@ export function createZaiProvider(options = {}) {
             try {
                 const response = await (options.fetch ?? fetch)(`${baseUrl}/chat/completions`, {
                     method: "POST",
-                    headers: { ...request.options?.headers, "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) },
+                    headers: {
+                        ...request.options?.headers,
+                        "content-type": "application/json",
+                        ...(token ? { authorization: `Bearer ${token}` } : {}),
+                    },
                     body: JSON.stringify(zaiBody(request)),
                     signal: request.signal,
                 });
@@ -35,18 +41,21 @@ export function createZaiProvider(options = {}) {
 export function zaiBody(request) {
     assertStructuredOutputRequestSupported(request.model, request.options);
     const { maxTokens, ...parameters } = request.model.parameters ?? {};
+    const compatRest = stripZaiManagedCompat(request.options?.compat);
+    const preserveThinking = zaiPreserveThinking(request);
     const body = {
         model: request.model.model,
-        messages: request.messages.map((message) => serializeOpenAIChatMessage(message, request.model.capabilities ?? {})),
+        messages: request.messages.map((message) => toZaiMessage(message, request.model, preserveThinking)),
         tools: request.tools?.map(serializeOpenAITool),
         stream: true,
-        tool_stream: zaiToolStream(request),
-        thinking: zaiThinking(request),
-        reasoning_effort: zaiReasoningEffort(request),
         ...parameters,
         max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens,
-        ...request.options?.compat,
+        ...compatRest,
         ...request.options?.extra,
+        // Resolved official fields win over raw compat/extra escape hatches.
+        thinking: zaiThinking(request),
+        reasoning_effort: zaiReasoningEffort(request),
+        tool_stream: zaiToolStream(request),
     };
     applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
     return clean(body);
@@ -58,11 +67,12 @@ export async function* zaiEvents(body, signal) {
         if (data === "[DONE]")
             break;
         const chunk = JSON.parse(data);
-        usage = mapOpenAIChatUsage(chunk.usage) ?? usage;
         if (chunk.usage) {
             const mapped = mapOpenAIChatUsage(chunk.usage);
-            if (mapped)
+            if (mapped) {
+                usage = mapped;
                 yield providerUsage(mapped);
+            }
         }
         for (const choice of chunk.choices ?? []) {
             const delta = choice.delta ?? {};
@@ -77,7 +87,12 @@ export async function* zaiEvents(body, signal) {
                 current.name = tool.function?.name ?? current.name;
                 current.argumentsText += tool.function?.arguments ?? "";
                 tools.set(index, current);
-                yield providerToolCallDelta({ index, id: tool.id, name: tool.function?.name, argumentsText: tool.function?.arguments });
+                yield providerToolCallDelta({
+                    index,
+                    id: tool.id,
+                    name: tool.function?.name,
+                    argumentsText: tool.function?.arguments,
+                });
             }
         }
     }
@@ -88,6 +103,82 @@ export async function* zaiEvents(body, signal) {
     }
     yield providerDone(usage);
 }
+/**
+ * Serialize Prism messages for Z.AI Chat Completions.
+ * Prior thinking blocks become `reasoning_content` when Preserved Thinking is active;
+ * otherwise they are dropped (never flattened into visible text).
+ * @see https://docs.z.ai/guides/capabilities/thinking-mode
+ */
+export function toZaiMessage(message, model, preserveThinking = false) {
+    const capabilities = model.capabilities ?? {};
+    const thinkingParts = message.content.filter((part) => part.type === "thinking");
+    const reasoningContent = preserveThinking && thinkingParts.length > 0
+        ? thinkingParts.map((part) => part.text).join("\n")
+        : undefined;
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return {
+            role: "tool",
+            tool_call_id: result?.toolCallId ?? "",
+            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+        };
+    }
+    if (message.role === "assistant") {
+        const toolCalls = message.content.filter((part) => part.type === "tool_call");
+        const textParts = message.content.filter((part) => part.type === "text");
+        if (toolCalls.length > 0) {
+            return clean({
+                role: "assistant",
+                content: textParts.map((part) => part.text).join("\n") || null,
+                tool_calls: toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+                })),
+                reasoning_content: reasoningContent,
+            });
+        }
+    }
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "thinking") {
+            // Handled via reasoning_content when preserving; otherwise dropped.
+            continue;
+        }
+        else if (part.type === "image") {
+            if (!capabilities.input?.includes("image")) {
+                throw new Error("Z.AI request includes image but model does not declare image input capability");
+            }
+            const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
+            if (!url)
+                throw new Error("Z.AI image block missing url or data");
+            content.push({ type: "image_url", image_url: { url } });
+        }
+        else if (part.type === "audio" || part.type === "file" || part.type === "document") {
+            throw new Error(`Z.AI Chat Completions does not support ${part.type} content blocks`);
+        }
+        else if (part.type === "tool_call") {
+            throw new Error("Z.AI assistant tool_call blocks must be the only content on the message");
+        }
+        else if (part.type === "tool_result") {
+            throw new Error("Z.AI tool_result blocks must appear in role=tool messages");
+        }
+    }
+    if (content.length === 1 && content[0].type === "text") {
+        return clean({ role: message.role, content: content[0].text, reasoning_content: reasoningContent });
+    }
+    return clean({ role: message.role, content, reasoning_content: reasoningContent });
+}
+/** Drop Prism-managed compat keys so they are not double-emitted / overwrite resolved fields. */
+function stripZaiManagedCompat(compat) {
+    if (!compat)
+        return {};
+    const { thinking: _thinking, reasoning_effort: _reasoningEffort, reasoningEffort: _reasoningEffortCamel, tool_stream: _toolStream, clear_thinking: _clearThinking, clearThinking: _clearThinkingCamel, preserveThinking: _preserveThinking, preserve_thinking: _preserveThinkingSnake, ...rest } = compat;
+    return rest;
+}
 function clean(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
 }

package/dist/thinking.d.ts

@@ -1,4 +1,30 @@
 import type { JsonObject, ProviderRequest } from "@arnilo/prism";
+/**
+ * Map Prism compat → official Z.AI `thinking` body object.
+ * @see https://docs.z.ai/guides/capabilities/thinking
+ * @see https://docs.z.ai/api-reference/llm/chat-completion
+ */
 export declare function zaiThinking(request: ProviderRequest): JsonObject | undefined;
+/**
+ * Official `reasoning_effort` (GLM-5.2+). Request `options.compat` wins over model defaults.
+ * Allowed: max | xhigh | high | medium | low | minimal | none.
+ * @see https://docs.z.ai/guides/capabilities/thinking
+ */
 export declare function zaiReasoningEffort(request: ProviderRequest): string | undefined;
+/**
+ * Official `tool_stream` (GLM-4.6+). Request wins over model defaults.
+ * @see https://docs.z.ai/guides/capabilities/stream-tool
+ */
 export declare function zaiToolStream(request: ProviderRequest): boolean | undefined;
+/**
+ * Official nested `thinking.clear_thinking` (default true on the wire).
+ * When false, prior `reasoning_content` must be replayed for Preserved Thinking.
+ * @see https://docs.z.ai/guides/capabilities/thinking-mode
+ */
+export declare function zaiClearThinking(request: ProviderRequest): boolean | undefined;
+/**
+ * Prism-local: when true (and clear_thinking is not true), replay prior thinking
+ * blocks as assistant `reasoning_content`. Official Preserved Thinking also requires
+ * `thinking.clear_thinking: false`.
+ */
+export declare function zaiPreserveThinking(request: ProviderRequest): boolean;

package/dist/thinking.js

@@ -1,17 +1,87 @@
+/**
+ * Map Prism compat → official Z.AI `thinking` body object.
+ * @see https://docs.z.ai/guides/capabilities/thinking
+ * @see https://docs.z.ai/api-reference/llm/chat-completion
+ */
 export function zaiThinking(request) {
     const value = request.options?.compat?.thinking ?? request.model.compat?.thinking;
-    if (value === false || request.options?.cacheRetention === "none")
-        return { type: "disabled" };
-    if (value && typeof value === "object")
-        return value;
-    return value === true ? { type: "enabled" } : undefined;
+    const clearThinking = zaiClearThinking(request);
+    if (value === false || request.options?.cacheRetention === "none") {
+        return cleanThinking({ type: "disabled", clear_thinking: clearThinking });
+    }
+    if (value && typeof value === "object") {
+        return cleanThinking({
+            ...value,
+            ...(clearThinking !== undefined ? { clear_thinking: clearThinking } : {}),
+        });
+    }
+    if (value === true) {
+        return cleanThinking({ type: "enabled", clear_thinking: clearThinking });
+    }
+    // Hosts may set only `clear_thinking` / preserve flags without an explicit thinking switch.
+    if (clearThinking !== undefined) {
+        return cleanThinking({ type: "enabled", clear_thinking: clearThinking });
+    }
+    return undefined;
 }
+/**
+ * Official `reasoning_effort` (GLM-5.2+). Request `options.compat` wins over model defaults.
+ * Allowed: max | xhigh | high | medium | low | minimal | none.
+ * @see https://docs.z.ai/guides/capabilities/thinking
+ */
 export function zaiReasoningEffort(request) {
-    const effort = request.options?.compat?.reasoning_effort ?? request.options?.compat?.reasoningEffort ?? request.model.compat?.reasoning_effort;
+    const effort = request.options?.compat?.reasoning_effort
+        ?? request.options?.compat?.reasoningEffort
+        ?? request.model.compat?.reasoning_effort;
     return typeof effort === "string" ? effort : undefined;
 }
+/**
+ * Official `tool_stream` (GLM-4.6+). Request wins over model defaults.
+ * @see https://docs.z.ai/guides/capabilities/stream-tool
+ */
 export function zaiToolStream(request) {
     const value = request.options?.compat?.tool_stream ?? request.model.compat?.tool_stream;
     return typeof value === "boolean" ? value : undefined;
 }
+/**
+ * Official nested `thinking.clear_thinking` (default true on the wire).
+ * When false, prior `reasoning_content` must be replayed for Preserved Thinking.
+ * @see https://docs.z.ai/guides/capabilities/thinking-mode
+ */
+export function zaiClearThinking(request) {
+    const fromThinkingObject = readClearThinkingFromObject(request.options?.compat?.thinking ?? request.model.compat?.thinking);
+    if (fromThinkingObject !== undefined)
+        return fromThinkingObject;
+    const value = request.options?.compat?.clear_thinking
+        ?? request.options?.compat?.clearThinking
+        ?? request.model.compat?.clear_thinking;
+    return typeof value === "boolean" ? value : undefined;
+}
+/**
+ * Prism-local: when true (and clear_thinking is not true), replay prior thinking
+ * blocks as assistant `reasoning_content`. Official Preserved Thinking also requires
+ * `thinking.clear_thinking: false`.
+ */
+export function zaiPreserveThinking(request) {
+    const clear = zaiClearThinking(request);
+    if (clear === true)
+        return false;
+    const value = request.options?.compat?.preserveThinking
+        ?? request.options?.compat?.preserve_thinking
+        ?? request.model.compat?.preserveThinking
+        ?? request.model.compat?.preserve_thinking;
+    if (typeof value === "boolean")
+        return value;
+    // clear_thinking:false implies preserved thinking even without an explicit preserve flag.
+    return clear === false;
+}
+function readClearThinkingFromObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const clear = value.clear_thinking ?? value.clearThinking;
+    return typeof clear === "boolean" ? clear : undefined;
+}
+function cleanThinking(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
 //# sourceMappingURL=thinking.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-provider-zai",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Z.AI provider package for Prism.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.4"
+    "@arnilo/prism": "0.0.6"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."