use schemars::JsonSchema;
use super::RequestId;
macro_rules! method_marker {
($(#[$doc:meta])* $name:ident, $variant:ident, $method:literal) => {
$(#[$doc])*
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
serde::Serialize,
serde::Deserialize,
JsonSchema,
)]
pub enum $name {
#[serde(rename = $method)]
$variant,
}
impl $name {
pub const METHOD: &'static str = $method;
}
};
}
pub(super) use method_marker;
method_marker!(
InitializeMethod, Initialize, "initialize"
);
method_marker!(
PingMethod, Ping, "ping"
);
method_marker!(
ListToolsMethod, ListTools, "tools/list"
);
method_marker!(
CallToolMethod, CallTool, "tools/call"
);
method_marker!(
ListResourcesMethod, ListResources, "resources/list"
);
method_marker!(
ReadResourceMethod, ReadResource, "resources/read"
);
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, JsonSchema)]
#[serde(untagged)]
#[schemars(rename = "mcp.ClientRequestMethod")]
pub enum ClientRequestMethod {
Initialize(InitializeMethod),
Ping(PingMethod),
ListTools(ListToolsMethod),
CallTool(CallToolMethod),
ListResources(ListResourcesMethod),
ReadResource(ReadResourceMethod),
Other(String),
}
impl ClientRequestMethod {
pub fn as_str(&self) -> &str {
match self {
ClientRequestMethod::Initialize(_) => InitializeMethod::METHOD,
ClientRequestMethod::Ping(_) => PingMethod::METHOD,
ClientRequestMethod::ListTools(_) => ListToolsMethod::METHOD,
ClientRequestMethod::CallTool(_) => CallToolMethod::METHOD,
ClientRequestMethod::ListResources(_) => {
ListResourcesMethod::METHOD
}
ClientRequestMethod::ReadResource(_) => {
ReadResourceMethod::METHOD
}
ClientRequestMethod::Other(method) => method,
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
#[serde(untagged)]
#[schemars(rename = "mcp.JsonRpcRequest")]
pub enum JsonRpcRequest {
Initialize {
jsonrpc: String,
id: RequestId,
method: InitializeMethod,
params: InitializeRequestParams,
},
Ping {
jsonrpc: String,
id: RequestId,
method: PingMethod,
},
ListTools {
jsonrpc: String,
id: RequestId,
method: ListToolsMethod,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
params: Option<crate::mcp::tool::ListToolsRequest>,
},
CallTool {
jsonrpc: String,
id: RequestId,
method: CallToolMethod,
params: crate::mcp::tool::CallToolRequestParams,
},
ListResources {
jsonrpc: String,
id: RequestId,
method: ListResourcesMethod,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
params: Option<crate::mcp::resource::ListResourcesRequest>,
},
ReadResource {
jsonrpc: String,
id: RequestId,
method: ReadResourceMethod,
params: crate::mcp::resource::ReadResourceRequestParams,
},
Fallback {
jsonrpc: String,
id: RequestId,
method: ClientRequestMethod,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
params: Option<serde_json::Value>,
},
}
impl JsonRpcRequest {
pub fn initialize(id: RequestId, params: InitializeRequestParams) -> Self {
JsonRpcRequest::Initialize {
jsonrpc: "2.0".to_string(),
id,
method: InitializeMethod::Initialize,
params,
}
}
pub fn ping(id: RequestId) -> Self {
JsonRpcRequest::Ping {
jsonrpc: "2.0".to_string(),
id,
method: PingMethod::Ping,
}
}
pub fn list_tools(
id: RequestId,
params: crate::mcp::tool::ListToolsRequest,
) -> Self {
JsonRpcRequest::ListTools {
jsonrpc: "2.0".to_string(),
id,
method: ListToolsMethod::ListTools,
params: Some(params),
}
}
pub fn call_tool(
id: RequestId,
params: crate::mcp::tool::CallToolRequestParams,
) -> Self {
JsonRpcRequest::CallTool {
jsonrpc: "2.0".to_string(),
id,
method: CallToolMethod::CallTool,
params,
}
}
pub fn list_resources(
id: RequestId,
params: crate::mcp::resource::ListResourcesRequest,
) -> Self {
JsonRpcRequest::ListResources {
jsonrpc: "2.0".to_string(),
id,
method: ListResourcesMethod::ListResources,
params: Some(params),
}
}
pub fn read_resource(
id: RequestId,
params: crate::mcp::resource::ReadResourceRequestParams,
) -> Self {
JsonRpcRequest::ReadResource {
jsonrpc: "2.0".to_string(),
id,
method: ReadResourceMethod::ReadResource,
params,
}
}
pub fn id(&self) -> &RequestId {
match self {
JsonRpcRequest::Initialize { id, .. }
| JsonRpcRequest::Ping { id, .. }
| JsonRpcRequest::ListTools { id, .. }
| JsonRpcRequest::CallTool { id, .. }
| JsonRpcRequest::ListResources { id, .. }
| JsonRpcRequest::ReadResource { id, .. }
| JsonRpcRequest::Fallback { id, .. } => id,
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
#[serde(rename_all = "camelCase")]
#[schemars(rename = "mcp.InitializeRequestParams")]
pub struct InitializeRequestParams {
pub protocol_version: String,
#[serde(default)]
pub capabilities: ClientCapabilities,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub client_info: Option<crate::mcp::initialize_result::Implementation>,
}
#[derive(
Debug, Clone, Default, serde::Serialize, serde::Deserialize, JsonSchema,
)]
#[schemars(rename = "mcp.ClientCapabilities")]
pub struct ClientCapabilities {}
#[cfg(test)]
mod tests {
use super::*;
fn number_id(n: u64) -> RequestId {
RequestId::Number(n.into())
}
#[test]
fn initialize_matches_legacy_frame() {
let request = JsonRpcRequest::initialize(
number_id(1),
InitializeRequestParams {
protocol_version: "2025-06-18".to_string(),
capabilities: ClientCapabilities::default(),
client_info: Some(
crate::mcp::initialize_result::Implementation {
name: "objectiveai".to_string(),
title: None,
version: "1.2.3".to_string(),
website_url: None,
description: None,
icons: None,
},
),
},
);
assert_eq!(
serde_json::to_value(&request).unwrap(),
serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": {
"name": "objectiveai",
"version": "1.2.3",
},
},
}),
);
}
#[test]
fn round_trip() {
let requests = [
JsonRpcRequest::ping(number_id(2)),
JsonRpcRequest::list_tools(
RequestId::String("abc".to_string()),
crate::mcp::tool::ListToolsRequest {
cursor: Some("c1".to_string()),
},
),
JsonRpcRequest::call_tool(
number_id(3),
crate::mcp::tool::CallToolRequestParams {
name: "echo".to_string(),
arguments: None,
_meta: None,
task: None,
},
),
JsonRpcRequest::read_resource(
number_id(4),
crate::mcp::resource::ReadResourceRequestParams {
uri: "file://x".to_string(),
},
),
];
for request in requests {
let value = serde_json::to_value(&request).unwrap();
let back: JsonRpcRequest =
serde_json::from_str(&value.to_string()).unwrap();
assert_eq!(back.id(), request.id());
assert_eq!(serde_json::to_value(&back).unwrap(), value);
assert!(
!matches!(back, JsonRpcRequest::Fallback { .. }),
"constructor round-trip must land on its typed variant",
);
}
}
#[test]
fn field_order_independent() {
let frame = serde_json::json!({
"params": {"uri": "file://x"},
"method": "resources/read",
"id": 9,
"jsonrpc": "2.0",
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert!(matches!(
parsed,
JsonRpcRequest::ReadResource { params, .. }
if params.uri == "file://x",
));
}
#[test]
fn unknown_method_is_fallback_other() {
let frame = serde_json::json!({
"jsonrpc": "2.0",
"id": 5,
"method": "prompts/list",
"params": {"cursor": null},
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert!(matches!(
parsed,
JsonRpcRequest::Fallback {
method: ClientRequestMethod::Other(method),
..
} if method == "prompts/list",
));
}
#[test]
fn bad_params_is_fallback_with_known_method() {
let frame = serde_json::json!({
"jsonrpc": "2.0",
"id": 6,
"method": "tools/call",
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert_eq!(parsed.id(), &number_id(6));
assert!(matches!(
parsed,
JsonRpcRequest::Fallback {
method: ClientRequestMethod::CallTool(_),
..
},
));
}
#[test]
fn list_tools_with_absent_params_parses() {
let frame = serde_json::json!({
"jsonrpc": "2.0",
"id": 7,
"method": "tools/list",
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert!(matches!(
parsed,
JsonRpcRequest::ListTools { params: None, .. },
));
}
#[test]
fn initialize_with_only_protocol_version_parses() {
let frame = serde_json::json!({
"jsonrpc": "2.0",
"id": 8,
"method": "initialize",
"params": {"protocolVersion": "2025-06-18"},
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert!(matches!(
parsed,
JsonRpcRequest::Initialize { params, .. }
if params.protocol_version == "2025-06-18"
&& params.client_info.is_none(),
));
}
#[test]
fn ping_ignores_params() {
let frame = serde_json::json!({
"jsonrpc": "2.0",
"id": 10,
"method": "ping",
"params": {"_meta": {"x": 1}},
});
let parsed: JsonRpcRequest =
serde_json::from_str(&frame.to_string()).unwrap();
assert!(matches!(parsed, JsonRpcRequest::Ping { .. }));
}
}