Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion docs/_server/cancellation.md
Original file line number Diff line number Diff line change
Expand Up @@ -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:

Expand Down
12 changes: 12 additions & 0 deletions lib/mcp/server.rb
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down
27 changes: 27 additions & 0 deletions test/mcp/server/transports/streamable_http_transport_test.rb
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
122 changes: 122 additions & 0 deletions test/mcp/server_cancellation_test.rb
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down