agcodex_mcp_types/
lib.rs

1// @generated
2// DO NOT EDIT THIS FILE DIRECTLY.
3// Run the following in the crate root to regenerate this file:
4//
5// ```shell
6// ./generate_mcp_types.py
7// ```
8#![allow(clippy::fallible_impl_from)]
9use serde::Deserialize;
10use serde::Serialize;
11use serde::de::DeserializeOwned;
12use std::convert::TryFrom;
13
14use ts_rs::TS;
15
16pub const MCP_SCHEMA_VERSION: &str = "2025-06-18";
17pub const JSONRPC_VERSION: &str = "2.0";
18
19/// Paired request/response types for the Model Context Protocol (MCP).
20pub trait ModelContextProtocolRequest {
21    const METHOD: &'static str;
22    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
23    type Result: DeserializeOwned + Serialize + Send + Sync + 'static;
24}
25
26/// One-way message in the Model Context Protocol (MCP).
27pub trait ModelContextProtocolNotification {
28    const METHOD: &'static str;
29    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
30}
31
32fn default_jsonrpc() -> String {
33    JSONRPC_VERSION.to_owned()
34}
35
36/// Optional annotations for the client. The client can use annotations to inform how objects are used or displayed
37#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
38pub struct Annotations {
39    #[serde(default, skip_serializing_if = "Option::is_none")]
40    pub audience: Option<Vec<Role>>,
41    #[serde(
42        rename = "lastModified",
43        default,
44        skip_serializing_if = "Option::is_none"
45    )]
46    pub last_modified: Option<String>,
47    #[serde(default, skip_serializing_if = "Option::is_none")]
48    pub priority: Option<f64>,
49}
50
51/// Audio provided to or from an LLM.
52#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
53pub struct AudioContent {
54    #[serde(default, skip_serializing_if = "Option::is_none")]
55    pub annotations: Option<Annotations>,
56    pub data: String,
57    #[serde(rename = "mimeType")]
58    pub mime_type: String,
59    pub r#type: String, // &'static str = "audio"
60}
61
62/// Base interface for metadata with name (identifier) and title (display name) properties.
63#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
64pub struct BaseMetadata {
65    pub name: String,
66    #[serde(default, skip_serializing_if = "Option::is_none")]
67    pub title: Option<String>,
68}
69
70#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
71pub struct BlobResourceContents {
72    pub blob: String,
73    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
74    pub mime_type: Option<String>,
75    pub uri: String,
76}
77
78#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
79pub struct BooleanSchema {
80    #[serde(default, skip_serializing_if = "Option::is_none")]
81    pub default: Option<bool>,
82    #[serde(default, skip_serializing_if = "Option::is_none")]
83    pub description: Option<String>,
84    #[serde(default, skip_serializing_if = "Option::is_none")]
85    pub title: Option<String>,
86    pub r#type: String, // &'static str = "boolean"
87}
88
89#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
90pub enum CallToolRequest {}
91
92impl ModelContextProtocolRequest for CallToolRequest {
93    const METHOD: &'static str = "tools/call";
94    type Params = CallToolRequestParams;
95    type Result = CallToolResult;
96}
97
98#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
99pub struct CallToolRequestParams {
100    #[serde(default, skip_serializing_if = "Option::is_none")]
101    pub arguments: Option<serde_json::Value>,
102    pub name: String,
103}
104
105/// The server's response to a tool call.
106#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
107pub struct CallToolResult {
108    pub content: Vec<ContentBlock>,
109    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
110    pub is_error: Option<bool>,
111    #[serde(
112        rename = "structuredContent",
113        default,
114        skip_serializing_if = "Option::is_none"
115    )]
116    pub structured_content: Option<serde_json::Value>,
117}
118
119impl From<CallToolResult> for serde_json::Value {
120    fn from(value: CallToolResult) -> Self {
121        // Leave this as it should never fail
122        #[expect(clippy::unwrap_used)]
123        serde_json::to_value(value).unwrap()
124    }
125}
126
127#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
128pub enum CancelledNotification {}
129
130impl ModelContextProtocolNotification for CancelledNotification {
131    const METHOD: &'static str = "notifications/cancelled";
132    type Params = CancelledNotificationParams;
133}
134
135#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
136pub struct CancelledNotificationParams {
137    #[serde(default, skip_serializing_if = "Option::is_none")]
138    pub reason: Option<String>,
139    #[serde(rename = "requestId")]
140    pub request_id: RequestId,
141}
142
143/// Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
144#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
145pub struct ClientCapabilities {
146    #[serde(default, skip_serializing_if = "Option::is_none")]
147    pub elicitation: Option<serde_json::Value>,
148    #[serde(default, skip_serializing_if = "Option::is_none")]
149    pub experimental: Option<serde_json::Value>,
150    #[serde(default, skip_serializing_if = "Option::is_none")]
151    pub roots: Option<ClientCapabilitiesRoots>,
152    #[serde(default, skip_serializing_if = "Option::is_none")]
153    pub sampling: Option<serde_json::Value>,
154}
155
156/// Present if the client supports listing roots.
157#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
158pub struct ClientCapabilitiesRoots {
159    #[serde(
160        rename = "listChanged",
161        default,
162        skip_serializing_if = "Option::is_none"
163    )]
164    pub list_changed: Option<bool>,
165}
166
167#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
168#[serde(untagged)]
169pub enum ClientNotification {
170    CancelledNotification(CancelledNotification),
171    InitializedNotification(InitializedNotification),
172    ProgressNotification(ProgressNotification),
173    RootsListChangedNotification(RootsListChangedNotification),
174}
175
176#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
177#[serde(tag = "method", content = "params")]
178pub enum ClientRequest {
179    #[serde(rename = "initialize")]
180    InitializeRequest(<InitializeRequest as ModelContextProtocolRequest>::Params),
181    #[serde(rename = "ping")]
182    PingRequest(<PingRequest as ModelContextProtocolRequest>::Params),
183    #[serde(rename = "resources/list")]
184    ListResourcesRequest(<ListResourcesRequest as ModelContextProtocolRequest>::Params),
185    #[serde(rename = "resources/templates/list")]
186    ListResourceTemplatesRequest(
187        <ListResourceTemplatesRequest as ModelContextProtocolRequest>::Params,
188    ),
189    #[serde(rename = "resources/read")]
190    ReadResourceRequest(<ReadResourceRequest as ModelContextProtocolRequest>::Params),
191    #[serde(rename = "resources/subscribe")]
192    SubscribeRequest(<SubscribeRequest as ModelContextProtocolRequest>::Params),
193    #[serde(rename = "resources/unsubscribe")]
194    UnsubscribeRequest(<UnsubscribeRequest as ModelContextProtocolRequest>::Params),
195    #[serde(rename = "prompts/list")]
196    ListPromptsRequest(<ListPromptsRequest as ModelContextProtocolRequest>::Params),
197    #[serde(rename = "prompts/get")]
198    GetPromptRequest(<GetPromptRequest as ModelContextProtocolRequest>::Params),
199    #[serde(rename = "tools/list")]
200    ListToolsRequest(<ListToolsRequest as ModelContextProtocolRequest>::Params),
201    #[serde(rename = "tools/call")]
202    CallToolRequest(<CallToolRequest as ModelContextProtocolRequest>::Params),
203    #[serde(rename = "logging/setLevel")]
204    SetLevelRequest(<SetLevelRequest as ModelContextProtocolRequest>::Params),
205    #[serde(rename = "completion/complete")]
206    CompleteRequest(<CompleteRequest as ModelContextProtocolRequest>::Params),
207}
208
209#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
210#[serde(untagged)]
211pub enum ClientResult {
212    Result(Result),
213    CreateMessageResult(CreateMessageResult),
214    ListRootsResult(ListRootsResult),
215    ElicitResult(ElicitResult),
216}
217
218#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
219pub enum CompleteRequest {}
220
221impl ModelContextProtocolRequest for CompleteRequest {
222    const METHOD: &'static str = "completion/complete";
223    type Params = CompleteRequestParams;
224    type Result = CompleteResult;
225}
226
227#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
228pub struct CompleteRequestParams {
229    pub argument: CompleteRequestParamsArgument,
230    #[serde(default, skip_serializing_if = "Option::is_none")]
231    pub context: Option<CompleteRequestParamsContext>,
232    pub r#ref: CompleteRequestParamsRef,
233}
234
235/// Additional, optional context for completions
236#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
237pub struct CompleteRequestParamsContext {
238    #[serde(default, skip_serializing_if = "Option::is_none")]
239    pub arguments: Option<serde_json::Value>,
240}
241
242/// The argument's information
243#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
244pub struct CompleteRequestParamsArgument {
245    pub name: String,
246    pub value: String,
247}
248
249#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
250#[serde(untagged)]
251pub enum CompleteRequestParamsRef {
252    PromptReference(PromptReference),
253    ResourceTemplateReference(ResourceTemplateReference),
254}
255
256/// The server's response to a completion/complete request
257#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
258pub struct CompleteResult {
259    pub completion: CompleteResultCompletion,
260}
261
262#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
263pub struct CompleteResultCompletion {
264    #[serde(rename = "hasMore", default, skip_serializing_if = "Option::is_none")]
265    pub has_more: Option<bool>,
266    #[serde(default, skip_serializing_if = "Option::is_none")]
267    pub total: Option<i64>,
268    pub values: Vec<String>,
269}
270
271impl From<CompleteResult> for serde_json::Value {
272    fn from(value: CompleteResult) -> Self {
273        // Leave this as it should never fail
274        #[expect(clippy::unwrap_used)]
275        serde_json::to_value(value).unwrap()
276    }
277}
278
279#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
280#[serde(untagged)]
281pub enum ContentBlock {
282    TextContent(TextContent),
283    ImageContent(ImageContent),
284    AudioContent(AudioContent),
285    ResourceLink(ResourceLink),
286    EmbeddedResource(EmbeddedResource),
287}
288
289#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
290pub enum CreateMessageRequest {}
291
292impl ModelContextProtocolRequest for CreateMessageRequest {
293    const METHOD: &'static str = "sampling/createMessage";
294    type Params = CreateMessageRequestParams;
295    type Result = CreateMessageResult;
296}
297
298#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
299pub struct CreateMessageRequestParams {
300    #[serde(
301        rename = "includeContext",
302        default,
303        skip_serializing_if = "Option::is_none"
304    )]
305    pub include_context: Option<String>,
306    #[serde(rename = "maxTokens")]
307    pub max_tokens: i64,
308    pub messages: Vec<SamplingMessage>,
309    #[serde(default, skip_serializing_if = "Option::is_none")]
310    pub metadata: Option<serde_json::Value>,
311    #[serde(
312        rename = "modelPreferences",
313        default,
314        skip_serializing_if = "Option::is_none"
315    )]
316    pub model_preferences: Option<ModelPreferences>,
317    #[serde(
318        rename = "stopSequences",
319        default,
320        skip_serializing_if = "Option::is_none"
321    )]
322    pub stop_sequences: Option<Vec<String>>,
323    #[serde(
324        rename = "systemPrompt",
325        default,
326        skip_serializing_if = "Option::is_none"
327    )]
328    pub system_prompt: Option<String>,
329    #[serde(default, skip_serializing_if = "Option::is_none")]
330    pub temperature: Option<f64>,
331}
332
333/// The client's response to a sampling/create_message request from the server. The client should inform the user before returning the sampled message, to allow them to inspect the response (human in the loop) and decide whether to allow the server to see it.
334#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
335pub struct CreateMessageResult {
336    pub content: CreateMessageResultContent,
337    pub model: String,
338    pub role: Role,
339    #[serde(
340        rename = "stopReason",
341        default,
342        skip_serializing_if = "Option::is_none"
343    )]
344    pub stop_reason: Option<String>,
345}
346
347#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
348#[serde(untagged)]
349pub enum CreateMessageResultContent {
350    TextContent(TextContent),
351    ImageContent(ImageContent),
352    AudioContent(AudioContent),
353}
354
355impl From<CreateMessageResult> for serde_json::Value {
356    fn from(value: CreateMessageResult) -> Self {
357        // Leave this as it should never fail
358        #[expect(clippy::unwrap_used)]
359        serde_json::to_value(value).unwrap()
360    }
361}
362
363#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
364pub struct Cursor(String);
365
366#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
367pub enum ElicitRequest {}
368
369impl ModelContextProtocolRequest for ElicitRequest {
370    const METHOD: &'static str = "elicitation/create";
371    type Params = ElicitRequestParams;
372    type Result = ElicitResult;
373}
374
375#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
376pub struct ElicitRequestParams {
377    pub message: String,
378    #[serde(rename = "requestedSchema")]
379    pub requested_schema: ElicitRequestParamsRequestedSchema,
380}
381
382/// A restricted subset of JSON Schema.
383/// Only top-level properties are allowed, without nesting.
384#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
385pub struct ElicitRequestParamsRequestedSchema {
386    pub properties: serde_json::Value,
387    #[serde(default, skip_serializing_if = "Option::is_none")]
388    pub required: Option<Vec<String>>,
389    pub r#type: String, // &'static str = "object"
390}
391
392/// The client's response to an elicitation request.
393#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
394pub struct ElicitResult {
395    pub action: String,
396    #[serde(default, skip_serializing_if = "Option::is_none")]
397    pub content: Option<serde_json::Value>,
398}
399
400impl From<ElicitResult> for serde_json::Value {
401    fn from(value: ElicitResult) -> Self {
402        // Leave this as it should never fail
403        #[expect(clippy::unwrap_used)]
404        serde_json::to_value(value).unwrap()
405    }
406}
407
408/// The contents of a resource, embedded into a prompt or tool call result.
409///
410/// It is up to the client how best to render embedded resources for the benefit
411/// of the LLM and/or the user.
412#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
413pub struct EmbeddedResource {
414    #[serde(default, skip_serializing_if = "Option::is_none")]
415    pub annotations: Option<Annotations>,
416    pub resource: EmbeddedResourceResource,
417    pub r#type: String, // &'static str = "resource"
418}
419
420#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
421#[serde(untagged)]
422pub enum EmbeddedResourceResource {
423    TextResourceContents(TextResourceContents),
424    BlobResourceContents(BlobResourceContents),
425}
426
427pub type EmptyResult = Result;
428
429#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
430pub struct EnumSchema {
431    #[serde(default, skip_serializing_if = "Option::is_none")]
432    pub description: Option<String>,
433    pub r#enum: Vec<String>,
434    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
435    pub enum_names: Option<Vec<String>>,
436    #[serde(default, skip_serializing_if = "Option::is_none")]
437    pub title: Option<String>,
438    pub r#type: String, // &'static str = "string"
439}
440
441#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
442pub enum GetPromptRequest {}
443
444impl ModelContextProtocolRequest for GetPromptRequest {
445    const METHOD: &'static str = "prompts/get";
446    type Params = GetPromptRequestParams;
447    type Result = GetPromptResult;
448}
449
450#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
451pub struct GetPromptRequestParams {
452    #[serde(default, skip_serializing_if = "Option::is_none")]
453    pub arguments: Option<serde_json::Value>,
454    pub name: String,
455}
456
457/// The server's response to a prompts/get request from the client.
458#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
459pub struct GetPromptResult {
460    #[serde(default, skip_serializing_if = "Option::is_none")]
461    pub description: Option<String>,
462    pub messages: Vec<PromptMessage>,
463}
464
465impl From<GetPromptResult> for serde_json::Value {
466    fn from(value: GetPromptResult) -> Self {
467        // Leave this as it should never fail
468        #[expect(clippy::unwrap_used)]
469        serde_json::to_value(value).unwrap()
470    }
471}
472
473/// An image provided to or from an LLM.
474#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
475pub struct ImageContent {
476    #[serde(default, skip_serializing_if = "Option::is_none")]
477    pub annotations: Option<Annotations>,
478    pub data: String,
479    #[serde(rename = "mimeType")]
480    pub mime_type: String,
481    pub r#type: String, // &'static str = "image"
482}
483
484/// Describes the name and version of an MCP implementation, with an optional title for UI representation.
485#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
486pub struct Implementation {
487    pub name: String,
488    #[serde(default, skip_serializing_if = "Option::is_none")]
489    pub title: Option<String>,
490    pub version: String,
491}
492
493#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
494pub enum InitializeRequest {}
495
496impl ModelContextProtocolRequest for InitializeRequest {
497    const METHOD: &'static str = "initialize";
498    type Params = InitializeRequestParams;
499    type Result = InitializeResult;
500}
501
502#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
503pub struct InitializeRequestParams {
504    pub capabilities: ClientCapabilities,
505    #[serde(rename = "clientInfo")]
506    pub client_info: Implementation,
507    #[serde(rename = "protocolVersion")]
508    pub protocol_version: String,
509}
510
511/// After receiving an initialize request from the client, the server sends this response.
512#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
513pub struct InitializeResult {
514    pub capabilities: ServerCapabilities,
515    #[serde(default, skip_serializing_if = "Option::is_none")]
516    pub instructions: Option<String>,
517    #[serde(rename = "protocolVersion")]
518    pub protocol_version: String,
519    #[serde(rename = "serverInfo")]
520    pub server_info: Implementation,
521}
522
523impl From<InitializeResult> for serde_json::Value {
524    fn from(value: InitializeResult) -> Self {
525        // Leave this as it should never fail
526        #[expect(clippy::unwrap_used)]
527        serde_json::to_value(value).unwrap()
528    }
529}
530
531#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
532pub enum InitializedNotification {}
533
534impl ModelContextProtocolNotification for InitializedNotification {
535    const METHOD: &'static str = "notifications/initialized";
536    type Params = Option<serde_json::Value>;
537}
538
539/// A response to a request that indicates an error occurred.
540#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
541pub struct JSONRPCError {
542    pub error: JSONRPCErrorError,
543    pub id: RequestId,
544    #[serde(rename = "jsonrpc", default = "default_jsonrpc")]
545    pub jsonrpc: String,
546}
547
548#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
549pub struct JSONRPCErrorError {
550    pub code: i64,
551    #[serde(default, skip_serializing_if = "Option::is_none")]
552    pub data: Option<serde_json::Value>,
553    pub message: String,
554}
555
556/// Refers to any valid JSON-RPC object that can be decoded off the wire, or encoded to be sent.
557#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
558#[serde(untagged)]
559pub enum JSONRPCMessage {
560    Request(JSONRPCRequest),
561    Notification(JSONRPCNotification),
562    Response(JSONRPCResponse),
563    Error(JSONRPCError),
564}
565
566/// A notification which does not expect a response.
567#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
568pub struct JSONRPCNotification {
569    #[serde(rename = "jsonrpc", default = "default_jsonrpc")]
570    pub jsonrpc: String,
571    pub method: String,
572    #[serde(default, skip_serializing_if = "Option::is_none")]
573    pub params: Option<serde_json::Value>,
574}
575
576/// A request that expects a response.
577#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
578pub struct JSONRPCRequest {
579    pub id: RequestId,
580    #[serde(rename = "jsonrpc", default = "default_jsonrpc")]
581    pub jsonrpc: String,
582    pub method: String,
583    #[serde(default, skip_serializing_if = "Option::is_none")]
584    pub params: Option<serde_json::Value>,
585}
586
587/// A successful (non-error) response to a request.
588#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
589pub struct JSONRPCResponse {
590    pub id: RequestId,
591    #[serde(rename = "jsonrpc", default = "default_jsonrpc")]
592    pub jsonrpc: String,
593    pub result: Result,
594}
595
596#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
597pub enum ListPromptsRequest {}
598
599impl ModelContextProtocolRequest for ListPromptsRequest {
600    const METHOD: &'static str = "prompts/list";
601    type Params = Option<ListPromptsRequestParams>;
602    type Result = ListPromptsResult;
603}
604
605#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
606pub struct ListPromptsRequestParams {
607    #[serde(default, skip_serializing_if = "Option::is_none")]
608    pub cursor: Option<String>,
609}
610
611/// The server's response to a prompts/list request from the client.
612#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
613pub struct ListPromptsResult {
614    #[serde(
615        rename = "nextCursor",
616        default,
617        skip_serializing_if = "Option::is_none"
618    )]
619    pub next_cursor: Option<String>,
620    pub prompts: Vec<Prompt>,
621}
622
623impl From<ListPromptsResult> for serde_json::Value {
624    fn from(value: ListPromptsResult) -> Self {
625        // Leave this as it should never fail
626        #[expect(clippy::unwrap_used)]
627        serde_json::to_value(value).unwrap()
628    }
629}
630
631#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
632pub enum ListResourceTemplatesRequest {}
633
634impl ModelContextProtocolRequest for ListResourceTemplatesRequest {
635    const METHOD: &'static str = "resources/templates/list";
636    type Params = Option<ListResourceTemplatesRequestParams>;
637    type Result = ListResourceTemplatesResult;
638}
639
640#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
641pub struct ListResourceTemplatesRequestParams {
642    #[serde(default, skip_serializing_if = "Option::is_none")]
643    pub cursor: Option<String>,
644}
645
646/// The server's response to a resources/templates/list request from the client.
647#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
648pub struct ListResourceTemplatesResult {
649    #[serde(
650        rename = "nextCursor",
651        default,
652        skip_serializing_if = "Option::is_none"
653    )]
654    pub next_cursor: Option<String>,
655    #[serde(rename = "resourceTemplates")]
656    pub resource_templates: Vec<ResourceTemplate>,
657}
658
659impl From<ListResourceTemplatesResult> for serde_json::Value {
660    fn from(value: ListResourceTemplatesResult) -> Self {
661        // Leave this as it should never fail
662        #[expect(clippy::unwrap_used)]
663        serde_json::to_value(value).unwrap()
664    }
665}
666
667#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
668pub enum ListResourcesRequest {}
669
670impl ModelContextProtocolRequest for ListResourcesRequest {
671    const METHOD: &'static str = "resources/list";
672    type Params = Option<ListResourcesRequestParams>;
673    type Result = ListResourcesResult;
674}
675
676#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
677pub struct ListResourcesRequestParams {
678    #[serde(default, skip_serializing_if = "Option::is_none")]
679    pub cursor: Option<String>,
680}
681
682/// The server's response to a resources/list request from the client.
683#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
684pub struct ListResourcesResult {
685    #[serde(
686        rename = "nextCursor",
687        default,
688        skip_serializing_if = "Option::is_none"
689    )]
690    pub next_cursor: Option<String>,
691    pub resources: Vec<Resource>,
692}
693
694impl From<ListResourcesResult> for serde_json::Value {
695    fn from(value: ListResourcesResult) -> Self {
696        // Leave this as it should never fail
697        #[expect(clippy::unwrap_used)]
698        serde_json::to_value(value).unwrap()
699    }
700}
701
702#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
703pub enum ListRootsRequest {}
704
705impl ModelContextProtocolRequest for ListRootsRequest {
706    const METHOD: &'static str = "roots/list";
707    type Params = Option<serde_json::Value>;
708    type Result = ListRootsResult;
709}
710
711/// The client's response to a roots/list request from the server.
712/// This result contains an array of Root objects, each representing a root directory
713/// or file that the server can operate on.
714#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
715pub struct ListRootsResult {
716    pub roots: Vec<Root>,
717}
718
719impl From<ListRootsResult> for serde_json::Value {
720    fn from(value: ListRootsResult) -> Self {
721        // Leave this as it should never fail
722        #[expect(clippy::unwrap_used)]
723        serde_json::to_value(value).unwrap()
724    }
725}
726
727#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
728pub enum ListToolsRequest {}
729
730impl ModelContextProtocolRequest for ListToolsRequest {
731    const METHOD: &'static str = "tools/list";
732    type Params = Option<ListToolsRequestParams>;
733    type Result = ListToolsResult;
734}
735
736#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
737pub struct ListToolsRequestParams {
738    #[serde(default, skip_serializing_if = "Option::is_none")]
739    pub cursor: Option<String>,
740}
741
742/// The server's response to a tools/list request from the client.
743#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
744pub struct ListToolsResult {
745    #[serde(
746        rename = "nextCursor",
747        default,
748        skip_serializing_if = "Option::is_none"
749    )]
750    pub next_cursor: Option<String>,
751    pub tools: Vec<Tool>,
752}
753
754impl From<ListToolsResult> for serde_json::Value {
755    fn from(value: ListToolsResult) -> Self {
756        // Leave this as it should never fail
757        #[expect(clippy::unwrap_used)]
758        serde_json::to_value(value).unwrap()
759    }
760}
761
762/// The severity of a log message.
763///
764/// These map to syslog message severities, as specified in RFC-5424:
765/// https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
766#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
767pub enum LoggingLevel {
768    #[serde(rename = "alert")]
769    Alert,
770    #[serde(rename = "critical")]
771    Critical,
772    #[serde(rename = "debug")]
773    Debug,
774    #[serde(rename = "emergency")]
775    Emergency,
776    #[serde(rename = "error")]
777    Error,
778    #[serde(rename = "info")]
779    Info,
780    #[serde(rename = "notice")]
781    Notice,
782    #[serde(rename = "warning")]
783    Warning,
784}
785
786#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
787pub enum LoggingMessageNotification {}
788
789impl ModelContextProtocolNotification for LoggingMessageNotification {
790    const METHOD: &'static str = "notifications/message";
791    type Params = LoggingMessageNotificationParams;
792}
793
794#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
795pub struct LoggingMessageNotificationParams {
796    pub data: serde_json::Value,
797    pub level: LoggingLevel,
798    #[serde(default, skip_serializing_if = "Option::is_none")]
799    pub logger: Option<String>,
800}
801
802/// Hints to use for model selection.
803///
804/// Keys not declared here are currently left unspecified by the spec and are up
805/// to the client to interpret.
806#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
807pub struct ModelHint {
808    #[serde(default, skip_serializing_if = "Option::is_none")]
809    pub name: Option<String>,
810}
811
812/// The server's preferences for model selection, requested of the client during sampling.
813///
814/// Because LLMs can vary along multiple dimensions, choosing the "best" model is
815/// rarely straightforward.  Different models excel in different areas—some are
816/// faster but less capable, others are more capable but more expensive, and so
817/// on. This interface allows servers to express their priorities across multiple
818/// dimensions to help clients make an appropriate selection for their use case.
819///
820/// These preferences are always advisory. The client MAY ignore them. It is also
821/// up to the client to decide how to interpret these preferences and how to
822/// balance them against other considerations.
823#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
824pub struct ModelPreferences {
825    #[serde(
826        rename = "costPriority",
827        default,
828        skip_serializing_if = "Option::is_none"
829    )]
830    pub cost_priority: Option<f64>,
831    #[serde(default, skip_serializing_if = "Option::is_none")]
832    pub hints: Option<Vec<ModelHint>>,
833    #[serde(
834        rename = "intelligencePriority",
835        default,
836        skip_serializing_if = "Option::is_none"
837    )]
838    pub intelligence_priority: Option<f64>,
839    #[serde(
840        rename = "speedPriority",
841        default,
842        skip_serializing_if = "Option::is_none"
843    )]
844    pub speed_priority: Option<f64>,
845}
846
847#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
848pub struct Notification {
849    pub method: String,
850    #[serde(default, skip_serializing_if = "Option::is_none")]
851    pub params: Option<serde_json::Value>,
852}
853
854#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
855pub struct NumberSchema {
856    #[serde(default, skip_serializing_if = "Option::is_none")]
857    pub description: Option<String>,
858    #[serde(default, skip_serializing_if = "Option::is_none")]
859    pub maximum: Option<i64>,
860    #[serde(default, skip_serializing_if = "Option::is_none")]
861    pub minimum: Option<i64>,
862    #[serde(default, skip_serializing_if = "Option::is_none")]
863    pub title: Option<String>,
864    pub r#type: String,
865}
866
867#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
868pub struct PaginatedRequest {
869    pub method: String,
870    #[serde(default, skip_serializing_if = "Option::is_none")]
871    pub params: Option<PaginatedRequestParams>,
872}
873
874#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
875pub struct PaginatedRequestParams {
876    #[serde(default, skip_serializing_if = "Option::is_none")]
877    pub cursor: Option<String>,
878}
879
880#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
881pub struct PaginatedResult {
882    #[serde(
883        rename = "nextCursor",
884        default,
885        skip_serializing_if = "Option::is_none"
886    )]
887    pub next_cursor: Option<String>,
888}
889
890impl From<PaginatedResult> for serde_json::Value {
891    fn from(value: PaginatedResult) -> Self {
892        // Leave this as it should never fail
893        #[expect(clippy::unwrap_used)]
894        serde_json::to_value(value).unwrap()
895    }
896}
897
898#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
899pub enum PingRequest {}
900
901impl ModelContextProtocolRequest for PingRequest {
902    const METHOD: &'static str = "ping";
903    type Params = Option<serde_json::Value>;
904    type Result = Result;
905}
906
907/// Restricted schema definitions that only allow primitive types
908/// without nested objects or arrays.
909#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
910#[serde(untagged)]
911pub enum PrimitiveSchemaDefinition {
912    StringSchema(StringSchema),
913    NumberSchema(NumberSchema),
914    BooleanSchema(BooleanSchema),
915    EnumSchema(EnumSchema),
916}
917
918#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
919pub enum ProgressNotification {}
920
921impl ModelContextProtocolNotification for ProgressNotification {
922    const METHOD: &'static str = "notifications/progress";
923    type Params = ProgressNotificationParams;
924}
925
926#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
927pub struct ProgressNotificationParams {
928    #[serde(default, skip_serializing_if = "Option::is_none")]
929    pub message: Option<String>,
930    pub progress: f64,
931    #[serde(rename = "progressToken")]
932    pub progress_token: ProgressToken,
933    #[serde(default, skip_serializing_if = "Option::is_none")]
934    pub total: Option<f64>,
935}
936
937#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Hash, Eq, TS)]
938#[serde(untagged)]
939pub enum ProgressToken {
940    String(String),
941    Integer(i64),
942}
943
944/// A prompt or prompt template that the server offers.
945#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
946pub struct Prompt {
947    #[serde(default, skip_serializing_if = "Option::is_none")]
948    pub arguments: Option<Vec<PromptArgument>>,
949    #[serde(default, skip_serializing_if = "Option::is_none")]
950    pub description: Option<String>,
951    pub name: String,
952    #[serde(default, skip_serializing_if = "Option::is_none")]
953    pub title: Option<String>,
954}
955
956/// Describes an argument that a prompt can accept.
957#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
958pub struct PromptArgument {
959    #[serde(default, skip_serializing_if = "Option::is_none")]
960    pub description: Option<String>,
961    pub name: String,
962    #[serde(default, skip_serializing_if = "Option::is_none")]
963    pub required: Option<bool>,
964    #[serde(default, skip_serializing_if = "Option::is_none")]
965    pub title: Option<String>,
966}
967
968#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
969pub enum PromptListChangedNotification {}
970
971impl ModelContextProtocolNotification for PromptListChangedNotification {
972    const METHOD: &'static str = "notifications/prompts/list_changed";
973    type Params = Option<serde_json::Value>;
974}
975
976/// Describes a message returned as part of a prompt.
977///
978/// This is similar to `SamplingMessage`, but also supports the embedding of
979/// resources from the MCP server.
980#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
981pub struct PromptMessage {
982    pub content: ContentBlock,
983    pub role: Role,
984}
985
986/// Identifies a prompt.
987#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
988pub struct PromptReference {
989    pub name: String,
990    #[serde(default, skip_serializing_if = "Option::is_none")]
991    pub title: Option<String>,
992    pub r#type: String, // &'static str = "ref/prompt"
993}
994
995#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
996pub enum ReadResourceRequest {}
997
998impl ModelContextProtocolRequest for ReadResourceRequest {
999    const METHOD: &'static str = "resources/read";
1000    type Params = ReadResourceRequestParams;
1001    type Result = ReadResourceResult;
1002}
1003
1004#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1005pub struct ReadResourceRequestParams {
1006    pub uri: String,
1007}
1008
1009/// The server's response to a resources/read request from the client.
1010#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1011pub struct ReadResourceResult {
1012    pub contents: Vec<ReadResourceResultContents>,
1013}
1014
1015#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1016#[serde(untagged)]
1017pub enum ReadResourceResultContents {
1018    TextResourceContents(TextResourceContents),
1019    BlobResourceContents(BlobResourceContents),
1020}
1021
1022impl From<ReadResourceResult> for serde_json::Value {
1023    fn from(value: ReadResourceResult) -> Self {
1024        // Leave this as it should never fail
1025        #[expect(clippy::unwrap_used)]
1026        serde_json::to_value(value).unwrap()
1027    }
1028}
1029
1030#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1031pub struct Request {
1032    pub method: String,
1033    #[serde(default, skip_serializing_if = "Option::is_none")]
1034    pub params: Option<serde_json::Value>,
1035}
1036
1037#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Hash, Eq, TS)]
1038#[serde(untagged)]
1039pub enum RequestId {
1040    String(String),
1041    Integer(i64),
1042}
1043
1044/// A known resource that the server is capable of reading.
1045#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1046pub struct Resource {
1047    #[serde(default, skip_serializing_if = "Option::is_none")]
1048    pub annotations: Option<Annotations>,
1049    #[serde(default, skip_serializing_if = "Option::is_none")]
1050    pub description: Option<String>,
1051    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1052    pub mime_type: Option<String>,
1053    pub name: String,
1054    #[serde(default, skip_serializing_if = "Option::is_none")]
1055    pub size: Option<i64>,
1056    #[serde(default, skip_serializing_if = "Option::is_none")]
1057    pub title: Option<String>,
1058    pub uri: String,
1059}
1060
1061/// The contents of a specific resource or sub-resource.
1062#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1063pub struct ResourceContents {
1064    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1065    pub mime_type: Option<String>,
1066    pub uri: String,
1067}
1068
1069/// A resource that the server is capable of reading, included in a prompt or tool call result.
1070///
1071/// Note: resource links returned by tools are not guaranteed to appear in the results of `resources/list` requests.
1072#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1073pub struct ResourceLink {
1074    #[serde(default, skip_serializing_if = "Option::is_none")]
1075    pub annotations: Option<Annotations>,
1076    #[serde(default, skip_serializing_if = "Option::is_none")]
1077    pub description: Option<String>,
1078    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1079    pub mime_type: Option<String>,
1080    pub name: String,
1081    #[serde(default, skip_serializing_if = "Option::is_none")]
1082    pub size: Option<i64>,
1083    #[serde(default, skip_serializing_if = "Option::is_none")]
1084    pub title: Option<String>,
1085    pub r#type: String, // &'static str = "resource_link"
1086    pub uri: String,
1087}
1088
1089#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1090pub enum ResourceListChangedNotification {}
1091
1092impl ModelContextProtocolNotification for ResourceListChangedNotification {
1093    const METHOD: &'static str = "notifications/resources/list_changed";
1094    type Params = Option<serde_json::Value>;
1095}
1096
1097/// A template description for resources available on the server.
1098#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1099pub struct ResourceTemplate {
1100    #[serde(default, skip_serializing_if = "Option::is_none")]
1101    pub annotations: Option<Annotations>,
1102    #[serde(default, skip_serializing_if = "Option::is_none")]
1103    pub description: Option<String>,
1104    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1105    pub mime_type: Option<String>,
1106    pub name: String,
1107    #[serde(default, skip_serializing_if = "Option::is_none")]
1108    pub title: Option<String>,
1109    #[serde(rename = "uriTemplate")]
1110    pub uri_template: String,
1111}
1112
1113/// A reference to a resource or resource template definition.
1114#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1115pub struct ResourceTemplateReference {
1116    pub r#type: String, // &'static str = "ref/resource"
1117    pub uri: String,
1118}
1119
1120#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1121pub enum ResourceUpdatedNotification {}
1122
1123impl ModelContextProtocolNotification for ResourceUpdatedNotification {
1124    const METHOD: &'static str = "notifications/resources/updated";
1125    type Params = ResourceUpdatedNotificationParams;
1126}
1127
1128#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1129pub struct ResourceUpdatedNotificationParams {
1130    pub uri: String,
1131}
1132
1133pub type Result = serde_json::Value;
1134
1135/// The sender or recipient of messages and data in a conversation.
1136#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1137pub enum Role {
1138    #[serde(rename = "assistant")]
1139    Assistant,
1140    #[serde(rename = "user")]
1141    User,
1142}
1143
1144/// Represents a root directory or file that the server can operate on.
1145#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1146pub struct Root {
1147    #[serde(default, skip_serializing_if = "Option::is_none")]
1148    pub name: Option<String>,
1149    pub uri: String,
1150}
1151
1152#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1153pub enum RootsListChangedNotification {}
1154
1155impl ModelContextProtocolNotification for RootsListChangedNotification {
1156    const METHOD: &'static str = "notifications/roots/list_changed";
1157    type Params = Option<serde_json::Value>;
1158}
1159
1160/// Describes a message issued to or received from an LLM API.
1161#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1162pub struct SamplingMessage {
1163    pub content: SamplingMessageContent,
1164    pub role: Role,
1165}
1166
1167#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1168#[serde(untagged)]
1169pub enum SamplingMessageContent {
1170    TextContent(TextContent),
1171    ImageContent(ImageContent),
1172    AudioContent(AudioContent),
1173}
1174
1175/// Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
1176#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1177pub struct ServerCapabilities {
1178    #[serde(default, skip_serializing_if = "Option::is_none")]
1179    pub completions: Option<serde_json::Value>,
1180    #[serde(default, skip_serializing_if = "Option::is_none")]
1181    pub experimental: Option<serde_json::Value>,
1182    #[serde(default, skip_serializing_if = "Option::is_none")]
1183    pub logging: Option<serde_json::Value>,
1184    #[serde(default, skip_serializing_if = "Option::is_none")]
1185    pub prompts: Option<ServerCapabilitiesPrompts>,
1186    #[serde(default, skip_serializing_if = "Option::is_none")]
1187    pub resources: Option<ServerCapabilitiesResources>,
1188    #[serde(default, skip_serializing_if = "Option::is_none")]
1189    pub tools: Option<ServerCapabilitiesTools>,
1190}
1191
1192/// Present if the server offers any tools to call.
1193#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1194pub struct ServerCapabilitiesTools {
1195    #[serde(
1196        rename = "listChanged",
1197        default,
1198        skip_serializing_if = "Option::is_none"
1199    )]
1200    pub list_changed: Option<bool>,
1201}
1202
1203/// Present if the server offers any resources to read.
1204#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1205pub struct ServerCapabilitiesResources {
1206    #[serde(
1207        rename = "listChanged",
1208        default,
1209        skip_serializing_if = "Option::is_none"
1210    )]
1211    pub list_changed: Option<bool>,
1212    #[serde(default, skip_serializing_if = "Option::is_none")]
1213    pub subscribe: Option<bool>,
1214}
1215
1216/// Present if the server offers any prompt templates.
1217#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1218pub struct ServerCapabilitiesPrompts {
1219    #[serde(
1220        rename = "listChanged",
1221        default,
1222        skip_serializing_if = "Option::is_none"
1223    )]
1224    pub list_changed: Option<bool>,
1225}
1226
1227#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1228#[serde(tag = "method", content = "params")]
1229pub enum ServerNotification {
1230    #[serde(rename = "notifications/cancelled")]
1231    CancelledNotification(<CancelledNotification as ModelContextProtocolNotification>::Params),
1232    #[serde(rename = "notifications/progress")]
1233    ProgressNotification(<ProgressNotification as ModelContextProtocolNotification>::Params),
1234    #[serde(rename = "notifications/resources/list_changed")]
1235    ResourceListChangedNotification(
1236        <ResourceListChangedNotification as ModelContextProtocolNotification>::Params,
1237    ),
1238    #[serde(rename = "notifications/resources/updated")]
1239    ResourceUpdatedNotification(
1240        <ResourceUpdatedNotification as ModelContextProtocolNotification>::Params,
1241    ),
1242    #[serde(rename = "notifications/prompts/list_changed")]
1243    PromptListChangedNotification(
1244        <PromptListChangedNotification as ModelContextProtocolNotification>::Params,
1245    ),
1246    #[serde(rename = "notifications/tools/list_changed")]
1247    ToolListChangedNotification(
1248        <ToolListChangedNotification as ModelContextProtocolNotification>::Params,
1249    ),
1250    #[serde(rename = "notifications/message")]
1251    LoggingMessageNotification(
1252        <LoggingMessageNotification as ModelContextProtocolNotification>::Params,
1253    ),
1254}
1255
1256#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1257#[serde(untagged)]
1258pub enum ServerRequest {
1259    PingRequest(PingRequest),
1260    CreateMessageRequest(CreateMessageRequest),
1261    ListRootsRequest(ListRootsRequest),
1262    ElicitRequest(ElicitRequest),
1263}
1264
1265#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1266#[serde(untagged)]
1267#[allow(clippy::large_enum_variant)]
1268pub enum ServerResult {
1269    Result(Result),
1270    InitializeResult(InitializeResult),
1271    ListResourcesResult(ListResourcesResult),
1272    ListResourceTemplatesResult(ListResourceTemplatesResult),
1273    ReadResourceResult(ReadResourceResult),
1274    ListPromptsResult(ListPromptsResult),
1275    GetPromptResult(GetPromptResult),
1276    ListToolsResult(ListToolsResult),
1277    CallToolResult(CallToolResult),
1278    CompleteResult(CompleteResult),
1279}
1280
1281#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1282pub enum SetLevelRequest {}
1283
1284impl ModelContextProtocolRequest for SetLevelRequest {
1285    const METHOD: &'static str = "logging/setLevel";
1286    type Params = SetLevelRequestParams;
1287    type Result = Result;
1288}
1289
1290#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1291pub struct SetLevelRequestParams {
1292    pub level: LoggingLevel,
1293}
1294
1295#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1296pub struct StringSchema {
1297    #[serde(default, skip_serializing_if = "Option::is_none")]
1298    pub description: Option<String>,
1299    #[serde(default, skip_serializing_if = "Option::is_none")]
1300    pub format: Option<String>,
1301    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
1302    pub max_length: Option<i64>,
1303    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
1304    pub min_length: Option<i64>,
1305    #[serde(default, skip_serializing_if = "Option::is_none")]
1306    pub title: Option<String>,
1307    pub r#type: String, // &'static str = "string"
1308}
1309
1310#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1311pub enum SubscribeRequest {}
1312
1313impl ModelContextProtocolRequest for SubscribeRequest {
1314    const METHOD: &'static str = "resources/subscribe";
1315    type Params = SubscribeRequestParams;
1316    type Result = Result;
1317}
1318
1319#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1320pub struct SubscribeRequestParams {
1321    pub uri: String,
1322}
1323
1324/// Text provided to or from an LLM.
1325#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1326pub struct TextContent {
1327    #[serde(default, skip_serializing_if = "Option::is_none")]
1328    pub annotations: Option<Annotations>,
1329    pub text: String,
1330    pub r#type: String, // &'static str = "text"
1331}
1332
1333#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1334pub struct TextResourceContents {
1335    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1336    pub mime_type: Option<String>,
1337    pub text: String,
1338    pub uri: String,
1339}
1340
1341/// Definition for a tool the client can call.
1342#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1343pub struct Tool {
1344    #[serde(default, skip_serializing_if = "Option::is_none")]
1345    pub annotations: Option<ToolAnnotations>,
1346    #[serde(default, skip_serializing_if = "Option::is_none")]
1347    pub description: Option<String>,
1348    #[serde(rename = "inputSchema")]
1349    pub input_schema: ToolInputSchema,
1350    pub name: String,
1351    #[serde(
1352        rename = "outputSchema",
1353        default,
1354        skip_serializing_if = "Option::is_none"
1355    )]
1356    pub output_schema: Option<ToolOutputSchema>,
1357    #[serde(default, skip_serializing_if = "Option::is_none")]
1358    pub title: Option<String>,
1359}
1360
1361/// An optional JSON Schema object defining the structure of the tool's output returned in
1362/// the structuredContent field of a CallToolResult.
1363#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1364pub struct ToolOutputSchema {
1365    #[serde(default, skip_serializing_if = "Option::is_none")]
1366    pub properties: Option<serde_json::Value>,
1367    #[serde(default, skip_serializing_if = "Option::is_none")]
1368    pub required: Option<Vec<String>>,
1369    pub r#type: String, // &'static str = "object"
1370}
1371
1372/// A JSON Schema object defining the expected parameters for the tool.
1373#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1374pub struct ToolInputSchema {
1375    #[serde(default, skip_serializing_if = "Option::is_none")]
1376    pub properties: Option<serde_json::Value>,
1377    #[serde(default, skip_serializing_if = "Option::is_none")]
1378    pub required: Option<Vec<String>>,
1379    pub r#type: String, // &'static str = "object"
1380}
1381
1382/// Additional properties describing a Tool to clients.
1383///
1384/// NOTE: all properties in ToolAnnotations are **hints**.
1385/// They are not guaranteed to provide a faithful description of
1386/// tool behavior (including descriptive properties like `title`).
1387///
1388/// Clients should never make tool use decisions based on ToolAnnotations
1389/// received from untrusted servers.
1390#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1391pub struct ToolAnnotations {
1392    #[serde(
1393        rename = "destructiveHint",
1394        default,
1395        skip_serializing_if = "Option::is_none"
1396    )]
1397    pub destructive_hint: Option<bool>,
1398    #[serde(
1399        rename = "idempotentHint",
1400        default,
1401        skip_serializing_if = "Option::is_none"
1402    )]
1403    pub idempotent_hint: Option<bool>,
1404    #[serde(
1405        rename = "openWorldHint",
1406        default,
1407        skip_serializing_if = "Option::is_none"
1408    )]
1409    pub open_world_hint: Option<bool>,
1410    #[serde(
1411        rename = "readOnlyHint",
1412        default,
1413        skip_serializing_if = "Option::is_none"
1414    )]
1415    pub read_only_hint: Option<bool>,
1416    #[serde(default, skip_serializing_if = "Option::is_none")]
1417    pub title: Option<String>,
1418}
1419
1420#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1421pub enum ToolListChangedNotification {}
1422
1423impl ModelContextProtocolNotification for ToolListChangedNotification {
1424    const METHOD: &'static str = "notifications/tools/list_changed";
1425    type Params = Option<serde_json::Value>;
1426}
1427
1428#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1429pub enum UnsubscribeRequest {}
1430
1431impl ModelContextProtocolRequest for UnsubscribeRequest {
1432    const METHOD: &'static str = "resources/unsubscribe";
1433    type Params = UnsubscribeRequestParams;
1434    type Result = Result;
1435}
1436
1437#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]
1438pub struct UnsubscribeRequestParams {
1439    pub uri: String,
1440}
1441
1442impl TryFrom<JSONRPCRequest> for ClientRequest {
1443    type Error = serde_json::Error;
1444    fn try_from(req: JSONRPCRequest) -> std::result::Result<Self, Self::Error> {
1445        match req.method.as_str() {
1446            "initialize" => {
1447                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1448                let params: <InitializeRequest as ModelContextProtocolRequest>::Params =
1449                    serde_json::from_value(params_json)?;
1450                Ok(ClientRequest::InitializeRequest(params))
1451            }
1452            "ping" => {
1453                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1454                let params: <PingRequest as ModelContextProtocolRequest>::Params =
1455                    serde_json::from_value(params_json)?;
1456                Ok(ClientRequest::PingRequest(params))
1457            }
1458            "resources/list" => {
1459                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1460                let params: <ListResourcesRequest as ModelContextProtocolRequest>::Params =
1461                    serde_json::from_value(params_json)?;
1462                Ok(ClientRequest::ListResourcesRequest(params))
1463            }
1464            "resources/templates/list" => {
1465                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1466                let params: <ListResourceTemplatesRequest as ModelContextProtocolRequest>::Params =
1467                    serde_json::from_value(params_json)?;
1468                Ok(ClientRequest::ListResourceTemplatesRequest(params))
1469            }
1470            "resources/read" => {
1471                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1472                let params: <ReadResourceRequest as ModelContextProtocolRequest>::Params =
1473                    serde_json::from_value(params_json)?;
1474                Ok(ClientRequest::ReadResourceRequest(params))
1475            }
1476            "resources/subscribe" => {
1477                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1478                let params: <SubscribeRequest as ModelContextProtocolRequest>::Params =
1479                    serde_json::from_value(params_json)?;
1480                Ok(ClientRequest::SubscribeRequest(params))
1481            }
1482            "resources/unsubscribe" => {
1483                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1484                let params: <UnsubscribeRequest as ModelContextProtocolRequest>::Params =
1485                    serde_json::from_value(params_json)?;
1486                Ok(ClientRequest::UnsubscribeRequest(params))
1487            }
1488            "prompts/list" => {
1489                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1490                let params: <ListPromptsRequest as ModelContextProtocolRequest>::Params =
1491                    serde_json::from_value(params_json)?;
1492                Ok(ClientRequest::ListPromptsRequest(params))
1493            }
1494            "prompts/get" => {
1495                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1496                let params: <GetPromptRequest as ModelContextProtocolRequest>::Params =
1497                    serde_json::from_value(params_json)?;
1498                Ok(ClientRequest::GetPromptRequest(params))
1499            }
1500            "tools/list" => {
1501                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1502                let params: <ListToolsRequest as ModelContextProtocolRequest>::Params =
1503                    serde_json::from_value(params_json)?;
1504                Ok(ClientRequest::ListToolsRequest(params))
1505            }
1506            "tools/call" => {
1507                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1508                let params: <CallToolRequest as ModelContextProtocolRequest>::Params =
1509                    serde_json::from_value(params_json)?;
1510                Ok(ClientRequest::CallToolRequest(params))
1511            }
1512            "logging/setLevel" => {
1513                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1514                let params: <SetLevelRequest as ModelContextProtocolRequest>::Params =
1515                    serde_json::from_value(params_json)?;
1516                Ok(ClientRequest::SetLevelRequest(params))
1517            }
1518            "completion/complete" => {
1519                let params_json = req.params.unwrap_or(serde_json::Value::Null);
1520                let params: <CompleteRequest as ModelContextProtocolRequest>::Params =
1521                    serde_json::from_value(params_json)?;
1522                Ok(ClientRequest::CompleteRequest(params))
1523            }
1524            _ => Err(serde_json::Error::io(std::io::Error::new(
1525                std::io::ErrorKind::InvalidData,
1526                format!("Unknown method: {}", req.method),
1527            ))),
1528        }
1529    }
1530}
1531
1532impl TryFrom<JSONRPCNotification> for ServerNotification {
1533    type Error = serde_json::Error;
1534    fn try_from(n: JSONRPCNotification) -> std::result::Result<Self, Self::Error> {
1535        match n.method.as_str() {
1536            "notifications/cancelled" => {
1537                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1538                let params: <CancelledNotification as ModelContextProtocolNotification>::Params =
1539                    serde_json::from_value(params_json)?;
1540                Ok(ServerNotification::CancelledNotification(params))
1541            }
1542            "notifications/progress" => {
1543                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1544                let params: <ProgressNotification as ModelContextProtocolNotification>::Params =
1545                    serde_json::from_value(params_json)?;
1546                Ok(ServerNotification::ProgressNotification(params))
1547            }
1548            "notifications/resources/list_changed" => {
1549                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1550                let params: <ResourceListChangedNotification as ModelContextProtocolNotification>::Params = serde_json::from_value(params_json)?;
1551                Ok(ServerNotification::ResourceListChangedNotification(params))
1552            }
1553            "notifications/resources/updated" => {
1554                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1555                let params: <ResourceUpdatedNotification as ModelContextProtocolNotification>::Params = serde_json::from_value(params_json)?;
1556                Ok(ServerNotification::ResourceUpdatedNotification(params))
1557            }
1558            "notifications/prompts/list_changed" => {
1559                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1560                let params: <PromptListChangedNotification as ModelContextProtocolNotification>::Params = serde_json::from_value(params_json)?;
1561                Ok(ServerNotification::PromptListChangedNotification(params))
1562            }
1563            "notifications/tools/list_changed" => {
1564                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1565                let params: <ToolListChangedNotification as ModelContextProtocolNotification>::Params = serde_json::from_value(params_json)?;
1566                Ok(ServerNotification::ToolListChangedNotification(params))
1567            }
1568            "notifications/message" => {
1569                let params_json = n.params.unwrap_or(serde_json::Value::Null);
1570                let params: <LoggingMessageNotification as ModelContextProtocolNotification>::Params = serde_json::from_value(params_json)?;
1571                Ok(ServerNotification::LoggingMessageNotification(params))
1572            }
1573            _ => Err(serde_json::Error::io(std::io::Error::new(
1574                std::io::ErrorKind::InvalidData,
1575                format!("Unknown method: {}", n.method),
1576            ))),
1577        }
1578    }
1579}
agcodex_mcp_types/lib.rs

agcodex_mcp_types/
lib.rs
