hexser 0.4.7

Zero-boilerplate hexagonal architecture with graph-based introspection
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

//! MCP initialization protocol types.
//!
//! Handles the initialization handshake between MCP client and server.
//! The initialize method is the first call made by clients, establishing
//! protocol version and exchanging capability information.
//!
//! Revision History
//! - 2025-10-08T23:35:00Z @AI: Initial MCP initialization types.

/// Initialize request from client to server.
///
/// First message in MCP handshake. Client declares its protocol version
/// and capabilities. Server responds with its own capabilities and
/// server information.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct InitializeRequest {
  /// MCP protocol version the client supports
  #[serde(rename = "protocolVersion")]
  pub protocol_version: String,

  /// Client capabilities (optional)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub capabilities: Option<ClientCapabilities>,

  /// Client information (optional)
  #[serde(skip_serializing_if = "Option::is_none", rename = "clientInfo")]
  pub client_info: Option<ClientInfo>,
}

/// Client capability declarations.
///
/// Informs server of what the client supports. Currently a placeholder
/// as Hexser server doesn't require specific client capabilities.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, Default)]
pub struct ClientCapabilities {
  /// Experimental features (placeholder)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub experimental: Option<serde_json::Value>,
}

/// Client information for identification.
///
/// Allows client to identify itself to server. Useful for logging
/// and debugging MCP interactions.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct ClientInfo {
  /// Client name
  pub name: String,

  /// Client version
  pub version: String,
}

/// Initialize result from server to client.
///
/// Server response to initialization request. Declares supported
/// protocol version, server capabilities, and server information.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct InitializeResult {
  /// MCP protocol version the server supports
  #[serde(rename = "protocolVersion")]
  pub protocol_version: String,

  /// Server capabilities declaration
  pub capabilities: super::capabilities::ServerCapabilities,

  /// Server information for identification
  #[serde(rename = "serverInfo")]
  pub server_info: ServerInfo,
}

impl InitializeResult {
  /// Creates Hexser MCP server initialization result.
  ///
  /// Uses default Hexser capabilities and current version information.
  ///
  /// # Returns
  ///
  /// InitializeResult for Hexser MCP server
  pub fn hexser_default() -> Self {
    InitializeResult {
      protocol_version: String::from("2024-11-05"),
      capabilities: super::capabilities::ServerCapabilities::hexser_default(),
      server_info: ServerInfo::hexser_default(),
    }
  }
}

/// Server information for identification.
///
/// Provides server name and version to client. Helps clients
/// understand what server implementation they are connected to.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct ServerInfo {
  /// Server name
  pub name: String,

  /// Server version
  pub version: String,
}

impl ServerInfo {
  /// Creates Hexser server information.
  ///
  /// # Returns
  ///
  /// ServerInfo for Hexser MCP server
  pub fn hexser_default() -> Self {
    ServerInfo {
      name: String::from("hexser-mcp-server"),
      version: String::from(env!("CARGO_PKG_VERSION")),
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_initialize_request_deserialization() {
    let json = r#"{
            "protocolVersion": "2024-11-05",
            "clientInfo": {
                "name": "test-client",
                "version": "1.0.0"
            }
        }"#;

    let req: InitializeRequest = serde_json::from_str(json).unwrap();
    std::assert_eq!(req.protocol_version, "2024-11-05");
    std::assert!(req.client_info.is_some());
  }

  #[test]
  fn test_initialize_result_serialization() {
    let result = InitializeResult::hexser_default();
    let json = serde_json::to_string(&result).unwrap();

    std::assert!(json.contains("\"protocolVersion\":\"2024-11-05\""));
    std::assert!(json.contains("\"serverInfo\""));
    std::assert!(json.contains("\"capabilities\""));
  }

  #[test]
  fn test_server_info_default() {
    let info = ServerInfo::hexser_default();

    std::assert_eq!(info.name, "hexser-mcp-server");
    std::assert!(!info.version.is_empty());
  }
}