abyss_plugin_protocol/event/
conversation.rs1use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, Deserialize, Serialize)]
7#[serde(deny_unknown_fields)]
8pub struct Conversation {
9 pub entries: Vec<ConversationEntry>,
12 pub completeness: ContentCompleteness,
14}
15
16#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
18#[serde(deny_unknown_fields)]
19pub struct ConversationEntry {
20 pub role: EntryRole,
22 pub text: String,
25 #[serde(default, skip_serializing_if = "Option::is_none")]
27 pub call_id: Option<String>,
28 #[serde(default, skip_serializing_if = "Option::is_none")]
30 pub name: Option<String>,
31 #[serde(default, skip_serializing_if = "Option::is_none")]
36 pub item_id: Option<String>,
37}
38
39#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
41#[serde(rename_all = "snake_case")]
42#[non_exhaustive]
43pub enum EntryRole {
44 System,
46 Developer,
48 User,
50 Assistant,
52 Reasoning,
54 ToolCall,
56 ToolResult,
58 Unknown,
60}
61
62#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
64#[serde(rename_all = "snake_case")]
65#[non_exhaustive]
66pub enum ContentCompleteness {
67 Complete,
69 Partial,
71 Unsupported,
73}
74
75#[cfg(test)]
76mod tests {
77 use super::{ContentCompleteness, Conversation, ConversationEntry, EntryRole};
78 use serde_json::json;
79
80 #[test]
81 fn roles_use_the_published_snake_case_names() {
82 let roles = [
83 (EntryRole::System, "system"),
84 (EntryRole::Developer, "developer"),
85 (EntryRole::User, "user"),
86 (EntryRole::Assistant, "assistant"),
87 (EntryRole::Reasoning, "reasoning"),
88 (EntryRole::ToolCall, "tool_call"),
89 (EntryRole::ToolResult, "tool_result"),
90 (EntryRole::Unknown, "unknown"),
91 ];
92 for (role, wire) in roles {
93 assert_eq!(serde_json::to_value(role).unwrap(), wire);
94 assert_eq!(
95 serde_json::from_value::<EntryRole>(json!(wire)).unwrap(),
96 role
97 );
98 }
99 assert!(serde_json::from_value::<EntryRole>(json!("tool")).is_err());
100 }
101
102 #[test]
103 fn identities_are_omitted_when_absent() {
104 let conversation = Conversation {
105 entries: vec![
106 ConversationEntry {
107 role: EntryRole::User,
108 text: "run pwd".to_owned(),
109 call_id: None,
110 name: None,
111 item_id: None,
112 },
113 ConversationEntry {
114 role: EntryRole::ToolCall,
115 text: "{\"cmd\":\"pwd\"}".to_owned(),
116 call_id: Some("call_1".to_owned()),
117 name: Some("exec".to_owned()),
118 item_id: Some("fc_1".to_owned()),
119 },
120 ],
121 completeness: ContentCompleteness::Complete,
122 };
123
124 assert_eq!(
125 serde_json::to_value(&conversation).unwrap(),
126 json!({
127 "entries": [
128 {"role": "user", "text": "run pwd"},
129 {"role": "tool_call", "text": "{\"cmd\":\"pwd\"}", "call_id": "call_1", "name": "exec", "item_id": "fc_1"}
130 ],
131 "completeness": "complete"
132 })
133 );
134 }
135
136 #[test]
137 fn undeclared_and_raw_fields_are_rejected() {
138 let conversation = json!({
139 "entries": [{"role": "user", "text": "hello"}],
140 "completeness": "partial"
141 });
142 serde_json::from_value::<Conversation>(conversation.clone())
143 .expect("the structured conversation should decode");
144
145 for (path, value) in [
146 ("messages", json!([])),
147 ("instructions_present", json!(true)),
148 ("policy_omitted", json!(false)),
149 ("payloads", json!([{"output": []}])),
150 ] {
151 let mut undeclared = conversation.clone();
152 undeclared[path] = value;
153 assert!(
154 serde_json::from_value::<Conversation>(undeclared).is_err(),
155 "{path}"
156 );
157 }
158 let mut with_id = conversation;
159 with_id["entries"][0]["id"] = json!("m1");
160 assert!(serde_json::from_value::<Conversation>(with_id).is_err());
161 }
162}