refactor: Transport trait and worker transport, and streamable http client with those new features. (#167)

* refactor: a transport trait and streamable http client

* test: test with js streamable http server

* refactor: separate sse stream connection

* fix(test): streamable http client test with js

* fix(test): wait longer time for js server startup

crates/rmcp/tests/test_with_js.rs

@@ -1,6 +1,10 @@
 use rmcp::{
     ServiceExt,
-    transport::{SseServer, TokioChildProcess, streamable_http_server::axum::StreamableHttpServer},
+    service::QuitReason,
+    transport::{
+        SseServer, StreamableHttpClientTransport, TokioChildProcess,
+        streamable_http_server::axum::StreamableHttpServer,
+    },
 };
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 mod common;
@@ -8,6 +12,7 @@ use common::calculator::Calculator;
 
 const SSE_BIND_ADDRESS: &str = "127.0.0.1:8000";
 const STREAMABLE_HTTP_BIND_ADDRESS: &str = "127.0.0.1:8001";
+const STREAMABLE_HTTP_JS_BIND_ADDRESS: &str = "127.0.0.1:8002";
 
 #[tokio::test]
 async fn test_with_js_client() -> anyhow::Result<()> {
@@ -97,3 +102,41 @@ async fn test_with_js_streamable_http_client() -> anyhow::Result<()> {
     ct.cancel();
     Ok(())
 }
+
+#[tokio::test]
+async fn test_with_js_streamable_http_server() -> anyhow::Result<()> {
+    let _ = tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "debug".to_string().into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .try_init();
+    tokio::process::Command::new("npm")
+        .arg("install")
+        .current_dir("tests/test_with_js")
+        .spawn()?
+        .wait()
+        .await?;
+
+    let transport = StreamableHttpClientTransport::from_uri(format!(
+        "http://{STREAMABLE_HTTP_JS_BIND_ADDRESS}/mcp"
+    ));
+
+    let mut server = tokio::process::Command::new("node")
+        .arg("tests/test_with_js/streamable_server.js")
+        .spawn()?;
+
+    // waiting for server up
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let client = ().serve(transport).await?;
+    let resources = client.list_all_resources().await?;
+    tracing::info!("{:#?}", resources);
+    let tools = client.list_all_tools().await?;
+    tracing::info!("{:#?}", tools);
+    let quit_reason = client.cancel().await?;
+    server.kill().await?;
+    assert!(matches!(quit_reason, QuitReason::Cancelled));
+    Ok(())
+}

crates/rmcp/tests/test_with_js/package.json

@@ -1,7 +1,8 @@
 {
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.10",
-    "eventsource-parser": "^3.0.1"
+    "eventsource-parser": "^3.0.1",
+    "express": "^5.1.0"
   },
   "type": "module",
   "name": "test_with_ts",

crates/rmcp/tests/test_with_js/streamable_server.js

@@ -0,0 +1,105 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js"
+import { randomUUID } from "node:crypto"
+import { z } from "zod";
+import express from "express"
+
+const app = express();
+app.use(express.json());
+
+// Map to store transports by session ID
+const transports = {};
+
+// Handle POST requests for client-to-server communication
+app.post('/mcp', async (req, res) => {
+  // Check for existing session ID
+  const sessionId = req.headers['mcp-session-id'];
+  let transport;
+
+  if (sessionId && transports[sessionId]) {
+    // Reuse existing transport
+    transport = transports[sessionId];
+  } else if (!sessionId && isInitializeRequest(req.body)) {
+    // New initialization request
+    transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID().toString(),
+      onsessioninitialized: (sessionId) => {
+        // Store the transport by session ID
+        transports[sessionId] = transport;
+      }
+    });
+
+    // Clean up transport when closed
+    transport.onclose = () => {
+      if (transport.sessionId) {
+        delete transports[transport.sessionId];
+      }
+    };
+    const server = new McpServer({
+      name: "example-server",
+      version: "1.0.0"
+    });
+
+    server.resource(
+      "greeting",
+      new ResourceTemplate("greeting://{name}", { list: undefined }),
+      async (uri, { name }) => ({
+        contents: [{
+          uri: uri.href,
+          text: `Hello, ${name}`
+        }]
+      })
+    );
+
+    server.tool(
+      "add",
+      { a: z.number(), b: z.number() },
+      async ({ a, b }) => ({
+        "content": [
+          {
+            "type": "text",
+            "text": `${a + b}`
+          }
+        ]
+      })
+    );
+
+    // Connect to the MCP server
+    await server.connect(transport);
+  } else {
+    // Invalid request
+    res.status(400).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: 'Bad Request: No valid session ID provided',
+      },
+      id: null,
+    });
+    return;
+  }
+
+  // Handle the request
+  await transport.handleRequest(req, res, req.body);
+});
+
+// Reusable handler for GET and DELETE requests
+const handleSessionRequest = async (req, res) => {
+  const sessionId = req.headers['mcp-session-id'];
+  if (!sessionId || !transports[sessionId]) {
+    res.status(400).send('Invalid or missing session ID');
+    return;
+  }
+
+  const transport = transports[sessionId];
+  await transport.handleRequest(req, res);
+};
+
+// Handle GET requests for server-to-client notifications via SSE
+app.get('/mcp', handleSessionRequest);
+
+// Handle DELETE requests for session termination
+app.delete('/mcp', handleSessionRequest);
+console.log("Listening on port 8002");
+app.listen(8002);