rmcp 1.5.0

Rust SDK for Model Context Protocol
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//cargo test --test test_prompt_handler --features "client server"
// Tests for verifying that the #[prompt_handler] macro correctly generates
// the ServerHandler trait implementation methods.
#![allow(dead_code)]

use rmcp::{
    RoleServer, ServerHandler,
    handler::server::router::prompt::PromptRouter,
    model::{GetPromptRequestParams, GetPromptResult, ListPromptsResult, PaginatedRequestParams},
    prompt_handler,
    service::RequestContext,
};

#[derive(Debug, Clone)]
pub struct TestPromptServer {
    prompt_router: PromptRouter<Self>,
}

impl Default for TestPromptServer {
    fn default() -> Self {
        Self::new()
    }
}

impl TestPromptServer {
    pub fn new() -> Self {
        Self {
            prompt_router: PromptRouter::new(),
        }
    }
}

#[prompt_handler(router = self.prompt_router)]
impl ServerHandler for TestPromptServer {}

#[derive(Debug, Clone)]
pub struct CustomRouterServer {
    custom_router: PromptRouter<Self>,
}

impl Default for CustomRouterServer {
    fn default() -> Self {
        Self::new()
    }
}

impl CustomRouterServer {
    pub fn new() -> Self {
        Self {
            custom_router: PromptRouter::new(),
        }
    }

    pub fn get_custom_router(&self) -> &PromptRouter<Self> {
        &self.custom_router
    }
}

#[prompt_handler(router = self.custom_router)]
impl ServerHandler for CustomRouterServer {}

#[derive(Debug, Clone)]
pub struct GenericPromptServer<T: Send + Sync + 'static> {
    prompt_router: PromptRouter<Self>,
    _marker: std::marker::PhantomData<T>,
}

impl<T: Send + Sync + 'static> Default for GenericPromptServer<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Send + Sync + 'static> GenericPromptServer<T> {
    pub fn new() -> Self {
        Self {
            prompt_router: PromptRouter::new(),
            _marker: std::marker::PhantomData,
        }
    }
}

#[prompt_handler(router = self.prompt_router)]
impl<T: Send + Sync + 'static> ServerHandler for GenericPromptServer<T> {}

#[test]
fn test_prompt_handler_basic() {
    let server = TestPromptServer::new();

    // Test that the server implements ServerHandler
    fn assert_server_handler<T: ServerHandler>(_: &T) {}
    assert_server_handler(&server);

    // Test that the prompt router is accessible
    assert_eq!(server.prompt_router.list_all().len(), 0);
}

#[test]
fn test_prompt_handler_custom_router() {
    let server = CustomRouterServer::new();

    // Test that the server implements ServerHandler
    fn assert_server_handler<T: ServerHandler>(_: &T) {}
    assert_server_handler(&server);

    // Test that the custom router is used
    assert_eq!(server.custom_router.list_all().len(), 0);
}

#[test]
fn test_prompt_handler_with_generics() {
    let server = GenericPromptServer::<String>::new();

    // Test that generic server implements ServerHandler
    fn assert_server_handler<T: ServerHandler>(_: &T) {}
    assert_server_handler(&server);

    // Test with a different generic type
    let server2 = GenericPromptServer::<i32>::new();
    assert_server_handler(&server2);
}

#[test]
fn test_prompt_handler_trait_implementation() {
    // This test verifies that the prompt_handler macro generates proper ServerHandler implementation
    // The actual method signatures are tested through the ServerHandler trait bound
    fn compile_time_check<T: ServerHandler>() {}

    compile_time_check::<TestPromptServer>();
    compile_time_check::<CustomRouterServer>();
    compile_time_check::<GenericPromptServer<String>>();
}

// Test that the macro works with different server configurations
mod nested {
    use super::*;

    #[derive(Debug, Clone)]
    pub struct NestedServer {
        prompt_router: PromptRouter<Self>,
    }

    impl NestedServer {
        pub fn new() -> Self {
            Self {
                prompt_router: PromptRouter::new(),
            }
        }
    }

    #[prompt_handler(router = self.prompt_router)]
    impl ServerHandler for NestedServer {}

    #[test]
    fn test_nested_prompt_handler() {
        let server = NestedServer::new();
        // Verify it implements ServerHandler
        fn assert_server_handler<T: ServerHandler>(_: &T) {}
        assert_server_handler(&server);
    }
}