Struct ChatMessage 

pub struct ChatMessage {
    pub role: String,
    pub content: Option<String>,
    pub content_blocks: Option<Vec<ContentBlock>>,
    pub tool_call_id: Option<String>,
    pub is_error: Option<bool>,
}

A single message in a conversation.

Fields

role: String

One of “system”, “user”, “assistant”, or “tool”.

content: Option<String>

Text content of the message.

content_blocks: Option<Vec<ContentBlock>>

Structured content for assistant messages with tool calls. When present, takes precedence over content.

tool_call_id: Option<String>

Required when role is “tool” — references the tool_use ID.

is_error: Option<bool>

Whether a tool result is an error.

Implementations

impl ChatMessage

pub fn user(content: impl Into<String>) -> Self

Creates a user message.

Examples found in repository

examples/chat.rs (lines 23-25)

async fn main() {
    let api_key = std::env::var("QAI_API_KEY").expect("QAI_API_KEY environment variable is required");

    let client = Client::new(api_key);

    // --- Non-streaming example ---
    println!("=== Non-streaming Chat ===");

    let resp = client
        .chat(&ChatRequest {
            model: "claude-sonnet-4-6".into(),
            messages: vec![ChatMessage::user(
                "What is quantum computing in one sentence?",
            )],
            ..Default::default()
        })
        .await
        .expect("Chat failed");

    println!("Model: {}", resp.model);
    println!("Response: {}", resp.text());
    if let Some(usage) = &resp.usage {
        println!(
            "Tokens: {} in / {} out (cost: {} ticks)",
            usage.input_tokens, usage.output_tokens, usage.cost_ticks
        );
    }
    println!("Request ID: {}\n", resp.request_id);

    // --- Streaming example ---
    println!("=== Streaming Chat ===");

    let mut stream = client
        .chat_stream(&ChatRequest {
            model: "claude-sonnet-4-6".into(),
            messages: vec![ChatMessage::user(
                "Count from 1 to 5, one number per line.",
            )],
            ..Default::default()
        })
        .await
        .expect("ChatStream failed");

    while let Some(ev) = stream.next().await {
        match ev.event_type.as_str() {
            "content_delta" => {
                if let Some(delta) = &ev.delta {
                    print!("{}", delta.text);
                }
            }
            "usage" => {
                if let Some(usage) = &ev.usage {
                    println!("\n[Cost: {} ticks]", usage.cost_ticks);
                }
            }
            "error" => {
                eprintln!("Stream error: {}", ev.error.as_deref().unwrap_or("unknown"));
                std::process::exit(1);
            }
            "done" => {
                println!("\n[Stream complete]");
            }
            _ => {}
        }
    }
}

pub fn assistant(content: impl Into<String>) -> Self

Creates an assistant message.

pub fn system(content: impl Into<String>) -> Self

Creates a system message.

pub fn tool_result( tool_call_id: impl Into<String>, content: impl Into<String>, ) -> Self

Creates a tool result message.

pub fn tool_error( tool_call_id: impl Into<String>, content: impl Into<String>, ) -> Self

Creates a tool error result message.

Trait Implementations

impl Clone for ChatMessage

fn clone(&self) -> ChatMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatMessage

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

Formats the value using the given formatter.

impl Default for ChatMessage

fn default() -> ChatMessage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ChatMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.