mcp 1.5.1 → 1.6.1

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

@@ -95,7 +95,7 @@ module MCP
             assertion
           end
 
-          # `Accept-Encoding` is deliberately left unset, for the same reason as `Flow#default_http_client`:
+          # `Accept-Encoding` is deliberately left unset, for the same reason as `Flow.build_http_client`:
           # claiming that header turns Net::HTTP's `decode_content` off and would move `BoundedBody`'s cap
           # onto compressed bytes.
           def default_http_client

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

@@ -48,6 +48,13 @@ module MCP
       #   The document served at the URL is a separate JSON artifact from the `client_metadata` keyword:
       #   DCR `client_metadata` MUST NOT include `client_id`, while the CIMD document MUST include `client_id` set
       #   to the URL, `client_name`, and `redirect_uris` covering `redirect_uri`.
+      # - `token_request_params` - Hash of String keys and values added to every token request this provider makes
+      #   (the authorization code exchange and refresh), for parameters the authorization server requires beyond
+      #   the grant itself. The authorization request is not affected. A key in `Flow::RESERVED_TOKEN_REQUEST_PARAMS`
+      #   raises `Flow::InvalidTokenRequestParamsError`.
+      #   The Hash is copied and frozen. See `StorageBackedProvider#token_request_params`.
+      # - `http_client_customizer` - Callable invoked with the `Faraday::Connection` the flow builds for
+      #   its own requests; see `StorageBackedProvider#http_client_customizer`.
       class Provider
         include StorageBackedProvider
 
@@ -87,7 +94,9 @@ module MCP
           scope: nil,
           storage: nil,
           client_id_metadata_document_url: nil,
-          authorization_request_validator: nil
+          authorization_request_validator: nil,
+          token_request_params: nil,
+          http_client_customizer: nil
         )
           unless Discovery.secure_url?(redirect_uri)
             raise InsecureRedirectURIError,
@@ -109,6 +118,8 @@ module MCP
                 "per the MCP authorization specification and `draft-ietf-oauth-client-id-metadata-document`."
           end
 
+          http_client_customizer = validated_http_client_customizer(http_client_customizer)
+
           @client_metadata = client_metadata
           @redirect_uri = redirect_uri
           @redirect_handler = redirect_handler
@@ -117,6 +128,8 @@ module MCP
           @storage = storage || InMemoryStorage.new
           @client_id_metadata_document_url = client_id_metadata_document_url
           @authorization_request_validator = authorization_request_validator
+          @token_request_params = frozen_token_request_params(token_request_params)
+          @http_client_customizer = http_client_customizer
         end
 
         # Identifies the OAuth flow this provider drives.

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

@@ -4,11 +4,11 @@ module MCP
   class Client
     module OAuth
       # Shared token/credential persistence for the OAuth provider classes
-      # (`Provider` for the authorization-code flow and `ClientCredentialsProvider`
-      # for the client_credentials flow). The two grants differ in how they authenticate,
-      # but both read and write the same two pieces of state through a `storage` object:
-      # the token response and the client information. This module supplies that delegation
-      # so the `Flow` orchestrator can treat any provider uniformly.
+      # (`Provider` for the authorization-code flow, `ClientCredentialsProvider`
+      # for the client_credentials flow, and `CrossAppAccessProvider` for the jwt-bearer flow).
+      # The grants differ in how they authenticate, but all read and write the same two pieces of state
+      # through a `storage` object: the token response and the client information. This module supplies
+      # that delegation so the `Flow` orchestrator can treat any provider uniformly.
       #
       # Including classes must set `@storage` to an object responding to `tokens`,
       # `save_tokens(tokens)`, `client_information`, and `save_client_information(info)`
@@ -21,6 +21,20 @@ module MCP
         # MCP SDK has today.
         attr_reader :authorization_request_validator
 
+        # Optional Hash of String keys and values added to every token request the provider makes, for parameters
+        # the authorization server requires beyond the grant itself (RFC 6749 Section 8.2 leaves room for them;
+        # Auth0's `audience` is the usual one). `nil` (the default) adds nothing.
+        # Set through `frozen_token_request_params`, which refuses a key `Flow` sets itself or a wrongly shaped value
+        # with `Flow::InvalidTokenRequestParamsError`.
+        attr_reader :token_request_params
+
+        # Optional callable invoked with the `Faraday::Connection` the flow builds for its own requests,
+        # after the SDK's defaults and before its origin guard (see `Flow.build_http_client`), so an application can
+        # add middleware to discovery, registration, and token requests or swap their adapter. `nil` (the default)
+        # keeps the default connection. The transport's own connection and customizer block never serve these requests:
+        # they are bound to the MCP server URL and carry headers meant for that server.
+        attr_reader :http_client_customizer
+
         def access_token
           tokens&.dig("access_token") || tokens&.dig(:access_token)
         end
@@ -44,6 +58,29 @@ module MCP
         def clear_tokens!
           @storage.save_tokens(nil)
         end
+
+        private
+
+        # Constructors call this before writing to `storage`, so a rejected provider leaves it untouched.
+        # The copy has its own frozen keys and values, so a later change to the caller's Hash, to a key,
+        # or to a value cannot alter what is sent to the token endpoint. Keys are copied explicitly
+        # because `Hash` copies and freezes only keys whose class is exactly `String`.
+        def frozen_token_request_params(params)
+          return if params.nil?
+
+          problem = Flow.token_request_params_problem(params)
+          raise Flow::InvalidTokenRequestParamsError, "token_request_params #{problem}" if problem
+
+          params.each_with_object({}) { |(key, value), copy| copy[key.dup.freeze] = value.dup.freeze }.freeze
+        end
+
+        # Returns `customizer` when it is `nil` or callable and raises otherwise, so a connection object passed
+        # in place of a callable fails at construction rather than at the first `401`.
+        def validated_http_client_customizer(customizer)
+          return customizer if customizer.nil? || customizer.respond_to?(:call)
+
+          raise ArgumentError, "http_client_customizer must respond to call (got #{customizer.class})."
+        end
       end
     end
   end

data/lib/mcp/icon.rb

@@ -1,13 +1,35 @@
 # frozen_string_literal: true
 
 module MCP
+  # An icon attached to a server, tool, prompt, or resource, per the specification's `Icon` type:
+  # https://modelcontextprotocol.io/specification/2026-07-28/basic#icons
+  #
+  # Each argument is checked against the schema's type, as the TypeScript and Python SDKs check theirs,
+  # so an icon that would serialize into something a client rejects fails here instead. What a value means
+  # is not judged: `src` may be any non-empty `String` (the schema types it as a URI, which an empty `String`
+  # is not, and the specification allows an HTTP/HTTPS URL or a `data:` URI), and a size may be any `String`
+  # (the specification expects `WxH` or `"any"`).
   class Icon
     SUPPORTED_THEMES = ["light", "dark"].freeze
 
     attr_reader :mime_type, :sizes, :src, :theme
 
-    def initialize(mime_type: nil, sizes: nil, src: nil, theme: nil)
-      raise ArgumentError, 'The value of theme must specify "light" or "dark".' if theme && !SUPPORTED_THEMES.include?(theme)
+    def initialize(mime_type: nil, sizes: nil, src:, theme: nil)
+      unless src.is_a?(String) && !src.empty?
+        raise ArgumentError, "The value of src must be a non-empty String (got #{src.class})."
+      end
+
+      unless mime_type.nil? || mime_type.is_a?(String)
+        raise ArgumentError, "The value of mime_type must be a String (got #{mime_type.class})."
+      end
+
+      if (problem = sizes_problem(sizes))
+        raise ArgumentError, "The value of sizes must be an Array of Strings such as [\"48x48\"] or [\"any\"] (#{problem})."
+      end
+
+      unless theme.nil? || SUPPORTED_THEMES.include?(theme)
+        raise ArgumentError, 'The value of theme must specify "light" or "dark".'
+      end
 
       @mime_type = mime_type
       @sizes = sizes
@@ -18,5 +40,16 @@ module MCP
     def to_h
       { mimeType: mime_type, sizes: sizes, src: src, theme: theme }.compact
     end
+
+    private
+
+    def sizes_problem(sizes)
+      return if sizes.nil?
+      return "got #{sizes.class}" unless sizes.is_a?(Array)
+
+      index = sizes.index { |size| !size.is_a?(String) }
+
+      "got #{sizes[index].class} inside the Array" if index
+    end
   end
 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/tool.rb

@@ -149,7 +149,7 @@ module MCP
           raise ArgumentError, "Tool names should be between 1 and 128 characters in length (inclusive)."
         end
 
-        unless tool_name.match?(/\A[A-Za-z\d_\-\.]+\z/)
+        unless tool_name.match?(/\A[A-Za-z\d_\-.]+\z/)
           raise ArgumentError, <<~MESSAGE
             Tool names only allowed characters: uppercase and lowercase ASCII letters (A-Z, a-z), digits (0-9), underscore (_), hyphen (-), and dot (.).
           MESSAGE

data/lib/mcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  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.5.1
+  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
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: The official Ruby SDK for Model Context Protocol servers and clients
 test_files: []