Conversation

pub struct Conversation(Vec<Message>);

pub fn new<I>(messages: I) -> Result<Self, InvalidConversation>
where
    I: IntoIterator<Item = Message>,

let messages = vec![
    Message::user().with_text("Hello"),
    Message::assistant().with_text("Hi there!"),
];
let conversation = Conversation::new(messages)?;

pub fn new_unvalidated<I>(messages: I) -> Self
where
    I: IntoIterator<Item = Message>,

pub fn empty() -> Self

pub fn messages(&self) -> &Vec<Message>

for message in conversation.messages() {
    println!("Role: {:?}, Text: {}", message.role, message.as_concat_text());
}

pub fn last(&self) -> Option<&Message>

pub fn first(&self) -> Option<&Message>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn push(&mut self, message: Message)

let mut conversation = Conversation::empty();
conversation.push(Message::user().with_text("Hello"));
conversation.push(Message::assistant().with_text("Hi!"));

pub fn extend<I>(&mut self, iter: I)
where
    I: IntoIterator<Item = Message>,

pub fn pop(&mut self) -> Option<Message>

pub fn truncate(&mut self, len: usize)

pub fn clear(&mut self)

pub fn filtered_messages<F>(&self, filter: F) -> Vec<Message>
where
    F: Fn(&MessageMetadata) -> bool,

pub fn agent_visible_messages(&self) -> Vec<Message>

let agent_messages = conversation.agent_visible_messages();
for msg in agent_messages {
    // These messages will be sent to the LLM
}

pub fn user_visible_messages(&self) -> Vec<Message>

pub fn fix_conversation(conversation: Conversation) -> (Conversation, Vec<String>)

let (fixed, issues) = fix_conversation(conversation);
if !issues.is_empty() {
    println!("Fixed issues: {:?}", issues);
}

pub struct Message {
    pub id: Option<String>,
    pub role: Role,
    pub created: i64,
    pub content: Vec<MessageContent>,
    pub metadata: MessageMetadata,
}

pub fn user() -> Self

pub fn assistant() -> Self

let user_msg = Message::user()
    .with_text("Run the tests")
    .with_generated_id();

let assistant_msg = Message::assistant()
    .with_text("I'll run the tests for you.")
    .with_tool_request("req_1", Ok(tool_params));

pub fn with_text<S: Into<String>>(self, text: S) -> Self

pub fn with_image<S: Into<String>, T: Into<String>>(self, data: S, mime_type: T) -> Self

pub fn with_tool_request<S: Into<String>>(
    self,
    id: S,
    tool_call: ToolResult<CallToolRequestParams>,
) -> Self

pub fn with_tool_response<S: Into<String>>(
    self,
    id: S,
    result: ToolResult<CallToolResult>,
) -> Self

pub fn with_visibility(mut self, user_visible: bool, agent_visible: bool) -> Self

// Message visible only to agent
let internal_msg = Message::assistant()
    .with_text("Internal processing note")
    .with_visibility(false, true);

pub fn as_concat_text(&self) -> String

pub fn is_tool_call(&self) -> bool

pub fn is_tool_response(&self) -> bool

pub enum MessageContent {
    Text(TextContent),
    Image(ImageContent),
    ToolRequest(ToolRequest),
    ToolResponse(ToolResponse),
    ToolConfirmationRequest(ToolConfirmationRequest),
    ActionRequired(ActionRequired),
    FrontendToolRequest(FrontendToolRequest),
    Thinking(ThinkingContent),
    RedactedThinking(RedactedThinkingContent),
    SystemNotification(SystemNotificationContent),
    Reasoning(ReasoningContent),
}

pub struct MessageMetadata {
    pub user_visible: bool,
    pub agent_visible: bool,
}

impl MessageMetadata {
    pub fn agent_only() -> Self;   // user_visible: false, agent_visible: true
    pub fn user_only() -> Self;    // user_visible: true, agent_visible: false
    pub fn invisible() -> Self;    // user_visible: false, agent_visible: false
}

let internal_msg = Message::assistant()
    .with_text("System processing")
    .with_metadata(MessageMetadata::agent_only());