Struct ChatCompletion 

pub struct ChatCompletion<N, M, S = StreamOff>
where
    N: ModelName + Chat,
    (N, M): Bounded,
    ChatBody<N, M>: Serialize,
    S: StreamState,
{
    pub key: String,
    pub url: String,
    /* private fields */
}

Type-safe chat completion request structure.

This struct represents a chat completion request with compile-time guarantees for model compatibility and streaming capabilities.

Type Parameters

• N - The AI model type (must implement ModelName + Chat)
• M - The message type (must form a valid bound with the model)
• S - Stream state (StreamOn or StreamOff, defaults to StreamOff)

Examples

let model = GLM4_5_flash {};
let messages = TextMessage::user("Hello, how are you?");
let request = ChatCompletion::new(model, messages, api_key);

Fields

key: String

API key for authentication with the Zhipu AI service.

url: String

API endpoint URL for chat completions. Defaults to “https://open.bigmodel.cn/api/paas/v4/chat/completions” but can be customized using the with_url() method.

Implementations

impl<N, M> ChatCompletion<N, M, StreamOff>

where N: ModelName + Chat, (N, M): Bounded, ChatBody<N, M>: Serialize,

pub fn new( model: N, messages: M, key: String, ) -> ChatCompletion<N, M, StreamOff>

Creates a new non-streaming chat completion request.

Arguments

• model - The AI model to use for completion
• messages - The conversation messages
• key - API key for authentication

Returns

A new ChatCompletion instance configured for non-streaming requests.

pub fn body_mut(&mut self) -> &mut ChatBody<N, M>

Gets mutable access to the request body for further customization.

This method allows modification of request parameters after initial creation.

pub fn add_messages(self, messages: M) -> Self

Adds additional messages to the conversation.

This method provides a fluent interface for building conversation context.

Arguments

• messages - Additional messages to append to the conversation

Returns

Self with the updated message collection, enabling method chaining.

pub fn with_request_id(self, request_id: impl Into<String>) -> Self

pub fn with_do_sample(self, do_sample: bool) -> Self

pub fn with_temperature(self, temperature: f32) -> Self

pub fn with_top_p(self, top_p: f32) -> Self

pub fn with_max_tokens(self, max_tokens: u32) -> Self

pub fn add_tool(self, tool: Tools) -> Self

pub fn add_tools(self, tools: Vec<Tools>) -> Self

pub fn with_user_id(self, user_id: impl Into<String>) -> Self

pub fn with_stop(self, stop: String) -> Self

pub fn with_url(self, url: impl Into<String>) -> Self

Sets a custom API endpoint URL for this chat completion request.

This method allows overriding the default API endpoint with a custom URL, enabling support for different deployment environments or proxy configurations.

Arguments

• url - The custom API endpoint URL

Returns

Self with the updated URL, enabling method chaining.

Examples

let request = ChatCompletion::new(model, messages, api_key)
    .with_url("https://custom-api.example.com/v1/chat/completions");

pub fn with_coding_plan(self) -> Self

Sets the URL to the coding plan endpoint.

This method configures the chat completion request to use the coding-specific API endpoint “https://open.bigmodel.cn/api/coding/paas/v4/chat/completions”.

Returns

Self with the coding plan URL, enabling method chaining.

Examples

let request = ChatCompletion::new(model, messages, api_key)
    .with_coding_plan();

pub fn with_thinking(self, thinking: ThinkingType) -> Self

where N: ThinkEnable,

pub fn enable_stream(self) -> ChatCompletion<N, M, StreamOn>

Enables streaming for this chat completion request.

This method transitions the request to streaming mode, allowing real-time response processing through Server-Sent Events (SSE).

Returns

A new ChatCompletion instance with streaming enabled (StreamOn).

pub fn validate(&self) -> ZaiResult<()>

Validate request parameters for non-stream chat (StreamOff)

pub async fn send(&self) -> ZaiResult<ChatCompletionResponse>

where N: Serialize, M: Serialize,

impl<N, M> ChatCompletion<N, M, StreamOn>

where N: ModelName + Chat, (N, M): Bounded, ChatBody<N, M>: Serialize,

pub fn with_tool_stream(self, tool_stream: bool) -> Self

where N: ToolStreamEnable,

pub fn disable_stream(self) -> ChatCompletion<N, M, StreamOff>

Disables streaming for this chat completion request.

This method ensures the request will receive a complete response rather than streaming chunks.

Returns

A new ChatCompletion instance with streaming disabled (StreamOff).

Trait Implementations

impl<N, M, S> HttpClient for ChatCompletion<N, M, S>

where N: ModelName + Serialize + Chat, M: Serialize, (N, M): Bounded, S: StreamState,

fn api_url(&self) -> &Self::ApiUrl

Returns the API endpoint URL for chat completions.

type Body = ChatBody<N, M>

type ApiUrl = String

type ApiKey = String

fn api_key(&self) -> &Self::ApiKey

fn body(&self) -> &Self::Body

fn http_config(&self) -> Arc<HttpClientConfig>

Get HTTP client configuration for this request

fn post(&self) -> impl Future<Output = ZaiResult<Response>> + Send

Sends a POST request to the API endpoint.

fn get(&self) -> impl Future<Output = ZaiResult<Response>> + Send

Sends a GET request to the API endpoint.

impl<N, M> SseStreamable for ChatCompletion<N, M, StreamOn>

where N: ModelName + Serialize + Chat, M: Serialize, (N, M): Bounded,

Enables Server-Sent Events (SSE) streaming for streaming-enabled chat completions.

This implementation allows streaming chat completions to be processed incrementally as responses arrive from the API.

fn stream_sse_for_each<'a, F>( &'a mut self, on_data: F, ) -> impl Future<Output = ZaiResult<()>> + 'a

where F: FnMut(&[u8]) + 'a,

impl<N, M> StreamChatLikeExt for ChatCompletion<N, M, StreamOn>

where N: ModelName + Serialize + Chat, M: Serialize, (N, M): Bounded,

Provides streaming extension methods for streaming-enabled chat completions.

This implementation enables the use of streaming-specific methods for processing chat responses in real-time.

fn stream_for_each<'a, F, Fut>( &'a mut self, on_chunk: F, ) -> impl Future<Output = ZaiResult<()>> + 'a

where F: FnMut(ChatStreamResponse) -> Fut + 'a, Fut: Future<Output = ZaiResult<()>> + 'a,

Processes streaming responses using an async callback function.

fn to_stream<'a>( &'a mut self, ) -> impl Future<Output = ZaiResult<Pin<Box<dyn Stream<Item = ZaiResult<ChatStreamResponse>> + Send + 'static>>>> + 'a

Converts the streaming response into a composable Stream.