actionmcp 0.31.1 → 0.32.1

data/app/models/action_mcp/session.rb

@@ -10,12 +10,15 @@
 #  ended_at(The time the session ended)                :datetime
 #  initialized                                         :boolean          default(FALSE), not null
 #  messages_count                                      :integer          default(0), not null
+#  prompt_registry                                     :jsonb
 #  protocol_version                                    :string
+#  resource_registry                                   :jsonb
 #  role(The role of the session)                       :string           default("server"), not null
 #  server_capabilities(The capabilities of the server) :jsonb
 #  server_info(The information about the server)       :jsonb
 #  sse_event_counter                                   :integer          default(0), not null
 #  status                                              :string           default("pre_initialize"), not null
+#  tool_registry                                       :jsonb
 #  created_at                                          :datetime         not null
 #  updated_at                                          :datetime         not null
 #
@@ -26,6 +29,7 @@ module ActionMCP
   # such as client and server capabilities, protocol version, and session status.
   # It also manages the association with messages and subscriptions related to the session.
   class Session < ApplicationRecord
+    include MCPConsoleHelpers
     attribute :id, :string, default: -> { SecureRandom.hex(6) }
     has_many :messages,
              class_name: "ActionMCP::Session::Message",
@@ -43,17 +47,24 @@ module ActionMCP
              dependent: :delete_all,
              inverse_of: :session
 
+    has_many :sse_events,
+             class_name: "ActionMCP::Session::SSEEvent",
+             foreign_key: "session_id",
+             dependent: :delete_all,
+             inverse_of: :session
+
     scope :pre_initialize, -> { where(status: "pre_initialize") }
     scope :closed, -> { where(status: "closed") }
     scope :without_messages, -> { includes(:messages).where(action_mcp_session_messages: { id: nil }) }
 
     scope :from_server, -> { where(role: "server") }
     scope :from_client, -> { where(role: "client") }
-
+    # Initialize with default registries
+    before_create :initialize_registries
     before_create :set_server_info, if: -> { role == "server" }
     before_create :set_server_capabilities, if: -> { role == "server" }
 
-    validates :protocol_version, inclusion: { in: [ PROTOCOL_VERSION ] }, allow_nil: true
+    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true
 
     def close!
       dummy_callback = ->(*) { } # this callback seem broken
@@ -119,16 +130,6 @@ module ActionMCP
       save
     end
 
-    def message_flow
-      messages.without_pings.order(created_at: :asc).map do |message|
-        {
-          direction: message.direction,
-          data: message.data,
-          type: message.message_type
-        }
-      end
-    end
-
     def send_ping!
       Session.logger.silence do
         write(JSON_RPC::Request.new(id: Time.now.to_i, method: "ping"))
@@ -153,6 +154,163 @@ module ActionMCP
       reload.sse_event_counter
     end
 
+    # Stores an SSE event for potential resumption
+    # @param event_id [Integer] The event ID
+    # @param data [Hash, String] The event data
+    # @param max_events [Integer] Maximum number of events to store (oldest events are removed when exceeded)
+    # @return [ActionMCP::Session::SSEEvent] The created event
+    def store_sse_event(event_id, data, max_events = 100)
+      # Create the SSE event record
+      event = sse_events.create!(
+        event_id: event_id,
+        data: data
+      )
+
+      # Maintain cache limit by removing oldest events if needed
+      if sse_events.count > max_events
+        sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all
+      end
+
+      event
+    end
+
+    # Retrieves SSE events after a given ID
+    # @param last_event_id [Integer] The ID to retrieve events after
+    # @param limit [Integer] Maximum number of events to return
+    # @return [Array<ActionMCP::Session::SSEEvent>] The events
+    def get_sse_events_after(last_event_id, limit = 50)
+      sse_events.where("event_id > ?", last_event_id)
+                .order(event_id: :asc)
+                .limit(limit)
+    end
+
+    # Cleans up old SSE events
+    # @param max_age [ActiveSupport::Duration] Maximum age of events to keep
+    # @return [Integer] Number of events removed
+    def cleanup_old_sse_events(max_age = 15.minutes)
+      cutoff_time = Time.current - max_age
+      events_to_delete = sse_events.where("created_at < ?", cutoff_time)
+      count = events_to_delete.count
+      events_to_delete.destroy_all
+      count
+    end
+
+    def send_progress_notification(progressToken:, progress:, total: nil, message: nil)
+      # Create a transport handler to send the notification
+      handler = ActionMCP::Server::TransportHandler.new(self)
+      handler.send_progress_notification(
+        progressToken: progressToken,
+        progress: progress,
+        total: total,
+        message: message
+      )
+    end
+
+    # Calculates the retention period for SSE events based on configuration
+    # @return [ActiveSupport::Duration] The retention period
+    def sse_event_retention_period
+      ActionMCP.configuration.sse_event_retention_period || 15.minutes
+    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
+
+    def send_progress_notification_legacy(token:, value:, message: nil)
+      send_progress_notification(progressToken: token, progress: value, message: message)
+    end
+
+    # Registry management methods
+    def register_tool(tool_class_or_name)
+      tool_name = normalize_name(tool_class_or_name, :tool)
+      return false unless tool_exists?(tool_name)
+
+      self.tool_registry ||= []
+      unless self.tool_registry.include?(tool_name)
+        self.tool_registry << tool_name
+        save!
+        send_tools_list_changed_notification
+      end
+      true
+    end
+
+    def unregister_tool(tool_class_or_name)
+      tool_name = normalize_name(tool_class_or_name, :tool)
+      self.tool_registry ||= []
+
+      if self.tool_registry.delete(tool_name)
+        save!
+        send_tools_list_changed_notification
+      end
+    end
+
+    def register_prompt(prompt_class_or_name)
+      prompt_name = normalize_name(prompt_class_or_name, :prompt)
+      return false unless prompt_exists?(prompt_name)
+
+      self.prompt_registry ||= []
+      unless self.prompt_registry.include?(prompt_name)
+        self.prompt_registry << prompt_name
+        save!
+        send_prompts_list_changed_notification
+      end
+      true
+    end
+
+    def unregister_prompt(prompt_class_or_name)
+      prompt_name = normalize_name(prompt_class_or_name, :prompt)
+      self.prompt_registry ||= []
+
+      if self.prompt_registry.delete(prompt_name)
+        save!
+        send_prompts_list_changed_notification
+      end
+    end
+
+    def register_resource_template(template_class_or_name)
+      template_name = normalize_name(template_class_or_name, :resource_template)
+      return false unless resource_template_exists?(template_name)
+
+      self.resource_registry ||= []
+      unless self.resource_registry.include?(template_name)
+        self.resource_registry << template_name
+        save!
+        send_resources_list_changed_notification
+      end
+      true
+    end
+
+    def unregister_resource_template(template_class_or_name)
+      template_name = normalize_name(template_class_or_name, :resource_template)
+      self.resource_registry ||= []
+
+      if self.resource_registry.delete(template_name)
+        save!
+        send_resources_list_changed_notification
+      end
+    end
+
+    # Get registered items for this session
+    def registered_tools
+      (self.tool_registry || []).filter_map do |tool_name|
+        ActionMCP::ToolsRegistry.find(tool_name) rescue nil
+      end
+    end
+
+    def registered_prompts
+      (self.prompt_registry || []).filter_map do |prompt_name|
+        ActionMCP::PromptsRegistry.find(prompt_name) rescue nil
+      end
+    end
+
+    def registered_resource_templates
+      (self.resource_registry || []).filter_map do |template_name|
+        ActionMCP::ResourceTemplatesRegistry.find(template_name) rescue nil
+      end
+    end
+
     private
 
     # if this session is from a server, the writer is the client
@@ -172,5 +330,70 @@ module ActionMCP
     def set_server_capabilities
       self.server_capabilities ||= ActionMCP.configuration.capabilities
     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)
+    end
+
+    def normalize_name(class_or_name, type)
+      case class_or_name
+      when String
+        class_or_name
+      when Class
+        case type
+        when :tool
+          class_or_name.tool_name
+        when :prompt
+          class_or_name.prompt_name
+        when :resource_template
+          class_or_name.capability_name
+        end
+      else
+        raise ArgumentError, "Expected String or Class, got #{class_or_name.class}"
+      end
+    end
+
+    def tool_exists?(tool_name)
+      ActionMCP::ToolsRegistry.find(tool_name)
+      true
+    rescue ActionMCP::RegistryBase::NotFound
+      false
+    end
+
+    def prompt_exists?(prompt_name)
+      ActionMCP::PromptsRegistry.find(prompt_name)
+      true
+    rescue ActionMCP::RegistryBase::NotFound
+      false
+    end
+
+    def resource_template_exists?(template_name)
+      ActionMCP::ResourceTemplatesRegistry.find(template_name)
+      true
+    rescue ActionMCP::RegistryBase::NotFound
+      false
+    end
+
+    def send_tools_list_changed_notification
+      # Only send if server capabilities allow it
+      if server_capabilities.dig("tools", "listChanged")
+        write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
+      end
+    end
+
+    def send_prompts_list_changed_notification
+      if server_capabilities.dig("prompts", "listChanged")
+        write(JSON_RPC::Notification.new(method: "notifications/prompts/list_changed"))
+      end
+    end
+
+    def send_resources_list_changed_notification
+      if server_capabilities.dig("resources", "listChanged")
+        write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
+      end
+    end
   end
 end

data/app/models/concerns/mcp_console_helpers.rb

@@ -0,0 +1,68 @@
+# app/models/concerns/mcp_console_helpers.rb
+module MCPConsoleHelpers
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def pretty_messages(session_or_messages, limit: 10)
+      messages = if session_or_messages.respond_to?(:messages)
+                   session_or_messages.messages.order(:created_at).last(limit)
+      else
+                   session_or_messages.last(limit)
+      end
+
+      messages.each do |msg|
+        puts msg.inspect
+        if msg.data&.dig("method")
+          puts "  └─ #{msg.data['method']}"
+        end
+        puts
+      end
+    end
+
+    def message_flow(session, limit: 50)
+      puts "\nMCP Message Flow:"
+      puts "Session ID: #{session.id}"
+      puts "Protocol: #{session.protocol_version}"
+      puts "─" * 70
+
+      session.messages.order(:created_at).last(limit).each do |msg|
+        time = msg.created_at.strftime("%H:%M:%S.%3N")
+        arrow = msg.direction == "client" ? "→" : "←"
+        direction_label = msg.direction == "client" ? "CLIENT" : "SERVER"
+
+        if ActionMCP::ConsoleDetector.in_console?
+          color_code = case msg.message_type
+          when "request" then "\e[34m"
+          when "response" then "\e[32m"
+          when "error" then "\e[31m"
+          when "notification" then "\e[33m"
+          else "\e[90m"
+          end
+          puts "#{time} #{color_code}#{direction_label}\e[0m #{arrow} #{msg.inspect}"
+        else
+          puts "#{time} #{direction_label} #{arrow} #{msg.inspect}"
+        end
+      end
+
+      puts "─" * 70
+    end
+
+    def message_stats(session)
+      stats = session.messages.group(:message_type, :direction).count
+
+      puts "\nMessage Statistics:"
+      puts "─" * 40
+
+      stats.each do |(type, direction), count|
+        puts "#{type.ljust(15)} #{direction.ljust(10)} #{count}"
+      end
+
+      puts "─" * 40
+      puts "Total: #{session.messages.count}"
+    end
+  end
+
+  def message_flow(limit: 50)
+    self.class.message_flow(self, limit: limit)
+  end
+end

data/app/models/concerns/mcp_message_inspect.rb

@@ -0,0 +1,73 @@
+# app/models/concerns/mcp_message_inspect.rb
+module MCPMessageInspect
+  extend ActiveSupport::Concern
+
+  def inspect(show_data: false)
+    if show_data
+      super()  # Rails default inspect
+    else
+      build_summary_inspect
+    end
+  end
+
+  private
+
+  def build_summary_inspect
+    case message_type
+    when "request"
+      format_request_summary
+    when "response", "error"
+      format_response_summary
+    when "notification"
+      format_notification_summary
+    else
+      format_default_summary
+    end
+  end
+
+  def format_request_summary
+    method = data&.dig("method")
+    formatted = "#<Message #{id}: REQUEST #{jsonrpc_id} -> #{method}>"
+    console? ? colorize(formatted, :blue) : formatted
+  end
+
+  def format_response_summary
+    formatted = "#<Message #{id}: #{message_type.upcase} #{jsonrpc_id}>"
+    if console?
+      color = message_type == "error" ? :red : :green
+      colorize(formatted, color)
+    else
+      formatted
+    end
+  end
+
+  def format_notification_summary
+    method = data&.dig("method")
+    formatted = "#<Message #{id}: NOTIFICATION -> #{method}>"
+    console? ? colorize(formatted, :yellow) : formatted
+  end
+
+  def format_default_summary
+    formatted = "#<Message #{id}: #{message_type.upcase}>"
+    console? ? colorize(formatted, :gray) : formatted
+  end
+
+  def console?
+    # Check if we're in a Rails console environment
+    defined?(Rails::Console) ||
+      defined?(::Rails.application) && Rails.application.console? ||
+      (defined?(IRB) && IRB.CurrentContext.kind_of?(IRB::ExtendCommandBundle))
+  end
+
+  def colorize(text, color)
+    colors = {
+      blue: "\e[34m",
+      green: "\e[32m",
+      red: "\e[31m",
+      yellow: "\e[33m",
+      gray: "\e[90m"
+    }
+
+    "#{colors[color]}#{text}\e[0m"
+  end
+end

data/config/routes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 ActionMCP::Engine.routes.draw do
+  get "/up", to: "/rails/health#show", as: :action_mcp_health_check
   # --- Routes for 2024-11-05 Spec (HTTP+SSE) ---
   # Kept for backward compatibility
   get "/", to: "sse#events", as: :sse_out
@@ -8,6 +9,7 @@ ActionMCP::Engine.routes.draw do
 
   # --- Routes for 2025-03-26 Spec (Streamable HTTP) ---
   mcp_endpoint = ActionMCP.configuration.mcp_endpoint_path
-  get mcp_endpoint, to: "unified#handle_get", as: :mcp_get
-  post mcp_endpoint, to: "unified#handle_post", as: :mcp_post
+  get mcp_endpoint, to: "unified#show", as: :mcp_get
+  post mcp_endpoint, to: "unified#create", as: :mcp_post
+  delete mcp_endpoint, to: "unified#destroy", as: :mcp_delete
 end

data/db/migrate/20250329120300_add_registries_to_sessions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddRegistriesToSessions < ActiveRecord::Migration[8.0]
+  def change
+    add_column :action_mcp_sessions, :tool_registry, :jsonb, default: []
+    add_column :action_mcp_sessions, :prompt_registry, :jsonb, default: []
+    add_column :action_mcp_sessions, :resource_registry, :jsonb, default: []
+  end
+end

data/db/migrate/20250329150312_create_action_mcp_sse_events.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateActionMCPSSEEvents < ActiveRecord::Migration[8.0]
+  def change
+    create_table :action_mcp_sse_events do |t|
+      t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions }, index: true, type: :string
+      t.integer :event_id, null: false
+      t.text :data, null: false
+      t.timestamps
+
+      # Index for efficiently retrieving events after a given ID for a specific session
+      t.index [ :session_id, :event_id ], unique: true
+      t.index :created_at # For cleanup of old events
+    end
+  end
+end

data/lib/action_mcp/capability.rb

@@ -14,6 +14,22 @@ module ActionMCP
     class_attribute :_capability_name, instance_accessor: false
     class_attribute :_description, instance_accessor: false, default: ""
 
+    attr_reader :execution_context
+
+    def initialize(*)
+      super
+      @execution_context = {}
+    end
+
+    def with_context(context)
+      @execution_context = context
+      self
+    end
+
+    def session
+      execution_context[:session]
+    end
+
     # use _capability_name or default_capability_name
     def self.capability_name
       _capability_name || default_capability_name

data/lib/action_mcp/configuration.rb

@@ -23,10 +23,14 @@ module ActionMCP
                   :active_profile,
                   :profiles,
                   # --- New Transport Options ---
-                  :allow_client_session_termination,
                   :mcp_endpoint_path,
                   :sse_heartbeat_interval,
-                  :post_response_preference # :json or :sse
+                  :post_response_preference, # :json or :sse
+                  :protocol_version,
+                  # --- SSE Resumability Options ---
+                  :enable_sse_resumability,
+                  :sse_event_retention_period,
+                  :max_stored_sse_events
 
     def initialize
       @logging_enabled = true
@@ -36,10 +40,15 @@ module ActionMCP
       @active_profile = :primary
       @profiles = default_profiles
 
-      @allow_client_session_termination = true
       @mcp_endpoint_path = "/mcp"
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
+      @protocol_version = "2024-11-05"
+
+      # Resumability defaults
+      @enable_sse_resumability = true
+      @sse_event_retention_period = 15.minutes
+      @max_stored_sse_events = 100
     end
 
     def name
@@ -132,6 +141,9 @@ module ActionMCP
 
       capabilities[:resources] = { subscribe: @resources_subscribe } if filtered_resources.any?
 
+      # Add resumability capability if enabled
+      capabilities[:resumability] = { enabled: @enable_sse_resumability } if @enable_sse_resumability
+
       capabilities
     end
 
@@ -193,7 +205,7 @@ module ActionMCP
   end
 
   class << self
-    attr_accessor :server, :logger
+    attr_accessor :logger
 
     # Thread-local storage for active profiles
     def thread_profiles

data/lib/action_mcp/console_detector.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module ConsoleDetector
+    module_function
+
+    def in_console?
+      # Check for Rails console
+      defined?(Rails::Console)
+    end
+  end
+end

data/lib/action_mcp/engine.rb

@@ -2,6 +2,7 @@
 
 require "rails"
 require "active_model/railtie"
+require "jsonrpc-rails"
 
 module ActionMCP
   # Engine for integrating ActionMCP with Rails applications.
@@ -20,6 +21,8 @@ module ActionMCP
       ActionMCP::ResourceTemplate.registered_templates.clear
     end
 
+    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ ActionMCP.configuration.mcp_endpoint_path ]
+
     # Load MCP profiles during initialization
     initializer "action_mcp.load_profiles" do
       ActionMCP.configuration.load_profiles

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -75,9 +75,9 @@ module ActionMCP
     # @param request [Hash]
     def process_request(request)
       return unless valid_request?(request)
+      request = request.with_indifferent_access
 
       read(request)
-
       id = request["id"]
 
       unless (rpc_method = request["method"])

data/lib/action_mcp/resource_template.rb

@@ -13,6 +13,7 @@ module ActionMCP
 
     # Track all registered templates
     @registered_templates = []
+    attr_reader :execution_context
 
     class << self
       attr_reader :registered_templates, :description, :uri_template,
@@ -201,6 +202,7 @@ module ActionMCP
     # Initialize with attribute values
     def initialize(attributes = {})
       super(attributes)
+      @execution_context = {}
       validate!
     end
 
@@ -209,6 +211,15 @@ module ActionMCP
       valid?
     end
 
+    def with_context(context)
+      @execution_context = context
+      self
+    end
+
+    def session
+      execution_context[:session]
+    end
+
     # Add custom validation for required parameters
     validate do |_template|
       self.class.required_parameters.each do |param|