1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use std::collections::HashMap;
4
5#[derive(Debug, Clone, Serialize, Deserialize)]
10pub struct InitializeParams {
11 #[serde(rename = "protocolVersion")]
12 pub protocol_version: String,
13 pub capabilities: ClientCapabilities,
14 #[serde(rename = "clientInfo")]
15 pub client_info: Implementation,
16}
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
19pub struct InitializeResult {
20 #[serde(rename = "protocolVersion")]
21 pub protocol_version: String,
22 pub capabilities: ServerCapabilities,
23 #[serde(rename = "serverInfo")]
24 pub server_info: Implementation,
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
28pub struct Implementation {
29 pub name: String,
30 pub version: String,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize, Default)]
38pub struct ClientCapabilities {
39 #[serde(skip_serializing_if = "Option::is_none")]
40 pub roots: Option<RootsCapability>,
41 #[serde(skip_serializing_if = "Option::is_none")]
42 pub sampling: Option<SamplingCapability>,
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize, Default)]
46pub struct ServerCapabilities {
47 #[serde(skip_serializing_if = "Option::is_none")]
48 pub logging: Option<LoggingCapability>,
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub prompts: Option<PromptsCapability>,
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub resources: Option<ResourcesCapability>,
53 #[serde(skip_serializing_if = "Option::is_none")]
54 pub tools: Option<ToolsCapability>,
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize, Default)]
58pub struct RootsCapability {
59 #[serde(rename = "listChanged", skip_serializing_if = "Option::is_none")]
60 pub list_changed: Option<bool>,
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize, Default)]
64pub struct SamplingCapability {}
65
66#[derive(Debug, Clone, Serialize, Deserialize, Default)]
67pub struct LoggingCapability {}
68
69#[derive(Debug, Clone, Serialize, Deserialize, Default)]
70pub struct PromptsCapability {
71 #[serde(rename = "listChanged", skip_serializing_if = "Option::is_none")]
72 pub list_changed: Option<bool>,
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize, Default)]
76pub struct ResourcesCapability {
77 #[serde(skip_serializing_if = "Option::is_none")]
78 pub subscribe: Option<bool>,
79 #[serde(rename = "listChanged", skip_serializing_if = "Option::is_none")]
80 pub list_changed: Option<bool>,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize, Default)]
84pub struct ToolsCapability {
85 #[serde(rename = "listChanged", skip_serializing_if = "Option::is_none")]
86 pub list_changed: Option<bool>,
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
94pub struct ResourcesListParams {
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub cursor: Option<String>,
97}
98
99#[derive(Debug, Clone, Serialize, Deserialize)]
100pub struct ResourcesListResult {
101 pub resources: Vec<Resource>,
102 #[serde(rename = "nextCursor", skip_serializing_if = "Option::is_none")]
103 pub next_cursor: Option<String>,
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
107pub struct Resource {
108 pub uri: String,
109 pub name: String,
110 #[serde(skip_serializing_if = "Option::is_none")]
111 pub description: Option<String>,
112 #[serde(rename = "mimeType", skip_serializing_if = "Option::is_none")]
113 pub mime_type: Option<String>,
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
117pub struct ResourcesReadParams {
118 pub uri: String,
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
122pub struct ResourcesReadResult {
123 pub contents: Vec<ResourceContents>,
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub struct ResourceContents {
128 pub uri: String,
129 #[serde(rename = "mimeType", skip_serializing_if = "Option::is_none")]
130 pub mime_type: Option<String>,
131 #[serde(skip_serializing_if = "Option::is_none")]
132 pub text: Option<String>,
133 #[serde(skip_serializing_if = "Option::is_none")]
134 pub blob: Option<String>,
135}
136
137#[derive(Debug, Clone, Serialize, Deserialize)]
138pub struct ResourceTemplate {
139 #[serde(rename = "uriTemplate")]
140 pub uri_template: String,
141 pub name: String,
142 #[serde(skip_serializing_if = "Option::is_none")]
143 pub description: Option<String>,
144 #[serde(rename = "mimeType", skip_serializing_if = "Option::is_none")]
145 pub mime_type: Option<String>,
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
153pub struct ToolsListResult {
154 pub tools: Vec<Tool>,
155 #[serde(rename = "nextCursor", skip_serializing_if = "Option::is_none")]
156 pub next_cursor: Option<String>,
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize)]
160pub struct Tool {
161 pub name: String,
162 #[serde(skip_serializing_if = "Option::is_none")]
163 pub description: Option<String>,
164 #[serde(rename = "inputSchema")]
165 pub input_schema: Value,
166}
167
168#[derive(Debug, Clone, Serialize, Deserialize)]
169pub struct ToolsCallParams {
170 pub name: String,
171 #[serde(skip_serializing_if = "Option::is_none")]
172 pub arguments: Option<HashMap<String, Value>>,
173}
174
175#[derive(Debug, Clone, Serialize, Deserialize)]
176pub struct ToolsCallResult {
177 pub content: Vec<ToolContent>,
178 #[serde(rename = "isError", skip_serializing_if = "Option::is_none")]
179 pub is_error: Option<bool>,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(tag = "type")]
184pub enum ToolContent {
185 #[serde(rename = "text")]
186 Text { text: String },
187 #[serde(rename = "image")]
188 Image {
189 data: String,
190 #[serde(rename = "mimeType")]
191 mime_type: String,
192 },
193 #[serde(rename = "resource")]
194 Resource { resource: ResourceContents },
195}
196
197#[derive(Debug, Clone, Serialize, Deserialize)]
202pub struct PromptsListParams {
203 #[serde(skip_serializing_if = "Option::is_none")]
204 pub cursor: Option<String>,
205}
206
207#[derive(Debug, Clone, Serialize, Deserialize)]
208pub struct PromptsListResult {
209 pub prompts: Vec<Prompt>,
210 #[serde(rename = "nextCursor", skip_serializing_if = "Option::is_none")]
211 pub next_cursor: Option<String>,
212}
213
214#[derive(Debug, Clone, Serialize, Deserialize)]
215pub struct Prompt {
216 pub name: String,
217 #[serde(skip_serializing_if = "Option::is_none")]
218 pub description: Option<String>,
219 #[serde(skip_serializing_if = "Option::is_none")]
220 pub arguments: Option<Vec<PromptArgument>>,
221}
222
223#[derive(Debug, Clone, Serialize, Deserialize)]
224pub struct PromptArgument {
225 pub name: String,
226 #[serde(skip_serializing_if = "Option::is_none")]
227 pub description: Option<String>,
228 #[serde(skip_serializing_if = "Option::is_none")]
229 pub required: Option<bool>,
230}
231
232#[derive(Debug, Clone, Serialize, Deserialize)]
233pub struct PromptsGetParams {
234 pub name: String,
235 #[serde(skip_serializing_if = "Option::is_none")]
236 pub arguments: Option<HashMap<String, String>>,
237}
238
239#[derive(Debug, Clone, Serialize, Deserialize)]
240pub struct PromptsGetResult {
241 #[serde(skip_serializing_if = "Option::is_none")]
242 pub description: Option<String>,
243 pub messages: Vec<PromptMessage>,
244}
245
246#[derive(Debug, Clone, Serialize, Deserialize)]
247pub struct PromptMessage {
248 pub role: String,
249 pub content: PromptContent,
250}
251
252#[derive(Debug, Clone, Serialize, Deserialize)]
253#[serde(tag = "type")]
254pub enum PromptContent {
255 #[serde(rename = "text")]
256 Text { text: String },
257 #[serde(rename = "image")]
258 Image {
259 data: String,
260 #[serde(rename = "mimeType")]
261 mime_type: String,
262 },
263}
264
265#[derive(Debug, Clone, Serialize, Deserialize)]
270pub struct LoggingSetLevelParams {
271 pub level: LogLevel,
272}
273
274#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
275#[serde(rename_all = "lowercase")]
276pub enum LogLevel {
277 Debug,
278 Info,
279 Warning,
280 Error,
281}