@arnilo/prism-provider-zai 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to @arnilo/prism-provider-zai will be documented in this file.
+
+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]
+
+### Added
+
+- Added `LICENSE` (MIT) and `CHANGELOG.md`.
+- Added npm package metadata: `license`, `repository`, `bugs`, `homepage`,
+  `keywords`, and `sideEffects`.
+
+### Changed
+
+- `files` whitelist now explicitly excludes `dist/__tests__/` and
+  `dist/**/*.map` from published tarballs.
+- Made `prism` a required peer dependency; it is no longer optional.
+
+## [0.0.1] - 2026-06-22
+
+### Added
+
+- Initial release of @arnilo/prism-provider-zai.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# @arnilo/prism-provider-zai
+
+Z.AI GLM provider package for Prism.
+
+```ts
+import { createZaiProviderPackage } from "@arnilo/prism-provider-zai";
+
+api.registerProviderPackage(createZaiProviderPackage({ apiKey: "fake-zai-key" }));
+```
+
+Exports:
+- `createZaiProviderPackage()`
+- `createZaiProvider()`
+- `defineZaiModel()`
+- `zaiModels`
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { type CredentialValueSource, type ModelConfig, type ProviderPackage } from "@arnilo/prism";
+export interface ZaiProviderPackageOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    readonly baseUrl?: string;
+    readonly id?: string;
+    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";

package/dist/index.js

@@ -0,0 +1,20 @@
+import { defineProviderPackage } from "@arnilo/prism";
+import { createZaiProvider } from "./provider.js";
+import { zaiModels } from "./models.js";
+export function createZaiProviderPackage(options = {}) {
+    const providerId = options.id ?? "zai";
+    return defineProviderPackage({
+        name: "@arnilo/prism-provider-zai",
+        description: "Z.AI provider package for Prism.",
+        docs: { links: ["docs/providers/zai.md"] },
+        setup(api) {
+            api.registerProvider(createZaiProvider(options));
+            for (const model of options.models ?? zaiModels)
+                api.registerModel({ ...model, provider: providerId });
+            api.registerAuthMethod({ kind: "api_key", provider: providerId, credentialName: "apiKey" });
+        },
+    });
+}
+export { defineZaiModel, zaiModels } from "./models.js";
+export { createZaiProvider, zaiBody, zaiEvents } from "./provider.js";
+//# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject, ModelConfig } from "@arnilo/prism";
+export interface ZaiModelConfig extends Omit<ModelConfig, "provider" | "compat"> {
+    readonly provider?: "zai";
+    readonly compat?: JsonObject & {
+        readonly thinking?: boolean | JsonObject;
+        readonly reasoning_effort?: string;
+        readonly tool_stream?: boolean;
+    };
+}
+export declare function defineZaiModel(config: ZaiModelConfig): ModelConfig;
+export declare const zaiModels: readonly [ModelConfig, ModelConfig];

package/dist/models.js

@@ -0,0 +1,18 @@
+export function defineZaiModel(config) {
+    return { ...config, provider: "zai", capabilities: { input: ["text"], output: ["text"], reasoning: true, tools: true, streaming: true, ...config.capabilities } };
+}
+export const zaiModels = [
+    defineZaiModel({
+        model: "glm-4.7",
+        displayName: "GLM-4.7",
+        limits: { contextWindow: 128_000, maxOutputTokens: 32_000 },
+        compat: { thinking: true, reasoning_effort: "medium", tool_stream: true },
+    }),
+    defineZaiModel({
+        model: "glm-4.5",
+        displayName: "GLM-4.5",
+        limits: { contextWindow: 128_000, maxOutputTokens: 32_000 },
+        compat: { thinking: true, reasoning_effort: "medium", tool_stream: true },
+    }),
+];
+//# sourceMappingURL=models.js.map

package/dist/provider.d.ts

@@ -0,0 +1,10 @@
+import type { AIProvider, CredentialValueSource, JsonObject, ProviderEvent, ProviderRequest } from "@arnilo/prism";
+export interface ZaiProviderOptions {
+    readonly id?: string;
+    readonly baseUrl?: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+}
+export declare function createZaiProvider(options?: ZaiProviderOptions): AIProvider;
+export declare function zaiBody(request: ProviderRequest): JsonObject;
+export declare function zaiEvents(body: ReadableStream<Uint8Array>): AsyncIterable<ProviderEvent>;

package/dist/provider.js

@@ -0,0 +1,153 @@
+import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
+import { readSseData } from "./sse.js";
+import { zaiReasoningEffort, zaiThinking, zaiToolStream } from "./thinking.js";
+export function createZaiProvider(options = {}) {
+    const id = options.id ?? "zai";
+    const baseUrl = (options.baseUrl ?? "https://open.bigmodel.cn/api/paas/v4").replace(/\/$/, "");
+    return {
+        id,
+        async *generate(request) {
+            if (request.signal?.aborted)
+                throw request.signal.reason ?? new Error("aborted");
+            const token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
+            const secrets = [token];
+            try {
+                const response = await (options.fetch ?? fetch)(`${baseUrl}/chat/completions`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json", ...request.options?.headers, ...(token ? { authorization: `Bearer ${token}` } : {}) },
+                    body: JSON.stringify(zaiBody(request)),
+                    signal: request.signal,
+                });
+                if (!response.ok)
+                    return yield providerError(new Error(`Z.AI request failed: ${response.status} ${await safeText(response)}`), secrets);
+                if (!response.body)
+                    return yield providerError(new Error("Z.AI response had no body"), secrets);
+                yield* zaiEvents(response.body);
+            }
+            catch (error) {
+                yield providerError(error, secrets);
+            }
+        },
+    };
+}
+export function zaiBody(request) {
+    return clean({
+        model: request.model.model,
+        messages: request.messages.map((message) => toMessage(message, request.model.capabilities ?? {})),
+        tools: request.tools?.map(toTool),
+        stream: true,
+        tool_stream: zaiToolStream(request),
+        thinking: zaiThinking(request),
+        reasoning_effort: zaiReasoningEffort(request),
+        max_tokens: request.model.limits?.maxOutputTokens,
+        ...request.model.parameters,
+        ...request.options?.compat,
+        ...request.options?.extra,
+    });
+}
+export async function* zaiEvents(body) {
+    const tools = new Map();
+    let usage;
+    for await (const data of readSseData(body)) {
+        if (data === "[DONE]")
+            break;
+        const chunk = JSON.parse(data);
+        usage = toUsage(chunk.usage) ?? usage;
+        if (chunk.usage)
+            yield providerUsage(toUsage(chunk.usage));
+        for (const choice of chunk.choices ?? []) {
+            const delta = choice.delta ?? {};
+            if (delta.content)
+                yield providerTextDelta(delta.content);
+            if (delta.reasoning_content)
+                yield providerThinkingDelta(delta.reasoning_content);
+            for (const tool of delta.tool_calls ?? []) {
+                const index = tool.index ?? 0;
+                const current = tools.get(index) ?? { argumentsText: "" };
+                current.id = tool.id ?? current.id;
+                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 });
+            }
+        }
+    }
+    for (const call of tools.values())
+        if (call.id && call.name)
+            yield providerToolCall(toolCallContent(call.id, call.name, parseArgs(call.argumentsText)));
+    yield providerDone(usage);
+}
+function toMessage(message, capabilities = {}) {
+    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" || part.type === "thinking");
+        if (toolCalls.length > 0) {
+            return {
+                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) },
+                })),
+            };
+        }
+    }
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text" || part.type === "thinking") {
+            content.push({ type: "text", text: part.text });
+        }
+        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 === "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 { role: message.role, content: content[0].text };
+    }
+    return { role: message.role, content };
+}
+function toTool(tool) {
+    return clean({ type: "function", function: { name: tool.name, description: tool.description, parameters: tool.parameters ?? { type: "object" } } });
+}
+function toUsage(usage) {
+    return usage ? { inputTokens: usage.prompt_tokens, outputTokens: usage.completion_tokens, totalTokens: usage.total_tokens, cacheReadTokens: usage.prompt_tokens_details?.cached_tokens, cacheWriteTokens: usage.prompt_tokens_details?.cache_write_tokens } : undefined;
+}
+function parseArgs(text) {
+    if (!text)
+        return {};
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function clean(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+async function safeText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=provider.js.map

package/dist/sse.d.ts

@@ -0,0 +1 @@
+export declare function readSseData(body: ReadableStream<Uint8Array>): AsyncIterable<string>;

package/dist/sse.js

@@ -0,0 +1,24 @@
+export async function* readSseData(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop() ?? "";
+        for (const part of parts)
+            yield* eventData(part);
+    }
+    buffer += decoder.decode();
+    if (buffer)
+        yield* eventData(buffer);
+}
+function* eventData(event) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+    if (data)
+        yield data;
+}
+//# sourceMappingURL=sse.js.map

package/dist/thinking.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject, ProviderRequest } from "@arnilo/prism";
+export declare function zaiThinking(request: ProviderRequest): JsonObject | undefined;
+export declare function zaiReasoningEffort(request: ProviderRequest): string | undefined;
+export declare function zaiToolStream(request: ProviderRequest): boolean | undefined;

package/dist/thinking.js

@@ -0,0 +1,17 @@
+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;
+}
+export function zaiReasoningEffort(request) {
+    const effort = request.options?.compat?.reasoning_effort ?? request.options?.compat?.reasoningEffort ?? request.model.compat?.reasoning_effort;
+    return typeof effort === "string" ? effort : undefined;
+}
+export function zaiToolStream(request) {
+    const value = request.options?.compat?.tool_stream ?? request.model.compat?.tool_stream;
+    return typeof value === "boolean" ? value : undefined;
+}
+//# sourceMappingURL=thinking.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@arnilo/prism-provider-zai",
+  "version": "0.0.1",
+  "description": "Z.AI provider package for Prism.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/__tests__/*.test.js",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@arnilo/prism": "0.0.1"
+  },
+  "devDependencies": {
+    "@arnilo/prism": "file:../.."
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git",
+    "directory": "packages/provider-zai"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism/tree/main/packages/provider-zai#readme",
+  "keywords": [
+    "prism",
+    "provider",
+    "zai",
+    "agent",
+    "llm"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}