actionmcp 0.111.1 → 0.200.0

data/lib/action_mcp/server/elicitation_request.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json_schemer"
+
 module ActionMCP
   module Server
     # Value object for form-mode elicitation requests.
@@ -9,14 +11,135 @@ module ActionMCP
       include ActiveModel::Model
       include ActiveModel::Attributes
 
+      STRING_SCHEMA = {
+        "type" => "object",
+        "required" => [ "type" ],
+        "properties" => {
+          "type" => { "const" => "string" },
+          "title" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "default" => { "type" => "string" },
+          "format" => { "enum" => %w[date date-time email uri] },
+          "minLength" => { "type" => "integer" },
+          "maxLength" => { "type" => "integer" }
+        }
+      }.freeze
+
+      NUMBER_SCHEMA = {
+        "type" => "object",
+        "required" => [ "type" ],
+        "properties" => {
+          "type" => { "enum" => %w[integer number] },
+          "title" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "default" => { "type" => "integer" },
+          "minimum" => { "type" => "integer" },
+          "maximum" => { "type" => "integer" }
+        }
+      }.freeze
+
+      BOOLEAN_SCHEMA = {
+        "type" => "object",
+        "required" => [ "type" ],
+        "properties" => {
+          "type" => { "const" => "boolean" },
+          "title" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "default" => { "type" => "boolean" }
+        }
+      }.freeze
+
+      ENUM_OPTION_SCHEMA = {
+        "type" => "object",
+        "required" => %w[const title],
+        "properties" => {
+          "const" => { "type" => "string" },
+          "title" => { "type" => "string" }
+        }
+      }.freeze
+
+      UNTITLED_MULTI_SELECT_SCHEMA = {
+        "type" => "object",
+        "required" => %w[items type],
+        "properties" => {
+          "type" => { "const" => "array" },
+          "title" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "default" => { "type" => "array", "items" => { "type" => "string" } },
+          "minItems" => { "type" => "integer" },
+          "maxItems" => { "type" => "integer" },
+          "items" => {
+            "type" => "object",
+            "required" => %w[enum type],
+            "properties" => {
+              "type" => { "const" => "string" },
+              "enum" => { "type" => "array", "items" => { "type" => "string" } }
+            }
+          }
+        }
+      }.freeze
+
+      TITLED_MULTI_SELECT_SCHEMA = {
+        "type" => "object",
+        "required" => %w[items type],
+        "properties" => {
+          "type" => { "const" => "array" },
+          "title" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "default" => { "type" => "array", "items" => { "type" => "string" } },
+          "minItems" => { "type" => "integer" },
+          "maxItems" => { "type" => "integer" },
+          "items" => {
+            "type" => "object",
+            "required" => [ "anyOf" ],
+            "properties" => {
+              "anyOf" => { "type" => "array", "items" => ENUM_OPTION_SCHEMA }
+            }
+          }
+        }
+      }.freeze
+
+      REQUESTED_SCHEMA = {
+        "type" => "object",
+        "required" => %w[properties type],
+        "properties" => {
+          "$schema" => { "type" => "string" },
+          "type" => { "const" => "object" },
+          "required" => { "type" => "array", "items" => { "type" => "string" } },
+          "properties" => {
+            "type" => "object",
+            "additionalProperties" => {
+              "anyOf" => [
+                STRING_SCHEMA,
+                NUMBER_SCHEMA,
+                BOOLEAN_SCHEMA,
+                UNTITLED_MULTI_SELECT_SCHEMA,
+                TITLED_MULTI_SELECT_SCHEMA
+              ]
+            }
+          }
+        }
+      }.freeze
+      REQUESTED_SCHEMA_SCHEMER = JSONSchemer.schema(REQUESTED_SCHEMA)
+      TASK_SCHEMA = {
+        "type" => "object",
+        "additionalProperties" => false,
+        "properties" => {
+          "ttl" => { "type" => "integer" }
+        }
+      }.freeze
+      TASK_SCHEMER = JSONSchemer.schema(TASK_SCHEMA)
+
       attribute :message, :string
       attribute :requested_schema # Hash
       attribute :_meta            # Hash, optional
+      attribute :task             # TaskMetadata, optional
 
       validates :message, presence: true
       validates :requested_schema, presence: true
-      validate :schema_must_be_object_with_properties, if: -> { requested_schema.present? }
-      validate :properties_must_be_primitive, if: -> { errors[:requested_schema].empty? && requested_schema.present? }
+      validate :requested_schema_must_match_protocol, if: -> { requested_schema.present? }
+      validate :meta_must_be_object, if: -> { _meta.present? }
+      validate :task_must_match_protocol, unless: -> { task.nil? }
 
       # Wrap incoming schema in indifferent access so both string and symbol keys work.
       def requested_schema=(value)
@@ -27,6 +150,7 @@ module ActionMCP
       def to_params
         params = { mode: "form", message: message, requestedSchema: requested_schema.to_hash.deep_symbolize_keys }
         params[:_meta] = _meta if _meta.present?
+        params[:task] = task unless task.nil?
         params
       end
 
@@ -40,60 +164,21 @@ module ActionMCP
 
       private
 
-      def schema_must_be_object_with_properties
-        unless requested_schema.is_a?(Hash) && requested_schema[:type] == "object"
-          errors.add(:requested_schema, "must be an object type")
-          return
-        end
-
-        properties = requested_schema[:properties]
-        errors.add(:requested_schema, "must have properties") unless properties.is_a?(Hash)
-      end
-
-      def properties_must_be_primitive
-        properties = requested_schema[:properties]
-        return unless properties.is_a?(Hash)
-
-        properties.each do |key, prop_schema|
-          validate_primitive_property(key, prop_schema)
-        end
-      end
+      def requested_schema_must_match_protocol
+        validation_errors = REQUESTED_SCHEMA_SCHEMER.validate(requested_schema.to_h.deep_stringify_keys).to_a
+        return if validation_errors.empty?
 
-      def validate_primitive_property(key, schema)
-        unless schema.is_a?(Hash)
-          errors.add(:requested_schema, "property '#{key}' must have a schema definition")
-          return
-        end
-
-        case schema[:type]
-        when "string"
-          validate_string_enum(key, schema)
-        when "number", "integer", "boolean"
-          # valid primitive types
-        when "array"
-          validate_enum_array(key, schema)
-        else
-          errors.add(:requested_schema,
-            "property '#{key}' must be a primitive type (string, number, integer, boolean) or enum array")
-        end
+        pointers = validation_errors.map { |error| error["data_pointer"].presence || "/" }.uniq
+        errors.add(:requested_schema, "must match MCP 2025-11-25 at #{pointers.join(', ')}")
       end
 
-      def validate_string_enum(key, schema)
-        if schema[:enum] && !schema[:enum].is_a?(Array)
-          errors.add(:requested_schema, "property '#{key}' enum must be an array")
-        end
+      def meta_must_be_object
+        errors.add(:_meta, "must be an object") unless _meta.is_a?(Hash)
       end
 
-      def validate_enum_array(key, schema)
-        items = schema[:items]
-        unless items.is_a?(Hash)
-          errors.add(:requested_schema, "property '#{key}' array must have items schema")
-          return
-        end
-
-        unless items[:enum].is_a?(Array) || items[:anyOf].is_a?(Array)
-          errors.add(:requested_schema, "property '#{key}' array items must be an enum (enum or anyOf)")
-        end
+      def task_must_match_protocol
+        errors.add(:task, "must match MCP 2025-11-25 TaskMetadata") unless
+          task.is_a?(Hash) && TASK_SCHEMER.valid?(task.deep_stringify_keys)
       end
     end
   end

data/lib/action_mcp/server/handlers/logging_handler.rb

@@ -10,13 +10,16 @@ module ActionMCP
         # @param params [Hash] Request parameters containing level
         # @return [Hash] Empty hash on success
         def handle_logging_set_level(id, params)
-          # Check if logging is enabled
-          unless ActionMCP.configuration.logging_enabled
+          unless ActionMCP::Logging.supported_by?(transport.session)
             transport.send_jsonrpc_error(id, :method_not_found, "Logging not enabled")
             return
           end
 
-          # Extract and validate level parameter
+          unless params.is_a?(Hash)
+            transport.send_jsonrpc_error(id, :invalid_params, "Logging params must be an object")
+            return
+          end
+
           level = params[:level] || params["level"]
           unless level
             transport.send_jsonrpc_error(id, :invalid_params, "Missing required parameter: level")
@@ -24,8 +27,7 @@ module ActionMCP
           end
 
           begin
-            # Validate and set the new level
-            ActionMCP::Logging.set_level(level)
+            ActionMCP::Logging.set_level_for(transport.session, level)
 
             # Send successful response (empty object per MCP spec)
             transport.send_jsonrpc_response(id, result: {})

data/lib/action_mcp/server/handlers/prompt_handler.rb

@@ -10,6 +10,10 @@ module ActionMCP
           params ||= {}
 
           with_error_handling(id) do
+            unless params.is_a?(Hash)
+              raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Prompt params must be an object")
+            end
+
             handler = prompt_method_handlers[rpc_method]
             if handler
               send(handler, id, params)
@@ -30,8 +34,15 @@ module ActionMCP
         end
 
         def handle_prompts_get(id, params)
-          name = extract_name(params)
+          name = validate_required_param(params, "name", "Prompt name is required")
           arguments = extract_arguments(params)
+          unless arguments.is_a?(Hash)
+            raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Prompt arguments must be an object")
+          end
+          unless arguments.values.all? { |value| value.is_a?(String) }
+            raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Prompt argument values must be strings")
+          end
+
           transport.send_prompts_get(id, name, arguments)
         end
 

data/lib/action_mcp/server/handlers/resource_handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module ActionMCP
   module Server
     module Handlers
@@ -10,6 +12,21 @@ module ActionMCP
           params ||= {}
 
           with_error_handling(id) do
+            unless params.is_a?(Hash)
+              raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Resource params must be an object")
+            end
+
+            capabilities = negotiated_resource_capabilities
+            unless capabilities
+              raise JSON_RPC::JsonRpcError.new(:method_not_found,
+                                               message: "Resources are not available for this session")
+            end
+
+            if subscription_method?(rpc_method) && capabilities[:subscribe] != true
+              raise JSON_RPC::JsonRpcError.new(:method_not_found,
+                                               message: "Resource subscriptions are not available for this session")
+            end
+
             handler = resource_method_handlers[rpc_method]
             if handler
               send(handler, id, params)
@@ -32,6 +49,17 @@ module ActionMCP
           }
         end
 
+        def negotiated_resource_capabilities
+          capabilities = (transport.session.server_capabilities || {}).with_indifferent_access
+          resource_capabilities = capabilities[:resources]
+          resource_capabilities.with_indifferent_access if resource_capabilities.is_a?(Hash)
+        end
+
+        def subscription_method?(rpc_method)
+          rpc_method == JsonRpcHandlerBase::Methods::RESOURCES_SUBSCRIBE ||
+            rpc_method == JsonRpcHandlerBase::Methods::RESOURCES_UNSUBSCRIBE
+        end
+
         def handle_resources_list(id, params)
           transport.send_resources_list(id, params)
         end
@@ -41,22 +69,28 @@ module ActionMCP
         end
 
         def handle_resources_read(id, params)
-          validate_params_present(params, "Resource URI is required")
+          validate_resource_uri(params)
           transport.send_resource_read(id, params)
         end
 
         def handle_resources_subscribe(id, params)
-          uri = validate_required_param(params, "uri", "Resource URI is required")
-
-          message = transport.send_resource_subscribe(id, uri)
-          extract_message_payload(message, id)
+          uri = validate_resource_uri(params)
+          transport.send_resource_subscribe(id, uri)
         end
 
         def handle_resources_unsubscribe(id, params)
+          uri = validate_resource_uri(params)
+          transport.send_resource_unsubscribe(id, uri)
+        end
+
+        def validate_resource_uri(params)
           uri = validate_required_param(params, "uri", "Resource URI is required")
+          parsed = URI.parse(uri) if uri.is_a?(String)
+          return uri if parsed&.scheme.present?
 
-          message = transport.send_resource_unsubscribe(id, uri)
-          extract_message_payload(message, id)
+          raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Resource URI must be an absolute URI")
+        rescue URI::InvalidURIError
+          raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Resource URI must be an absolute URI")
         end
       end
     end

data/lib/action_mcp/server/handlers/task_handler.rb

@@ -12,11 +12,31 @@ module ActionMCP
           params ||= {}
 
           with_error_handling(id) do
+            unless params.is_a?(Hash)
+              raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Task params must be an object")
+            end
+
             unless transport.session.protocol_version == "2025-11-25"
               raise JSON_RPC::JsonRpcError.new(:method_not_found,
                                                message: "Tasks are only available in MCP 2025-11-25")
             end
 
+            task_capabilities = negotiated_task_capabilities
+            unless task_capabilities
+              raise JSON_RPC::JsonRpcError.new(:method_not_found,
+                                               message: "Tasks are not available for this session")
+            end
+
+            if rpc_method == JsonRpcHandlerBase::Methods::TASKS_LIST && !task_capabilities.key?(:list)
+              raise JSON_RPC::JsonRpcError.new(:method_not_found,
+                                               message: "Task listing is not available for this session")
+            end
+
+            if rpc_method == JsonRpcHandlerBase::Methods::TASKS_CANCEL && !task_capabilities.key?(:cancel)
+              raise JSON_RPC::JsonRpcError.new(:method_not_found,
+                                               message: "Task cancellation is not available for this session")
+            end
+
             handler = task_method_handlers[rpc_method]
             if handler
               send(handler, id, params)
@@ -38,6 +58,12 @@ module ActionMCP
           }
         end
 
+        def negotiated_task_capabilities
+          capabilities = (transport.session.server_capabilities || {}).with_indifferent_access
+          task_capabilities = capabilities[:tasks]
+          task_capabilities.with_indifferent_access if task_capabilities.is_a?(Hash)
+        end
+
         def handle_tasks_get(id, params)
           task_id = validate_required_param(params, "taskId", "Task ID is required")
           task = find_task_or_error(id, task_id)

data/lib/action_mcp/server/handlers/tool_handler.rb

@@ -10,6 +10,10 @@ module ActionMCP
           params ||= {}
 
           with_error_handling(id) do
+            unless params.is_a?(Hash)
+              raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Tool params must be an object")
+            end
+
             handler = tool_method_handlers[rpc_method]
             if handler
               send(handler, id, params)
@@ -36,6 +40,10 @@ module ActionMCP
         def handle_tools_call(id, params)
           name = validate_required_param(params, "name", "Tool name is required")
           arguments = extract_arguments(params)
+          unless arguments.is_a?(Hash)
+            raise JSON_RPC::JsonRpcError.new(:invalid_params, message: "Tool arguments must be an object")
+          end
+
           _meta = params["_meta"] || params[:_meta] || {}
           task_params = params.key?("task") ? params["task"] : params[:task]
           transport.send_tools_call(id, name, arguments, _meta, task_params)

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -81,20 +81,19 @@ module ActionMCP
 
       def handle_response(response)
         Rails.logger.debug("Received response: #{response.inspect}")
-        response
+        nil
       end
 
       def process_completion_complete(id, params)
-        # Extract context if provided
-        context = params["context"] if params.is_a?(Hash)
-
-        transport.send_jsonrpc_response(id, result: build_completion_result(params, context))
+        transport.send_completion_complete(id, params)
       end
 
       def process_notifications(rpc_method, params)
         case rpc_method
         when Methods::NOTIFICATIONS_INITIALIZED
-          transport.initialize!
+          raise JSON_RPC::JsonRpcError.new(:invalid_request, message: "Session is not awaiting initialization") unless transport.initialize!
+        when Methods::NOTIFICATIONS_ROOTS_LIST_CHANGED
+          transport.refresh_roots_list
         else
           super
         end
@@ -107,21 +106,6 @@ module ActionMCP
           result: response.result
         }
       end
-
-      def build_completion_result(_params = {}, _context = nil)
-        # In a real implementation, this would use the params and context
-        # to generate appropriate completion suggestions
-        # For now, we just return an empty result
-        #
-        # params contains:
-        # - ref: reference to prompt or resource template
-        # - argument: { name: string, value: string }
-        # - context: { arguments: { [key]: string } } (previously resolved variables)
-
-        {
-          completion: { values: [], total: 0, hasMore: false }
-        }
-      end
     end
   end
 end

data/lib/action_mcp/server/messaging_service.rb

@@ -33,6 +33,8 @@ module ActionMCP
       end
 
       def send_resource_updated_notification(uri)
+        return unless session.resource_subscribed?(uri)
+
         send_jsonrpc_notification("notifications/resources/updated", { uri: uri })
       end
 
@@ -47,7 +49,7 @@ module ActionMCP
       def send_logging_message_notification(level:, data:, logger: nil)
         params = { level: level, data: data }
         params[:logger] = logger if logger.present?
-        send_jsonrpc_notification("notifications/logging/message", params)
+        send_jsonrpc_notification("notifications/message", params)
       end
 
       def send_progress_notification(progressToken:, progress:, total: nil, message: nil, **options)

data/lib/action_mcp/server/prompts.rb

@@ -33,13 +33,15 @@ module ActionMCP
           end
 
           if result.is_error
-            send_jsonrpc_response(request_id, error: result)
+            send_jsonrpc_response(request_id, error: result.to_h)
           else
-            send_jsonrpc_response(request_id, result: result)
+            send_jsonrpc_response(request_id, result: result.to_h)
           end
         else
-          send_jsonrpc_error(request_id, :method_not_found, "Prompt '#{prompt_name}' not available in this session")
+          send_jsonrpc_error(request_id, :invalid_params, "Prompt '#{prompt_name}' not available in this session")
         end
+      rescue ArgumentError, ActiveModel::UnknownAttributeError => e
+        send_jsonrpc_error(request_id, :invalid_params, e.message)
       end
     end
   end

data/lib/action_mcp/server/resources.rb

@@ -46,7 +46,7 @@ module ActionMCP
       # @param params [Hash] Parameters specifying which resource to read
       def send_resource_read(id, params)
         uri = params["uri"]
-        template = ResourceTemplatesRegistry.find_template_for_uri(uri)
+        template = find_registered_template_for_uri(uri)
 
         unless template
           error = {
@@ -108,8 +108,40 @@ module ActionMCP
         end
       end
 
+      # Subscribe the current session to updates for an available resource.
+      def send_resource_subscribe(id, uri)
+        unless find_registered_template_for_uri(uri)
+          send_jsonrpc_response(id, error: resource_not_found_error(uri))
+          return
+        end
+
+        session.resource_subscribe(uri)
+        send_jsonrpc_response(id, result: {})
+      end
+
+      # Remove a resource update subscription. Unsubscribing is idempotent.
+      def send_resource_unsubscribe(id, uri)
+        session.resource_unsubscribe(uri)
+        send_jsonrpc_response(id, result: {})
+      end
+
       private
 
+      def find_registered_template_for_uri(uri)
+        ResourceTemplatesRegistry.find_template_for_uri(
+          uri,
+          templates: session.registered_resource_templates
+        )
+      end
+
+      def resource_not_found_error(uri)
+        {
+          code: -32_002,
+          message: "Resource not found",
+          data: { uri: uri }
+        }
+      end
+
       # Collect all concrete resources from templates that implement list.
       # Returns nil if a URI collision error was sent.
       # @return [Array<ActionMCP::Resource>, nil]
@@ -167,7 +199,8 @@ module ActionMCP
       def normalize_read_content(content, _uri)
         case content
         when ActionMCP::Content::Resource
-          inner = { uri: content.uri, mimeType: content.mime_type }
+          inner = { uri: content.uri }
+          inner[:mimeType] = content.mime_type if content.mime_type
           inner[:text] = content.text if content.text
           inner[:blob] = content.blob if content.blob
           inner[:_meta] = content.meta if content.meta && !content.meta.empty?

data/lib/action_mcp/server/response_collector.rb

@@ -10,11 +10,15 @@ module ActionMCP
         @collected_responses = []
       end
 
-      # Override write_message to collect responses instead of writing them
+      # Collect messages for the HTTP response while retaining the session's
+      # complete wire history. Server-initiated requests cannot be placed in
+      # the empty 202 response required for an incoming notification, so the
+      # generated request must not be silently discarded.
       def write_message(message)
         if messaging_mode == :return
           @collected_responses ||= []
           @collected_responses << message
+          super
           message
         else
           super

data/lib/action_mcp/server/roots.rb

@@ -3,9 +3,22 @@
 module ActionMCP
   module Server
     module Roots
-      def send_roots_list(id)
-        send_jsonrpc_response(id, result: { roots: [] })
+      def send_roots_list(id = SecureRandom.uuid_v7)
+        roots = session.client_capabilities&.then { |capabilities| capabilities["roots"] || capabilities[:roots] }
+        raise UnsupportedRootsError, "Client does not support roots" unless roots.is_a?(Hash)
+
+        send_jsonrpc_request("roots/list", id: id)
+      end
+
+      def refresh_roots_list
+        roots = session.client_capabilities&.then { |capabilities| capabilities["roots"] || capabilities[:roots] }
+        return unless roots.is_a?(Hash)
+
+        list_changed = roots["listChanged"] || roots[:listChanged]
+        send_roots_list if list_changed == true
       end
     end
+
+    class UnsupportedRootsError < StandardError; end
   end
 end

data/lib/action_mcp/server/sampling.rb

@@ -7,8 +7,43 @@ module ActionMCP
       # @param [SamplingRequest] request
       def send_sampling_create_message(id, request)
         params = request.is_a?(SamplingRequest) ? request.to_h : request
-        send_jsonrpc_request(id, "sampling/createMessage", params)
+        SamplingRequest.validate_params!(params)
+        require_client_sampling_support!(params)
+
+        send_jsonrpc_request("sampling/createMessage", params: params, id: id)
+      end
+
+      private
+
+      def require_client_sampling_support!(params)
+        client_capabilities = session.client_capabilities || {}
+        sampling = client_capabilities["sampling"] || client_capabilities[:sampling]
+        raise UnsupportedSamplingError, "Client does not support sampling" unless sampling.is_a?(Hash)
+
+        if params.key?(:tools) || params.key?("tools") || params.key?(:toolChoice) || params.key?("toolChoice")
+          tools = sampling["tools"] || sampling[:tools]
+          raise UnsupportedSamplingError, "Client does not support sampling with tools" unless tools.is_a?(Hash)
+        end
+
+        include_context = params[:includeContext] || params["includeContext"]
+        if %w[thisServer allServers].include?(include_context)
+          context = sampling["context"] || sampling[:context]
+          raise UnsupportedSamplingError, "Client does not support sampling context inclusion" unless context.is_a?(Hash)
+        end
+
+        return unless params.key?(:task) || params.key?("task")
+
+        tasks = client_capabilities["tasks"] || client_capabilities[:tasks]
+        task_requests = tasks.is_a?(Hash) && (tasks["requests"] || tasks[:requests])
+        task_sampling = task_requests.is_a?(Hash) && (task_requests["sampling"] || task_requests[:sampling])
+        create_message = task_sampling.is_a?(Hash) &&
+          (task_sampling["createMessage"] || task_sampling[:createMessage])
+        return if create_message.is_a?(Hash)
+
+        raise UnsupportedSamplingError, "Client does not support task-augmented sampling"
       end
     end
+
+    class UnsupportedSamplingError < StandardError; end
   end
 end