rigspark-runtime 2.0.0

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use crate::mcp::{McpError, loopback_url};
use futures_util::{StreamExt, stream::BoxStream};
use rmcp::{
    RoleClient,
    model::{ClientJsonRpcMessage, ServerJsonRpcMessage},
    transport::Transport,
};
use tokio_util::sync::CancellationToken;

pub(crate) struct LegacySse {
    client: reqwest_mcp::Client,
    endpoint: url::Url,
    events: Option<BoxStream<'static, Result<sse_stream::Sse, sse_stream::Error>>>,
    cancel: CancellationToken,
}

fn endpoint(base: &url::Url, target: &str) -> Result<url::Url, McpError> {
    if target.len() > 2048 || target.chars().any(char::is_control) {
        return Err(McpError::Invalid);
    }
    let endpoint = base.join(target).map_err(|_| McpError::Invalid)?;
    loopback_url(endpoint.as_str())?;
    if endpoint.origin() != base.origin() || endpoint.fragment().is_some() {
        return Err(McpError::Invalid);
    }
    Ok(endpoint)
}

impl LegacySse {
    pub(crate) async fn open(
        client: reqwest_mcp::Client,
        url: url::Url,
        cancel: &CancellationToken,
    ) -> Result<Self, McpError> {
        loopback_url(url.as_str())?;
        let response = tokio::select! {
            biased;
            _ = cancel.cancelled() => return Err(McpError::Cancelled),
            response = client.get(url.clone()).header("accept", "text/event-stream").send() => response.map_err(|_| McpError::Transport)?,
        };
        if !response.status().is_success()
            || response
                .headers()
                .get("content-type")
                .and_then(|value| value.to_str().ok())
                .and_then(|value| value.split(';').next())
                .is_none_or(|value| value.trim() != "text/event-stream")
        {
            return Err(McpError::Transport);
        }
        let mut events = crate::mcp_framing::events(response.bytes_stream());
        for _ in 0..32 {
            let event = tokio::select! {
                biased;
                _ = cancel.cancelled() => return Err(McpError::Cancelled),
                event = events.next() => event.ok_or(McpError::Transport)?.map_err(|_| McpError::Transport)?,
            };
            if event.event.as_deref() == Some("endpoint") {
                let endpoint = endpoint(&url, event.data.as_deref().ok_or(McpError::Invalid)?)?;
                return Ok(Self {
                    client,
                    endpoint,
                    events: Some(events),
                    cancel: cancel.child_token(),
                });
            }
        }
        Err(McpError::Limit)
    }
}

impl Drop for LegacySse {
    fn drop(&mut self) {
        self.cancel.cancel();
    }
}

impl Transport<RoleClient> for LegacySse {
    type Error = McpError;
    fn send(
        &mut self,
        message: ClientJsonRpcMessage,
    ) -> impl Future<Output = Result<(), McpError>> + Send + 'static {
        let client = self.client.clone();
        let endpoint = self.endpoint.clone();
        let cancel = self.cancel.clone();
        async move {
            let body = serde_json::to_vec(&message).map_err(|_| McpError::Invalid)?;
            if body.len() > 1048576 {
                return Err(McpError::Limit);
            }
            let response = tokio::select! {
                biased;
                _ = cancel.cancelled() => return Err(McpError::Cancelled),
                response = client.post(endpoint).header("content-type", "application/json").body(body).send() => response.map_err(|_| McpError::Transport)?,
            };
            if response.status().is_success() {
                Ok(())
            } else {
                Err(McpError::Transport)
            }
        }
    }
    async fn receive(&mut self) -> Option<ServerJsonRpcMessage> {
        let events = self.events.as_mut()?;
        loop {
            let event = tokio::select! {
                biased;
                _ = self.cancel.cancelled() => return None,
                event = events.next() => event?.ok()?,
            };
            if event.event.as_deref().is_none_or(|kind| kind == "message") {
                return serde_json::from_str(event.data.as_deref()?).ok();
            }
        }
    }
    async fn close(&mut self) -> Result<(), McpError> {
        self.cancel.cancel();
        self.events.take();
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn legacy_endpoint_cannot_change_origin() {
        let base = loopback_url("http://127.0.0.1:3000/sse").unwrap();
        assert_eq!(
            endpoint(&base, "/messages?session=x").unwrap().path(),
            "/messages"
        );
        for target in [
            "http://127.0.0.1:4000/messages",
            "https://example.com/messages",
            "http://localhost:3000/messages",
            "//127.0.0.1:4000/messages",
            "/messages#fragment",
            "http://user@127.0.0.1:3000/messages",
        ] {
            assert!(endpoint(&base, target).is_err(), "{target}");
        }
    }
}