Skip to main content

rskit_ai/chat/
message.rs

1//! Canonical AI chat message types.
2
3use serde::{Deserialize, Serialize};
4
5use crate::{ContentPart, ToolUseBlock, Usage, text_content, text_of};
6
7/// A chat message discriminated by role.
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9#[serde(tag = "role", rename_all = "snake_case")]
10pub enum Message {
11    /// User-authored message.
12    User(UserMessage),
13    /// Assistant/model-authored message.
14    Assistant(AssistantMessage),
15    /// System instruction.
16    System(SystemMessage),
17    /// Tool execution result.
18    #[serde(rename = "tool_result", alias = "tool")]
19    Tool(ToolResultMessage),
20}
21
22impl Message {
23    /// Return the wire role string.
24    #[must_use]
25    pub fn role(&self) -> &'static str {
26        match self {
27            Self::User(_) => "user",
28            Self::Assistant(_) => "assistant",
29            Self::System(_) => "system",
30            Self::Tool(_) => "tool_result",
31        }
32    }
33}
34
35/// A user message.
36#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
37pub struct UserMessage {
38    /// Content parts supplied by the user.
39    pub content: Vec<ContentPart>,
40}
41
42impl UserMessage {
43    /// Construct a single-text user message.
44    #[must_use]
45    pub fn from_text(text: impl Into<String>) -> Self {
46        Self {
47            content: text_content(text),
48        }
49    }
50}
51
52/// An assistant message.
53#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
54pub struct AssistantMessage {
55    /// Assistant content parts.
56    #[serde(default, skip_serializing_if = "Vec::is_empty")]
57    pub content: Vec<ContentPart>,
58    /// Canonical tool-use blocks requested by the assistant.
59    #[serde(default, skip_serializing_if = "Vec::is_empty")]
60    pub tool_calls: Vec<ToolUseBlock>,
61    /// Per-turn usage when tracked in conversation history.
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub usage: Option<Usage>,
64}
65
66impl AssistantMessage {
67    /// Concatenate all text content parts.
68    #[must_use]
69    pub fn text(&self) -> String {
70        text_of(&self.content)
71    }
72
73    /// Whether this message requested any tool calls.
74    #[must_use]
75    pub fn has_tool_calls(&self) -> bool {
76        !self.tool_calls.is_empty()
77    }
78}
79
80/// A system instruction message.
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
82pub struct SystemMessage {
83    /// System prompt content.
84    pub content: String,
85}
86
87/// A tool execution result message.
88#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
89pub struct ToolResultMessage {
90    /// Tool-use identifier satisfied by this result.
91    #[serde(alias = "tool_use_id")]
92    pub id: String,
93    /// Human-readable tool output.
94    pub content: String,
95    /// Whether the tool execution failed.
96    #[serde(default)]
97    pub is_error: bool,
98}
99
100/// Create a user message with text content.
101#[must_use]
102pub fn user(text: &str) -> Message {
103    Message::User(UserMessage::from_text(text))
104}
105
106/// Create an assistant message with text content.
107#[must_use]
108pub fn assistant(text: &str) -> Message {
109    Message::Assistant(AssistantMessage {
110        content: text_content(text),
111        tool_calls: Vec::new(),
112        usage: None,
113    })
114}
115
116/// Create a system message.
117#[must_use]
118pub fn system(text: &str) -> Message {
119    Message::System(SystemMessage {
120        content: text.to_string(),
121    })
122}
123
124/// Create a tool-result message.
125#[must_use]
126pub fn tool_result_msg(tool_use_id: &str, content: &str, is_error: bool) -> Message {
127    Message::Tool(ToolResultMessage {
128        id: tool_use_id.to_string(),
129        content: content.to_string(),
130        is_error,
131    })
132}