ruby-mcp-client 0.9.1 → 1.0.1

data/lib/mcp_client/client.rb

@@ -25,7 +25,7 @@ module MCPClient
     # @param logger [Logger, nil] optional logger, defaults to STDOUT
     # @param elicitation_handler [Proc, nil] optional handler for elicitation requests (MCP 2025-06-18)
     # @param roots [Array<MCPClient::Root, Hash>, nil] optional list of roots (MCP 2025-06-18)
-    # @param sampling_handler [Proc, nil] optional handler for sampling requests (MCP 2025-06-18)
+    # @param sampling_handler [Proc, nil] optional handler for sampling requests (MCP 2025-11-25)
     def initialize(mcp_server_configs: [], logger: nil, elicitation_handler: nil, roots: nil, sampling_handler: nil)
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
       @logger.progname = self.class.name
@@ -41,7 +41,7 @@ module MCPClient
       @notification_listeners = []
       # Elicitation handler (MCP 2025-06-18)
       @elicitation_handler = elicitation_handler
-      # Sampling handler (MCP 2025-06-18)
+      # Sampling handler (MCP 2025-11-25)
       @sampling_handler = sampling_handler
       # Roots (MCP 2025-06-18)
       @roots = normalize_roots(roots)
@@ -59,7 +59,7 @@ module MCPClient
         end
         # Register roots list handler on each server (MCP 2025-06-18)
         server.on_roots_list_request(&method(:handle_roots_list_request)) if server.respond_to?(:on_roots_list_request)
-        # Register sampling handler on each server (MCP 2025-06-18)
+        # Register sampling handler on each server (MCP 2025-11-25)
         server.on_sampling_request(&method(:handle_sampling_request)) if server.respond_to?(:on_sampling_request)
       end
     end
@@ -486,13 +486,85 @@ module MCPClient
     # Request completion suggestions from a server (MCP 2025-06-18)
     # @param ref [Hash] reference object (e.g., { 'type' => 'ref/prompt', 'name' => 'prompt_name' })
     # @param argument [Hash] the argument being completed (e.g., { 'name' => 'arg_name', 'value' => 'partial' })
+    # @param context [Hash, nil] optional context for the completion (MCP 2025-11-25),
+    #   e.g., { 'arguments' => { 'arg1' => 'value1' } } for previously-resolved arguments
     # @param server [Integer, String, Symbol, MCPClient::ServerBase, nil] server selector
     # @return [Hash] completion result with 'values', optional 'total', and 'hasMore' fields
     # @raise [MCPClient::Errors::ServerNotFound] if no server is available
     # @raise [MCPClient::Errors::ServerError] if server returns an error
-    def complete(ref:, argument:, server: nil)
+    def complete(ref:, argument:, context: nil, server: nil)
       srv = select_server(server)
-      srv.complete(ref: ref, argument: argument)
+      srv.complete(ref: ref, argument: argument, context: context)
+    end
+
+    # Create a new task on a server (MCP 2025-11-25)
+    # Tasks represent long-running operations that can report progress
+    # @param method [String] the method to execute as a task
+    # @param params [Hash] parameters for the task method
+    # @param progress_token [String, nil] optional token for receiving progress notifications
+    # @param server [Integer, String, Symbol, MCPClient::ServerBase, nil] server selector
+    # @return [MCPClient::Task] the created task
+    # @raise [MCPClient::Errors::ServerNotFound] if no server is available
+    # @raise [MCPClient::Errors::TaskError] if task creation fails
+    def create_task(method, params: {}, progress_token: nil, server: nil)
+      srv = select_server(server)
+      rpc_params = { method: method, params: params }
+      rpc_params[:progressToken] = progress_token if progress_token
+
+      begin
+        result = srv.rpc_request('tasks/create', rpc_params)
+        MCPClient::Task.from_json(result, server: srv)
+      rescue MCPClient::Errors::ServerError, MCPClient::Errors::TransportError, MCPClient::Errors::ConnectionError => e
+        raise MCPClient::Errors::TaskError, "Error creating task: #{e.message}"
+      end
+    end
+
+    # Get the current state of a task (MCP 2025-11-25)
+    # @param task_id [String] the ID of the task to query
+    # @param server [Integer, String, Symbol, MCPClient::ServerBase, nil] server selector
+    # @return [MCPClient::Task] the task with current state
+    # @raise [MCPClient::Errors::ServerNotFound] if no server is available
+    # @raise [MCPClient::Errors::TaskNotFound] if the task does not exist
+    # @raise [MCPClient::Errors::TaskError] if retrieving the task fails
+    def get_task(task_id, server: nil)
+      srv = select_server(server)
+
+      begin
+        result = srv.rpc_request('tasks/get', { id: task_id })
+        MCPClient::Task.from_json(result, server: srv)
+      rescue MCPClient::Errors::ServerError => e
+        if e.message.include?('not found') || e.message.include?('unknown task')
+          raise MCPClient::Errors::TaskNotFound, "Task '#{task_id}' not found"
+        end
+
+        raise MCPClient::Errors::TaskError, "Error getting task '#{task_id}': #{e.message}"
+      rescue MCPClient::Errors::TransportError, MCPClient::Errors::ConnectionError => e
+        raise MCPClient::Errors::TaskError, "Error getting task '#{task_id}': #{e.message}"
+      end
+    end
+
+    # Cancel a running task (MCP 2025-11-25)
+    # @param task_id [String] the ID of the task to cancel
+    # @param server [Integer, String, Symbol, MCPClient::ServerBase, nil] server selector
+    # @return [MCPClient::Task] the task with updated (cancelled) state
+    # @raise [MCPClient::Errors::ServerNotFound] if no server is available
+    # @raise [MCPClient::Errors::TaskNotFound] if the task does not exist
+    # @raise [MCPClient::Errors::TaskError] if cancellation fails
+    def cancel_task(task_id, server: nil)
+      srv = select_server(server)
+
+      begin
+        result = srv.rpc_request('tasks/cancel', { id: task_id })
+        MCPClient::Task.from_json(result, server: srv)
+      rescue MCPClient::Errors::ServerError => e
+        if e.message.include?('not found') || e.message.include?('unknown task')
+          raise MCPClient::Errors::TaskNotFound, "Task '#{task_id}' not found"
+        end
+
+        raise MCPClient::Errors::TaskError, "Error cancelling task '#{task_id}': #{e.message}"
+      rescue MCPClient::Errors::TransportError, MCPClient::Errors::ConnectionError => e
+        raise MCPClient::Errors::TaskError, "Error cancelling task '#{task_id}': #{e.message}"
+      end
     end
 
     # Set the logging level on all connected servers (MCP 2025-06-18)
@@ -606,7 +678,17 @@ module MCPClient
       required = schema['required'] || schema[:required]
       return unless required.is_a?(Array)
 
+      properties = schema['properties'] || schema[:properties] || {}
+
       missing = required.map(&:to_s) - parameters.keys.map(&:to_s)
+
+      # Exclude required params that have a default value in the schema,
+      # since the server will apply the default.
+      missing = missing.reject do |param|
+        prop = properties[param] || properties[param.to_sym]
+        prop.is_a?(Hash) && (prop.key?('default') || prop.key?(:default))
+      end
+
       return unless missing.any?
 
       raise MCPClient::Errors::ValidationError, "Missing required parameters: #{missing.join(', ')}"
@@ -683,7 +765,8 @@ module MCPClient
       end
     end
 
-    # Handle elicitation request from server (MCP 2025-06-18)
+    # Handle elicitation request from server (MCP 2025-11-25)
+    # Supports both form mode (structured data) and URL mode (out-of-band interaction).
     # @param _request_id [String, Integer] the JSON-RPC request ID (unused at client layer)
     # @param params [Hash] the elicitation parameters
     # @return [Hash] the elicitation response
@@ -694,43 +777,17 @@ module MCPClient
         return { 'action' => 'decline' }
       end
 
+      mode = params['mode'] || 'form'
       message = params['message']
-      schema = params['schema'] || params['requestedSchema']
-      metadata = params['metadata']
 
       begin
-        # Call the user-defined handler
-        result = case @elicitation_handler.arity
-                 when 0
-                   @elicitation_handler.call
-                 when 1
-                   @elicitation_handler.call(message)
-                 when 2, -1
-                   @elicitation_handler.call(message, schema)
+        result = if mode == 'url'
+                   handle_url_elicitation(params, message)
                  else
-                   @elicitation_handler.call(message, schema, metadata)
+                   handle_form_elicitation(params, message)
                  end
 
-        # Validate and format response
-        case result
-        when Hash
-          if result['action']
-            normalised_action_response(result)
-          elsif result[:action]
-            # Convert symbol keys to strings
-            {
-              'action' => result[:action].to_s,
-              'content' => result[:content]
-            }.compact.then { |payload| normalised_action_response(payload) }
-          else
-            # Assume it's content for an accept action
-            { 'action' => 'accept', 'content' => result }
-          end
-        when nil
-          { 'action' => 'cancel' }
-        else
-          { 'action' => 'accept', 'content' => result }
-        end
+        format_elicitation_response(result, params)
       rescue StandardError => e
         @logger.error("Elicitation handler error: #{e.message}")
         @logger.debug(e.backtrace.join("\n"))
@@ -738,6 +795,103 @@ module MCPClient
       end
     end
 
+    # Handle form mode elicitation (MCP 2025-11-25)
+    # @param params [Hash] the elicitation parameters
+    # @param message [String] the human-readable message
+    # @return [Object] handler result
+    def handle_form_elicitation(params, message)
+      schema = params['requestedSchema'] || params['schema']
+      metadata = params['metadata']
+
+      # Validate schema if present
+      if schema
+        schema_errors = ElicitationValidator.validate_schema(schema)
+        @logger.warn("Elicitation schema validation warnings: #{schema_errors.join('; ')}") unless schema_errors.empty?
+      end
+
+      # Call the user-defined handler
+      case @elicitation_handler.arity
+      when 0
+        @elicitation_handler.call
+      when 1
+        @elicitation_handler.call(message)
+      when 2, -1
+        @elicitation_handler.call(message, schema)
+      else
+        @elicitation_handler.call(message, schema, metadata)
+      end
+    end
+
+    # Handle URL mode elicitation (MCP 2025-11-25)
+    # @param params [Hash] the elicitation parameters
+    # @param message [String] the human-readable message
+    # @return [Object] handler result
+    def handle_url_elicitation(params, message)
+      url = params['url']
+      elicitation_id = params['elicitationId']
+
+      # Call handler with URL-mode specific params
+      case @elicitation_handler.arity
+      when 0
+        @elicitation_handler.call
+      when 1
+        @elicitation_handler.call(message)
+      when 2, -1
+        @elicitation_handler.call(message, { 'mode' => 'url', 'url' => url, 'elicitationId' => elicitation_id })
+      else
+        @elicitation_handler.call(message, { 'mode' => 'url', 'url' => url, 'elicitationId' => elicitation_id },
+                                  params['metadata'])
+      end
+    end
+
+    # Format and validate the elicitation response
+    # @param result [Object] handler result
+    # @param params [Hash] original request params (for schema validation)
+    # @return [Hash] formatted response
+    def format_elicitation_response(result, params)
+      response = case result
+                 when Hash
+                   if result['action']
+                     normalised_action_response(result)
+                   elsif result[:action]
+                     {
+                       'action' => result[:action].to_s,
+                       'content' => result[:content]
+                     }.compact.then { |payload| normalised_action_response(payload) }
+                   else
+                     { 'action' => 'accept', 'content' => result }
+                   end
+                 when nil
+                   { 'action' => 'cancel' }
+                 else
+                   { 'action' => 'accept', 'content' => result }
+                 end
+
+      # Validate content against schema for form mode accept responses
+      validate_elicitation_content(response, params)
+
+      response
+    end
+
+    # Validate elicitation response content against the requestedSchema
+    # @param response [Hash] the formatted response
+    # @param params [Hash] original request params
+    # @return [void]
+    def validate_elicitation_content(response, params)
+      return unless response['action'] == 'accept' && response['content'].is_a?(Hash)
+
+      mode = params['mode'] || 'form'
+      return unless mode == 'form'
+
+      schema = params['requestedSchema'] || params['schema']
+      return unless schema.is_a?(Hash)
+
+      errors = ElicitationValidator.validate_content(response['content'], schema)
+      return if errors.empty?
+
+      @logger.warn("Elicitation content validation warnings: #{errors.join('; ')}")
+    end
+
     # Ensure the action value conforms to MCP spec (accept, decline, cancel)
     # Falls back to accept for unknown action values.
     def normalised_action_response(result)
@@ -785,9 +939,9 @@ module MCPClient
       end
     end
 
-    # Handle sampling/createMessage request from server (MCP 2025-06-18)
+    # Handle sampling/createMessage request from server (MCP 2025-11-25)
     # @param _request_id [String, Integer] the JSON-RPC request ID (unused, kept for callback signature)
-    # @param params [Hash] the sampling parameters (messages, modelPreferences, systemPrompt, maxTokens)
+    # @param params [Hash] the sampling parameters
     # @return [Hash] the sampling response (role, content, model, stopReason)
     def handle_sampling_request(_request_id, params)
       # If no handler is configured, return an error
@@ -797,24 +951,18 @@ module MCPClient
       end
 
       messages = params['messages'] || []
-      model_preferences = params['modelPreferences']
+      model_preferences = normalize_model_preferences(params['modelPreferences'])
       system_prompt = params['systemPrompt']
       max_tokens = params['maxTokens']
+      include_context = params['includeContext']
+      temperature = params['temperature']
+      stop_sequences = params['stopSequences']
+      metadata = params['metadata']
 
       begin
-        # Call the user-defined handler
-        result = case @sampling_handler.arity
-                 when 0
-                   @sampling_handler.call
-                 when 1
-                   @sampling_handler.call(messages)
-                 when 2
-                   @sampling_handler.call(messages, model_preferences)
-                 when 3
-                   @sampling_handler.call(messages, model_preferences, system_prompt)
-                 else
-                   @sampling_handler.call(messages, model_preferences, system_prompt, max_tokens)
-                 end
+        # Call the user-defined handler with parameters based on arity
+        result = call_sampling_handler(messages, model_preferences, system_prompt, max_tokens,
+                                       include_context, temperature, stop_sequences, metadata)
 
         # Validate and format response
         validate_sampling_response(result)
@@ -825,7 +973,70 @@ module MCPClient
       end
     end
 
-    # Validate sampling response from handler (MCP 2025-06-18)
+    # Call sampling handler with appropriate arity
+    # @param messages [Array] the messages
+    # @param model_preferences [Hash, nil] normalized model preferences
+    # @param system_prompt [String, nil] system prompt
+    # @param max_tokens [Integer, nil] max tokens
+    # @param include_context [String, nil] context inclusion setting
+    # @param temperature [Float, nil] temperature
+    # @param stop_sequences [Array, nil] stop sequences
+    # @param metadata [Hash, nil] metadata
+    # @return [Hash] the handler result
+    def call_sampling_handler(messages, model_preferences, system_prompt, max_tokens,
+                              include_context, temperature, stop_sequences, metadata)
+      arity = @sampling_handler.arity
+      # Normalize negative arity (optional params) to minimum required args
+      arity = -(arity + 1) if arity.negative?
+      case arity
+      when 0
+        @sampling_handler.call
+      when 1
+        @sampling_handler.call(messages)
+      when 2
+        @sampling_handler.call(messages, model_preferences)
+      when 3
+        @sampling_handler.call(messages, model_preferences, system_prompt)
+      when 4
+        @sampling_handler.call(messages, model_preferences, system_prompt, max_tokens)
+      else
+        @sampling_handler.call(messages, model_preferences, system_prompt, max_tokens,
+                               { 'includeContext' => include_context, 'temperature' => temperature,
+                                 'stopSequences' => stop_sequences, 'metadata' => metadata })
+      end
+    end
+
+    # Normalize and validate modelPreferences from sampling request (MCP 2025-11-25)
+    # Ensures hints is an array of hashes with 'name', and priority values are clamped to 0.0..1.0
+    # @param prefs [Hash, nil] raw modelPreferences from request
+    # @return [Hash, nil] normalized modelPreferences or nil
+    def normalize_model_preferences(prefs)
+      return nil if prefs.nil?
+      return nil unless prefs.is_a?(Hash)
+
+      normalized = {}
+
+      # Normalize hints: array of { 'name' => String }
+      if prefs['hints']
+        normalized['hints'] = Array(prefs['hints']).filter_map do |hint|
+          next nil unless hint.is_a?(Hash) && hint['name']
+
+          { 'name' => hint['name'].to_s }
+        end
+      end
+
+      # Normalize priority values (0.0 to 1.0)
+      %w[costPriority speedPriority intelligencePriority].each do |key|
+        next unless prefs.key?(key)
+
+        value = prefs[key]
+        normalized[key] = value.is_a?(Numeric) ? value.to_f.clamp(0.0, 1.0) : nil
+      end
+
+      normalized
+    end
+
+    # Validate sampling response from handler (MCP 2025-11-25)
     # @param result [Hash] the result from the sampling handler
     # @return [Hash] validated sampling response
     def validate_sampling_response(result)

data/lib/mcp_client/elicitation_validator.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Validates elicitation schemas and content per MCP 2025-11-25 spec.
+  # Schemas are restricted to flat objects with primitive property types:
+  #   string (with optional enum, pattern, format, minLength, maxLength)
+  #   number / integer (with optional minimum, maximum)
+  #   boolean
+  #   array (multi-select enum only, with items containing enum or anyOf)
+  module ElicitationValidator
+    # Allowed primitive types for schema properties
+    PRIMITIVE_TYPES = %w[string number integer boolean].freeze
+
+    # Allowed string formats per MCP spec
+    STRING_FORMATS = %w[email uri date date-time].freeze
+
+    # Validate that a requestedSchema conforms to MCP elicitation constraints.
+    # Returns an array of error messages (empty if valid).
+    # @param schema [Hash] the requestedSchema
+    # @return [Array<String>] validation errors
+    def self.validate_schema(schema)
+      errors = []
+      return errors unless schema.is_a?(Hash)
+
+      unless schema['type'] == 'object'
+        errors << "Schema type must be 'object', got '#{schema['type']}'"
+        return errors
+      end
+
+      properties = schema['properties']
+      return errors unless properties.is_a?(Hash)
+
+      properties.each do |name, prop|
+        errors.concat(validate_property(name, prop))
+      end
+
+      errors
+    end
+
+    # Validate a single property definition.
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_property(name, prop)
+      errors = []
+      return errors unless prop.is_a?(Hash)
+
+      type = prop['type']
+
+      if type == 'array'
+        errors.concat(validate_array_property(name, prop))
+      elsif PRIMITIVE_TYPES.include?(type)
+        errors.concat(validate_primitive_property(name, prop))
+      else
+        errors << "Property '#{name}' has unsupported type '#{type}'"
+      end
+
+      errors
+    end
+
+    # Validate a primitive property (string, number, integer, boolean).
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_primitive_property(name, prop)
+      errors = []
+      type = prop['type']
+
+      case type
+      when 'string'
+        if prop['format'] && !STRING_FORMATS.include?(prop['format'])
+          errors << "Property '#{name}' has unsupported format '#{prop['format']}'"
+        end
+        errors << "Property '#{name}' enum must be an array" if prop['enum'] && !prop['enum'].is_a?(Array)
+      when 'number', 'integer'
+        if prop.key?('minimum') && !prop['minimum'].is_a?(Numeric)
+          errors << "Property '#{name}' minimum must be numeric"
+        end
+        if prop.key?('maximum') && !prop['maximum'].is_a?(Numeric)
+          errors << "Property '#{name}' maximum must be numeric"
+        end
+      end
+
+      errors
+    end
+
+    # Validate an array property (multi-select enum only).
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_array_property(name, prop)
+      errors = []
+      items = prop['items']
+
+      unless items.is_a?(Hash)
+        errors << "Property '#{name}' array type requires 'items' definition"
+        return errors
+      end
+
+      has_enum = items['enum'].is_a?(Array)
+      has_any_of = items['anyOf'].is_a?(Array)
+
+      errors << "Property '#{name}' array items must have 'enum' or 'anyOf'" unless has_enum || has_any_of
+
+      errors
+    end
+
+    # Validate content against a requestedSchema.
+    # Returns an array of error messages (empty if valid).
+    # @param content [Hash] the response content
+    # @param schema [Hash] the requestedSchema
+    # @return [Array<String>] validation errors
+    def self.validate_content(content, schema)
+      errors = []
+      return errors unless content.is_a?(Hash) && schema.is_a?(Hash)
+
+      properties = schema['properties'] || {}
+      required = Array(schema['required'])
+
+      # Check required fields
+      required.each do |field|
+        field_s = field.to_s
+        errors << "Missing required field '#{field_s}'" unless content.key?(field_s) || content.key?(field_s.to_sym)
+      end
+
+      # Validate each provided field
+      content.each do |field, value|
+        prop = properties[field.to_s]
+        next unless prop.is_a?(Hash)
+
+        errors.concat(validate_value(field.to_s, value, prop))
+      end
+
+      errors
+    end
+
+    # Validate a single value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value to validate
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_value(field, value, prop)
+      errors = []
+      type = prop['type']
+
+      case type
+      when 'string'
+        errors.concat(validate_string_value(field, value, prop))
+      when 'number', 'integer'
+        errors.concat(validate_number_value(field, value, prop))
+      when 'boolean'
+        errors << "Field '#{field}' must be a boolean" unless [true, false].include?(value)
+      when 'array'
+        errors.concat(validate_array_value(field, value, prop))
+      end
+
+      errors
+    end
+
+    # Validate a string value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_string_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(String)
+        errors << "Field '#{field}' must be a string"
+        return errors
+      end
+
+      if prop['enum'].is_a?(Array) && !prop['enum'].include?(value)
+        errors << "Field '#{field}' must be one of: #{prop['enum'].join(', ')}"
+      end
+
+      if prop['oneOf'].is_a?(Array)
+        allowed = prop['oneOf'].map { |o| o['const'] }
+        errors << "Field '#{field}' must be one of: #{allowed.join(', ')}" unless allowed.include?(value)
+      end
+
+      if prop['pattern']
+        begin
+          unless value.match?(Regexp.new(prop['pattern']))
+            errors << "Field '#{field}' must match pattern '#{prop['pattern']}'"
+          end
+        rescue RegexpError
+          # Skip pattern validation if the pattern is invalid
+        end
+      end
+
+      if prop['minLength'] && value.length < prop['minLength']
+        errors << "Field '#{field}' must be at least #{prop['minLength']} characters"
+      end
+
+      if prop['maxLength'] && value.length > prop['maxLength']
+        errors << "Field '#{field}' must be at most #{prop['maxLength']} characters"
+      end
+
+      errors
+    end
+
+    # Validate a number value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_number_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(Numeric)
+        errors << "Field '#{field}' must be a number"
+        return errors
+      end
+
+      errors << "Field '#{field}' must be an integer" if prop['type'] == 'integer' && !value.is_a?(Integer)
+
+      errors << "Field '#{field}' must be >= #{prop['minimum']}" if prop['minimum'] && value < prop['minimum']
+
+      errors << "Field '#{field}' must be <= #{prop['maximum']}" if prop['maximum'] && value > prop['maximum']
+
+      errors
+    end
+
+    # Validate an array value against its property schema (multi-select enum).
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_array_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(Array)
+        errors << "Field '#{field}' must be an array"
+        return errors
+      end
+
+      items = prop['items'] || {}
+      allowed = if items['enum'].is_a?(Array)
+                  items['enum']
+                elsif items['anyOf'].is_a?(Array)
+                  items['anyOf'].map { |o| o['const'] }
+                end
+
+      if allowed
+        value.each do |v|
+          errors << "Field '#{field}' contains invalid value '#{v}'" unless allowed.include?(v)
+        end
+      end
+
+      if prop['minItems'] && value.length < prop['minItems']
+        errors << "Field '#{field}' must have at least #{prop['minItems']} items"
+      end
+
+      if prop['maxItems'] && value.length > prop['maxItems']
+        errors << "Field '#{field}' must have at most #{prop['maxItems']} items"
+      end
+
+      errors
+    end
+  end
+end

data/lib/mcp_client/errors.rb

@@ -50,5 +50,11 @@ module MCPClient
 
     # Raised when transport type cannot be determined from target URL/command
     class TransportDetectionError < MCPError; end
+
+    # Raised when a task is not found
+    class TaskNotFound < MCPError; end
+
+    # Raised when there's an error creating or managing a task
+    class TaskError < MCPError; end
   end
 end