fix: remove batched json rpc support (#408)

* fix: remove batched json rpc  support

* fix(test): fix schema

Author: 4t145

crates/rmcp/src/model.rs

@@ -490,40 +490,6 @@ impl ErrorData {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-#[serde(untagged)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub enum JsonRpcBatchRequestItem<Req, Not> {
-    Request(JsonRpcRequest<Req>),
-    Notification(JsonRpcNotification<Not>),
-}
-
-impl<Req, Not> JsonRpcBatchRequestItem<Req, Not> {
-    pub fn into_non_batch_message<Resp>(self) -> JsonRpcMessage<Req, Resp, Not> {
-        match self {
-            JsonRpcBatchRequestItem::Request(r) => JsonRpcMessage::Request(r),
-            JsonRpcBatchRequestItem::Notification(n) => JsonRpcMessage::Notification(n),
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-#[serde(untagged)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub enum JsonRpcBatchResponseItem<Resp> {
-    Response(JsonRpcResponse<Resp>),
-    Error(JsonRpcError),
-}
-
-impl<Resp> JsonRpcBatchResponseItem<Resp> {
-    pub fn into_non_batch_message<Req, Not>(self) -> JsonRpcMessage<Req, Resp, Not> {
-        match self {
-            JsonRpcBatchResponseItem::Response(r) => JsonRpcMessage::Response(r),
-            JsonRpcBatchResponseItem::Error(e) => JsonRpcMessage::Error(e),
-        }
-    }
-}
-
 /// Represents any JSON-RPC message that can be sent or received.
 ///
 /// This enum covers all possible message types in the JSON-RPC protocol:
@@ -539,10 +505,6 @@ pub enum JsonRpcMessage<Req = Request, Resp = DefaultResponse, Noti = Notificati
     Response(JsonRpcResponse<Resp>),
     /// A one-way notification (no response expected)
     Notification(JsonRpcNotification<Noti>),
-    /// Multiple requests sent together
-    BatchRequest(Vec<JsonRpcBatchRequestItem<Req, Noti>>),
-    /// Multiple responses sent together
-    BatchResponse(Vec<JsonRpcBatchResponseItem<Resp>>),
     /// An error response
     Error(JsonRpcError),
 }

crates/rmcp/src/model/meta.rs

@@ -172,24 +172,6 @@ where
                     .extensions_mut()
                     .insert(value);
             }
-            JsonRpcMessage::BatchRequest(json_rpc_batch_request_items) => {
-                for item in json_rpc_batch_request_items {
-                    match item {
-                        super::JsonRpcBatchRequestItem::Request(json_rpc_request) => {
-                            json_rpc_request
-                                .request
-                                .extensions_mut()
-                                .insert(value.clone());
-                        }
-                        super::JsonRpcBatchRequestItem::Notification(json_rpc_notification) => {
-                            json_rpc_notification
-                                .notification
-                                .extensions_mut()
-                                .insert(value.clone());
-                        }
-                    }
-                }
-            }
             _ => {}
         }
     }

crates/rmcp/src/service.rs

@@ -5,9 +5,8 @@ use crate::{
     error::ErrorData as McpError,
     model::{
         CancelledNotification, CancelledNotificationParam, Extensions, GetExtensions, GetMeta,
-        JsonRpcBatchRequestItem, JsonRpcBatchResponseItem, JsonRpcError, JsonRpcMessage,
-        JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, Meta, NumberOrString, ProgressToken,
-        RequestId, ServerJsonRpcMessage,
+        JsonRpcError, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, Meta,
+        NumberOrString, ProgressToken, RequestId, ServerJsonRpcMessage,
     },
     transport::{DynamicTransportError, IntoTransport, Transport},
 };
@@ -835,20 +834,6 @@ where
                         }
                     }
                 }
-                Event::PeerMessage(JsonRpcMessage::BatchRequest(batch)) => {
-                    batch_messages.extend(
-                        batch
-                            .into_iter()
-                            .map(JsonRpcBatchRequestItem::into_non_batch_message),
-                    );
-                }
-                Event::PeerMessage(JsonRpcMessage::BatchResponse(batch)) => {
-                    batch_messages.extend(
-                        batch
-                            .into_iter()
-                            .map(JsonRpcBatchResponseItem::into_non_batch_message),
-                    );
-                }
             }
         };
         let sink_close_result = transport.close().await;

crates/rmcp/src/transport/streamable_http_server/session/local.rs

@@ -468,10 +468,6 @@ impl LocalSessionWorker {
                     OutboundChannel::Common
                 }
             }
-            ServerJsonRpcMessage::BatchRequest(_) | ServerJsonRpcMessage::BatchResponse(_) => {
-                // the server side should never yield a batch request or response now
-                unreachable!("server side won't yield batch request or response")
-            }
         }
     }
     async fn handle_server_message(
@@ -824,20 +820,6 @@ impl Worker for LocalSessionWorker {
                         crate::model::JsonRpcMessage::Notification(notification) => {
                             self.catch_cancellation_notification(notification)
                         }
-                        crate::model::JsonRpcMessage::BatchRequest(items) => {
-                            for r in items {
-                                match r {
-                                    crate::model::JsonRpcBatchRequestItem::Request(request) => {
-                                        if let Some(http_request_id) = http_request_id {
-                                            self.register_request(request, http_request_id)
-                                        }
-                                    }
-                                    crate::model::JsonRpcBatchRequestItem::Notification(
-                                        notification,
-                                    ) => self.catch_cancellation_notification(notification),
-                                }
-                            }
-                        }
                         _ => {}
                     }
                     context.send_to_handler(json_rpc_message).await?;

crates/rmcp/src/transport/streamable_http_server/tower.rs

@@ -319,12 +319,6 @@ where
                             .map_err(internal_error_response("accept message"))?;
                         Ok(accepted_response())
                     }
-                    _ => Ok(Response::builder()
-                        .status(http::StatusCode::NOT_IMPLEMENTED)
-                        .body(
-                            Full::new(Bytes::from("Batch requests are not supported yet")).boxed(),
-                        )
-                        .expect("valid response")),
                 }
             } else {
                 let (session_id, transport) = self
@@ -427,10 +421,6 @@ where
                 }
                 ClientJsonRpcMessage::Response(_json_rpc_response) => Ok(accepted_response()),
                 ClientJsonRpcMessage::Error(_json_rpc_error) => Ok(accepted_response()),
-                _ => Ok(Response::builder()
-                    .status(http::StatusCode::NOT_IMPLEMENTED)
-                    .body(Full::new(Bytes::from("Batch requests are not supported yet")).boxed())
-                    .expect("valid response")),
             }
         }
     }

crates/rmcp/tests/test_message_schema/client_json_rpc_message_schema.json

@@ -27,20 +27,6 @@
         }
       ]
     },
-    {
-      "description": "Multiple requests sent together",
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/JsonRpcBatchRequestItem"
-      }
-    },
-    {
-      "description": "Multiple responses sent together",
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/JsonRpcBatchResponseItem"
-      }
-    },
     {
       "description": "An error response",
       "allOf": [
@@ -559,26 +545,6 @@
       "format": "const",
       "const": "notifications/initialized"
     },
-    "JsonRpcBatchRequestItem": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/JsonRpcRequest"
-        },
-        {
-          "$ref": "#/definitions/JsonRpcNotification"
-        }
-      ]
-    },
-    "JsonRpcBatchResponseItem": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/JsonRpcResponse"
-        },
-        {
-          "$ref": "#/definitions/JsonRpcError"
-        }
-      ]
-    },
     "JsonRpcError": {
       "type": "object",
       "properties": {