actionmcp 0.60.1 → 0.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2384a0cea84e17ca34e3c46e4029e2dc008561ebeeb8e52f15cb05c3fb5f5eb4
-  data.tar.gz: ccba3d9432ae0be54a4950e2f5d357c55fdd39cec2766253e2b3093dba9eedd8
+  metadata.gz: 5b498d3bdd7cde670eef99ba3458e4af3808ce1eaf2cb29c369bdaa3048a9098
+  data.tar.gz: a3f0f8db133018b5f9a2ee822f35a59c0cbf79301be7b69c894ef4daa2f99472
 SHA512:
-  metadata.gz: e7ed0c8b71d4211dc48388a7544c17ecb9ff674faad9274cd1225cb3e3a65f76bcb546c2c2353882a1ade9016670659fed38aa1c90aa94e17479149012e1be01
-  data.tar.gz: add51e3d310ec89d96bef2767008bc4be9f9bddfeda60ca826d6e9168485771ebf61c03e1011c889d0a57fb4ff3d7bb0e0f5c5046cb35ca69a5285d647fe71d2
+  metadata.gz: 4880debf4726112a664348076862e92c92578c9d4cafd6a0ac923944e37d5c6929bab0b3779bcc322fd478b19f57635f629be76100e9b3254b4fd3895c3eff13
+  data.tar.gz: dba72df2677959588c73431c99cd7a3a3d176ac3fcbfea99d5ea2c53e2ff96aac228a5a46d5f3dc8c7b1f79a9f2cb1467d0a784236d613deeddb135ddcf300bd

data/README.md

@@ -237,30 +237,12 @@ module Tron
     config.action_mcp.version = "1.2.3"                               # defaults to "0.0.1"
     config.action_mcp.logging_enabled = true                          # defaults to true
     config.action_mcp.logging_level = :info                           # defaults to :info, can be :debug, :info, :warn, :error, :fatal
-    config.action_mcp.vibed_ignore_version = false                    # defaults to false, set to true to ignore client protocol version mismatches
   end
 end
 ```
 
 For dynamic versioning, consider adding the `rails_app_version` gem.
 
-### Protocol Version Compatibility
-
-By default, ActionMCP requires clients to use the exact protocol version supported by the server (currently "2025-03-26"). If the client specifies a different version during initialization, the request will be rejected with an error.
-
-To support clients with incompatible protocol versions, you can enable the `vibed_ignore_version` option:
-
-```ruby
-# In config/application.rb or an initializer
-Rails.application.config.action_mcp.vibed_ignore_version = true
-```
-
-When enabled, the server will ignore protocol version mismatches from clients and always use the latest supported version. This is useful for:
-- Development environments with older client libraries
-- Supporting clients that cannot be easily updated
-- Situations where protocol differences are minor and known to be compatible
-
-> **Note:** Using `vibed_ignore_version = true` in production is not recommended as it may lead to unexpected behavior if clients rely on specific protocol features that differ between versions.
 
 ### PubSub Configuration
 

data/app/controllers/action_mcp/application_controller.rb

@@ -12,6 +12,7 @@ module ActionMCP
     include ActionController::Live
     include ActionController::Instrumentation
 
+
     # Provides the ActionMCP::Session for the current request.
     # Handles finding existing sessions via header/param or initializing a new one.
     # Specific controllers/handlers might need to enforce session ID presence based on context.
@@ -143,7 +144,7 @@ module ActionMCP
     # @route POST /mcp
     def create
       unless post_accept_headers_valid?
-        id = extract_jsonrpc_id_from_params
+        id = extract_jsonrpc_id_from_request
         return render_not_acceptable(post_accept_headers_error_message, id)
       end
 
@@ -157,8 +158,7 @@ module ActionMCP
       session = mcp_session
 
       # Validate MCP-Protocol-Version header for non-initialize requests
-      # Temporarily disabled to debug session issues
-      # return unless validate_protocol_version_header
+      return unless validate_protocol_version_header
 
       unless is_initialize_request
         if session_initially_missing
@@ -228,18 +228,26 @@ module ActionMCP
       # Skip validation for initialize requests
       return true if check_if_initialize_request(jsonrpc_params)
 
-      header_version = request.headers["MCP-Protocol-Version"]
+      # Check for both case variations of the header (spec uses MCP-Protocol-Version)
+      header_version = request.headers["MCP-Protocol-Version"] || request.headers["mcp-protocol-version"]
       session = mcp_session
 
-      # If header is missing, assume 2025-03-26 for backward compatibility
+      # If header is missing, assume 2025-03-26 for backward compatibility as per spec
       if header_version.nil?
-        Rails.logger.debug "MCP-Protocol-Version header missing, assuming 2025-03-26 for backward compatibility"
+        ActionMCP.logger.debug "MCP-Protocol-Version header missing, assuming 2025-03-26 for backward compatibility"
         return true
       end
 
+      # Handle array values (take the last one as per TypeScript SDK)
+      if header_version.is_a?(Array)
+        header_version = header_version.last
+      end
+
       # Check if the header version is supported
       unless ActionMCP::SUPPORTED_VERSIONS.include?(header_version)
-        render_bad_request("Unsupported MCP-Protocol-Version: #{header_version}")
+        supported_versions = ActionMCP::SUPPORTED_VERSIONS.join(", ")
+        ActionMCP.logger.warn "Unsupported MCP-Protocol-Version: #{header_version}. Supported versions: #{supported_versions}"
+        render_protocol_version_error("Unsupported MCP-Protocol-Version: #{header_version}. Supported versions: #{supported_versions}")
         return false
       end
 
@@ -247,12 +255,13 @@ module ActionMCP
       if session && session.initialized?
         negotiated_version = session.protocol_version
         if header_version != negotiated_version
-          Rails.logger.warn "MCP-Protocol-Version mismatch: header=#{header_version}, negotiated=#{negotiated_version}"
-          render_bad_request("MCP-Protocol-Version header (#{header_version}) does not match negotiated version (#{negotiated_version})")
+          ActionMCP.logger.warn "MCP-Protocol-Version mismatch: header=#{header_version}, negotiated=#{negotiated_version}"
+          render_protocol_version_error("MCP-Protocol-Version header (#{header_version}) does not match negotiated version (#{negotiated_version})")
           return false
         end
       end
 
+      ActionMCP.logger.debug "MCP-Protocol-Version header validation passed: #{header_version}"
       true
     end
 
@@ -260,12 +269,12 @@ module ActionMCP
     # Note: This doesn't save the new session; that happens upon first use or explicitly.
     def find_or_initialize_session
       session_id = extract_session_id
+      session_store = ActionMCP::Server.session_store
+
       if session_id
-        session = Server.session_store.load_session(session_id)
-        # Session protocol version is set during initialization and should not be overridden
-        session
+        session_store.load_session(session_id)
       else
-        Server.session_store.create_session(nil, protocol_version: ActionMCP::DEFAULT_PROTOCOL_VERSION)
+        session_store.create_session(nil, protocol_version: ActionMCP::DEFAULT_PROTOCOL_VERSION)
       end
     end
 
@@ -415,6 +424,12 @@ module ActionMCP
       render json: { jsonrpc: "2.0", id: id, error: { code: -32_600, message: message } }
     end
 
+    # Renders a 400 Bad Request response for protocol version errors as per MCP spec
+    def render_protocol_version_error(message = "Protocol Version Error", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_000, message: message } }, status: :bad_request
+    end
+
     # Renders a 404 Not Found response with a JSON-RPC-like error structure.
     def render_not_found(message = "Not Found", id = nil)
       id ||= extract_jsonrpc_id_from_request

data/app/models/action_mcp/session/message.rb

@@ -4,17 +4,17 @@
 #
 # Table name: action_mcp_session_messages
 #
-#  id                                     :bigint           not null, primary key
-#  direction(The message recipient)       :string           default("client"), not null
-#  is_ping(Whether the message is a ping) :boolean          default(FALSE), not null
-#  message_json                           :json
-#  message_type(The type of the message)  :string           not null
-#  request_acknowledged                   :boolean          default(FALSE), not null
-#  request_cancelled                      :boolean          default(FALSE), not null
-#  created_at                             :datetime         not null
-#  updated_at                             :datetime         not null
-#  jsonrpc_id                             :string
-#  session_id                             :string           not null
+#  id                               :bigint           not null, primary key
+#  direction(The message recipient) :string           default("client"), not null
+#  is_ping                          :boolean          default(FALSE), not null
+#  message_json                     :json
+#  message_type                     :string           not null
+#  request_acknowledged             :boolean          default(FALSE), not null
+#  request_cancelled                :boolean          default(FALSE), not null
+#  created_at                       :datetime         not null
+#  updated_at                       :datetime         not null
+#  jsonrpc_id                       :string
+#  session_id                       :string           not null
 #
 # Indexes
 #
@@ -22,7 +22,7 @@
 #
 # Foreign Keys
 #
-#  fk_action_mcp_session_messages_session_id  (session_id => action_mcp_sessions.id) ON DELETE => cascade ON UPDATE => cascade
+#  fk_rails_...  (session_id => action_mcp_sessions.id) ON DELETE => cascade ON UPDATE => cascade
 #
 module ActionMCP
   class Session

data/app/models/action_mcp/session.rb

@@ -75,9 +75,7 @@ module ActionMCP
     before_create :set_server_info, if: -> { role == "server" }
     before_create :set_server_capabilities, if: -> { role == "server" }
 
-    validates :protocol_version, inclusion: { in: ActionMCP::SUPPORTED_VERSIONS }, allow_nil: true, unless: lambda {
-      ActionMCP.configuration.vibed_ignore_version
-    }
+    validates :protocol_version, inclusion: { in: ActionMCP::SUPPORTED_VERSIONS }, allow_nil: true
 
     def close!
       dummy_callback = ->(*) { } # this callback seem broken
@@ -115,8 +113,6 @@ module ActionMCP
     end
 
     def set_protocol_version(version)
-      # If vibed_ignore_version is true, always use the latest supported version
-      version = PROTOCOL_VERSION if ActionMCP.configuration.vibed_ignore_version
       update(protocol_version: version)
     end
 
@@ -311,29 +307,58 @@ module ActionMCP
 
     # Get registered items for this session
     def registered_tools
-      (self.tool_registry || []).filter_map do |tool_name|
-        ActionMCP::ToolsRegistry.find(tool_name)
-      rescue StandardError
-        nil
+      # Special case: ['*'] means use all available tools dynamically
+      if tool_registry == [ "*" ]
+        # filtered_tools returns a RegistryScope with Item objects, need to extract the klass
+        ActionMCP.configuration.filtered_tools.map(&:klass)
+      else
+        (self.tool_registry || []).filter_map do |tool_name|
+          ActionMCP::ToolsRegistry.find(tool_name)
+        rescue StandardError
+          nil
+        end
       end
     end
 
     def registered_prompts
-      (self.prompt_registry || []).filter_map do |prompt_name|
-        ActionMCP::PromptsRegistry.find(prompt_name)
-      rescue StandardError
-        nil
+      if prompt_registry == [ "*" ]
+        # filtered_prompts returns a RegistryScope with Item objects, need to extract the klass
+        ActionMCP.configuration.filtered_prompts.map(&:klass)
+      else
+        (self.prompt_registry || []).filter_map do |prompt_name|
+          ActionMCP::PromptsRegistry.find(prompt_name)
+        rescue StandardError
+          nil
+        end
       end
     end
 
     def registered_resource_templates
-      (self.resource_registry || []).filter_map do |template_name|
-        ActionMCP::ResourceTemplatesRegistry.find(template_name)
-      rescue StandardError
-        nil
+      if resource_registry == [ "*" ]
+        # filtered_resources returns a RegistryScope with Item objects, need to extract the klass
+        ActionMCP.configuration.filtered_resources.map(&:klass)
+      else
+        (self.resource_registry || []).filter_map do |template_name|
+          ActionMCP::ResourceTemplatesRegistry.find(template_name)
+        rescue StandardError
+          nil
+        end
       end
     end
 
+    # Helper methods to check if using all capabilities
+    def uses_all_tools?
+      tool_registry == [ "*" ]
+    end
+
+    def uses_all_prompts?
+      prompt_registry == [ "*" ]
+    end
+
+    def uses_all_resources?
+      resource_registry == [ "*" ]
+    end
+
     # OAuth Session Management
     # Required by MCP 2025-03-26 specification for session binding
 
@@ -443,10 +468,10 @@ module ActionMCP
     end
 
     def initialize_registries
-      # Start with default registries from configuration
-      self.tool_registry = ActionMCP.configuration.filtered_tools.map(&:name)
-      self.prompt_registry = ActionMCP.configuration.filtered_prompts.map(&:name)
-      self.resource_registry = ActionMCP.configuration.filtered_resources.map(&:name)
+      # Default to using all available capabilities with '*'
+      self.tool_registry = [ "*" ]
+      self.prompt_registry = [ "*" ]
+      self.resource_registry = [ "*" ]
     end
 
     def normalize_name(class_or_name, type)

data/lib/action_mcp/base_response.rb

@@ -19,7 +19,7 @@ module ActionMCP
     end
 
     # Convert to hash format expected by MCP protocol
-    def to_h
+    def to_h(options = nil)
       if @is_error
         JSON_RPC::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
       else

data/lib/action_mcp/capability.rb

@@ -49,6 +49,8 @@ module ActionMCP
     # @return [void]
     def self.abstract!
       self.abstract_capability = true
+      # Unregister from the appropriate registry if already registered
+      unregister_from_registry
     end
 
     # Returns whether this tool is abstract.

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -35,12 +35,12 @@ module ActionMCP
 
       def handle_notification(notification)
         # Handle server notifications to client
-        puts "\e[33mReceived notification: #{notification.method}\e[0m"
+        client.log_debug("Received notification: #{notification.method}")
       end
 
       def handle_response(response)
         # Handle server responses to client requests
-        puts "\e[32mReceived response: #{response.id} - #{response.result ? 'success' : 'error'}\e[0m"
+        client.log_debug("Received response: #{response.id} - #{response.result ? 'success' : 'error'}")
       end
 
       protected
@@ -60,7 +60,7 @@ module ActionMCP
         else
           common_result = handle_common_methods(rpc_method, id, params)
           if common_result.nil?
-            puts "\e[31mUnknown server method: #{rpc_method} #{id} #{params}\e[0m"
+            client.log_warn("Unknown server method: #{rpc_method} #{id} #{params}")
           end
         end
       end
@@ -94,19 +94,19 @@ module ActionMCP
       def process_notifications(rpc_method, params)
         case rpc_method
         when "notifications/resources/updated" # Resource update notification
-          puts "\e[31m Resource #{params['uri']} was updated\e[0m"
+          client.log_debug("Resource #{params['uri']} was updated")
           # Handle resource update notification
           # TODO: fetch updated resource or mark it as stale
         when "notifications/tools/list_changed" # Tool list change notification
-          puts "\e[31m Tool list has changed\e[0m"
+          client.log_debug("Tool list has changed")
           # Handle tool list change notification
           # TODO: fetch new tools or mark them as stale
         when "notifications/prompts/list_changed" # Prompt list change notification
-          puts "\e[31m Prompt list has changed\e[0m"
+          client.log_debug("Prompt list has changed")
           # Handle prompt list change notification
           # TODO: fetch new prompts or mark them as stale
         when "notifications/resources/list_changed" # Resource list change notification
-          puts "\e[31m Resource list has changed\e[0m"
+          client.log_debug("Resource list has changed")
           # Handle resource list change notification
           # TODO: fetch new resources or mark them as stale
         else
@@ -153,12 +153,12 @@ module ActionMCP
           return true
         end
 
-        puts "\e[31mUnknown response: #{id} #{result}\e[0m"
+        client.log_warn("Unknown response: #{id} #{result}")
       end
 
       def process_error(id, error)
         # Do something ?
-        puts "\e[31mUnknown error: #{id} #{error}\e[0m"
+        client.log_error("Unknown error: #{id} #{error}")
       end
 
       def handle_initialize_response(request_id, result)

data/lib/action_mcp/configuration.rb

@@ -33,8 +33,6 @@ module ActionMCP
                   :sse_heartbeat_interval,
                   :post_response_preference, # :json or :sse
                   :protocol_version,
-                  # --- VibedIgnoreVersion Option ---
-                  :vibed_ignore_version,
                   # --- SSE Resumability Options ---
                   :sse_event_retention_period,
                   :max_stored_sse_events,
@@ -68,7 +66,6 @@ module ActionMCP
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
       @protocol_version = "2025-03-26"  # Default to legacy for backwards compatibility
-      @vibed_ignore_version = false
 
       # Resumability defaults
       @sse_event_retention_period = 15.minutes
@@ -178,15 +175,25 @@ module ActionMCP
     # Returns capabilities based on active profile
     def capabilities
       capabilities = {}
+      profile = @profiles[active_profile]
 
-      # Only include capabilities if the corresponding filtered registry is non-empty
-      capabilities[:tools] = { listChanged: @list_changed } if filtered_tools.any?
+      # Check profile configuration instead of registry contents
+      # If profile includes tools (either "all" or specific tools), advertise tools capability
+      if profile && profile[:tools] && profile[:tools].any?
+        capabilities[:tools] = { listChanged: @list_changed }
+      end
 
-      capabilities[:prompts] = { listChanged: @list_changed } if filtered_prompts.any?
+      # If profile includes prompts, advertise prompts capability
+      if profile && profile[:prompts] && profile[:prompts].any?
+        capabilities[:prompts] = { listChanged: @list_changed }
+      end
 
       capabilities[:logging] = {} if @logging_enabled
 
-      capabilities[:resources] = { subscribe: @resources_subscribe } if filtered_resources.any?
+      # If profile includes resources, advertise resources capability
+      if profile && profile[:resources] && profile[:resources].any?
+        capabilities[:resources] = { subscribe: @resources_subscribe }
+      end
 
       capabilities[:elicitation] = {} if @elicitation_enabled
 
@@ -214,6 +221,20 @@ module ActionMCP
       @resources_subscribe = options[:resources_subscribe] unless options[:resources_subscribe].nil?
     end
 
+    def eager_load_if_needed
+      profile = @profiles[active_profile]
+      return unless profile
+
+      # Check if any component type includes "all"
+      needs_eager_load = profile[:tools]&.include?("all") ||
+                        profile[:prompts]&.include?("all") ||
+                        profile[:resources]&.include?("all")
+
+      if needs_eager_load
+        ensure_mcp_components_loaded
+      end
+    end
+
     private
 
     def default_profiles
@@ -303,6 +324,41 @@ module ActionMCP
     rescue LoadError
       false
     end
+
+    def ensure_mcp_components_loaded
+      # Only load if we haven't loaded yet - but in development, always reload
+      return if @mcp_components_loaded && !Rails.env.development?
+
+      # Use Zeitwerk eager loading if available (in to_prepare phase)
+      mcp_path = Rails.root.join("app/mcp")
+      if mcp_path.exist? && Rails.autoloaders.main.respond_to?(:eager_load_dir)
+        # This will trigger all inherited hooks properly
+        Rails.autoloaders.main.eager_load_dir(mcp_path)
+      elsif mcp_path.exist?
+        # Fallback for initialization phase - use require_dependency
+        # Load base classes first in specific order
+        base_files = [
+          mcp_path.join("application_gateway.rb"),
+          mcp_path.join("tools/application_mcp_tool.rb"),
+          mcp_path.join("prompts/application_mcp_prompt.rb"),
+          mcp_path.join("resource_templates/application_mcp_res_template.rb"),
+          # Load ArithmeticTool before other tools that inherit from it
+          mcp_path.join("tools/arithmetic_tool.rb")
+        ]
+
+        base_files.each do |file|
+          require_dependency file.to_s if file.exist?
+        end
+
+        # Then load all other files
+        Dir.glob(mcp_path.join("**/*.rb")).sort.each do |file|
+          # Skip base classes we already loaded
+          next if base_files.any? { |base| file == base.to_s }
+          require_dependency file
+        end
+      end
+      @mcp_components_loaded = true unless Rails.env.development?
+    end
   end
 
   class << self

data/lib/action_mcp/engine.rb

@@ -18,8 +18,33 @@ module ActionMCP
     # Provide a configuration namespace for ActionMCP
     config.action_mcp = ActionMCP.configuration
 
+    # Create the ActiveSupport load hooks
+    ActiveSupport.on_load(:action_mcp_tool) do
+      # Register the tool when it's loaded
+      ActionMCP::ToolsRegistry.register(self) unless abstract?
+    end
+
+    ActiveSupport.on_load(:action_mcp_prompt) do
+      # Register the prompt when it's loaded
+      ActionMCP::PromptsRegistry.register(self) unless abstract?
+    end
+
+    ActiveSupport.on_load(:action_mcp_resource_template) do
+      # Register the resource template when it's loaded
+      ActionMCP::ResourceTemplatesRegistry.register(self) unless abstract?
+    end
+
     config.to_prepare do
-      ActionMCP::ResourceTemplate.registered_templates.clear
+      # Only clear registries if we're in development mode
+      if Rails.env.development?
+        ActionMCP::ResourceTemplate.registered_templates.clear
+        ActionMCP::ToolsRegistry.clear!
+        ActionMCP::PromptsRegistry.clear!
+      end
+
+      # Eager load MCP components if profile includes "all"
+      # This runs after Zeitwerk is fully set up
+      ActionMCP.configuration.eager_load_if_needed
     end
 
     config.middleware.use JSONRPC_Rails::Middleware::Validator, [ "/" ]

data/lib/action_mcp/prompt.rb

@@ -27,6 +27,7 @@ module ActionMCP
     #
     # @return [String] The default prompt name.
     def self.default_prompt_name
+      return "" if name.nil?
       name.demodulize.underscore.sub(/_prompt$/, "")
     end
 
@@ -37,6 +38,19 @@ module ActionMCP
         :prompt
       end
 
+      def unregister_from_registry
+        ActionMCP::PromptsRegistry.unregister(self) if ActionMCP::PromptsRegistry.items.values.include?(self)
+      end
+
+      # Hook called when a class inherits from Prompt
+      def inherited(subclass)
+        super
+        # Run the ActiveSupport load hook when a prompt is defined
+        subclass.class_eval do
+          ActiveSupport.run_load_hooks(:action_mcp_prompt, subclass)
+        end
+      end
+
       # Sets or retrieves the _meta field
       def meta(data = nil)
         if data

data/lib/action_mcp/registry_base.rb

@@ -11,11 +11,25 @@ module ActionMCP
       #
       # @return [Hash] A hash of registered items.
       def items
-        @items = item_klass.descendants.each_with_object({}) do |klass, hash|
-          next if klass.abstract?
+        @items ||= {}
+      end
+
+      # Register an item explicitly
+      #
+      # @param klass [Class] The class to register
+      # @return [void]
+      def register(klass)
+        return if klass.abstract?
+
+        items[klass.capability_name] = klass
+      end
 
-          hash[klass.capability_name] = klass
-        end
+      # Unregister an item
+      #
+      # @param klass [Class] The class to unregister
+      # @return [void]
+      def unregister(klass)
+        items.delete(klass.capability_name)
       end
 
       # Retrieve an item by name.
@@ -44,6 +58,13 @@ module ActionMCP
         RegistryScope.new(items)
       end
 
+      # Clears the registry cache.
+      #
+      # @return [void]
+      def clear!
+        @items = nil
+      end
+
       private
 
       # Helper to determine if an item is abstract.

data/lib/action_mcp/resource_response.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Manages resource resolution results and errors for ResourceTemplate operations.
+  # Unlike ToolResponse, ResourceResponse only uses JSON-RPC protocol errors per MCP spec.
+  class ResourceResponse < BaseResponse
+    attr_reader :contents
+
+    delegate :empty?, :size, :each, :find, :map, to: :contents
+
+    def initialize
+      super
+      @contents = []
+    end
+
+    # Add a resource content item to the response
+    def add_content(content)
+      @contents << content
+      content # Return the content for chaining
+    end
+
+    # Add multiple content items
+    def add_contents(contents_array)
+      @contents.concat(contents_array)
+      self
+    end
+
+    # Mark as error with ResourceTemplate-specific error types
+    def mark_as_template_not_found!(uri)
+      mark_as_error!(
+        :invalid_params,
+        message: "Resource template not found for URI: #{uri}",
+        data: { uri: uri, error_type: "TEMPLATE_NOT_FOUND" }
+      )
+    end
+
+    def mark_as_parameter_validation_failed!(missing_params, uri)
+      mark_as_error!(
+        :invalid_params,
+        message: "Required parameters missing: #{missing_params.join(', ')}",
+        data: {
+          uri: uri,
+          missing_parameters: missing_params,
+          error_type: "PARAMETER_VALIDATION_FAILED"
+        }
+      )
+    end
+
+    def mark_as_resolution_failed!(uri, reason = nil)
+      message = "Resource resolution failed for URI: #{uri}"
+      message += " - #{reason}" if reason
+
+      mark_as_error!(
+        :internal_error,
+        message: message,
+        data: {
+          uri: uri,
+          reason: reason,
+          error_type: "RESOLUTION_FAILED"
+        }
+      )
+    end
+
+    def mark_as_callback_aborted!(uri)
+      mark_as_error!(
+        :internal_error,
+        message: "Resource resolution was aborted by callback chain",
+        data: {
+          uri: uri,
+          error_type: "CALLBACK_ABORTED"
+        }
+      )
+    end
+
+    def mark_as_not_found!(uri)
+      # Use method_not_found for resource not found (closest standard JSON-RPC error)
+      mark_as_error!(
+        :method_not_found, # -32601 - closest standard error for "not found"
+        message: "Resource not found",
+        data: { uri: uri }
+      )
+    end
+
+    # Implementation of build_success_hash for ResourceResponse
+    def build_success_hash
+      {
+        contents: @contents.map(&:to_h)
+      }
+    end
+
+    # Implementation of compare_with_same_class for ResourceResponse
+    def compare_with_same_class(other)
+      contents == other.contents && is_error == other.is_error
+    end
+
+    # Implementation of hash_components for ResourceResponse
+    def hash_components
+      [ contents, is_error ]
+    end
+
+    # Pretty print for better debugging
+    def inspect
+      if is_error
+        "#<#{self.class.name} error: #{@error_message}>"
+      else
+        "#<#{self.class.name} contents: #{contents.size} items>"
+      end
+    end
+  end
+end

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,
@@ -44,11 +44,7 @@ module ActionMCP
 
             # 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")
@@ -65,11 +61,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")

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
 
@@ -52,7 +54,14 @@ module ActionMCP
             }
           })
 
-          result = tool.call
+          # Wrap tool execution with Rails reloader for development
+          result = if Rails.env.development? && defined?(Rails.application.reloader)
+            Rails.application.reloader.wrap do
+              tool.call
+            end
+          else
+            tool.call
+          end
 
           if result.is_error
             # Convert ToolResponse error to proper JSON-RPC error format

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/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

data/lib/action_mcp/version.rb

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

data/lib/tasks/action_mcp_tasks.rake

@@ -124,4 +124,242 @@ namespace :action_mcp do
   task list: %i[list_tools list_prompts list_resources list_profiles] do
     # This task lists all tools, prompts, resources and profiles
   end
+
+  # bin/rails action_mcp:info
+  # bin/rails action_mcp:info[test]
+  desc "Display ActionMCP configuration for current or specified environment"
+  task :info, [ :env ] => :environment do |_t, args|
+    env = args[:env] || Rails.env
+
+    # Load configuration for the specified environment
+    original_env = Rails.env
+    Rails.env = env.to_s
+
+    # Reload configuration to get the environment-specific settings
+    config = ActionMCP::Configuration.new
+    config.load_profiles
+
+    puts "\e[35mActionMCP Configuration (#{env})\e[0m"
+    puts "\e[35m#{'=' * (25 + env.length)}\e[0m"
+
+    # Basic Information
+    puts "\n\e[36mBasic Information:\e[0m"
+    puts "  Name: #{config.name}"
+    puts "  Version: #{config.version}"
+    puts "  Protocol Version: #{config.protocol_version}"
+    puts "  Active Profile: #{config.active_profile}"
+
+    # Session Storage
+    puts "\n\e[36mSession Storage:\e[0m"
+    puts "  Session Store Type: #{config.session_store_type}"
+    puts "  Client Session Store: #{config.client_session_store_type || 'default'}"
+    puts "  Server Session Store: #{config.server_session_store_type || 'default'}"
+
+    # Transport Configuration
+    puts "\n\e[36mTransport Configuration:\e[0m"
+    puts "  SSE Heartbeat Interval: #{config.sse_heartbeat_interval}s"
+    puts "  Post Response Preference: #{config.post_response_preference}"
+    puts "  SSE Event Retention Period: #{config.sse_event_retention_period}"
+    puts "  Max Stored SSE Events: #{config.max_stored_sse_events}"
+
+    # Pub/Sub Adapter
+    puts "\n\e[36mPub/Sub Adapter:\e[0m"
+    puts "  Adapter: #{config.adapter || 'not configured'}"
+    if config.adapter
+      puts "  Polling Interval: #{config.polling_interval}" if config.polling_interval
+      puts "  Min Threads: #{config.min_threads}" if config.min_threads
+      puts "  Max Threads: #{config.max_threads}" if config.max_threads
+      puts "  Max Queue: #{config.max_queue}" if config.max_queue
+    end
+
+    # Authentication
+    puts "\n\e[36mAuthentication:\e[0m"
+    puts "  Methods: #{config.authentication_methods.join(', ')}"
+    if config.oauth_config && config.oauth_config.any?
+      puts "  OAuth Provider: #{config.oauth_config['provider']}"
+      puts "  OAuth Scopes: #{config.oauth_config['scopes_supported']&.join(', ')}"
+    end
+
+    # Logging
+    puts "\n\e[36mLogging:\e[0m"
+    puts "  Logging Enabled: #{config.logging_enabled}"
+    puts "  Logging Level: #{config.logging_level}"
+
+    # Gateway
+    puts "\n\e[36mGateway:\e[0m"
+    puts "  Gateway Class: #{config.gateway_class}"
+
+    # Capabilities
+    puts "\n\e[36mEnabled Capabilities:\e[0m"
+    capabilities = config.capabilities
+    if capabilities.any?
+      capabilities.each do |cap_name, cap_config|
+        puts "  #{cap_name}: #{cap_config.inspect}"
+      end
+    else
+      puts "  None"
+    end
+
+    # Available Profiles
+    puts "\n\e[36mAvailable Profiles:\e[0m"
+    config.profiles.each_key do |profile_name|
+      puts "  - #{profile_name}"
+    end
+
+    # Restore original environment
+    Rails.env = original_env
+
+    puts "\n"
+  end
+
+  # bin/rails action_mcp:stats
+  desc "Display ActionMCP session and database statistics"
+  task stats: :environment do
+    puts "\e[35mActionMCP Statistics\e[0m"
+    puts "\e[35m===================\e[0m"
+
+    # Debug database connection
+    puts "\n\e[36mDatabase Debug:\e[0m"
+    puts "  Rails Environment: #{Rails.env}"
+    puts "  Rails Root: #{Rails.root}"
+    puts "  Database Config: #{ActionMCP::ApplicationRecord.connection_db_config.configuration_hash.inspect}"
+    if ActionMCP::ApplicationRecord.connection.adapter_name.downcase.include?("sqlite")
+      db_path = ActionMCP::ApplicationRecord.connection_db_config.database
+      puts "  Database Path: #{db_path}"
+      puts "  Database Exists?: #{File.exist?(db_path)}" if db_path
+    end
+
+    # Session Statistics
+    puts "\n\e[36mSession Statistics:\e[0m"
+
+    begin
+      total_sessions = ActionMCP::Session.count
+      puts "  Total Sessions: #{total_sessions}"
+
+      if total_sessions > 0
+        # Sessions by status
+        sessions_by_status = ActionMCP::Session.group(:status).count
+        puts "  Sessions by Status:"
+        sessions_by_status.each do |status, count|
+          puts "    #{status}: #{count}"
+        end
+
+        # Sessions by protocol version
+        sessions_by_protocol = ActionMCP::Session.group(:protocol_version).count
+        puts "  Sessions by Protocol Version:"
+        sessions_by_protocol.each do |version, count|
+          puts "    #{version}: #{count}"
+        end
+
+        # Active sessions (initialized and not ended)
+        active_sessions = ActionMCP::Session.where(status: "initialized", ended_at: nil).count
+        puts "  Active Sessions: #{active_sessions}"
+
+        # Recent activity
+        recent_sessions = ActionMCP::Session.where("created_at > ?", 1.hour.ago).count
+        puts "  Sessions Created (Last Hour): #{recent_sessions}"
+
+        # Session with most messages
+        if ActionMCP::Session.maximum(:messages_count)
+          busiest_session = ActionMCP::Session.order(messages_count: :desc).first
+          puts "  Most Active Session: #{busiest_session.id} (#{busiest_session.messages_count} messages)"
+        end
+
+        # Average messages per session
+        avg_messages = ActionMCP::Session.average(:messages_count).to_f.round(2)
+        puts "  Average Messages per Session: #{avg_messages}"
+      end
+    rescue StandardError => e
+      puts "  Error accessing session data: #{e.message}"
+      puts "  (Session store might be using volatile storage)"
+    end
+
+    # Message Statistics (if messages table exists)
+    puts "\n\e[36mMessage Statistics:\e[0m"
+
+    begin
+      if ActionMCP::ApplicationRecord.connection.table_exists?("action_mcp_session_messages")
+        total_messages = ActionMCP::Session::Message.count
+        puts "  Total Messages: #{total_messages}"
+
+        if total_messages > 0
+          # Messages by direction
+          messages_by_direction = ActionMCP::Session::Message.group(:direction).count
+          puts "  Messages by Direction:"
+          messages_by_direction.each do |direction, count|
+            puts "    #{direction}: #{count}"
+          end
+
+          # Messages by type
+          messages_by_type = ActionMCP::Session::Message.group(:message_type).count.sort_by { |_type, count| -count }.first(10)
+          puts "  Top Message Types:"
+          messages_by_type.each do |type, count|
+            puts "    #{type}: #{count}"
+          end
+
+          # Recent messages
+          recent_messages = ActionMCP::Session::Message.where("created_at > ?", 1.hour.ago).count
+          puts "  Messages (Last Hour): #{recent_messages}"
+        end
+      else
+        puts "  Message table not found"
+      end
+    rescue StandardError => e
+      puts "  Error accessing message data: #{e.message}"
+    end
+
+    # SSE Event Statistics (if table exists)
+    puts "\n\e[36mSSE Event Statistics:\e[0m"
+
+    begin
+      if ActionMCP::ApplicationRecord.connection.table_exists?("action_mcp_sse_events")
+        total_events = ActionMCP::Session::SSEEvent.count
+        puts "  Total SSE Events: #{total_events}"
+
+        if total_events > 0
+          # Recent events
+          recent_events = ActionMCP::Session::SSEEvent.where("created_at > ?", 1.hour.ago).count
+          puts "  SSE Events (Last Hour): #{recent_events}"
+
+          # Events by session
+          events_by_session = ActionMCP::Session::SSEEvent.joins(:session)
+                                                          .group("action_mcp_sessions.id")
+                                                          .count
+                                                          .sort_by { |_session_id, count| -count }
+                                                          .first(5)
+          puts "  Top Sessions by SSE Events:"
+          events_by_session.each do |session_id, count|
+            puts "    #{session_id}: #{count} events"
+          end
+        end
+      else
+        puts "  SSE Events table not found"
+      end
+    rescue StandardError => e
+      puts "  Error accessing SSE event data: #{e.message}"
+    end
+
+    # Storage Information
+    puts "\n\e[36mStorage Information:\e[0m"
+    puts "  Session Store Type: #{ActionMCP.configuration.session_store_type}"
+    puts "  Database Adapter: #{ActionMCP::ApplicationRecord.connection.adapter_name}"
+
+    # Database size (if SQLite)
+    begin
+      if ActionMCP::ApplicationRecord.connection.adapter_name.downcase.include?("sqlite")
+        db_config = Rails.application.config.database_configuration[Rails.env]
+        if db_config && db_config["database"]
+          db_file = db_config["database"]
+          if File.exist?(db_file)
+            size_mb = (File.size(db_file) / 1024.0 / 1024.0).round(2)
+            puts "  Database Size: #{size_mb} MB"
+          end
+        end
+      end
+    rescue StandardError => e
+      puts "  Could not determine database size: #{e.message}"
+    end
+
+    puts "\n"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.60.1
+  version: 0.70.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -284,6 +284,7 @@ files:
 - lib/action_mcp/renderable.rb
 - lib/action_mcp/resource.rb
 - lib/action_mcp/resource_callbacks.rb
+- lib/action_mcp/resource_response.rb
 - lib/action_mcp/resource_template.rb
 - lib/action_mcp/resource_templates_registry.rb
 - lib/action_mcp/server.rb