@lovrozagar/honey 0.1.0

package/src/client-rust/realtime.rs

@@ -0,0 +1,695 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+use crate::errors::Error;
+use bytes::Bytes;
+use serde::{de::DeserializeOwned, Serialize};
+use std::collections::HashMap;
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::pin::Pin;
+
+/// TransportKind tags which transport a connection was opened with.
+/// The behaviour-bearing abstraction is the [`Transport`] trait.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TransportKind {
+    Ws,
+    Sse,
+    Longpoll,
+}
+
+/// ConnectionState mirrors the TS client's connection lifecycle.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ConnectionState {
+    Connecting,
+    Connected,
+    Reconnecting,
+    Disconnected,
+}
+
+/// RealtimeError wraps realtime-specific error variants.
+#[derive(Debug)]
+pub enum RealtimeError {
+    Connect(Error),
+    Send(Error),
+    Recv(Error),
+    Closed,
+    NotImplemented(String),
+}
+
+impl std::fmt::Display for RealtimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RealtimeError::Connect(e) => write!(f, "connect error: {e}"),
+            RealtimeError::Send(e) => write!(f, "send error: {e}"),
+            RealtimeError::Recv(e) => write!(f, "recv error: {e}"),
+            RealtimeError::Closed => write!(f, "connection closed"),
+            RealtimeError::NotImplemented(s) => write!(f, "not implemented: {s}"),
+        }
+    }
+}
+
+impl std::error::Error for RealtimeError {}
+
+/// ResumableConnectionOpts configures reconnect behaviour and auth.
+#[derive(Debug, Clone, Default)]
+pub struct ResumableConnectionOpts {
+    pub reconnect_token: Option<String>,
+    pub protocols: Option<Vec<String>>,
+    pub max_reconnect_attempts: Option<u32>,
+    pub reconnect_delay_ms: Option<u64>,
+    pub last_event_id: Option<String>,
+    pub headers: HashMap<String, String>,
+}
+
+/// TransportOpts is handed to each `Transport::connect`.
+/// Mirrors TS `TransportOpts`; `http_client` lets SSE / longpoll adapters share a pool.
+#[derive(Debug, Clone, Default)]
+pub struct TransportOpts {
+    pub reconnect_token: Option<String>,
+    pub protocols: Option<Vec<String>>,
+    pub last_event_id: Option<String>,
+    pub headers: HashMap<String, String>,
+    pub http_client: Option<reqwest::Client>,
+    pub max_reconnect_attempts: Option<u32>,
+    pub reconnect_delay_ms: Option<u64>,
+}
+
+type WsStream = tokio_tungstenite::WebSocketStream<
+    tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
+>;
+
+type ByteStream = Pin<Box<dyn futures_util::Stream<Item = Result<Bytes, reqwest::Error>> + Send>>;
+
+/// SseState holds mutable state for an active SSE resumable connection.
+pub struct SseState {
+    pub byte_stream: ByteStream,
+    pub buf: Vec<u8>,
+    pub last_event_id: Option<String>,
+    pub retry_hint_ms: u64,
+    /* internal fields for reconnect and send */
+    http_client: reqwest::Client,
+    url: String,
+    extra_headers: HashMap<String, String>,
+    max_reconnect_attempts: u32,
+    reconnect_delay_ms: u64,
+    reconnect_attempts: u32,
+}
+
+/// LongpollState holds mutable state for a long-poll resumable connection.
+pub struct LongpollState {
+    pub client: reqwest::Client,
+    pub url: String,
+    pub cursor: Option<String>,
+    pub pending_events: VecDeque<serde_json::Value>,
+    pub headers: HashMap<String, String>,
+    max_reconnect_attempts: u32,
+    reconnect_delay_ms: u64,
+    reconnect_attempts: u32,
+}
+
+/// TransportConn is the live per-transport connection.
+/// Each built-in adapter returns its own impl (`WsConn`, `SseConn`, `LongpollConn`).
+/// Send-only (not Sync): SSE's byte stream is a `Pin<Box<dyn Stream + Send>>`,
+/// exclusive owned access via `&mut self` is sufficient — no cross-thread sharing needed.
+#[async_trait::async_trait]
+pub trait TransportConn: Send {
+    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError>;
+    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError>;
+    async fn close(&mut self) -> Result<(), RealtimeError>;
+    fn kind(&self) -> TransportKind;
+}
+
+/// Transport is the pluggable adapter trait. Consumers can swap in their own
+/// WS / SSE / longpoll impls by implementing this.
+#[async_trait::async_trait]
+pub trait Transport: Send + Sync + 'static {
+    fn name(&self) -> &'static str;
+    fn kind(&self) -> TransportKind;
+    async fn connect(
+        &self,
+        url: &str,
+        opts: &TransportOpts,
+    ) -> Result<Box<dyn TransportConn>, RealtimeError>;
+}
+
+/* ------------------------------------------------------------------ */
+/*  WS adapter                                                         */
+/* ------------------------------------------------------------------ */
+
+/// WsTransport dials a WebSocket via tokio-tungstenite.
+#[derive(Debug, Default)]
+pub struct WsTransport;
+
+/// WsConn is the live WS connection returned by [`WsTransport::connect`].
+pub struct WsConn {
+    /* WsStream is ~1384 bytes; box to flatten */
+    stream: Box<WsStream>,
+}
+
+#[async_trait::async_trait]
+impl Transport for WsTransport {
+    fn name(&self) -> &'static str {
+        "ws"
+    }
+    fn kind(&self) -> TransportKind {
+        TransportKind::Ws
+    }
+    async fn connect(
+        &self,
+        url: &str,
+        opts: &TransportOpts,
+    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
+        use tokio_tungstenite::tungstenite::client::IntoClientRequest;
+        let ws_url = url.replacen("https://", "wss://", 1).replacen("http://", "ws://", 1);
+        let mut req = ws_url
+            .as_str()
+            .into_client_request()
+            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        if let Some(ref protos) = opts.protocols {
+            if !protos.is_empty() {
+                req.headers_mut().insert(
+                    "Sec-WebSocket-Protocol",
+                    protos
+                        .join(", ")
+                        .parse()
+                        .map_err(|_| RealtimeError::Connect(Error::Other("invalid protocol header".into())))?,
+                );
+            }
+        }
+        for (k, v) in &opts.headers {
+            if let (Ok(name), Ok(val)) = (
+                tokio_tungstenite::tungstenite::http::HeaderName::from_bytes(k.as_bytes()),
+                v.parse::<tokio_tungstenite::tungstenite::http::HeaderValue>(),
+            ) {
+                req.headers_mut().insert(name, val);
+            }
+        }
+        let (stream, _) = tokio_tungstenite::connect_async(req)
+            .await
+            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        Ok(Box::new(WsConn { stream: Box::new(stream) }))
+    }
+}
+
+#[async_trait::async_trait]
+impl TransportConn for WsConn {
+    fn kind(&self) -> TransportKind {
+        TransportKind::Ws
+    }
+    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
+        use futures_util::SinkExt;
+        use tokio_tungstenite::tungstenite::Message;
+        let encoded = serde_json::to_vec(&value)
+            .map_err(|e| RealtimeError::Send(Error::Json(e)))?;
+        self.stream
+            .send(Message::Text(String::from_utf8_lossy(&encoded).into_owned()))
+            .await
+            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))
+    }
+    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
+        use futures_util::StreamExt;
+        use tokio_tungstenite::tungstenite::Message;
+        loop {
+            match self.stream.next().await {
+                None => return Err(RealtimeError::Closed),
+                Some(Err(e)) => return Err(RealtimeError::Recv(Error::Other(e.to_string()))),
+                Some(Ok(Message::Text(t))) => {
+                    return serde_json::from_slice(t.as_bytes())
+                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
+                }
+                Some(Ok(Message::Binary(b))) => {
+                    return serde_json::from_slice(&b)
+                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
+                }
+                Some(Ok(_)) => continue, /* ping/pong/close — skip */
+            }
+        }
+    }
+    async fn close(&mut self) -> Result<(), RealtimeError> {
+        use futures_util::SinkExt;
+        use tokio_tungstenite::tungstenite::protocol::CloseFrame;
+        use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
+        let frame = CloseFrame { code: CloseCode::Normal, reason: "client close".into() };
+        self.stream
+            .send(tokio_tungstenite::tungstenite::Message::Close(Some(frame)))
+            .await
+            .ok();
+        Ok(())
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  SSE adapter                                                        */
+/* ------------------------------------------------------------------ */
+
+/// SseTransport opens a GET / text-event-stream using reqwest.
+#[derive(Debug, Default)]
+pub struct SseTransport {
+    pub http_client: Option<reqwest::Client>,
+}
+
+/// SseConn is the live SSE connection returned by [`SseTransport::connect`].
+pub struct SseConn {
+    state: SseState,
+}
+
+#[async_trait::async_trait]
+impl Transport for SseTransport {
+    fn name(&self) -> &'static str {
+        "sse"
+    }
+    fn kind(&self) -> TransportKind {
+        TransportKind::Sse
+    }
+    async fn connect(
+        &self,
+        url: &str,
+        opts: &TransportOpts,
+    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
+        let client = self
+            .http_client
+            .clone()
+            .or_else(|| opts.http_client.clone())
+            .unwrap_or_else(reqwest::Client::new);
+        let state = build_sse_state(url.to_string(), client, opts)
+            .await
+            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        Ok(Box::new(SseConn { state }))
+    }
+}
+
+#[async_trait::async_trait]
+impl TransportConn for SseConn {
+    fn kind(&self) -> TransportKind {
+        TransportKind::Sse
+    }
+    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
+        /* SSE is server → client; send POSTs back to the endpoint. */
+        self.state
+            .http_client
+            .post(self.state.url.as_str())
+            .json(&value)
+            .send()
+            .await
+            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        Ok(())
+    }
+    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
+        use crate::sse::{find_double_newline, parse_sse_block};
+        use futures_util::StreamExt;
+        loop {
+            if let Some((start, end)) = find_double_newline(&self.state.buf) {
+                let block = self.state.buf[..start].to_vec();
+                self.state.buf.drain(..end);
+                let block_str = String::from_utf8_lossy(&block);
+                let trimmed = block_str.trim();
+                if !trimmed.is_empty() {
+                    if let Some(ev) = parse_sse_block(trimmed) {
+                        if !ev.id.is_empty() {
+                            self.state.last_event_id = Some(ev.id.clone());
+                        }
+                        if ev.retry > 0 {
+                            self.state.retry_hint_ms = ev.retry as u64;
+                        }
+                        return serde_json::from_str(&ev.data)
+                            .map_err(|e| RealtimeError::Recv(Error::Json(e)));
+                    }
+                }
+                continue;
+            }
+            match self.state.byte_stream.next().await {
+                Some(Ok(bytes)) => {
+                    self.state.buf.extend_from_slice(&bytes);
+                }
+                Some(Err(e)) => {
+                    return Err(RealtimeError::Recv(Error::Other(e.to_string())));
+                }
+                None => {
+                    /* stream ended — attempt transport-level reconnect */
+                    self.state.reconnect_attempts += 1;
+                    if self.state.reconnect_attempts >= self.state.max_reconnect_attempts {
+                        return Err(RealtimeError::Closed);
+                    }
+                    let delay_ms = if self.state.retry_hint_ms > 0 {
+                        self.state.retry_hint_ms
+                    } else {
+                        self.state.reconnect_delay_ms
+                    };
+                    tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await;
+                    let reopen_opts = TransportOpts {
+                        last_event_id: self.state.last_event_id.clone(),
+                        headers: self.state.extra_headers.clone(),
+                        max_reconnect_attempts: Some(self.state.max_reconnect_attempts),
+                        reconnect_delay_ms: Some(self.state.reconnect_delay_ms),
+                        ..Default::default()
+                    };
+                    let new_state = build_sse_state(
+                        self.state.url.clone(),
+                        self.state.http_client.clone(),
+                        &reopen_opts,
+                    )
+                    .await
+                    .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+                    self.state.byte_stream = new_state.byte_stream;
+                    self.state.buf.clear();
+                }
+            }
+        }
+    }
+    async fn close(&mut self) -> Result<(), RealtimeError> {
+        /* reqwest stream is dropped with self; nothing to do explicitly. */
+        Ok(())
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Longpoll adapter                                                   */
+/* ------------------------------------------------------------------ */
+
+/// LongpollTransport opens a long-poll GET loop using reqwest.
+#[derive(Debug, Default)]
+pub struct LongpollTransport {
+    pub http_client: Option<reqwest::Client>,
+}
+
+/// LongpollConn is the live longpoll connection returned by [`LongpollTransport::connect`].
+pub struct LongpollConn {
+    state: LongpollState,
+}
+
+#[async_trait::async_trait]
+impl Transport for LongpollTransport {
+    fn name(&self) -> &'static str {
+        "longpoll"
+    }
+    fn kind(&self) -> TransportKind {
+        TransportKind::Longpoll
+    }
+    async fn connect(
+        &self,
+        url: &str,
+        opts: &TransportOpts,
+    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
+        let client = self
+            .http_client
+            .clone()
+            .or_else(|| opts.http_client.clone())
+            .unwrap_or_else(reqwest::Client::new);
+        let state = LongpollState {
+            client,
+            url: url.to_string(),
+            cursor: None,
+            pending_events: VecDeque::new(),
+            headers: opts.headers.clone(),
+            max_reconnect_attempts: opts.max_reconnect_attempts.unwrap_or(5),
+            reconnect_delay_ms: opts.reconnect_delay_ms.unwrap_or(1000),
+            reconnect_attempts: 0,
+        };
+        Ok(Box::new(LongpollConn { state }))
+    }
+}
+
+#[async_trait::async_trait]
+impl TransportConn for LongpollConn {
+    fn kind(&self) -> TransportKind {
+        TransportKind::Longpoll
+    }
+    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
+        self.state
+            .client
+            .post(self.state.url.as_str())
+            .json(&value)
+            .send()
+            .await
+            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        Ok(())
+    }
+    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
+        loop {
+            if let Some(ev) = self.state.pending_events.pop_front() {
+                return Ok(ev);
+            }
+            let request_url = match &self.state.cursor {
+                Some(c) => format!("{}?cursor={}", self.state.url, c),
+                None => self.state.url.clone(),
+            };
+            let mut req = self.state.client.get(request_url.as_str());
+            for (k, v) in &self.state.headers {
+                req = req.header(k.as_str(), v.as_str());
+            }
+            match req.send().await {
+                Err(e) => {
+                    self.state.reconnect_attempts += 1;
+                    if self.state.reconnect_attempts >= self.state.max_reconnect_attempts {
+                        return Err(RealtimeError::Recv(Error::Other(e.to_string())));
+                    }
+                    tokio::time::sleep(tokio::time::Duration::from_millis(
+                        self.state.reconnect_delay_ms,
+                    ))
+                    .await;
+                }
+                Ok(resp) => {
+                    let bytes = resp
+                        .bytes()
+                        .await
+                        .map_err(|e| RealtimeError::Recv(Error::Other(e.to_string())))?;
+
+                    #[derive(serde::Deserialize)]
+                    struct PollResponse {
+                        #[serde(default)]
+                        events: Vec<serde_json::Value>,
+                        cursor: Option<String>,
+                    }
+
+                    let parsed: PollResponse = serde_json::from_slice(&bytes)
+                        .map_err(|e| RealtimeError::Recv(Error::Json(e)))?;
+                    self.state.cursor = parsed.cursor;
+                    for ev in parsed.events {
+                        self.state.pending_events.push_back(ev);
+                    }
+                }
+            }
+        }
+    }
+    async fn close(&mut self) -> Result<(), RealtimeError> {
+        /* no persistent connection to tear down */
+        Ok(())
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  ResumableConnection                                                */
+/* ------------------------------------------------------------------ */
+
+/// ResumableConnection is a typed, self-reconnecting realtime channel.
+/// Send/Recv type parameters encode the message types flowing in each direction.
+pub struct ResumableConnection<Send, Recv> {
+    state: ConnectionState,
+    url: String,
+    opts: ResumableConnectionOpts,
+    transport_opts: TransportOpts,
+    transports: Vec<Box<dyn Transport>>,
+    conn: Option<Box<dyn TransportConn>>,
+    proven_index: Option<usize>,
+    reconnect_attempts: u32,
+    _send: PhantomData<Send>,
+    _recv: PhantomData<Recv>,
+}
+
+impl<SendMsg, RecvMsg> ResumableConnection<SendMsg, RecvMsg>
+where
+    SendMsg: Serialize,
+    RecvMsg: DeserializeOwned,
+{
+    /// connect tries each transport in order, memoizes the first that succeeds,
+    /// and returns the active ResumableConnection.
+    pub async fn connect(
+        url: String,
+        opts: ResumableConnectionOpts,
+        transports: Vec<Box<dyn Transport>>,
+    ) -> Result<Self, RealtimeError> {
+        if transports.is_empty() {
+            return Err(RealtimeError::Connect(Error::Other(
+                "no transports configured".into(),
+            )));
+        }
+        let transport_opts = TransportOpts {
+            reconnect_token: opts.reconnect_token.clone(),
+            protocols: opts.protocols.clone(),
+            last_event_id: opts.last_event_id.clone(),
+            headers: opts.headers.clone(),
+            http_client: None,
+            max_reconnect_attempts: opts.max_reconnect_attempts,
+            reconnect_delay_ms: opts.reconnect_delay_ms,
+        };
+        let mut rc = ResumableConnection {
+            state: ConnectionState::Connecting,
+            url,
+            opts,
+            transport_opts,
+            transports,
+            conn: None,
+            proven_index: None,
+            reconnect_attempts: 0,
+            _send: PhantomData,
+            _recv: PhantomData,
+        };
+        rc.open_chain().await?;
+        Ok(rc)
+    }
+
+    /// connect_with_defaults builds the canonical transport chain
+    /// `[WsTransport, SseTransport, LongpollTransport]` and calls [`Self::connect`].
+    /// Convenience entry point for consumers that don't need a custom chain.
+    pub async fn connect_with_defaults(
+        url: String,
+        opts: ResumableConnectionOpts,
+    ) -> Result<Self, RealtimeError> {
+        let transports: Vec<Box<dyn Transport>> = vec![
+            Box::new(WsTransport),
+            Box::new(SseTransport::default()),
+            Box::new(LongpollTransport::default()),
+        ];
+        Self::connect(url, opts, transports).await
+    }
+
+    /// state returns the current connection lifecycle state.
+    pub fn state(&self) -> &ConnectionState {
+        &self.state
+    }
+
+    /// proven_transport returns the kind of the last successfully-opened transport.
+    pub fn proven_transport(&self) -> Option<TransportKind> {
+        self.proven_index
+            .and_then(|i| self.transports.get(i))
+            .map(|t| t.kind())
+    }
+
+    /// current_transport returns the kind of the currently-active transport.
+    pub fn current_transport(&self) -> Option<TransportKind> {
+        self.conn.as_ref().map(|c| c.kind())
+    }
+
+    /// send serialises a message and writes it to the active transport.
+    pub async fn send(&mut self, data: &SendMsg) -> Result<(), RealtimeError> {
+        let conn = self.conn.as_mut().ok_or(RealtimeError::Closed)?;
+        let v = serde_json::to_value(data).map_err(|e| RealtimeError::Send(Error::Json(e)))?;
+        conn.send_json(v).await
+    }
+
+    /// recv reads the next message from the transport and deserialises it.
+    /// On transport failure: invalidates `proven_index`, sleeps `reconnect_delay_ms`,
+    /// re-runs `open_chain()` (full fallback sequence). Mirrors Python `_iter`
+    /// and TS `createResumableConnection`'s recv loop. Gives up after
+    /// `max_reconnect_attempts` attempts and returns the last error.
+    pub async fn recv(&mut self) -> Result<RecvMsg, RealtimeError> {
+        let max_attempts = self.opts.max_reconnect_attempts.unwrap_or(5);
+        let delay_ms = self.opts.reconnect_delay_ms.unwrap_or(1000);
+        loop {
+            let result = {
+                let conn = self.conn.as_mut().ok_or(RealtimeError::Closed)?;
+                conn.recv_json().await
+            };
+            match result {
+                Ok(v) => {
+                    self.reconnect_attempts = 0;
+                    return serde_json::from_value(v)
+                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
+                }
+                Err(err) => {
+                    self.reconnect_attempts += 1;
+                    if max_attempts > 0 && self.reconnect_attempts > max_attempts {
+                        self.state = ConnectionState::Disconnected;
+                        return Err(err);
+                    }
+                    self.state = ConnectionState::Reconnecting;
+                    /* drop the dead conn + invalidate proven so chain retries from the top */
+                    if let Some(mut c) = self.conn.take() {
+                        let _ = c.close().await;
+                    }
+                    self.proven_index = None;
+                    if delay_ms > 0 {
+                        tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await;
+                    }
+                    if let Err(open_err) = self.open_chain().await {
+                        self.state = ConnectionState::Disconnected;
+                        return Err(open_err);
+                    }
+                }
+            }
+        }
+    }
+
+    /// close gracefully shuts down the connection.
+    pub async fn close(&mut self) -> Result<(), RealtimeError> {
+        if let Some(mut c) = self.conn.take() {
+            let _ = c.close().await;
+        }
+        self.state = ConnectionState::Disconnected;
+        Ok(())
+    }
+
+    async fn open_chain(&mut self) -> Result<(), RealtimeError> {
+        /* Try proven first if set */
+        if let Some(i) = self.proven_index {
+            if let Some(t) = self.transports.get(i) {
+                if let Ok(c) = t.connect(&self.url, &self.transport_opts).await {
+                    self.conn = Some(c);
+                    self.state = ConnectionState::Connected;
+                    return Ok(());
+                }
+            }
+        }
+        /* Full chain */
+        let mut last_err: Option<RealtimeError> = None;
+        for (i, t) in self.transports.iter().enumerate() {
+            match t.connect(&self.url, &self.transport_opts).await {
+                Ok(c) => {
+                    self.conn = Some(c);
+                    self.proven_index = Some(i);
+                    self.state = ConnectionState::Connected;
+                    return Ok(());
+                }
+                Err(e) => last_err = Some(e),
+            }
+        }
+        Err(last_err.unwrap_or(RealtimeError::Connect(Error::Other(
+            "all transports failed".into(),
+        ))))
+    }
+
+}
+
+async fn build_sse_state(
+    url: String,
+    http_client: reqwest::Client,
+    opts: &TransportOpts,
+) -> Result<SseState, reqwest::Error> {
+    let mut req_builder = http_client
+        .get(url.as_str())
+        .header("Accept", "text/event-stream");
+    if let Some(ref last_event_id) = opts.last_event_id {
+        req_builder = req_builder.header("Last-Event-ID", last_event_id.as_str());
+    }
+    for (k, v) in &opts.headers {
+        req_builder = req_builder.header(k.as_str(), v.as_str());
+    }
+    let resp = req_builder.send().await?;
+    let reconnect_delay_ms = opts.reconnect_delay_ms.unwrap_or(1000);
+    let max_reconnect_attempts = opts.max_reconnect_attempts.unwrap_or(5);
+    let last_event_id = opts.last_event_id.clone();
+    let extra_headers = opts.headers.clone();
+    let byte_stream: ByteStream = Box::pin(resp.bytes_stream());
+    Ok(SseState {
+        byte_stream,
+        buf: Vec::new(),
+        last_event_id,
+        retry_hint_ms: reconnect_delay_ms,
+        http_client,
+        url,
+        extra_headers,
+        max_reconnect_attempts,
+        reconnect_delay_ms,
+        reconnect_attempts: 0,
+    })
+}