Move whole rmcp crate to offcial rust sdk (#44)

* get rid of async-trait

* move rmcp to official-rust-sdk

* replace master with main

* update readme, change license

* fix typo

* Update README.md

Co-authored-by: Jefry Dewangga <jefrydco@gmail.com>

* fix typos

---------

Co-authored-by: = <=>
Co-authored-by: Jefry Dewangga <jefrydco@gmail.com>

examples/transport/src/common/calculator.rs

@@ -0,0 +1,41 @@
+use rmcp::{ServerHandler, model::ServerInfo, schemars, tool, tool_box};
+
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+pub struct SumRequest {
+    #[schemars(description = "the left hand side number")]
+    pub a: i32,
+    pub b: i32,
+}
+#[derive(Debug, Clone)]
+pub struct Calculator;
+impl Calculator {
+    #[tool(description = "Calculate the sum of two numbers")]
+    fn sum(&self, #[tool(aggr)] SumRequest { a, b }: SumRequest) -> String {
+        (a + b).to_string()
+    }
+
+    #[tool(description = "Calculate the sum of two numbers")]
+    fn sub(
+        &self,
+        #[tool(param)]
+        #[schemars(description = "the left hand side number")]
+        a: i32,
+        #[tool(param)]
+        #[schemars(description = "the left hand side number")]
+        b: i32,
+    ) -> String {
+        (a - b).to_string()
+    }
+
+    tool_box!(Calculator { sum, sub });
+}
+
+impl ServerHandler for Calculator {
+    tool_box!(@derive);
+    fn get_info(&self) -> ServerInfo {
+        ServerInfo {
+            instructions: Some("A simple calculator".into()),
+            ..Default::default()
+        }
+    }
+}

examples/transport/src/common/mod.rs

@@ -0,0 +1 @@
+pub mod calculator;

examples/transport/src/http_upgrade.rs

@@ -0,0 +1,67 @@
+use common::calculator::Calculator;
+use hyper::{
+    Request, StatusCode,
+    body::Incoming,
+    header::{HeaderValue, UPGRADE},
+};
+use hyper_util::rt::TokioIo;
+use rmcp::{RoleClient, ServiceExt, service::RunningService};
+use tracing_subscriber::EnvFilter;
+mod common;
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
+        .init();
+    start_server().await?;
+    let client = http_client("127.0.0.1:8001").await?;
+    let tools = client.list_all_tools().await?;
+    client.cancel().await?;
+    tracing::info!("{:#?}", tools);
+    Ok(())
+}
+
+async fn http_server(req: Request<Incoming>) -> Result<hyper::Response<String>, hyper::Error> {
+    tokio::spawn(async move {
+        let upgraded = hyper::upgrade::on(req).await?;
+        let service = Calculator.serve(TokioIo::new(upgraded)).await?;
+        service.waiting().await?;
+        anyhow::Result::<()>::Ok(())
+    });
+    let mut response = hyper::Response::new(String::new());
+    *response.status_mut() = StatusCode::SWITCHING_PROTOCOLS;
+    response
+        .headers_mut()
+        .insert(UPGRADE, HeaderValue::from_static("mcp"));
+    Ok(response)
+}
+
+async fn http_client(uri: &str) -> anyhow::Result<RunningService<RoleClient, ()>> {
+    let tcp_stream = tokio::net::TcpStream::connect(uri).await?;
+    let (mut s, c) =
+        hyper::client::conn::http1::handshake::<_, String>(TokioIo::new(tcp_stream)).await?;
+    tokio::spawn(c.with_upgrades());
+    let mut req = Request::new(String::new());
+    req.headers_mut()
+        .insert(UPGRADE, HeaderValue::from_static("mcp"));
+    let response = s.send_request(req).await?;
+    let upgraded = hyper::upgrade::on(response).await?;
+    let client = ().serve(TokioIo::new(upgraded)).await?;
+    Ok(client)
+}
+
+async fn start_server() -> anyhow::Result<()> {
+    let tcp_listener = tokio::net::TcpListener::bind("127.0.0.1:8001").await?;
+    let service = hyper::service::service_fn(http_server);
+    tokio::spawn(async move {
+        while let Ok((stream, addr)) = tcp_listener.accept().await {
+            tracing::info!("accepted connection from: {}", addr);
+            let conn = hyper::server::conn::http1::Builder::new()
+                .serve_connection(TokioIo::new(stream), service)
+                .with_upgrades();
+            tokio::spawn(conn);
+        }
+    });
+
+    Ok(())
+}

examples/transport/src/tcp.rs

@@ -0,0 +1,32 @@
+use common::calculator::Calculator;
+use rmcp::{serve_client, serve_server};
+
+mod common;
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tokio::spawn(server());
+    client().await?;
+    Ok(())
+}
+
+async fn server() -> anyhow::Result<()> {
+    let tcp_listener = tokio::net::TcpListener::bind("127.0.0.1:8001").await?;
+    while let Ok((stream, _)) = tcp_listener.accept().await {
+        tokio::spawn(async move {
+            let server = serve_server(Calculator, stream).await?;
+            server.waiting().await?;
+            anyhow::Ok(())
+        });
+    }
+    Ok(())
+}
+
+async fn client() -> anyhow::Result<()> {
+    let stream = tokio::net::TcpSocket::new_v4()?
+        .connect("127.0.0.1:8001".parse()?)
+        .await?;
+    let client = serve_client((), stream).await?;
+    let tools = client.peer().list_tools(Default::default()).await?;
+    println!("{:?}", tools);
+    Ok(())
+}

examples/transport/src/unix_socket.rs

@@ -0,0 +1,81 @@
+use common::calculator::Calculator;
+use rmcp::{serve_client, serve_server};
+use std::fs;
+use tokio::net::{UnixListener, UnixStream};
+
+mod common;
+
+const SOCKET_PATH: &str = "/tmp/rmcp_example.sock";
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Remove any existing socket file
+    let _ = fs::remove_file(SOCKET_PATH);
+    match UnixListener::bind(SOCKET_PATH) {
+        Ok(unix_listener) => {
+            println!("Server successfully listening on {}", SOCKET_PATH);
+            tokio::spawn(server(unix_listener));
+        }
+        Err(e) => {
+            println!("Unable to bind to {}: {}", SOCKET_PATH, e);
+        }
+    }
+
+    client().await?;
+
+    // Clean up socket file
+    let _ = fs::remove_file(SOCKET_PATH);
+
+    Ok(())
+}
+
+async fn server(unix_listener: UnixListener) -> anyhow::Result<()> {
+    while let Ok((stream, addr)) = unix_listener.accept().await {
+        println!("Client connected: {:?}", addr);
+        tokio::spawn(async move {
+            match serve_server(Calculator, stream).await {
+                Ok(server) => {
+                    println!("Server initialized successfully");
+                    if let Err(e) = server.waiting().await {
+                        println!("Error while server waiting: {}", e);
+                    }
+                }
+                Err(e) => println!("Server initialization failed: {}", e),
+            }
+
+            anyhow::Ok(())
+        });
+    }
+    Ok(())
+}
+
+async fn client() -> anyhow::Result<()> {
+    println!("Client connecting to {}", SOCKET_PATH);
+    let stream = UnixStream::connect(SOCKET_PATH).await?;
+
+    let client = serve_client((), stream).await?;
+    println!("Client connected and initialized successfully");
+
+    // List available tools
+    let tools = client.peer().list_tools(Default::default()).await?;
+    println!("Available tools: {:?}", tools);
+
+    // Call the sum tool
+    if let Some(sum_tool) = tools.tools.iter().find(|t| t.name.contains("sum")) {
+        println!("Calling sum tool: {}", sum_tool.name);
+        let result = client
+            .peer()
+            .call_tool(rmcp::model::CallToolRequestParam {
+                name: sum_tool.name.clone(),
+                arguments: Some(rmcp::object!({
+                    "a": 10,
+                    "b": 20
+                })),
+            })
+            .await?;
+
+        println!("Result: {:?}", result);
+    }
+
+    Ok(())
+}

examples/transport/src/websocket.rs

@@ -0,0 +1,169 @@
+use std::marker::PhantomData;
+
+use common::calculator::Calculator;
+use futures::{Sink, Stream};
+
+use rmcp::{
+    RoleClient, RoleServer, ServiceExt,
+    service::{RunningService, RxJsonRpcMessage, ServiceRole, TxJsonRpcMessage},
+};
+use tokio_tungstenite::tungstenite;
+use tracing_subscriber::EnvFilter;
+mod common;
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
+        .init();
+    start_server().await?;
+    let client = http_client("ws://127.0.0.1:8001").await?;
+    let tools = client.list_all_tools().await?;
+    client.cancel().await?;
+    tracing::info!("{:#?}", tools);
+    Ok(())
+}
+
+async fn http_client(uri: &str) -> anyhow::Result<RunningService<RoleClient, ()>> {
+    let (stream, response) = tokio_tungstenite::connect_async(uri).await?;
+    if response.status() != tungstenite::http::StatusCode::SWITCHING_PROTOCOLS {
+        return Err(anyhow::anyhow!("failed to upgrade connection"));
+    }
+    let transport = WebsocketTransport::new_client(stream);
+    let client = ().serve(transport).await?;
+    Ok(client)
+}
+
+async fn start_server() -> anyhow::Result<()> {
+    let tcp_listener = tokio::net::TcpListener::bind("127.0.0.1:8001").await?;
+    tokio::spawn(async move {
+        while let Ok((stream, addr)) = tcp_listener.accept().await {
+            tracing::info!("accepted connection from: {}", addr);
+            tokio::spawn(async move {
+                let ws_stream = tokio_tungstenite::accept_async(stream).await?;
+                let transport = WebsocketTransport::new_server(ws_stream);
+                let server = Calculator.serve(transport).await?;
+                server.waiting().await?;
+                Ok::<(), anyhow::Error>(())
+            });
+        }
+    });
+    Ok(())
+}
+
+pin_project_lite::pin_project! {
+    pub struct WebsocketTransport<R, S, E> {
+        #[pin]
+        stream: S,
+        marker: PhantomData<(fn() -> E, fn() -> R)>
+    }
+}
+
+impl<R, S, E> WebsocketTransport<R, S, E> {
+    pub fn new(stream: S) -> Self {
+        Self {
+            stream,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<S, E> WebsocketTransport<RoleClient, S, E> {
+    pub fn new_client(stream: S) -> Self {
+        Self {
+            stream,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<S, E> WebsocketTransport<RoleServer, S, E> {
+    pub fn new_server(stream: S) -> Self {
+        Self {
+            stream,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<R, S, E> Stream for WebsocketTransport<R, S, E>
+where
+    S: Stream<Item = Result<tungstenite::Message, E>>,
+    R: ServiceRole,
+    E: std::error::Error,
+{
+    type Item = RxJsonRpcMessage<R>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        let this = self.as_mut().project();
+        match this.stream.poll_next(cx) {
+            std::task::Poll::Ready(Some(Ok(message))) => {
+                let message = match message {
+                    tungstenite::Message::Text(json) => json,
+                    _ => return self.poll_next(cx),
+                };
+                let message = match serde_json::from_str::<RxJsonRpcMessage<R>>(&message) {
+                    Ok(message) => message,
+                    Err(e) => {
+                        tracing::warn!(error = %e, "serde_json parse error");
+                        return self.poll_next(cx);
+                    }
+                };
+                std::task::Poll::Ready(Some(message))
+            }
+            std::task::Poll::Ready(Some(Err(e))) => {
+                tracing::warn!(error = %e, "websocket error");
+                self.poll_next(cx)
+            }
+            std::task::Poll::Ready(None) => std::task::Poll::Ready(None),
+            std::task::Poll::Pending => std::task::Poll::Pending,
+        }
+    }
+}
+
+impl<R, S, E> Sink<TxJsonRpcMessage<R>> for WebsocketTransport<R, S, E>
+where
+    S: Sink<tungstenite::Message, Error = E>,
+    R: ServiceRole,
+{
+    type Error = E;
+
+    fn poll_ready(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        let this = self.project();
+        this.stream.poll_ready(cx)
+    }
+
+    fn start_send(
+        self: std::pin::Pin<&mut Self>,
+        item: TxJsonRpcMessage<R>,
+    ) -> Result<(), Self::Error> {
+        let this = self.project();
+        let message = tungstenite::Message::Text(
+            serde_json::to_string(&item)
+                .expect("jsonrpc should be valid json")
+                .into(),
+        );
+        this.stream.start_send(message)
+    }
+
+    fn poll_flush(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        let this = self.project();
+        this.stream.poll_flush(cx)
+    }
+
+    fn poll_close(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        let this = self.project();
+        this.stream.poll_close(cx)
+    }
+}