mcp 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cb0f742e469efeb15202b40310bfb2eab52b94bb208bab1f33cfd2204bcf8c9
-  data.tar.gz: 07df380a1dd652b6fd5deb0ddbafe3c3379bc6fa77c8a391f169f6a7fed11742
+  metadata.gz: '08c2de444c55244db435a10ce7b9f9026d24158d47cadd6f89b917f42e09b534'
+  data.tar.gz: 6126a02c9adf92df07f22b323a0337f2abae9eb23c7bf014f1b7ef1ccbbf3a72
 SHA512:
-  metadata.gz: c756d7552fbf3accc8eedc32876e715c1d34939ed8c44d9d540a97b46ccf4cc2d3a163f5ba5989277be6e8933bce374ccab80f27ddf62ed52f6ea27c0367a3c5
-  data.tar.gz: '0873ea9933d9b30e1c0e2bcbd6f56eb0c658f16736ae309007cd752b097cb9f75ebcead7277c89ea9f255f92f3f62d2d4f1ac5d4ae87cf36359df4e42e030d38'
+  metadata.gz: 7318acb46d46e9c958115f95171f21b20c186ab32608770d443440e0202d29319b9384b11099ed69f136c3ba9146be39998e1a9a47a839fe506e07cddca0ad89
+  data.tar.gz: 3008f7f6061e0a2cd514d377ade38a03be1ed88d863fb268e50c9820ece43f585b7fcc801bc6c0ffcf78fab3a80af3397c20e497722a6821c55d6128d391d4fc

data/README.md

@@ -125,7 +125,7 @@ see [Client Transports](https://ruby.sdk.modelcontextprotocol.io/client/transpor
 
 ## Examples
 
-Runnable examples are available in [`examples/`](https://github.com/modelcontextprotocol/ruby-sdk/tree/main/examples),
+Runnable examples are available in [`examples`](https://github.com/modelcontextprotocol/ruby-sdk/tree/main/examples),
 including a complete Rails application in [`examples/rails`](https://github.com/modelcontextprotocol/ruby-sdk/tree/main/examples/rails).
 
 ## Documentation

data/lib/mcp/client/oauth/discovery.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ipaddr"
+require "strscan"
 require "uri"
 
 module MCP
@@ -43,6 +44,12 @@ module MCP
         # or a bare token, per RFC 7235.
         WWW_AUTH_PARAM_PATTERN = /\A([A-Za-z0-9_-]+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,]+))/.freeze
 
+        # The whitespace and optional comma between two `key=value` pairs, or before the first one.
+        WWW_AUTH_PARAM_SEPARATOR_PATTERN = /\s*,?\s*/.freeze
+
+        # The `Bearer` challenge: at the start of the header or after a comma.
+        WWW_AUTH_BEARER_PATTERN = /(?:\A|,)\s*Bearer(?:\s+|\z)/i.freeze
+
         class << self
           # Parses a `WWW-Authenticate` header and returns the parameters of
           # the `Bearer` challenge as a hash with lower-cased keys (e.g. `resource_metadata`,
@@ -55,25 +62,21 @@ module MCP
           def parse_www_authenticate(header)
             return {} unless header
 
-            # Locate the Bearer challenge: at the start of the header or after a comma.
-            bearer = header.match(/(?:\A|,)\s*Bearer(?:\s+|\z)/i)
-            return {} unless bearer
-
             # Walk key=value pairs starting where Bearer's parameters begin.
-            # The loop stops at the first token that is not a key=value pair,
-            # which marks the next challenge (e.g. `, DPoP algs="..."`).
-            cursor = bearer.end(0)
-            params = {}
-            while cursor < header.length
-              prefix = header[cursor..]
-              prefix = prefix.sub(/\A\s*,?\s*/, "")
-              break if prefix.empty?
+            # The loop stops at the first token that is not a key=value pair, which marks the next challenge (e.g. `, DPoP algs="..."`).
+            # The scanner keeps the walk linear in the header's length: slicing off the consumed prefix instead copies the remainder
+            # for every pair, and the server chooses how many pairs it sends. The header is also the server's to fill: a byte sequence
+            # that is not valid in the string's encoding would make the patterns raise `ArgumentError`, so such bytes are replaced first.
+            scanner = StringScanner.new(header.scrub)
+            return {} unless scanner.skip_until(WWW_AUTH_BEARER_PATTERN)
 
-              match = prefix.match(WWW_AUTH_PARAM_PATTERN)
-              break unless match
+            params = {}
+            until scanner.eos?
+              scanner.skip(WWW_AUTH_PARAM_SEPARATOR_PATTERN)
+              break if scanner.eos?
+              break unless scanner.scan(WWW_AUTH_PARAM_PATTERN)
 
-              params[match[1].downcase] = match[2] ? unescape_quoted_pair(match[2]) : match[3]
-              cursor = header.length - prefix.length + match.end(0)
+              params[scanner[1].downcase] = scanner[2] ? unescape_quoted_pair(scanner[2]) : scanner[3]
             end
             params
           end
@@ -576,47 +579,46 @@ module MCP
               end.join("&")
           end
 
-          # Implements RFC 3986 Section 5.2.4 `remove_dot_segments`. Walks the input
-          # buffer one segment at a time, popping the previous output segment
-          # whenever a `..` is encountered, so that `/api/../mcp` collapses to
-          # `/mcp` and `/foo/./bar` collapses to `/foo/bar`.
+          # Implements RFC 3986 Section 5.2.4 `remove_dot_segments` over the path's segments, so that `/api/../mcp` collapses to
+          # `/mcp` and `/foo/./bar` collapses to `/foo/bar`. Each segment is visited once: the RFC's buffer rewriting,
+          # applied literally, copies the remaining input for every dot segment, and the path is the server's to choose.
+          #
+          # The output matches the RFC's algorithm for a relative path as well, including its quirk that a `..` popping
+          # the first segment leaves the result absolute (`a/../b` becomes `/b`), although `URI#path` never hands over a relative path.
+          # The rule letters below are the RFC's own: steps A through E of its loop.
           # https://www.rfc-editor.org/rfc/rfc3986#section-5.2.4
           def remove_dot_segments(path)
             return path if path.nil? || path.empty?
 
-            input = path.dup
-            output = +""
-            until input.empty?
-              if input.start_with?("../")
-                input = input[3..]
-              elsif input.start_with?("./")
-                input = input[2..]
-              elsif input.start_with?("/./")
-                input = "/#{input[3..]}"
-              elsif input == "/."
-                input = "/"
-              elsif input.start_with?("/../")
-                input = "/#{input[4..]}"
-                output = remove_last_segment(output)
-              elsif input == "/.."
-                input = "/"
-                output = remove_last_segment(output)
-              elsif input == "." || input == ".."
-                input = ""
+            absolute = path.start_with?("/")
+            segments = path.split("/", -1)
+            segments.shift if absolute
+
+            output = []
+
+            # True until a segment other than `.` or `..` is kept: a relative path's leading `./` and `../` are dropped together with
+            # the slash after them (Rule A), so the segment that follows is still the slash-less first one.
+            leading = !absolute
+            segments.each_with_index do |segment, index|
+              last = index == segments.length - 1
+
+              # Rule A, and Rule D for a path that is nothing but `.` or `..`.
+              next if leading && (segment == "." || segment == "..")
+
+              if segment == "."
+                # Rule B: `/./` disappears; a final `/.` leaves its slash behind.
+                output << "/" if last
+              elsif segment == ".."
+                # Rule C: `/../` removes the previous segment; a final `/..` leaves its slash behind.
+                output.pop
+                output << "/" if last
               else
-                segment = input.match(%r{\A/?[^/]*})[0]
-                output << segment
-                input = input[segment.length..]
+                # Rule E: the first segment of a relative path carries no slash.
+                output << (leading ? segment : "/#{segment}")
               end
+              leading = false
             end
-            output
-          end
-
-          def remove_last_segment(output)
-            idx = output.rindex("/")
-            return +"" if idx.nil?
-
-            output[0...idx]
+            output.join
           end
         end
       end

data/lib/mcp/client/oauth/flow.rb

@@ -1206,16 +1206,30 @@ module MCP
               "Authorization server metadata `authorization_endpoint` is not a valid URI: #{e.message}."
           end
 
-          params = URI.decode_www_form(uri.query.to_s)
-          params << ["response_type", "code"]
-          params << ["client_id", client_id]
-          params << ["redirect_uri", @provider.redirect_uri]
-          params << ["code_challenge", code_challenge]
-          params << ["code_challenge_method", "S256"]
-          params << ["state", state]
-          params << ["scope", scope] if scope
-          params << ["resource", resource] if resource
-          uri.query = URI.encode_www_form(params)
+          # A parameter the flow sets replaces any of the same name the endpoint URL already carries.
+          # RFC 6749 Section 3.1 forbids sending a parameter twice, and which of two values a server would honor is
+          # its own choice; on the legacy path the endpoint URL is served by the MCP server, whose query must not speak
+          # for the client's `client_id`, `redirect_uri`, `code_challenge`, or `resource`.
+          # Other parameters in the URL are kept, as the TypeScript SDK's `searchParams.set` keeps them; that includes
+          # a `scope` when the flow has none, since an authorization server may set a default scope there.
+          # RFC 9101 `request` and `request_uri` are dropped as well, though the flow sets neither: a server takes
+          # the whole authorization request from the object they carry, over every parameter in the query, and both are
+          # the client's to send, never an endpoint URL's to supply.
+          own_params = [
+            ["response_type", "code"],
+            ["client_id", client_id],
+            ["redirect_uri", @provider.redirect_uri],
+            ["code_challenge", code_challenge],
+            ["code_challenge_method", "S256"],
+            ["state", state],
+          ]
+          own_params << ["scope", scope] if scope
+          own_params << ["resource", resource] if resource
+          dropped_names = own_params.map(&:first) + ["request", "request_uri"]
+
+          params = URI.decode_www_form(uri.query.to_s).reject { |name, _value| dropped_names.include?(name) }
+          uri.query = URI.encode_www_form(params + own_params)
+
           uri
         end
 

data/lib/mcp/server/transports/streamable_http_transport.rb

@@ -169,8 +169,12 @@ module MCP
           @allowed_origins = Array(allowed_origins).map(&:downcase).freeze
           @pending_responses = {}
 
-          # Maps a `subscriptions/listen` request id to
-          # `{ stream: stream_object, filter: honored_subscription_filter, active: boolean, write_mutex: Mutex }` (SEP-2575).
+          # Maps a key the transport mints for each `subscriptions/listen` stream to
+          # `{ request_id: listen_request_id, stream: stream_object, filter: honored_subscription_filter, active: boolean,
+          # write_mutex: Mutex, keepalive_wakeup: ConditionVariable }` (SEP-2575). The request id is the client's,
+          # unique only among that client's own in-flight requests, so it stamps `subscriptionId` but cannot serve as the key:
+          # two clients may pick the same one. Whoever removes an entry signals `keepalive_wakeup` under `@mutex`,
+          # so the stream's keepalive thread ends with its slot instead of sleeping out its interval.
           # In-process only; a multi-worker deployment needs an external event bus to fan notifications out across processes,
           # which is a follow-up.
           @listen_subscriptions = {}
@@ -925,23 +929,33 @@ module MCP
         # the legacy GET stream (`create_sse_body`).
         #
         # Registration and activation are split on purpose: the entry is inserted inactive
-        # (reserving the id and the cap slot atomically), the acknowledgement is written outside the lock,
+        # (reserving the cap slot atomically), the acknowledgement is written outside the registry lock,
         # and only then does the entry become eligible for delivery. A concurrent notification between
         # the insert and the acknowledgement write skips the inactive entry,
         # enforcing the SEP-2575 rule that no notification precedes the acknowledgement.
+        #
+        # The acknowledgement write holds the stream's write mutex, which `teardown_listen_subscriptions` also takes
+        # before it marks an entry closed. The two therefore cannot interleave: the acknowledgement either lands
+        # before the result, or, if the transport closed first, is not written at all and the stream just closes,
+        # so no stream ever carries a result ahead of its acknowledgement.
+        #
+        # The entry is keyed by an identifier minted here, not by the request id: that id is unique only among
+        # the requesting client's own in-flight requests, and two clients that pick the same one must each get
+        # their stream, stamped with the id they sent.
         def listen_sse_body(request_id, honored)
           ListenStreamBody.new do |stream|
-            rejected = false
+            subscription_key = SecureRandom.uuid
+            subscription = nil
             @mutex.synchronize do
-              if @listen_subscriptions.key?(request_id) ||
-                  (@max_listen_subscriptions && @listen_subscriptions.size >= @max_listen_subscriptions)
-                rejected = true
-              else
-                @listen_subscriptions[request_id] = { stream: stream, filter: honored, active: false, write_mutex: Mutex.new }
+              unless @max_listen_subscriptions && @listen_subscriptions.size >= @max_listen_subscriptions
+                subscription = {
+                  request_id: request_id, stream: stream, filter: honored, active: false, write_mutex: Mutex.new, keepalive_wakeup: ConditionVariable.new
+                }
+                @listen_subscriptions[subscription_key] = subscription
               end
             end
 
-            if rejected
+            if subscription.nil?
               close_stream_safely(stream)
             else
               acknowledgement = {
@@ -954,66 +968,92 @@ module MCP
               }
 
               begin
-                send_to_stream(stream, acknowledgement)
-                activate_listen_subscription(request_id)
-                start_listen_keepalive_thread(request_id)
+                acknowledged = subscription[:write_mutex].synchronize do
+                  next false if subscription[:closed]
+
+                  send_to_stream(stream, acknowledgement)
+
+                  # Set on the entry itself, not through the registry: a concurrent close may already have cleared the registry
+                  # while its result write waits on this mutex, and that write must still find the stream acknowledged.
+                  # Set under the registry lock as well, since that is the lock the delivery snapshot reads the flag under.
+                  # This is the one place a write mutex is held while the registry lock is taken; it stays deadlock-free only
+                  # as long as no path takes a write mutex inside `@mutex.synchronize`, so resolve entries under `@mutex`,
+                  # release it, then write.
+                  @mutex.synchronize { subscription[:active] = true }
+
+                  true
+                end
+
+                if acknowledged
+                  start_listen_keepalive_thread(subscription_key, request_id)
+                else
+                  close_stream_safely(stream)
+                end
               rescue *STREAM_WRITE_ERRORS
-                remove_listen_subscription(request_id)
+                remove_listen_subscription(subscription_key)
                 close_stream_safely(stream)
               end
             end
           end
         end
 
-        # Marks a listen subscription eligible for delivery once its acknowledgement write has completed.
-        # The entry may already be gone when the transport closed concurrently.
-        def activate_listen_subscription(request_id)
-          @mutex.synchronize do
-            subscription = @listen_subscriptions[request_id]
-            subscription[:active] = true if subscription
-          end
-        end
-
         # Periodically writes an SSE keepalive comment frame to a listen stream so a silently dropped
         # connection is detected and its slot freed, rather than held until the next fan-out write.
         # Mirrors the legacy GET stream's `start_keepalive_thread`; a comment frame (not a data frame)
         # cannot corrupt an interleaved notification's JSON.
-        def start_listen_keepalive_thread(request_id)
+        #
+        # The wait between pings is a condition variable wait under `@mutex`, not a plain sleep:
+        # the presence check and the wait happen under the same lock that removals signal from,
+        # so a removal cannot slip in between them and a thread waiting out its interval wakes
+        # at once when its entry goes, whichever path removed it. A thread already past the wait,
+        # in a ping, finishes that write first and then finds its entry gone.
+        def start_listen_keepalive_thread(subscription_key, request_id)
           return unless @listen_keepalive_interval
 
           Thread.new do
-            while listen_subscription_active?(request_id)
-              sleep(@listen_keepalive_interval)
-              send_listen_keepalive_ping(request_id)
+            loop do
+              registered = @mutex.synchronize do
+                subscription = @listen_subscriptions[subscription_key]
+                next false unless subscription
+
+                subscription[:keepalive_wakeup].wait(@mutex, @listen_keepalive_interval)
+
+                @listen_subscriptions.key?(subscription_key)
+              end
+              break unless registered
+
+              send_listen_keepalive_ping(subscription_key)
             end
           rescue *STREAM_WRITE_ERRORS
             # The peer went away; the ensure frees the slot. A dropped listen stream is the normal
             # way this loop ends, so it is not reported.
           rescue StandardError => e
+            # The request id is taken from the caller rather than the registry: a delivery failure may have
+            # removed the entry already, and the report should still name the stream.
             MCP.configuration.exception_reporter.call(e, { subscription_id: request_id })
           ensure
             stream = @mutex.synchronize do
-              subscription = @listen_subscriptions.delete(request_id)
+              subscription = @listen_subscriptions.delete(subscription_key)
               subscription && subscription[:stream]
             end
             close_stream_safely(stream) if stream
           end
         end
 
-        def listen_subscription_active?(request_id)
-          @mutex.synchronize { @listen_subscriptions.key?(request_id) }
-        end
+        # Resolves the entry under the registry lock, then writes outside it so a stalled reader cannot
+        # block every other subscription on `@mutex`. The write itself holds the stream's write mutex,
+        # like notification delivery and the closing result: the comment frame then cannot land between
+        # the bytes of a notification or after the closing result, and once teardown has marked
+        # the entry closed the ping is skipped. A write error propagates to end the keepalive loop.
+        def send_listen_keepalive_ping(subscription_key)
+          subscription = @mutex.synchronize { @listen_subscriptions[subscription_key] }
+          return unless subscription
 
-        # Resolves the stream under the lock, then writes outside it so a stalled reader cannot block
-        # every other subscription on `@mutex`. A write error propagates to end the keepalive loop.
-        def send_listen_keepalive_ping(request_id)
-          stream = @mutex.synchronize do
-            subscription = @listen_subscriptions[request_id]
-            subscription && subscription[:stream]
-          end
-          return unless stream
+          subscription[:write_mutex].synchronize do
+            next if subscription[:closed]
 
-          send_ping_to_stream(stream)
+            send_ping_to_stream(subscription[:stream])
+          end
         end
 
         # Per SEP-2575, the server MUST NOT send notification types the client has not requested,
@@ -1054,7 +1094,7 @@ module MCP
           # The matching snapshot is taken under `@mutex`, but stream writes happen outside it:
           # a slow or stalled subscriber must not block the transport, matching the legacy delivery paths.
           matched = @mutex.synchronize do
-            @listen_subscriptions.filter_map do |request_id, subscription|
+            @listen_subscriptions.filter_map do |subscription_key, subscription|
               # An inactive entry has not finished writing its acknowledgement yet;
               # delivering to it would put a notification ahead of the acknowledgement.
               next unless subscription[:active]
@@ -1067,12 +1107,12 @@ module MCP
                 uris.is_a?(Array) && uris.include?(uri)
               end
 
-              [request_id, subscription] if hit
+              [subscription_key, subscription] if hit
             end
           end
 
-          matched.each do |request_id, subscription|
-            meta = { RequestEnvelope::SUBSCRIPTION_ID_META_KEY.to_sym => request_id }
+          matched.each do |subscription_key, subscription|
+            meta = { RequestEnvelope::SUBSCRIPTION_ID_META_KEY.to_sym => subscription[:request_id] }
             notification_params = (params || {}).merge(_meta: meta)
             notification = { jsonrpc: "2.0", method: method, params: notification_params }
 
@@ -1089,16 +1129,21 @@ module MCP
             rescue *STREAM_WRITE_ERRORS => e
               MCP.configuration.exception_reporter.call(
                 e,
-                { subscription_id: request_id, error: "Failed to send notification" },
+                { subscription_id: subscription[:request_id], error: "Failed to send notification" },
               )
-              remove_listen_subscription(request_id)
+              remove_listen_subscription(subscription_key)
               close_stream_safely(subscription[:stream])
             end
           end
         end
 
-        def remove_listen_subscription(request_id)
-          @mutex.synchronize { @listen_subscriptions.delete(request_id) }
+        def remove_listen_subscription(subscription_key)
+          @mutex.synchronize do
+            subscription = @listen_subscriptions.delete(subscription_key)
+            subscription[:keepalive_wakeup].signal if subscription
+
+            subscription
+          end
         end
 
         # Graceful teardown (SEP-2575): each open listen stream receives its `SubscriptionsListenResult` response
@@ -1107,26 +1152,35 @@ module MCP
           removed = @mutex.synchronize do
             subscriptions = @listen_subscriptions.dup
             @listen_subscriptions.clear
+
+            subscriptions.each_value do |subscription|
+              subscription[:keepalive_wakeup].signal
+            end
+
             subscriptions
           end
 
-          removed.each do |request_id, subscription|
+          removed.each_value do |subscription|
             # Marking the entry closed and writing the result under the stream's write mutex orders
-            # this against in-flight deliveries: each one either lands before the result or observes
-            # `closed` and skips, keeping the graceful result the stream's final message.
+            # this against in-flight deliveries and against the acknowledgement write: each one either lands
+            # before the result or observes `closed` and skips, keeping the graceful result the stream's final message.
             subscription[:write_mutex].synchronize do
               subscription[:closed] = true
 
+              # A stream whose acknowledgement was never written gets no result either: SEP-2575 makes
+              # the acknowledgement the first message, so the stream closes abruptly and the client re-sends.
+              next unless subscription[:active]
+
               begin
                 send_to_stream(subscription[:stream], {
                   jsonrpc: "2.0",
-                  id: request_id,
+                  id: subscription[:request_id],
                   result: {
                     # `SubscriptionsListenResult` is served at the transport layer and never
                     # passes through the dispatch path, so the REQUIRED 2026-07-28 `resultType` is
                     # stamped at its construction site.
                     resultType: ResultType::COMPLETE,
-                    _meta: { RequestEnvelope::SUBSCRIPTION_ID_META_KEY.to_sym => request_id },
+                    _meta: { RequestEnvelope::SUBSCRIPTION_ID_META_KEY.to_sym => subscription[:request_id] },
                   },
                 })
               rescue *STREAM_WRITE_ERRORS

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "1.6.0"
+  VERSION = "1.6.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - Model Context Protocol
@@ -108,7 +108,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v1.6.0
+  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v1.6.1
   homepage_uri: https://ruby.sdk.modelcontextprotocol.io
   source_code_uri: https://github.com/modelcontextprotocol/ruby-sdk
   bug_tracker_uri: https://github.com/modelcontextprotocol/ruby-sdk/issues