[Jimy][mcp] Allow metadata to be passed from tool call

Cargo.toml

@@ -33,6 +33,7 @@ reqwest = { version = "0.12", features = ["json"] }
 reqwest-eventsource = "0.6"
 mime = "0.3"
 tokio-tungstenite = { version = "0.26", features = ["native-tls"] }
+typed-builder = "0.21.0"
 tracing-core = "0.1"
 async-recursion = "1"
 http = "1.1"

bin/client.rs

@@ -2,9 +2,8 @@ use clap::{Parser, Subcommand};
 use mcp_rs::{
     client::{Client, ClientInfo},
     error::McpError,
-    transport::sse::SseTransport,
-    transport::stdio::StdioTransport,
-    transport::ws::WebSocketTransport,
+    tools::CallToolArgs,
+    transport::{sse::SseTransport, stdio::StdioTransport, ws::WebSocketTransport},
 };
 use serde_json::json;
 
@@ -69,6 +68,10 @@ enum Commands {
         name: String,
         #[arg(short, long)]
         args: String,
+        #[arg(short, long)]
+        tool_id: Option<String>,
+        #[arg(short, long)]
+        session_id: Option<String>,
     },
     /// Set log level
     SetLogLevel {
@@ -236,10 +239,26 @@ async fn main() -> Result<(), McpError> {
             println!("{}", json!(res));
         }
 
-        Commands::CallTool { name, args } => {
+        Commands::CallTool {
+            name,
+            args,
+            tool_id,
+            session_id,
+        } => {
             let arguments =
                 serde_json::from_str(&args).map_err(|e| McpError::InvalidRequest(e.to_string()))?;
-            let res = client.call_tool(name, arguments).await?;
+            let res = client
+                .call_tool(
+                    name,
+                    arguments,
+                    Some(
+                        CallToolArgs::builder()
+                            .session_id(session_id)
+                            .tool_id(tool_id)
+                            .build(),
+                    ),
+                )
+                .await?;
             println!("{}", json!(res));
         }
 

src/client/mod.rs

@@ -9,7 +9,10 @@ use crate::{
         ListResourcesRequest, ListResourcesResponse, ReadResourceRequest, ReadResourceResponse,
         ResourceCapabilities,
     },
-    tools::{CallToolRequest, ListToolsRequest, ListToolsResponse, ToolCapabilities, ToolResult},
+    tools::{
+        CallToolArgs, CallToolRequest, ListToolsRequest, ListToolsResponse, ToolCapabilities,
+        ToolResult,
+    },
     transport::{Transport, TransportCommand},
 };
 use serde::{Deserialize, Serialize};
@@ -245,14 +248,19 @@ impl Client {
         &self,
         name: String,
         arguments: serde_json::Value,
+        metadata: Option<CallToolArgs>,
     ) -> Result<ToolResult, McpError> {
         self.assert_initialized().await?;
         self.assert_capability("tools").await?;
 
         self.protocol
             .request(
                 "tools/call",
-                Some(CallToolRequest { name, arguments }),
+                Some(CallToolRequest {
+                    name,
+                    arguments,
+                    metadata,
+                }),
                 None,
             )
             .await

src/server/mod.rs

@@ -347,7 +347,7 @@ where
                         serde_json::from_value(req.params.unwrap_or_default())
                             .map_err(|_| McpError::InvalidParams)?;
                     let result = tool_manager
-                        .call_tool(&params.name, params.arguments)
+                        .call_tool(&params.name, params.arguments, params.metadata)
                         .await?;
                     Ok(serde_json::to_value(result).unwrap())
                 })

src/tools/calculator.rs

@@ -7,7 +7,7 @@ use crate::{
     protocol::{RequestHandler, ServerCapabilities},
 };
 
-use super::{Tool, ToolContent, ToolInputSchema, ToolProvider, ToolResult};
+use super::{CallToolArgs, Tool, ToolContent, ToolInputSchema, ToolProvider, ToolResult};
 
 // Domain types
 #[derive(Debug, serde::Deserialize)]
@@ -205,7 +205,11 @@ impl ToolProvider for CalculatorTool {
         }
     }
 
-    async fn execute(&self, arguments: serde_json::Value) -> Result<ToolResult, McpError> {
+    async fn execute(
+        &self,
+        arguments: Value,
+        _metadata: Option<CallToolArgs>,
+    ) -> Result<ToolResult, McpError> {
         let params: CalculatorParams = serde_json::from_value(arguments).map_err(|e| {
             tracing::error!("Error parsing calculator arguments: {:?}", e);
             McpError::InvalidParams
@@ -301,6 +305,12 @@ mod tests {
                     "a": 2.0,
                     "b": 3.0
                 }),
+                Some(
+                    CallToolArgs::builder()
+                        .session_id(Some("session-1234".to_string()))
+                        .tool_id(Some("calculator-1234".to_string()))
+                        .build(),
+                ),
             )
             .await
             .unwrap();
@@ -319,6 +329,12 @@ mod tests {
                     "operation": "ln",
                     "a": 2.718281828459045
                 }),
+                Some(
+                    CallToolArgs::builder()
+                        .session_id(Some("session-5678".to_string()))
+                        .tool_id(Some("calculator-5678".to_string()))
+                        .build(),
+                ),
             )
             .await
             .unwrap();
@@ -350,6 +366,12 @@ mod tests {
                     "a": -1.0,
                     "b": 10.0
                 }),
+                Some(
+                    CallToolArgs::builder()
+                        .session_id(Some("session-9999".to_string()))
+                        .tool_id(Some("calculator-9999".to_string()))
+                        .build(),
+                ),
             )
             .await
             .unwrap();

src/tools/file_system/directory.rs

@@ -5,7 +5,7 @@ use tokio::fs;
 
 use crate::{
     error::McpError,
-    tools::{Tool, ToolContent, ToolInputSchema, ToolProvider, ToolResult},
+    tools::{CallToolArgs, Tool, ToolContent, ToolInputSchema, ToolProvider, ToolResult},
 };
 
 pub struct DirectoryTool;
@@ -57,7 +57,11 @@ impl ToolProvider for DirectoryTool {
         }
     }
 
-    async fn execute(&self, arguments: Value) -> Result<ToolResult, McpError> {
+    async fn execute(
+        &self,
+        arguments: Value,
+        _metadata: Option<CallToolArgs>,
+    ) -> Result<ToolResult, McpError> {
         match arguments["operation"].as_str() {
             Some("create_directory") => {
                 let path = arguments["path"].as_str().ok_or(McpError::InvalidParams)?;