rigspark-runtime 3.0.8

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use futures_util::stream::BoxStream;
use http::{HeaderName, HeaderValue};
use rmcp::{
    model::ClientJsonRpcMessage,
    transport::streamable_http_client::{
        SseError, StreamableHttpClient, StreamableHttpError, StreamableHttpPostResponse,
    },
};
use std::{collections::HashMap, sync::Arc};

#[derive(Clone)]
pub(crate) struct BoundedHttp(pub reqwest_mcp::Client);
type Error = StreamableHttpError<std::io::Error>;
fn invalid() -> Error {
    Error::Io(std::io::Error::other("invalid MCP HTTP response"))
}
impl BoundedHttp {
    fn request(
        &self,
        method: http::Method,
        uri: &str,
        session: Option<&str>,
        auth: Option<String>,
        headers: HashMap<HeaderName, HeaderValue>,
    ) -> Result<reqwest_mcp::RequestBuilder, Error> {
        crate::mcp::loopback_url(uri).map_err(|_| invalid())?;
        if auth.is_some()
            || headers.len() > 67
            || headers
                .iter()
                .map(|(name, value)| name.as_str().len() + value.as_bytes().len())
                .sum::<usize>()
                > 16384
            || headers.iter().any(|(name, value)| {
                (!matches!(
                    name.as_str(),
                    "mcp-protocol-version" | "mcp-method" | "mcp-name"
                ) && !name.as_str().starts_with("mcp-param-"))
                    || name.as_str().len() > 256
                    || value.as_bytes().len() > 4096
            })
        {
            return Err(invalid());
        }
        let mut request = self
            .0
            .request(method, uri)
            .header("accept", "application/json, text/event-stream");
        for (name, mut value) in headers {
            value.set_sensitive(true);
            request = request.header(name, value);
        }
        if let Some(session) = session {
            if session.is_empty()
                || session.len() > 4096
                || !session.bytes().all(|byte| (0x21..=0x7e).contains(&byte))
            {
                return Err(invalid());
            }
            request = request.header("mcp-session-id", session);
        }
        Ok(request)
    }
}
impl StreamableHttpClient for BoundedHttp {
    type Error = std::io::Error;
    async fn post_message(
        &self,
        uri: Arc<str>,
        message: ClientJsonRpcMessage,
        session: Option<Arc<str>>,
        auth: Option<String>,
        headers: HashMap<HeaderName, HeaderValue>,
    ) -> Result<StreamableHttpPostResponse, Error> {
        let body = serde_json::to_vec(&message).map_err(|_| invalid())?;
        if body.len() > 1048576 {
            return Err(invalid());
        }
        let response = self
            .request(http::Method::POST, &uri, session.as_deref(), auth, headers)?
            .header("content-type", "application/json")
            .body(body)
            .send()
            .await
            .map_err(|_| invalid())?;
        if [202, 204].contains(&response.status().as_u16()) {
            return Ok(StreamableHttpPostResponse::Accepted);
        }
        if response.status().as_u16() == 404 && session.is_some() {
            return Err(Error::SessionExpired);
        }
        if !response.status().is_success() {
            return Err(invalid());
        }
        let session = response
            .headers()
            .get("mcp-session-id")
            .map(|value| value.to_str().map(str::to_owned))
            .transpose()
            .map_err(|_| invalid())?;
        if session.as_ref().is_some_and(|value| {
            value.is_empty()
                || value.len() > 4096
                || !value.bytes().all(|byte| (0x21..=0x7e).contains(&byte))
        }) {
            return Err(invalid());
        }
        let kind = response
            .headers()
            .get("content-type")
            .and_then(|value| value.to_str().ok())
            .unwrap_or("")
            .split(';')
            .next()
            .unwrap_or("")
            .trim();
        if kind == "text/event-stream" {
            return Ok(StreamableHttpPostResponse::Sse(
                crate::mcp_framing::events(response.bytes_stream()),
                session,
            ));
        }
        if kind != "application/json" {
            return Err(invalid());
        }
        let bytes = crate::mcp_framing::json_body(response.bytes_stream())
            .await
            .map_err(Error::Io)?;
        let message = serde_json::from_slice(&bytes).map_err(|_| invalid())?;
        Ok(StreamableHttpPostResponse::Json(message, session))
    }
    async fn delete_session(
        &self,
        uri: Arc<str>,
        session: Arc<str>,
        auth: Option<String>,
        headers: HashMap<HeaderName, HeaderValue>,
    ) -> Result<(), Error> {
        let response = self
            .request(http::Method::DELETE, &uri, Some(&session), auth, headers)?
            .send()
            .await
            .map_err(|_| invalid())?;
        if response.status().is_success() || matches!(response.status().as_u16(), 404 | 405) {
            Ok(())
        } else {
            Err(invalid())
        }
    }
    async fn get_stream(
        &self,
        uri: Arc<str>,
        session: Option<Arc<str>>,
        last: Option<String>,
        auth: Option<String>,
        headers: HashMap<HeaderName, HeaderValue>,
    ) -> Result<BoxStream<'static, Result<sse_stream::Sse, SseError>>, Error> {
        let mut request =
            self.request(http::Method::GET, &uri, session.as_deref(), auth, headers)?;
        if let Some(last) = last {
            if last.len() > 4096 {
                return Err(invalid());
            }
            request = request.header("last-event-id", last);
        }
        let response = request.send().await.map_err(|_| invalid())?;
        if response.status().as_u16() == 405 {
            return Err(Error::ServerDoesNotSupportSse);
        }
        if response.status().as_u16() == 404 && session.is_some() {
            return Err(Error::SessionExpired);
        }
        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(invalid());
        }
        Ok(crate::mcp_framing::events(response.bytes_stream()))
    }
}

#[cfg(test)]
mod header_tests {
    use super::*;
    #[test]
    fn standard_sdk_headers_are_allowed_but_routing_and_credentials_are_not() {
        let client = BoundedHttp(reqwest_mcp::Client::builder().no_proxy().build().unwrap());
        let headers = [
            "mcp-protocol-version",
            "mcp-method",
            "mcp-name",
            "mcp-param-region",
        ]
        .into_iter()
        .map(|name| {
            (
                HeaderName::from_static(name),
                HeaderValue::from_static("fixture"),
            )
        })
        .collect();
        assert!(
            client
                .request(
                    http::Method::POST,
                    "http://127.0.0.1:3000/mcp",
                    None,
                    None,
                    headers
                )
                .is_ok()
        );
        for name in ["host", "authorization", "cookie", "x-forwarded-host"] {
            let headers = [(
                HeaderName::from_static(name),
                HeaderValue::from_static("fixture"),
            )]
            .into();
            assert!(
                client
                    .request(
                        http::Method::POST,
                        "http://127.0.0.1:3000/mcp",
                        None,
                        None,
                        headers
                    )
                    .is_err()
            );
        }
    }
}