mcp 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 255e316335616783063d8a7374f385ff10b99c9ddef24571734e19b6ec6f5f93
-  data.tar.gz: 07021e227f5b1be05fd2c1e4dc88e0d563bc963b6f1190f998aa632ed6871031
+  metadata.gz: e99b2f4d4d5727123d1ae167586134b1f06498f975ed2b16cb2f7e1c413d1271
+  data.tar.gz: 9ea2939b0f5fd94cad620376561def6cc0db832f0f62f990cdf66799c91c3bb6
 SHA512:
-  metadata.gz: 3d496817c30ae59b7f99704fead73cc9dfe5d926a87455a5c51fcc766bdf299d943ce86c0d43ca859d870a488df191cc0a4bdeba302b95d8ebcf084730743a68
-  data.tar.gz: 6291785257c054baf3570fb9baef4ecb1db006c920608ad69239460e2494610fa9133341bdf903a4c127f7ab40146f2bf9eecb34266621cba172a08ef52812f0
+  metadata.gz: acc1d2aa4fa8c76b2028cf2cc74b806b08ffc3e42a1e41d48326c53145fc6d3c95e6e724db9960e808b5c2f80330d4973caec143d97bf644f0f800348782476c
+  data.tar.gz: ddf8af09d31cb72577ceb3b4f2ef7fb90f0e813790966d532cc82690d9e9f56847cf8f391c36e860c6f51747dd795394f943941d6ecb44045e9ba424819b5854

data/lib/json_rpc_handler.rb

@@ -53,7 +53,9 @@ module JsonRpcHandler
     end
   end
 
-  def handle_json(request_json, id_validation_pattern: DEFAULT_ALLOWED_ID_CHARACTERS, &method_finder)
+  # `on_generate_error`, when given, is called with the `JSON::GeneratorError` of a response that cannot be generated,
+  # before that response is replaced with Internal error.
+  def handle_json(request_json, id_validation_pattern: DEFAULT_ALLOWED_ID_CHARACTERS, on_generate_error: nil, &method_finder)
     begin
       begin
         request = JSON.parse(request_json, symbolize_names: true)
@@ -77,7 +79,35 @@ module JsonRpcHandler
       })
     end
 
-    response&.to_json
+    begin
+      response&.to_json
+    rescue JSON::GeneratorError => e
+      on_generate_error&.call(e)
+      encodable_response(response, id_validation_pattern: id_validation_pattern).to_json
+    end
+  end
+
+  # `response` with each part JSON cannot generate replaced with Internal error. A batch is replaced item by item,
+  # so the other items keep their results.
+  def encodable_response(response, id_validation_pattern: nil)
+    return response.map { |item| encodable_response(item, id_validation_pattern: id_validation_pattern) } if response.is_a?(Array)
+
+    response.to_json
+    response
+  rescue JSON::GeneratorError
+    internal_error_for(response, id_validation_pattern: id_validation_pattern)
+  end
+
+  # The error answering a request whose response cannot be generated: a result or an error holding a string that
+  # is not valid UTF-8, typically one the request carried and the SDK or a handler repeated, such as a tool name
+  # in its Tool not found error. It carries the request id when the response has one, which was validated before
+  # the method ran.
+  def internal_error_for(response, id_validation_pattern: nil)
+    id = response[:id] if response.is_a?(Hash)
+    error_response(id: id.nil? ? :unknown_id : id, id_validation_pattern: id_validation_pattern, error: {
+      code: ErrorCode::INTERNAL_ERROR,
+      message: "Internal error",
+    })
   end
 
   def process_request(request, id_validation_pattern:, &method_finder)

data/lib/mcp/client/stdio.rb

@@ -434,7 +434,7 @@ module MCP
           line = read_line(method, params)
           raise_connection_error!(method, params) if line.nil?
 
-          parsed = JSON.parse(line.strip)
+          parsed = JSON.parse(strip_frame(line))
 
           # A frame carrying `method` is a request or notification, never the awaited response,
           # whatever its id says: JSON-RPC id spaces are per sender, so a server-chosen ping id
@@ -484,8 +484,10 @@ module MCP
         parsed["method"] == MCP::Methods::PING && json_rpc_id?(parsed["id"]) && JsonRpcHandler.valid_version?(parsed["jsonrpc"])
       end
 
+      # An id the pong could not write back is skipped too: a String that is not valid UTF-8, or a number
+      # such as `1e400`, which the parser reads as an infinite Float that JSON cannot represent.
       def json_rpc_id?(id)
-        id.is_a?(String) || id.is_a?(Numeric)
+        (id.is_a?(String) && id.valid_encoding?) || id.is_a?(Integer) || (id.is_a?(Float) && id.finite?)
       end
 
       def ensure_running!
@@ -534,6 +536,14 @@ module MCP
         )
       end
 
+      # Strips a frame as bytes. The server's stdout is read as UTF-8, and `String#strip` raises for a UTF-8 string
+      # holding an invalid byte at either end on every supported Ruby, and anywhere in it from Ruby 3.2 on, which would
+      # surface as that exception instead of the client's own error. As bytes, the frame reaches the parser, which
+      # refuses what is not JSON with the client's parse failure.
+      def strip_frame(line)
+        line.b.strip.force_encoding(Encoding::UTF_8)
+      end
+
       def raise_connection_error!(method, params)
         raise RequestHandlerError.new(
           "Server process closed stdout unexpectedly",

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

@@ -521,12 +521,19 @@ module MCP
           # a per-request sink for its ephemeral session and flushes it as SSE frames ahead of the final response.
           # Checked before the stateless guard, since modern requests are served in stateless deployments too.
           # The sink is bounded; past `MAX_MODERN_REQUEST_NOTIFICATIONS` the notification is dropped as
-          # non-delivery (`false`), never handed to the legacy paths below.
+          # non-delivery (`false`), never handed to the legacy paths below. It holds each notification as JSON,
+          # generated here so that one that cannot be generated is dropped on its own instead of failing
+          # the whole response when the sink is flushed.
           sink = @mutex.synchronize { session_id && @modern_request_sinks[session_id] }
           if sink
             return false if sink.size >= MAX_MODERN_REQUEST_NOTIFICATIONS
 
-            sink << notification
+            begin
+              sink << notification.to_json
+            rescue JSON::GeneratorError => e
+              MCP.configuration.exception_reporter.call(e, { session_id: session_id, error: "Failed to generate notification" })
+              return false
+            end
             return true
           end
 
@@ -931,16 +938,26 @@ module MCP
           # `nil` covers notifications and cancellation-suppressed responses; ack with 202 like the legacy notification path.
           return handle_accepted if response.nil?
 
+          # A response that cannot be generated answers its request with Internal error, as `JsonRpcHandler.handle_json`
+          # does on the legacy paths, instead of failing the whole exchange with a 500.
+          response_json = begin
+            response.to_json
+          rescue JSON::GeneratorError => e
+            MCP.configuration.exception_reporter.call(e, { error: "Failed to generate response" })
+            response = JsonRpcHandler.encodable_response(response)
+            response.to_json
+          end
+
           # Notifications a handler emitted during the request ride the request's own response stream as SSE frames ahead of
           # the final response (SEP-2575); a request that emitted none keeps the single JSON exchange and its HTTP status ladder.
           # Delivery is buffered: frames flush after the handler returns, preserving order but not real-time interleaving
           # (the TypeScript and Python SDKs stream live), and the sink grows with the handler's notification count.
           # Live streaming can follow without changing the wire shape.
           if notifications.empty?
-            [modern_http_status(response), { "content-type" => "application/json" }, [response.to_json]]
+            [modern_http_status(response), { "content-type" => "application/json" }, [response_json]]
           else
-            frames = notifications + [response]
-            sse_body = frames.map { |frame| "event: message\ndata: #{frame.to_json}\n\n" }.join
+            frames = notifications + [response_json]
+            sse_body = frames.map { |frame| "event: message\ndata: #{frame}\n\n" }.join
             [200, SSE_HEADERS.dup, [sse_body]]
           end
         rescue StandardError => e
@@ -1034,7 +1051,7 @@ module MCP
 
           begin
             if RequestEnvelope.modern?(params)
-              RequestEnvelope.parse!(params, request: params)
+              envelope = RequestEnvelope.parse!(params, request: params)
             else
               return invalid_request_response("Invalid Request: modern requests require the SEP-2575 `_meta` envelope")
             end
@@ -1074,7 +1091,7 @@ module MCP
             return too_many_listen_subscriptions_response(request_id)
           end
 
-          honored = honored_filter(filter)
+          honored = honored_filter(filter, meta: params[:_meta], envelope: envelope, auth_info: auth_info)
 
           # The acknowledgement echoes the honored filter, whose resource URIs are client-supplied strings,
           # so it is encoded before the stream is committed to: a URI that cannot be written as JSON is
@@ -1321,8 +1338,9 @@ module MCP
 
         # Per SEP-2575, the server MUST NOT send notification types the client has not requested,
         # and the acknowledgement only includes types the server actually supports
-        # (derived from its declared capabilities).
-        def honored_filter(filter)
+        # (derived from its declared capabilities). Resource URIs are further narrowed to those
+        # the server's `resources_subscribe_handler` accepts; the field is omitted when none remain.
+        def honored_filter(filter, meta: nil, envelope: nil, auth_info: nil)
           capabilities = @server.capabilities
           honored = {}
           honored[:toolsListChanged] = true if filter[:toolsListChanged] && capability_flag?(capabilities, :tools, :listChanged)
@@ -1331,7 +1349,8 @@ module MCP
 
           subscriptions = filter[:resourceSubscriptions]
           if capability_flag?(capabilities, :resources, :subscribe) && subscriptions.is_a?(Array) && !subscriptions.empty?
-            honored[:resourceSubscriptions] = subscriptions.uniq
+            uris = @server.subscribable_resource_uris(subscriptions, meta: meta, envelope: envelope, auth_info: auth_info)
+            honored[:resourceSubscriptions] = uris unless uris.empty?
           end
 
           honored

data/lib/mcp/server.rb

@@ -303,7 +303,8 @@ module MCP
     #   for the current request, as in `handle`.
     # @return [String, nil] The JSON-RPC response as JSON, or `nil` for notifications.
     def handle_json(request, session: nil, auth_info: nil)
-      JsonRpcHandler.handle_json(request, id_validation_pattern: nil) do |method, request_id|
+      on_generate_error = ->(error) { report_exception(error, { error: "Failed to generate response" }) }
+      JsonRpcHandler.handle_json(request, id_validation_pattern: nil, on_generate_error: on_generate_error) do |method, request_id|
         handle_request(request, method, session: session, related_request_id: request_id, auth_info: auth_info)
       end
     end
@@ -500,6 +501,36 @@ module MCP
       @handlers[Methods::RESOURCES_UNSUBSCRIBE] = block
     end
 
+    # Returns the distinct members of `uris` that the `resources_subscribe_handler` accepts, calling it once per URI
+    # with `{ uri: }`, plus `_meta` when given. `subscriptions/listen` takes the place of `resources/subscribe`
+    # in the 2026-07-28 lifecycle, so the handler keeps deciding which resources a client may follow there too.
+    # A URI the handler raises for is reported and left out, as the spec lets the acknowledgement honor a subset of
+    # what was requested; any return value accepts the URI and is otherwise discarded. The `server_context` has no session,
+    # related request id, or cancellation. Public only so that `StreamableHTTPTransport` can call it.
+    #
+    # @api private
+    # @param uris [Array<String>] The `resourceSubscriptions` of a `subscriptions/listen` request.
+    # @param meta [Hash, nil] The `_meta` of that request.
+    # @param envelope [MCP::RequestEnvelope, nil] The envelope of that request.
+    # @param auth_info [MCP::Server::OAuth::AccessToken, nil] The token that authenticated that request.
+    # @return [Array<String>]
+    def subscribable_resource_uris(uris, meta: nil, envelope: nil, auth_info: nil)
+      handler = @handlers[Methods::RESOURCES_SUBSCRIBE]
+
+      uris.uniq.select do |uri|
+        params = { uri: uri }
+        params[:_meta] = meta if meta
+        dispatch_optional_context_handler(handler, params, envelope: envelope, auth_info: auth_info)
+        true
+      rescue RequestHandlerError => e
+        report_exception(e.original_error || e, { request: params })
+        false
+      rescue => e
+        report_exception(e, { request: params })
+        false
+      end
+    end
+
     def build_sampling_params(
       capabilities,
       messages:,

data/lib/mcp/server_session.rb

@@ -275,14 +275,14 @@ module MCP
     def notify_elicitation_complete(elicitation_id:)
       send_to_transport(Methods::NOTIFICATIONS_ELICITATION_COMPLETE, { elicitationId: elicitation_id })
     rescue => e
-      @server.report_exception(e, notification: "elicitation_complete")
+      @server.configuration.exception_reporter.call(e, { notification: "elicitation_complete" })
     end
 
     # Sends a resource updated notification to this session only.
     def notify_resources_updated(uri:)
       send_to_transport(Methods::NOTIFICATIONS_RESOURCES_UPDATED, { "uri" => uri })
     rescue => e
-      @server.report_exception(e, notification: "resources_updated")
+      @server.configuration.exception_reporter.call(e, { notification: "resources_updated" })
     end
 
     # Sends a progress notification to this session only.
@@ -296,7 +296,7 @@ module MCP
 
       send_to_transport(Methods::NOTIFICATIONS_PROGRESS, params, related_request_id: related_request_id)
     rescue => e
-      @server.report_exception(e, notification: "progress")
+      @server.configuration.exception_reporter.call(e, { notification: "progress" })
     end
 
     # Sends a log message notification to this session only.
@@ -320,7 +320,7 @@ module MCP
 
       send_to_transport(Methods::NOTIFICATIONS_MESSAGE, params, related_request_id: related_request_id)
     rescue => e
-      @server.report_exception(e, { notification: "log_message" })
+      @server.configuration.exception_reporter.call(e, { notification: "log_message" })
     end
 
     private

data/lib/mcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
 platform: ruby
 authors:
 - Model Context Protocol
@@ -119,7 +119,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v1.8.1
+  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v1.8.2
   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