Struct MessagesResponse

pub struct MessagesResponse {
    pub id: String,
    pub model: String,
    pub role: MessageRole,
    pub content: Vec<ResponseContentBlock>,
    pub stop_reason: Option<String>,
    pub stop_sequence: Option<String>,
    pub typ: String,
    pub usage: Usage,
}

Represents a full message response from the Anthropic API.

This struct contains the complete response from a message request, including the model’s generated content and usage statistics.

Fields

id: String

Unique identifier for this message

model: String

The model that generated the response

role: MessageRole

The role of the message sender (always Assistant for responses)

content: Vec<ResponseContentBlock>

The content blocks in the response (text or tool use)

stop_reason: Option<String>

Reason why the model stopped generating, if applicable

stop_sequence: Option<String>

The specific sequence that caused generation to stop, if applicable

typ: String

The type of the response (always “message”)

usage: Usage

Token usage statistics for the request and response

Implementations

impl MessagesResponse

pub async fn create(request: MessagesRequest) -> ApiResponseOrError<Self>

Creates a new message request and returns the response.

This method sends a request to the Messages API and returns the complete response.

Example

let credentials = Credentials::from_env();
let request = MessagesRequest {
    model: "claude-3-7-sonnet-20250219".to_string(),
    messages: vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text("Hello!".to_string()),
    }],
    max_tokens: 100,
    credentials: Some(credentials),
    metadata: None,
    stop_sequences: None,
    stream: None,
    system: None,
    temperature: None,
    thinking: None,
    tool_choice: None,
    tools: None,
    top_k: None,
    top_p: None,
};

let response = MessagesResponse::create(request).await?;

impl MessagesResponse

pub fn builder( model: &str, messages: impl Into<Vec<Message>>, max_tokens: u64, ) -> MessagesBuilder

Creates a new builder with the required fields.

This is a convenience method to create a builder with the minimum required fields for a message request.

Example

let credentials = Credentials::from_env();

let response =MessagesBuilder::builder(
    "claude-3-7-sonnet-20250219",
    vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text("Hello!".to_string()),
    }],
    100,
)
.credentials(credentials)
.create()
.await?;

Examples found in repository

examples/tool_use.rs (line 62)

async fn main() {
    let credentials = Credentials::from_env();

    // Define a calculator tool
    let calculator_tool = Tool {
        name: "calculator".to_string(),
        description: "A calculator that can perform basic arithmetic operations".to_string(),
        input_schema: json!({
            "type": "object",
            "properties": {
                "operation": {
                    "type": "string",
                    "enum": ["add", "subtract", "multiply", "divide"]
                },
                "operands": {
                    "type": "array",
                    "items": {"type": "number"},
                    "minItems": 2,
                    "maxItems": 2
                }
            },
            "required": ["operation", "operands"]
        }),
    };

    let content =
        "You are a helpful AI assistant. Please calculate 15 + 27 using the calculator tool.";
    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(content.to_string()),
    }];

    println!("Claude: {}", content);

    // Create message request with tool
    let response = MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
        .credentials(credentials.clone())
        .tools(vec![calculator_tool.clone()])
        .tool_choice(ToolChoice::Any)
        .create()
        .await
        .unwrap();

    // Print assistant's response and tool usage
    for content in response.content {
        match content {
            ResponseContentBlock::Text { text } => {
                println!("Assistant: {}", text.trim());
                messages.push(Message {
                    role: MessageRole::Assistant,
                    content: MessageContent::Text(text),
                });
            }
            ResponseContentBlock::ToolUse { name, input, .. } => {
                println!("Claude decided to use the tool: {}: {}", name, input);
            }
        }
    }
}

examples/message_cli.rs (line 78)

async fn main() {
    // Load .env file containing ANTHROPIC_API_KEY
    let credentials = Credentials::from_env();

    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(
            "You are a helpful AI assistant. Please introduce yourself briefly.".to_string(),
        ),
    }];

    // Create initial message request
    let response = MessagesBuilder::builder("claude-3-7-sonnet-20250219", messages.clone(), 2000)
        .credentials(credentials.clone())
        .thinking(Thinking {
            thinking_type: ThinkingType::Enabled,
            budget_tokens: 1000,
        })
        .create()
        .await
        .unwrap();

    // Print assistant's response
    if let Some(content) = response.content.first() {
        match content {
            ResponseContentBlock::Text { text } => {
                println!("Assistant: {}", text.trim());
                messages.push(Message {
                    role: MessageRole::Assistant,
                    content: MessageContent::Text(text.clone()),
                });
            }
            _ => {}
        }
    }

    // Start conversation loop
    loop {
        print!("User: ");
        stdout().flush().unwrap();

        let mut user_input = String::new();
        stdin().read_line(&mut user_input).unwrap();

        // Add user message
        messages.push(Message {
            role: MessageRole::User,
            content: MessageContent::Text(user_input),
        });

        // Send message request
        let response =
            MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
                .credentials(credentials.clone())
                .create()
                .await
                .unwrap();

        // Print assistant's response
        if let Some(content) = response.content.first() {
            match content {
                ResponseContentBlock::Text { text } => {
                    println!("Assistant: {}", text.trim());
                    messages.push(Message {
                        role: MessageRole::Assistant,
                        content: MessageContent::Text(text.clone()),
                    });
                }
                _ => {}
            }
        }
    }
}

examples/streaming.rs (line 40)

async fn main() {
    let credentials = Credentials::from_env();

    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(
            "You are a helpful AI assistant. Please introduce yourself briefly.".to_string(),
        ),
    }];

    // Create initial message request with streaming
    let mut stream =
        MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
            .credentials(credentials.clone())
            .create_stream()
            .await
            .unwrap();

    // Print assistant's streaming response
    print!("Assistant: ");
    stdout().flush().unwrap();
    while let Some(event) = stream.recv().await {
        match event {
            StreamEvent::ContentBlockDelta { delta, .. } => {
                if let ContentBlockDelta::Text { text } = delta {
                    print!("{}", text);
                    stdout().flush().unwrap();
                }
            }
            StreamEvent::MessageStop => {
                println!();
            }
            _ => {}
        }
    }

    // Start conversation loop
    loop {
        print!("\nUser: ");
        stdout().flush().unwrap();

        let mut user_input = String::new();
        stdin().read_line(&mut user_input).unwrap();

        // Add user message
        messages.push(Message {
            role: MessageRole::User,
            content: MessageContent::Text(user_input),
        });

        // Send message request with streaming
        let mut stream =
            MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
                .credentials(credentials.clone())
                .create_stream()
                .await
                .unwrap();

        // Print assistant's streaming response and store the text
        print!("\nAssistant: ");
        stdout().flush().unwrap();
        let mut full_response = String::new();
        while let Some(event) = stream.recv().await {
            match event {
                StreamEvent::ContentBlockDelta { delta, .. } => {
                    if let ContentBlockDelta::Text { text } = delta {
                        print!("{}", text);
                        stdout().flush().unwrap();
                        full_response.push_str(&text);
                    }
                }
                StreamEvent::MessageStop => {
                    println!();
                }
                _ => {}
            }
        }

        // Add assistant's complete response to messages
        messages.push(Message {
            role: MessageRole::Assistant,
            content: MessageContent::Text(full_response),
        });
    }
}

Trait Implementations

impl Clone for MessagesResponse

fn clone(&self) -> MessagesResponse

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MessagesResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MessagesResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MessagesResponse

fn eq(&self, other: &MessagesResponse) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for MessagesResponse

impl StructuralPartialEq for MessagesResponse