Remove rust-toolchain and enhance tool macro functionality

1. Remove rust-toolchain.toml file
   - Project doesn't need to restrict specific Rust version
   - No dependency on components not included in default Rust installation

2. Enhance tool macro functionality
   - Automatically recognize #[tool(param)] and #[tool(aggr)] parameters, no manual marking needed
   - Add tool_impl_item functionality, supporting default implementation of ServerHandler trait for structs
   - Add default_build parameter (defaults to true), can be disabled with default_build=false

3. Update tests and example code
   - Update calculator and other examples to demonstrate new features
   - Modify related test cases

These improvements simplify API usage and reduce manual configuration needs. In most cases,
users only need to mark #[tool(tool_box)] to get default implementation of the ServerHandler trait.

Author: 姚临倾

crates/rmcp-macros/.DS_Store

@@ -2,10 +2,9 @@
 use proc_macro::TokenStream;
 
 mod tool;
-
 #[proc_macro_attribute]
 pub fn tool(attr: TokenStream, input: TokenStream) -> TokenStream {
     tool::tool(attr.into(), input.into())
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
-}
+}

crates/rmcp-macros/src/lib.rs

@@ -55,7 +55,7 @@ rand = { version = "0.9", optional = true }
 tokio-stream = { version = "0.1", optional = true }
 
 # macro
-rmcp-macros = { version = "0.1", workspace = true, optional = true }
+rmcp-macros = { workspace = true, optional = true }
 
 [features]
 default = ["base64", "macros", "server"]

crates/rmcp-macros/src/tool.rs

@@ -8,7 +8,7 @@ impl Display for ErrorData {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}: {}", self.code.0, self.message)?;
         if let Some(data) = &self.data {
-            write!(f, "({})", data)?;
+            write!(f, "({data})")?;
         }
         Ok(())
     }

crates/rmcp/Cargo.toml

@@ -46,11 +46,33 @@ pub fn cached_schema_for_type<T: JsonSchema + std::any::Any>() -> Arc<JsonObject
     })
 }
 
+/// Like cached_schema_for_type, but ensures the schema type is "object"
+pub fn ensure_object_schema_for_type<T: JsonSchema + std::any::Any>() -> Arc<JsonObject> {
+    let schema = cached_schema_for_type::<T>();
+    // Create a mutable clone of the schema
+    let mut schema_clone = (*schema).clone();
+    
+    // Ensure the schema has type: "object"
+    if let Some(schema_type) = schema_clone.get_mut("type") {
+        *schema_type = serde_json::Value::String("object".to_string());
+    } else {
+        schema_clone.insert("type".to_string(), serde_json::Value::String("object".to_string()));
+    }
+    
+    Arc::new(schema_clone)
+}
+
+#[derive(Deserialize, Serialize, Debug,schemars::JsonSchema)]
+struct A{
+    i:i32,
+    b:i32,
+}
+
 /// Deserialize a JSON object into a type
 pub fn parse_json_object<T: DeserializeOwned>(input: JsonObject) -> Result<T, crate::Error> {
     serde_json::from_value(serde_json::Value::Object(input)).map_err(|e| {
         crate::Error::invalid_params(
-            format!("failed to deserialize parameters: {error}", error = e),
+            format!("failed to deserialize parameters: {e}"),
             None,
         )
     })
@@ -259,7 +281,7 @@ where
         let value: P =
             serde_json::from_value(serde_json::Value::Object(arguments)).map_err(|e| {
                 crate::Error::invalid_params(
-                    format!("failed to deserialize parameters: {error}", error = e),
+                    format!("failed to deserialize parameters: {e}"),
                     None,
                 )
             })?;

crates/rmcp/src/error.rs

@@ -499,6 +499,7 @@ const_string!(InitializedNotificationMethod = "notifications/initialized");
 pub type InitializedNotification = NotificationNoParam<InitializedNotificationMethod>;
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
+#[derive(Default)]
 pub struct InitializeRequestParam {
     pub protocol_version: ProtocolVersion,
     pub capabilities: ClientCapabilities,
@@ -507,6 +508,7 @@ pub struct InitializeRequestParam {
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
+#[derive(Default)]
 pub struct InitializeResult {
     pub protocol_version: ProtocolVersion,
     pub capabilities: ServerCapabilities,
@@ -518,26 +520,7 @@ pub struct InitializeResult {
 pub type ServerInfo = InitializeResult;
 pub type ClientInfo = InitializeRequestParam;
 
-impl Default for ServerInfo {
-    fn default() -> Self {
-        ServerInfo {
-            protocol_version: ProtocolVersion::default(),
-            capabilities: ServerCapabilities::default(),
-            server_info: Implementation::from_build_env(),
-            instructions: None,
-        }
-    }
-}
 
-impl Default for ClientInfo {
-    fn default() -> Self {
-        ClientInfo {
-            protocol_version: ProtocolVersion::default(),
-            capabilities: ClientCapabilities::default(),
-            client_info: Implementation::from_build_env(),
-        }
-    }
-}
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct Implementation {

crates/rmcp/src/handler/server/tool.rs

@@ -546,7 +546,7 @@ where
     let serve_loop_ct = ct.child_token();
     let peer_return: Peer<R> = peer.clone();
     let handle = tokio::spawn(async move {
-        let (mut sink, mut stream) = transport.into_transport();
+        let (sink, stream) = transport.into_transport();
         let mut sink = std::pin::pin!(sink);
         let mut stream = std::pin::pin!(stream);
         let mut batch_messages = VecDeque::<RxJsonRpcMessage<R>>::new();

crates/rmcp/src/model.rs

@@ -49,7 +49,7 @@ where
         .next()
         .await
         .ok_or_else(|| ClientError::ConnectionClosed(context.to_string()))
-        .map_err(|e| ClientError::Io(std::io::Error::new(std::io::ErrorKind::Other, e)))
+        .map_err(|e| ClientError::Io(std::io::Error::other(e)))
 }
 
 /// Helper function to expect a response from the stream
@@ -132,7 +132,7 @@ where
     let handle_client_error = |e: ClientError| -> E {
         match e {
             ClientError::Io(io_err) => io_err.into(),
-            other => std::io::Error::new(std::io::ErrorKind::Other, format!("{}", other)).into(),
+            other => std::io::Error::other(format!("{other}")).into(),
         }
     };
 

crates/rmcp/src/service.rs

@@ -141,7 +141,7 @@ where
     let handle_server_error = |e: ServerError| -> E {
         match e {
             ServerError::Io(io_err) => io_err.into(),
-            other => std::io::Error::new(std::io::ErrorKind::Other, format!("{}", other)).into(),
+            other => std::io::Error::other(format!("{other}")).into(),
         }
     };
 

crates/rmcp/src/service/client.rs

@@ -174,7 +174,7 @@ impl AuthorizationManager {
                 .json::<AuthorizationMetadata>()
                 .await
                 .map_err(|e| {
-                    AuthError::MetadataError(format!("Failed to parse metadata: {}", e))
+                    AuthError::MetadataError(format!("Failed to parse metadata: {e}"))
                 })?;
             debug!("metadata: {:?}", metadata);
             Ok(metadata)
@@ -185,9 +185,9 @@ impl AuthorizationManager {
             auth_base.set_path("");
 
             Ok(AuthorizationMetadata {
-                authorization_endpoint: format!("{}/authorize", auth_base),
-                token_endpoint: format!("{}/token", auth_base),
-                registration_endpoint: format!("{}/register", auth_base),
+                authorization_endpoint: format!("{auth_base}/authorize"),
+                token_endpoint: format!("{auth_base}/token"),
+                registration_endpoint: format!("{auth_base}/register"),
                 issuer: None,
                 jwks_uri: None,
                 scopes_supported: None,
@@ -204,15 +204,15 @@ impl AuthorizationManager {
         let metadata = self.metadata.as_ref().unwrap();
 
         let auth_url = AuthUrl::new(metadata.authorization_endpoint.clone())
-            .map_err(|e| AuthError::OAuthError(format!("Invalid authorization URL: {}", e)))?;
+            .map_err(|e| AuthError::OAuthError(format!("Invalid authorization URL: {e}")))?;
 
         let token_url = TokenUrl::new(metadata.token_endpoint.clone())
-            .map_err(|e| AuthError::OAuthError(format!("Invalid token URL: {}", e)))?;
+            .map_err(|e| AuthError::OAuthError(format!("Invalid token URL: {e}")))?;
 
         // debug!("token url: {:?}", token_url);
         let client_id = ClientId::new(config.client_id);
         let redirect_url = RedirectUrl::new(config.redirect_uri.clone())
-            .map_err(|e| AuthError::OAuthError(format!("Invalid re URL: {}", e)))?;
+            .map_err(|e| AuthError::OAuthError(format!("Invalid re URL: {e}")))?;
 
         debug!("client_id: {:?}", client_id);
         let mut client_builder = BasicClient::new(client_id.clone())
@@ -268,8 +268,7 @@ impl AuthorizationManager {
             Err(e) => {
                 error!("Registration request failed: {}", e);
                 return Err(AuthError::RegistrationFailed(format!(
-                    "HTTP request error: {}",
-                    e
+                    "HTTP request error: {e}"
                 )));
             }
         };
@@ -283,8 +282,7 @@ impl AuthorizationManager {
 
             error!("Registration failed: HTTP {} - {}", status, error_text);
             return Err(AuthError::RegistrationFailed(format!(
-                "HTTP {}: {}",
-                status, error_text
+                "HTTP {status}: {error_text}"
             )));
         }
         debug!("registration response: {:?}", response);
@@ -293,8 +291,7 @@ impl AuthorizationManager {
             Err(e) => {
                 error!("Failed to parse registration response: {}", e);
                 return Err(AuthError::RegistrationFailed(format!(
-                    "analyze response error: {}",
-                    e
+                    "analyze response error: {e}"
                 )));
             }
         };
@@ -451,7 +448,7 @@ impl AuthorizationManager {
         request: reqwest::RequestBuilder,
     ) -> Result<reqwest::RequestBuilder, AuthError> {
         let token = self.get_access_token().await?;
-        Ok(request.header(AUTHORIZATION, format!("Bearer {}", token)))
+        Ok(request.header(AUTHORIZATION, format!("Bearer {token}")))
     }
 
     /// handle response, check if need to re-authorize
@@ -497,7 +494,7 @@ impl AuthorizationSession {
         {
             Ok(config) => config,
             Err(e) => {
-                eprintln!("Dynamic registration failed: {}", e);
+                eprintln!("Dynamic registration failed: {e}");
                 // fallback to default config
                 config
             }

crates/rmcp/src/service/server.rs

@@ -307,7 +307,7 @@ impl<C: SseClient<E>, E: std::error::Error + Send + Sync + 'static> Stream for S
                         if let Some(max_retry_times) = retry_config.max_times {
                             if *times >= max_retry_times {
                                 self.as_mut().state = SseTransportState::Fatal {
-                                    reason: format!("retrying failed after {} times: {}", times, e),
+                                    reason: format!("retrying failed after {times} times: {e}"),
                                 };
                                 return self.poll_next(cx);
                             }

crates/rmcp/src/transport/auth.rs

@@ -87,7 +87,7 @@ impl SseClient<reqwest::Error> for AuthorizedSseClient {
             let mut request_builder = client
                 .get(&sse_url)
                 .header(ACCEPT, MIME_TYPE)
-                .header(AUTHORIZATION, format!("Bearer {}", token));
+                .header(AUTHORIZATION, format!("Bearer {token}"));
 
             if let Some(last_event_id) = last_event_id {
                 request_builder = request_builder.header(HEADER_LAST_EVENT_ID, last_event_id);
@@ -136,7 +136,7 @@ impl SseClient<reqwest::Error> for AuthorizedSseClient {
             let uri = sse_url.join(&session_id).map_err(SseTransportError::from)?;
             let request_builder = client
                 .post(uri.as_ref())
-                .header(AUTHORIZATION, format!("Bearer {}", token))
+                .header(AUTHORIZATION, format!("Bearer {token}"))
                 .json(&message);
 
             request_builder
@@ -151,8 +151,7 @@ impl SseClient<reqwest::Error> for AuthorizedSseClient {
 
 impl From<AuthError> for SseTransportError<reqwest::Error> {
     fn from(err: AuthError) -> Self {
-        SseTransportError::Io(std::io::Error::new(
-            std::io::ErrorKind::Other,
+        SseTransportError::Io(std::io::Error::other(
             err.to_string(),
         ))
     }
@@ -175,8 +174,7 @@ where
             transport.retry_config = retry_config.unwrap_or_default();
             Ok(transport)
         }
-        _ => Err(SseTransportError::Io(std::io::Error::new(
-            std::io::ErrorKind::Other,
+        _ => Err(SseTransportError::Io(std::io::Error::other(
             "Not authorized".to_string(),
         ))),
     }

crates/rmcp/src/transport/sse.rs

@@ -1,6 +1,4 @@
 use rmcp::{
-    ServerHandler,
-    model::{ServerCapabilities, ServerInfo},
     schemars, tool,
 };
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
@@ -11,34 +9,21 @@ pub struct SumRequest {
 }
 #[derive(Debug, Clone, Default)]
 pub struct Calculator;
-#[tool(tool_box)]
+#[tool(tool_box,description = "A simple calculator")]
 impl Calculator {
     #[tool(description = "Calculate the sum of two numbers")]
-    fn sum(&self, #[tool(aggr)] SumRequest { a, b }: SumRequest) -> String {
+    fn sum(&self, SumRequest { a, b }: SumRequest) -> String {
         (a + b).to_string()
     }
 
     #[tool(description = "Calculate the sub of two numbers")]
     fn sub(
         &self,
-        #[tool(param)]
         #[schemars(description = "the left hand side number")]
         a: i32,
-        #[tool(param)]
         #[schemars(description = "the right hand side number")]
         b: i32,
     ) -> String {
         (a - b).to_string()
     }
 }
-
-#[tool(tool_box)]
-impl ServerHandler for Calculator {
-    fn get_info(&self) -> ServerInfo {
-        ServerInfo {
-            instructions: Some("A simple calculator".into()),
-            capabilities: ServerCapabilities::builder().enable_tools().build(),
-            ..Default::default()
-        }
-    }
-}

crates/rmcp/src/transport/sse_auth.rs

@@ -100,7 +100,7 @@ impl ClientHandler for TestClientHandler {
         let received_messages = self.received_messages.clone();
 
         async move {
-            println!("Client: Received log message: {:?}", params);
+            println!("Client: Received log message: {params:?}");
             let mut messages = received_messages.lock().unwrap();
             messages.push(params);
             receive_signal.notify_one();
@@ -185,7 +185,7 @@ impl ServerHandler for TestServer {
                 })
                 .await
             {
-                panic!("Failed to send notification: {}", e);
+                panic!("Failed to send notification: {e}");
             }
             Ok(())
         }

crates/rmcp/tests/common/calculator.rs

@@ -33,7 +33,7 @@ impl Demo {
     #[tool(description = "LLM")]
     async fn chat(
         &self,
-        #[tool(aggr)] chat_request: ChatRequest,
+        chat_request: ChatRequest,
     ) -> Result<CallToolResult, McpError> {
         let content = Content::json(chat_request)?;
         Ok(CallToolResult::success(vec![content]))

crates/rmcp/tests/common/handlers.rs

@@ -210,19 +210,17 @@ fn test_logging_level_serialization() {
         let serialized = serialized.trim_matches('"');
         assert_eq!(
             serialized, expected,
-            "LoggingLevel::{:?} should serialize to \"{}\"",
-            level, expected
+            "LoggingLevel::{level:?} should serialize to \"{expected}\""
         );
     }
 
     // Test deserialization from spec strings
     for (level, spec_string) in test_cases {
         let deserialized: LoggingLevel =
-            serde_json::from_str(&format!("\"{}\"", spec_string)).unwrap();
+            serde_json::from_str(&format!("\"{spec_string}\"")).unwrap();
         assert_eq!(
             deserialized, level,
-            "\"{}\" should deserialize to LoggingLevel::{:?}",
-            spec_string, level
+            "\"{spec_string}\" should deserialize to LoggingLevel::{level:?}"
         );
     }
 }

crates/rmcp/tests/test_complex_schema.rs

@@ -39,7 +39,7 @@ impl ServerHandler for Server {
                 .notify_resource_updated(ResourceUpdatedNotificationParam { uri: uri.clone() })
                 .await
             {
-                panic!("Failed to send notification: {}", e);
+                panic!("Failed to send notification: {e}");
             }
         });