rust-mcp-schema 0.10.0

Type-safe implementation of the Model Context Protocol in Rust, designed to reduce errors and accelerate development with powerful utilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#![cfg_attr(rustfmt, rustfmt_skip)]
#[cfg(feature = "latest")]
use rust_mcp_schema::{schema_utils::*, *};
use std::str::FromStr;

#[cfg(feature = "latest")]
type AppError = RpcError;

const SAMPLE_PAYLOAD: &str = r#"
{
    "id": 0,
    "jsonrpc": "2.0",
    "method": "initialize",
    "params": {
        "protocolVersion": "2024-11-05",
        "capabilities": {
            "sampling": {},
            "roots": {
                "listChanged": true
            }
        },
        "clientInfo": {
            "name": "mcp-inspector",
            "version": "0.1.0"
        }
    }
}
"#;

fn main() {
    #[cfg(feature = "latest")]
    if let Err(error) = handle_message(SAMPLE_PAYLOAD) {
        eprintln!("Error occurred: {:?}", error);
    }
}

#[cfg(feature = "latest")]
/// Deserialize the JSON-RPC message into the appropriate MCP type and print it with dbg!() macro .
fn handle_message(message_payload: &str) -> std::result::Result<(), AppError> {
    // Deserialize message into ClientMessage.
    // ClientMessage represents a message sent by an MCP Client and received by an MCP Server.
    let mcp_message = ClientMessage::from_str(message_payload)?;

    match mcp_message {
        // Determine if the message is a Request
        ClientMessage::Request(request) => match request {
            ClientJsonrpcRequest::InitializeRequest(initialize_request) => println!("InitializeRequest request received: {:?}", initialize_request),
            ClientJsonrpcRequest::PingRequest(ping_request) => println!("PingRequest request received: {:?}", ping_request),
            ClientJsonrpcRequest::ListResourcesRequest(list_resources_request) => println!("ListResourcesRequest request received: {:?}", list_resources_request),
            ClientJsonrpcRequest::ListResourceTemplatesRequest(list_resource_templates_request) => println!("ListResourceTemplatesRequest request received: {:?}",list_resource_templates_request),
            ClientJsonrpcRequest::ReadResourceRequest(read_resource_request) => println!("ReadResourceRequest request received: {:?}", read_resource_request),
            ClientJsonrpcRequest::SubscribeRequest(subscribe_request) => println!("SubscribeRequest request received: {:?}", subscribe_request),
            ClientJsonrpcRequest::UnsubscribeRequest(unsubscribe_request) => println!("UnsubscribeRequest request received: {:?}", unsubscribe_request),
            ClientJsonrpcRequest::ListPromptsRequest(list_prompts_request) => println!("ListPromptsRequest request received: {:?}", list_prompts_request),
            ClientJsonrpcRequest::GetPromptRequest(get_prompt_request) => println!("GetPromptRequest request received: {:?}", get_prompt_request),
            ClientJsonrpcRequest::ListToolsRequest(list_tools_request) => println!("ListToolsRequest request received: {:?}", list_tools_request),
            ClientJsonrpcRequest::CallToolRequest(call_tool_request) => println!("CallToolRequest request received: {:?}", call_tool_request),
            ClientJsonrpcRequest::GetTaskRequest(get_task_request) => println!("GetTaskRequest request received: {:?}", get_task_request),
            ClientJsonrpcRequest::GetTaskPayloadRequest(get_task_payload_request) => println!("GetTaskPayloadRequest request received: {:?}", get_task_payload_request),
            ClientJsonrpcRequest::CancelTaskRequest(cancel_task_request) => println!("CancelTaskRequest request received: {:?}", cancel_task_request),
            ClientJsonrpcRequest::ListTasksRequest(list_tasks_request) => println!("ListTasksRequest request received: {:?}", list_tasks_request),
            ClientJsonrpcRequest::SetLevelRequest(set_level_request) => println!("SetLevelRequest request received: {:?}", set_level_request),
            ClientJsonrpcRequest::CompleteRequest(complete_request) => println!("CompleteRequest request received: {:?}", complete_request),
            ClientJsonrpcRequest::CustomRequest(jsonrpc_request) => println!("CustomRequest request received: {:?}", jsonrpc_request),
        },
        // Determine if the message is a Notification
        ClientMessage::Notification(notification) => match notification {
            ClientJsonrpcNotification::CancelledNotification(cancelled_notification) => println!("CancelledNotification notification received: {:?}", cancelled_notification),
            ClientJsonrpcNotification::InitializedNotification(initialized_notification) => println!("InitializedNotification notification received: {:?}",initialized_notification),
            ClientJsonrpcNotification::ProgressNotification(progress_notification) => println!("ProgressNotification notification received: {:?}", progress_notification),
            ClientJsonrpcNotification::TaskStatusNotification(task_status_notification) => println!("TaskStatusNotification notification received: {:?}", task_status_notification),
            ClientJsonrpcNotification::RootsListChangedNotification(roots_list_changed_notification) => println!("RootsListChangedNotification notification received: {:?}",roots_list_changed_notification),
            ClientJsonrpcNotification::CustomNotification(jsonrpc_notification) => println!("CustomNotification notification received: {:?}", jsonrpc_notification),
        },
        // Determine if the message is a Response
        ClientMessage::Response(response) => match &response.result {
            ResultFromClient::GetTaskResult(_get_task_result) => println!("GetTaskResult  response received: {:?}", response),
            ResultFromClient::CancelTaskResult(_cancel_task_result) => println!("CancelTaskResult  response received: {:?}", response),
            ResultFromClient::ListTasksResult(_list_tasks_result) => println!("ListTasksResult  response received: {:?}", response),
            ResultFromClient::CreateMessageResult(_create_message_result) => println!("CreateMessageResult  response received: {:?}", response),
            ResultFromClient::ListRootsResult(_list_roots_result) => println!("ListRootsResult  response received: {:?}", response),
            ResultFromClient::ElicitResult(_elicit_result) => println!("ElicitResult  response received: {:?}", response),
            ResultFromClient::CreateTaskResult(_create_task_result) => println!("CreateTaskResult response received: {:?}", response),
            ResultFromClient::Result(_generic_result) => println!("Generic Result response received: {:?}", response),
            ResultFromClient::GetTaskPayloadResult(_generic_result) => println!("Generic Result response received: {:?}", response),
        },
        // Determine if the message is an Error
        ClientMessage::Error(error_response) => {
            println!("Error response received: {:?}", error_response)
        }
    }

    Ok(())
}