Struct ChatResponse 

pub struct ChatResponse {
    pub id: String,
    pub model: String,
    pub content: Vec<ContentBlock>,
    pub usage: Option<ChatUsage>,
    pub stop_reason: String,
    pub citations: Vec<Citation>,
    pub cost_ticks: i64,
    pub request_id: String,
}

Response from a non-streaming chat request.

Fields

id: String

Unique request identifier.

model: String

Model that generated the response.

content: Vec<ContentBlock>

List of content blocks (text, thinking, tool_use).

usage: Option<ChatUsage>

Token counts and cost.

stop_reason: String

Why generation stopped (“end_turn”, “tool_use”, “max_tokens”).

citations: Vec<Citation>

Citations from web search (when search is enabled via provider_options).

cost_ticks: i64

Total cost from the X-QAI-Cost-Ticks header.

request_id: String

From the X-QAI-Request-Id header.

Implementations

impl ChatResponse

pub fn text(&self) -> String

Returns the concatenated text content, ignoring thinking and tool_use blocks.

Examples found in repository

examples/chat.rs (line 32)

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 thinking(&self) -> String

Returns the concatenated thinking content.

pub fn tool_calls(&self) -> Vec<&ContentBlock>

Returns all tool_use blocks from the response.

Trait Implementations

impl Clone for ChatResponse

fn clone(&self) -> ChatResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.