1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! Presentations are ledger entries (docs/design/68-context-engine.md §10):
4. 4//! a validated card is written once, hash-linked like every other entry,
5. 5//! never model-visible raw, and is the single source both the display
6. 6//! channel and a later turn's history read.
7. 7
8. 8use std::path::PathBuf;
9. 9
10. 10use tempfile::tempdir;
11. 11
12. 12use vak_llm::{ContentBlock, Message, Role};
13. 13use vak_session::SessionLog;
14. 14use vak_session::types::{
15. 15 FrozenContract, MessageRecord, PresentationRecord, PresentationSource, SessionHeader,
16. 16 canonicalize_json, payload_digest,
17. 17};
18. 18
19. 19fn header() -> SessionHeader {
20. 20 SessionHeader {
21. 21 agent: None,
22. 22 session_id: "s-test".into(),
23. 23 created_at: chrono::Utc::now(),
24. 24 cwd: PathBuf::from("/tmp/proj"),
25. 25 parent_session_id: None,
26. 26 contract_id: None,
27. 27 work_item_id: None,
28. 28 conversation: None,
29. 29 contract: FrozenContract {
30. 30 app_version: "0.1.0".into(),
31. 31 provider: "anthropic".into(),
32. 32 model: "claude-sonnet-4-5".into(),
33. 33 route_ladder: Vec::new(),
34. 34 route_objective: String::new(),
35. 35 route_annotations: Vec::new(),
36. 36 system_prompt: "system prompt v1".into(),
37. 37 permission_mode: "workspace-write".into(),
38. 38 capabilities: Vec::new(),
39. 39 prompt_layers: Vec::new(),
40. 40 },
41. 41 }
42. 42}
43. 43
44. 44fn chart_payload(summary: &str) -> serde_json::Value {
45. 45 serde_json::json!({
46. 46 "chart_type": "line",
47. 47 "series": [{"name": "s1", "points": [{"x": 1, "y": 2.0}]}],
48. 48 "accessible_summary": summary,
49. 49 })
50. 50}
51. 51
52. 52fn record_for(turn_id: &str, tool_use_id: &str, summary: &str) -> PresentationRecord {
53. 53 let payload = canonicalize_json(&chart_payload(summary));
54. 54 PresentationRecord {
55. 55 turn_id: turn_id.into(),
56. 56 source: PresentationSource::ToolCall {
57. 57 tool_use_id: tool_use_id.into(),
58. 58 },
59. 59 semantic_type: "chart".into(),
60. 60 skill_id: "core".into(),
61. 61 skill_version: "1.0.0".into(),
62. 62 schema_version: 1,
63. 63 payload_digest: payload_digest(&payload),
64. 64 payload,
65. 65 derived_from: Vec::new(),
66. 66 title: "Chart".into(),
67. 67 identity_digest: format!("summary: {summary}"),
68. 68 }
69. 69}
70. 70
71. 71#[test]
72. 72fn a_presentation_entry_round_trips_through_jsonl() {
73. 73 let dir = tempdir().unwrap();
74. 74 let path = dir.path().join("presentation.jsonl");
75. 75 let mut log = SessionLog::create(path.clone(), header()).unwrap();
76. 76 let user = log
77. 77 .append_message(MessageRecord {
78. 78 message: Message::user_text("show me a chart"),
79. 79 meta: None,
80. 80 })
81. 81 .unwrap();
82. 82 let record = record_for(&user.id, "call-1", "rising");
83. 83 let appended = log.append_presentation(record.clone()).unwrap();
84. 84 drop(log);
85. 85
86. 86 // Reopen from disk: the entry must parse back byte-identical in the
87. 87 // fields that matter, proving the JSONL round-trip.
88. 88 let reopened = SessionLog::open_read_only(path).unwrap();
89. 89 let (id, reloaded) = reopened
90. 90 .presentations()
91. 91 .into_iter()
92. 92 .next()
93. 93 .expect("presentation entry must survive a reopen");
94. 94 assert_eq!(id, appended.id);
95. 95 assert_eq!(reloaded.turn_id, record.turn_id);
96. 96 assert_eq!(reloaded.semantic_type, "chart");
97. 97 assert_eq!(reloaded.payload_digest, record.payload_digest);
98. 98 assert_eq!(reloaded.identity_digest, "summary: rising");
99. 99 match &reloaded.source {
100. 100 PresentationSource::ToolCall { tool_use_id } => assert_eq!(tool_use_id, "call-1"),
101. 101 other => panic!("expected ToolCall source, got {other:?}"),
102. 102 }
103. 103}
104. 104
105. 105#[test]
106. 106fn presentations_are_returned_in_chain_order() {
107. 107 let dir = tempdir().unwrap();
108. 108 let path = dir.path().join("order.jsonl");
109. 109 let mut log = SessionLog::create(path, header()).unwrap();
110. 110 let user = log
111. 111 .append_message(MessageRecord {
112. 112 message: Message::user_text("go"),
113. 113 meta: None,
114. 114 })
115. 115 .unwrap();
116. 116 log.append_presentation(record_for(&user.id, "call-1", "first"))
117. 117 .unwrap();
118. 118 log.append_presentation(record_for(&user.id, "call-2", "second"))
119. 119 .unwrap();
120. 120 log.append_presentation(record_for(&user.id, "call-3", "third"))
121. 121 .unwrap();
122. 122
123. 123 let ids: Vec<String> = log
124. 124 .presentations()
125. 125 .into_iter()
126. 126 .map(|(_, record)| match &record.source {
127. 127 PresentationSource::ToolCall { tool_use_id } => tool_use_id.clone(),
128. 128 other => panic!("expected ToolCall source, got {other:?}"),
129. 129 })
130. 130 .collect();
131. 131 assert_eq!(ids, vec!["call-1", "call-2", "call-3"]);
132. 132}
133. 133
134. 134#[test]
135. 135fn has_presentation_dedupes_by_turn_and_payload_digest() {
136. 136 let dir = tempdir().unwrap();
137. 137 let path = dir.path().join("dedupe.jsonl");
138. 138 let mut log = SessionLog::create(path, header()).unwrap();
139. 139 let user = log
140. 140 .append_message(MessageRecord {
141. 141 message: Message::user_text("go"),
142. 142 meta: None,
143. 143 })
144. 144 .unwrap();
145. 145 let record = record_for(&user.id, "call-1", "same");
146. 146 let digest = record.payload_digest.clone();
147. 147 assert!(!log.has_presentation(&user.id, &digest));
148. 148 log.append_presentation(record).unwrap();
149. 149 assert!(log.has_presentation(&user.id, &digest));
150. 150 // A different turn with the same digest is not a duplicate.
151. 151 assert!(!log.has_presentation("some-other-turn", &digest));
152. 152 // A different digest in the same turn is not a duplicate either.
153. 153 assert!(!log.has_presentation(&user.id, "not-the-real-digest"));
154. 154}
155. 155
156. 156#[test]
157. 157fn derive_messages_skips_presentation_entries_like_receipts() {
158. 158 let dir = tempdir().unwrap();
159. 159 let with_path = dir.path().join("with.jsonl");
160. 160 let without_path = dir.path().join("without.jsonl");
161. 161
162. 162 let mut with_log = SessionLog::create(with_path, header()).unwrap();
163. 163 let mut without_log = SessionLog::create(without_path, header()).unwrap();
164. 164
165. 165 for log in [&mut with_log, &mut without_log] {
166. 166 log.append_message(MessageRecord {
167. 167 message: Message::user_text("show me a chart"),
168. 168 meta: None,
169. 169 })
170. 170 .unwrap();
171. 171 log.append_message(MessageRecord {
172. 172 message: Message::assistant(vec![ContentBlock::ToolUse {
173. 173 id: "call-1".into(),
174. 174 name: "emit_chart_card".into(),
175. 175 input: serde_json::json!({"semantic_type": "chart", "payload": chart_payload("flat")}),
176. 176 }]),
177. 177 meta: None,
178. 178 })
179. 179 .unwrap();
180. 180 log.append_message(MessageRecord {
181. 181 message: Message {
182. 182 role: Role::User,
183. 183 content: vec![ContentBlock::tool_result(
184. 184 "call-1",
185. 185 "Card displayed to the user.",
186. 186 )],
187. 187 },
188. 188 meta: None,
189. 189 })
190. 190 .unwrap();
191. 191 }
192. 192
193. 193 let user_entry = with_log.latest_directive_entry_id().unwrap();
194. 194 with_log
195. 195 .append_presentation(record_for(&user_entry, "call-1", "flat"))
196. 196 .unwrap();
197. 197
198. 198 assert_eq!(
199. 199 with_log.derive_messages().len(),
200. 200 without_log.derive_messages().len(),
201. 201 "a Presentation entry must never change the model-visible projection"
202. 202 );
203. 203 // And it genuinely never appears verbatim anywhere in that projection.
204. 204 let serialized: String = with_log
205. 205 .derive_messages()
206. 206 .iter()
207. 207 .map(|m| m.text_content())
208. 208 .collect();
209. 209 assert!(!serialized.contains("identity_digest"));
210. 210}
211. 211
212. 212#[test]
213. 213fn latest_directive_entry_id_ignores_control_messages() {
214. 214 let dir = tempdir().unwrap();
215. 215 let path = dir.path().join("directive.jsonl");
216. 216 let mut log = SessionLog::create(path, header()).unwrap();
217. 217 let first = log
218. 218 .append_message(MessageRecord {
219. 219 message: Message::user_text("first"),
220. 220 meta: None,
221. 221 })
222. 222 .unwrap();
223. 223 assert_eq!(log.latest_directive_entry_id(), Some(first.id.clone()));
224. 224
225. 225 log.append_message(MessageRecord::control(
226. 226 vak_intent::control::ControlKind::GroundingCheck,
227. 227 "redo",
228. 228 ))
229. 229 .unwrap();
230. 230 // A runtime-authored nudge must never be mistaken for the directive.
231. 231 assert_eq!(log.latest_directive_entry_id(), Some(first.id));
232. 232
233. 233 let second = log
234. 234 .append_message(MessageRecord {
235. 235 message: Message::user_text("second"),
236. 236 meta: None,
237. 237 })
238. 238 .unwrap();
239. 239 assert_eq!(log.latest_directive_entry_id(), Some(second.id.clone()));
240. 240
241. 241 // A mid-turn tool-result message is `User` role and non-control, but it
242. 242 // is not a directive: it carries no `Text` block and it carries a
243. 243 // `ToolResult` block. Mistaking it for the directive breaks any
244. 244 // `turn_id` computed from it after the tool call — the fence-path
245. 245 // presentation write does exactly this
246. 246 // (docs/design/68-context-engine.md §10).
247. 247 log.append_message(MessageRecord {
248. 248 message: Message {
249. 249 role: vak_llm::Role::User,
250. 250 content: vec![vak_llm::ContentBlock::tool_result("call-1", "result")],
251. 251 },
252. 252 meta: None,
253. 253 })
254. 254 .unwrap();
255. 255 assert_eq!(log.latest_directive_entry_id(), Some(second.id));
256. 256}
257. 257
258. 258#[test]
259. 259fn non_card_evidence_since_collects_prior_non_card_tool_results_only() {
260. 260 let dir = tempdir().unwrap();
261. 261 let path = dir.path().join("evidence.jsonl");
262. 262 let mut log = SessionLog::create(path, header()).unwrap();
263. 263 let user = log
264. 264 .append_message(MessageRecord {
265. 265 message: Message::user_text("what's the weather, with a chart"),
266. 266 meta: None,
267. 267 })
268. 268 .unwrap();
269. 269 // Evidence-gathering call.
270. 270 log.append_message(MessageRecord {
271. 271 message: Message::assistant(vec![ContentBlock::ToolUse {
272. 272 id: "search-1".into(),
273. 273 name: "web_search".into(),
274. 274 input: serde_json::json!({"query": "weather"}),
275. 275 }]),
276. 276 meta: None,
277. 277 })
278. 278 .unwrap();
279. 279 log.append_message(MessageRecord {
280. 280 message: Message {
281. 281 role: Role::User,
282. 282 content: vec![ContentBlock::tool_result("search-1", "72F and sunny")],
283. 283 },
284. 284 meta: None,
285. 285 })
286. 286 .unwrap();
287. 287 // Card call (not evidence).
288. 288 log.append_message(MessageRecord {
289. 289 message: Message::assistant(vec![ContentBlock::ToolUse {
290. 290 id: "call-1".into(),
291. 291 name: "emit_chart_card".into(),
292. 292 input: serde_json::json!({"semantic_type": "chart", "payload": chart_payload("flat")}),
293. 293 }]),
294. 294 meta: None,
295. 295 })
296. 296 .unwrap();
297. 297 log.append_message(MessageRecord {
298. 298 message: Message {
299. 299 role: Role::User,
300. 300 content: vec![ContentBlock::tool_result(
301. 301 "call-1",
302. 302 "Card displayed to the user.",
303. 303 )],
304. 304 },
305. 305 meta: None,
306. 306 })
307. 307 .unwrap();
308. 308
309. 309 let is_card_tool = |name: &str| name == "emit_chart_card";
310. 310 let evidence = log.non_card_evidence_since(&user.id, is_card_tool);
311. 311 assert_eq!(evidence, vec!["search-1".to_string()]);
312. 312}
313. 313