actionmcp 0.71.1 → 0.80.0

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)
 

data/lib/action_mcp/server/tools.rb

@@ -10,7 +10,7 @@ module ActionMCP
 
         # Send initial progress notification if token is provided
         if progress_token
-          session.send_progress_notification(
+          send_progress_notification(
             progressToken: progress_token,
             progress: 0,
             message: "Starting tools list retrieval"
@@ -26,7 +26,7 @@ module ActionMCP
 
         # Send completion progress notification if token is provided
         if progress_token
-          session.send_progress_notification(
+          send_progress_notification(
             progressToken: progress_token,
             progress: 100,
             message: "Tools list retrieval complete"
@@ -40,51 +40,70 @@ module ActionMCP
         # Find tool in session's registry
         tool_class = session.registered_tools.find { |t| t.tool_name == tool_name }
 
-        if tool_class
-          begin
-            # Create tool and set execution context with request info
-            tool = tool_class.new(arguments)
-            tool.with_context({
-              session: session,
-              request: {
-                params: {
-                  name: tool_name,
-                  arguments: arguments,
-                  _meta: _meta
-                }
-              }
-            })
+        unless tool_class
+          Rails.logger.error "Tool not found: #{tool_name}. Registered tools: #{session.registered_tools.map(&:tool_name).join(', ')}"
+          send_jsonrpc_error(request_id, :method_not_found,
+                             "Tool '#{tool_name}' not found or not registered for this session")
+          return
+        end
+
+        # Check if tool requires consent and if consent is granted
+        if tool_class.respond_to?(:requires_consent?) && tool_class.requires_consent? && !session.consent_granted_for?(tool_name)
+          # Use custom error response for consent required (-32002)
+          error = {
+            code: -32_002,
+            message: "Consent required for tool '#{tool_name}'"
+          }
+          send_jsonrpc_response(request_id, error: error)
+          return
+        end
 
-            # Wrap tool execution with Rails reloader for development
-            result = if Rails.env.development?
-              # Preserve Current attributes across reloader boundary
-              current_user = ActionMCP::Current.user
-              current_gateway = ActionMCP::Current.gateway
+        begin
+          # Create tool and set execution context with request info
+          tool = tool_class.new(arguments)
+          tool.with_context({
+                              session: session,
+                              request: {
+                                params: {
+                                  name: tool_name,
+                                  arguments: arguments,
+                                  _meta: _meta
+                                }
+                              }
+                            })
 
-              Rails.application.reloader.wrap do
-                # Restore Current attributes inside reloader
-                ActionMCP::Current.user = current_user
-                ActionMCP::Current.gateway = current_gateway
-                tool.call
-              end
-            else
-              tool.call
-            end
+          # Wrap tool execution with Rails reloader for development
+          result = if Rails.env.development?
+                     # Preserve Current attributes across reloader boundary
+                     current_user = ActionMCP::Current.user
+                     current_gateway = ActionMCP::Current.gateway
+
+                     Rails.application.reloader.wrap do
+                       # Restore Current attributes inside reloader
+                       ActionMCP::Current.user = current_user
+                       ActionMCP::Current.gateway = current_gateway
+                       tool.call
+                     end
+          else
+                     tool.call
+          end
 
-            if result.is_error
-              # Convert ToolResponse error to proper JSON-RPC error format
-              # Pass the error hash directly - the Response class will handle it
-              error_hash = result.to_h
-              send_jsonrpc_response(request_id, error: error_hash)
-            else
-              send_jsonrpc_response(request_id, result: result)
-            end
-          rescue ArgumentError => e
-            # Handle parameter validation errors
-            send_jsonrpc_error(request_id, :invalid_params, e.message)
+          if result.is_error
+            # Convert ToolResponse error to proper JSON-RPC error format
+            # Pass the error hash directly - the Response class will handle it
+            error_hash = result.to_h
+            send_jsonrpc_response(request_id, error: error_hash)
+          else
+            send_jsonrpc_response(request_id, result: result)
           end
-        else
-          send_jsonrpc_error(request_id, :method_not_found, "Tool '#{tool_name}' not available in this session")
+        rescue ArgumentError => e
+          # Handle parameter validation errors
+          send_jsonrpc_error(request_id, :invalid_params, e.message)
+        rescue StandardError => e
+          # Log the actual error for debugging
+          Rails.logger.error "Tool execution error: #{e.class} - #{e.message}"
+          Rails.logger.error e.backtrace.join("\n")
+          send_jsonrpc_error(request_id, :internal_error, "An unexpected error occurred.")
         end
       end
 

data/lib/action_mcp/server/transport_handler.rb

@@ -12,17 +12,15 @@ module ActionMCP
       delegate :read, :write, to: :session
       include Logging
 
-      include  BaseMessaging  # Provides basic write_message
-      include  Messaging
+      include  MessagingService
       include  Capabilities
       include  Tools
       include  Prompts
       include  Resources
-      include  Notifications
       include  Sampling
       include  Roots
       include  Elicitation
-      include  ResponseCollector  # Must be included last to override write_message
+      include  ResponseCollector # Must be included last to override write_message
 
       # @param [ActionMCP::Session] session
       # @param messaging_mode [:write, :return] The mode for message handling