tmcp 0.4.0

Complete, ergonomic implementation of the Model Context Protocol (MCP)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use serde::{Deserialize, Serialize};

use super::{NotificationParams, PaginatedResult, Result};
use crate::macros::with_meta;

/// The status of a task.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TaskStatus {
    Working,
    InputRequired,
    Completed,
    Failed,
    Cancelled,
}

/// Metadata for augmenting a request with task execution.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct TaskMetadata {
    /// Requested duration in milliseconds to retain task from creation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ttl: Option<u64>,
}

/// Metadata for associating messages with a task.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RelatedTaskMetadata {
    /// The task identifier this message is associated with.
    #[serde(rename = "taskId")]
    pub task_id: String,
}

/// Data associated with a task.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Task {
    /// The task identifier.
    #[serde(rename = "taskId")]
    pub task_id: String,
    /// Current task state.
    pub status: TaskStatus,
    /// Optional human-readable message describing the current task state.
    #[serde(rename = "statusMessage", skip_serializing_if = "Option::is_none")]
    pub status_message: Option<String>,
    /// ISO 8601 timestamp when the task was created.
    #[serde(rename = "createdAt")]
    pub created_at: String,
    /// ISO 8601 timestamp when the task was last updated.
    #[serde(rename = "lastUpdatedAt")]
    pub last_updated_at: String,
    /// Actual retention duration from creation in milliseconds, null for unlimited.
    pub ttl: Option<u64>,
    /// Suggested polling interval in milliseconds.
    #[serde(rename = "pollInterval", skip_serializing_if = "Option::is_none")]
    pub poll_interval: Option<u64>,
}

/// A response to a task-augmented request.
#[with_meta]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateTaskResult {
    pub task: Task,
}

/// Parameters for tasks/get, tasks/result, and tasks/cancel requests.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskIdParams {
    /// The task identifier to query.
    #[serde(rename = "taskId")]
    pub task_id: String,
}

/// Parameters for a tasks/get request.
pub type GetTaskRequestParams = TaskIdParams;

/// Parameters for a tasks/result request.
pub type GetTaskPayloadRequestParams = TaskIdParams;

/// Parameters for a tasks/cancel request.
pub type CancelTaskRequestParams = TaskIdParams;

/// The response to a tasks/get request.
#[with_meta]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GetTaskResult {
    #[serde(flatten)]
    pub task: Task,
}

/// The response to a tasks/result request.
pub type GetTaskPayloadResult = Result;

/// The response to a tasks/cancel request.
#[with_meta]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CancelTaskResult {
    #[serde(flatten)]
    pub task: Task,
}

/// The response to a tasks/list request.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ListTasksResult {
    #[serde(flatten)]
    pub page: PaginatedResult,
    pub tasks: Vec<Task>,
}

impl ListTasksResult {
    /// Create an empty task list.
    pub fn new() -> Self {
        Self {
            page: PaginatedResult {
                next_cursor: None,
                _meta: None,
            },
            tasks: Vec::new(),
        }
    }

    /// Add a task to the result list.
    pub fn with_task(mut self, task: Task) -> Self {
        self.tasks.push(task);
        self
    }

    /// Add multiple tasks to the result list.
    pub fn with_tasks(mut self, tasks: impl IntoIterator<Item = Task>) -> Self {
        self.tasks.extend(tasks);
        self
    }

    /// Set the pagination cursor for the next page.
    pub fn with_cursor(mut self, cursor: impl Into<super::Cursor>) -> Self {
        self.page.next_cursor = Some(cursor.into());
        self
    }
}

impl Default for ListTasksResult {
    fn default() -> Self {
        Self::new()
    }
}

/// Parameters for a `notifications/tasks/status` notification.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskStatusNotificationParams {
    #[serde(flatten)]
    pub notification: NotificationParams,
    #[serde(flatten)]
    pub task: Task,
}