Stop negotiating modern protocol versions through the initialize handshake
## Motivation and Context Follow-up to https://github.com/modelcontextprotocol/ruby-sdk/issues/512#issuecomment-5285679761 A comment on #512 reported that results stay unstamped when a client negotiates `2026-07-28` through the legacy `initialize` handshake: the SEP-2322 `resultType` stamp and the SEP-2549 cache hints are both gated on the per-request `_meta` envelope, which such a connection never carries, so strictly validating clients reject every result as missing the REQUIRED `resultType`. The root cause sits upstream of the stamp. Per the SEP-2575 era model, an era is a property of the protocol version itself: legacy versions establish a session via `initialize` (`2025-11-25` and earlier), and modern versions carry their version on every request in `_meta` with no handshake at all - the 2026-07-28 schema defines no `initialize`, and a request without the envelope is malformed. The negotiation list of this server still contained `2026-07-28`, producing a hybrid state the spec does not define and the reference SDKs refuse to construct: the TypeScript server negotiates from `SUPPORTED_PROTOCOL_VERSIONS`, which stops at `2025-11-25`, and counter-offers its first entry; the Python server negotiates from `HANDSHAKE_PROTOCOL_VERSIONS`, which stops there too, and counter-offers `LATEST_HANDSHAKE_VERSION`. `initialize` now negotiates from a new `SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS` list (`2025-11-25` and earlier): a request for `2026-07-28`, or for a version this server does not know, is counter-offered `2025-11-25`, exactly as both reference SDKs answer. A counter-offered client proceeds on `2025-11-25`, where `resultType` does not exist and its absence is the correct shape, resolving the reported rejection. `2026-07-28` stays reachable through `server/discover` and the per-request envelope, where the stamps already apply. The `envelope &&` stamp gates are intentionally unchanged: with the handshake capped, an envelope-less `2026-07-28` connection is no longer constructible, so the gates are correct by construction. The client side is symmetrized the same way, matching both reference SDKs: the legacy handshake offers `LATEST_HANDSHAKE_PROTOCOL_VERSION` by default, passing an explicitly modern `protocol_version` to the legacy connect raises `ArgumentError` (validated before the stdio transport spawns its child process), and a server answering `initialize` with a modern version is rejected like an unknown one. `:auto` forwards an explicitly modern version to the discovery probe and never downgrades it into the legacy fallback: the probe's failure is the real answer and propagates, instead of the fallback dying on the handshake guard. The handshake rule itself lives in one place (`Configuration.reject_modern_handshake_version!`), and the handshake list is derived from the stable and modern lists so the era partition cannot drift when the next revision lands. Two consequences are worth naming. The roots/sampling deprecation warnings move to the modern connect on the client, the revision where SEP-2577 actually deprecates them, since the handshake can no longer land on a deprecating version and the call site the warnings used to sit on had become unreachable. On the server the answer is removal: `Configuration#protocol_version` scopes the handshake, so it now accepts handshake versions only and rejects a modern pin with `ArgumentError` at construction. Accepting one would configure nothing (a modern version has no handshake to pin), and neither reference SDK carries a config value that is accepted but inert: Python's negotiation has no knob at all, and every entry of the TypeScript server's `supportedProtocolVersions` is consumed by its own era's mechanism. With no path left onto a deprecating revision, the server-side deprecation warning plumbing became unreachable and is removed along with it. Keying those warnings on a modern-era session instead was tried and rejected, because `notify_log_message` is the SEP-2575 sanctioned delivery path on that wire and every log line would then carry a deprecation warning for doing exactly what the revision prescribes (a single test file produced over a thousand of them). A session-bound request may still stamp `MCP-Protocol-Version: 2026-07-28` after being counter-offered, and such a request continues to be served at the negotiated revision rather than rejected. Sending the negotiated version is a SHOULD on the client, and the spec's `400 Bad Request` rule covers a version the server does not support, which is not the case here: this server does serve `2026-07-28`, through the other lifecycle. The session it is bound to decides, and a test now pins that reading along with its consequence, which is that no `resultType` appears on those results. Two details follow from the pin being handshake-scoped. Reading it back when nothing is set now answers `LATEST_HANDSHAKE_PROTOCOL_VERSION` rather than the newest version of any era, so the getter no longer hands out a value its own writer rejects and round-tripping the setting keeps working; only `Server#validate!` reads that default, through three comparisons that answer the same for either value, so nothing else moves. And the rejection names its reason instead of listing the accepted versions, because this is the error an upgrade from a release that accepted the value lands on, which makes it the migration note a bare list would not be. `MCP::ProtocolDeprecations` says in its own documentation that only the client emits these warnings now, and that `LOGGING_MESSAGE` has no caller left. It stays public and callable: removing it would be a breaking change for no gain. The handshake examples in `docs/building-clients.md` and the shared `initialize_params` test helper now use the handshake version as well, and the README section on `protocol_version` describes the pin as handshake-scoped: handshake versions only, `ArgumentError` for a modern one, the handshake version as the default, and `2026-07-28` reached through `server/discover` with no configuration needed. ## How Has This Been Tested? New regression tests pin the reported scenario end to end: an `initialize` requesting `2026-07-28` is counter-offered `2025-11-25`, locks the legacy era, and subsequent results carry no `resultType` (the correct shape at that revision). Client-side tests cover the default `2025-11-25` offer, the `ArgumentError` for an explicitly modern version on the legacy connect (asserting no child process is spawned on the stdio transport), the rejection of a modern `InitializeResult` on both transports, the `:auto` probe failure propagating for an explicitly modern version instead of falling back, and the deprecation warning firing on modern connects declaring roots/sampling capabilities. Counter-offer adoption gets its own test on both transports, since the server-side fix only resolves anything for clients that honor a counter-offer, and this client is one of them: the offer is the latest handshake version, the answer is an older one, and the connection speaks the answer afterwards (over HTTP the next request's `MCP-Protocol-Version` header carries it). The existing tests could not tell adoption from an echo, because every one of them had the server answer with the version the client had just offered. Both new tests were confirmed to fail when the client is made to report its own offer instead. Tests that pinned the previous dual-lifecycle negotiation were inverted or reworked: the server tests asserting `2026-07-28` echoes and fallbacks now assert the counter-offer, and the deprecation warning tests keyed on a legacy-negotiated `2026-07-28` now assert no warning fires. The server-side deprecation tests that reached their state by calling `mark_initialized!` with a modern version, or by pinning one in `Configuration`, were replaced by tests asserting no warning fires on those paths, since no code path can produce the warning state any more; `Configuration` rejecting a modern pin has its own tests on the constructor and the setter, asserting the reason in the message rather than the list of accepted values. The default-pin test now also round-trips what it reads back into a fresh `Configuration`, which is what the old default could not do. The default move was checked for neutrality outside the suite as well, by building a server that uses every feature `Server#validate!` gates on that value (`description`, `title`, `website_url`, `instructions`, a `$ref` input schema, and tool annotations) and confirming all of them are still accepted. ## Breaking Changes Servers no longer echo `2026-07-28` from `initialize`: clients that negotiated it through the handshake are counter-offered `2025-11-25` and are served at that revision, matching the TypeScript and Python servers. `Configuration.new(protocol_version: "2026-07-28")` now raises `ArgumentError` (the pin scopes the handshake, which cannot land there); the value was only accepted since v1.1.0, whose handshake behavior this change replaces anyway. Reading `Configuration#protocol_version` with no pin set answers `2025-11-25` instead of `2026-07-28`; nothing in this SDK behaves differently for either value, but code comparing that reader against a literal will see the change. The client no longer offers modern versions on the legacy handshake and rejects a modern `InitializeResult`. Server-side deprecation warnings for SEP-2577 features no longer fire at all, because no negotiation or configuration path can put a connection on a deprecating revision; the client-side warning on a modern connect replaces them.
This commit is contained in:
Koichi ITO
parent
67779a2e88
commit
48b7aaacd9
7 changed files with 472 additions and 207 deletions
|
|
@ -327,8 +327,9 @@ module MCP
|
|||
#
|
||||
# @param client_info [Hash, nil] `{ name:, version: }` identifying the client.
|
||||
# Defaults to `{ name: "mcp-ruby-client", version: MCP::VERSION }`.
|
||||
# @param protocol_version [String, nil] Protocol version to offer. Defaults
|
||||
# to `MCP::Configuration::LATEST_STABLE_PROTOCOL_VERSION`.
|
||||
# @param protocol_version [String, nil] Protocol version to offer on the legacy handshake.
|
||||
# Defaults to `MCP::Configuration::LATEST_HANDSHAKE_PROTOCOL_VERSION`; a modern version
|
||||
# raises `ArgumentError` here (modern versions are selected via `mode: :modern`/`:auto`).
|
||||
# @param capabilities [Hash] Capabilities advertised by the client. Defaults to `{}`.
|
||||
# @return [Hash] The server's `InitializeResult`.
|
||||
# @raise [RequestHandlerError] If the server responds with a JSON-RPC error
|
||||
|
|
@ -341,6 +342,9 @@ module MCP
|
|||
def connect(client_info: nil, protocol_version: nil, capabilities: {}, mode: :legacy)
|
||||
return @server_info if connected?
|
||||
|
||||
# Per the SEP-2575 era model, a modern version cannot ride the legacy `initialize` handshake.
|
||||
MCP::Configuration.reject_modern_handshake_version!(protocol_version) if mode == :legacy
|
||||
|
||||
client_info ||= { name: "mcp-ruby-client", version: MCP::VERSION }
|
||||
|
||||
case mode
|
||||
|
|
@ -559,7 +563,7 @@ module MCP
|
|||
attr_reader :headers
|
||||
|
||||
def connect_legacy(client_info:, protocol_version:, capabilities:)
|
||||
protocol_version ||= MCP::Configuration::LATEST_STABLE_PROTOCOL_VERSION
|
||||
protocol_version ||= MCP::Configuration::LATEST_HANDSHAKE_PROTOCOL_VERSION
|
||||
|
||||
response = send_request(request: {
|
||||
jsonrpc: JsonRpcHandler::Version::V2_0,
|
||||
|
|
@ -593,7 +597,10 @@ module MCP
|
|||
|
||||
@server_info = response["result"]
|
||||
negotiated_protocol_version = @server_info["protocolVersion"]
|
||||
unless MCP::Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(negotiated_protocol_version)
|
||||
# A modern version in an `InitializeResult` is rejected along with unknown ones: the handshake
|
||||
# settles on a legacy version by definition, and the TypeScript and Python clients refuse
|
||||
# a modern counter-offer the same way.
|
||||
unless MCP::Configuration::SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS.include?(negotiated_protocol_version)
|
||||
clear_session
|
||||
raise RequestHandlerError.new(
|
||||
"Server initialization failed: unsupported protocol version #{negotiated_protocol_version.inspect}",
|
||||
|
|
@ -602,8 +609,6 @@ module MCP
|
|||
)
|
||||
end
|
||||
|
||||
MCP::ProtocolDeprecations.warn_for_client_capabilities(capabilities, protocol_version: negotiated_protocol_version, uplevel: 1)
|
||||
|
||||
begin
|
||||
send_request(request: {
|
||||
jsonrpc: JsonRpcHandler::Version::V2_0,
|
||||
|
|
@ -647,6 +652,10 @@ module MCP
|
|||
)
|
||||
end
|
||||
|
||||
# SEP-2577 deprecates roots and sampling at 2026-07-28, the revision every modern connection speaks,
|
||||
# so the warning lives here now that the handshake cannot land on one.
|
||||
MCP::ProtocolDeprecations.warn_for_client_capabilities(capabilities, protocol_version: version, uplevel: 1)
|
||||
|
||||
@server_info = result
|
||||
@connected = true
|
||||
@server_info
|
||||
|
|
@ -658,8 +667,13 @@ module MCP
|
|||
# version as well: during the 2026-07-28 rollout a server may answer discovery while
|
||||
# only serving legacy versions.
|
||||
def connect_auto(client_info:, protocol_version:, capabilities:)
|
||||
connect_modern(client_info: client_info, protocol_version: nil, capabilities: capabilities)
|
||||
modern_pin = protocol_version if protocol_version && MCP::Configuration.modern_protocol_version?(protocol_version)
|
||||
connect_modern(client_info: client_info, protocol_version: modern_pin, capabilities: capabilities)
|
||||
rescue RequestHandlerError
|
||||
# An explicitly requested modern version is never downgraded by the fallback: the legacy handshake cannot negotiate it,
|
||||
# so the probe's failure is the real answer and propagates.
|
||||
raise if modern_pin
|
||||
|
||||
connect_legacy(client_info: client_info, protocol_version: protocol_version, capabilities: capabilities)
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -77,8 +77,9 @@ module MCP
|
|||
#
|
||||
# @param client_info [Hash, nil] `{ name:, version: }` identifying the client.
|
||||
# Defaults to `{ name: "mcp-ruby-client", version: MCP::VERSION }`.
|
||||
# @param protocol_version [String, nil] Protocol version to offer. Defaults
|
||||
# to `MCP::Configuration::LATEST_STABLE_PROTOCOL_VERSION`.
|
||||
# @param protocol_version [String, nil] Protocol version to offer on the legacy handshake.
|
||||
# Defaults to `MCP::Configuration::LATEST_HANDSHAKE_PROTOCOL_VERSION`; a modern version
|
||||
# raises `ArgumentError` here (modern versions are selected via `mode: :modern`/`:auto`).
|
||||
# @param capabilities [Hash] Capabilities advertised by the client. Defaults to `{}`.
|
||||
# @return [Hash] The server's `InitializeResult`.
|
||||
# @raise [RequestHandlerError] If the server responds with a JSON-RPC error,
|
||||
|
|
@ -91,6 +92,9 @@ module MCP
|
|||
def connect(client_info: nil, protocol_version: nil, capabilities: {}, mode: :legacy)
|
||||
return @server_info if connected?
|
||||
|
||||
# Validated before `start` so a pure argument error never spawns the server process.
|
||||
MCP::Configuration.reject_modern_handshake_version!(protocol_version) if mode == :legacy
|
||||
|
||||
start unless @started
|
||||
|
||||
client_info ||= { name: "mcp-ruby-client", version: MCP::VERSION }
|
||||
|
|
@ -221,7 +225,7 @@ module MCP
|
|||
private
|
||||
|
||||
def connect_legacy(client_info:, protocol_version:, capabilities:)
|
||||
protocol_version ||= MCP::Configuration::LATEST_STABLE_PROTOCOL_VERSION
|
||||
protocol_version ||= MCP::Configuration::LATEST_HANDSHAKE_PROTOCOL_VERSION
|
||||
|
||||
init_request = {
|
||||
jsonrpc: JsonRpcHandler::Version::V2_0,
|
||||
|
|
@ -257,9 +261,11 @@ module MCP
|
|||
@server_info = response["result"]
|
||||
|
||||
negotiated_protocol_version = @server_info["protocolVersion"]
|
||||
unless MCP::Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(negotiated_protocol_version)
|
||||
unless MCP::Configuration::SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS.include?(negotiated_protocol_version)
|
||||
# Per spec, if the client does not support the server's returned protocol version,
|
||||
# the client SHOULD disconnect. Roll back the cached `InitializeResult` before raising
|
||||
# the client SHOULD disconnect. A modern version is rejected along with unknown ones:
|
||||
# the handshake settles on a legacy version by definition, and the TypeScript and Python clients refuse
|
||||
# a modern counter-offer the same way. Roll back the cached `InitializeResult` before raising
|
||||
# so a retry starts without a stale `server_info`.
|
||||
# https://modelcontextprotocol.io/specification/2025-11-25/basic/lifecycle#version-negotiation
|
||||
@server_info = nil
|
||||
|
|
@ -270,8 +276,6 @@ module MCP
|
|||
)
|
||||
end
|
||||
|
||||
MCP::ProtocolDeprecations.warn_for_client_capabilities(capabilities, protocol_version: negotiated_protocol_version, uplevel: 1)
|
||||
|
||||
begin
|
||||
notification = {
|
||||
jsonrpc: JsonRpcHandler::Version::V2_0,
|
||||
|
|
@ -317,6 +321,10 @@ module MCP
|
|||
)
|
||||
end
|
||||
|
||||
# SEP-2577 deprecates roots and sampling at 2026-07-28, the revision every modern connection speaks,
|
||||
# so the warning lives here now that the handshake cannot land on one.
|
||||
MCP::ProtocolDeprecations.warn_for_client_capabilities(capabilities, protocol_version: version, uplevel: 1)
|
||||
|
||||
@server_info = result
|
||||
@server_info
|
||||
end
|
||||
|
|
@ -327,8 +335,13 @@ module MCP
|
|||
# version as well: during the 2026-07-28 rollout a server may answer discovery while
|
||||
# only serving legacy versions.
|
||||
def connect_auto(client_info:, protocol_version:, capabilities:)
|
||||
connect_modern(client_info: client_info, protocol_version: nil, capabilities: capabilities)
|
||||
modern_pin = protocol_version if protocol_version && MCP::Configuration.modern_protocol_version?(protocol_version)
|
||||
connect_modern(client_info: client_info, protocol_version: modern_pin, capabilities: capabilities)
|
||||
rescue RequestHandlerError
|
||||
# An explicitly requested modern version is never downgraded by the fallback: the legacy handshake cannot negotiate it,
|
||||
# so the probe's failure is the real answer and propagates.
|
||||
raise if modern_pin
|
||||
|
||||
connect_legacy(client_info: client_info, protocol_version: protocol_version, capabilities: capabilities)
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -9,19 +9,40 @@ module MCP
|
|||
].freeze
|
||||
DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26"
|
||||
|
||||
# Protocol versions of the stateless "modern" lifecycle introduced by the MCP 2026-07-28 spec release (SEP-2575).
|
||||
# 2026-07-28 serves both lifecycles of the dual-era model: it is negotiable through the legacy `initialize`
|
||||
# handshake (so it also appears in `SUPPORTED_STABLE_PROTOCOL_VERSIONS`), and it is the version of the modern
|
||||
# lifecycle, where each request carries its own version in `_meta` and is validated against this list
|
||||
# independently, with no handshake.
|
||||
# Protocol versions of the stateless "modern" lifecycle introduced by the MCP 2026-07-28 spec release (SEP-2575),
|
||||
# where each request carries its own version in `_meta` and is validated against this list independently,
|
||||
# with no handshake. These are reachable only through `server/discover` and the per-request envelope.
|
||||
# https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2575
|
||||
LATEST_MODERN_PROTOCOL_VERSION = "2026-07-28"
|
||||
SUPPORTED_MODERN_PROTOCOL_VERSIONS = [LATEST_MODERN_PROTOCOL_VERSION].freeze
|
||||
|
||||
# Protocol versions reachable through the legacy `initialize` handshake, derived so the era partition
|
||||
# (handshake = stable minus modern) cannot drift when a new revision lands.
|
||||
# Per the SEP-2575 era model, an era is a property of the protocol version itself: legacy versions establish
|
||||
# a session via `initialize` (2025-11-25 and earlier), and modern versions carry the version on every request
|
||||
# in `_meta` with no handshake at all. The handshake therefore never negotiates a modern version:
|
||||
# a client asking `initialize` for one is counter-offered
|
||||
# `LATEST_HANDSHAKE_PROTOCOL_VERSION`, matching the TypeScript and Python SDKs.
|
||||
SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS = (SUPPORTED_STABLE_PROTOCOL_VERSIONS - SUPPORTED_MODERN_PROTOCOL_VERSIONS).freeze
|
||||
LATEST_HANDSHAKE_PROTOCOL_VERSION = SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS.first
|
||||
|
||||
class << self
|
||||
def modern_protocol_version?(version)
|
||||
SUPPORTED_MODERN_PROTOCOL_VERSIONS.include?(version)
|
||||
end
|
||||
|
||||
def handshake_protocol_version?(version)
|
||||
SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS.include?(version)
|
||||
end
|
||||
|
||||
# The one statement of the client-side handshake contract, shared by every transport:
|
||||
# a modern version cannot ride the legacy `initialize` handshake.
|
||||
def reject_modern_handshake_version!(version)
|
||||
return unless version && modern_protocol_version?(version)
|
||||
|
||||
raise ArgumentError, "protocol version #{version.inspect} cannot be negotiated through the legacy " \
|
||||
"`initialize` handshake; use `mode: :modern` (or `:auto`) instead"
|
||||
end
|
||||
end
|
||||
|
||||
attr_writer :exception_reporter, :around_request
|
||||
|
|
@ -78,8 +99,12 @@ module MCP
|
|||
@validate_tool_call_results = validate_tool_call_results
|
||||
end
|
||||
|
||||
# The pin scopes the `initialize` handshake, so an unset pin reads as the version that handshake
|
||||
# settles on by default. Reading the newest version of any era here would hand back a value
|
||||
# the writer rejects, and no caller wants the modern revision: a modern connection carries
|
||||
# its version on every request instead of consulting configuration.
|
||||
def protocol_version
|
||||
@protocol_version || LATEST_STABLE_PROTOCOL_VERSION
|
||||
@protocol_version || LATEST_HANDSHAKE_PROTOCOL_VERSION
|
||||
end
|
||||
|
||||
def protocol_version?
|
||||
|
|
@ -174,11 +199,24 @@ module MCP
|
|||
|
||||
private
|
||||
|
||||
# A pin scopes the `initialize` handshake, so only handshake versions are accepted:
|
||||
# a modern version has no handshake to pin (its version rides every request in `_meta`),
|
||||
# and accepting one here would configure nothing. Failing at construction beats
|
||||
# a setting that silently does not apply.
|
||||
def validate_protocol_version!(protocol_version)
|
||||
unless SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(protocol_version)
|
||||
message = "protocol_version must be #{SUPPORTED_STABLE_PROTOCOL_VERSIONS[0...-1].join(", ")}, or #{SUPPORTED_STABLE_PROTOCOL_VERSIONS[-1]}"
|
||||
raise ArgumentError, message
|
||||
return if SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS.include?(protocol_version)
|
||||
|
||||
# A version this SDK serves, rejected only for where it was set, deserves the reason and
|
||||
# the alternative rather than a list it is missing from: this is the error an upgrade from
|
||||
# a release that accepted the value lands on, so it doubles as the migration note.
|
||||
if self.class.modern_protocol_version?(protocol_version)
|
||||
raise ArgumentError, "protocol_version #{protocol_version.inspect} is a modern protocol version and cannot be pinned here: " \
|
||||
"the pin scopes the `initialize` handshake, which never negotiates a modern version. " \
|
||||
"Modern clients carry their version on every request and need no pin; remove the setting."
|
||||
end
|
||||
|
||||
raise ArgumentError, "protocol_version must be #{SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS[0...-1].join(", ")}, " \
|
||||
"or #{SUPPORTED_HANDSHAKE_PROTOCOL_VERSIONS[-1]}"
|
||||
end
|
||||
|
||||
def validate_value_of_validate_tool_call_arguments!(validate_tool_call_arguments)
|
||||
|
|
|
|||
|
|
@ -3,6 +3,15 @@
|
|||
require_relative "configuration"
|
||||
|
||||
module MCP
|
||||
# Warning texts for the features SEP-2577 deprecates at 2026-07-28.
|
||||
#
|
||||
# Only the client emits these, from the modern connect, where the capabilities it declares are
|
||||
# the ones being deprecated. No server-side trigger remains: the `initialize` handshake never lands on
|
||||
# a deprecating revision and `Configuration` rejects a modern pin, so nothing on that side can reach
|
||||
# a version these apply to. `LOGGING_MESSAGE` in particular has no caller left
|
||||
# (a modern client declares no logging capability, and `notify_log_message` on that wire is
|
||||
# the SEP-2575 sanctioned delivery path rather than a deprecated call). It stays public and
|
||||
# callable for embedders, and because deleting it would be a breaking change for no gain.
|
||||
module ProtocolDeprecations
|
||||
extend self
|
||||
|
||||
|
|
|
|||
|
|
@ -403,8 +403,6 @@ module MCP
|
|||
# is deprecated as of MCP protocol version 2026-07-28 (SEP-2577).
|
||||
# Use stderr or OpenTelemetry instead.
|
||||
def notify_log_message(data:, level:, logger: nil)
|
||||
warn_if_deprecated_protocol_feature(:logging, uplevel: 1)
|
||||
|
||||
return unless @transport
|
||||
return unless logging_message_notification&.should_notify?(level)
|
||||
|
||||
|
|
@ -425,8 +423,6 @@ module MCP
|
|||
# version 2026-07-28 (SEP-2577). Use tool parameters, resource URIs,
|
||||
# server configuration, or environment variables instead.
|
||||
def roots_list_changed_handler(&block)
|
||||
warn_if_deprecated_protocol_feature(:roots, uplevel: 1)
|
||||
|
||||
@handlers[Methods::NOTIFICATIONS_ROOTS_LIST_CHANGED] = block
|
||||
end
|
||||
|
||||
|
|
@ -591,13 +587,6 @@ module MCP
|
|||
return ->(params) { handle_cancelled_notification(params, session: session) }
|
||||
end
|
||||
|
||||
case method
|
||||
when Methods::NOTIFICATIONS_ROOTS_LIST_CHANGED
|
||||
warn_if_deprecated_protocol_feature(:roots, session: session, uplevel: 2)
|
||||
when Methods::LOGGING_SET_LEVEL
|
||||
warn_if_deprecated_protocol_feature(:logging, session: session, uplevel: 2)
|
||||
end
|
||||
|
||||
handler = @handlers[method]
|
||||
unless handler
|
||||
instrument_call("unsupported_method", server_context: { request: request }) do
|
||||
|
|
@ -1045,10 +1034,19 @@ module MCP
|
|||
end
|
||||
protocol_version = params[:protocolVersion]
|
||||
|
||||
negotiated_version = if Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(protocol_version)
|
||||
# Per the SEP-2575 era model, `initialize` negotiates legacy protocol versions only: a modern version is
|
||||
# defined by carrying its own version on every request in `_meta`, with no handshake,
|
||||
# so asking `initialize` for one (or for a version this server does not know) is answered with
|
||||
# a counter-offer instead of an echo, matching the TypeScript and Python SDKs. Modern versions
|
||||
# stay reachable through `server/discover` and the per-request envelope. The counter-offer is
|
||||
# a configured `protocol_version` pin when one is set (`Configuration` only accepts handshake versions there),
|
||||
# and the latest handshake version otherwise.
|
||||
negotiated_version = if Configuration.handshake_protocol_version?(protocol_version)
|
||||
protocol_version
|
||||
else
|
||||
elsif configuration.protocol_version?
|
||||
configuration.protocol_version
|
||||
else
|
||||
Configuration::LATEST_HANDSHAKE_PROTOCOL_VERSION
|
||||
end
|
||||
|
||||
info = server_info.reject do |property|
|
||||
|
|
@ -1160,19 +1158,6 @@ module MCP
|
|||
{}
|
||||
end
|
||||
|
||||
def warn_if_deprecated_protocol_feature(feature, session: nil, uplevel: 1)
|
||||
protocol_version = effective_deprecation_protocol_version(session)
|
||||
MCP::ProtocolDeprecations.warn_for(feature, protocol_version: protocol_version, uplevel: uplevel)
|
||||
end
|
||||
|
||||
def effective_deprecation_protocol_version(session)
|
||||
session&.protocol_version || @client_protocol_version || explicit_protocol_version
|
||||
end
|
||||
|
||||
def explicit_protocol_version
|
||||
configuration.protocol_version if configuration.protocol_version?
|
||||
end
|
||||
|
||||
def list_tools(request)
|
||||
page = paginate(@tools.values, cursor: cursor_from(request), page_size: @page_size, request: request, &:to_h)
|
||||
|
||||
|
|
|
|||
|
|
@ -277,12 +277,12 @@ module MCP
|
|||
# An empty header value is malformed rather than a version claim, so it stays on the legacy path
|
||||
# and fails legacy header validation as before.
|
||||
#
|
||||
# 2026-07-28 serves both lifecycles of the dual-era model, so for that header value the version
|
||||
# alone cannot decide the era: an `Mcp-Session-Id` binds the request to an established legacy session
|
||||
# (POST requests, the GET SSE stream, and DELETE termination keep working), and a session-less POST whose
|
||||
# body is `initialize` is the legacy-distinctive handshake. Everything else under a dual-era header is
|
||||
# sessionless modern traffic (`server/discover`, envelope-carrying requests, and envelope-missing requests
|
||||
# that get the modern path's error shape).
|
||||
# A modern header value (2026-07-28) alone cannot decide the era: sessionless modern traffic carries it,
|
||||
# and requests of an established legacy session may stamp it as well (the handshake itself never negotiates it):
|
||||
# an `Mcp-Session-Id` binds the request to an established legacy session (POST requests, the GET SSE stream,
|
||||
# and DELETE termination keep working), and a session-less POST whose body is `initialize` is
|
||||
# the legacy-distinctive handshake. Everything else under a dual-era header is sessionless modern traffic
|
||||
# (`server/discover`, envelope-carrying requests, and envelope-missing requests that get the modern path's error shape).
|
||||
header_version = request.env["HTTP_MCP_PROTOCOL_VERSION"]
|
||||
if header_version && !header_version.empty? && !stable_only_version?(header_version)
|
||||
unless MCP::Configuration.modern_protocol_version?(header_version)
|
||||
|
|
@ -1414,8 +1414,9 @@ module MCP
|
|||
body.is_a?(Hash) && body[:method] == Methods::SERVER_DISCOVER
|
||||
end
|
||||
|
||||
# A version negotiable only through the legacy handshake, with no modern meaning.
|
||||
# Dual-era versions (2026-07-28) appear in both lists and need further disambiguation.
|
||||
# A version with no modern meaning, whose header can only accompany legacy traffic.
|
||||
# A modern version's header (2026-07-28) can accompany either era's traffic - the handshake never negotiates it,
|
||||
# but requests of an established legacy session may stamp it - so that value needs further disambiguation.
|
||||
def stable_only_version?(version)
|
||||
MCP::Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(version) &&
|
||||
!MCP::Configuration.modern_protocol_version?(version)
|
||||
|
|
|
|||
|
|
@ -132,7 +132,6 @@ module MCP
|
|||
# version 2026-07-28 (SEP-2577). Use tool parameters, resource URIs,
|
||||
# server configuration, or environment variables instead.
|
||||
def list_roots(related_request_id: nil, timeout: nil)
|
||||
@server.send(:warn_if_deprecated_protocol_feature, :roots, session: self, uplevel: 2)
|
||||
warn_unassociated_request(__method__, related_request_id)
|
||||
|
||||
unless client_capabilities&.dig(:roots)
|
||||
|
|
@ -159,7 +158,6 @@ module MCP
|
|||
# MCP protocol version 2026-07-28 (SEP-2577). Use direct LLM provider
|
||||
# APIs instead.
|
||||
def create_sampling_message(related_request_id: nil, timeout: nil, **kwargs)
|
||||
@server.send(:warn_if_deprecated_protocol_feature, :sampling, session: self, uplevel: 2)
|
||||
warn_unassociated_request(__method__, related_request_id)
|
||||
|
||||
params = @server.build_sampling_params(client_capabilities, **kwargs)
|
||||
|
|
@ -274,8 +272,6 @@ module MCP
|
|||
# is deprecated as of MCP protocol version 2026-07-28 (SEP-2577).
|
||||
# Use stderr or OpenTelemetry instead.
|
||||
def notify_log_message(data:, level:, logger: nil, related_request_id: nil)
|
||||
@server.send(:warn_if_deprecated_protocol_feature, :logging, session: self, uplevel: 2)
|
||||
|
||||
# In the modern lifecycle, log delivery is authorized per request through the `_meta` envelope's `logLevel` member
|
||||
# (applied via `configure_logging`); without it no `notifications/message` is sent, and the server-wide level
|
||||
# does not apply (SEP-2575).
|
||||
|
|
|
|||
Loading…
Reference in a new issue