Struct Message 

pub struct Message {
    pub role: Role,
    pub content: Option<String>,
    pub tool_calls: Option<Vec<ToolCall>>,
    pub tool_call_id: Option<String>,
}

A single message in a conversation.

Messages are the fundamental unit of communication with LLM providers. Each message has a role (who sent it), content (the text), and optionally tool calls (for function calling).

Examples

User Message

use limit_llm::{Message, Role};

let msg = Message {
    role: Role::User,
    content: Some("What is the capital of France?".to_string()),
    tool_calls: None,
    tool_call_id: None,
};

Assistant Message with Tool Call

use limit_llm::{Message, Role, ToolCall, FunctionCall};

let msg = Message {
    role: Role::Assistant,
    content: None,
    tool_calls: Some(vec![ToolCall {
        id: "call_123".to_string(),
        tool_type: "function".to_string(),
        function: FunctionCall {
            name: "get_weather".to_string(),
            arguments: r#"{"location": "Paris"}"#.to_string(),
        },
    }]),
    tool_call_id: None,
};

Tool Result Message

use limit_llm::{Message, Role};

let msg = Message {
    role: Role::Tool,
    content: Some(r#"{"temp": 22, "condition": "sunny"}"#.to_string()),
    tool_calls: None,
    tool_call_id: Some("call_123".to_string()),
};

Fields

role: Role

The role of the message sender.

content: Option<String>

The text content of the message.

Can be None for assistant messages that only contain tool calls.

tool_calls: Option<Vec<ToolCall>>

Tool calls made by the assistant.

Only present in assistant messages when the LLM decides to call tools.

tool_call_id: Option<String>

ID of the tool call this message is responding to.

Only present in tool result messages.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Message

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

where __S: Serializer,

Serialize this value into the given Serde serializer.