feat: add MCP spec version management and elicitation improvements

- Add versioned feature flags for MCP specifications (2025-03-26, 2025-06-18)
- Implement conditional compilation for elicitation features based on spec version
- Improve code formatting and consistency across elicitation tests
- Add proper feature gating for elicitation API methods
- Update Cargo.toml with new MCP spec feature structure

Author: bug-ops

crates/rmcp/Cargo.toml

@@ -67,14 +67,25 @@ rmcp-macros = { version = "0.1", workspace = true, optional = true }
 chrono = { version = "0.4.38", features = ["serde"] }
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-chrono = { version = "0.4.38", default-features = false, features = ["serde", "clock", "std", "oldtime"] }
+chrono = { version = "0.4.38", default-features = false, features = [
+    "serde",
+    "clock",
+    "std",
+    "oldtime",
+] }
 
 [features]
-default = ["base64", "macros", "server"]
+default = ["base64", "macros", "server", "mcp_spec"]
 client = ["dep:tokio-stream"]
 server = ["transport-async-rw", "dep:schemars"]
 macros = ["dep:rmcp-macros", "dep:paste"]
 
+mcp_spec = ["mcp_spec-2025-03-26"]
+# MCP Spec Version 2025-03-26
+mcp_spec-2025-03-26 = []
+# MCP Spec Version 2025-06-18 - includes all previous features plus new ones
+mcp_spec-2025-06-18 = ["mcp_spec-2025-03-26"]
+
 # reqwest http client
 __reqwest = ["dep:reqwest"]
 
@@ -195,4 +206,4 @@ path = "tests/test_message_schema.rs"
 [[test]]
 name = "test_progress_subscriber"
 required-features = ["server", "client", "macros"]
-path = "tests/test_progress_subscriber.rs"
+path = "tests/test_progress_subscriber.rs"

crates/rmcp/src/handler/client.rs

@@ -95,9 +95,9 @@ pub trait ClientHandler: Sized + Send + Sync + 'static {
         params: CreateElicitationRequestParam,
         context: RequestContext<RoleClient>,
     ) -> impl Future<Output = Result<CreateElicitationResult, McpError>> + Send + '_ {
-        std::future::ready(Err(
-            McpError::method_not_found::<CreateElicitationRequestMethod>(),
-        ))
+        std::future::ready(Err(McpError::method_not_found::<
+            CreateElicitationRequestMethod,
+        >()))
     }
 
     fn on_cancelled(

crates/rmcp/src/model.rs

@@ -142,8 +142,13 @@ impl std::fmt::Display for ProtocolVersion {
 }
 
 impl ProtocolVersion {
+    #[cfg(feature = "mcp_spec-2025-06-18")]
+    pub const V_2025_06_18: Self = Self(Cow::Borrowed("2025-06-18"));
     pub const V_2025_03_26: Self = Self(Cow::Borrowed("2025-03-26"));
     pub const V_2024_11_05: Self = Self(Cow::Borrowed("2024-11-05"));
+    #[cfg(feature = "mcp_spec-2025-06-18")]
+    pub const LATEST: Self = Self::V_2025_06_18;
+    #[cfg(not(feature = "mcp_spec-2025-06-18"))]
     pub const LATEST: Self = Self::V_2025_03_26;
 }
 
@@ -1207,7 +1212,8 @@ pub struct CreateElicitationRequestParam {
 }
 
 /// Request to create an elicitation (server to client)
-pub type CreateElicitationRequest = Request<CreateElicitationRequestMethod, CreateElicitationRequestParam>;
+pub type CreateElicitationRequest =
+    Request<CreateElicitationRequestMethod, CreateElicitationRequestParam>;
 
 /// Result of an elicitation request
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
@@ -1220,7 +1226,6 @@ pub struct CreateElicitationResult {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub content: Option<serde_json::Value>,
 }
-
 // =============================================================================
 // TOOL EXECUTION RESULTS
 // =============================================================================

crates/rmcp/src/service/server.rs

@@ -5,14 +5,17 @@ use thiserror::Error;
 use super::*;
 use crate::model::{
     CancelledNotification, CancelledNotificationParam, ClientInfo, ClientJsonRpcMessage,
-    ClientNotification, ClientRequest, ClientResult, CreateElicitationRequest,
-    CreateElicitationRequestParam, CreateElicitationResult, CreateMessageRequest,
+    ClientNotification, ClientRequest, ClientResult, CreateMessageRequest,
     CreateMessageRequestParam, CreateMessageResult, ErrorData, ListRootsRequest, ListRootsResult,
     LoggingMessageNotification, LoggingMessageNotificationParam, ProgressNotification,
     ProgressNotificationParam, PromptListChangedNotification, ProtocolVersion,
     ResourceListChangedNotification, ResourceUpdatedNotification, ResourceUpdatedNotificationParam,
     ServerInfo, ServerNotification, ServerRequest, ServerResult, ToolListChangedNotification,
 };
+#[cfg(feature = "mcp_spec-2025-06-18")]
+use crate::model::{
+    CreateElicitationRequest, CreateElicitationRequestParam, CreateElicitationResult,
+};
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct RoleServer;
@@ -318,6 +321,7 @@ macro_rules! method {
 impl Peer<RoleServer> {
     method!(peer_req create_message CreateMessageRequest(CreateMessageRequestParam) => CreateMessageResult);
     method!(peer_req list_roots ListRootsRequest() => ListRootsResult);
+    #[cfg(feature = "mcp_spec-2025-06-18")]
     method!(peer_req create_elicitation CreateElicitationRequest(CreateElicitationRequestParam) => CreateElicitationResult);
 
     method!(peer_not notify_cancelled CancelledNotification(CancelledNotificationParam));

crates/rmcp/tests/test_elicitation.rs

@@ -1,13 +1,11 @@
 // cargo test --features "server client" --package rmcp test_elicitation
+#![cfg(feature = "mcp_spec-2025-06-18")]
 mod common;
 
 use std::sync::{Arc, Mutex};
 
 use common::handlers::{TestClientHandler, TestServer};
-use rmcp::{
-    ServiceExt,
-    model::{CreateElicitationRequestParam, CreateElicitationResult, ElicitationAction},
-};
+use rmcp::{ServiceExt, model::*};
 use serde_json::json;
 use tokio::sync::Notify;
 
@@ -30,7 +28,12 @@ async fn test_elicitation_spec_compliance() -> anyhow::Result<()> {
             received_requests: Arc<Mutex<Vec<CreateElicitationRequestParam>>>,
         ) -> Self {
             Self {
-                inner: TestClientHandler::with_notification(false, false, receive_signal.clone(), Arc::new(Mutex::new(Vec::new()))),
+                inner: TestClientHandler::with_notification(
+                    false,
+                    false,
+                    receive_signal.clone(),
+                    Arc::new(Mutex::new(Vec::new())),
+                ),
                 receive_signal,
                 received_requests,
             }
@@ -48,10 +51,10 @@ async fn test_elicitation_spec_compliance() -> anyhow::Result<()> {
                 let mut requests = self.received_requests.lock().unwrap();
                 requests.push(params.clone());
             }
-            
+
             // Signal that we received a request
             self.receive_signal.notify_one();
-            
+
             // Simulate user accepting the elicitation with test data
             Ok(CreateElicitationResult {
                 action: ElicitationAction::Accept,
@@ -121,7 +124,7 @@ async fn test_elicitation_spec_compliance() -> anyhow::Result<()> {
         // Verify the response
         assert_eq!(result.action, ElicitationAction::Accept);
         assert!(result.content.is_some());
-        
+
         let content = result.content.unwrap();
         assert_eq!(content["email"], "[email protected]");
         assert_eq!(content["age"], 25);
@@ -131,24 +134,26 @@ async fn test_elicitation_spec_compliance() -> anyhow::Result<()> {
         anyhow::Ok(())
     });
 
-    let client = ElicitationTestClientHandler::new(
-        receive_signal.clone(),
-        received_requests.clone(),
-    )
-    .serve(client_transport)
-    .await?;
+    let client =
+        ElicitationTestClientHandler::new(receive_signal.clone(), received_requests.clone())
+            .serve(client_transport)
+            .await?;
 
     // Wait for the elicitation request
     receive_signal.notified().await;
-    
+
     // Verify the request was received correctly
     {
         let requests = received_requests.lock().unwrap();
-        assert_eq!(requests.len(), 1, "Should receive exactly one elicitation request");
-        
+        assert_eq!(
+            requests.len(),
+            1,
+            "Should receive exactly one elicitation request"
+        );
+
         let request = &requests[0];
         assert_eq!(request.message, "Please provide your contact information");
-        
+
         // Verify the schema structure
         let schema = &request.requested_schema;
         assert!(schema["type"].as_str().unwrap() == "object");
@@ -165,11 +170,8 @@ async fn test_elicitation_spec_compliance() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test] 
+#[tokio::test]
 async fn test_elicitation_action_types() -> anyhow::Result<()> {
-    let (server_transport, client_transport) = tokio::io::duplex(4096);
-    let receive_signal = Arc::new(Notify::new());
-    
     // Test different action types
     for (action_type, expected_action) in [
         ("accept", ElicitationAction::Accept),
@@ -178,7 +180,7 @@ async fn test_elicitation_action_types() -> anyhow::Result<()> {
     ] {
         let (server_transport, client_transport) = tokio::io::duplex(4096);
         let receive_signal = Arc::new(Notify::new());
-        
+
         struct ActionTestClientHandler {
             action: ElicitationAction,
             receive_signal: Arc<Notify>,
@@ -191,7 +193,7 @@ async fn test_elicitation_action_types() -> anyhow::Result<()> {
                 _context: rmcp::service::RequestContext<rmcp::service::RoleClient>,
             ) -> Result<CreateElicitationResult, rmcp::Error> {
                 self.receive_signal.notify_one();
-                
+
                 Ok(CreateElicitationResult {
                     action: self.action.clone(),
                     content: match self.action {
@@ -226,12 +228,12 @@ async fn test_elicitation_action_types() -> anyhow::Result<()> {
                 .await?;
 
             assert_eq!(result.action, expected_action);
-            
+
             match expected_action {
                 ElicitationAction::Accept => {
                     assert!(result.content.is_some());
                     assert_eq!(result.content.unwrap()["test"], "data");
-                },
+                }
                 _ => {
                     assert!(result.content.is_none());
                 }
@@ -262,11 +264,20 @@ fn test_elicitation_serialization() {
     for (action, expected) in test_cases {
         let serialized = serde_json::to_string(&action).unwrap();
         let serialized = serialized.trim_matches('"');
-        assert_eq!(serialized, expected, "ElicitationAction::{:?} should serialize to \"{}\"", action, expected);
-        
+        assert_eq!(
+            serialized, expected,
+            "ElicitationAction::{:?} should serialize to \"{}\"",
+            action, expected
+        );
+
         // Test deserialization
-        let deserialized: ElicitationAction = serde_json::from_str(&format!("\"{}\"", expected)).unwrap();
-        assert_eq!(deserialized, action, "\"{}\" should deserialize to ElicitationAction::{:?}", expected, action);
+        let deserialized: ElicitationAction =
+            serde_json::from_str(&format!("\"{}\"", expected)).unwrap();
+        assert_eq!(
+            deserialized, action,
+            "\"{}\" should deserialize to ElicitationAction::{:?}",
+            expected, action
+        );
     }
 
     // Test CreateElicitationRequestParam serialization
@@ -302,5 +313,8 @@ fn test_elicitation_serialization() {
 
     let serialized = serde_json::to_value(&result_no_content).unwrap();
     assert_eq!(serialized["action"], "cancel");
-    assert!(serialized.get("content").is_none(), "content field should be omitted when None");
-}
+    assert!(
+        serialized.get("content").is_none(),
+        "content field should be omitted when None"
+    );
+}