diff --git a/docs/_server/cancellation.md b/docs/_server/cancellation.md index e0dff0cc..44bf3c81 100644 --- a/docs/_server/cancellation.md +++ b/docs/_server/cancellation.md @@ -68,7 +68,8 @@ end When a handler observes cancellation (either by returning early with `cancelled?` or by raising `MCP::CancelledError` via `raise_if_cancelled!`), the server drops the response and -no JSON-RPC result is sent to the client. +no JSON-RPC result is sent to the client. Any other error a handler raises once its request is cancelled +still reaches `exception_reporter`, but no JSON-RPC error is sent for it either. The same pattern works for other handler types: diff --git a/lib/mcp/server.rb b/lib/mcp/server.rb index 1da6e8fc..5ecd512e 100644 --- a/lib/mcp/server.rb +++ b/lib/mcp/server.rb @@ -924,17 +924,23 @@ def handle_request(request, method, session: nil, related_request_id: nil, auth_ # HTTP-level 403 challenges remain the transport `required_scopes` gate's job. report_exception(e, { request: request }) instrumentation_data.merge!(error: :insufficient_scope) + next cancelled_response(cancellation, instrumentation_data) if cancellation&.cancelled? + converted = RequestHandlerError.new(e.message, request, error_type: :invalid_request, original_error: e) reported_exception = converted raise converted rescue RequestHandlerError => e report_exception(e.original_error || e, { request: request }) instrumentation_data.merge!(error: e.error_type) + next cancelled_response(cancellation, instrumentation_data) if cancellation&.cancelled? + reported_exception = e raise e rescue => e report_exception(e, { request: request }) instrumentation_data.merge!(error: :internal_error) + next cancelled_response(cancellation, instrumentation_data) if cancellation&.cancelled? + wrapped = RequestHandlerError.new("Internal error handling #{method} request", request, original_error: e) reported_exception = wrapped raise wrapped @@ -2044,6 +2050,12 @@ def report_exception(exception, server_context = {}) configuration.exception_reporter.call(exception, server_context) end + # A cancelled request gets no response, so an error it raises once cancelled is reported but not answered. + def cancelled_response(cancellation, instrumentation_data) + instrumentation_data.merge!(cancelled: true, cancellation_reason: cancellation.reason) + JsonRpcHandler::NO_RESPONSE + end + def index_resources_by_uri(resources) resources.to_h { |resource| [resource.uri, resource] } end diff --git a/test/mcp/server/transports/streamable_http_transport_test.rb b/test/mcp/server/transports/streamable_http_transport_test.rb index d6df2192..eb5c1101 100644 --- a/test/mcp/server/transports/streamable_http_transport_test.rb +++ b/test/mcp/server/transports/streamable_http_transport_test.rb @@ -4054,6 +4054,33 @@ def string transport&.close end + test "a request whose session is terminated with DELETE gets no error response when it then raises" do + server = Server.new(name: "test", tools: [], prompts: [], resources: []) + transport = StreamableHTTPTransport.new(server, enable_json_response: true) + server.transport = transport + started = Queue.new + release = Queue.new + server.define_tool(name: "held_tool") do |server_context:| + started << true + release.pop + raise "connection reset while cleaning up" + end + session_id, = start_session(transport) + + call = Thread.new { transport.handle_request(held_tool_call(session_id, "call-1")) } + started.pop + transport.handle_request(create_rack_request("DELETE", "/", { "HTTP_MCP_SESSION_ID" => session_id })) + release << true + + response = call.value + assert_equal(202, response[0]) + assert_empty(response[2]) + ensure + release&.push(true) + call&.join + transport&.close + end + test "terminating a session cancels only the requests in flight in that session" do server = Server.new(name: "test", tools: [], prompts: [], resources: []) transport = StreamableHTTPTransport.new(server, enable_json_response: true) diff --git a/test/mcp/server_cancellation_test.rb b/test/mcp/server_cancellation_test.rb index 99fd8cab..675dab95 100644 --- a/test/mcp/server_cancellation_test.rb +++ b/test/mcp/server_cancellation_test.rb @@ -135,6 +135,128 @@ def handle_request(request); end assert_nil response, "CancelledError propagating from a nested call must suppress the JSON-RPC response" end + test "tool raising an ordinary error after cancellation suppresses the JSON-RPC response" do + started = Queue.new + release = Queue.new + + @server.define_tool(name: "fails_after_cancel") do |server_context:| + started << true + release.pop + raise "connection reset while cleaning up" + end + + call_thread = Thread.new do + @session.handle(jsonrpc: "2.0", id: 7, method: Methods::TOOLS_CALL, params: { name: "fails_after_cancel", arguments: {} }) + end + started.pop + + @session.handle(jsonrpc: "2.0", method: Methods::NOTIFICATIONS_CANCELLED, params: { requestId: 7, reason: "user aborted" }) + release << true + + assert_nil call_thread.value, "a cancelled request must not emit a JSON-RPC error response" + end + + test "handler raising RequestHandlerError after cancellation suppresses the JSON-RPC response" do + started = Queue.new + release = Queue.new + + @server.define_custom_method(method_name: "custom/fails_after_cancel") do |_params, server_context:| + started << true + release.pop + raise Server::RequestHandlerError.new("upstream unavailable", {}, error_type: :internal_error) + end + + call_thread = Thread.new do + @session.handle(jsonrpc: "2.0", id: 8, method: "custom/fails_after_cancel", params: {}) + end + started.pop + + @session.handle(jsonrpc: "2.0", method: Methods::NOTIFICATIONS_CANCELLED, params: { requestId: 8, reason: "user aborted" }) + release << true + + assert_nil call_thread.value, "a cancelled request must not emit a JSON-RPC error response" + end + + test "custom method raising an ordinary error after cancellation suppresses the JSON-RPC response" do + started = Queue.new + release = Queue.new + + @server.define_custom_method(method_name: "custom/raises_after_cancel") do |_params, server_context:| + started << true + release.pop + raise "connection reset while cleaning up" + end + + call_thread = Thread.new do + @session.handle(jsonrpc: "2.0", id: 12, method: "custom/raises_after_cancel", params: {}) + end + started.pop + + @session.handle(jsonrpc: "2.0", method: Methods::NOTIFICATIONS_CANCELLED, params: { requestId: 12, reason: "user aborted" }) + release << true + + assert_nil call_thread.value, "a cancelled request must not emit a JSON-RPC error response" + end + + test "tool failing require_scopes! after cancellation suppresses the JSON-RPC response" do + started = Queue.new + release = Queue.new + + @server.define_tool(name: "scoped_after_cancel") do |server_context:| + started << true + release.pop + server_context.require_scopes!("files:write") + end + + call_thread = Thread.new do + @session.handle(jsonrpc: "2.0", id: 11, method: Methods::TOOLS_CALL, params: { name: "scoped_after_cancel", arguments: {} }) + end + started.pop + + @session.handle(jsonrpc: "2.0", method: Methods::NOTIFICATIONS_CANCELLED, params: { requestId: 11, reason: "user aborted" }) + release << true + + assert_nil call_thread.value, "a cancelled request must not emit a JSON-RPC error response" + end + + test "error raised after cancellation is still reported and is recorded as cancelled" do + reported = [] + recorded_data = nil + @server.configuration.exception_reporter = ->(exception, _context) { reported << exception } + @server.configuration.instrumentation_callback = ->(data) { recorded_data = data } + started = Queue.new + release = Queue.new + + @server.define_tool(name: "fails_after_cancel") do |server_context:| + started << true + release.pop + raise "connection reset while cleaning up" + end + + call_thread = Thread.new do + @session.handle(jsonrpc: "2.0", id: 9, method: Methods::TOOLS_CALL, params: { name: "fails_after_cancel", arguments: {} }) + end + started.pop + + @session.handle(jsonrpc: "2.0", method: Methods::NOTIFICATIONS_CANCELLED, params: { requestId: 9, reason: "user aborted" }) + release << true + call_thread.value + + assert_equal ["connection reset while cleaning up"], reported.map(&:message) + assert recorded_data[:cancelled] + assert_equal "user aborted", recorded_data[:cancellation_reason] + end + + test "uncancelled tool raising an ordinary error still gets an error response" do + @server.define_tool(name: "fails") do |server_context:| + raise "boom" + end + + response = @session.handle(jsonrpc: "2.0", id: 10, method: Methods::TOOLS_CALL, params: { name: "fails", arguments: {} }) + + assert_equal JsonRpcHandler::ErrorCode::INTERNAL_ERROR, response.dig(:error, :code) + end + test "cancellation with unknown request id is silently ignored" do response = @session.handle( jsonrpc: "2.0",