1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3use std::sync::{Arc, Mutex};
4. 4
5. 5use tokio_util::sync::CancellationToken;
6. 6
7. 7use vak_core::Core;
8. 8use vak_llm::stream;
9. 9use vak_llm::types::{AssistantMessage, ChatRequest, ContentBlock, Usage};
10. 10use vak_llm::{EventStream, LlmError, Provider};
11. 11
12. 12/// Records every request it receives so tests can assert exactly what the
13. 13/// model would have seen.
14. 14struct Recording {
15. 15 seen: Arc<Mutex<Vec<ChatRequest>>>,
16. 16 reply: String,
17. 17}
18. 18
19. 19#[async_trait::async_trait]
20. 20impl Provider for Recording {
21. 21 fn name(&self) -> &str {
22. 22 "recording"
23. 23 }
24. 24
25. 25 async fn stream(
26. 26 &self,
27. 27 request: ChatRequest,
28. 28 _cancel: CancellationToken,
29. 29 ) -> Result<EventStream, LlmError> {
30. 30 self.seen.lock().unwrap().push(request);
31. 31 let (mut sink, rx) = stream::channel(16);
32. 32 sink.push(stream::StreamEvent::Start {
33. 33 partial: AssistantMessage {
34. 34 content: vec![ContentBlock::text(self.reply.clone())],
35. 35 stop_reason: vak_llm::types::StopReason::EndTurn,
36. 36 usage: Usage::default(),
37. 37 model: "test-model".into(),
38. 38 response_id: None,
39. 39 },
40. 40 });
41. 41 sink.close_message(AssistantMessage {
42. 42 content: vec![ContentBlock::text(self.reply.clone())],
43. 43 stop_reason: vak_llm::types::StopReason::EndTurn,
44. 44 usage: Usage::default(),
45. 45 model: "test-model".into(),
46. 46 response_id: None,
47. 47 })
48. 48 .await;
49. 49 Ok(rx)
50. 50 }
51. 51}
52. 52
53. 53const PNG_B64: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==";
54. 54
55. 55#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
56. 56async fn gateway_inbound_carries_images_to_the_model() {
57. 57 let seen: Arc<Mutex<Vec<ChatRequest>>> = Arc::new(Mutex::new(Vec::new()));
58. 58 let core_provider = Arc::new(Recording {
59. 59 seen: seen.clone(),
60. 60 reply: "I see a tiny red pixel.".into(),
61. 61 });
62. 62
63. 63 let dir = tempfile::tempdir().unwrap();
64. 64 let cwd = dir.path().to_path_buf();
65. 65 // Hermetic against the developer's global config (reflection=true):
66. 66 let _ = std::fs::create_dir_all(cwd.join(".vak"));
67. 67 let _ = std::fs::write(
68. 68 cwd.join(".vak/config.toml"),
69. 69 "[memory]\nreflection = false\n[gateway]\nchat_allowlist_open = true\n",
70. 70 );
71. 71 vak_config::paths::isolate_home_for_tests();
72. 72 let core = Core::new_with_trust(cwd.clone(), true).unwrap();
73. 73 core.set_sessions_home(dir.path().join("home"));
74. 74 core.set_permission_mode(vak_config::PermissionMode::FullAccess);
75. 75 core.set_provider_instance(core_provider);
76. 76 std::mem::forget(dir);
77. 77
78. 78 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
79. 79 let addr = listener.local_addr().unwrap();
80. 80 tokio::spawn(async move {
81. 81 axum::serve(listener, vak_server::gateway_router(core))
82. 82 .await
83. 83 .unwrap();
84. 84 });
85. 85 let base = format!("http://{addr}");
86. 86 let client = reqwest::Client::new();
87. 87
88. 88 let res = client
89. 89 .post(format!("{base}/gateway/inbound"))
90. 90 .json(&serde_json::json!({
91. 91 "surface": "telegram",
92. 92 "chat": "42",
93. 93 "text": "what is this?",
94. 94 "wait": true,
95. 95 "attachments": [
96. 96 {"mime": "image/png", "data": PNG_B64}
97. 97 ]
98. 98 }))
99. 99 .send()
100. 100 .await
101. 101 .unwrap();
102. 102 assert_eq!(res.status(), 200);
103. 103 let body: serde_json::Value = res.json().await.unwrap();
104. 104 assert_eq!(body["text"], "I see a tiny red pixel.");
105. 105
106. 106 // The MODEL saw the image block...
107. 107 {
108. 108 let requests = seen.lock().unwrap();
109. 109 assert_eq!(requests.len(), 1);
110. 110 // Checked across every user message rather than the first one: the
111. 111 // projection also emits runtime control blocks in the user role (the
112. 112 // work-contract summary, and this turn's intent note), so "the first
113. 113 // user message" is not necessarily the user's.
114. 114 assert!(
115. 115 requests[0]
116. 116 .messages
117. 117 .iter()
118. 118 .filter(|m| m.role == vak_llm::Role::User)
119. 119 .any(|m| m.content.iter().any(|b| matches!(
120. 120 b,
121. 121 ContentBlock::Image { source }
122. 122 if source.data == PNG_B64 && source.media_type == "image/png"
123. 123 ))),
124. 124 "image block reached the request"
125. 125 );
126. 126 }
127. 127
128. 128 // ...and the LEDGER stored it verbatim (invariant 1).
129. 129 let sid: String = {
130. 130 // wait:true response carries session_id only on completed; re-read
131. 131 // status for the binding.
132. 132 let st: serde_json::Value = client
133. 133 .get(format!("{base}/gateway/status"))
134. 134 .send()
135. 135 .await
136. 136 .unwrap()
137. 137 .json()
138. 138 .await
139. 139 .unwrap();
140. 140 st["bindings"][0]["session_id"]
141. 141 .as_str()
142. 142 .unwrap()
143. 143 .to_string()
144. 144 };
145. 145 let t: serde_json::Value = client
146. 146 .get(format!("{base}/sessions/{sid}/transcript"))
147. 147 .send()
148. 148 .await
149. 149 .unwrap()
150. 150 .json()
151. 151 .await
152. 152 .unwrap();
153. 153 let raw = serde_json::to_string(&t).unwrap();
154. 154 assert!(
155. 155 raw.contains("iVBORw0KGgo") && raw.contains("\"type\":\"image\""),
156. 156 "image persisted on the ledger"
157. 157 );
158. 158}
159. 159