agentic 0.0.4

Support library for building Agentic MCP and Agent2Agent based systems
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

use crate::mcp::{Error, Result};
use rpc_router::{RpcId, RpcRequest};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as DeError};
use serde_json::Value;

#[derive(Debug, Clone)]
pub struct McpRequest<P = Value> {
	/// The json-rpc id
	pub id: RpcId,

	/// The Method of this notification
	pub method: String,

	/// The Params
	pub params: Option<P>,
}

impl<P: Serialize + IntoMcpRequest<P>> McpRequest<P> {
	pub fn new(id: impl Into<RpcId>, params: P) -> Self {
		McpRequest {
			id: id.into(),
			method: P::METHOD.into(),
			params: Some(params),
		}
	}
}

/// Generic stringify implementation for any type that implement IntoMcpRequest
impl<P: Serialize> McpRequest<P> {
	pub fn stringify(&self) -> Result<String> {
		serde_json::to_string(&self).map_err(Error::custom_from_err)
	}
	pub fn stringify_pretty(&self) -> Result<String> {
		serde_json::to_string_pretty(&self).map_err(Error::custom_from_err)
	}
}

// region:    --- IntoRequest

pub trait IntoMcpRequest<P>: Serialize + Sized + Into<McpRequest<P>>
where
	Self::McpResult: DeserializeOwned,
{
	const METHOD: &'static str;
	type McpResult;

	fn into_mcp_request(self) -> McpRequest<P> {
		self.into()
	}
}

/// Blanket implementation for all params that implement IntoMcpRequest on themselves
impl<P: Serialize + IntoMcpRequest<P>> From<P> for McpRequest<P> {
	fn from(params: P) -> Self {
		let id = RpcId::new_uuid_v7_base58();
		McpRequest {
			id,
			method: P::METHOD.to_string(),
			params: Some(params),
		}
	}
}

/// Blanket implementation for all self `McpRequest<P>`
/// This allow to pass Params or `McpRequest<P>` in the `Client::send_request(...)`
/// e.g., `impl IntoMcpRequest<ListToolsParams>` for `McpRequest<ListToolsParams>`
impl<P> IntoMcpRequest<P> for McpRequest<P>
where
	P: IntoMcpRequest<P>,
{
	const METHOD: &'static str = P::METHOD;
	type McpResult = P::McpResult;
}

// endregion: --- IntoRequest

// region:    --- Custom De/Serialization

impl<P> Serialize for McpRequest<P>
where
	P: Serialize,
{
	fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		// Convert params to Option<Value> if present
		let params_value = match &self.params {
			Some(p) => Some(serde_json::to_value(p).map_err(serde::ser::Error::custom)?),
			None => None,
		};

		// Create RpcRequest
		let rpc_request = RpcRequest {
			id: self.id.clone(), // RpcId needs to be cloneable
			method: self.method.clone(),
			params: params_value,
		};

		// Serialize the RpcRequest
		rpc_request.serialize(serializer)
	}
}

impl<'de, P> Deserialize<'de> for McpRequest<P>
where
	P: Deserialize<'de>,
{
	fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
	where
		D: Deserializer<'de>,
	{
		// Deserialize into RpcRequest first to leverage its validation
		let rpc_request = RpcRequest::deserialize(deserializer)?;

		// Convert params from Option<Value> to Option<P>
		let params = match rpc_request.params {
			Some(value) => {
				let p = P::deserialize(value).map_err(DeError::custom)?;
				Some(p)
			}
			None => None,
		};

		// Construct the Request
		Ok(McpRequest {
			id: rpc_request.id,
			method: rpc_request.method,
			params,
		})
	}
}

// endregion: --- Custom De/Serialization