Skip to main content

unofficial_opencode_sdk/
sse.rs

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}