rust_mcp_sdk/mcp_runtimes/server_runtime/
mcp_server_runtime.rs

1use std::sync::Arc;
2
3use crate::schema::{
4    schema_utils::{
5        self, CallToolError, ClientMessage, MessageFromServer, NotificationFromClient,
6        RequestFromClient, ResultFromServer,
7    },
8    CallToolResult, ClientNotification, ClientRequest, InitializeResult, RpcError,
9};
10use async_trait::async_trait;
11use rust_mcp_transport::Transport;
12
13use super::ServerRuntime;
14#[cfg(feature = "hyper-server")]
15use rust_mcp_transport::SessionId;
16
17use crate::{
18    error::SdkResult,
19    mcp_handlers::mcp_server_handler::ServerHandler,
20    mcp_traits::{mcp_handler::McpServerHandler, mcp_server::McpServer},
21};
22
23/// Creates a new MCP server runtime with the specified configuration.
24///
25/// This function initializes a server for (MCP) by accepting server details, transport ,
26/// and a handler for server-side logic.
27/// The resulting `ServerRuntime` manages the server's operation and communication with MCP clients.
28///
29/// # Arguments
30/// * `server_details` - Server name , version and capabilities.
31/// * `transport` - An implementation of the `Transport` trait facilitating communication with the MCP clients.
32/// * `handler` - An implementation of the `ServerHandler` trait that defines the server's core behavior and response logic.
33///
34/// # Returns
35/// A `ServerRuntime` instance representing the initialized server, ready for asynchronous operation.
36///
37/// # Examples
38/// You can find a detailed example of how to use this function in the repository:
39///
40/// [Repository Example](https://github.com/rust-mcp-stack/rust-mcp-sdk/tree/main/examples/hello-world-mcp-server)
41pub fn create_server(
42    server_details: InitializeResult,
43    transport: impl Transport<ClientMessage, MessageFromServer>,
44    handler: impl ServerHandler,
45) -> ServerRuntime {
46    ServerRuntime::new(
47        server_details,
48        transport,
49        Arc::new(ServerRuntimeInternalHandler::new(Box::new(handler))),
50    )
51}
52
53#[cfg(feature = "hyper-server")]
54pub(crate) fn create_server_instance(
55    server_details: Arc<InitializeResult>,
56    transport: impl Transport<ClientMessage, MessageFromServer>,
57    handler: Arc<dyn McpServerHandler>,
58    session_id: SessionId,
59) -> ServerRuntime {
60    ServerRuntime::new_instance(server_details, transport, handler, session_id)
61}
62
63pub(crate) struct ServerRuntimeInternalHandler<H> {
64    handler: H,
65}
66impl ServerRuntimeInternalHandler<Box<dyn ServerHandler>> {
67    pub fn new(handler: Box<dyn ServerHandler>) -> Self {
68        Self { handler }
69    }
70}
71
72#[async_trait]
73impl McpServerHandler for ServerRuntimeInternalHandler<Box<dyn ServerHandler>> {
74    async fn handle_request(
75        &self,
76        client_jsonrpc_request: RequestFromClient,
77        runtime: &dyn McpServer,
78    ) -> std::result::Result<ResultFromServer, RpcError> {
79        match client_jsonrpc_request {
80            schema_utils::RequestFromClient::ClientRequest(client_request) => {
81                match client_request {
82                    ClientRequest::InitializeRequest(initialize_request) => self
83                        .handler
84                        .handle_initialize_request(initialize_request, runtime)
85                        .await
86                        .map(|value| value.into()),
87                    ClientRequest::PingRequest(ping_request) => self
88                        .handler
89                        .handle_ping_request(ping_request, runtime)
90                        .await
91                        .map(|value| value.into()),
92                    ClientRequest::ListResourcesRequest(list_resources_request) => self
93                        .handler
94                        .handle_list_resources_request(list_resources_request, runtime)
95                        .await
96                        .map(|value| value.into()),
97                    ClientRequest::ListResourceTemplatesRequest(
98                        list_resource_templates_request,
99                    ) => self
100                        .handler
101                        .handle_list_resource_templates_request(
102                            list_resource_templates_request,
103                            runtime,
104                        )
105                        .await
106                        .map(|value| value.into()),
107                    ClientRequest::ReadResourceRequest(read_resource_request) => self
108                        .handler
109                        .handle_read_resource_request(read_resource_request, runtime)
110                        .await
111                        .map(|value| value.into()),
112                    ClientRequest::SubscribeRequest(subscribe_request) => self
113                        .handler
114                        .handle_subscribe_request(subscribe_request, runtime)
115                        .await
116                        .map(|value| value.into()),
117                    ClientRequest::UnsubscribeRequest(unsubscribe_request) => self
118                        .handler
119                        .handle_unsubscribe_request(unsubscribe_request, runtime)
120                        .await
121                        .map(|value| value.into()),
122                    ClientRequest::ListPromptsRequest(list_prompts_request) => self
123                        .handler
124                        .handle_list_prompts_request(list_prompts_request, runtime)
125                        .await
126                        .map(|value| value.into()),
127
128                    ClientRequest::GetPromptRequest(prompt_request) => self
129                        .handler
130                        .handle_get_prompt_request(prompt_request, runtime)
131                        .await
132                        .map(|value| value.into()),
133                    ClientRequest::ListToolsRequest(list_tools_request) => self
134                        .handler
135                        .handle_list_tools_request(list_tools_request, runtime)
136                        .await
137                        .map(|value| value.into()),
138                    ClientRequest::CallToolRequest(call_tool_request) => {
139                        let result = self
140                            .handler
141                            .handle_call_tool_request(call_tool_request, runtime)
142                            .await;
143
144                        Ok(result.map_or_else(
145                            |err| {
146                                let result: CallToolResult = CallToolError::new(err).into();
147                                result.into()
148                            },
149                            Into::into,
150                        ))
151                    }
152                    ClientRequest::SetLevelRequest(set_level_request) => self
153                        .handler
154                        .handle_set_level_request(set_level_request, runtime)
155                        .await
156                        .map(|value| value.into()),
157                    ClientRequest::CompleteRequest(complete_request) => self
158                        .handler
159                        .handle_complete_request(complete_request, runtime)
160                        .await
161                        .map(|value| value.into()),
162                }
163            }
164            schema_utils::RequestFromClient::CustomRequest(value) => self
165                .handler
166                .handle_custom_request(value, runtime)
167                .await
168                .map(|value| value.into()),
169        }
170    }
171
172    async fn handle_error(
173        &self,
174        jsonrpc_error: RpcError,
175        runtime: &dyn McpServer,
176    ) -> SdkResult<()> {
177        self.handler.handle_error(jsonrpc_error, runtime).await?;
178        Ok(())
179    }
180
181    async fn handle_notification(
182        &self,
183        client_jsonrpc_notification: NotificationFromClient,
184        runtime: &dyn McpServer,
185    ) -> SdkResult<()> {
186        match client_jsonrpc_notification {
187            schema_utils::NotificationFromClient::ClientNotification(client_notification) => {
188                match client_notification {
189                    ClientNotification::CancelledNotification(cancelled_notification) => {
190                        self.handler
191                            .handle_cancelled_notification(cancelled_notification, runtime)
192                            .await?;
193                    }
194                    ClientNotification::InitializedNotification(initialized_notification) => {
195                        self.handler
196                            .handle_initialized_notification(initialized_notification, runtime)
197                            .await?;
198                        self.handler.on_initialized(runtime).await;
199                    }
200                    ClientNotification::ProgressNotification(progress_notification) => {
201                        self.handler
202                            .handle_progress_notification(progress_notification, runtime)
203                            .await?;
204                    }
205                    ClientNotification::RootsListChangedNotification(
206                        roots_list_changed_notification,
207                    ) => {
208                        self.handler
209                            .handle_roots_list_changed_notification(
210                                roots_list_changed_notification,
211                                runtime,
212                            )
213                            .await?;
214                    }
215                }
216            }
217            schema_utils::NotificationFromClient::CustomNotification(value) => {
218                self.handler.handle_custom_notification(value).await?;
219            }
220        }
221        Ok(())
222    }
223
224    async fn on_server_started(&self, runtime: &dyn McpServer) {
225        self.handler.on_server_started(runtime).await;
226    }
227}
rust_mcp_sdk/mcp_runtimes/server_runtime/mcp_server_runtime.rs

rust_mcp_sdk/mcp_runtimes/server_runtime/
mcp_server_runtime.rs
