fix: preserve peer public API

Author: DaleSeo

crates/rmcp/src/service.rs

@@ -124,7 +124,6 @@ pub trait ServiceRole: std::fmt::Debug + Send + Sync + 'static + Copy + Clone {
     type PeerNot: TryInto<CancelledNotification, Error = Self::PeerNot>
         + From<CancelledNotification>
         + TransferObject
-        + CancelledNotificationReference
         + GetMeta<Metadata = NotificationMetaObject>
         + GetExtensions;
     type InitializeError;
@@ -133,6 +132,10 @@ pub trait ServiceRole: std::fmt::Debug + Send + Sync + 'static + Copy + Clone {
     type PeerInfo: TransferObject;
     #[doc(hidden)]
     fn configure_direct_peer(_peer: &Peer<Self>, _info: &Self::Info) {}
+    #[doc(hidden)]
+    fn peer_cancelled_params(_notification: &Self::PeerNot) -> Option<&CancelledNotificationParam> {
+        None
+    }
 }
 
 pub type TxJsonRpcMessage<R> =
@@ -319,31 +322,6 @@ pub trait ProgressNotificationToken {
     fn progress_token(&self) -> Option<&ProgressToken>;
 }
 
-#[doc(hidden)]
-pub trait CancelledNotificationReference {
-    fn cancelled_params(&self) -> Option<&CancelledNotificationParam>;
-}
-
-#[cfg(feature = "server")]
-impl CancelledNotificationReference for ClientNotification {
-    fn cancelled_params(&self) -> Option<&CancelledNotificationParam> {
-        match self {
-            ClientNotification::CancelledNotification(notification) => Some(&notification.params),
-            _ => None,
-        }
-    }
-}
-
-#[cfg(feature = "client")]
-impl CancelledNotificationReference for ServerNotification {
-    fn cancelled_params(&self) -> Option<&CancelledNotificationParam> {
-        match self {
-            ServerNotification::CancelledNotification(notification) => Some(&notification.params),
-            _ => None,
-        }
-    }
-}
-
 #[cfg(feature = "server")]
 impl ProgressNotificationToken for ClientNotification {
     fn progress_token(&self) -> Option<&ProgressToken> {
@@ -565,7 +543,6 @@ pub(crate) struct ClientRequestMetadata {
 /// 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_request_with_option`].
-#[derive(Clone)]
 pub struct Peer<R: ServiceRole> {
     tx: mpsc::Sender<PeerSinkMessage<R>>,
     request_id_provider: Arc<dyn RequestIdProvider>,
@@ -577,6 +554,25 @@ pub struct Peer<R: ServiceRole> {
     subscription_channels: Arc<std::sync::RwLock<SubscriptionChannelMap<R::PeerNot>>>,
 }
 
+impl<R> Clone for Peer<R>
+where
+    R: Clone + ServiceRole,
+    R::PeerInfo: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            tx: self.tx.clone(),
+            request_id_provider: self.request_id_provider.clone(),
+            progress_token_provider: self.progress_token_provider.clone(),
+            progress_timeout_watchers: self.progress_timeout_watchers.clone(),
+            info: self.info.clone(),
+            client_request_metadata: self.client_request_metadata.clone(),
+            request_metadata_required: self.request_metadata_required.clone(),
+            subscription_channels: self.subscription_channels.clone(),
+        }
+    }
+}
+
 impl<R: ServiceRole> std::fmt::Debug for Peer<R> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PeerSink")
@@ -1389,7 +1385,7 @@ where
                 })) => {
                     tracing::info!(?notification, "received notification");
                     let cancellation_request_id =
-                        if let Some(cancelled) = notification.cancelled_params() {
+                        if let Some(cancelled) = R::peer_cancelled_params(&notification) {
                             let request_id = cancelled.request_id.clone();
                             if let Some(request_id) = request_id.as_ref() {
                                 if R::IS_CLIENT {

crates/rmcp/src/service/client.rs

@@ -199,6 +199,13 @@ impl ServiceRole for RoleClient {
             client_capabilities: info.capabilities.clone(),
         });
     }
+
+    fn peer_cancelled_params(notification: &Self::PeerNot) -> Option<&CancelledNotificationParam> {
+        match notification {
+            ServerNotification::CancelledNotification(notification) => Some(&notification.params),
+            _ => None,
+        }
+    }
 }
 
 pub type ServerSink = Peer<RoleClient>;

crates/rmcp/src/service/server.rs

@@ -42,6 +42,13 @@ impl ServiceRole for RoleServer {
 
     type InitializeError = ServerInitializeError;
     const IS_CLIENT: bool = false;
+
+    fn peer_cancelled_params(notification: &Self::PeerNot) -> Option<&CancelledNotificationParam> {
+        match notification {
+            ClientNotification::CancelledNotification(notification) => Some(&notification.params),
+            _ => None,
+        }
+    }
 }
 
 /// It represents the error that may occur when serving the server.