mcp 0.23.0 → 0.24.0

data/lib/mcp/resource.rb

@@ -5,6 +5,141 @@ require_relative "resource/embedded"
 
 module MCP
   class Resource
+    class << self
+      NOT_SET = Object.new
+
+      attr_reader :uri_value
+      attr_reader :title_value
+      attr_reader :description_value
+      attr_reader :icons_value
+      attr_reader :mime_type_value
+      attr_reader :annotations_value
+      attr_reader :size_value
+      attr_reader :meta_value
+
+      def contents(server_context: nil)
+        raise NotImplementedError, "Subclasses must implement contents"
+      end
+
+      def to_h
+        {
+          uri: uri_value,
+          name: name_value,
+          title: title_value,
+          description: description_value,
+          icons: icons_value&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
+          mimeType: mime_type_value,
+          annotations: annotations_value&.to_h,
+          size: size_value,
+          _meta: meta_value,
+        }.compact
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@uri_value, nil)
+        subclass.instance_variable_set(:@name_value, nil)
+        subclass.instance_variable_set(:@title_value, nil)
+        subclass.instance_variable_set(:@description_value, nil)
+        subclass.instance_variable_set(:@icons_value, nil)
+        subclass.instance_variable_set(:@mime_type_value, nil)
+        subclass.instance_variable_set(:@annotations_value, nil)
+        subclass.instance_variable_set(:@size_value, nil)
+        subclass.instance_variable_set(:@meta_value, nil)
+      end
+
+      def uri(value = NOT_SET)
+        if value == NOT_SET
+          @uri_value
+        else
+          @uri_value = value
+        end
+      end
+
+      def resource_name(value = NOT_SET)
+        if value == NOT_SET
+          name_value
+        else
+          @name_value = value
+        end
+      end
+
+      def name_value
+        @name_value || (name.nil? ? nil : StringUtils.handle_from_class_name(name))
+      end
+
+      def title(value = NOT_SET)
+        if value == NOT_SET
+          @title_value
+        else
+          @title_value = value
+        end
+      end
+
+      def description(value = NOT_SET)
+        if value == NOT_SET
+          @description_value
+        else
+          @description_value = value
+        end
+      end
+
+      def icons(value = NOT_SET)
+        if value == NOT_SET
+          @icons_value
+        else
+          @icons_value = value
+        end
+      end
+
+      def mime_type(value = NOT_SET)
+        if value == NOT_SET
+          @mime_type_value
+        else
+          @mime_type_value = value
+        end
+      end
+
+      def annotations(value = NOT_SET)
+        if value == NOT_SET
+          @annotations_value
+        else
+          @annotations_value = value.is_a?(Annotations) ? value : Annotations.new(**value)
+        end
+      end
+
+      def size(value = NOT_SET)
+        if value == NOT_SET
+          @size_value
+        else
+          @size_value = value
+        end
+      end
+
+      def meta(value = NOT_SET)
+        if value == NOT_SET
+          @meta_value
+        else
+          @meta_value = value
+        end
+      end
+
+      def define(uri: nil, name: nil, title: nil, description: nil, icons: [], mime_type: nil, annotations: nil, size: nil, meta: nil, &block)
+        Class.new(self) do
+          uri uri
+          resource_name name
+          title title
+          description description
+          icons icons
+          mime_type mime_type
+          self.annotations(annotations) if annotations
+          size size
+          meta meta
+          define_singleton_method(:contents, &block) if block
+        end
+      end
+    end
+
     attr_reader :uri, :name, :title, :description, :icons, :mime_type, :annotations, :size, :meta
 
     def initialize(uri:, name:, title: nil, description: nil, icons: [], mime_type: nil, annotations: nil, size: nil, meta: nil)

data/lib/mcp/resource_template.rb

@@ -2,6 +2,155 @@
 
 module MCP
   class ResourceTemplate
+    class << self
+      NOT_SET = Object.new
+
+      # Applied after `Regexp.escape`, which turns `{` and `}` into `\{` and `\}`.
+      # Variable names are restricted to valid Regexp named-group names,
+      # so RFC 6570 operator expressions (e.g. `{?query}`) stay literal and never match.
+      VARIABLE_PATTERN = /\\\{([A-Za-z_]\w*)\\\}/
+
+      attr_reader :uri_template_value
+      attr_reader :title_value
+      attr_reader :description_value
+      attr_reader :icons_value
+      attr_reader :mime_type_value
+      attr_reader :annotations_value
+      attr_reader :meta_value
+
+      def contents(server_context: nil, **params)
+        raise NotImplementedError, "Subclasses must implement contents"
+      end
+
+      def to_h
+        {
+          uriTemplate: uri_template_value,
+          name: name_value,
+          title: title_value,
+          description: description_value,
+          icons: icons_value&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
+          mimeType: mime_type_value,
+          annotations: annotations_value&.to_h,
+          _meta: meta_value,
+        }.compact
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@uri_template_value, nil)
+        subclass.instance_variable_set(:@uri_template_pattern, nil)
+        subclass.instance_variable_set(:@name_value, nil)
+        subclass.instance_variable_set(:@title_value, nil)
+        subclass.instance_variable_set(:@description_value, nil)
+        subclass.instance_variable_set(:@icons_value, nil)
+        subclass.instance_variable_set(:@mime_type_value, nil)
+        subclass.instance_variable_set(:@annotations_value, nil)
+        subclass.instance_variable_set(:@meta_value, nil)
+      end
+
+      def uri_template(value = NOT_SET)
+        if value == NOT_SET
+          @uri_template_value
+        else
+          @uri_template_pattern = nil
+          @uri_template_value = value
+        end
+      end
+
+      def resource_template_name(value = NOT_SET)
+        if value == NOT_SET
+          name_value
+        else
+          @name_value = value
+        end
+      end
+
+      def name_value
+        @name_value || (name.nil? ? nil : StringUtils.handle_from_class_name(name))
+      end
+
+      def title(value = NOT_SET)
+        if value == NOT_SET
+          @title_value
+        else
+          @title_value = value
+        end
+      end
+
+      def description(value = NOT_SET)
+        if value == NOT_SET
+          @description_value
+        else
+          @description_value = value
+        end
+      end
+
+      def icons(value = NOT_SET)
+        if value == NOT_SET
+          @icons_value
+        else
+          @icons_value = value
+        end
+      end
+
+      def mime_type(value = NOT_SET)
+        if value == NOT_SET
+          @mime_type_value
+        else
+          @mime_type_value = value
+        end
+      end
+
+      def annotations(value = NOT_SET)
+        if value == NOT_SET
+          @annotations_value
+        else
+          @annotations_value = value.is_a?(Annotations) ? value : Annotations.new(**value)
+        end
+      end
+
+      def meta(value = NOT_SET)
+        if value == NOT_SET
+          @meta_value
+        else
+          @meta_value = value
+        end
+      end
+
+      # Matches a concrete URI against the template's simple RFC 6570 level-1 `{var}` expressions.
+      # Returns a symbol-keyed Hash of variable values, or `nil` if the URI does not match.
+      # Variables match one or more characters excluding `/`, and values are not percent-decoded.
+      def match_uri(uri)
+        match = uri_template_pattern&.match(uri)
+        match&.named_captures&.transform_keys(&:to_sym)
+      end
+
+      def define(uri_template: nil, name: nil, title: nil, description: nil, icons: [], mime_type: nil, annotations: nil, meta: nil, &block)
+        Class.new(self) do
+          uri_template uri_template
+          resource_template_name name
+          title title
+          description description
+          icons icons
+          mime_type mime_type
+          self.annotations(annotations) if annotations
+          meta meta
+          define_singleton_method(:contents, &block) if block
+        end
+      end
+
+      private
+
+      def uri_template_pattern
+        return if uri_template.nil?
+
+        @uri_template_pattern ||= begin
+          pattern = Regexp.escape(uri_template).gsub(VARIABLE_PATTERN) { "(?<#{Regexp.last_match(1)}>[^/]+)" }
+          Regexp.new("\\A#{pattern}\\z")
+        end
+      end
+    end
+
     attr_reader :uri_template, :name, :title, :description, :icons, :mime_type, :annotations, :meta
 
     def initialize(uri_template:, name:, title: nil, description: nil, icons: [], mime_type: nil, annotations: nil, meta: nil)

data/lib/mcp/result_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MCP
+  # Values of the `resultType` result field introduced by SEP-2322 (Multi Round-Trip Requests)
+  # for the MCP 2026-07-28 draft.
+  #
+  # A result with `resultType: "input_required"` is not a final answer: it carries an `inputRequests` map
+  # of server-to-client requests (`sampling/createMessage`, `roots/list`, `elicitation/create` shapes) plus
+  # an opaque `requestState` string, and the client is expected to fulfill the requests and re-issue
+  # the original request with `inputResponses` and the echoed `requestState`. A missing `resultType`
+  # or `"complete"` is a final result.
+  #
+  # https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2322
+  module ResultType
+    COMPLETE = "complete"
+    INPUT_REQUIRED = "input_required"
+  end
+end

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

@@ -196,80 +196,107 @@ module MCP
           }
           notification[:params] = params if params
 
+          if session_id
+            deliver_targeted_notification(notification, session_id, related_request_id)
+          else
+            deliver_broadcast_notification(notification)
+          end
+        end
+
+        def deliver_targeted_notification(notification, session_id, related_request_id)
+          # JSON response mode returns a single JSON object as the POST response,
+          # so request-scoped notifications (e.g. progress, log) cannot be delivered
+          # alongside it. Session-scoped standalone notifications
+          # (e.g. `resources/updated`, `elicitation/complete`) still flow via GET SSE.
+          return false if @enable_json_response && related_request_id
+
           streams_to_close = []
 
-          result = @mutex.synchronize do
-            if session_id
-              # JSON response mode returns a single JSON object as the POST response,
-              # so request-scoped notifications (e.g. progress, log) cannot be delivered
-              # alongside it. Session-scoped standalone notifications
-              # (e.g. `resources/updated`, `elicitation/complete`) still flow via GET SSE.
-              next false if @enable_json_response && related_request_id
-
-              # Send to specific session
-              if (session = @sessions[session_id])
-                stream = active_stream(session, related_request_id: related_request_id)
-              end
-              next false unless stream
+          # Resolve the target stream under the lock, then write outside it: a stalled SSE reader
+          # must not block every other session that needs `@mutex`.
+          stream = @mutex.synchronize do
+            next unless (session = @sessions[session_id])
+
+            if session_expired?(session)
+              cleanup_and_collect_stream(session_id, streams_to_close)
+              next
+            end
+
+            active_stream(session, related_request_id: related_request_id)
+          end
+
+          close_streams(streams_to_close)
+          return false unless stream
+
+          write_notification(stream, notification, session_id, related_request_id)
+        end
+
+        def deliver_broadcast_notification(notification)
+          streams_to_close = []
+
+          # Snapshot the connected streams under the lock, then write to each outside it.
+          targets = @mutex.synchronize do
+            expired_session_ids = []
+
+            collected = @sessions.filter_map do |session_id, session|
+              next unless (stream = session[:get_sse_stream])
 
               if session_expired?(session)
-                cleanup_and_collect_stream(session_id, streams_to_close)
-                next false
+                expired_session_ids << session_id
+                next
               end
 
-              begin
-                send_to_stream(stream, notification)
-                true
-              rescue *STREAM_WRITE_ERRORS => e
-                MCP.configuration.exception_reporter.call(
-                  e,
-                  { session_id: session_id, error: "Failed to send notification" },
-                )
-                if related_request_id && session[:post_request_streams]&.key?(related_request_id)
-                  session[:post_request_streams].delete(related_request_id)
-                  streams_to_close << stream
-                else
-                  cleanup_and_collect_stream(session_id, streams_to_close)
-                end
-                false
-              end
-            else
-              # Broadcast to all connected SSE sessions
-              sent_count = 0
-              failed_sessions = []
+              [session_id, stream]
+            end
 
-              @sessions.each do |sid, session|
-                next unless (stream = session[:get_sse_stream])
+            expired_session_ids.each do |session_id|
+              cleanup_and_collect_stream(session_id, streams_to_close)
+            end
 
-                if session_expired?(session)
-                  failed_sessions << sid
-                  next
-                end
+            collected
+          end
 
-                begin
-                  send_to_stream(stream, notification)
-                  sent_count += 1
-                rescue *STREAM_WRITE_ERRORS => e
-                  MCP.configuration.exception_reporter.call(
-                    e,
-                    { session_id: sid, error: "Failed to send notification" },
-                  )
-                  failed_sessions << sid
-                end
-              end
+          close_streams(streams_to_close)
+
+          targets.count do |session_id, stream|
+            write_notification(stream, notification, session_id, nil)
+          end
+        end
+
+        # Writes a notification to an SSE stream without holding `@mutex`. On a write error,
+        # drops the broken stream and returns false; on success returns true.
+        def write_notification(stream, notification, session_id, related_request_id)
+          send_to_stream(stream, notification)
+          true
+        rescue *STREAM_WRITE_ERRORS => e
+          MCP.configuration.exception_reporter.call(e, { session_id: session_id, error: "Failed to send notification" })
+          drop_broken_stream(session_id, stream, related_request_id)
+          false
+        end
 
-              # Clean up failed sessions
-              failed_sessions.each { |sid| cleanup_and_collect_stream(sid, streams_to_close) }
+        # Removes a stream that failed to accept a write. A request-scoped stream is dropped on its own;
+        # a session-scoped (GET SSE) failure tears down the whole session. The `@sessions` mutation runs
+        # under `@mutex`, and the affected streams are closed outside it.
+        def drop_broken_stream(session_id, stream, related_request_id)
+          streams_to_close = []
 
-              sent_count
+          @mutex.synchronize do
+            session = @sessions[session_id]
+            if related_request_id && session&.dig(:post_request_streams, related_request_id)
+              session[:post_request_streams].delete(related_request_id)
+              streams_to_close << stream
+            else
+              cleanup_and_collect_stream(session_id, streams_to_close)
             end
           end
 
-          streams_to_close.each do |stream|
+          close_streams(streams_to_close)
+        end
+
+        def close_streams(streams)
+          streams.each do |stream|
             close_stream_safely(stream)
           end
-
-          result
         end
 
         # Sends a server-to-client JSON-RPC request (e.g., `sampling/createMessage`) and
@@ -299,27 +326,25 @@ module MCP
           request = { jsonrpc: "2.0", id: request_id, method: method }
           request[:params] = params if params
 
-          sent = false
-
-          @mutex.synchronize do
+          # Register the pending response and resolve the stream under the lock, but perform
+          # the write outside it so a stalled reader cannot block every other session on `@mutex`.
+          stream = @mutex.synchronize do
             unless (session = @sessions[session_id])
               raise "Session not found: #{session_id}."
             end
 
             @pending_responses[request_id] = { queue: queue, session_id: session_id }
 
-            if (stream = active_stream(session, related_request_id: related_request_id))
-              begin
-                send_to_stream(stream, request)
-                sent = true
-              rescue *STREAM_WRITE_ERRORS
-                if related_request_id && session[:post_request_streams]&.key?(related_request_id)
-                  session[:post_request_streams].delete(related_request_id)
-                  close_stream_safely(stream)
-                else
-                  cleanup_session_unsafe(session_id)
-                end
-              end
+            active_stream(session, related_request_id: related_request_id)
+          end
+
+          sent = false
+          if stream
+            begin
+              send_to_stream(stream, request)
+              sent = true
+            rescue *STREAM_WRITE_ERRORS
+              drop_broken_stream(session_id, stream, related_request_id)
             end
           end
 
@@ -461,7 +486,9 @@ module MCP
           # The `MCP-Protocol-Version` header is only meaningful after negotiation, so on `initialize`
           # the JSON-RPC body `params.protocolVersion` is authoritative and the header (if any) is ignored.
           # This matches the TypeScript and Python SDKs.
-          unless initialize_request?(body)
+          # `server/discover` (SEP-2575) is likewise exempt: it is sessionless capability discovery that
+          # happens before (or instead of) negotiation.
+          unless initialize_request?(body) || discover_request?(body)
             return missing_session_id_response if !@stateless && !session_id
 
             protocol_version_error = validate_protocol_version_header(request)
@@ -712,6 +739,10 @@ module MCP
           body.is_a?(Hash) && body[:method] == Methods::INITIALIZE
         end
 
+        def discover_request?(body)
+          body.is_a?(Hash) && body[:method] == Methods::SERVER_DISCOVER
+        end
+
         def validate_protocol_version_header(request)
           header_value = request.env["HTTP_MCP_PROTOCOL_VERSION"] || MCP::Configuration::DEFAULT_NEGOTIATED_PROTOCOL_VERSION
           return if MCP::Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(header_value)
@@ -1158,11 +1189,15 @@ module MCP
         end
 
         def send_keepalive_ping(session_id)
-          @mutex.synchronize do
-            if @sessions[session_id] && @sessions[session_id][:get_sse_stream]
-              send_ping_to_stream(@sessions[session_id][:get_sse_stream])
-            end
+          # Resolve the stream under the lock, then write outside it so a stalled reader
+          # cannot block every other session on `@mutex`.
+          stream = @mutex.synchronize do
+            session = @sessions[session_id]
+            session && session[:get_sse_stream]
           end
+          return unless stream
+
+          send_ping_to_stream(stream)
         rescue *STREAM_WRITE_ERRORS => e
           MCP.configuration.exception_reporter.call(
             e,