mcp_sdk_rs/
types.rs

1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use std::collections::HashMap;
4
5/// A progress token, used to associate progress notifications with the original request
6pub type ProgressToken = String;
7
8/// An opaque token used to represent a cursor for pagination
9pub type Cursor = String;
10
11/// Base request metadata
12#[derive(Debug, Clone, Serialize, Deserialize)]
13pub struct RequestMeta {
14    #[serde(skip_serializing_if = "Option::is_none")]
15    pub progress_token: Option<ProgressToken>,
16}
17
18/// Base notification metadata
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct NotificationMeta {
21    #[serde(skip_serializing_if = "Option::is_none")]
22    pub custom: Option<HashMap<String, Value>>,
23}
24
25/// Progress information
26#[derive(Debug, Clone, Serialize, Deserialize)]
27pub struct Progress {
28    /// The progress thus far
29    pub progress: u64,
30    /// Optional total progress
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub total: Option<u64>,
33    /// Optional message describing the progress
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub message: Option<String>,
36}
37
38/// Resource contents
39#[derive(Debug, Clone, Serialize, Deserialize)]
40pub struct ResourceContents {
41    uri: String,
42    #[serde(rename = "mimeType")]
43    mime_type: Option<String>,
44    #[serde(skip_serializing_if = "Option::is_none")]
45    text: Option<String>,
46    #[serde(skip_serializing_if = "Option::is_none")]
47    blob: Option<String>,
48}
49
50/// A resource in the system
51#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct Resource {
53    /// Unique identifier for the resource
54    pub uri: String,
55    /// Human-readable name
56    pub name: String,
57    /// Optional description
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub description: Option<String>,
60    /// The MIME type of this resource, if known
61    #[serde(skip_serializing_if = "Option::is_none")]
62    #[serde(rename = "mimeType")]
63    pub mime_type: Option<String>,
64    /// The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known
65    #[serde(skip_serializing_if = "Option::is_none")]
66    pub size: Option<String>,
67}
68
69/// A resource template
70#[derive(Debug, Clone, Serialize, Deserialize)]
71pub struct ResourceTemplate {
72    /// Unique identifier for the resource
73    #[serde(rename = "uriTemplate")]
74    pub uri_template: String,
75    /// Human-readable name
76    pub name: String,
77    /// Optional description
78    #[serde(skip_serializing_if = "Option::is_none")]
79    pub description: Option<String>,
80    /// The MIME type of this resource, if known
81    #[serde(skip_serializing_if = "Option::is_none")]
82    #[serde(rename = "mimeType")]
83    pub mime_type: Option<String>,
84}
85
86/// Model preferences for completion requests
87#[derive(Debug, Clone, Serialize, Deserialize)]
88pub struct ModelPreferences {
89    /// Optional model name
90    #[serde(skip_serializing_if = "Option::is_none")]
91    pub model: Option<String>,
92    /// Optional temperature (0.0 - 1.0)
93    #[serde(skip_serializing_if = "Option::is_none")]
94    pub temperature: Option<f32>,
95    /// Optional maximum number of tokens
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub max_tokens: Option<u32>,
98}
99
100/// A completion result
101#[derive(Debug, Clone, Serialize, Deserialize)]
102pub struct Completion {
103    /// The completion text
104    pub text: String,
105    /// Optional score/confidence (0.0 - 1.0)
106    #[serde(skip_serializing_if = "Option::is_none")]
107    pub score: Option<f32>,
108}
109
110/// Client implementation information
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct Implementation {
113    /// Name of the implementation
114    pub name: String,
115    /// Version of the implementation
116    pub version: String,
117}
118
119/// Client capabilities
120#[derive(Debug, Clone, Default, Serialize, Deserialize)]
121pub struct ClientCapabilities {
122    /// Experimental, non-standard capabilities that the client supports
123    #[serde(skip_serializing_if = "Option::is_none")]
124    pub experimental: Option<Value>,
125    /// Present if the client supports listing roots
126    #[serde(skip_serializing_if = "Option::is_none")]
127    pub roots: Option<Value>,
128    /// Present if the client supports sampling from an LLM
129    #[serde(skip_serializing_if = "Option::is_none")]
130    pub sampling: Option<Value>,
131}
132
133/// Server capabilities
134#[derive(Debug, Clone, Default, Serialize, Deserialize)]
135pub struct ServerCapabilities {
136    /// Experimental, non-standard capabilities that the client supports
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub experimental: Option<Value>,
139    /// Present if the server supports sending log messages to the client
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub logging: Option<Value>,
142    /// Present if the server offers any prompt templates
143    #[serde(skip_serializing_if = "Option::is_none")]
144    pub prompts: Option<Value>,
145    /// Present if the server offers any resources to read
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub resources: Option<Value>,
148    /// Present if the server offers any tools to call
149    #[serde(skip_serializing_if = "Option::is_none")]
150    pub tools: Option<Value>,
151}
152
153/// Logging levels
154#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
155#[serde(rename_all = "lowercase")]
156pub enum LoggingLevel {
157    Debug,
158    Info,
159    Notice,
160    Warning,
161    Error,
162    Critical,
163    Alert,
164    Emergency,
165}
166impl From<LoggingLevel> for log::Level {
167    fn from(level: LoggingLevel) -> log::Level {
168        match level {
169            LoggingLevel::Debug => log::Level::Debug,
170            LoggingLevel::Info | LoggingLevel::Notice => log::Level::Info,
171            LoggingLevel::Warning => log::Level::Warn,
172            LoggingLevel::Error
173            | LoggingLevel::Critical
174            | LoggingLevel::Alert
175            | LoggingLevel::Emergency => log::Level::Error,
176        }
177    }
178}
179
180/// A log message
181#[derive(Debug, Clone, Serialize, Deserialize)]
182pub struct LoggingMessage {
183    pub level: LoggingLevel,
184    #[serde(skip_serializing_if = "Option::is_none")]
185    pub logger: Option<String>,
186    pub data: Value,
187}
188
189/// A prompt argument
190#[derive(Debug, Clone, Serialize, Deserialize)]
191pub struct PromptArgument {
192    pub name: String,
193    pub description: String,
194    #[serde(skip_serializing_if = "Option::is_none")]
195    pub default_value: Option<String>,
196}
197
198/// A prompt definition
199#[derive(Debug, Clone, Serialize, Deserialize)]
200pub struct Prompt {
201    pub name: String,
202    #[serde(skip_serializing_if = "Option::is_none")]
203    pub description: Option<String>,
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub arguments: Option<Vec<PromptArgument>>,
206}
207
208/// Content types for prompt messages
209#[derive(Debug, Clone, Serialize, Deserialize)]
210#[serde(tag = "type")]
211pub enum MessageContent {
212    #[serde(rename = "text")]
213    Text { text: String },
214    #[serde(rename = "image")]
215    Image {
216        data: String,
217        #[serde(rename = "mimeType")]
218        mime_type: Option<String>,
219    },
220    #[serde(rename = "audio")]
221    Audio {
222        data: String,
223        #[serde(rename = "mimeType")]
224        mime_type: Option<String>,
225    },
226    #[serde(rename = "resource")]
227    Resource {
228        uri: String,
229        #[serde(alias = "mimeType")]
230        mime_type: String,
231        text: String,
232    },
233}
234
235/// A prompt message
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct PromptMessage {
238    pub role: String,
239    pub content: MessageContent,
240}
241
242/// A tool definition
243#[derive(Debug, Clone, Serialize, Deserialize)]
244pub struct Tool {
245    pub name: String,
246    pub description: String,
247    #[serde(rename = "inputSchema", skip_serializing_if = "Option::is_none")]
248    pub input_schema: Option<ToolSchema>,
249    #[serde(skip_serializing_if = "Option::is_none")]
250    pub annotations: Option<ToolAnnotations>,
251}
252
253/// A tool's schema, defining the expected input parameters for the tool
254#[derive(Debug, Clone, Serialize, Deserialize)]
255pub struct ToolSchema {
256    #[serde(skip_serializing_if = "Option::is_none")]
257    pub properties: Option<Value>,
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub required: Option<Vec<String>>,
260}
261
262/// A tool's output
263#[derive(Debug, Clone, Serialize, Deserialize)]
264pub struct ToolResult {
265    pub content: Vec<MessageContent>,
266    #[serde(rename = "structuredContent", skip_serializing_if = "Option::is_none")]
267    pub structured_content: Option<Value>,
268}
269
270/// A tool's schema, defining the expected input parameters for the tool
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(rename_all = "camelCase")]
273pub struct ToolAnnotations {
274    #[serde(skip_serializing_if = "Option::is_none")]
275    pub title: Option<String>,
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub read_only_hint: Option<bool>,
278    #[serde(skip_serializing_if = "Option::is_none")]
279    pub destructive_hint: Option<bool>,
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub idempotent_hint: Option<bool>,
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub open_world_hint: Option<bool>,
284}
285
286/// Root definition
287#[derive(Debug, Clone, Serialize, Deserialize)]
288pub struct Root {
289    pub id: String,
290    pub name: String,
291    pub description: String,
292}
293
294/// /initialize request
295#[derive(Debug, Clone, Serialize, Deserialize)]
296pub struct InitializeRequest {
297    pub client_info: Implementation,
298    pub capabilities: ClientCapabilities,
299    #[serde(skip_serializing_if = "Option::is_none")]
300    pub protocol_version: Option<String>,
301}
302
303/// /initialize response
304#[derive(Debug, Clone, Serialize, Deserialize)]
305pub struct InitializeResult {
306    pub server_info: Implementation,
307    pub capabilities: ServerCapabilities,
308}
309
310/// /resources/list request
311#[derive(Debug, Clone, Serialize, Deserialize)]
312pub struct ListResourcesRequest {
313    #[serde(skip_serializing_if = "Option::is_none")]
314    pub root_id: Option<String>,
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub cursor: Option<Cursor>,
317}
318
319/// /resources/list response
320#[derive(Debug, Clone, Serialize, Deserialize)]
321pub struct ListResourcesResult {
322    pub resources: Vec<Resource>,
323    #[serde(skip_serializing_if = "Option::is_none")]
324    pub next_cursor: Option<Cursor>,
325}
326
327/// /prompts/list request
328#[derive(Debug, Clone, Serialize, Deserialize)]
329pub struct ListPromptsRequest {
330    #[serde(skip_serializing_if = "Option::is_none")]
331    pub cursor: Option<Cursor>,
332}
333
334/// /prompts/list response
335#[derive(Debug, Clone, Serialize, Deserialize)]
336pub struct ListPromptsResult {
337    pub prompts: Vec<Prompt>,
338    #[serde(skip_serializing_if = "Option::is_none")]
339    pub next_cursor: Option<Cursor>,
340}
341
342/// /prompts/get request
343#[derive(Debug, Clone, Serialize, Deserialize)]
344pub struct GetPromptRequest {
345    pub name: String,
346    pub arguments: Option<Value>,
347}
348
349/// /prompts/get response
350#[derive(Debug, Clone, Serialize, Deserialize)]
351pub struct GetPromptResult {
352    pub description: Option<String>,
353    pub messages: Vec<PromptMessage>,
354}
355
356/// /tools/list request
357#[derive(Debug, Clone, Serialize, Deserialize)]
358pub struct ListToolsRequest {
359    #[serde(skip_serializing_if = "Option::is_none")]
360    pub cursor: Option<Cursor>,
361}
362
363/// /tools/list response
364#[derive(Debug, Clone, Serialize, Deserialize)]
365pub struct ListToolsResult {
366    pub tools: Vec<Tool>,
367    #[serde(skip_serializing_if = "Option::is_none")]
368    pub next_cursor: Option<Cursor>,
369}
370
371/// Complete request
372#[derive(Debug, Clone, Serialize, Deserialize)]
373pub struct CompleteRequest {
374    pub prompt_id: String,
375    #[serde(skip_serializing_if = "Option::is_none")]
376    pub arguments: Option<HashMap<String, String>>,
377    #[serde(skip_serializing_if = "Option::is_none")]
378    pub model_preferences: Option<ModelPreferences>,
379}
380
381/// Complete result
382#[derive(Debug, Clone, Serialize, Deserialize)]
383pub struct CompleteResult {
384    pub completion: Completion,
385}
mcp_sdk_rs/types.rs

mcp_sdk_rs/
types.rs
