agenterra_rmcp/model/
serde_impl.rs

1use std::borrow::Cow;
2
3use serde::{Deserialize, Serialize};
4
5use super::{
6    Extensions, Meta, Notification, NotificationNoParam, Request, RequestNoParam,
7    RequestOptionalParam,
8};
9#[derive(Serialize, Deserialize)]
10struct WithMeta<'a, P> {
11    #[serde(skip_serializing_if = "Option::is_none")]
12    _meta: Option<Cow<'a, Meta>>,
13    #[serde(flatten)]
14    _rest: P,
15}
16
17#[derive(Serialize, Deserialize)]
18struct Proxy<'a, M, P> {
19    method: M,
20    params: WithMeta<'a, P>,
21}
22
23#[derive(Serialize, Deserialize)]
24struct ProxyOptionalParam<'a, M, P> {
25    method: M,
26    params: Option<WithMeta<'a, P>>,
27}
28
29#[derive(Serialize, Deserialize)]
30struct ProxyNoParam<M> {
31    method: M,
32}
33
34impl<M, R> Serialize for Request<M, R>
35where
36    M: Serialize,
37    R: Serialize,
38{
39    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
40    where
41        S: serde::Serializer,
42    {
43        let extensions = &self.extensions;
44        let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
45        Proxy::serialize(
46            &Proxy {
47                method: &self.method,
48                params: WithMeta {
49                    _rest: &self.params,
50                    _meta,
51                },
52            },
53            serializer,
54        )
55    }
56}
57
58impl<'de, M, R> Deserialize<'de> for Request<M, R>
59where
60    M: Deserialize<'de>,
61    R: Deserialize<'de>,
62{
63    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
64    where
65        D: serde::Deserializer<'de>,
66    {
67        let body = Proxy::deserialize(deserializer)?;
68        let _meta = body.params._meta.map(|m| m.into_owned());
69        let mut extensions = Extensions::new();
70        if let Some(meta) = _meta {
71            extensions.insert(meta);
72        }
73        Ok(Request {
74            extensions,
75            method: body.method,
76            params: body.params._rest,
77        })
78    }
79}
80
81impl<M, R> Serialize for RequestOptionalParam<M, R>
82where
83    M: Serialize,
84    R: Serialize,
85{
86    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
87    where
88        S: serde::Serializer,
89    {
90        let extensions = &self.extensions;
91        let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
92        Proxy::serialize(
93            &Proxy {
94                method: &self.method,
95                params: WithMeta {
96                    _rest: &self.params,
97                    _meta,
98                },
99            },
100            serializer,
101        )
102    }
103}
104
105impl<'de, M, R> Deserialize<'de> for RequestOptionalParam<M, R>
106where
107    M: Deserialize<'de>,
108    R: Deserialize<'de>,
109{
110    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
111    where
112        D: serde::Deserializer<'de>,
113    {
114        let body = ProxyOptionalParam::<'_, _, Option<R>>::deserialize(deserializer)?;
115        let mut params = None;
116        let mut _meta = None;
117        if let Some(body_params) = body.params {
118            params = body_params._rest;
119            _meta = body_params._meta.map(|m| m.into_owned());
120        }
121        let mut extensions = Extensions::new();
122        if let Some(meta) = _meta {
123            extensions.insert(meta);
124        }
125        Ok(RequestOptionalParam {
126            extensions,
127            method: body.method,
128            params,
129        })
130    }
131}
132
133impl<M> Serialize for RequestNoParam<M>
134where
135    M: Serialize,
136{
137    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
138    where
139        S: serde::Serializer,
140    {
141        let extensions = &self.extensions;
142        let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
143        ProxyNoParam::serialize(
144            &ProxyNoParam {
145                method: &self.method,
146            },
147            serializer,
148        )
149    }
150}
151
152impl<'de, M> Deserialize<'de> for RequestNoParam<M>
153where
154    M: Deserialize<'de>,
155{
156    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
157    where
158        D: serde::Deserializer<'de>,
159    {
160        let body = ProxyNoParam::<_>::deserialize(deserializer)?;
161        let extensions = Extensions::new();
162        Ok(RequestNoParam {
163            extensions,
164            method: body.method,
165        })
166    }
167}
168
169impl<M, R> Serialize for Notification<M, R>
170where
171    M: Serialize,
172    R: Serialize,
173{
174    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
175    where
176        S: serde::Serializer,
177    {
178        let extensions = &self.extensions;
179        let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
180        Proxy::serialize(
181            &Proxy {
182                method: &self.method,
183                params: WithMeta {
184                    _rest: &self.params,
185                    _meta,
186                },
187            },
188            serializer,
189        )
190    }
191}
192
193impl<'de, M, R> Deserialize<'de> for Notification<M, R>
194where
195    M: Deserialize<'de>,
196    R: Deserialize<'de>,
197{
198    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
199    where
200        D: serde::Deserializer<'de>,
201    {
202        let body = Proxy::deserialize(deserializer)?;
203        let _meta = body.params._meta.map(|m| m.into_owned());
204        let mut extensions = Extensions::new();
205        if let Some(meta) = _meta {
206            extensions.insert(meta);
207        }
208        Ok(Notification {
209            extensions,
210            method: body.method,
211            params: body.params._rest,
212        })
213    }
214}
215
216impl<M> Serialize for NotificationNoParam<M>
217where
218    M: Serialize,
219{
220    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
221    where
222        S: serde::Serializer,
223    {
224        let extensions = &self.extensions;
225        let _meta = extensions.get::<Meta>().map(Cow::Borrowed);
226        ProxyNoParam::serialize(
227            &ProxyNoParam {
228                method: &self.method,
229            },
230            serializer,
231        )
232    }
233}
234
235impl<'de, M> Deserialize<'de> for NotificationNoParam<M>
236where
237    M: Deserialize<'de>,
238{
239    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
240    where
241        D: serde::Deserializer<'de>,
242    {
243        let body = ProxyNoParam::<_>::deserialize(deserializer)?;
244        let extensions = Extensions::new();
245        Ok(NotificationNoParam {
246            extensions,
247            method: body.method,
248        })
249    }
250}
251
252#[cfg(test)]
253mod test {
254    use serde_json::json;
255
256    use crate::model::ListToolsRequest;
257
258    #[test]
259    fn test_deserialize_lost_tools_request() {
260        let _req: ListToolsRequest = serde_json::from_value(json!(
261            {
262                "method": "tools/list",
263            }
264        ))
265        .unwrap();
266    }
267}
agenterra_rmcp/model/serde_impl.rs

agenterra_rmcp/model/
serde_impl.rs
