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

use rmcp::model::{CallToolResult, Content, RawResource};

#[test]
fn test_resource_link_in_tool_result() {
    // Test creating a tool result with resource links
    let resource = RawResource::new("file:///test/file.txt", "test.txt");

    // Create a tool result with a resource link
    let result = CallToolResult::success(vec![
        Content::text("Found a file"),
        Content::resource_link(resource),
    ]);

    // Serialize to JSON to verify format
    let json = serde_json::to_string_pretty(&result).unwrap();
    println!("Tool result with resource link:\n{}", json);

    // Verify JSON contains expected structure
    assert!(
        json.contains("\"type\":\"resource_link\"") || json.contains("\"type\": \"resource_link\"")
    );
    assert!(
        json.contains("\"uri\":\"file:///test/file.txt\"")
            || json.contains("\"uri\": \"file:///test/file.txt\"")
    );
    assert!(json.contains("\"name\":\"test.txt\"") || json.contains("\"name\": \"test.txt\""));

    // Test deserialization
    let deserialized: CallToolResult = serde_json::from_str(&json).unwrap();
    assert_eq!(deserialized.content.len(), 2);

    // Check the text content
    assert!(deserialized.content[0].as_text().is_some());

    // Check the resource link
    let resource_link = deserialized.content[1]
        .as_resource_link()
        .expect("Expected resource link in content[1]");
    assert_eq!(resource_link.uri, "file:///test/file.txt");
    assert_eq!(resource_link.name, "test.txt");
}

#[test]
fn test_resource_link_with_full_metadata() {
    let mut resource = RawResource::new("https://example.com/data.json", "API Data");
    resource.description = Some("JSON data from external API".to_string());
    resource.mime_type = Some("application/json".to_string());
    resource.size = Some(1024);

    let result = CallToolResult::success(vec![Content::resource_link(resource)]);

    let json = serde_json::to_string(&result).unwrap();
    let deserialized: CallToolResult = serde_json::from_str(&json).unwrap();

    let resource_link = deserialized.content[0]
        .as_resource_link()
        .expect("Expected resource link");
    assert_eq!(resource_link.uri, "https://example.com/data.json");
    assert_eq!(resource_link.name, "API Data");
    assert_eq!(
        resource_link.description,
        Some("JSON data from external API".to_string())
    );
    assert_eq!(
        resource_link.mime_type,
        Some("application/json".to_string())
    );
    assert_eq!(resource_link.size, Some(1024));
}

#[test]
fn test_mixed_content_types() {
    // Test that resource links can be mixed with other content types
    let resource = RawResource::new("file:///doc.pdf", "Document");

    let result = CallToolResult::success(vec![
        Content::text("Processing complete"),
        Content::resource_link(resource),
        Content::embedded_text("memo://result", "Analysis results here"),
    ]);

    assert_eq!(result.content.len(), 3);
    assert!(result.content[0].as_text().is_some());
    assert!(result.content[1].as_resource_link().is_some());
    assert!(result.content[2].as_resource().is_some());
}