Struct ChatBody 

pub struct ChatBody<N, M>
where
    N: ChatRequestModel,
    M: Serialize,
    (N, M): Bounded,
{ /* private fields */ }

Validated request body for a chat-completion operation.

This type stores the union of frozen chat request fields. Its fields are private, and capability-gated builders expose only the subset accepted by the selected text, vision, or audio model family.

Examples

use zai_rs::model::{
    chat_base_request::ChatBody,
    chat_message_types::TextMessage,
    chat_models::GLM5_2,
};

let chat_body = ChatBody::new(GLM5_2 {}, TextMessage::user("Hello"))
    .add_message(TextMessage::assistant("How can I help?"))
    .with_temperature(0.7)
    .with_max_tokens(1_000);

Implementations

impl<N, M> ChatBody<N, M>

where N: ChatRequestModel, M: Serialize, (N, M): Bounded,

pub fn new(model: N, messages: M) -> Self

Create a new chat request body from a model and the first message batch.

pub fn add_message(self, message: M) -> Self

Add one message to the conversation.

pub fn extend_messages(self, messages: impl IntoIterator<Item = M>) -> Self

Add multiple messages to the conversation at once.

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

Set the client-side request id (used for tracing/dedup).

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

Enable/disable sampling (do_sample).

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

Set the sampling temperature.

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

Set the nucleus-sampling probability (top_p).

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

Set the maximum number of tokens to generate.

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

Set the end-user id (used for abuse monitoring).

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

Add a stop sequence that halts generation when encountered.

pub const fn model(&self) -> &N

Borrow the selected model.

pub fn messages(&self) -> &[M]

Borrow the complete conversation in wire order.

pub fn request_id(&self) -> Option<&str>

Client-provided request identifier.

pub const fn thinking(&self) -> Option<&ThinkingType>

Thinking configuration, when supported and configured.

pub const fn reasoning_effort(&self) -> Option<ReasoningEffort>

Reasoning depth, when supported and configured.

pub const fn do_sample(&self) -> Option<bool>

Explicit sampling toggle.

pub const fn stream(&self) -> Option<bool>

Streaming flag managed by the ChatCompletion type state.

pub const fn tool_stream(&self) -> Option<bool>

Incremental tool-call flag managed by the streaming builder.

pub const fn temperature(&self) -> Option<f64>

Configured sampling temperature.

pub const fn top_p(&self) -> Option<f64>

Configured nucleus-sampling probability.

pub const fn max_tokens(&self) -> Option<u32>

Configured output-token limit.

pub fn tools(&self) -> Option<&[Tools]>

Attached tools, if this model family supports them.

pub const fn tool_choice(&self) -> Option<ToolChoice>

Configured automatic tool-selection policy.

pub fn user_id(&self) -> Option<&str>

End-user identifier used for abuse monitoring.

pub fn stop(&self) -> Option<&[String]>

Borrow configured stop sequences.

pub const fn response_format(&self) -> Option<ResponseFormat>

Text response format, when supported and configured.

pub const fn watermark_enabled(&self) -> Option<bool>

Audio-model watermark setting, when configured.

impl<N, M> ChatBody<N, M>

where N: ChatToolSupport, M: Serialize, (N, M): Bounded,

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

Add one schema-compatible tool.

pub fn add_tools(self, tools: impl IntoIterator<Item = N::Tool>) -> Self

Add multiple schema-compatible tools.

pub fn with_tool_choice(self, tool_choice: ToolChoice) -> Self

Let the model choose automatically among the attached tools.

pub fn clear_tools(self) -> Self

Remove attached tools and their selection policy.

impl<N, M> ChatBody<N, M>

where N: ResponseFormatEnable, M: Serialize, (N, M): Bounded,

pub fn with_response_format(self, format: ResponseFormat) -> Self

Set the response format for a text chat model.

impl<N, M> ChatBody<N, M>

where N: WatermarkEnable, M: Serialize, (N, M): Bounded,

pub fn with_watermark_enabled(self, enabled: bool) -> Self

Enable or disable provider watermarking for audio-model output.

impl<N, M> ChatBody<N, M>

where N: ChatRequestModel + ThinkEnable, M: Serialize, (N, M): Bounded,

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

Configure extended reasoning for a model that implements ThinkEnable.

Examples

use zai_rs::model::{
    chat_base_request::ChatBody,
    chat_message_types::TextMessage,
    chat_models::GLM5_2,
    tools::ThinkingType,
};

let chat_body = ChatBody::new(GLM5_2 {}, TextMessage::user("Solve this"))
    .with_thinking(ThinkingType::enabled());

impl<N, M> ChatBody<N, M>

where N: ChatRequestModel + ReasoningEffortEnable, M: Serialize, (N, M): Bounded,

pub fn with_reasoning_effort(self, effort: ReasoningEffort) -> Self

Set the reasoning_effort level that controls how much reasoning the model performs when thinking mode is enabled.

Available only for models implementing ReasoningEffortEnable. Typically combined with with_thinking to enable thinking first.

Examples

use zai_rs::model::{
    GLM5_2, TextMessage,
    chat_base_request::ChatBody,
    tools::{ReasoningEffort, ThinkingType},
};

let chat_body = ChatBody::new(GLM5_2 {}, TextMessage::user("Solve this"))
    .with_thinking(ThinkingType::enabled())
    .with_reasoning_effort(ReasoningEffort::Max);

Trait Implementations

impl<N, M> Clone for ChatBody<N, M>

where N: ChatRequestModel + Clone, M: Serialize + Clone, (N, M): Bounded,

fn clone(&self) -> ChatBody<N, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N, M> Debug for ChatBody<N, M>

where N: ChatRequestModel + Debug, M: Serialize, (N, M): Bounded,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<N, M> Serialize for ChatBody<N, M>

where N: ChatRequestModel + Serialize, M: Serialize + Serialize, (N, M): Bounded,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<N, M> Validate for ChatBody<N, M>

where N: ChatRequestModel, M: Serialize, (N, M): Bounded,

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a, N, M> ValidateArgs<'v_a> for ChatBody<N, M>

where N: ChatRequestModel, M: Serialize, (N, M): Bounded,

type Args = ()

fn validate_with_args(&self, args: Self::Args) -> Result<(), ValidationErrors>