actionmcp 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a1cd6d70ca62ff8ecf4d25c00e29d9592bc9d80ca46db50330a2f818a66ce1f
-  data.tar.gz: 259e35b08f9627aa4165157b71436f4fdd4c0c9eaedc2ae41ddb6f0bb8c3fdde
+  metadata.gz: 15695f4c672c4af6d7b6114a92d395af80f012da1221815237d12dd21d1dee31
+  data.tar.gz: 5c446ff697530b0600e0a176360de1653536e86eadff979a35149bf62821c4d1
 SHA512:
-  metadata.gz: c213f50edbec5dc96af78b3090f562dae9fe479a405a44d573927ef65c1c042d6a43ef174297bca3bc92280a372d5a3a74c61aec5a8dfc3e1381550c56b27397
-  data.tar.gz: 343bee907d44e4e7869372b5ffa250c6d628c8789ef51a4690b311c494d6b5b20199837dbbc5f39959e36b8a71d3ce2942b82685b4076897ddc393e59e73d8e3
+  metadata.gz: 936f8873dcb2fb25fd57880107d768672655a1c75df41fb26f7a7d9be34f3bff289bb671afff31a5dcef4a8aca3398413622791b2c6c1ad1cc2429209fc5ac8f
+  data.tar.gz: 81e347ed22f4f2d2fa6bb0d6bbb91e7c1b3a89b2295b5635872e4f90107183b5dab658cb20973e41c080977e361a90a16b1cf7ca582947600f70050abf060901

data/README.md

@@ -86,6 +86,7 @@ ActionMCP includes Rails generators to help you quickly set up your MCP server c
 You can generate the base classes for your MCP Prompt and Tool using the following command:
 
 ```bash
+bin/rails action_mcp:install:migrations  # to copy the migrations
 bin/rails generate action_mcp:install 
 ```
 

data/app/controllers/action_mcp/messages_controller.rb

@@ -3,7 +3,7 @@ module ActionMCP
     # @route POST / (sse_in)
     def create
       begin
-        handle_post_message(params, response)
+        handle_post_message(clean_params, response)
       rescue => e
         head :internal_server_error
       end
@@ -12,12 +12,8 @@ module ActionMCP
 
     private
 
-    def transport
-      @transport ||= Transport.new(session_key)
-    end
-
     def transport_handler
-      TransportHandler.new(transport)
+      TransportHandler.new(mcp_session)
     end
 
     def json_rpc_handler
@@ -29,23 +25,17 @@ module ActionMCP
 
       response.status = :accepted
     rescue StandardError => e
+      puts "Error: #{e.message}"
+      puts e.backtrace.join("\n")
       response.status = :bad_request
     end
 
-    def session_id
-      params[:session_id]
+    def mcp_session
+      Session.find(params[:session_id])
     end
 
-    class Transport
-      attr_reader :session_key, :adapter
-      def initialize(session_key)
-        @session_key = session_key
-        @adapter = ActionMCP::Server.server.pubsub
-      end
-
-      def write(data)
-        adapter.broadcast(session_key, data.to_json)
-      end
+    def clean_params
+      params.slice(:id, :method, :jsonrpc, :params, :result, :error)
     end
   end
 end

data/app/controllers/action_mcp/sse_controller.rb

@@ -1,6 +1,6 @@
 module ActionMCP
   class SSEController < ApplicationController
-    HEARTBEAT_INTERVAL = 10
+    HEARTBEAT_INTERVAL = 30 # TODO: The frequency of pings SHOULD be configurable
     INITIALIZATION_TIMEOUT = 2
     include ActionController::Live
 
@@ -12,29 +12,22 @@ module ActionMCP
       response.headers["Cache-Control"] = "no-cache"
       response.headers["Connection"] = "keep-alive"
 
-      listener = nil
-      begin
-        # Now start streaming - send endpoint
-        send_endpoint_event(sse_in_url)
+      # Now start streaming - send endpoint
+      send_endpoint_event(sse_in_url)
 
+      begin
         # Start listener and process messages via the transport
-        listener = SseListener.new(session_key)
+        listener = SSEListener.new(mcp_session)
         if listener.start do |message|
-          begin
-            Rails.logger.debug "Processing message in controller: #{message.inspect} (#{message.class})"
-
-            # Send with proper SSE formatting
-            sse = SSE.new(response.stream)
-            sse.write(message)
-          rescue => e
-            Rails.logger.error "Error sending SSE message: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
-          end
+          # Send with proper SSE formatting
+          sse = SSE.new(response.stream)
+          sse.write(message)
         end
 
           # Heartbeat loop
           until response.stream.closed?
             sleep HEARTBEAT_INTERVAL
-            send_ping!
+            mcp_session.send_ping!
           end
         else
           Rails.logger.error "Listener failed to activate for session: #{session_id}"
@@ -45,7 +38,7 @@ module ActionMCP
       rescue => e
         Rails.logger.error "SSE: Unexpected error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
       ensure
-        listener&.stop
+        listener.stop
         response.stream.close
         Rails.logger.debug "SSE: Connection closed for session: #{session_id}"
       end
@@ -60,32 +53,31 @@ module ActionMCP
          .write(endpoint)
     end
 
-    def send_ping!
-      SSE.new(response.stream,
-              event: "ping")
-         .write(Time.now.to_i)
-    end
-
     def default_url_options
       { host: request.host, port: request.port }
     end
 
+    def mcp_session
+      @mcp_session ||= Session.create
+    end
+
     def session_id
-      @session_id ||= SecureRandom.hex(6)
+      @session_id ||= mcp_session.id
     end
   end
 
-  class SseListener
+  class SSEListener
     attr_reader :session_key, :adapter
+    delegate :session_key, :adapter, to: :@session
 
-    def initialize(session_key)
-      @session_key = session_key
-      @adapter = ActionMCP::Server.server.pubsub
+    # @param session [ActionMCP::Session]
+    def initialize(session)
+      @session = session
       @stopped = false
       @subscription_active = false
     end
 
-    # Start listening using ActionCable's PostgreSQL adapter
+    # Start listening using ActionCable's adapter
     def start(&callback)
       Rails.logger.debug "Starting listener for channel: #{session_key}"
 
@@ -97,17 +89,13 @@ module ActionMCP
 
       # Set up message callback with detailed debugging
       message_callback = ->(raw_message) {
-        Rails.logger.debug "Received raw message via adapter: #{raw_message.inspect} (#{raw_message.class})"
-
         begin
           # Try to parse the message if it's JSON
-          message = raw_message.is_a?(String) ? JSON.parse(raw_message) : raw_message
-          Rails.logger.debug "Processed message: #{message.inspect}"
+          message = MultiJson.load(raw_message)
 
           # Send the message to the callback
           callback.call(message) if callback && !@stopped
         rescue => e
-          Rails.logger.error "Error processing message: #{e.class} - #{e.message}"
           # Still try to send the raw message as a fallback
           callback.call(raw_message) if callback && !@stopped
         end
@@ -117,16 +105,9 @@ module ActionMCP
       adapter.subscribe(session_key, message_callback, success_callback)
 
       # Give some time for the subscription to be established
-      sleep 1.5
-
-      # Check if subscription was successful
-      if @subscription_active
-        Rails.logger.debug "Subscription confirmed active for: #{session_key}"
-        true
-      else
-        Rails.logger.error "Failed to activate subscription for: #{session_key}"
-        false
-      end
+      sleep 0.5
+
+      @subscription_active
     end
 
     def stop
@@ -136,8 +117,7 @@ module ActionMCP
       # Unsubscribe using the correct method signature
       begin
         # Create a dummy callback that matches the one we provided in start
-        dummy_callback = ->(_) { }
-        adapter.unsubscribe(session_key, dummy_callback)
+        @session.close!
         Rails.logger.debug "Unsubscribed from: #{session_key}"
       rescue => e
         Rails.logger.error "Error unsubscribing from #{session_key}: #{e.message}"

data/app/models/action_mcp/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

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

@@ -0,0 +1,91 @@
+module ActionMCP
+  class Session::Message < ApplicationRecord
+    belongs_to :session,
+               class_name: "ActionMCP::Session",
+               inverse_of: :messages,
+               counter_cache: true
+
+    delegate :adapter,
+             :role,
+             :session_key,
+             to: :session
+
+    # Virtual attribute for data
+    attr_reader :data
+
+    after_create_commit :broadcast_message, if: :outgoing_message?
+
+    # @param payload [String, Hash]
+    def data=(payload)
+      @data = payload
+
+      # Store original version and attempt to determine type
+      if payload.is_a?(String)
+        self.message_text = payload
+
+        begin
+          parsed_json = MultiJson.load(payload)
+          self.message_json = parsed_json
+          process_json_content(parsed_json)
+        rescue MultiJson::ParseError
+          # Not valid JSON, just store as text
+          self.message_type = "text"
+        end
+      else
+        # Handle Hash or other JSON-serializable input
+        self.message_json = payload
+        self.message_text = MultiJson.dump(payload)
+        process_json_content(payload)
+      end
+    end
+
+    def data
+      message_json.presence || message_text
+    end
+
+    # Helper method to check if message is a particular type
+    def request?
+      message_type == "request"
+    end
+
+    def notification?
+      message_type == "notification"
+    end
+
+    def response?
+      message_type == "response"
+    end
+
+    private
+
+    def outgoing_message?
+      direction != role
+    end
+
+    def broadcast_message
+      adapter.broadcast(session_key, data.to_json)
+    end
+
+    def process_json_content(content)
+      # Determine message type based on JSON-RPC spec
+      if content.is_a?(Hash) && content["jsonrpc"] == "2.0"
+        if content.key?("id") && content.key?("method")
+          self.message_type = "request"
+          self.jsonrpc_id = content["id"]
+        elsif content.key?("method") && !content.key?("id")
+          self.message_type = "notification"
+        elsif content.key?("id") && content.key?("result")
+          self.message_type = "response"
+          self.jsonrpc_id = content["id"]
+        elsif content.key?("id") && content.key?("error")
+          self.message_type = "error"
+          self.jsonrpc_id = content["id"]
+        else
+          self.message_type = "invalid_jsonrpc"
+        end
+      else
+        self.message_type = "non_jsonrpc_json"
+      end
+    end
+  end
+end

data/app/models/action_mcp/session.rb

@@ -0,0 +1,109 @@
+module ActionMCP
+  class Session < ApplicationRecord
+    attribute :id, :string, default: -> { SecureRandom.hex(6) }
+    has_many :messages,
+             class_name: "ActionMCP::Session::Message",
+             foreign_key: "session_id",
+             dependent: :destroy,
+             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 }) }
+
+    before_create :set_server_info
+    before_create :set_server_capabilities
+
+    validates :protocol_version, inclusion: { in: [ PROTOCOL_VERSION ] }, allow_nil: true
+
+    def close!
+      adapter.unsubscribe(session_key, _)
+      update!(status: "closed", ended_at: Time.zone.now)
+    end
+
+    def write(data)
+      if data.is_a?(JsonRpc::Request) || data.is_a?(JsonRpc::Response) || data.is_a?(JsonRpc::Notification)
+        data = data.to_json
+      end
+      if data.is_a?(Hash)
+        data = MultiJson.dump(data)
+      end
+
+      messages.create!(data: data, direction: writer_role)
+    end
+
+    def read(data)
+      puts "\e[33m[#{role}] #{data}\e[0m"
+      messages.create!(data: data, direction: role)
+    end
+
+    def session_key
+      "action_mcp:session:#{id}"
+    end
+
+    def adapter
+      @adapter ||= ActionMCP::Server.server.pubsub
+    end
+
+    def set_protocol_version(version)
+      update(protocol_version: version)
+    end
+
+    def store_client_info(info)
+      self.client_info = info
+    end
+
+    def store_client_capabilities(capabilities)
+      self.client_capabilities = capabilities
+    end
+
+    def server_capabilities_payload
+      {
+        protocolVersion: PROTOCOL_VERSION,
+        serverInfo: server_info,
+        capabilities: server_capabilities
+      }
+    end
+
+    def initialize!
+      # update the session initialized to true if client_capabilities are present
+      update!(initialized: true,
+              status: "initialized"
+      ) if client_capabilities.present?
+    end
+
+    def message_flow
+      messages.order(created_at: :asc).map do |message|
+        {
+          direction: message.direction,
+          data: message.data,
+          type: message.message_type
+        }
+      end
+    end
+
+    def send_ping!
+      write(JsonRpc::Request.new(id: Time.now.to_i, method: "ping"))
+    end
+
+    private
+
+    # if this session is from a server, the writer is the client
+    def writer_role
+      role == "server" ? "client" : "server"
+    end
+
+    # This will keep the version and name of the server when this session was created
+    def set_server_info
+      self.server_info = {
+        name: ActionMCP.configuration.name,
+        version: ActionMCP.configuration.version
+      }
+    end
+
+    # This can be overridden by the application in future versions
+    def set_server_capabilities
+      self.server_capabilities ||= ActionMCP.configuration.capabilities
+    end
+  end
+end

data/app/models/action_mcp.rb

@@ -0,0 +1,5 @@
+module ActionMCP
+  def self.table_name_prefix
+    "action_mcp_"
+  end
+end

data/db/migrate/20250308122801_create_action_mcp_sessions.rb

@@ -0,0 +1,30 @@
+class CreateActionMCPSessions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :action_mcp_sessions, id: :string do |t|
+      t.string :role, null: false, default: "server", comment: "The role of the session"
+      t.string :status, null: false, default: "pre_initialize"
+      t.datetime :ended_at, comment: "The time the session ended"
+      t.string :protocol_version
+      t.jsonb :server_capabilities, comment: "The capabilities of the server"
+      t.jsonb :client_capabilities, comment: "The capabilities of the client"
+      t.jsonb :server_info, comment: "The information about the server"
+      t.jsonb :client_info, comment: "The information about the client"
+      t.boolean :initialized, null: false, default: false
+      t.integer :messages_count, null: false, default: 0
+      t.timestamps
+    end
+
+    create_table :action_mcp_session_messages do |t|
+      t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions,
+                                                         on_delete: :cascade,
+                                                         on_update: :cascade,
+                                                         name: "fk_action_mcp_session_messages_session_id" }, type: :string
+      t.string :direction, null: false, comment: "The session direction", default: "client"
+      t.string :message_type, null: false, comment: "The type of the message"
+      t.string :jsonrpc_id
+      t.string :message_text
+      t.jsonb :message_json
+      t.timestamps
+    end
+  end
+end

data/lib/action_mcp/configuration.rb

@@ -45,7 +45,7 @@ module ActionMCP
       capabilities[:logging] = {} if @logging_enabled
       # capabilities[:resources] = { subscribe: @resources_subscribe,
       #                              listChanged: @list_changed }.compact
-      { capabilities: capabilities }
+      capabilities
     end
   end
 

data/lib/action_mcp/json_rpc_handler.rb

@@ -2,13 +2,17 @@
 
 module ActionMCP
   class JsonRpcHandler
+    delegate :initialize!, :initialized?, to: :transport
+    delegate :write, :read, to: :transport
     attr_reader :transport
 
+    # @param transport [ActionMCP::TransportHandler]
     def initialize(transport)
       @transport = transport
     end
 
     # Process a single line of input.
+    # @param line [String, Hash]
     def call(line)
       request = if line.is_a?(String)
                   line.strip!
@@ -28,11 +32,16 @@ module ActionMCP
 
     private
 
+    # @param request [Hash]
     def process_request(request)
-       unless request["jsonrpc"] == "2.0"
-         puts "Invalid request: #{request}"
-         return
-       end
+      unless request["jsonrpc"] == "2.0"
+        puts "Invalid request: #{request}"
+        return
+      end
+      read(request)
+      return if request["error"]
+      return if request["result"] == {} # Probably a pong
+
       method = request["method"]
       id = request["id"]
       params = request["params"]
@@ -45,42 +54,80 @@ module ActionMCP
         transport.send_pong(id)
       when /^notifications\//
         puts "\e[31mProcessing notifications\e[0m"
-        process_notifications(method, id, params)
+        process_notifications(method)
       when /^prompts\//
         process_prompts(method, id, params)
       when /^resources\//
         process_resources(method, id, params)
       when /^tools\//
         process_tools(method, id, params)
+      when "completion/complete"
+        process_completion_complete(id, params)
       else
-        puts "\e[31mUnknown method: #{method}\e[0m"
-        Rails.logger.warn("Unknown method: #{method}")
+        puts "\e[31mUnknown method: #{method} #{request}\e[0m"
       end
     end
 
-    def process_notifications(method, _id, _params)
-      case method
+    # @param rpc_method [String]
+    def process_notifications(rpc_method)
+      case rpc_method
       when "notifications/initialized"
         puts "\e[31mInitialized\e[0m"
-        transport.initialized!
+        transport.initialize!
       else
-        Rails.logger.warn("Unknown notifications method: #{method}")
+        Rails.logger.warn("Unknown notifications method: #{rpc_method}")
       end
     end
 
-    def process_prompts(method, id, params)
-      case method
+    # @param id [String]
+    # @param params [Hash]
+    # @example {
+    #     "ref": {
+    #       "type": "ref/prompt",
+    #       "name": "code_review"
+    #     },
+    #     "argument": {
+    #       "name": "language",
+    #       "value": "py"
+    #     }
+    #   }
+    # @return [Hash]
+    # @example {
+    #     "completion": {
+    #       "values": ["python", "pytorch", "pyside"],
+    #       "total": 10,
+    #       "hasMore": true
+    #     }
+    #   }
+    def process_completion_complete(id, params)
+      case params["ref"]["type"]
+      when "ref/prompt"
+        # TODO: Implement completion
+      when "ref/resource"
+        # TODO: Implement completion
+      end
+    end
+
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    def process_prompts(rpc_method, id, params)
+      case rpc_method
       when "prompts/get"
-        transport.send_prompts_get(id, params&.dig("name"), params&.dig("arguments"))
+        transport.send_prompts_get(id, params["name"], params["arguments"])
       when "prompts/list"
         transport.send_prompts_list(id)
       else
-        Rails.logger.warn("Unknown prompts method: #{method}")
+        Rails.logger.warn("Unknown prompts method: #{rpc_method}")
       end
     end
 
-    def process_resources(method, id, params)
-      case method
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    # Not implemented
+    def process_resources(rpc_method, id, params)
+      case rpc_method
       when "resources/list"
         transport.send_resources_list(id)
       when "resources/templates/list"
@@ -88,18 +135,18 @@ module ActionMCP
       when "resources/read"
         transport.send_resource_read(id, params)
       else
-        Rails.logger.warn("Unknown resources method: #{method}")
+        Rails.logger.warn("Unknown resources method: #{rpc_method}")
       end
     end
 
-    def process_tools(method, id, params)
-      case method
+    def process_tools(rpc_method, id, params)
+      case rpc_method
       when "tools/list"
         transport.send_tools_list(id)
       when "tools/call"
         transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
       else
-        Rails.logger.warn("Unknown tools method: #{method}")
+        Rails.logger.warn("Unknown tools method: #{rpc_method}")
       end
     end
   end

data/lib/action_mcp/prompt.rb

@@ -26,8 +26,9 @@ module ActionMCP
     def self.default_prompt_name
       name.demodulize.underscore.sub(/_prompt$/, "")
     end
+
     class << self
-    alias default_capability_name default_prompt_name
+      alias default_capability_name default_prompt_name
     end
 
     # ---------------------------------------------------
@@ -39,21 +40,26 @@ module ActionMCP
     # @param description [String] The description of the argument.
     # @param required [Boolean] Whether the argument is required.
     # @param default [Object] The default value of the argument.
+    # @param enum [Array<String>] The list of allowed values for the argument.
     # @return [void]
-    def self.argument(arg_name, description: "", required: false, default: nil)
+    # Argument DSL
+    def self.argument(arg_name, description: "", required: false, default: nil, enum: nil)
       arg_def = {
         name: arg_name.to_s,
         description: description,
         required: required,
-        default: default
+        default: default,
+        enum: enum
       }
       self._argument_definitions += [ arg_def ]
 
       # Register the attribute so it's recognized by ActiveModel
       attribute arg_name, :string, default: default
-      return unless required
+      validates arg_name, presence: true if required
 
-      validates arg_name, presence: true
+      if enum.present?
+        validates arg_name, inclusion: { in: enum }
+      end
     end
 
     # Returns the list of argument definitions.

data/lib/action_mcp/transport/capabilities.rb

@@ -5,16 +5,12 @@ module ActionMCP
         @protocol_version = params["protocolVersion"]
         @client_info = params["clientInfo"]
         @client_capabilities = params["capabilities"]
-        capabilities = ActionMCP.configuration.capabilities
-
-        payload = {
-          protocolVersion: PROTOCOL_VERSION,
-          serverInfo: {
-            name: ActionMCP.configuration.name,
-            version: ActionMCP.configuration.version
-          }
-        }.merge(capabilities)
-        send_jsonrpc_response(request_id, result: payload)
+        session.store_client_info(@client_info)
+        session.store_client_capabilities(@client_capabilities)
+        session.set_protocol_version(@protocol_version)
+        session.save
+        # TODO , if the server don't support the protocol version, send a response with error
+        send_jsonrpc_response(request_id, result: session.server_capabilities_payload)
       end
     end
   end

data/lib/action_mcp/transport/messaging.rb

@@ -3,17 +3,17 @@ module ActionMCP
     module Messaging
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
         request = JsonRpc::Request.new(id: id, method: method, params: params)
-        write_message(request.to_json)
+        write_message(request)
       end
 
       def send_jsonrpc_response(request_id, result: nil, error: nil)
         response = JsonRpc::Response.new(id: request_id, result: result, error: error)
-        write_message(response.to_json)
+        write_message(response)
       end
 
       def send_jsonrpc_notification(method, params = nil)
         notification = JsonRpc::Notification.new(method: method, params: params)
-        write_message(notification.to_json)
+        write_message(notification)
       end
     end
   end

data/lib/action_mcp/transport_handler.rb

@@ -2,6 +2,9 @@
 
 module ActionMCP
   class TransportHandler
+    attr_reader :session
+    delegate :initialize!, :initialized?, to: :session
+    delegate :read, :write, to: :session
     include Logging
 
     include Transport::Capabilities
@@ -10,41 +13,20 @@ module ActionMCP
     include Transport::Messaging
 
     HEARTBEAT_INTERVAL = 15 # seconds
-    attr_reader :initialized
-
-    def initialize(output_io)
-      @output = output_io
-      @output.sync = true if @output.respond_to?(:sync=)
-      @initialized = false
-      @client_capabilities = {}
-      @client_info = {}
-      @protocol_version = ""
-    end
 
-    def send_ping
-      send_jsonrpc_request("ping")
+    # @param [ActionMCP::Session] session
+    def initialize(session)
+      @session = session
     end
 
     def send_pong(request_id)
       send_jsonrpc_response(request_id, result: {})
     end
 
-    def initialized?
-      @initialized
-    end
-
-    def initialized!
-      @initialized = true
-    end
-
     private
 
     def write_message(data)
-      Timeout.timeout(5) do
-        @output.write("#{data}\n")
-      end
-    rescue Timeout::Error
-      # ActionMCP.logger.error("Write operation timed out")
+      session.write(data)
     end
 
     def format_registry_items(registry)

data/lib/action_mcp/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Abdelkader Boudih
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -108,7 +108,12 @@ files:
 - app/controllers/action_mcp/application_controller.rb
 - app/controllers/action_mcp/messages_controller.rb
 - app/controllers/action_mcp/sse_controller.rb
+- app/models/action_mcp.rb
+- app/models/action_mcp/application_record.rb
+- app/models/action_mcp/session.rb
+- app/models/action_mcp/session/message.rb
 - config/routes.rb
+- db/migrate/20250308122801_create_action_mcp_sessions.rb
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/capability.rb