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 { resource: ResourceContent },
228}
229#[derive(Debug, Clone, Serialize, Deserialize)]
230pub struct ResourceContent {
231    pub uri: String,
232    #[serde(alias = "mimeType")]
233    pub mime_type: String,
234    pub text: String,
235}
236
237/// A prompt message
238#[derive(Debug, Clone, Serialize, Deserialize)]
239pub struct PromptMessage {
240    pub role: String,
241    pub content: MessageContent,
242}
243
244/// A tool definition
245#[derive(Debug, Clone, Serialize, Deserialize)]
246pub struct Tool {
247    pub name: String,
248    pub description: String,
249    #[serde(rename = "inputSchema", skip_serializing_if = "Option::is_none")]
250    pub input_schema: Option<ToolSchema>,
251    #[serde(skip_serializing_if = "Option::is_none")]
252    pub annotations: Option<ToolAnnotations>,
253}
254
255/// A tool's schema, defining the expected input parameters for the tool
256#[derive(Debug, Clone, Serialize, Deserialize)]
257pub struct ToolSchema {
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub properties: Option<Value>,
260    #[serde(skip_serializing_if = "Option::is_none")]
261    pub required: Option<Vec<String>>,
262}
263
264/// A tool's output
265#[derive(Debug, Clone, Serialize, Deserialize)]
266pub struct ToolResult {
267    pub content: Vec<MessageContent>,
268    #[serde(rename = "structuredContent", skip_serializing_if = "Option::is_none")]
269    pub structured_content: Option<Value>,
270}
271
272/// A tool's schema, defining the expected input parameters for the tool
273#[derive(Debug, Clone, Serialize, Deserialize)]
274#[serde(rename_all = "camelCase")]
275pub struct ToolAnnotations {
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub title: Option<String>,
278    #[serde(skip_serializing_if = "Option::is_none")]
279    pub read_only_hint: Option<bool>,
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub destructive_hint: Option<bool>,
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub idempotent_hint: Option<bool>,
284    #[serde(skip_serializing_if = "Option::is_none")]
285    pub open_world_hint: Option<bool>,
286}
287
288/// Root definition
289#[derive(Debug, Clone, Serialize, Deserialize)]
290pub struct Root {
291    pub id: String,
292    pub name: String,
293    pub description: String,
294}
295
296/// /initialize request
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct InitializeRequest {
299    pub client_info: Implementation,
300    pub capabilities: ClientCapabilities,
301    #[serde(skip_serializing_if = "Option::is_none")]
302    pub protocol_version: Option<String>,
303}
304
305/// /initialize response
306#[derive(Debug, Clone, Serialize, Deserialize)]
307pub struct InitializeResult {
308    pub server_info: Implementation,
309    pub capabilities: ServerCapabilities,
310}
311
312/// /resources/list request
313#[derive(Debug, Clone, Serialize, Deserialize)]
314pub struct ListResourcesRequest {
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub root_id: Option<String>,
317    #[serde(skip_serializing_if = "Option::is_none")]
318    pub cursor: Option<Cursor>,
319}
320
321/// /resources/list response
322#[derive(Debug, Clone, Serialize, Deserialize)]
323pub struct ListResourcesResult {
324    pub resources: Vec<Resource>,
325    #[serde(skip_serializing_if = "Option::is_none")]
326    pub next_cursor: Option<Cursor>,
327}
328
329/// /prompts/list request
330#[derive(Debug, Clone, Serialize, Deserialize)]
331pub struct ListPromptsRequest {
332    #[serde(skip_serializing_if = "Option::is_none")]
333    pub cursor: Option<Cursor>,
334}
335
336/// /prompts/list response
337#[derive(Debug, Clone, Serialize, Deserialize)]
338pub struct ListPromptsResult {
339    pub prompts: Vec<Prompt>,
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub next_cursor: Option<Cursor>,
342}
343
344/// /prompts/get request
345#[derive(Debug, Clone, Serialize, Deserialize)]
346pub struct GetPromptRequest {
347    pub name: String,
348    pub arguments: Option<Value>,
349}
350
351/// /prompts/get response
352#[derive(Debug, Clone, Serialize, Deserialize)]
353pub struct GetPromptResult {
354    pub description: Option<String>,
355    pub messages: Vec<PromptMessage>,
356}
357
358/// /tools/list request
359#[derive(Debug, Clone, Serialize, Deserialize)]
360pub struct ListToolsRequest {
361    #[serde(skip_serializing_if = "Option::is_none")]
362    pub cursor: Option<Cursor>,
363}
364
365/// /tools/list response
366#[derive(Debug, Clone, Serialize, Deserialize)]
367pub struct ListToolsResult {
368    pub tools: Vec<Tool>,
369    #[serde(skip_serializing_if = "Option::is_none")]
370    pub next_cursor: Option<Cursor>,
371}
372
373/// Complete request
374#[derive(Debug, Clone, Serialize, Deserialize)]
375pub struct CompleteRequest {
376    pub prompt_id: String,
377    #[serde(skip_serializing_if = "Option::is_none")]
378    pub arguments: Option<HashMap<String, String>>,
379    #[serde(skip_serializing_if = "Option::is_none")]
380    pub model_preferences: Option<ModelPreferences>,
381}
382
383/// Complete result
384#[derive(Debug, Clone, Serialize, Deserialize)]
385pub struct CompleteResult {
386    pub completion: Completion,
387}
mcp_sdk_rs/types.rs

mcp_sdk_rs/
types.rs
