rmcp 2.0.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

use rmcp::model::{ContentBlock, EmbeddedResource, Meta, ResourceContents};
use serde_json::json;

#[test]
fn serialize_embedded_text_resource_with_meta() {
    let mut resource_content_meta = Meta::new();
    resource_content_meta.insert("inner".to_string(), json!(2));

    let mut resource_meta = Meta::new();
    resource_meta.insert("top".to_string(), json!(1));

    let content = ContentBlock::Resource(
        EmbeddedResource::new(ResourceContents::TextResourceContents {
            uri: "str://example".to_string(),
            mime_type: Some("text/plain".to_string()),
            text: "hello".to_string(),
            meta: Some(resource_content_meta),
        })
        .with_meta(resource_meta),
    );

    let v = serde_json::to_value(&content).unwrap();

    let expected = json!({
        "type": "resource",
        "_meta": {"top": 1},
        "resource": {
            "uri": "str://example",
            "mimeType": "text/plain",
            "text": "hello",
            "_meta": {"inner": 2}
        }
    });

    assert_eq!(v, expected);
}

#[test]
fn serialize_embedded_text_resource_without_meta_omits_fields() {
    let content = ContentBlock::Resource(EmbeddedResource::new(
        ResourceContents::TextResourceContents {
            uri: "str://no-meta".to_string(),
            mime_type: Some("text/plain".to_string()),
            text: "hi".to_string(),
            meta: None,
        },
    ));

    let v = serde_json::to_value(&content).unwrap();

    assert_eq!(v.get("_meta"), None);
    let inner = v.get("resource").and_then(|r| r.as_object()).unwrap();
    assert_eq!(inner.get("_meta"), None);
}

#[test]
fn deserialize_embedded_text_resource_with_meta() {
    let raw = json!({
        "type": "resource",
        "_meta": {"x": true},
        "resource": {
            "uri": "str://from-json",
            "text": "ok",
            "_meta": {"y": 42}
        }
    });

    let content: ContentBlock = serde_json::from_value(raw).unwrap();

    let er = match &content {
        ContentBlock::Resource(er) => er,
        _ => panic!("expected resource"),
    };

    let top = er.meta.as_ref().expect("top-level meta missing");
    assert_eq!(top.get("x").unwrap(), &json!(true));

    match &er.resource {
        ResourceContents::TextResourceContents {
            meta, uri, text, ..
        } => {
            assert_eq!(uri, "str://from-json");
            assert_eq!(text, "ok");
            let inner = meta.as_ref().expect("inner meta missing");
            assert_eq!(inner.get("y").unwrap(), &json!(42));
        }
        _ => panic!("expected text resource contents"),
    }
}

#[test]
fn serialize_embedded_blob_resource_with_meta() {
    let mut resource_content_meta = Meta::new();
    resource_content_meta.insert("blob_inner".to_string(), json!(true));

    let mut resource_meta = Meta::new();
    resource_meta.insert("blob_top".to_string(), json!("t"));

    let content = ContentBlock::Resource(
        EmbeddedResource::new(ResourceContents::BlobResourceContents {
            uri: "str://blob".to_string(),
            mime_type: Some("application/octet-stream".to_string()),
            blob: "Zm9v".to_string(),
            meta: Some(resource_content_meta),
        })
        .with_meta(resource_meta),
    );

    let v = serde_json::to_value(&content).unwrap();

    assert_eq!(v.get("_meta").unwrap(), &json!({"blob_top": "t"}));
    let inner = v.get("resource").unwrap();
    assert_eq!(inner.get("_meta").unwrap(), &json!({"blob_inner": true}));
}