fix(model): fix the serde implementation

Author: 4t145

crates/rmcp/src/model/meta.rs

@@ -127,6 +127,12 @@ impl Meta {
                 .insert(PROGRESS_TOKEN_FIELD.to_string(), Value::Number(n.into())),
         };
     }
+
+    pub fn extend(&mut self, other: Meta) {
+        for (k, v) in other.0.into_iter() {
+            self.0.insert(k, v);
+        }
+    }
 }
 
 impl Deref for Meta {

crates/rmcp/src/model/serde_impl.rs

@@ -3,15 +3,32 @@ use std::borrow::Cow;
 use serde::{Deserialize, Serialize};
 
 use super::{Extensions, Meta, Notification, NotificationNoParam, Request, RequestNoParam};
+#[derive(Serialize, Deserialize)]
+struct WithMeta<'a, P> {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    _meta: Option<Cow<'a, Meta>>,
+    #[serde(flatten)]
+    _rest: P,
+}
 
 #[derive(Serialize, Deserialize)]
-struct WithMeta<'a, M, P> {
+struct Proxy<'a, M, P> {
     method: M,
-    params: P,
+    params: WithMeta<'a, P>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct WithMetaNoParam<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     _meta: Option<Cow<'a, Meta>>,
 }
 
+#[derive(Serialize, Deserialize)]
+struct ProxyNoParam<'a, M> {
+    method: M,
+    params: WithMetaNoParam<'a>,
+}
+
 impl<M, R> Serialize for Request<M, R>
 where
     M: Serialize,
@@ -23,11 +40,13 @@ where
     {
         let extensions = &self.extensions;
         let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
-        WithMeta::serialize(
-            &WithMeta {
+        Proxy::serialize(
+            &Proxy {
                 method: &self.method,
-                params: &self.params,
-                _meta,
+                params: WithMeta {
+                    _rest: &self.params,
+                    _meta,
+                },
             },
             serializer,
         )
@@ -43,27 +62,20 @@ where
     where
         D: serde::Deserializer<'de>,
     {
-        let body = WithMeta::deserialize(deserializer)?;
-        let _meta = body._meta.map(|m| m.into_owned());
+        let body = Proxy::deserialize(deserializer)?;
+        let _meta = body.params._meta.map(|m| m.into_owned());
         let mut extensions = Extensions::new();
         if let Some(meta) = _meta {
             extensions.insert(meta);
         }
         Ok(Request {
             extensions,
             method: body.method,
-            params: body.params,
+            params: body.params._rest,
         })
     }
 }
 
-#[derive(Serialize, Deserialize)]
-struct NoParamWithMeta<'a, M> {
-    method: M,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    _meta: Option<Cow<'a, Meta>>,
-}
-
 impl<M> Serialize for RequestNoParam<M>
 where
     M: Serialize,
@@ -74,10 +86,10 @@ where
     {
         let extensions = &self.extensions;
         let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
-        NoParamWithMeta::serialize(
-            &NoParamWithMeta {
+        ProxyNoParam::serialize(
+            &ProxyNoParam {
                 method: &self.method,
-                _meta,
+                params: WithMetaNoParam { _meta },
             },
             serializer,
         )
@@ -92,8 +104,8 @@ where
     where
         D: serde::Deserializer<'de>,
     {
-        let body = NoParamWithMeta::deserialize(deserializer)?;
-        let _meta = body._meta.map(|m| m.into_owned());
+        let body = ProxyNoParam::<'_, _>::deserialize(deserializer)?;
+        let _meta = body.params._meta.map(|m| m.into_owned());
         let mut extensions = Extensions::new();
         if let Some(meta) = _meta {
             extensions.insert(meta);
@@ -116,11 +128,13 @@ where
     {
         let extensions = &self.extensions;
         let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
-        WithMeta::serialize(
-            &WithMeta {
+        Proxy::serialize(
+            &Proxy {
                 method: &self.method,
-                params: &self.params,
-                _meta,
+                params: WithMeta {
+                    _rest: &self.params,
+                    _meta,
+                },
             },
             serializer,
         )
@@ -136,16 +150,16 @@ where
     where
         D: serde::Deserializer<'de>,
     {
-        let body = WithMeta::deserialize(deserializer)?;
-        let _meta = body._meta.map(|m| m.into_owned());
+        let body = Proxy::deserialize(deserializer)?;
+        let _meta = body.params._meta.map(|m| m.into_owned());
         let mut extensions = Extensions::new();
         if let Some(meta) = _meta {
             extensions.insert(meta);
         }
         Ok(Notification {
             extensions,
             method: body.method,
-            params: body.params,
+            params: body.params._rest,
         })
     }
 }
@@ -160,10 +174,10 @@ where
     {
         let extensions = &self.extensions;
         let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
-        NoParamWithMeta::serialize(
-            &NoParamWithMeta {
+        ProxyNoParam::serialize(
+            &ProxyNoParam {
                 method: &self.method,
-                _meta,
+                params: WithMetaNoParam { _meta },
             },
             serializer,
         )
@@ -178,8 +192,8 @@ where
     where
         D: serde::Deserializer<'de>,
     {
-        let body = NoParamWithMeta::deserialize(deserializer)?;
-        let _meta = body._meta.map(|m| m.into_owned());
+        let body = ProxyNoParam::<'_, _>::deserialize(deserializer)?;
+        let _meta = body.params._meta.map(|m| m.into_owned());
         let mut extensions = Extensions::new();
         if let Some(meta) = _meta {
             extensions.insert(meta);

crates/rmcp/src/service.rs

@@ -310,7 +310,7 @@ pub(crate) enum PeerSinkMessage<R: ServiceRole> {
 ///
 /// For general purpose, call [`Peer::send_request`] or [`Peer::send_notification`] to send message to remote peer.
 ///
-/// To create a cancellable request, call [`Peer::send_cancellable_request`].
+/// To create a cancellable request, call [`Peer::send_request_with_option`].
 #[derive(Clone)]
 pub struct Peer<R: ServiceRole> {
     tx: mpsc::Sender<PeerSinkMessage<R>>,
@@ -332,7 +332,8 @@ type ProxyOutbound<R> = mpsc::Receiver<PeerSinkMessage<R>>;
 
 #[derive(Debug, Default)]
 pub struct PeerRequestOptions {
-    timeout: Option<Duration>,
+    pub timeout: Option<Duration>,
+    pub meta: Option<Meta>,
 }
 
 impl PeerRequestOptions {
@@ -374,12 +375,21 @@ impl<R: ServiceRole> Peer<R> {
         })?
     }
     pub async fn send_request(&self, request: R::Req) -> Result<R::PeerResp, ServiceError> {
-        self.send_cancellable_request(request, PeerRequestOptions::no_options())
+        self.send_request_with_option(request, PeerRequestOptions::no_options())
             .await?
             .await_response()
             .await
     }
+    
     pub async fn send_cancellable_request(
+        &self,
+        request: R::Req,
+        options: PeerRequestOptions,
+    ) -> Result<RequestHandle<R>, ServiceError> {
+        self.send_request_with_option(request, options).await
+    }
+
+    pub async fn send_request_with_option(
         &self,
         mut request: R::Req,
         options: PeerRequestOptions,
@@ -389,6 +399,9 @@ impl<R: ServiceRole> Peer<R> {
         request
             .get_meta_mut()
             .set_progress_token(progress_token.clone());
+        if let Some(meta) = options.meta.clone() {
+            request.get_meta_mut().extend(meta);
+        }
         let (responder, receiver) = tokio::sync::oneshot::channel();
         self.tx
             .send(PeerSinkMessage::Request {