fmt

Author: Hendler

crates/rmcp/tests/common/handlers.rs

@@ -1,13 +1,14 @@
+use std::{
+    future::Future,
+    sync::{Arc, Mutex},
+};
+
 use rmcp::{
     ClientHandler, Error as McpError, RoleClient, RoleServer, ServerHandler,
     model::*,
     service::{Peer, RequestContext},
 };
 use serde_json::json;
-use std::{
-    future::Future,
-    sync::{Arc, Mutex},
-};
 use tokio::sync::Notify;
 
 #[derive(Clone)]
@@ -57,40 +58,38 @@ impl ClientHandler for TestClientHandler {
         self.peer = Some(peer);
     }
 
-    fn create_message(
+    async fn create_message(
         &self,
         params: CreateMessageRequestParam,
         _context: RequestContext<RoleClient>,
-    ) -> impl Future<Output = Result<CreateMessageResult, McpError>> + Send + '_ {
-        async move {
-            // First validate that there's at least one User message
-            if !params.messages.iter().any(|msg| msg.role == Role::User) {
-                return Err(McpError::invalid_request(
-                    "Message sequence must contain at least one user message",
-                    Some(json!({"messages": params.messages})),
-                ));
-            }
+    ) -> Result<CreateMessageResult, McpError> {
+        // First validate that there's at least one User message
+        if !params.messages.iter().any(|msg| msg.role == Role::User) {
+            return Err(McpError::invalid_request(
+                "Message sequence must contain at least one user message",
+                Some(json!({"messages": params.messages})),
+            ));
+        }
 
-            // Create response based on context inclusion
-            let response = match params.include_context {
-                Some(ContextInclusion::ThisServer) if self.honor_this_server => {
-                    "Test response with context: test context"
-                }
-                Some(ContextInclusion::AllServers) if self.honor_all_servers => {
-                    "Test response with context: test context"
-                }
-                _ => "Test response without context",
-            };
+        // Create response based on context inclusion
+        let response = match params.include_context {
+            Some(ContextInclusion::ThisServer) if self.honor_this_server => {
+                "Test response with context: test context"
+            }
+            Some(ContextInclusion::AllServers) if self.honor_all_servers => {
+                "Test response with context: test context"
+            }
+            _ => "Test response without context",
+        };
 
-            Ok(CreateMessageResult {
-                message: SamplingMessage {
-                    role: Role::Assistant,
-                    content: Content::text(response.to_string()),
-                },
-                model: "test-model".to_string(),
-                stop_reason: Some(CreateMessageResult::STOP_REASON_END_TURN.to_string()),
-            })
-        }
+        Ok(CreateMessageResult {
+            message: SamplingMessage {
+                role: Role::Assistant,
+                content: Content::text(response.to_string()),
+            },
+            model: "test-model".to_string(),
+            stop_reason: Some(CreateMessageResult::STOP_REASON_END_TURN.to_string()),
+        })
     }
 
     fn on_logging_message(
@@ -112,6 +111,7 @@ impl ClientHandler for TestClientHandler {
 pub struct TestServer {}
 
 impl TestServer {
+    #[allow(dead_code)]
     pub fn new() -> Self {
         Self {}
     }

crates/rmcp/tests/test_message_protocol.rs

@@ -2,7 +2,6 @@
 
 mod common;
 use common::handlers::{TestClientHandler, TestServer};
-
 use rmcp::{
     ServiceExt,
     model::*,