feat(task): route server-originated tasks/* to ClientHandler (SEP-1686)

crates/rmcp-macros/src/task_handler.rs

@@ -223,38 +223,24 @@ pub fn task_handler(attr: TokenStream, input: TokenStream) -> syn::Result<TokenS
             .push(syn::parse2::<ImplItem>(get_result_fn)?);
     }
 
-    if !has_method("cancel_task", &item_impl) {
-        let cancel_fn = quote! {
-            async fn cancel_task(
+    if !has_method("delete_task", &item_impl) {
+        let delete_fn = quote! {
+            async fn delete_task(
                 &self,
-                request: rmcp::model::CancelTaskParams,
+                request: rmcp::model::DeleteTaskParams,
                 _context: rmcp::service::RequestContext<rmcp::RoleServer>,
-            ) -> Result<rmcp::model::CancelTaskResult, McpError> {
-                use rmcp::task_manager::current_timestamp;
+            ) -> Result<rmcp::model::DeleteTaskResult, McpError> {
                 let task_id = request.task_id;
                 let mut processor = (#processor).lock().await;
 
-                if processor.cancel_task(&task_id) {
-                    let timestamp = current_timestamp();
-                    let task = rmcp::model::Task::new(
-                        task_id,
-                        rmcp::model::TaskStatus::Cancelled,
-                        timestamp.clone(),
-                        timestamp,
-                    );
-                    return Ok(rmcp::model::CancelTaskResult { meta: None, task });
-                }
-
-                // If already completed, signal it's not cancellable
-                let exists_completed = processor.peek_completed().iter().any(|r| r.descriptor.operation_id == task_id);
-                if exists_completed {
-                    return Err(McpError::invalid_request(format!("task already completed: {}", task_id), None));
+                if processor.delete_task(&task_id) {
+                    return Ok(rmcp::model::DeleteTaskResult { meta: None });
                 }
 
                 Err(McpError::resource_not_found(format!("task not found: {}", task_id), None))
             }
         };
-        item_impl.items.push(syn::parse2::<ImplItem>(cancel_fn)?);
+        item_impl.items.push(syn::parse2::<ImplItem>(delete_fn)?);
     }
 
     // Auto-generate get_info() if not already provided and no sibling tool/prompt handler

crates/rmcp/Cargo.toml

@@ -283,6 +283,11 @@ name = "test_custom_request"
 required-features = ["server", "client"]
 path = "tests/test_custom_request.rs"
 
+[[test]]
+name = "test_task_client_receiver"
+required-features = ["server", "client"]
+path = "tests/test_task_client_receiver.rs"
+
 [[test]]
 name = "test_prompt_macros"
 required-features = ["server", "client"]

crates/rmcp/src/handler/client.rs

@@ -30,6 +30,22 @@ impl<H: ClientHandler> Service<RoleClient> for H {
                 .create_elicitation(request.params, context)
                 .await
                 .map(ClientResult::CreateElicitationResult),
+            ServerRequest::ListTasksRequest(request) => self
+                .list_tasks(request.params, context)
+                .await
+                .map(ClientResult::ListTasksResult),
+            ServerRequest::GetTaskInfoRequest(request) => self
+                .get_task_info(request.params, context)
+                .await
+                .map(ClientResult::GetTaskResult),
+            ServerRequest::GetTaskResultRequest(request) => self
+                .get_task_result(request.params, context)
+                .await
+                .map(ClientResult::GetTaskPayloadResult),
+            ServerRequest::DeleteTaskRequest(request) => self
+                .delete_task(request.params, context)
+                .await
+                .map(ClientResult::DeleteTaskResult),
             ServerRequest::CustomRequest(request) => self
                 .on_custom_request(request, context)
                 .await
@@ -191,6 +207,68 @@ pub trait ClientHandler: Sized + Send + Sync + 'static {
         )))
     }
 
+    /// Handle a `tasks/list` request from a server. Only relevant when the
+    /// client is also a task *receiver* (e.g. it accepted a task-augmented
+    /// `sampling/createMessage` or `elicitation/create` request).
+    ///
+    /// # Default Behavior
+    /// Returns `-32601` (Method not found). Clients that advertise
+    /// `capabilities.tasks.list` must override this.
+    fn list_tasks(
+        &self,
+        request: Option<PaginatedRequestParams>,
+        context: RequestContext<RoleClient>,
+    ) -> impl Future<Output = Result<ListTasksResult, McpError>> + MaybeSendFuture + '_ {
+        let _ = (request, context);
+        std::future::ready(Err(McpError::method_not_found::<ListTasksMethod>()))
+    }
+
+    /// Handle a `tasks/get` request from a server. Only relevant when the
+    /// client is also a task *receiver* (e.g. it accepted a task-augmented
+    /// `sampling/createMessage` or `elicitation/create` request).
+    ///
+    /// # Default Behavior
+    /// Returns `-32601` (Method not found). Clients that advertise
+    /// `capabilities.tasks.requests.sampling.createMessage` or
+    /// `capabilities.tasks.requests.elicitation.create` must override this.
+    fn get_task_info(
+        &self,
+        request: GetTaskInfoParams,
+        context: RequestContext<RoleClient>,
+    ) -> impl Future<Output = Result<GetTaskResult, McpError>> + MaybeSendFuture + '_ {
+        let _ = (request, context);
+        std::future::ready(Err(McpError::method_not_found::<GetTaskInfoMethod>()))
+    }
+
+    /// Handle a `tasks/result` request from a server. Only relevant when
+    /// the client is also a task *receiver*.
+    ///
+    /// # Default Behavior
+    /// Returns `-32601` (Method not found).
+    fn get_task_result(
+        &self,
+        request: GetTaskResultParams,
+        context: RequestContext<RoleClient>,
+    ) -> impl Future<Output = Result<GetTaskPayloadResult, McpError>> + MaybeSendFuture + '_ {
+        let _ = (request, context);
+        std::future::ready(Err(McpError::method_not_found::<GetTaskResultMethod>()))
+    }
+
+    /// Handle a `tasks/delete` request from a server (SEP-1686 §3.6).
+    /// Only relevant when the client is also a task *receiver*.
+    ///
+    /// # Default Behavior
+    /// Returns `-32601` (Method not found). Task receivers must override this
+    /// to delete the task and any associated stored result.
+    fn delete_task(
+        &self,
+        request: DeleteTaskParams,
+        context: RequestContext<RoleClient>,
+    ) -> impl Future<Output = Result<DeleteTaskResult, McpError>> + MaybeSendFuture + '_ {
+        let _ = (request, context);
+        std::future::ready(Err(McpError::method_not_found::<DeleteTaskMethod>()))
+    }
+
     fn on_cancelled(
         &self,
         params: CancelledNotificationParam,
@@ -310,6 +388,38 @@ macro_rules! impl_client_handler_for_wrapper {
                 (**self).on_custom_request(request, context)
             }
 
+            fn list_tasks(
+                &self,
+                request: Option<PaginatedRequestParams>,
+                context: RequestContext<RoleClient>,
+            ) -> impl Future<Output = Result<ListTasksResult, McpError>> + MaybeSendFuture + '_ {
+                (**self).list_tasks(request, context)
+            }
+
+            fn get_task_info(
+                &self,
+                request: GetTaskInfoParams,
+                context: RequestContext<RoleClient>,
+            ) -> impl Future<Output = Result<GetTaskResult, McpError>> + MaybeSendFuture + '_ {
+                (**self).get_task_info(request, context)
+            }
+
+            fn get_task_result(
+                &self,
+                request: GetTaskResultParams,
+                context: RequestContext<RoleClient>,
+            ) -> impl Future<Output = Result<GetTaskPayloadResult, McpError>> + MaybeSendFuture + '_ {
+                (**self).get_task_result(request, context)
+            }
+
+            fn delete_task(
+                &self,
+                request: DeleteTaskParams,
+                context: RequestContext<RoleClient>,
+            ) -> impl Future<Output = Result<DeleteTaskResult, McpError>> + MaybeSendFuture + '_ {
+                (**self).delete_task(request, context)
+            }
+
             fn on_cancelled(
                 &self,
                 params: CancelledNotificationParam,

crates/rmcp/src/handler/server.rs

@@ -123,10 +123,10 @@ impl<H: ServerHandler> Service<RoleServer> for H {
                 .get_task_result(request.params, context)
                 .await
                 .map(ServerResult::GetTaskPayloadResult),
-            ClientRequest::CancelTaskRequest(request) => self
-                .cancel_task(request.params, context)
+            ClientRequest::DeleteTaskRequest(request) => self
+                .delete_task(request.params, context)
                 .await
-                .map(ServerResult::CancelTaskResult),
+                .map(ServerResult::DeleteTaskResult),
         }
     }
 
@@ -359,13 +359,13 @@ macro_rules! server_handler_methods {
             std::future::ready(Err(McpError::method_not_found::<GetTaskResultMethod>()))
         }
 
-        fn cancel_task(
+        fn delete_task(
             &self,
-            request: CancelTaskParams,
+            request: DeleteTaskParams,
             context: RequestContext<RoleServer>,
-        ) -> impl Future<Output = Result<CancelTaskResult, McpError>> + MaybeSendFuture + '_ {
+        ) -> impl Future<Output = Result<DeleteTaskResult, McpError>> + MaybeSendFuture + '_ {
             let _ = (request, context);
-            std::future::ready(Err(McpError::method_not_found::<CancelTaskMethod>()))
+            std::future::ready(Err(McpError::method_not_found::<DeleteTaskMethod>()))
         }
     };
 }
@@ -575,12 +575,12 @@ macro_rules! impl_server_handler_for_wrapper {
                 (**self).get_task_result(request, context)
             }
 
-            fn cancel_task(
+            fn delete_task(
                 &self,
-                request: CancelTaskParams,
+                request: DeleteTaskParams,
                 context: RequestContext<RoleServer>,
-            ) -> impl Future<Output = Result<CancelTaskResult, McpError>> + MaybeSendFuture + '_ {
-                (**self).cancel_task(request, context)
+            ) -> impl Future<Output = Result<DeleteTaskResult, McpError>> + MaybeSendFuture + '_ {
+                (**self).delete_task(request, context)
             }
         }
     };

crates/rmcp/src/model.rs

@@ -3155,32 +3155,28 @@ impl RequestParamsMeta for GetTaskResultParams {
 #[deprecated(since = "0.13.0", note = "Use GetTaskResultParams instead")]
 pub type GetTaskResultParam = GetTaskResultParams;
 
-const_string!(CancelTaskMethod = "tasks/cancel");
-pub type CancelTaskRequest = Request<CancelTaskMethod, CancelTaskParams>;
+const_string!(DeleteTaskMethod = "tasks/delete");
+pub type DeleteTaskRequest = Request<DeleteTaskMethod, DeleteTaskParams>;
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[expect(clippy::exhaustive_structs, reason = "intentionally exhaustive")]
-pub struct CancelTaskParams {
+pub struct DeleteTaskParams {
     /// Protocol-level metadata for this request (SEP-1319)
     #[serde(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
     pub meta: Option<Meta>,
     pub task_id: String,
 }
 
-impl RequestParamsMeta for CancelTaskParams {
+impl RequestParamsMeta for DeleteTaskParams {
     fn meta(&self) -> Option<&Meta> {
         self.meta.as_ref()
     }
     fn meta_mut(&mut self) -> &mut Option<Meta> {
         &mut self.meta
     }
 }
-
-/// Deprecated: Use [`CancelTaskParams`] instead (SEP-1319 compliance).
-#[deprecated(since = "0.13.0", note = "Use CancelTaskParams instead")]
-pub type CancelTaskParam = CancelTaskParams;
 /// Deprecated: Use [`GetTaskResult`] instead (spec alignment).
 #[deprecated(since = "0.15.0", note = "Use GetTaskResult instead")]
 pub type GetTaskInfoResult = GetTaskResult;
@@ -3280,7 +3276,7 @@ ts_union!(
     | GetTaskInfoRequest
     | ListTasksRequest
     | GetTaskResultRequest
-    | CancelTaskRequest
+    | DeleteTaskRequest
     | CustomRequest;
 );
 
@@ -3303,7 +3299,7 @@ impl ClientRequest {
             ClientRequest::GetTaskInfoRequest(r) => r.method.as_str(),
             ClientRequest::ListTasksRequest(r) => r.method.as_str(),
             ClientRequest::GetTaskResultRequest(r) => r.method.as_str(),
-            ClientRequest::CancelTaskRequest(r) => r.method.as_str(),
+            ClientRequest::DeleteTaskRequest(r) => r.method.as_str(),
             ClientRequest::CustomRequest(r) => r.method.as_str(),
         }
     }
@@ -3323,6 +3319,10 @@ ts_union!(
     box CreateMessageResult
     | ListRootsResult
     | CreateElicitationResult
+    | ListTasksResult
+    | GetTaskResult
+    | GetTaskPayloadResult
+    | DeleteTaskResult
     | EmptyResult
     | CustomResult;
 );
@@ -3341,9 +3341,29 @@ ts_union!(
     | CreateMessageRequest
     | ListRootsRequest
     | CreateElicitationRequest
+    | GetTaskInfoRequest
+    | ListTasksRequest
+    | GetTaskResultRequest
+    | DeleteTaskRequest
     | CustomRequest;
 );
 
+impl ServerRequest {
+    pub fn method(&self) -> &str {
+        match &self {
+            ServerRequest::PingRequest(r) => r.method.as_str(),
+            ServerRequest::CreateMessageRequest(r) => r.method.as_str(),
+            ServerRequest::ListRootsRequest(r) => r.method.as_str(),
+            ServerRequest::CreateElicitationRequest(r) => r.method.as_str(),
+            ServerRequest::GetTaskInfoRequest(r) => r.method.as_str(),
+            ServerRequest::ListTasksRequest(r) => r.method.as_str(),
+            ServerRequest::GetTaskResultRequest(r) => r.method.as_str(),
+            ServerRequest::DeleteTaskRequest(r) => r.method.as_str(),
+            ServerRequest::CustomRequest(r) => r.method.as_str(),
+        }
+    }
+}
+
 ts_union!(
     export type ServerNotification =
     | CancelledNotification
@@ -3371,7 +3391,7 @@ ts_union!(
     | CreateTaskResult
     | ListTasksResult
     | GetTaskResult
-    | CancelTaskResult
+    | DeleteTaskResult
     | CallToolResult
     | GetTaskPayloadResult
     | EmptyResult

crates/rmcp/src/model/meta.rs

@@ -155,7 +155,7 @@ variant_extension! {
         GetTaskInfoRequest
         ListTasksRequest
         GetTaskResultRequest
-        CancelTaskRequest
+        DeleteTaskRequest
     }
 }
 
@@ -166,6 +166,10 @@ variant_extension! {
         ListRootsRequest
         CreateElicitationRequest
         CustomRequest
+        GetTaskInfoRequest
+        ListTasksRequest
+        GetTaskResultRequest
+        DeleteTaskRequest
     }
 }