Crate zai_rs 

ZAI-RS: Zhipu AI Rust SDK

zai-rs is a type-safe Rust SDK providing full coverage of the Zhipu AI (BigModel) API. Strongly-typed clients and models span chat completions, image generation, speech recognition, text embeddings, knowledge-base management, and more.

Capabilities

Capability	Description	Module
Chat completions	Sync / async / streaming text, vision, voice	model
Image generation	Text-to-image	model::gen_image
Video generation	Async text-to-video	model::gen_video_async
Text-to-speech	Audio synthesis	model::text_to_audio
Speech-to-text	Audio transcription	model::audio_to_text
Voice cloning	Voice clone, list, delete	model::voice_clone
Text embeddings	Embeddings, reranking, tokenization	model::text_embedded
Content moderation	Safety analysis	model::moderation
OCR	Handwriting recognition	model::ocr
File management	Upload, list, content, delete	file
Batch processing	Create, list, retrieve, cancel	batches
Knowledge base	CRUD, document upload, retrieval	knowledge
Tool calling	Function calling, web search, file parsing	tool
Agent	Agent creation & management	agent
Tool execution framework	Dynamic registration, execution, caching	toolkits
Real-time	WebSocket audio/video (GLM-Realtime)	realtime
Coding Plan usage	GLM Coding Plan quota / 余量查询	usage

Module Structure

• client — HTTP client, connection pool, retry strategy, error types
• model — Data models, request/response types, model definitions, SSE parsing
• file — File management (upload, list, content, delete)
• batches — Batch processing (create, list, retrieve, cancel)
• knowledge — Knowledge-base management (CRUD, document upload, retrieval)
• tool — Tool implementations (web search, file parsing)
• agent — Agent API (creation, chat, history)
• toolkits — Tool execution framework (registration, execution, caching, RMCP bridge)
• realtime — Real-time audio/video communication (WebSocket, experimental)
• usage — Coding Plan usage / quota query (GLM Coding Plan 余量查询)

Quick Start

use zai_rs::{client::ZaiClient, model::*};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let model = GLM4_5_flash {};
    let client = ZaiClient::from_env()?;
    let request = ChatCompletion::new(model, TextMessage::user("Hello"));
    let _resp = request.send_via(&client).await?;
    Ok(())
}

Streaming Requests

use zai_rs::{client::ZaiClient, model::*};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let model = GLM4_5_flash {};
    let client = ZaiClient::from_env()?;
    let request = ChatCompletion::new(model, TextMessage::user("Hello"));
    let _response = request.send_via(&client).await?;
    Ok(())
}

Configuration

ZaiConfig is the central place for credentials, endpoint families, and HTTP transport settings. It mirrors the API families exposed by client::EndpointConfig, including the dedicated Coding Plan endpoint required by official Zhipu AI documentation.

# fn main() -> Result<(), Box<dyn std::error::Error>> {
use zai_rs::ZaiConfig;

let config = ZaiConfig::builder()
    .api_key("abc123.abcdefghijklmnopqrstuvwxyz")
    .paas_v4_base("https://open.bigmodel.cn/api/paas/v4")
    .coding_paas_v4_base("https://open.bigmodel.cn/api/coding/paas/v4")
    .build()?;

assert_eq!(
    config.coding_paas_v4_url("chat/completions"),
    "https://open.bigmodel.cn/api/coding/paas/v4/chat/completions"
);
# Ok(())
# }

Feature Flags

Feature	Default	Description
(default)	enabled	Core API functionality
realtime	disabled	Real-time audio/video over WebSocket (GLM-Realtime)
rmcp-kits	disabled	Enable RMCP protocol bridge for MCP tool calling
tool-validation	disabled	Runtime validation of tool-call arguments against their JSON Schema

Enable in Cargo.toml:

[dependencies]
zai-rs = { version = "0.4", features = ["rmcp-kits"] }

Error Handling

All API calls return ZaiResult<T>, unified under the ZaiError enum:

• ApiError — Business-level API error (with code and message)
• NetworkError — Network / timeout error
• JsonError — JSON serialization / deserialization error
• RateLimitError — Rate-limit or quota exceeded
• ContentPolicyError — API policy or unsafe-content block
• AuthError — Authentication / authorization error

Design Principles

• Compile-time type safety — trait bounds and type-state patterns ensure model/message compatibility at compile time
• Zero-cost abstractions — marker traits and type-state patterns impose no runtime overhead
• Consistent API style — request builders carry typed payloads and all network operations are dispatched with send_via(&ZaiClient)

Re-exports

pub use client::ZaiClient;

pub use client::error::*;

Modules

agent

Agent v1 API (plan P04).

batches

Batch Processing Module

client

HTTP client infrastructure: the shared ZaiClient, validated endpoints, transport policies and error types.

file

File Management Module

knowledge

Knowledge Base Module

model

Model Module

prelude

Prelude for the zai-rs 0.5 public surface (plan P10.1).

realtimerealtime

WebSocket realtime (GLM-Realtime) client — audio/video over a WebSocket. Gated behind the realtime Cargo feature (off by default).

services

tool

Tool Module

toolkits

Toolkits Module

usage

Coding Plan Usage / Quota Query

Macros

define_model_type

Macro for defining AI model types with standard implementations.

impl_message_binding

Macro for binding message types to AI models.

impl_model_markers

Macro for implementing multiple capability traits on model types.