solidmcp 0.4.0

A high-level Rust toolkit for building Model Context Protocol (MCP) servers with type safety and minimal boilerplate. Supports tools, resources, and prompts with automatic JSON schema generation.
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

//! Regression tests for server info correctness
//!
//! Ensures server identification is consistent and correct

mod mcp_test_helpers;

use anyhow::Result;
use serde_json::{json, Value};

/// Test that server info is correctly reported
#[tokio::test]
async fn test_server_info_correctness() -> Result<()> {
    let server = mcp_test_helpers::McpTestServer::start()
        .await
        .map_err(|e| anyhow::anyhow!("{}", e))?;
    let url = format!("{}/mcp", server.http_url());

    let client = reqwest::Client::new();

    // Initialize and check server info
    let init_request = json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-06-18",
            "capabilities": {},
            "clientInfo": {
                "name": "test-client",
                "version": "1.0.0"
            }
        }
    });

    let response = client.post(&url).json(&init_request).send().await?;
    let init_response: Value = response.json().await?;

    // Verify server info structure
    assert!(init_response["result"]["serverInfo"].is_object());
    assert!(init_response["result"]["serverInfo"]["name"].is_string());
    assert!(init_response["result"]["serverInfo"]["version"].is_string());

    // Server name should not be empty
    let server_name = init_response["result"]["serverInfo"]["name"]
        .as_str()
        .unwrap();
    assert!(!server_name.is_empty(), "Server name should not be empty");

    println!("✅ Server info correctly reported: {server_name}");
    Ok(())
}

/// Test protocol version negotiation
#[tokio::test]
async fn test_protocol_version_negotiation() -> Result<()> {
    let server = mcp_test_helpers::McpTestServer::start()
        .await
        .map_err(|e| anyhow::anyhow!("{}", e))?;
    let url = format!("{}/mcp", server.http_url());

    let client = reqwest::Client::new();

    // Test with current protocol version
    let init_request = json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-06-18",
            "capabilities": {},
            "clientInfo": {
                "name": "test-client",
                "version": "1.0.0"
            }
        }
    });

    let response = client.post(&url).json(&init_request).send().await?;
    let init_response: Value = response.json().await?;

    // Server should accept and echo back the protocol version
    assert_eq!(init_response["result"]["protocolVersion"], "2025-06-18");

    println!("✅ Protocol version negotiation works correctly!");
    Ok(())
}

/// Test that server handles re-initialization correctly
#[tokio::test]
async fn test_reinitialization_handling() -> Result<()> {
    let server = mcp_test_helpers::McpTestServer::start()
        .await
        .map_err(|e| anyhow::anyhow!("{}", e))?;
    let url = format!("{}/mcp", server.http_url());

    let client = reqwest::Client::new();

    // First initialization
    let init_request = json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-06-18",
            "capabilities": {},
            "clientInfo": {
                "name": "test-client",
                "version": "1.0.0"
            }
        }
    });

    let response = client.post(&url).json(&init_request).send().await?;
    assert_eq!(response.status(), 200);

    // Try to reinitialize with same session (should work)
    let init_request2 = json!({
        "jsonrpc": "2.0",
        "id": 2,
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-06-18",
            "capabilities": {},
            "clientInfo": {
                "name": "test-client-2",
                "version": "2.0.0"
            }
        }
    });

    let response = client
        .post(&url)
        .header("Cookie", "mcp_session=http_default_session")
        .json(&init_request2)
        .send()
        .await?;
    let reinit_response: Value = response.json().await?;

    // Should fail with "Already initialized" (MCP rejects duplicate initialization)
    assert!(reinit_response["error"].is_object());
    assert_eq!(reinit_response["error"]["message"], "Already initialized");

    println!("✅ Re-initialization handling works correctly!");
    Ok(())
}