actionmcp 0.60.2 → 0.71.0

data/lib/action_mcp/resource_template.rb

@@ -26,6 +26,8 @@ module ActionMCP
 
       def abstract!
         @abstract = true
+        # Unregister from the appropriate registry if already registered
+        ActionMCP::ResourceTemplatesRegistry.unregister(self) if ActionMCP::ResourceTemplatesRegistry.items.values.include?(self)
       end
 
       def inherited(subclass)
@@ -33,6 +35,11 @@ module ActionMCP
         subclass.instance_variable_set(:@abstract, false)
         # Create a copy of validation requirements for subclasses
         subclass.instance_variable_set(:@required_parameters, [])
+
+        # Run the ActiveSupport load hook when a resource template is defined
+        subclass.class_eval do
+          ActiveSupport.run_load_hooks(:action_mcp_resource_template, subclass)
+        end
       end
 
       # Track required parameters for validation
@@ -109,6 +116,7 @@ module ActionMCP
       end
 
       def capability_name
+        return "" if name.nil?
         @capability_name ||= name.demodulize.underscore.sub(/_template$/, "")
       end
 
@@ -245,9 +253,29 @@ module ActionMCP
     end
 
     def call
-      run_callbacks :resolve do
-        resolve
+      @response = ResourceResponse.new
+
+      # Validate parameters first
+      unless valid?
+        missing_params = errors.full_messages
+        @response.mark_as_parameter_validation_failed!(missing_params, "template://#{self.class.name}")
+        return @response
+      end
+
+      begin
+        run_callbacks :resolve do
+          result = resolve
+          if result.nil?
+            @response.mark_as_not_found!("template://#{self.class.name}")
+          else
+            @response.add_content(result)
+          end
+        end
+      rescue StandardError => e
+        @response.mark_as_resolution_failed!("template://#{self.class.name}", e.message)
       end
+
+      @response
     end
   end
 end

data/lib/action_mcp/server/capabilities.rb

@@ -18,7 +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.configuration.vibed_ignore_version || ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
+        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 = {
             supported: ActionMCP::SUPPORTED_VERSIONS,
@@ -40,18 +40,11 @@ module ActionMCP
           if existing_session && existing_session.initialized?
             # Resume existing session - update transport reference
             transport.instance_variable_set(:@session, existing_session)
-            Rails.logger.info("Resuming existing session: #{session_id}")
 
             # Return existing session info
             capabilities_payload = existing_session.server_capabilities_payload
-            capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
-                                                       ActionMCP::LATEST_VERSION
-            else
-                                                       client_protocol_version
-            end
+            capabilities_payload[:protocolVersion] = client_protocol_version
             return send_jsonrpc_response(request_id, result: capabilities_payload)
-          else
-            Rails.logger.warn("Session #{session_id} not found or not initialized, creating new session")
           end
         end
 
@@ -65,11 +58,7 @@ module ActionMCP
         end
 
         capabilities_payload = session.server_capabilities_payload
-        capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
-                                                   ActionMCP::LATEST_VERSION
-        else
-                                                   client_protocol_version
-        end
+        capabilities_payload[:protocolVersion] = client_protocol_version
 
         send_jsonrpc_response(request_id, result: capabilities_payload)
       end

data/lib/action_mcp/server/memory_session.rb

@@ -182,7 +182,6 @@ module ActionMCP
       end
 
       def set_protocol_version(version)
-        version = ActionMCP::LATEST_VERSION if ActionMCP.configuration.vibed_ignore_version
         self.protocol_version = version
         save
       end

data/lib/action_mcp/server/prompts.rb

@@ -18,7 +18,14 @@ module ActionMCP
           prompt = prompt_class.new(params)
           prompt.with_context({ session: session })
 
-          result = prompt.call
+          # 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
+          else
+            prompt.call
+          end
 
           if result.is_error
             send_jsonrpc_response(request_id, error: result)

data/lib/action_mcp/server/resources.rb

@@ -50,12 +50,15 @@ module ActionMCP
           record = template.process(params[:uri])
           record.with_context({ session: session })
 
-          if (resource = record.call)
-            resource = [ resource ] unless resource.respond_to?(:each)
-            content = resource.map(&:to_h)
-            send_jsonrpc_response(id, result: { contents: content })
+          response = record.call
+
+          if response.error?
+            # Convert ResourceResponse errors to JSON-RPC errors
+            error_info = response.to_h
+            send_jsonrpc_error(id, error_info[:code], error_info[:message], error_info[:data])
           else
-            send_jsonrpc_error(id, :invalid_params, "Resource not found")
+            # 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")
@@ -72,7 +75,7 @@ module ActionMCP
       # @example Output:
       #   # Logs: "Registered Resource Templates: ["db://{table}", "file://{path}"]"
       def log_resource_templates
-        Rails.logger.info("Registered Resource Templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}")
+        # Resource templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}
       end
     end
   end

data/lib/action_mcp/server/tools.rb

@@ -18,7 +18,9 @@ module ActionMCP
         end
 
         # Use session's registered tools instead of global registry
-        tools = session.registered_tools.map do |tool_class|
+        registered_tools = session.registered_tools
+
+        tools = registered_tools.map do |tool_class|
           tool_class.to_h(protocol_version: protocol_version)
         end
 
@@ -39,28 +41,47 @@ module ActionMCP
         tool_class = session.registered_tools.find { |t| t.tool_name == tool_name }
 
         if tool_class
-          # 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
+          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
+                }
               }
-            }
-          })
+            })
+
+            # 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
 
-          result = tool.call
+              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)
+            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)
           end
         else
           send_jsonrpc_error(request_id, :method_not_found, "Tool '#{tool_name}' not available in this session")

data/lib/action_mcp/server.rb

@@ -30,9 +30,12 @@ module ActionMCP
 
     # Access the session store
     def session_store
-      @session_store ||= SessionStoreFactory.create(
-        ActionMCP.configuration.server_session_store_type
-      )
+      current_type = ActionMCP.configuration.server_session_store_type
+      if @session_store.nil? || @session_store_type != current_type
+        @session_store_type = current_type
+        @session_store = SessionStoreFactory.create(current_type)
+      end
+      @session_store
     end
 
     # Available pubsub adapter types

data/lib/action_mcp/sse_listener.rb

@@ -19,10 +19,7 @@ module ActionMCP
     # @yield [Hash] Yields parsed message received from the pub/sub channel
     # @return [Boolean] True if subscription was successful within timeout, false otherwise.
     def start(&callback)
-      Rails.logger.debug "SSEListener: Starting for channel: #{session_key}"
-
       success_callback = lambda {
-        Rails.logger.info "SSEListener: Successfully subscribed to channel: #{session_key}"
         @subscription_active.make_true
       }
 
@@ -41,7 +38,6 @@ module ActionMCP
       return if @stopped.true?
 
       @stopped.make_true
-      Rails.logger.debug "SSEListener: Stopping listener for channel: #{session_key}"
     end
 
     private
@@ -50,8 +46,6 @@ module ActionMCP
       return if @stopped.true?
 
       begin
-        Rails.logger.debug "SSEListener: Received raw message of type: #{raw_message.class}"
-
         # Check if the message is a valid JSON string or has a message attribute
         if raw_message.is_a?(String) && valid_json_format?(raw_message)
           message = MultiJson.load(raw_message)
@@ -80,7 +74,6 @@ module ActionMCP
       begin
         subscription_future.value(5) || @subscription_active.true?
       rescue Concurrent::TimeoutError
-        Rails.logger.warn "SSEListener: Timed out waiting for subscription for #{session_key}"
         false
       end
     end

data/lib/action_mcp/test_helper.rb

@@ -49,6 +49,11 @@ module ActionMCP
     end
     alias execute_tool execute_mcp_tool
 
+    def execute_mcp_tool_with_error(name, args = {})
+      ActionMCP::ToolsRegistry.tool_call(name, args)
+    end
+    alias execute_tool_with_error execute_mcp_tool_with_error
+
     def execute_mcp_prompt(name, args = {})
       resp = ActionMCP::PromptsRegistry.prompt_call(name, args)
       assert !resp.is_error, "Prompt #{name.inspect} returned error: #{resp.to_h[:message]}"

data/lib/action_mcp/tool.rb

@@ -43,6 +43,7 @@ module ActionMCP
     #
     # @return [String] The default tool name.
     def self.default_tool_name
+      return "" if name.nil?
       name.demodulize.underscore.sub(/_tool$/, "")
     end
 
@@ -53,6 +54,19 @@ module ActionMCP
         :tool
       end
 
+      def unregister_from_registry
+        ActionMCP::ToolsRegistry.unregister(self) if ActionMCP::ToolsRegistry.items.values.include?(self)
+      end
+
+      # Hook called when a class inherits from Tool
+      def inherited(subclass)
+        super
+        # Run the ActiveSupport load hook when a tool is defined
+        subclass.class_eval do
+          ActiveSupport.run_load_hooks(:action_mcp_tool, subclass)
+        end
+      end
+
       def annotate(key, value)
         self._annotations = _annotations.merge(key.to_s => value)
       end
@@ -162,7 +176,7 @@ module ActionMCP
 
       return unless %w[number integer].include?(type)
 
-      validates prop_name, numericality: true, allow_nil: true
+      validates prop_name, numericality: true, allow_nil: !required
     end
 
     # --------------------------------------------------------------------------
@@ -243,6 +257,13 @@ module ActionMCP
     # Instance Methods
     # --------------------------------------------------------------------------
 
+    # Override initialize to validate parameters before ActiveModel conversion
+    def initialize(attributes = {})
+      # Validate parameters before ActiveModel processes them
+      validate_parameter_types(attributes)
+      super
+    end
+
     # Public entry point for executing the tool
     # Returns an array of Content objects collected from render calls
     def call
@@ -259,14 +280,16 @@ module ActionMCP
           @response.mark_as_error!(:internal_error, message: e.message)
         end
       else
-        @response.mark_as_error!(:invalid_request,
+        @response.mark_as_error!(:invalid_params,
                                  message: "Invalid input",
                                  data: errors.full_messages)
       end
 
       # If callbacks halted execution (`performed` still false) and
-      # nothing else marked an error, surface it as invalid_request.
-      @response.mark_as_error!(:invalid_request, message: "Aborted by callback") if !performed && !@response.error?
+      # nothing else marked an error, surface it as invalid_params.
+      if !performed && !@response.error?
+        @response.mark_as_error!(:invalid_params, message: "Tool execution was aborted")
+      end
 
       @response
     end
@@ -348,5 +371,86 @@ module ActionMCP
     end
 
     private_class_method :map_json_type_to_active_model_type
+
+    private
+
+    # Validates parameter types before ActiveModel conversion
+    def validate_parameter_types(attributes)
+      return unless attributes.is_a?(Hash)
+
+      attributes.each do |key, value|
+        key_str = key.to_s
+        property_schema = self.class._schema_properties[key_str]
+
+        next unless property_schema
+
+        expected_type = property_schema[:type]
+
+        # Skip validation if value is nil and property is not required
+        next if value.nil? && !self.class._required_properties.include?(key_str)
+
+        # Validate based on expected JSON Schema type
+        case expected_type
+        when "number"
+          validate_number_parameter(key_str, value)
+        when "integer"
+          validate_integer_parameter(key_str, value)
+        when "string"
+          validate_string_parameter(key_str, value)
+        when "boolean"
+          validate_boolean_parameter(key_str, value)
+        when "array"
+          validate_array_parameter(key_str, value, property_schema)
+        end
+      end
+    end
+
+    def validate_number_parameter(key, value)
+      return if value.is_a?(Numeric)
+
+      if value.is_a?(String)
+        # Check if string can be converted to a valid number
+        begin
+          Float(value)
+        rescue ArgumentError, TypeError
+          raise ArgumentError, "Parameter '#{key}' must be a valid number, got: #{value.inspect}"
+        end
+      else
+        raise ArgumentError, "Parameter '#{key}' must be a number, got: #{value.class}"
+      end
+    end
+
+    def validate_integer_parameter(key, value)
+      return if value.is_a?(Integer)
+
+      if value.is_a?(String)
+        # Check if string can be converted to a valid integer
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          raise ArgumentError, "Parameter '#{key}' must be a valid integer, got: #{value.inspect}"
+        end
+      else
+        raise ArgumentError, "Parameter '#{key}' must be an integer, got: #{value.class}"
+      end
+    end
+
+    def validate_string_parameter(key, value)
+      return if value.is_a?(String)
+
+      raise ArgumentError, "Parameter '#{key}' must be a string, got: #{value.class}"
+    end
+
+    def validate_boolean_parameter(key, value)
+      return if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      raise ArgumentError, "Parameter '#{key}' must be a boolean, got: #{value.class}"
+    end
+
+    def validate_array_parameter(key, value, property_schema)
+      return if value.is_a?(Array)
+
+      raise ArgumentError, "Parameter '#{key}' must be an array, got: #{value.class}"
+    end
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -22,6 +22,9 @@ module ActionMCP
         tool.call
       rescue RegistryBase::NotFound
         error_response(:invalid_params, message: "Tool not found: #{tool_name}")
+      rescue ArgumentError => e
+        # Handle parameter validation errors
+        error_response(:invalid_params, message: e.message)
       rescue StandardError => e
         # FIXME, we should maybe not return the error message to the user
         error_response(:invalid_params, message: "Tool execution failed: #{e.message}")

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.60.2"
+  VERSION = "0.71.0"
 
   class << self
     alias version gem_version

data/lib/generators/action_mcp/install/templates/mcp.yml

@@ -5,17 +5,17 @@
 shared:
   # Authentication configuration - array of methods to try in order
   authentication: ["none"]  # No authentication required by default
-  
+
   # Session store configuration
   # Global session store type used by both client and server (default: volatile in dev/test, active_record in production)
   # session_store_type: volatile
-  
+
   # Client-specific session store type (falls back to session_store_type if not specified)
   # client_session_store_type: volatile
-  
+
   # Server-specific session store type (falls back to session_store_type if not specified)
   # server_session_store_type: active_record
-  
+
   # OAuth configuration (if using OAuth authentication)
   # oauth:
   #   provider: "demo_oauth_provider"
@@ -24,7 +24,7 @@ shared:
   #   enable_token_revocation: true
   #   pkce_required: true
   #   issuer_url: https://yourapp.com
-  
+
   # MCP capability profiles
   profiles:
     primary:
@@ -38,7 +38,7 @@ shared:
         list_changed: false
         logging_enabled: true
         resources_subscribe: false
-        
+
     minimal:
       tools: []
       prompts: []
@@ -53,13 +53,13 @@ shared:
 development:
   # Use simple pub/sub adapter for development
   adapter: simple
-  
+
   # Session store examples for development
   # Use volatile client sessions for faster development
   # client_session_store_type: volatile
   # Use persistent server sessions to maintain state across restarts
   # server_session_store_type: active_record
-  
+
   # Thread pool configuration (optional)
   # min_threads: 5     # Minimum number of threads in the pool
   # max_threads: 10    # Maximum number of threads in the pool
@@ -69,10 +69,10 @@ development:
 test:
   # JWT authentication for testing environment
   authentication: ["jwt"]
-  
+
   # Test adapter for testing
   adapter: test
-  
+
   # Use volatile sessions for testing (fast cleanup)
   # session_store_type: volatile
 
@@ -80,7 +80,7 @@ test:
 production:
   # Multiple authentication methods - try OAuth first, fallback to JWT
   authentication: ["oauth", "jwt"]
-  
+
   # OAuth configuration for production
   oauth:
     provider: "application_oauth_provider"  # Your custom provider class
@@ -89,29 +89,29 @@ production:
     enable_token_revocation: true
     pkce_required: true
     issuer_url: https://yourapp.com
-  
+
   # Additional production profiles for external clients
   profiles:
     external_clients:
       tools: ["WeatherForecastTool"]  # Limited tool access for external clients
       prompts: []
       resources: []
-  
+
   # Production session store configuration
   # Use persistent storage for production reliability
   # session_store_type: active_record
   # Or configure separately:
   # client_session_store_type: active_record  # Client connections persist across restarts
   # server_session_store_type: active_record  # Server state persists across deployments
-  
+
   # Choose one of the following adapters:
-  
+
   # 1. Database-backed adapter (recommended)
   adapter: solid_mcp
   polling_interval: 0.5.seconds
   batch_size: 200      # Number of messages to write in a single batch
   flush_interval: 0.05 # Seconds between batch flushes
-  
+
   # Thread pool configuration (optional)
   min_threads: 10     # Minimum number of threads in the pool
   max_threads: 20     # Maximum number of threads in the pool