1use collections::HashMap;
2use serde::de::DeserializeOwned;
3use serde::{Deserialize, Serialize};
4use url::Url;
5
6use crate::client::RequestId;
7
8pub const LATEST_PROTOCOL_VERSION: &str = "2025-03-26";
9pub const VERSION_2024_11_05: &str = "2024-11-05";
10
11pub mod requests {
12 use super::*;
13
14 macro_rules! request {
15 ($method:expr, $name:ident, $params:ty, $response:ty) => {
16 pub struct $name;
17
18 impl Request for $name {
19 type Params = $params;
20 type Response = $response;
21 const METHOD: &'static str = $method;
22 }
23 };
24 }
25
26 request!(
27 "initialize",
28 Initialize,
29 InitializeParams,
30 InitializeResponse
31 );
32 request!("tools/call", CallTool, CallToolParams, CallToolResponse);
33 request!(
34 "resources/unsubscribe",
35 ResourcesUnsubscribe,
36 ResourcesUnsubscribeParams,
37 ()
38 );
39 request!(
40 "resources/subscribe",
41 ResourcesSubscribe,
42 ResourcesSubscribeParams,
43 ()
44 );
45 request!(
46 "resources/read",
47 ResourcesRead,
48 ResourcesReadParams,
49 ResourcesReadResponse
50 );
51 request!("resources/list", ResourcesList, (), ResourcesListResponse);
52 request!(
53 "logging/setLevel",
54 LoggingSetLevel,
55 LoggingSetLevelParams,
56 ()
57 );
58 request!(
59 "prompts/get",
60 PromptsGet,
61 PromptsGetParams,
62 PromptsGetResponse
63 );
64 request!("prompts/list", PromptsList, (), PromptsListResponse);
65 request!(
66 "completion/complete",
67 CompletionComplete,
68 CompletionCompleteParams,
69 CompletionCompleteResponse
70 );
71 request!("ping", Ping, (), ());
72 request!("tools/list", ListTools, (), ListToolsResponse);
73 request!(
74 "resources/templates/list",
75 ListResourceTemplates,
76 (),
77 ListResourceTemplatesResponse
78 );
79 request!("roots/list", ListRoots, (), ListRootsResponse);
80}
81
82pub trait Request {
83 type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
84 type Response: DeserializeOwned + Serialize + Send + Sync + 'static;
85 const METHOD: &'static str;
86}
87
88pub mod notifications {
89 use super::*;
90
91 macro_rules! notification {
92 ($method:expr, $name:ident, $params:ty) => {
93 pub struct $name;
94
95 impl Notification for $name {
96 type Params = $params;
97 const METHOD: &'static str = $method;
98 }
99 };
100 }
101
102 notification!("notifications/initialized", Initialized, ());
103 notification!("notifications/progress", Progress, ProgressParams);
104 notification!("notifications/message", Message, MessageParams);
105 notification!("notifications/cancelled", Cancelled, CancelledParams);
106 notification!(
107 "notifications/resources/updated",
108 ResourcesUpdated,
109 ResourcesUpdatedParams
110 );
111 notification!(
112 "notifications/resources/list_changed",
113 ResourcesListChanged,
114 ()
115 );
116 notification!("notifications/tools/list_changed", ToolsListChanged, ());
117 notification!("notifications/prompts/list_changed", PromptsListChanged, ());
118 notification!("notifications/roots/list_changed", RootsListChanged, ());
119}
120
121pub trait Notification {
122 type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
123 const METHOD: &'static str;
124}
125
126#[derive(Debug, Serialize, Deserialize)]
127#[serde(rename_all = "camelCase")]
128pub struct MessageParams {
129 pub level: LoggingLevel,
130 pub logger: Option<String>,
131 pub data: serde_json::Value,
132}
133
134#[derive(Debug, Serialize, Deserialize)]
135#[serde(rename_all = "camelCase")]
136pub struct ResourcesUpdatedParams {
137 pub uri: String,
138}
139
140#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
141#[serde(transparent)]
142pub struct ProtocolVersion(pub String);
143
144#[derive(Debug, Serialize, Deserialize)]
145#[serde(rename_all = "camelCase")]
146pub struct InitializeParams {
147 pub protocol_version: ProtocolVersion,
148 pub capabilities: ClientCapabilities,
149 pub client_info: Implementation,
150 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
151 pub meta: Option<HashMap<String, serde_json::Value>>,
152}
153
154#[derive(Debug, Serialize, Deserialize)]
155#[serde(rename_all = "camelCase")]
156pub struct CallToolParams {
157 pub name: String,
158 #[serde(skip_serializing_if = "Option::is_none")]
159 pub arguments: Option<serde_json::Value>,
160 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
161 pub meta: Option<HashMap<String, serde_json::Value>>,
162}
163
164#[derive(Debug, Serialize, Deserialize)]
165#[serde(rename_all = "camelCase")]
166pub struct ResourcesUnsubscribeParams {
167 pub uri: Url,
168 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
169 pub meta: Option<HashMap<String, serde_json::Value>>,
170}
171
172#[derive(Debug, Serialize, Deserialize)]
173#[serde(rename_all = "camelCase")]
174pub struct ResourcesSubscribeParams {
175 pub uri: Url,
176 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
177 pub meta: Option<HashMap<String, serde_json::Value>>,
178}
179
180#[derive(Debug, Serialize, Deserialize)]
181#[serde(rename_all = "camelCase")]
182pub struct ResourcesReadParams {
183 pub uri: Url,
184 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
185 pub meta: Option<HashMap<String, serde_json::Value>>,
186}
187
188#[derive(Debug, Serialize, Deserialize)]
189#[serde(rename_all = "camelCase")]
190pub struct LoggingSetLevelParams {
191 pub level: LoggingLevel,
192 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
193 pub meta: Option<HashMap<String, serde_json::Value>>,
194}
195
196#[derive(Debug, Serialize, Deserialize)]
197#[serde(rename_all = "camelCase")]
198pub struct PromptsGetParams {
199 pub name: String,
200 #[serde(skip_serializing_if = "Option::is_none")]
201 pub arguments: Option<HashMap<String, String>>,
202 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
203 pub meta: Option<HashMap<String, serde_json::Value>>,
204}
205
206#[derive(Debug, Serialize, Deserialize)]
207#[serde(rename_all = "camelCase")]
208pub struct CompletionCompleteParams {
209 #[serde(rename = "ref")]
210 pub reference: CompletionReference,
211 pub argument: CompletionArgument,
212 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
213 pub meta: Option<HashMap<String, serde_json::Value>>,
214}
215
216#[derive(Debug, Serialize, Deserialize)]
217#[serde(untagged)]
218pub enum CompletionReference {
219 Prompt(PromptReference),
220 Resource(ResourceReference),
221}
222
223#[derive(Debug, Serialize, Deserialize)]
224#[serde(rename_all = "camelCase")]
225pub struct PromptReference {
226 #[serde(rename = "type")]
227 pub ty: PromptReferenceType,
228 pub name: String,
229}
230
231#[derive(Debug, Serialize, Deserialize)]
232#[serde(rename_all = "camelCase")]
233pub struct ResourceReference {
234 #[serde(rename = "type")]
235 pub ty: PromptReferenceType,
236 pub uri: Url,
237}
238
239#[derive(Debug, Serialize, Deserialize)]
240#[serde(rename_all = "snake_case")]
241pub enum PromptReferenceType {
242 #[serde(rename = "ref/prompt")]
243 Prompt,
244 #[serde(rename = "ref/resource")]
245 Resource,
246}
247
248#[derive(Debug, Serialize, Deserialize)]
249#[serde(rename_all = "camelCase")]
250pub struct CompletionArgument {
251 pub name: String,
252 pub value: String,
253}
254
255#[derive(Debug, Serialize, Deserialize)]
256#[serde(rename_all = "camelCase")]
257pub struct InitializeResponse {
258 pub protocol_version: ProtocolVersion,
259 pub capabilities: ServerCapabilities,
260 pub server_info: Implementation,
261 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
262 pub meta: Option<HashMap<String, serde_json::Value>>,
263}
264
265#[derive(Debug, Serialize, Deserialize)]
266#[serde(rename_all = "camelCase")]
267pub struct ResourcesReadResponse {
268 pub contents: Vec<ResourceContentsType>,
269 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
270 pub meta: Option<HashMap<String, serde_json::Value>>,
271}
272
273#[derive(Debug, Serialize, Deserialize)]
274#[serde(untagged)]
275pub enum ResourceContentsType {
276 Text(TextResourceContents),
277 Blob(BlobResourceContents),
278}
279
280#[derive(Debug, Serialize, Deserialize)]
281#[serde(rename_all = "camelCase")]
282pub struct ResourcesListResponse {
283 pub resources: Vec<Resource>,
284 #[serde(skip_serializing_if = "Option::is_none")]
285 pub next_cursor: Option<String>,
286 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
287 pub meta: Option<HashMap<String, serde_json::Value>>,
288}
289
290#[derive(Debug, Serialize, Deserialize)]
291#[serde(rename_all = "camelCase")]
292pub struct SamplingMessage {
293 pub role: Role,
294 pub content: MessageContent,
295}
296
297#[derive(Debug, Serialize, Deserialize)]
298#[serde(rename_all = "camelCase")]
299pub struct CreateMessageRequest {
300 pub messages: Vec<SamplingMessage>,
301 #[serde(skip_serializing_if = "Option::is_none")]
302 pub model_preferences: Option<ModelPreferences>,
303 #[serde(skip_serializing_if = "Option::is_none")]
304 pub system_prompt: Option<String>,
305 #[serde(skip_serializing_if = "Option::is_none")]
306 pub include_context: Option<String>,
307 #[serde(skip_serializing_if = "Option::is_none")]
308 pub temperature: Option<f64>,
309 pub max_tokens: u32,
310 #[serde(skip_serializing_if = "Option::is_none")]
311 pub stop_sequences: Option<Vec<String>>,
312 #[serde(skip_serializing_if = "Option::is_none")]
313 pub metadata: Option<serde_json::Value>,
314}
315
316#[derive(Debug, Deserialize)]
317#[serde(rename_all = "camelCase")]
318pub struct CreateMessageResult {
319 pub role: Role,
320 pub content: MessageContent,
321 pub model: String,
322 #[serde(skip_serializing_if = "Option::is_none")]
323 pub stop_reason: Option<String>,
324}
325
326#[derive(Debug, Serialize, Deserialize)]
327#[serde(rename_all = "camelCase")]
328pub struct PromptMessage {
329 pub role: Role,
330 pub content: MessageContent,
331}
332
333#[derive(Debug, Serialize, Deserialize)]
334#[serde(rename_all = "lowercase")]
335pub enum Role {
336 User,
337 Assistant,
338}
339
340#[derive(Debug, Serialize, Deserialize)]
341#[serde(tag = "type")]
342pub enum MessageContent {
343 #[serde(rename = "text")]
344 Text {
345 text: String,
346 #[serde(skip_serializing_if = "Option::is_none")]
347 annotations: Option<MessageAnnotations>,
348 },
349 #[serde(rename = "image", rename_all = "camelCase")]
350 Image {
351 data: String,
352 mime_type: String,
353 #[serde(skip_serializing_if = "Option::is_none")]
354 annotations: Option<MessageAnnotations>,
355 },
356 #[serde(rename = "audio", rename_all = "camelCase")]
357 Audio {
358 data: String,
359 mime_type: String,
360 #[serde(skip_serializing_if = "Option::is_none")]
361 annotations: Option<MessageAnnotations>,
362 },
363 #[serde(rename = "resource")]
364 Resource {
365 resource: ResourceContents,
366 #[serde(skip_serializing_if = "Option::is_none")]
367 annotations: Option<MessageAnnotations>,
368 },
369}
370
371#[derive(Debug, Serialize, Deserialize)]
372#[serde(rename_all = "camelCase")]
373pub struct MessageAnnotations {
374 #[serde(skip_serializing_if = "Option::is_none")]
375 pub audience: Option<Vec<Role>>,
376 #[serde(skip_serializing_if = "Option::is_none")]
377 pub priority: Option<f64>,
378}
379
380#[derive(Debug, Serialize, Deserialize)]
381#[serde(rename_all = "camelCase")]
382pub struct PromptsGetResponse {
383 #[serde(skip_serializing_if = "Option::is_none")]
384 pub description: Option<String>,
385 pub messages: Vec<PromptMessage>,
386 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
387 pub meta: Option<HashMap<String, serde_json::Value>>,
388}
389
390#[derive(Debug, Serialize, Deserialize)]
391#[serde(rename_all = "camelCase")]
392pub struct PromptsListResponse {
393 pub prompts: Vec<Prompt>,
394 #[serde(skip_serializing_if = "Option::is_none")]
395 pub next_cursor: Option<String>,
396 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
397 pub meta: Option<HashMap<String, serde_json::Value>>,
398}
399
400#[derive(Debug, Serialize, Deserialize)]
401#[serde(rename_all = "camelCase")]
402pub struct CompletionCompleteResponse {
403 pub completion: CompletionResult,
404 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
405 pub meta: Option<HashMap<String, serde_json::Value>>,
406}
407
408#[derive(Debug, Serialize, Deserialize)]
409#[serde(rename_all = "camelCase")]
410pub struct CompletionResult {
411 pub values: Vec<String>,
412 #[serde(skip_serializing_if = "Option::is_none")]
413 pub total: Option<u32>,
414 #[serde(skip_serializing_if = "Option::is_none")]
415 pub has_more: Option<bool>,
416 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
417 pub meta: Option<HashMap<String, serde_json::Value>>,
418}
419
420#[derive(Debug, Serialize, Deserialize)]
421#[serde(rename_all = "camelCase")]
422pub struct Prompt {
423 pub name: String,
424 #[serde(skip_serializing_if = "Option::is_none")]
425 pub description: Option<String>,
426 #[serde(skip_serializing_if = "Option::is_none")]
427 pub arguments: Option<Vec<PromptArgument>>,
428}
429
430#[derive(Debug, Serialize, Deserialize)]
431#[serde(rename_all = "camelCase")]
432pub struct PromptArgument {
433 pub name: String,
434 #[serde(skip_serializing_if = "Option::is_none")]
435 pub description: Option<String>,
436 #[serde(skip_serializing_if = "Option::is_none")]
437 pub required: Option<bool>,
438}
439
440#[derive(Debug, Serialize, Deserialize)]
441#[serde(rename_all = "camelCase")]
442pub struct ClientCapabilities {
443 #[serde(skip_serializing_if = "Option::is_none")]
444 pub experimental: Option<HashMap<String, serde_json::Value>>,
445 #[serde(skip_serializing_if = "Option::is_none")]
446 pub sampling: Option<serde_json::Value>,
447 #[serde(skip_serializing_if = "Option::is_none")]
448 pub roots: Option<RootsCapabilities>,
449}
450
451#[derive(Default, Debug, Serialize, Deserialize)]
452#[serde(rename_all = "camelCase")]
453pub struct ServerCapabilities {
454 #[serde(skip_serializing_if = "Option::is_none")]
455 pub experimental: Option<HashMap<String, serde_json::Value>>,
456 #[serde(skip_serializing_if = "Option::is_none")]
457 pub logging: Option<serde_json::Value>,
458 #[serde(skip_serializing_if = "Option::is_none")]
459 pub completions: Option<serde_json::Value>,
460 #[serde(skip_serializing_if = "Option::is_none")]
461 pub prompts: Option<PromptsCapabilities>,
462 #[serde(skip_serializing_if = "Option::is_none")]
463 pub resources: Option<ResourcesCapabilities>,
464 #[serde(skip_serializing_if = "Option::is_none")]
465 pub tools: Option<ToolsCapabilities>,
466}
467
468#[derive(Debug, Serialize, Deserialize)]
469#[serde(rename_all = "camelCase")]
470pub struct PromptsCapabilities {
471 #[serde(skip_serializing_if = "Option::is_none")]
472 pub list_changed: Option<bool>,
473}
474
475#[derive(Debug, Serialize, Deserialize)]
476#[serde(rename_all = "camelCase")]
477pub struct ResourcesCapabilities {
478 #[serde(skip_serializing_if = "Option::is_none")]
479 pub subscribe: Option<bool>,
480 #[serde(skip_serializing_if = "Option::is_none")]
481 pub list_changed: Option<bool>,
482}
483
484#[derive(Debug, Serialize, Deserialize)]
485#[serde(rename_all = "camelCase")]
486pub struct ToolsCapabilities {
487 #[serde(skip_serializing_if = "Option::is_none")]
488 pub list_changed: Option<bool>,
489}
490
491#[derive(Debug, Serialize, Deserialize)]
492#[serde(rename_all = "camelCase")]
493pub struct RootsCapabilities {
494 #[serde(skip_serializing_if = "Option::is_none")]
495 pub list_changed: Option<bool>,
496}
497
498#[derive(Clone, Debug, Serialize, Deserialize)]
499#[serde(rename_all = "camelCase")]
500pub struct Tool {
501 pub name: String,
502 #[serde(skip_serializing_if = "Option::is_none")]
503 pub description: Option<String>,
504 pub input_schema: serde_json::Value,
505 #[serde(skip_serializing_if = "Option::is_none")]
506 pub annotations: Option<ToolAnnotations>,
507}
508
509#[derive(Clone, Debug, Serialize, Deserialize)]
510#[serde(rename_all = "camelCase")]
511pub struct ToolAnnotations {
512 /// A human-readable title for the tool.
513 #[serde(skip_serializing_if = "Option::is_none")]
514 pub title: Option<String>,
515 /// If true, the tool does not modify its environment.
516 #[serde(skip_serializing_if = "Option::is_none")]
517 pub read_only_hint: Option<bool>,
518 /// If true, the tool may perform destructive updates to its environment.
519 #[serde(skip_serializing_if = "Option::is_none")]
520 pub destructive_hint: Option<bool>,
521 /// If true, calling the tool repeatedly with the same arguments will have no additional effect on its environment.
522 #[serde(skip_serializing_if = "Option::is_none")]
523 pub idempotent_hint: Option<bool>,
524 /// If true, this tool may interact with an "open world" of external entities.
525 #[serde(skip_serializing_if = "Option::is_none")]
526 pub open_world_hint: Option<bool>,
527}
528
529#[derive(Debug, Serialize, Deserialize)]
530#[serde(rename_all = "camelCase")]
531pub struct Implementation {
532 pub name: String,
533 pub version: String,
534}
535
536#[derive(Debug, Serialize, Deserialize)]
537#[serde(rename_all = "camelCase")]
538pub struct Resource {
539 pub uri: Url,
540 pub name: String,
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub description: Option<String>,
543 #[serde(skip_serializing_if = "Option::is_none")]
544 pub mime_type: Option<String>,
545}
546
547#[derive(Debug, Serialize, Deserialize)]
548#[serde(rename_all = "camelCase")]
549pub struct ResourceContents {
550 pub uri: Url,
551 #[serde(skip_serializing_if = "Option::is_none")]
552 pub mime_type: Option<String>,
553}
554
555#[derive(Debug, Serialize, Deserialize)]
556#[serde(rename_all = "camelCase")]
557pub struct TextResourceContents {
558 pub uri: Url,
559 #[serde(skip_serializing_if = "Option::is_none")]
560 pub mime_type: Option<String>,
561 pub text: String,
562}
563
564#[derive(Debug, Serialize, Deserialize)]
565#[serde(rename_all = "camelCase")]
566pub struct BlobResourceContents {
567 pub uri: Url,
568 #[serde(skip_serializing_if = "Option::is_none")]
569 pub mime_type: Option<String>,
570 pub blob: String,
571}
572
573#[derive(Debug, Serialize, Deserialize)]
574#[serde(rename_all = "camelCase")]
575pub struct ResourceTemplate {
576 pub uri_template: String,
577 pub name: String,
578 #[serde(skip_serializing_if = "Option::is_none")]
579 pub description: Option<String>,
580 #[serde(skip_serializing_if = "Option::is_none")]
581 pub mime_type: Option<String>,
582}
583
584#[derive(Debug, Serialize, Deserialize)]
585#[serde(rename_all = "lowercase")]
586pub enum LoggingLevel {
587 Debug,
588 Info,
589 Notice,
590 Warning,
591 Error,
592 Critical,
593 Alert,
594 Emergency,
595}
596
597#[derive(Debug, Serialize, Deserialize)]
598#[serde(rename_all = "camelCase")]
599pub struct ModelPreferences {
600 #[serde(skip_serializing_if = "Option::is_none")]
601 pub hints: Option<Vec<ModelHint>>,
602 #[serde(skip_serializing_if = "Option::is_none")]
603 pub cost_priority: Option<f64>,
604 #[serde(skip_serializing_if = "Option::is_none")]
605 pub speed_priority: Option<f64>,
606 #[serde(skip_serializing_if = "Option::is_none")]
607 pub intelligence_priority: Option<f64>,
608}
609
610#[derive(Debug, Serialize, Deserialize)]
611#[serde(rename_all = "camelCase")]
612pub struct ModelHint {
613 #[serde(skip_serializing_if = "Option::is_none")]
614 pub name: Option<String>,
615}
616
617#[derive(Debug, Serialize)]
618#[serde(untagged)]
619pub enum ClientNotification {
620 Initialized,
621 Progress(ProgressParams),
622 RootsListChanged,
623 Cancelled(CancelledParams),
624}
625
626#[derive(Debug, Serialize, Deserialize)]
627pub struct CancelledParams {
628 pub request_id: RequestId,
629 #[serde(skip_serializing_if = "Option::is_none")]
630 pub reason: Option<String>,
631}
632
633#[derive(Debug, Serialize, Deserialize)]
634#[serde(untagged)]
635pub enum ProgressToken {
636 String(String),
637 Number(f64),
638}
639
640#[derive(Debug, Serialize, Deserialize)]
641#[serde(rename_all = "camelCase")]
642pub struct ProgressParams {
643 pub progress_token: ProgressToken,
644 pub progress: f64,
645 #[serde(skip_serializing_if = "Option::is_none")]
646 pub message: Option<String>,
647 #[serde(skip_serializing_if = "Option::is_none")]
648 pub total: Option<f64>,
649 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
650 pub meta: Option<HashMap<String, serde_json::Value>>,
651}
652
653pub enum CompletionTotal {
654 Exact(u32),
655 HasMore,
656 Unknown,
657}
658
659impl CompletionTotal {
660 pub fn from_options(has_more: Option<bool>, total: Option<u32>) -> Self {
661 match (has_more, total) {
662 (_, Some(count)) => CompletionTotal::Exact(count),
663 (Some(true), _) => CompletionTotal::HasMore,
664 _ => CompletionTotal::Unknown,
665 }
666 }
667}
668
669pub struct Completion {
670 pub values: Vec<String>,
671 pub total: CompletionTotal,
672}
673
674#[derive(Debug, Serialize, Deserialize)]
675#[serde(rename_all = "camelCase")]
676pub struct CallToolResponse {
677 pub content: Vec<ToolResponseContent>,
678 #[serde(skip_serializing_if = "Option::is_none")]
679 pub is_error: Option<bool>,
680 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
681 pub meta: Option<HashMap<String, serde_json::Value>>,
682 #[serde(default, skip_serializing_if = "Option::is_none")]
683 pub structured_content: Option<serde_json::Value>,
684}
685
686#[derive(Debug, Serialize, Deserialize)]
687#[serde(tag = "type")]
688pub enum ToolResponseContent {
689 #[serde(rename = "text")]
690 Text { text: String },
691 #[serde(rename = "image", rename_all = "camelCase")]
692 Image { data: String, mime_type: String },
693 #[serde(rename = "audio", rename_all = "camelCase")]
694 Audio { data: String, mime_type: String },
695 #[serde(rename = "resource")]
696 Resource { resource: ResourceContents },
697}
698
699#[derive(Debug, Serialize, Deserialize)]
700#[serde(rename_all = "camelCase")]
701pub struct ListToolsResponse {
702 pub tools: Vec<Tool>,
703 #[serde(skip_serializing_if = "Option::is_none")]
704 pub next_cursor: Option<String>,
705 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
706 pub meta: Option<HashMap<String, serde_json::Value>>,
707}
708
709#[derive(Debug, Serialize, Deserialize)]
710#[serde(rename_all = "camelCase")]
711pub struct ListResourceTemplatesResponse {
712 pub resource_templates: Vec<ResourceTemplate>,
713 #[serde(skip_serializing_if = "Option::is_none")]
714 pub next_cursor: Option<String>,
715 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
716 pub meta: Option<HashMap<String, serde_json::Value>>,
717}
718
719#[derive(Debug, Serialize, Deserialize)]
720#[serde(rename_all = "camelCase")]
721pub struct ListRootsResponse {
722 pub roots: Vec<Root>,
723 #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
724 pub meta: Option<HashMap<String, serde_json::Value>>,
725}
726
727#[derive(Debug, Serialize, Deserialize)]
728#[serde(rename_all = "camelCase")]
729pub struct Root {
730 pub uri: Url,
731 #[serde(skip_serializing_if = "Option::is_none")]
732 pub name: Option<String>,
733}