refactor: refactor tool macros and router implementation (#261)

* refactor: refactor tool macros and router implementation

- Updated the `#[tool(tool_box)]` macro to `#[tool_router]` across various modules for consistency.
- Enhanced the `Calculator`, `Counter`, and `GenericService` structs to utilize `ToolRouter` for handling tool calls.
- Introduced `Parameters` struct for better parameter handling in tool functions.
- Added new methods for listing tools and calling tools in server handlers.
- Improved test cases to reflect changes in tool routing and parameter handling.
- Updated documentation and examples to align with the new router structure.

* fix: fix fmt and build error

* fix: fix test failure

* docs: documents for macros, fix ci

* fix: fix ci

* fix: fix wrongly replaced documents

* fix: remove useless file

* fix: change the parameter format for tool_router

* fix: update extract_doc_line to handle existing documentation and clean up unused code in server handler

* doc: update document for macro and examples

* doc: update readme and add contribute guide

* fix: fix type

examples/servers/src/common/calculator.rs

@@ -1,8 +1,10 @@
+#![allow(dead_code)]
+
 use rmcp::{
     ServerHandler,
-    handler::server::wrapper::Json,
+    handler::server::{router::tool::ToolRouter, tool::Parameters, wrapper::Json},
     model::{ServerCapabilities, ServerInfo},
-    schemars, tool,
+    schemars, tool, tool_handler, tool_router,
 };
 
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
@@ -11,30 +13,40 @@ pub struct SumRequest {
     pub a: i32,
     pub b: i32,
 }
+
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+pub struct SubRequest {
+    #[schemars(description = "the left hand side number")]
+    pub a: i32,
+    #[schemars(description = "the right hand side number")]
+    pub b: i32,
+}
+
 #[derive(Debug, Clone)]
-pub struct Calculator;
-#[tool(tool_box)]
+pub struct Calculator {
+    tool_router: ToolRouter<Self>,
+}
+
+#[tool_router]
 impl Calculator {
+    pub fn new() -> Self {
+        Self {
+            tool_router: Self::tool_router(),
+        }
+    }
+
     #[tool(description = "Calculate the sum of two numbers")]
-    fn sum(&self, #[tool(aggr)] SumRequest { a, b }: SumRequest) -> String {
+    fn sum(&self, Parameters(SumRequest { a, b }): Parameters<SumRequest>) -> String {
         (a + b).to_string()
     }
 
     #[tool(description = "Calculate the difference 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,
-    ) -> Json<i32> {
+    fn sub(&self, Parameters(SubRequest { a, b }): Parameters<SubRequest>) -> Json<i32> {
         Json(a - b)
     }
 }
 
-#[tool(tool_box)]
+#[tool_handler]
 impl ServerHandler for Calculator {
     fn get_info(&self) -> ServerInfo {
         ServerInfo {

examples/servers/src/common/counter.rs

@@ -1,8 +1,13 @@
+#![allow(dead_code)]
 use std::sync::Arc;
 
 use rmcp::{
-    Error as McpError, RoleServer, ServerHandler, const_string, model::*, schemars,
-    service::RequestContext, tool,
+    Error as McpError, RoleServer, ServerHandler,
+    handler::server::{router::tool::ToolRouter, tool::Parameters},
+    model::*,
+    schemars,
+    service::RequestContext,
+    tool, tool_handler, tool_router,
 };
 use serde_json::json;
 use tokio::sync::Mutex;
@@ -16,14 +21,16 @@ pub struct StructRequest {
 #[derive(Clone)]
 pub struct Counter {
     counter: Arc<Mutex<i32>>,
+    tool_router: ToolRouter<Counter>,
 }
 
-#[tool(tool_box)]
+#[tool_router]
 impl Counter {
     #[allow(dead_code)]
     pub fn new() -> Self {
         Self {
             counter: Arc::new(Mutex::new(0)),
+            tool_router: Self::tool_router(),
         }
     }
 
@@ -63,27 +70,23 @@ impl Counter {
     }
 
     #[tool(description = "Repeat what you say")]
-    fn echo(
-        &self,
-        #[tool(param)]
-        #[schemars(description = "Repeat what you say")]
-        saying: String,
-    ) -> Result<CallToolResult, McpError> {
-        Ok(CallToolResult::success(vec![Content::text(saying)]))
+    fn echo(&self, Parameters(object): Parameters<JsonObject>) -> Result<CallToolResult, McpError> {
+        Ok(CallToolResult::success(vec![Content::text(
+            serde_json::Value::Object(object).to_string(),
+        )]))
     }
 
     #[tool(description = "Calculate the sum of two numbers")]
     fn sum(
         &self,
-        #[tool(aggr)] StructRequest { a, b }: StructRequest,
+        Parameters(StructRequest { a, b }): Parameters<StructRequest>,
     ) -> Result<CallToolResult, McpError> {
         Ok(CallToolResult::success(vec![Content::text(
             (a + b).to_string(),
         )]))
     }
 }
-const_string!(Echo = "echo");
-#[tool(tool_box)]
+#[tool_handler]
 impl ServerHandler for Counter {
     fn get_info(&self) -> ServerInfo {
         ServerInfo {

examples/servers/src/common/generic_service.rs

@@ -2,8 +2,9 @@ use std::sync::Arc;
 
 use rmcp::{
     ServerHandler,
+    handler::server::{router::tool::ToolRouter, tool::Parameters},
     model::{ServerCapabilities, ServerInfo},
-    schemars, tool,
+    schemars, tool, tool_handler, tool_router,
 };
 
 #[allow(dead_code)]
@@ -40,14 +41,21 @@ impl DataService for MemoryDataService {
 pub struct GenericService<DS: DataService> {
     #[allow(dead_code)]
     data_service: Arc<DS>,
+    tool_router: ToolRouter<Self>,
 }
 
-#[tool(tool_box)]
+#[derive(Debug, schemars::JsonSchema, serde::Deserialize, serde::Serialize)]
+pub struct SetDataRequest {
+    pub data: String,
+}
+
+#[tool_router]
 impl<DS: DataService> GenericService<DS> {
     #[allow(dead_code)]
     pub fn new(data_service: DS) -> Self {
         Self {
             data_service: Arc::new(data_service),
+            tool_router: Self::tool_router(),
         }
     }
 
@@ -57,13 +65,16 @@ impl<DS: DataService> GenericService<DS> {
     }
 
     #[tool(description = "set memory to service")]
-    pub async fn set_data(&self, #[tool(param)] data: String) -> String {
+    pub async fn set_data(
+        &self,
+        Parameters(SetDataRequest { data }): Parameters<SetDataRequest>,
+    ) -> String {
         let new_data = data.clone();
         format!("Current memory: {}", new_data)
     }
 }
 
-#[tool(tool_box)]
+#[tool_handler]
 impl<DS: DataService> ServerHandler for GenericService<DS> {
     fn get_info(&self) -> ServerInfo {
         ServerInfo {