actionmcp 0.71.0 → 0.72.0

data/lib/action_mcp/server/{memory_session.rb → base_session.rb}

@@ -2,14 +2,14 @@
 
 module ActionMCP
   module Server
-    # Memory-based session object that mimics ActiveRecord Session
-    class MemorySession
+    # Base session object that mimics ActiveRecord Session with common functionality
+    class BaseSession
       attr_accessor :id, :status, :initialized, :role, :messages_count,
                     :sse_event_counter, :protocol_version, :client_info,
                     :client_capabilities, :server_info, :server_capabilities,
                     :tool_registry, :prompt_registry, :resource_registry,
                     :created_at, :updated_at, :ended_at, :last_event_id,
-                    :session_data
+                    :session_data, :consents
 
       def initialize(attributes = {}, store = nil)
         @store = store
@@ -21,12 +21,15 @@ module ActionMCP
         @message_counter = Concurrent::AtomicFixnum.new(0)
         @new_record = true
 
+        # Initialize consents as empty hash if not provided
+        @consents = {}
+
         attributes.each do |key, value|
           send("#{key}=", value) if respond_to?("#{key}=")
         end
       end
 
-      # Mimic ActiveRecord interface
+      # ActiveRecord-like interface
       def new_record?
         @new_record
       end
@@ -37,7 +40,7 @@ module ActionMCP
 
       def save
         self.updated_at = Time.current
-        @store.save_session(self) if @store
+        @store&.save_session(self)
         @new_record = false
         true
       end
@@ -58,7 +61,7 @@ module ActionMCP
       end
 
       def destroy
-        @store.delete_session(id) if @store
+        @store&.delete_session(id)
       end
 
       def reload
@@ -133,17 +136,13 @@ module ActionMCP
         event = { event_id: event_id, data: data, created_at: Time.current }
         @sse_events << event
 
-        # Maintain cache limit
-        while @sse_events.size > max_events
-          @sse_events.shift
-        end
+        @sse_events.shift while @sse_events.size > max_events
 
         event
       end
 
       def get_sse_events_after(last_event_id, limit = 50)
-        @sse_events.select { |e| e[:event_id] > last_event_id }
-                   .first(limit)
+        @sse_events.select { |e| e[:event_id] > last_event_id }.first(limit)
       end
 
       def cleanup_old_sse_events(max_age = 15.minutes)
@@ -151,14 +150,10 @@ module ActionMCP
         @sse_events.delete_if { |e| e[:created_at] < cutoff_time }
       end
 
-      # Calculates the maximum number of SSE events to store based on configuration
-      # @return [Integer] The maximum number of events
       def max_stored_sse_events
         ActionMCP.configuration.max_stored_sse_events || 100
       end
 
-      # Returns the SSE event retention period from configuration
-      # @return [ActiveSupport::Duration] The retention period (default: 15 minutes)
       def sse_event_retention_period
         ActionMCP.configuration.sse_event_retention_period || 15.minutes
       end
@@ -196,9 +191,9 @@ module ActionMCP
 
       # Subscription management
       def resource_subscribe(uri)
-        unless @subscriptions.any? { |s| s[:uri] == uri }
-          @subscriptions << { uri: uri, created_at: Time.current }
-        end
+        return if @subscriptions.any? { |s| s[:uri] == uri }
+
+        @subscriptions << { uri: uri, created_at: Time.current }
       end
 
       def resource_unsubscribe(uri)
@@ -310,6 +305,29 @@ module ActionMCP
         end
       end
 
+      # Consent management methods
+      def consent_granted_for?(key)
+        consents_hash = consents.is_a?(String) ? JSON.parse(consents) : consents
+        consents_hash ||= {}
+        consents_hash[key] == true
+      end
+
+      def grant_consent(key)
+        consents_hash = consents.is_a?(String) ? JSON.parse(consents) : consents
+        consents_hash ||= {}
+        consents_hash[key] = true
+        self.consents = consents_hash
+        save!
+      end
+
+      def revoke_consent(key)
+        consents_hash = consents.is_a?(String) ? JSON.parse(consents) : consents
+        consents_hash ||= {}
+        consents_hash.delete(key)
+        self.consents = consents_hash
+        save!
+      end
+
       private
 
       def normalize_name(class_or_name, type)
@@ -352,7 +370,6 @@ module ActionMCP
       end
 
       def send_tools_list_changed_notification
-        # Only send if server capabilities allow it
         return unless server_capabilities.dig("tools", "listChanged")
 
         write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
@@ -370,9 +387,7 @@ module ActionMCP
         write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
       end
 
-      public
-
-      # Simple collection classes to mimic ActiveRecord associations
+      # Collection classes
       class MessageCollection < Array
         def create!(attributes)
           self << attributes
@@ -380,7 +395,6 @@ module ActionMCP
         end
 
         def order(field)
-          # Simple ordering implementation
           sort_by { |msg| msg[field] || msg[field.to_s] }
         end
       end
@@ -413,8 +427,7 @@ module ActionMCP
           size
         end
 
-        def where(condition, value)
-          # Simple implementation for "event_id > ?" condition
+        def where(_condition, value)
           select { |e| e[:event_id] > value }
         end
 

data/lib/action_mcp/server/base_session_store.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    class BaseSessionStore
+      include SessionStore
+
+      def initialize
+        @sessions = Concurrent::Hash.new
+      end
+
+      def create_session(session_id = nil, attributes = {})
+        session_id ||= SecureRandom.hex(6)
+
+        session_data = {
+          id: session_id,
+          status: "pre_initialize",
+          initialized: false,
+          role: "server",
+          messages_count: 0,
+          sse_event_counter: 0,
+          created_at: Time.current,
+          updated_at: Time.current
+        }.merge(attributes)
+
+        session = BaseSession.new(session_data, self)
+
+        if session.role == "server"
+          session.server_info = {
+            name: ActionMCP.configuration.name,
+            version: ActionMCP.configuration.version
+          }
+          session.server_capabilities = ActionMCP.configuration.capabilities
+
+          session.tool_registry = ActionMCP.configuration.filtered_tools.map(&:name)
+          session.prompt_registry = ActionMCP.configuration.filtered_prompts.map(&:name)
+          session.resource_registry = ActionMCP.configuration.filtered_resources.map(&:name)
+        end
+
+        @sessions[session_id] = session
+        session
+      end
+
+      def load_session(session_id)
+        session = @sessions[session_id]
+        session&.instance_variable_set(:@new_record, false)
+        session
+      end
+
+      def save_session(session)
+        @sessions[session.id] = session
+      end
+
+      def delete_session(session_id)
+        @sessions.delete(session_id)
+      end
+
+      def session_exists?(session_id)
+        @sessions.key?(session_id)
+      end
+
+      def find_sessions(criteria = {})
+        sessions = @sessions.values
+
+        sessions = sessions.select { |s| s.status == criteria[:status] } if criteria[:status]
+        sessions = sessions.select { |s| s.role == criteria[:role] } if criteria[:role]
+
+        sessions
+      end
+
+      def cleanup_expired_sessions(older_than: 24.hours.ago)
+        expired_ids = @sessions.select { |_id, session| session.updated_at < older_than }.keys
+        expired_ids.each { |id| @sessions.delete(id) }
+        expired_ids.count
+      end
+
+      def clear_all
+        @sessions.clear
+      end
+
+      def session_count
+        @sessions.size
+      end
+    end
+  end
+end

data/lib/action_mcp/server/capabilities.rb

@@ -18,6 +18,7 @@ module ActionMCP
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
           return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
         end
+
         unless ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
           error_message = "Unsupported protocol version. Client requested '#{client_protocol_version}' but server supports #{ActionMCP::SUPPORTED_VERSIONS.join(', ')}"
           error_data = {
@@ -37,7 +38,7 @@ module ActionMCP
         # Handle session resumption if sessionId provided
         if session_id
           existing_session = ActionMCP::Session.find_by(id: session_id)
-          if existing_session && existing_session.initialized?
+          if existing_session&.initialized?
             # Resume existing session - update transport reference
             transport.instance_variable_set(:@session, existing_session)
 

data/lib/action_mcp/server/elicitation.rb

@@ -31,9 +31,7 @@ module ActionMCP
         end
 
         properties = schema[:properties]
-        unless properties.is_a?(Hash)
-          raise ArgumentError, "Elicitation schema must have properties"
-        end
+        raise ArgumentError, "Elicitation schema must have properties" unless properties.is_a?(Hash)
 
         properties.each do |key, prop_schema|
           validate_primitive_schema!(key, prop_schema)
@@ -42,17 +40,13 @@ module ActionMCP
 
       # Validates individual property schemas are primitive types
       def validate_primitive_schema!(key, schema)
-        unless schema.is_a?(Hash)
-          raise ArgumentError, "Property '#{key}' must have a schema definition"
-        end
+        raise ArgumentError, "Property '#{key}' must have a schema definition" unless schema.is_a?(Hash)
 
         type = schema[:type]
         case type
         when "string"
           # Valid string schema, check for enums
-          if schema[:enum] && !schema[:enum].is_a?(Array)
-            raise ArgumentError, "Property '#{key}' enum must be an array"
-          end
+          raise ArgumentError, "Property '#{key}' enum must be an array" if schema[:enum] && !schema[:enum].is_a?(Array)
         when "number", "integer", "boolean"
           # Valid primitive types
         else

data/lib/action_mcp/server/error_handling.rb

@@ -22,10 +22,23 @@ module ActionMCP
       def error_response_from_exception(id, exception)
         if exception.is_a?(JSON_RPC::JsonRpcError)
           error_response(id, exception)
+        elsif Rails.env.development?
+          # Provide more detailed error information in development
+          error_response(id, :internal_error, exception.message, {
+                           class: exception.class.name,
+                           backtrace: exception.backtrace&.first(5)
+                         })
         else
-          error_response(id, :internal_error, exception.message)
+          error_response(id, :internal_error, "An unexpected error occurred")
         end
       end
+
+      # Enhanced error logging
+      def log_error(exception, context = {})
+        Rails.logger.error "[MCP Error] #{exception.class}: #{exception.message}"
+        Rails.logger.error "Context: #{context.inspect}" if context.present?
+        Rails.logger.error exception.backtrace&.first(10)&.join("\n") if Rails.env.development?
+      end
     end
   end
 end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      class Router
+        def initialize(handler)
+          @handler = handler
+        end
+
+        def route(rpc_method, id, params)
+          case rpc_method
+          when "initialize"
+            @handler.handle_initialize(id, params)
+          when %r{^prompts/}
+            @handler.process_prompts(rpc_method, id, params)
+          when %r{^resources/}
+            @handler.process_resources(rpc_method, id, params)
+          when %r{^tools/}
+            @handler.process_tools(rpc_method, id, params)
+          when "completion/complete"
+            @handler.process_completion_complete(id, params)
+          else
+            raise ActionMCP::Server::JSON_RPC::JsonRpcError.new(:method_not_found,
+                                                                message: "Method not found: #{rpc_method}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -31,7 +31,7 @@ module ActionMCP
         rpc_method = request.method
         params = request.params
 
-        result = with_error_handling(id) do
+        with_error_handling(id) do
           common_result = handle_common_methods(rpc_method, id, params)
           if common_result
             common_result
@@ -41,8 +41,6 @@ module ActionMCP
             transport.messaging_mode == :return ? transport.get_last_response : nil
           end
         end
-
-        result
       end
 
       def route_to_handler(rpc_method, id, params)
@@ -80,7 +78,6 @@ module ActionMCP
         response
       end
 
-
       def process_completion_complete(id, params)
         # Extract context if provided
         context = params["context"] if params.is_a?(Hash)
@@ -105,7 +102,7 @@ module ActionMCP
         }
       end
 
-      def build_completion_result(params = {}, context = nil)
+      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

data/lib/action_mcp/server/{messaging.rb → messaging_service.rb}

@@ -2,10 +2,9 @@
 
 module ActionMCP
   module Server
-    module Messaging
-      # Operation mode for the messaging module
-      # :write - writes messages directly (default, for SSE)
-      # :return - returns messages without writing (for JSON responses)
+    module MessagingService
+      include BaseMessaging # For write_message
+
       attr_accessor :messaging_mode
 
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
@@ -13,7 +12,6 @@ module ActionMCP
       end
 
       def send_jsonrpc_response(request_id, result: nil, error: nil)
-        # Only pass the parameters that are actually provided
         args = { id: request_id }
         args[:result] = result unless result.nil?
         args[:error] = error unless error.nil?
@@ -29,9 +27,39 @@ module ActionMCP
         send_jsonrpc_response(request_id, error: error)
       end
 
+      # Specific notifications
+      def send_resources_list_changed_notification
+        send_jsonrpc_notification("notifications/resources/list_changed")
+      end
+
+      def send_resource_updated_notification(uri)
+        send_jsonrpc_notification("notifications/resources/updated", { uri: uri })
+      end
+
+      def send_tools_list_changed_notification
+        send_jsonrpc_notification("notifications/tools/list_changed")
+      end
+
+      def send_prompts_list_changed_notification
+        send_jsonrpc_notification("notifications/prompts/list_changed")
+      end
+
+      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)
+      end
+
+      def send_progress_notification(progressToken:, progress:, total: nil, message: nil, **options)
+        params = { progressToken: progressToken, progress: progress }
+        params[:total] = total unless total.nil?
+        params[:message] = message if message.present?
+        params.merge!(options) if options.any?
+        send_jsonrpc_notification("notifications/progress", params)
+      end
+
       private
 
-      # Factory method to create and send appropriate JSON-RPC message
       def send_message(type, **args)
         message = case type
         when :request
@@ -41,7 +69,6 @@ module ActionMCP
                       params: args[:params]
                     )
         when :response
-                    # Pass only the provided parameters to avoid validation errors
                     response_args = { id: args[:id] }
                     response_args[:result] = args[:result] if args.key?(:result)
                     response_args[:error] = args[:error] if args.key?(:error)
@@ -53,13 +80,10 @@ module ActionMCP
                     )
         end
 
-        if messaging_mode == :return
-          write_message(message)  # This will be intercepted by ResponseCollector
-          message
-        else
-          write_message(message)
-          nil
-        end
+        write_message(message)
+        return unless messaging_mode == :return
+
+        message
       end
     end
   end

data/lib/action_mcp/server/prompts.rb

@@ -20,11 +20,11 @@ module ActionMCP
 
           # Wrap prompt execution with Rails reloader for development
           result = if Rails.env.development? && defined?(Rails.application.reloader)
-            Rails.application.reloader.wrap do
-              prompt.call
-            end
+                     Rails.application.reloader.wrap do
+                       prompt.call
+                     end
           else
-            prompt.call
+                     prompt.call
           end
 
           if result.is_error

data/lib/action_mcp/server/resources.rb

@@ -45,7 +45,25 @@ module ActionMCP
       # @example Output:
       #   # Sends: {"jsonrpc":"2.0","id":"req-789","result":{"contents":[{"uri":"file:///example.txt","text":"Example content"}]}}
       def send_resource_read(id, params)
-        if (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
+        template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri])
+
+        unless template
+          send_jsonrpc_error(id, :resource_not_found, "No resource template found for URI: #{params[:uri]}")
+          return
+        end
+
+        # Check if resource requires consent and if consent is granted
+        if template.respond_to?(:requires_consent?) && template.requires_consent? && !session.consent_granted_for?("resource:#{template.name}")
+          # Use custom error response for consent required (-32002)
+          error = {
+            code: -32_002,
+            message: "Consent required for resource template '#{template.name}'"
+          }
+          send_jsonrpc_response(id, error: error)
+          return
+        end
+
+        begin
           # Create template instance and set execution context
           record = template.process(params[:uri])
           record.with_context({ session: session })
@@ -60,8 +78,9 @@ module ActionMCP
             # Handle successful response - ResourceResponse.contents is already an array
             send_jsonrpc_response(id, result: { contents: response.contents.map(&:to_h) })
           end
-        else
-          send_jsonrpc_error(id, :invalid_params, "Invalid resource URI")
+        rescue StandardError => e
+          log_error(e, { resource_uri: params[:uri], template: template.name })
+          send_jsonrpc_error(id, :internal_error, "Failed to read resource: #{e.message}")
         end
       end
 
@@ -75,7 +94,7 @@ module ActionMCP
       # @example Output:
       #   # Logs: "Registered Resource Templates: ["db://{table}", "file://{path}"]"
       def log_resource_templates
-        # Resource templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}
+        Rails.logger.debug "Registered Resource Templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}"
       end
     end
   end

data/lib/action_mcp/server/session_store_factory.rb

@@ -3,7 +3,7 @@
 module ActionMCP
   module Server
     class SessionStoreFactory
-      def self.create(type = nil, **options)
+      def self.create(type = nil, **_options)
         type ||= default_type
 
         case type.to_sym

data/lib/action_mcp/server/solid_mcp_adapter.rb

@@ -38,13 +38,13 @@ module ActionMCP
           ensure_pubsub.subscribe(session_id) do |message|
             # Message from SolidMCP includes event_type, data, and id
             # Deliver to all callbacks for this session
-            @subscriptions.each do |sub_id, subscription|
-              if subscription[:session_id] == session_id && subscription[:message_callback]
-                begin
-                  subscription[:message_callback].call(message[:data])
-                rescue StandardError => e
-                  log_error("Error in message callback: #{e.message}")
-                end
+            @subscriptions.each_value do |subscription|
+              next unless subscription[:session_id] == session_id && subscription[:message_callback]
+
+              begin
+                subscription[:message_callback].call(message[:data])
+              rescue StandardError => e
+                log_error("Error in message callback: #{e.message}")
               end
             end
           end
@@ -80,7 +80,7 @@ module ActionMCP
         end
 
         # Only unsubscribe from SolidMCP if no more callbacks for this session
-        if @session_callbacks[session_id]&.empty?
+        if @session_callbacks[session_id] && @session_callbacks[session_id].empty?
           ensure_pubsub.unsubscribe(session_id)
           @session_callbacks.delete(session_id)
         end
@@ -125,7 +125,7 @@ module ActionMCP
       private
 
       def ensure_pubsub
-        @pubsub ||= SolidMCP::PubSub.new(@options)
+        @ensure_pubsub ||= SolidMCP::PubSub.new(@options)
       end
 
       def extract_session_id(channel)
@@ -141,7 +141,6 @@ module ActionMCP
         "message"
       end
 
-
       def log_subscription_event(channel, action, subscription_id = nil)
         return unless defined?(Rails) && Rails.respond_to?(:logger)