Stream modern request notifications and honor the envelope logLevel per SEP-2575
## Motivation and Context The modern (stateless) lifecycle of MCP 2026-07-28 serves each request as a self-contained exchange, and two delivery requirements of that model were unimplemented: - Notifications a handler emits while serving a modern request (progress, log messages) had nowhere to go: the modern path answered with a single JSON object, and the ephemeral per-request session degraded every notification to non-delivery. The conformance requirement expects them as frames on the request's own response stream (`tools-call-with-progress` fails with "No progress notifications received" at 2026-07-28). - The envelope's `logLevel` member, which replaces the removed `logging/setLevel` RPC, was parsed but never applied: log delivery fell back to the server-wide level, violating the requirement that no `notifications/message` is sent for requests that did not set `_meta` `logLevel`. The changes wire both up: - `StreamableHTTPTransport#handle_modern` registers a per-request notification sink for its ephemeral session; `send_notification` routes into the sink ahead of the stateless guard. A request whose handler emitted notifications answers as an SSE stream carrying them ahead of the final response; a request that emitted none keeps the single JSON exchange and its HTTP status ladder. - `Server#handle_request` applies the lifted envelope's `logLevel` to the session via the existing `configure_logging`, and on modern-era sessions `ServerSession#notify_log_message` no longer falls back to the server-wide level: without a per-request `logLevel` it stays silent, on every transport. An unrecognized level reads as absent, the safe direction, matching the Python SDK's `allowed_log_levels`. The `server-stateless` scenario of the 2026-07-28 conformance requirements probes two stream-discipline rules through diagnostic fixture tools the Ruby fixture did not define, so both checks failed as not testable: `sep-2575-http-server-no-independent-requests-on-stream` calls `test_streaming_elicitation` and requires that every frame on the request's response stream is a notification or the final response, and `sep-2575-server-no-log-without-loglevel` calls `test_logging_tool` without an envelope `logLevel` and requires that no `notifications/message` reaches the stream. The fixture now defines both tools. `test_streaming_elicitation` reports progress and completes; `test_logging_tool` calls `notify_log_message` unconditionally and relies on the SDK's per-request gate, which drops the notification for modern requests that did not authorize logging through `io.modelcontextprotocol/logLevel`. Both lean on the notification streaming this change adds: with a `progressToken` or an authorizing `logLevel`, the notification is delivered as an SSE frame ahead of the final response rather than being dropped. One known limitation relative to the TypeScript and Python SDKs, which stream notifications live while the handler runs: delivery here is buffered, flushing the frames after the handler returns. Ordering is preserved and the conformance checks are satisfied, but long-running handlers get no real-time interleaving. The sink is bounded (`MAX_MODERN_REQUEST_NOTIFICATIONS`, 1000): a handler emitting notifications in proportion to client-supplied input cannot grow one request's memory without bound, and past the cap the notify helpers report `false`, the same non-delivery degradation they have on every other undeliverable path. Live streaming can follow without changing the wire shape. ## How Has This Been Tested? `bundle exec rake test` passes with zero failures and RuboCop reports no offenses. New tests cover: a modern `tools/call` streaming `notifications/progress` frames ahead of the result, the single JSON exchange staying in place without notifications, log suppression without the envelope `logLevel`, log delivery with it, the modern-era session ignoring the server-wide level while honoring a per-request one, and the notification cap bounding one request's buffered frames while the notify helpers report `false` past it. Against the conformance fixture server, the `tools-call-with-progress` progress check passes at `--spec-version 2026-07-28` (its remaining wire-schema check belongs to the separate `resultType` change), the stream-discipline checks `sep-2575-http-server-no-independent-requests-on-stream` and `sep-2575-server-no-log-without-loglevel` report SUCCESS, and manual probes confirm the positive directions the suite leaves untested: with `io.modelcontextprotocol/logLevel` in `_meta`, `test_logging_tool` streams its `notifications/message` frame ahead of the result, and with a `progressToken`, `test_streaming_elicitation` streams its `notifications/progress` frame. The `--requirements 2025-11-25` server leg passes 78/78, unchanged. ## Breaking Changes None for stable protocol versions: legacy requests and their notification delivery are unchanged. Within the modern lifecycle, notifications become deliverable where they were previously dropped, and log messages without a per-request `logLevel` stop leaking through the server-wide level, as the specification requires.
This commit is contained in:
Koichi ITO
parent
8e30f325ce
commit
da2a7f80d7
2 changed files with 286 additions and 8 deletions
|
|
@ -5418,6 +5418,168 @@ module MCP
|
|||
assert_equal({ "elicitation" => { "form" => {} } }, body.dig("error", "data", "requiredCapabilities"))
|
||||
end
|
||||
|
||||
test "modern POST streams handler notifications ahead of the final response" do
|
||||
@server.define_tool(name: "progress_tool") do |server_context:|
|
||||
server_context.report_progress(50, total: 100)
|
||||
Tool::Response.new([{ type: "text", text: "done" }])
|
||||
end
|
||||
|
||||
body = {
|
||||
jsonrpc: "2.0",
|
||||
method: "tools/call",
|
||||
id: 1,
|
||||
params: {
|
||||
name: "progress_tool",
|
||||
arguments: {},
|
||||
_meta: {
|
||||
progressToken: "tok-1",
|
||||
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
|
||||
"io.modelcontextprotocol/clientInfo": { name: "modern_client", version: "2.0" },
|
||||
"io.modelcontextprotocol/clientCapabilities": {},
|
||||
},
|
||||
},
|
||||
}.to_json
|
||||
|
||||
response = @transport.handle_request(modern_rack_request(body))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "text/event-stream", response[1]["content-type"]
|
||||
frames = response[2][0].split("\n\n").reject(&:empty?).map do |chunk|
|
||||
JSON.parse(chunk.sub(/\Aevent: message\ndata: /, ""))
|
||||
end
|
||||
assert_equal "notifications/progress", frames.first["method"]
|
||||
assert_equal "tok-1", frames.first.dig("params", "progressToken")
|
||||
assert frames.last.key?("result"), "expected the final frame to carry the result"
|
||||
assert_equal 1, frames.last["id"]
|
||||
end
|
||||
|
||||
test "modern POST bounds the buffered notifications per request" do
|
||||
# The sink holds notifications in memory until the handler returns, so a handler
|
||||
# emitting in proportion to client input must not grow one request without bound.
|
||||
overflow = 5
|
||||
delivery_results = []
|
||||
@server.define_tool(name: "flood_tool") do |server_context:|
|
||||
(StreamableHTTPTransport::MAX_MODERN_REQUEST_NOTIFICATIONS + overflow).times do |i|
|
||||
delivery_results << server_context.notify_log_message(data: "message #{i}", level: "info")
|
||||
end
|
||||
Tool::Response.new([{ type: "text", text: "done" }])
|
||||
end
|
||||
|
||||
body = {
|
||||
jsonrpc: "2.0",
|
||||
method: "tools/call",
|
||||
id: 1,
|
||||
params: {
|
||||
name: "flood_tool",
|
||||
arguments: {},
|
||||
_meta: {
|
||||
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
|
||||
"io.modelcontextprotocol/clientInfo": { name: "modern_client", version: "2.0" },
|
||||
"io.modelcontextprotocol/clientCapabilities": {},
|
||||
"io.modelcontextprotocol/logLevel": "info",
|
||||
},
|
||||
},
|
||||
}.to_json
|
||||
|
||||
response = @transport.handle_request(modern_rack_request(body))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "text/event-stream", response[1]["content-type"]
|
||||
frames = response[2][0].split("\n\n").reject(&:empty?)
|
||||
assert_equal StreamableHTTPTransport::MAX_MODERN_REQUEST_NOTIFICATIONS + 1, frames.size
|
||||
assert_equal overflow, delivery_results.count { |result| result == false }
|
||||
end
|
||||
|
||||
test "modern POST without handler notifications keeps the single JSON exchange" do
|
||||
response = @transport.handle_request(modern_rack_request(modern_body("tools/list", {})))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "application/json", response[1]["content-type"]
|
||||
end
|
||||
|
||||
test "modern POST suppresses log notifications without the envelope logLevel" do
|
||||
# SEP-2575: log delivery is authorized per request via the `_meta` logLevel;
|
||||
# the server-wide level does not apply to modern requests.
|
||||
@server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "debug")
|
||||
@server.define_tool(name: "logging_tool") do |server_context:|
|
||||
server_context.notify_log_message(data: "hi", level: "info")
|
||||
Tool::Response.new([{ type: "text", text: "done" }])
|
||||
end
|
||||
|
||||
response = @transport.handle_request(modern_rack_request(
|
||||
modern_body("tools/call", { name: "logging_tool", arguments: {} }),
|
||||
))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "application/json", response[1]["content-type"]
|
||||
refute_includes response[2][0], "notifications/message"
|
||||
end
|
||||
|
||||
test "modern POST delivers log notifications when the envelope carries logLevel" do
|
||||
@server.define_tool(name: "logging_tool") do |server_context:|
|
||||
server_context.notify_log_message(data: "hi", level: "info")
|
||||
Tool::Response.new([{ type: "text", text: "done" }])
|
||||
end
|
||||
|
||||
body = {
|
||||
jsonrpc: "2.0",
|
||||
method: "tools/call",
|
||||
id: 1,
|
||||
params: {
|
||||
name: "logging_tool",
|
||||
arguments: {},
|
||||
_meta: {
|
||||
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
|
||||
"io.modelcontextprotocol/clientInfo": { name: "modern_client", version: "2.0" },
|
||||
"io.modelcontextprotocol/clientCapabilities": {},
|
||||
"io.modelcontextprotocol/logLevel": "info",
|
||||
},
|
||||
},
|
||||
}.to_json
|
||||
|
||||
response = @transport.handle_request(modern_rack_request(body))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "text/event-stream", response[1]["content-type"]
|
||||
assert_includes response[2][0], "notifications/message"
|
||||
end
|
||||
|
||||
test "modern POST treats an unrecognized envelope logLevel as absent" do
|
||||
# Matching the Python SDK, an unrecognized level reads as absent:
|
||||
# delivery stays off instead of erroring on every log call.
|
||||
reported = []
|
||||
configuration = MCP::Configuration.new(exception_reporter: ->(e, _ctx) { reported << e })
|
||||
server = Server.new(name: "log_level_test", configuration: configuration)
|
||||
transport = StreamableHTTPTransport.new(server, dns_rebinding_protection: false)
|
||||
server.define_tool(name: "logging_tool") do |server_context:|
|
||||
server_context.notify_log_message(data: "hi", level: "info")
|
||||
Tool::Response.new([{ type: "text", text: "done" }])
|
||||
end
|
||||
|
||||
body = {
|
||||
jsonrpc: "2.0",
|
||||
method: "tools/call",
|
||||
id: 1,
|
||||
params: {
|
||||
name: "logging_tool",
|
||||
arguments: {},
|
||||
_meta: {
|
||||
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
|
||||
"io.modelcontextprotocol/clientInfo": { name: "modern_client", version: "2.0" },
|
||||
"io.modelcontextprotocol/clientCapabilities": {},
|
||||
"io.modelcontextprotocol/logLevel": "bogus",
|
||||
},
|
||||
},
|
||||
}.to_json
|
||||
|
||||
response = transport.handle_request(modern_rack_request(body))
|
||||
|
||||
assert_equal 200, response[0]
|
||||
assert_equal "application/json", response[1]["content-type"]
|
||||
refute_includes response[2][0], "notifications/message"
|
||||
assert_empty reported
|
||||
end
|
||||
|
||||
test "modern POST serves server/discover without an envelope" do
|
||||
response = @transport.handle_request(modern_rack_request(
|
||||
{ jsonrpc: "2.0", method: "server/discover", id: 1 }.to_json,
|
||||
|
|
|
|||
|
|
@ -170,6 +170,31 @@ module MCP
|
|||
assert_empty mock_transport.notifications
|
||||
end
|
||||
|
||||
test "ServerSession#notify_log_message on a modern-era session ignores the server-wide level" do
|
||||
# SEP-2575: on the modern lifecycle, log delivery is authorized per request via
|
||||
# the envelope's logLevel; the server-wide level MUST NOT apply.
|
||||
server = Server.new(name: "test_server", version: "1.0.0")
|
||||
mock_transport = MockTransport.new(server)
|
||||
server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "debug")
|
||||
session = ServerSession.new(server: server, transport: mock_transport, era: :modern)
|
||||
|
||||
session.notify_log_message(data: { message: "test" }, level: "error")
|
||||
|
||||
assert_empty mock_transport.notifications
|
||||
end
|
||||
|
||||
test "ServerSession#notify_log_message on a modern-era session honors a per-request level" do
|
||||
server = Server.new(name: "test_server", version: "1.0.0")
|
||||
mock_transport = MockTransport.new(server)
|
||||
session = ServerSession.new(server: server, transport: mock_transport, era: :modern)
|
||||
session.configure_logging(MCP::LoggingMessageNotification.new(level: "info"))
|
||||
|
||||
session.notify_log_message(data: { message: "test" }, level: "error")
|
||||
|
||||
assert_equal 1, mock_transport.notifications.length
|
||||
assert_equal Methods::NOTIFICATIONS_MESSAGE, mock_transport.notifications.first[:method]
|
||||
end
|
||||
|
||||
test "#notify_log_message sends notification with logger through transport" do
|
||||
@server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "error")
|
||||
@server.notify_log_message(data: { error: "Connection Failed" }, level: "error", logger: "DatabaseLogger")
|
||||
|
|
|
|||
Loading…
Reference in a new issue