ruby-mcp-client 2.1.0 → 3.0.0

data/lib/mcp_client/result_completeness.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # The guard an operation runs before it projects a payload out of a result.
+  #
+  # An unfinished answer (MCP 2026-07-28 InputRequiredResult) that reaches
+  # such an operation would lose the server's inputRequests and its opaque
+  # requestState, and would be presented as an empty successful answer. The
+  # resolver that wraps every request drives the round trips a modern server
+  # asks for, so what reaches here is either finished or something no
+  # resolver claims; this is the backstop for the latter.
+  module ResultCompleteness
+    private
+
+    # @param result [Object] the JSON-RPC result
+    # @param method [String] the request method, for the message
+    # @return [Object] the result, when it is complete
+    # @raise [MCPClient::Errors::InputRequiredError] when it is unfinished --
+    #   the whole result rides on the error's `data`, so a host can drive the
+    #   round trip itself
+    # @raise [MCPClient::Errors::InvalidResultError] for any other
+    #   discriminator this client cannot carry through
+    def require_complete_result!(result, method)
+      type = MCPClient::JsonRpcCommon.result_type(result)
+      return result if type == 'complete'
+
+      message = "#{method} answered with resultType #{type.to_s[0, 64].inspect}, which this " \
+                'client cannot carry through'
+      raise MCPClient::Errors::InputRequiredError.new(message, data: result) if type == 'input_required'
+
+      raise MCPClient::Errors::InvalidResultError.new("Invalid result: #{message}", data: result)
+    end
+  end
+end

data/lib/mcp_client/root.rb

@@ -5,6 +5,12 @@ require 'uri'
 module MCPClient
   # Represents an MCP Root - a URI that defines a boundary where servers can operate
   # Roots are declared by clients to inform servers about relevant resources and their locations
+  #
+  # @deprecated Roots is deprecated since MCP 2026-07-28 (SEP-2577); earliest
+  #   removal is the first revision released on or after 2027-07-28. The class
+  #   keeps working for as long as the feature does, and building one raises no
+  #   notice — using the list does. Pass directories or files through tool
+  #   parameters, resource URIs or server configuration instead.
   class Root
     attr_reader :uri, :name, :meta
 

data/lib/mcp_client/round_trip_marker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Whether the request a thread last resolved went through a multi
+  # round-trip retry (MCP 2026-07-28 InputRequiredResult). A result that
+  # depended on input responses MUST NOT be cached, and the marker is
+  # thread-local because a transport serves concurrent requests: another
+  # request completing meanwhile says nothing about this one.
+  module RoundTripMarker
+    private
+
+    # @return [Boolean]
+    def last_result_from_round_trip?
+      Thread.current[round_trip_marker_key] == true
+    end
+
+    # @param flag [Boolean]
+    # @return [void]
+    def mark_round_trip_result(flag)
+      Thread.current[round_trip_marker_key] = flag
+    end
+
+    # @return [Symbol] the thread-local key of this transport's round-trip marker
+    def round_trip_marker_key
+      :"mcp_client_round_trip_#{object_id}"
+    end
+  end
+end

data/lib/mcp_client/schema_validator/annotations.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # What the schemas applied to one instance value evaluated of it: the
+    # annotation results `unevaluatedProperties` and `unevaluatedItems` read
+    # (JSON Schema 2020-12 Core Sections 11.2 and 11.3). One is kept per
+    # application of a schema to an object or an array, filled in by the
+    # keywords the node evaluates itself (`properties`, `patternProperties`,
+    # `additionalProperties`, `prefixItems`, `items`, `contains` and the two
+    # keywords themselves) and merged from every in-place applicator whose
+    # subschema passed — a failed subschema annotates nothing, and a cousin
+    # (a sibling branch of the same composition) never sees it.
+    class Evaluated
+      def initialize
+        @all = false
+        @names = {}
+        @prefix = 0
+        @indices = {}
+      end
+
+      # @return [Boolean] whether every member or item was evaluated
+      def all?
+        @all
+      end
+
+      # Every member or item is evaluated (an `items` schema, an
+      # `additionalProperties` schema, or the unevaluated keyword itself).
+      # @return [void]
+      def all!
+        @all = true
+      end
+
+      # @param name [Object] a property name (either key form)
+      # @return [void]
+      def name!(name)
+        @names[name.to_s] = true unless @all
+      end
+
+      # @param count [Integer] how many leading items a tuple evaluated
+      # @return [void]
+      def prefix!(count)
+        @prefix = count if count > @prefix
+      end
+
+      # @param index [Integer] an item `contains` matched
+      # @return [void]
+      def index!(index)
+        @indices[index] = true unless @all
+      end
+
+      # @param name [Object] a property name (either key form)
+      # @return [Boolean] whether the member was evaluated
+      def property?(name)
+        @all || @names.key?(name.to_s)
+      end
+
+      # @param index [Integer]
+      # @return [Boolean] whether the item was evaluated
+      def item?(index)
+        @all || index < @prefix || @indices.key?(index)
+      end
+
+      # Take over what a passed subschema evaluated of the same value.
+      # @param other [Evaluated, nil]
+      # @return [Evaluated] self
+      def merge!(other)
+        return self if other.nil?
+        return all! || self if other.all?
+
+        @names.merge!(other.names)
+        @prefix = other.prefix if other.prefix > @prefix
+        @indices.merge!(other.indices)
+        self
+      end
+
+      protected
+
+      attr_reader :names, :prefix, :indices
+    end
+  end
+end

data/lib/mcp_client/schema_validator/composition.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # How complete a verdict on one value is. Extended into SchemaValidator,
+    # so the methods are its own; {Evaluation} applies the composition
+    # keywords themselves and reads the answers here.
+    #
+    # A composition branch is evaluated speculatively (its errors are a
+    # verdict, not output). anyOf and allOf are monotonic, so a branch that
+    # passes as far as the validator can evaluate it is accepted; not, oneOf
+    # and if are not, so a branch that still holds an unevaluated assertion
+    # applying to the instance is :undecided and never a match, while one
+    # decided by its evaluated keywords (or carrying only annotations) is a
+    # full verdict.
+    #
+    # Every standard assertion whose verdict this validator can reach is
+    # evaluated ({Instances#validate_object},
+    # {Instances#validate_array}, {Scalars#validate_number},
+    # and the unevaluated keywords from the annotations {Evaluation}
+    # collects), so what is left here is only what genuinely cannot be
+    # decided: a dynamic reference whose target the dynamic scope could
+    # re-bind, and `format` where it asserts.
+    module Composition
+      # Whether a schema object carries an assertion the validator does not
+      # evaluate (in the dialect in force) that applies to this instance, so
+      # its verdict is only partial. Annotations (`format` in 2019-09 and
+      # 2020-12, `contentSchema`) decide nothing and leave the verdict whole;
+      # draft-07 `format` asserts (Validation Section 7.2), and the validator
+      # does not evaluate formats, so a string branch carrying one is
+      # undecided there. Dynamic references are evaluated, against the
+      # dynamic scope, and leave no verdict partial.
+      # @param schema [Hash] the schema object
+      # @param dialect [String, nil] the dialect in force at it
+      # @param data [Object] the instance
+      # @param _ctx [Context] the validation context
+      # @return [Boolean]
+      def partial_keywords?(schema, dialect, data, _ctx)
+        dialect == DRAFT_07 && data.is_a?(String) && schema.key?('format')
+      end
+
+      # The number of matching items `contains` requires: its companion
+      # where the dialect defines one and gives it a number, else the
+      # default of 1 (JSON Schema 2020-12 Validation Section 6.4.4).
+      # @return [Numeric]
+      def contains_min(schema, dialect)
+        min = schema['minContains'] if keyword_known?('minContains', dialect)
+        min.is_a?(Numeric) ? min : 1
+      end
+
+      # @return [Numeric, nil] the number of matching items `contains`
+      #   allows, when the dialect defines the companion and it is a number
+      def contains_max(schema, dialect)
+        max = schema['maxContains'] if keyword_known?('maxContains', dialect)
+        max if max.is_a?(Numeric)
+      end
+
+      # @param data [Hash] the instance
+      # @param name [Object] the property name a schema keyword names
+      # @return [Boolean] whether the instance carries the property in either
+      #   key form
+      def property_present?(data, name)
+        name = name.to_s
+        data.key?(name) || data.key?(name.to_sym)
+      end
+
+      # Match a server-supplied pattern against a property name. Both come
+      # from the peer, so — exactly like {.validate_pattern} — the match runs
+      # under the validation-wide deadline: a backtracking expression here
+      # must not be able to hold the calling thread.
+      # @param deadline [Float, nil] monotonic deadline for the whole validation
+      # @return [Boolean]
+      # @raise [Aborted] when the budget is exhausted
+      def pattern_matches?(pattern, name, deadline = nil)
+        remaining = pattern_budget_remaining(deadline)
+        raise Aborted, "validation time budget exhausted before pattern #{clip(pattern.inspect)}" if remaining.zero?
+
+        ecma_regexp(pattern, remaining, deadline).match?(name)
+      rescue Regexp::TimeoutError
+        raise Aborted, "pattern #{clip(pattern.inspect)} exceeded the #{PATTERN_MATCH_TIMEOUT}s matching budget"
+      rescue RegexpError, TypeError
+        false
+      end
+    end
+  end
+end

data/lib/mcp_client/schema_validator/dialects.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # Dialect selection: the `$schema` a document (or an embedded resource
+    # root) declares, its canonical supported form, and the problems an
+    # unusable declaration reports. Extended into SchemaValidator, so the
+    # methods are its own.
+    module Dialects
+      # The dialect a schema declares, or the default.
+      # @param schema [Object] the schema
+      # @return [String] the `$schema` value (without a trailing `#`), or DEFAULT_DIALECT
+      def dialect(schema)
+        return DEFAULT_DIALECT unless schema.is_a?(Hash)
+        return DEFAULT_DIALECT unless schema.key?('$schema') || schema.key?(:$schema)
+
+        declared = schema.key?('$schema') ? schema['$schema'] : schema[:$schema]
+        # A declaration that is present but unusable is not the default.
+        return nil unless declared.is_a?(String) && !declared.empty?
+
+        declared.sub(/#\z/, '')
+      end
+
+      # The supported dialect a declared URI stands for (scheme-insensitive),
+      # or nil.
+      # @param uri [String]
+      # @return [String, nil]
+      def canonical_dialect(uri)
+        canonical = uri.sub(/#\z/, '').sub(%r{\Ahttps?://}, '')
+        SUPPORTED_DIALECTS.find { |d| d.sub(%r{\Ahttps?://}, '') == canonical }
+      end
+
+      # @param uri [String]
+      # @return [Boolean]
+      def supported_dialect?(uri)
+        !canonical_dialect(uri).nil?
+      end
+
+      # The dialect in force at a schema object: an embedded resource root (a
+      # subschema whose `$id` is a URI) may declare its own `$schema`, which
+      # is that resource's dialect (JSON Schema 2020-12 Core Section 8.1.1);
+      # anywhere else the inherited dialect applies (a `$schema` that is not
+      # at a resource root is ignored).
+      # @param schema [Hash]
+      # @param inherited [String, nil] the enclosing resource's dialect
+      # @return [String, nil] the canonical dialect, or nil when the embedded
+      #   declaration is malformed or unsupported
+      def embedded_dialect(schema, inherited)
+        return inherited unless resource_root?(schema, inherited) && schema.key?('$schema')
+
+        declared = dialect(schema)
+        declared && canonical_dialect(declared)
+      end
+
+      # @return [String, nil] why an embedded resource's `$schema` is unusable
+      def embedded_dialect_problem(schema)
+        declared = dialect(schema)
+        return 'embedded resource $schema must be a non-empty string naming the dialect' if declared.nil?
+        return nil if supported_dialect?(declared)
+
+        "embedded resource dialect #{clip(declared.inspect)} is not supported " \
+          "(supported: #{SUPPORTED_DIALECTS.join(', ')})"
+      end
+    end
+  end
+end