use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Conversation {
pub messages: Vec<ConversationMessage>,
pub instructions_present: bool,
pub completeness: ContentCompleteness,
pub policy_omitted: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ConversationMessage {
pub id: Option<String>,
pub role: MessageRole,
pub text: String,
}
#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum MessageRole {
System,
Developer,
User,
Assistant,
Reasoning,
Tool,
Unknown,
}
#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ContentCompleteness {
Complete,
Partial,
Unsupported,
}
#[cfg(test)]
mod tests {
use super::{ContentCompleteness, Conversation, ConversationMessage, MessageRole};
use serde_json::json;
#[test]
fn roles_use_the_published_snake_case_names() {
let roles = [
(MessageRole::System, "system"),
(MessageRole::Developer, "developer"),
(MessageRole::User, "user"),
(MessageRole::Assistant, "assistant"),
(MessageRole::Reasoning, "reasoning"),
(MessageRole::Tool, "tool"),
(MessageRole::Unknown, "unknown"),
];
for (role, wire) in roles {
assert_eq!(serde_json::to_value(role).unwrap(), wire);
assert_eq!(
serde_json::from_value::<MessageRole>(json!(wire)).unwrap(),
role
);
}
assert!(
serde_json::from_value::<MessageRole>(json!("request")).is_err(),
"the former placeholder role is replaced by `unknown`"
);
}
#[test]
fn anthropic_thinking_is_a_reasoning_message_sharing_the_message_id() {
let conversation = Conversation {
messages: vec![
ConversationMessage {
id: Some("msg_1".to_owned()),
role: MessageRole::Reasoning,
text: "plan".to_owned(),
},
ConversationMessage {
id: Some("msg_1".to_owned()),
role: MessageRole::Assistant,
text: "hi".to_owned(),
},
],
instructions_present: false,
completeness: ContentCompleteness::Complete,
policy_omitted: false,
};
assert_eq!(
serde_json::to_value(&conversation).unwrap(),
json!({
"messages": [
{"id": "msg_1", "role": "reasoning", "text": "plan"},
{"id": "msg_1", "role": "assistant", "text": "hi"}
],
"instructions_present": false,
"completeness": "complete",
"policy_omitted": false
})
);
}
#[test]
fn raw_content_carriers_are_rejected() {
let conversation = json!({
"messages": [{"id": null, "role": "user", "text": "hello"}],
"instructions_present": true,
"completeness": "partial",
"policy_omitted": false
});
serde_json::from_value::<Conversation>(conversation.clone())
.expect("the structured conversation should decode");
let mut with_payloads = conversation.clone();
with_payloads["payloads"] = json!([{"output": []}]);
assert!(serde_json::from_value::<Conversation>(with_payloads).is_err());
let mut with_blocks = conversation;
with_blocks["messages"][0]["blocks"] = json!([{"type": "text", "text": "hello"}]);
assert!(serde_json::from_value::<Conversation>(with_blocks).is_err());
}
}