actionmcp 0.111.1 → 0.200.0

data/lib/action_mcp/logging.rb

@@ -7,6 +7,8 @@ require "logger"
 module ActionMCP
   # Global MCP logging interface
   module Logging
+    SESSION_LEVEL_KEY = "action_mcp_logging_level"
+
     class << self
       # Get the global logging state
       # @return [ActionMCP::Logging::State] The global state
@@ -54,12 +56,43 @@ module ActionMCP
       end
       alias_method :set_level, :level=
 
+      # Return the minimum log level negotiated for a session, falling back to
+      # the configured server default until the client sends logging/setLevel.
+      def level_for(session)
+        session_data = session.respond_to?(:session_data) && session.session_data
+        stored_level = session_data[SESSION_LEVEL_KEY] if session_data.is_a?(Hash)
+        Level.name_for(Level.coerce(stored_level || level))
+      end
+
+      def set_level_for(session, new_level)
+        normalized_level = Level.name_for(Level.coerce(new_level))
+        session_data = session.session_data.is_a?(Hash) ? session.session_data.deep_dup : {}
+        session_data[SESSION_LEVEL_KEY] = normalized_level.to_s
+
+        if session.respond_to?(:update!)
+          session.update!(session_data: session_data)
+        else
+          session.session_data = session_data
+          session.save! if session.respond_to?(:save!)
+        end
+
+        normalized_level
+      end
+
+      def supported_by?(session)
+        return false unless session&.respond_to?(:server_capabilities)
+
+        capabilities = session.server_capabilities
+        capabilities.is_a?(Hash) &&
+          (capabilities.key?("logging") || capabilities.key?(:logging))
+      end
+
       # Create a logger for the given session
       # @param name [String, nil] Optional logger name
       # @param session [ActionMCP::Session] The MCP session
       # @return [ActionMCP::Logging::Logger, ActionMCP::Logging::NullLogger] logger instance
       def logger(name: nil, session:)
-        if enabled?
+        if enabled? && supported_by?(session)
           Logger.new(name: name, session: session, state: state)
         else
           NullLogger.new

data/lib/action_mcp/middleware/origin_validation.rb

@@ -7,8 +7,8 @@ module ActionMCP
     # Rack middleware that validates the Origin header on MCP requests to
     # prevent DNS rebinding attacks per the MCP Streamable HTTP security
     # section. Non-browser clients (Claude Desktop, curl) never send Origin
-    # and are always allowed. Present Origins must match either
-    # `ActionMCP.configuration.allowed_origins` or the server's own host.
+    # and are always allowed. Present Origins must match the explicitly trusted
+    # hosts in `ActionMCP.configuration.allowed_origins`.
     #
     # Runs as middleware — same layer as `ActionDispatch::HostAuthorization` —
     # so invalid requests are rejected before they reach routing.
@@ -28,7 +28,7 @@ module ActionMCP
 
         request = ActionDispatch::Request.new(env)
         origin = request.origin
-        return @app.call(env) if origin.nil? || origin.empty?
+        return @app.call(env) if origin.nil?
         return @app.call(env) if origin_allowed?(origin, request)
 
         forbidden_response
@@ -49,21 +49,17 @@ module ActionMCP
         end
       end
 
-      def origin_allowed?(origin, request)
+      def origin_allowed?(origin, _request)
         return false if origin == "null"
 
         uri = URI.parse(origin)
-        return false if uri.host.nil? || uri.host.empty?
+        return false unless %w[http https].include?(uri.scheme)
+        return false if uri.host.nil? || uri.host.empty? || uri.userinfo || uri.query || uri.fragment
+        return false unless uri.path.empty?
 
         origin_host = strip_brackets(uri.host)
-        allowed = ActionMCP.configuration.allowed_origins
-
-        if allowed && !allowed.empty?
-          allowed.any? { |pattern| match?(pattern, origin_host) }
-        else
-          # ActionDispatch::Request#host strips the port and handles IPv6 brackets
-          origin_host.casecmp?(strip_brackets(request.host))
-        end
+        allowed = Array(ActionMCP.configuration.allowed_origins)
+        allowed.any? { |pattern| match?(pattern, origin_host) }
       rescue URI::InvalidURIError
         false
       end

data/lib/action_mcp/output_schema_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "schema_helpers"
+require_relative "schema_validator"
 
 module ActionMCP
   # DSL builder for creating output JSON Schema from Ruby-like syntax
@@ -173,6 +174,7 @@ module ActionMCP
     # Generate the final JSON Schema
     def to_json_schema
       schema = {
+        "$schema" => SchemaValidator::DEFAULT_DIALECT,
         "type" => "object",
         "properties" => @properties
       }

data/lib/action_mcp/prompt_response.rb

@@ -2,6 +2,8 @@
 
 module ActionMCP
   class PromptResponse < BaseResponse
+    ROLES = %w[user assistant].freeze
+
     attr_reader :messages
 
     # Delegate methods to the underlying messages array
@@ -14,7 +16,13 @@ module ActionMCP
 
     # Add a message to the response
     def add_message(role:, content:)
-      @messages << { role: role, content: content }
+      normalized_role = role.to_s
+      unless ROLES.include?(normalized_role)
+        raise ArgumentError, "role must be one of: #{ROLES.join(', ')}"
+      end
+      raise ArgumentError, "content must be an MCP content object" unless content.is_a?(Hash)
+
+      @messages << { role: normalized_role, content: Content::Validation.copy_content_block!(content) }
       self
     end
 
@@ -26,9 +34,11 @@ module ActionMCP
 
     # Implementation of build_success_hash for PromptResponse
     def build_success_hash
-      {
+      result = {
         messages: @messages
       }
+      Content::Validation.validate_prompt_result!(result)
+      result
     end
 
     # Implementation of compare_with_same_class for PromptResponse

data/lib/action_mcp/protocol_validator.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+
+require "json_schemer"
+
+module ActionMCP
+  # Validates the stable MCP JSON-RPC envelope and client message parameters.
+  class ProtocolValidator
+    ValidationError = Data.define(:code, :message)
+
+    ID_SCHEMA = { "type" => [ "string", "integer" ] }.freeze
+    PROGRESS_TOKEN_SCHEMA = { "type" => [ "string", "integer" ] }.freeze
+
+    REQUEST_META_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "progressToken" => PROGRESS_TOKEN_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    NOTIFICATION_META_SCHEMA = {
+      "type" => "object",
+      "additionalProperties" => true
+    }.freeze
+
+    REQUEST_PARAMS_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    NOTIFICATION_PARAMS_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "_meta" => NOTIFICATION_META_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    PAGINATED_PARAMS_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "cursor" => { "type" => "string" }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    ICON_SCHEMA = {
+      "type" => "object",
+      "required" => [ "src" ],
+      "properties" => {
+        "src" => { "type" => "string", "format" => "uri" },
+        "mimeType" => { "type" => "string" },
+        "sizes" => {
+          "type" => "array",
+          "items" => { "type" => "string" }
+        },
+        "theme" => {
+          "type" => "string",
+          "enum" => %w[dark light]
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    IMPLEMENTATION_SCHEMA = {
+      "type" => "object",
+      "required" => %w[name version],
+      "properties" => {
+        "name" => { "type" => "string" },
+        "title" => { "type" => "string" },
+        "version" => { "type" => "string" },
+        "description" => { "type" => "string" },
+        "websiteUrl" => { "type" => "string", "format" => "uri" },
+        "icons" => {
+          "type" => "array",
+          "items" => ICON_SCHEMA
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    EMPTY_CAPABILITY_SCHEMA = {
+      "type" => "object",
+      "additionalProperties" => true
+    }.freeze
+
+    CLIENT_CAPABILITIES_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "elicitation" => {
+          "type" => "object",
+          "properties" => {
+            "form" => EMPTY_CAPABILITY_SCHEMA,
+            "url" => EMPTY_CAPABILITY_SCHEMA
+          },
+          "additionalProperties" => true
+        },
+        "experimental" => {
+          "type" => "object",
+          "additionalProperties" => EMPTY_CAPABILITY_SCHEMA
+        },
+        "roots" => {
+          "type" => "object",
+          "properties" => {
+            "listChanged" => { "type" => "boolean" }
+          },
+          "additionalProperties" => true
+        },
+        "sampling" => {
+          "type" => "object",
+          "properties" => {
+            "context" => EMPTY_CAPABILITY_SCHEMA,
+            "tools" => EMPTY_CAPABILITY_SCHEMA
+          },
+          "additionalProperties" => true
+        },
+        "tasks" => {
+          "type" => "object",
+          "properties" => {
+            "cancel" => EMPTY_CAPABILITY_SCHEMA,
+            "list" => EMPTY_CAPABILITY_SCHEMA,
+            "requests" => {
+              "type" => "object",
+              "properties" => {
+                "elicitation" => {
+                  "type" => "object",
+                  "properties" => {
+                    "create" => EMPTY_CAPABILITY_SCHEMA
+                  },
+                  "additionalProperties" => true
+                },
+                "sampling" => {
+                  "type" => "object",
+                  "properties" => {
+                    "createMessage" => EMPTY_CAPABILITY_SCHEMA
+                  },
+                  "additionalProperties" => true
+                }
+              },
+              "additionalProperties" => true
+            }
+          },
+          "additionalProperties" => true
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    INITIALIZE_PARAMS_SCHEMA = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "type" => "object",
+      "required" => %w[protocolVersion capabilities clientInfo],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "protocolVersion" => { "type" => "string" },
+        "capabilities" => CLIENT_CAPABILITIES_SCHEMA,
+        "clientInfo" => IMPLEMENTATION_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    RESOURCE_URI_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => [ "uri" ],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "uri" => { "type" => "string", "format" => "uri" }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    GET_PROMPT_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => [ "name" ],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "name" => { "type" => "string" },
+        "arguments" => {
+          "type" => "object",
+          "additionalProperties" => { "type" => "string" }
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    TASK_METADATA_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "ttl" => { "type" => "integer" }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    CALL_TOOL_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => [ "name" ],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "name" => { "type" => "string" },
+        "arguments" => {
+          "type" => "object",
+          "additionalProperties" => true
+        },
+        "task" => TASK_METADATA_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    TASK_ID_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => [ "taskId" ],
+      "properties" => {
+        "taskId" => { "type" => "string" }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    SET_LEVEL_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => [ "level" ],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "level" => {
+          "type" => "string",
+          "enum" => %w[alert critical debug emergency error info notice warning]
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    COMPLETE_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => %w[argument ref],
+      "properties" => {
+        "_meta" => REQUEST_META_SCHEMA,
+        "argument" => {
+          "type" => "object",
+          "required" => %w[name value],
+          "properties" => {
+            "name" => { "type" => "string" },
+            "value" => { "type" => "string" }
+          },
+          "additionalProperties" => true
+        },
+        "context" => {
+          "type" => "object",
+          "properties" => {
+            "arguments" => {
+              "type" => "object",
+              "additionalProperties" => { "type" => "string" }
+            }
+          },
+          "additionalProperties" => true
+        },
+        "ref" => {
+          "anyOf" => [
+            {
+              "type" => "object",
+              "required" => %w[name type],
+              "properties" => {
+                "name" => { "type" => "string" },
+                "title" => { "type" => "string" },
+                "type" => { "const" => "ref/prompt" }
+              },
+              "additionalProperties" => true
+            },
+            {
+              "type" => "object",
+              "required" => %w[type uri],
+              "properties" => {
+                "type" => { "const" => "ref/resource" },
+                "uri" => { "type" => "string", "format" => "uri-template" }
+              },
+              "additionalProperties" => true
+            }
+          ]
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    CANCELLED_NOTIFICATION_PARAMS_SCHEMA = {
+      "type" => "object",
+      "properties" => {
+        "_meta" => NOTIFICATION_META_SCHEMA,
+        "reason" => { "type" => "string" },
+        "requestId" => ID_SCHEMA
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    PROGRESS_NOTIFICATION_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => %w[progress progressToken],
+      "properties" => {
+        "_meta" => NOTIFICATION_META_SCHEMA,
+        "message" => { "type" => "string" },
+        "progress" => { "type" => "number" },
+        "progressToken" => PROGRESS_TOKEN_SCHEMA,
+        "total" => { "type" => "number" }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    TASK_STATUS_NOTIFICATION_PARAMS_SCHEMA = {
+      "type" => "object",
+      "required" => %w[createdAt lastUpdatedAt status taskId ttl],
+      "properties" => {
+        "_meta" => NOTIFICATION_META_SCHEMA,
+        "createdAt" => { "type" => "string" },
+        "lastUpdatedAt" => { "type" => "string" },
+        "pollInterval" => { "type" => "integer" },
+        "status" => {
+          "type" => "string",
+          "enum" => %w[cancelled completed failed input_required working]
+        },
+        "statusMessage" => { "type" => "string" },
+        "taskId" => { "type" => "string" },
+        "ttl" => { "type" => [ "integer", "null" ] }
+      },
+      "additionalProperties" => true
+    }.freeze
+
+    MESSAGE_SCHEMA = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "anyOf" => [
+        {
+          "type" => "object",
+          "required" => %w[jsonrpc id method],
+          "properties" => {
+            "jsonrpc" => { "const" => "2.0" },
+            "id" => ID_SCHEMA,
+            "method" => { "type" => "string" },
+            "params" => { "type" => "object", "additionalProperties" => true }
+          },
+          "additionalProperties" => true
+        },
+        {
+          "type" => "object",
+          "required" => %w[jsonrpc method],
+          "not" => { "required" => [ "id" ] },
+          "properties" => {
+            "jsonrpc" => { "const" => "2.0" },
+            "method" => { "type" => "string" },
+            "params" => { "type" => "object", "additionalProperties" => true }
+          },
+          "additionalProperties" => true
+        },
+        {
+          "type" => "object",
+          "required" => %w[jsonrpc id result],
+          "properties" => {
+            "jsonrpc" => { "const" => "2.0" },
+            "id" => ID_SCHEMA,
+            "result" => { "type" => "object", "additionalProperties" => true }
+          },
+          "additionalProperties" => true
+        },
+        {
+          "type" => "object",
+          "required" => %w[jsonrpc error],
+          "properties" => {
+            "jsonrpc" => { "const" => "2.0" },
+            "id" => ID_SCHEMA,
+            "error" => {
+              "type" => "object",
+              "required" => %w[code message],
+              "properties" => {
+                "code" => { "type" => "integer" },
+                "message" => { "type" => "string" },
+                "data" => {}
+              },
+              "additionalProperties" => true
+            }
+          },
+          "additionalProperties" => true
+        }
+      ]
+    }.freeze
+
+    REQUEST_PARAM_SCHEMAS = {
+      "initialize" => INITIALIZE_PARAMS_SCHEMA,
+      "ping" => REQUEST_PARAMS_SCHEMA,
+      "resources/list" => PAGINATED_PARAMS_SCHEMA,
+      "resources/templates/list" => PAGINATED_PARAMS_SCHEMA,
+      "resources/read" => RESOURCE_URI_PARAMS_SCHEMA,
+      "resources/subscribe" => RESOURCE_URI_PARAMS_SCHEMA,
+      "resources/unsubscribe" => RESOURCE_URI_PARAMS_SCHEMA,
+      "prompts/list" => PAGINATED_PARAMS_SCHEMA,
+      "prompts/get" => GET_PROMPT_PARAMS_SCHEMA,
+      "tools/list" => PAGINATED_PARAMS_SCHEMA,
+      "tools/call" => CALL_TOOL_PARAMS_SCHEMA,
+      "tasks/get" => TASK_ID_PARAMS_SCHEMA,
+      "tasks/result" => TASK_ID_PARAMS_SCHEMA,
+      "tasks/cancel" => TASK_ID_PARAMS_SCHEMA,
+      "tasks/list" => PAGINATED_PARAMS_SCHEMA,
+      "logging/setLevel" => SET_LEVEL_PARAMS_SCHEMA,
+      "completion/complete" => COMPLETE_PARAMS_SCHEMA
+    }.freeze
+
+    REQUIRED_REQUEST_PARAMS = %w[
+      initialize
+      resources/read
+      resources/subscribe
+      resources/unsubscribe
+      prompts/get
+      tools/call
+      tasks/get
+      tasks/result
+      tasks/cancel
+      logging/setLevel
+      completion/complete
+    ].freeze
+
+    NOTIFICATION_PARAM_SCHEMAS = {
+      "notifications/cancelled" => CANCELLED_NOTIFICATION_PARAMS_SCHEMA,
+      "notifications/initialized" => NOTIFICATION_PARAMS_SCHEMA,
+      "notifications/progress" => PROGRESS_NOTIFICATION_PARAMS_SCHEMA,
+      "notifications/tasks/status" => TASK_STATUS_NOTIFICATION_PARAMS_SCHEMA,
+      "notifications/roots/list_changed" => NOTIFICATION_PARAMS_SCHEMA
+    }.freeze
+
+    REQUIRED_NOTIFICATION_PARAMS = %w[
+      notifications/cancelled
+      notifications/progress
+      notifications/tasks/status
+    ].freeze
+
+    MESSAGE_SCHEMER = JSONSchemer.schema(MESSAGE_SCHEMA)
+    REQUEST_PARAM_SCHEMERS = REQUEST_PARAM_SCHEMAS.transform_values { |schema| JSONSchemer.schema(schema) }.freeze
+    NOTIFICATION_PARAM_SCHEMERS = NOTIFICATION_PARAM_SCHEMAS.transform_values do |schema|
+      JSONSchemer.schema(schema)
+    end.freeze
+
+    class << self
+      def valid_message?(payload)
+        MESSAGE_SCHEMER.valid?(normalize(payload))
+      end
+
+      def valid?(payload)
+        valid_message?(payload)
+      end
+
+      def valid_initialize_params?(params)
+        REQUEST_PARAM_SCHEMERS.fetch("initialize").valid?(normalize(params))
+      end
+
+      def client_message_validation_error(payload)
+        case payload
+        when JSON_RPC::Request
+          validate_request(payload)
+        when JSON_RPC::Notification
+          validate_notification(payload)
+        end
+      end
+
+      def request_params_validation_error(method, params)
+        schemer = REQUEST_PARAM_SCHEMERS[method]
+        return unless schemer
+
+        validate_params(method, params, schemer, REQUIRED_REQUEST_PARAMS)
+      end
+
+      private
+
+      def validate_request(payload)
+        request_params_validation_error(payload.method, payload.params)
+      end
+
+      def validate_notification(payload)
+        schemer = NOTIFICATION_PARAM_SCHEMERS[payload.method]
+        unless schemer
+          return ValidationError.new(
+            code: :method_not_found,
+            message: "Unsupported MCP notification method: #{payload.method}"
+          )
+        end
+
+        validate_params(payload.method, payload.params, schemer, REQUIRED_NOTIFICATION_PARAMS)
+      end
+
+      def validate_params(method, params, schemer, required_methods)
+        if params.nil?
+          return unless required_methods.include?(method)
+
+          return ValidationError.new(code: :invalid_params, message: "Invalid params for #{method}: params are required")
+        end
+
+        errors = schemer.validate(normalize(params)).to_a
+        return if errors.empty?
+
+        ValidationError.new(
+          code: :invalid_params,
+          message: "Invalid params for #{method}: #{validation_messages(errors).join(', ')}"
+        )
+      end
+
+      def validation_messages(errors)
+        errors.map do |error|
+          error["error"].presence || "#{error['data_pointer'].presence || '/'} (#{error['type']})"
+        end.uniq
+      end
+
+      def normalize(value)
+        value.is_a?(Hash) ? value.deep_stringify_keys : value
+      end
+    end
+  end
+end