providers-kit 0.0.2

Portable enum-dispatch Kit over multiple model provider APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct SseEvent {
    pub(crate) event: Option<String>,
    pub(crate) data: String,
    pub(crate) id: Option<String>,
    pub(crate) retry: Option<u64>,
}

#[derive(Clone, Debug, Default)]
struct PartialEvent {
    event: Option<String>,
    data_lines: Vec<String>,
    id: Option<String>,
    retry: Option<u64>,
}

impl PartialEvent {
    fn finalize(&mut self) -> Option<SseEvent> {
        if self.event.is_none()
            && self.data_lines.is_empty()
            && self.id.is_none()
            && self.retry.is_none()
        {
            return None;
        }
        let event = SseEvent {
            event: self.event.take(),
            data: self.data_lines.join("\n"),
            id: self.id.take(),
            retry: self.retry.take(),
        };
        self.data_lines.clear();
        Some(event)
    }
}

#[derive(Clone, Debug, Default)]
pub(crate) struct SseParser {
    current: PartialEvent,
}

impl SseParser {
    pub(crate) fn has_pending_data(&self) -> bool {
        !self.current.data_lines.is_empty()
    }

    pub(crate) fn push_line(&mut self, line: &str) -> Option<SseEvent> {
        let line = line.strip_suffix('\r').unwrap_or(line);
        if line.is_empty() {
            return self.current.finalize();
        }
        if line.starts_with(':') {
            return None;
        }

        let (field, value) = match line.split_once(':') {
            Some((field, value)) => (field, value.strip_prefix(' ').unwrap_or(value)),
            None => (line, ""),
        };
        match field {
            "event" => self.current.event = Some(value.to_string()),
            "data" => self.current.data_lines.push(value.to_string()),
            "id" => self.current.id = Some(value.to_string()),
            "retry" => {
                if let Ok(retry) = value.parse::<u64>() {
                    self.current.retry = Some(retry);
                }
            }
            _ => {}
        }
        None
    }
}