1use std::collections::VecDeque;
2use std::pin::Pin;
3use std::task::{Context, Poll};
4
5use bytes::Bytes;
6use futures_core::Stream;
7use futures_util::StreamExt;
8use futures_util::stream::{self, BoxStream};
9use serde_json::Value;
10
11use crate::Error;
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub struct SseFrame {
15 pub id: Option<String>,
16 pub event: Option<String>,
17 pub data: String,
18}
19
20#[derive(Debug, Default)]
21pub struct SseDecoder {
22 buffer: Vec<u8>,
23}
24
25impl SseDecoder {
26 pub fn new() -> Self {
27 Self::default()
28 }
29
30 pub fn push(&mut self, chunk: &[u8]) -> Result<Vec<SseFrame>, Error> {
31 self.buffer.extend_from_slice(chunk);
32 self.drain(false)
33 }
34
35 pub fn finish(&mut self) -> Result<Vec<SseFrame>, Error> {
36 self.drain(true)
37 }
38
39 fn drain(&mut self, flush: bool) -> Result<Vec<SseFrame>, Error> {
40 let mut frames = Vec::new();
41 while let Some((end, separator_len)) = find_separator(&self.buffer) {
42 let raw: Vec<u8> = self.buffer.drain(..end + separator_len).collect();
43 if let Some(frame) = parse_frame(&raw[..end])? {
44 frames.push(frame);
45 }
46 }
47
48 if flush && !self.buffer.is_empty() {
49 let raw = std::mem::take(&mut self.buffer);
50 if let Some(frame) = parse_frame(&raw)? {
51 frames.push(frame);
52 }
53 }
54 Ok(frames)
55 }
56}
57
58fn find_separator(input: &[u8]) -> Option<(usize, usize)> {
59 let mut i = 0;
60 while i < input.len() {
61 if input.get(i..i + 4) == Some(b"\r\n\r\n") {
62 return Some((i, 4));
63 }
64 if input.get(i..i + 2) == Some(b"\n\n") {
65 return Some((i, 2));
66 }
67 i += 1;
68 }
69 None
70}
71
72fn parse_frame(raw: &[u8]) -> Result<Option<SseFrame>, Error> {
73 let text = std::str::from_utf8(raw)
74 .map_err(|error| Error::Sse(format!("invalid UTF-8 in SSE frame: {error}")))?;
75 let normalized = text.replace("\r\n", "\n");
76 let mut id = None;
77 let mut event = None;
78 let mut data = Vec::new();
79
80 for line in normalized.lines() {
81 if line.starts_with(':') || line.is_empty() {
82 continue;
83 }
84 let (field, value) = line
85 .split_once(':')
86 .map(|(field, value)| (field, value.strip_prefix(' ').unwrap_or(value)))
87 .unwrap_or((line, ""));
88 match field {
89 "id" => id = Some(value.to_owned()),
90 "event" => event = Some(value.to_owned()),
91 "data" => data.push(value),
92 _ => {}
93 }
94 }
95
96 if data.is_empty() {
97 return Ok(None);
98 }
99
100 Ok(Some(SseFrame {
101 id,
102 event,
103 data: data.join("\n"),
104 }))
105}
106
107#[derive(Debug, Clone, Copy, PartialEq, Eq)]
108#[non_exhaustive]
109pub enum KnownEventKind {
110 SessionCreated,
111 SessionUpdated,
112 SessionStatus,
113 SessionError,
114 PermissionAsked,
115 PermissionUpdated,
116}
117
118impl KnownEventKind {
119 fn from_type(value: &str) -> Option<Self> {
120 match value {
121 "session.created" => Some(Self::SessionCreated),
122 "session.updated" => Some(Self::SessionUpdated),
123 "session.status" => Some(Self::SessionStatus),
124 "session.error" => Some(Self::SessionError),
125 "permission.asked" => Some(Self::PermissionAsked),
126 "permission.updated" => Some(Self::PermissionUpdated),
127 _ => None,
128 }
129 }
130}
131
132#[derive(Debug, Clone, PartialEq)]
133pub struct KnownEvent {
134 pub kind: KnownEventKind,
135 pub event_type: String,
136 pub properties: Value,
137 pub value: Value,
138}
139
140#[derive(Debug, Clone, PartialEq)]
141#[non_exhaustive]
142pub enum EventData {
143 Known(KnownEvent),
144 Unknown(Value),
145 Malformed { raw: String, error: String },
146}
147
148#[derive(Debug, Clone, PartialEq)]
149pub struct OpenCodeEvent {
150 pub id: Option<String>,
151 pub event: Option<String>,
152 pub data: EventData,
153}
154
155impl OpenCodeEvent {
156 fn from_frame(frame: SseFrame) -> Self {
157 let data = match serde_json::from_str::<Value>(&frame.data) {
158 Ok(value) => {
159 let event_type = value.get("type").and_then(Value::as_str);
160 match event_type.and_then(KnownEventKind::from_type) {
161 Some(kind) => EventData::Known(KnownEvent {
162 kind,
163 event_type: event_type.unwrap_or_default().to_owned(),
164 properties: value.get("properties").cloned().unwrap_or(Value::Null),
165 value,
166 }),
167 None => EventData::Unknown(value),
168 }
169 }
170 Err(error) => EventData::Malformed {
171 raw: frame.data,
172 error: error.to_string(),
173 },
174 };
175 Self {
176 id: frame.id,
177 event: frame.event,
178 data,
179 }
180 }
181}
182
183pub struct EventStream {
184 inner: BoxStream<'static, Result<OpenCodeEvent, Error>>,
185}
186
187impl Stream for EventStream {
188 type Item = Result<OpenCodeEvent, Error>;
189
190 fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
191 Pin::new(&mut self.inner).poll_next(cx)
192 }
193}
194
195type ByteStream = BoxStream<'static, Result<Bytes, reqwest::Error>>;
196
197struct State {
198 bytes: ByteStream,
199 decoder: SseDecoder,
200 queued: VecDeque<OpenCodeEvent>,
201 finished: bool,
202}
203
204pub(crate) fn event_stream_from_response(response: reqwest::Response) -> EventStream {
205 let state = State {
206 bytes: response.bytes_stream().boxed(),
207 decoder: SseDecoder::new(),
208 queued: VecDeque::new(),
209 finished: false,
210 };
211 let inner = stream::unfold(state, |mut state| async move {
212 loop {
213 if let Some(event) = state.queued.pop_front() {
214 return Some((Ok(event), state));
215 }
216 if state.finished {
217 return None;
218 }
219 match state.bytes.next().await {
220 Some(Ok(chunk)) => match state.decoder.push(&chunk) {
221 Ok(frames) => {
222 state
223 .queued
224 .extend(frames.into_iter().map(OpenCodeEvent::from_frame));
225 }
226 Err(error) => return Some((Err(error), state)),
227 },
228 Some(Err(error)) => return Some((Err(Error::Http(error)), state)),
229 None => {
230 state.finished = true;
231 match state.decoder.finish() {
232 Ok(frames) => state
233 .queued
234 .extend(frames.into_iter().map(OpenCodeEvent::from_frame)),
235 Err(error) => return Some((Err(error), state)),
236 }
237 }
238 }
239 }
240 })
241 .boxed();
242 EventStream { inner }
243}
244
245#[cfg(test)]
246mod tests {
247 use super::*;
248
249 #[test]
250 fn fragmented_and_multiple_events() {
251 let mut decoder = SseDecoder::new();
252 assert!(
253 decoder
254 .push(b"data: {\"type\":\"session.")
255 .unwrap()
256 .is_empty()
257 );
258 let frames = decoder
259 .push(b"created\"}\n\ndata: {\"type\":\"future\"}\n\n")
260 .unwrap();
261 assert_eq!(frames.len(), 2);
262 assert!(frames[0].data.contains("session.created"));
263 assert!(frames[1].data.contains("future"));
264 }
265
266 #[test]
267 fn multiline_and_crlf() {
268 let mut decoder = SseDecoder::new();
269 let frames = decoder
270 .push(b"id: 1\r\nevent: message\r\ndata: first\r\ndata: second\r\n\r\n")
271 .unwrap();
272 assert_eq!(
273 frames,
274 vec![SseFrame {
275 id: Some("1".into()),
276 event: Some("message".into()),
277 data: "first\nsecond".into(),
278 }]
279 );
280 }
281
282 #[test]
283 fn malformed_json_is_data_not_stream_failure() {
284 let event = OpenCodeEvent::from_frame(SseFrame {
285 id: None,
286 event: None,
287 data: "{nope".into(),
288 });
289 assert!(matches!(event.data, EventData::Malformed { .. }));
290 }
291
292 #[test]
293 fn unknown_event_is_forward_compatible() {
294 let event = OpenCodeEvent::from_frame(SseFrame {
295 id: None,
296 event: None,
297 data: r#"{"type":"future.event","properties":{"x":1}}"#.into(),
298 });
299 assert!(matches!(event.data, EventData::Unknown(_)));
300 }
301
302 #[test]
303 fn finish_flushes_final_frame() {
304 let mut decoder = SseDecoder::new();
305 assert!(
306 decoder
307 .push(b"data: {\"type\":\"session.status\"}")
308 .unwrap()
309 .is_empty()
310 );
311 assert_eq!(decoder.finish().unwrap().len(), 1);
312 }
313}