actionmcp 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a6e51c000b677de70fd80f03788ba8334fc9e65bf7ad9344aea0bab75aebbdf
-  data.tar.gz: 3205256c52a5bf43316ac17c1c50634df3afb138c72b68994db071ac8a15722f
+  metadata.gz: 328575eb20b901f6a8b7aa2caf13b1a23c1bd2021eb74408d2f36314e0fda829
+  data.tar.gz: da1a9c14363f3d9104cecc61af3e4dac402d623a0054c1b4318cc54e16a0dd0a
 SHA512:
-  metadata.gz: af4c15acb851edb2906b9a6b164ed0abf54bb2cb2ad96752c907779f51d805c7a8835775e569b367341fa1d219a74581283680876fc261ab179ce782d5fc677f
-  data.tar.gz: fc5953ed45ceeea4ae7038134bea63b6fee0ed36e90bb9f3bd1b1bdb6397f6a3ac7e5875f85f458fae4155135405e481f78c24df37d63a5b565bdc2d40e0706e
+  metadata.gz: dcdd5da1fa8d6e48f373cd6ae1219b80870aae0d965456f4a6ab9be837dea71245604d6e2f2f7d2a5cd4066ac04d672283c7415f507a50c0a93a0f8c38a65c7f
+  data.tar.gz: a09c09d16754784de58995065089fce4fadea61df562358485ea794998cda9662f22dad89fff72cd313906350da22927b24584dfa761d4dc28134e9a82f0040c

data/app/controllers/action_mcp/sse_controller.rb

@@ -27,7 +27,7 @@ module ActionMCP
           # Heartbeat loop
           until response.stream.closed?
             sleep HEARTBEAT_INTERVAL
-            mcp_session.send_ping!
+            # mcp_session.send_ping!
           end
         else
           Rails.logger.error "Listener failed to activate for session: #{session_id}"

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

@@ -14,6 +14,11 @@ module ActionMCP
     attr_reader :data
 
     after_create_commit :broadcast_message, if: :outgoing_message?
+    # Set is_ping on responses if the original request was a ping
+    after_create :handle_ping_response, if: -> { %w[response error].include?(message_type) }
+
+    # Scope to exclude both "ping" requests and their responses
+    scope :without_pings, -> { where(is_ping: false) }
 
     # @param payload [String, Hash]
     def data=(payload)
@@ -22,17 +27,14 @@ module ActionMCP
       # 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)
@@ -43,7 +45,7 @@ module ActionMCP
       message_json.presence || message_text
     end
 
-    # Helper method to check if message is a particular type
+    # Helper methods
     def request?
       message_type == "request"
     end
@@ -67,19 +69,20 @@ module ActionMCP
     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"]
+          self.jsonrpc_id = content["id"].to_s
+          # Set is_ping to true if the method is "ping"
+          self.is_ping = true if content["method"] == "ping"
         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"]
+          self.jsonrpc_id = content["id"].to_s
         elsif content.key?("id") && content.key?("error")
           self.message_type = "error"
-          self.jsonrpc_id = content["id"]
+          self.jsonrpc_id = content["id"].to_s
         else
           self.message_type = "invalid_jsonrpc"
         end
@@ -87,5 +90,18 @@ module ActionMCP
         self.message_type = "non_jsonrpc_json"
       end
     end
+
+    def handle_ping_response
+      return unless jsonrpc_id.present?
+      request_message = session.messages.find_by(
+        jsonrpc_id: jsonrpc_id,
+        message_type: "request"
+      )
+      if request_message&.is_ping
+        self.is_ping = true
+        request_message.update(ping_acknowledged: true)
+        save! if changed?
+      end
+    end
   end
 end

data/app/models/action_mcp/session.rb

@@ -73,7 +73,7 @@ module ActionMCP
     end
 
     def message_flow
-      messages.order(created_at: :asc).map do |message|
+      messages.without_pings.order(created_at: :asc).map do |message|
         {
           direction: message.direction,
           data: message.data,
@@ -83,7 +83,9 @@ module ActionMCP
     end
 
     def send_ping!
-      write(JsonRpc::Request.new(id: Time.now.to_i, method: "ping"))
+      Session.logger.silence do
+        write(JsonRpc::Request.new(id: Time.now.to_i, method: "ping"))
+      end
     end
 
     private

data/db/migrate/20250314230152_add_is_ping_to_session_message.rb

@@ -0,0 +1,6 @@
+class AddIsPingToSessionMessage < ActiveRecord::Migration[8.0]
+  def change
+    add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false
+    add_column :action_mcp_session_messages, :ping_acknowledged, :boolean, default: false, null: false
+  end
+end

data/lib/action_mcp/content/resource.rb

@@ -33,7 +33,7 @@ module ActionMCP
         resource_data[:text] = @text if @text
         resource_data[:blob] = @blob if @blob
 
-        super.merge(resource: resource_data)
+        resource_data
       end
     end
   end

data/lib/action_mcp/json_rpc/json_rpc_error.rb

@@ -73,7 +73,7 @@ module ActionMCP
       # Returns a hash formatted for a JSON-RPC error response.
       #
       # @return [Hash] The error hash.
-      def as_json
+      def to_h
         hash = { code: code, message: message }
         hash[:data] = data if data
         hash
@@ -84,7 +84,7 @@ module ActionMCP
       # @param _args [Array] Arguments passed to MultiJson.dump.
       # @return [String] The JSON string.
       def to_json(*_args)
-        MultiJson.dump(as_json, *args)
+        MultiJson.dump(to_h, *args)
       end
     end
   end

data/lib/action_mcp/renderable.rb

@@ -3,6 +3,27 @@
 module ActionMCP
   # Module for rendering content.
   module Renderable
+    # Renders content for Model Context Protocol responses.
+    #
+    # @param text [String, nil] Text content to render
+    # @param audio [String, nil] Audio content to render
+    # @param image [String, nil] Image content to render
+    # @param resource [String, nil] Resource content to render
+    # @param error [Array, nil] Array of error messages to render
+    # @param mime_type [String, nil] MIME type for audio, image, or resource content
+    # @param uri [String, nil] URI for resource content
+    # @param blob [String, nil] Binary data for resource content
+    #
+    # @return [Content::Text, Content::Audio, Content::Image, Content::Resource, Hash]
+    #   The rendered content object or error hash
+    #
+    # @raise [ArgumentError] If no valid content parameters are provided
+    #
+    # @example Render text content
+    #   render(text: "Hello, world!")
+    #
+    # @example Render an error
+    #   render(error: ["Invalid input", "Please try again"])
     def render(text: nil, audio: nil, image: nil, resource: nil, error: nil, mime_type: nil, uri: nil, blob: nil)
       if text
         Content::Text.new(text)

data/lib/action_mcp/resource_template.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
+require "active_model"
+
 module ActionMCP
   class ResourceTemplate
+    # Add ActiveModel capabilities
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    # Track all registered templates
+    @registered_templates = []
+
     class << self
+      attr_reader :registered_templates
+
       def abstract?
         @abstract ||= false
       end
@@ -14,15 +25,31 @@ module ActionMCP
       def inherited(subclass)
         super
         subclass.instance_variable_set(:@abstract, false)
+        # Create a copy of validation requirements for subclasses
+        subclass.instance_variable_set(:@required_parameters, [])
       end
 
       attr_reader :description, :uri_template, :mime_type, :template_name, :parameters
 
-      def parameter(name, description:, required: false)
+      # Track required parameters for validation
+      def required_parameters
+        @required_parameters ||= []
+      end
+
+      def parameter(name, description:, required: false, **options)
         @parameters ||= {}
-        @parameters[name] = { description: description, required: required }
+        @parameters[name] = { description: description, required: required, **options }
+
+        # Define attribute accessor if not already defined
+        attr_accessor name unless method_defined?(name) && method_defined?("#{name}=")
+
+        # Track required parameters for validation
+        required_parameters << name if required
       end
 
+      # Alias parameter to attribute for clarity
+      alias_method :attribute, :parameter
+
       def parameters
         @parameters || {}
       end
@@ -32,7 +59,14 @@ module ActionMCP
       end
 
       def uri_template(value = nil)
-        value ? @uri_template = value : @uri_template
+        if value
+          validate_unique_uri_template(value)
+          @uri_template = value
+          # Only register if not abstract and uri_template is set
+          ResourceTemplate.registered_templates << self unless abstract?
+        else
+          @uri_template
+        end
       end
 
       def template_name(value = nil)
@@ -53,16 +87,166 @@ module ActionMCP
           mimeType: @mime_type
         }.compact
       end
+      def capability_name
+        @capability_name ||= name.demodulize.underscore.sub(/_template$/, "")
+      end
+
+      # Process a URI string to create a template instance
+      def process(uri_string)
+        return nil unless @uri_template
+
+        # Extract parameters from URI using pattern matching
+        params = extract_params_from_uri(uri_string)
+        return new if params.nil? # Return invalid template for bad URI
 
-      def retrieve(_params)
-        raise NotImplementedError, "Subclasses must implement the retrieve method"
+        # Create new instance with the extracted parameters
+        new(params)
       end
 
-      def capability_name
-        name.demodulize.underscore.sub(/_template$/, "")
+      private
+
+      # Extract parameters from a URI using the template pattern
+      def extract_params_from_uri(uri_string)
+        # Convert template parameters to named capture groups
+        regex_parts = []
+        current_pos = 0
+        param_names = []
+
+        # Find all template parameters like {param_name}
+        @uri_template.scan(/\{([^}]+)\}/) do |param_name|
+          param_names << param_name[0]
+
+          # Get the position of this parameter in the template
+          param_start = @uri_template.index("{#{param_name[0]}}", current_pos)
+
+          # Add the text before the parameter (escaped)
+          if param_start > current_pos
+            prefix = Regexp.escape(@uri_template[current_pos...param_start])
+            regex_parts << prefix
+          end
+
+          # Add the named capture group
+          regex_parts << "(?<#{param_name[0]}>[^/]+)"
+
+          # Update current position
+          current_pos = param_start + param_name[0].length + 2 # +2 for { and }
+        end
+
+        # Add any remaining text after the last parameter
+        if current_pos < @uri_template.length
+          suffix = Regexp.escape(@uri_template[current_pos..-1])
+          regex_parts << suffix
+        end
+
+        # Build the final regex
+        regex_pattern = regex_parts.join
+        regex = Regexp.new("^#{regex_pattern}$")
+
+        # Try to match the URI
+        match_data = regex.match(uri_string)
+        return nil unless match_data
+
+        # Extract named captures as parameters
+        params = {}
+        param_names.each do |name|
+          params[name.to_sym] = match_data[name] if match_data[name]
+        end
+
+        params
+      end
+
+      # Extract the schema and pattern from a URI template
+      def parse_uri_template(template)
+        # Parse the URI template to get schema and pattern
+        # Format: schema://path/{param1}/{param2}...
+        if template =~ /^([^:]+):\/\/(.+)$/
+          schema = $1
+          pattern = $2
+
+          # Replace parameter placeholders with generic markers to compare structure
+          normalized_pattern = pattern.gsub(/\{[^}]+\}/, "{param}")
+
+          return { schema: schema, pattern: normalized_pattern, original: template }
+        end
+
+        raise ArgumentError, "Invalid URI template format: #{template}"
+      end
+
+      # Validate that the URI template is unique
+      def validate_unique_uri_template(new_template)
+        new_template_data = parse_uri_template(new_template)
+
+        ResourceTemplate.registered_templates.each do |registered_class|
+          next if registered_class == self || registered_class.abstract?
+          next unless registered_class.uri_template
+
+          existing_template_data = parse_uri_template(registered_class.uri_template)
+
+          # Check if schema and structure are the same
+          if new_template_data[:schema] == existing_template_data[:schema] &&
+            are_potentially_ambiguous?(new_template_data[:pattern], existing_template_data[:pattern])
+
+            # Use a consistent error message format for all conflicts
+            raise ArgumentError, "URI template conflict detected: '#{new_template}' conflicts with existing template '#{registered_class.uri_template}' registered by #{registered_class.name}"
+          end
+        end
+      end
+
+      # Determine if two normalized patterns could be ambiguous
+      def are_potentially_ambiguous?(pattern1, pattern2)
+        # If the patterns are exactly the same, they're definitely ambiguous
+        return true if pattern1 == pattern2
+
+        # Split into segments to compare structure
+        segments1 = pattern1.split("/")
+        segments2 = pattern2.split("/")
+
+        # If different number of segments, they can't be ambiguous
+        return false if segments1.size != segments2.size
+
+        # Count parameter segments
+        param_segments1 = segments1.count { |s| s.include?("{param}") }
+        param_segments2 = segments2.count { |s| s.include?("{param}") }
+
+        # If they have different number of parameter segments, they're not ambiguous
+        return false if param_segments1 != param_segments2
+
+        # If we have the same number of segments and same number of parameters,
+        # but the patterns aren't identical, they could be ambiguous
+        # due to parameter position swapping
+        if param_segments1 > 0 && param_segments1 == param_segments2
+          # Create pattern maps (P for param, S for static)
+          pattern_map1 = segments1.map { |s| s.include?("{param}") ? "P" : "S" }
+          pattern_map2 = segments2.map { |s| s.include?("{param}") ? "P" : "S" }
+
+          # If pattern maps are different but have same param count, potentially ambiguous
+          return pattern_map1 != pattern_map2
+        end
+
+        false
+      end
+    end
+
+    # Initialize with attribute values
+    def initialize(attributes = {})
+      super(attributes)
+      validate!
+    end
+
+    # Override validate! to not raise exceptions
+    def validate!
+      valid?
+    end
+
+    # Add custom validation for required parameters
+    validate do |template|
+      self.class.required_parameters.each do |param|
+        if self.send(param).nil? || self.send(param).to_s.empty?
+          errors.add(param, "can't be blank")
+        end
       end
     end
 
     attr_reader :description, :uri_template, :mime_type
   end
-end
+end

data/lib/action_mcp/resource_templates_registry.rb

@@ -21,6 +21,139 @@ module ActionMCP
       def item_klass
         ResourceTemplate
       end
+
+      # Find the most specific template for a given URI
+      def find_template_for_uri(uri)
+        parse_result = parse_uri(uri)
+        return nil unless parse_result
+
+        schema = parse_result[:schema]
+        path = parse_result[:path]
+        path_segments = path.split("/")
+
+        matching_templates = ResourceTemplate.registered_templates.select do |template|
+          next unless template.uri_template
+
+          # Parse the template
+          template_data = parse_uri_template(template.uri_template)
+          next unless template_data && template_data[:schema] == schema
+
+          # Split template into segments and check if structure matches
+          template_segments = template_data[:path].split("/")
+          next unless template_segments.length == path_segments.length
+
+          # Check if each segment matches (either static match or a parameter)
+          segments_match = true
+
+          template_segments.each_with_index do |template_segment, index|
+            path_segment = path_segments[index]
+
+            if template_segment.start_with?("{") && template_segment.end_with?("}")
+              # This is a parameter segment, it matches any value
+              next
+            elsif template_segment != path_segment
+              # Static segment doesn't match
+              segments_match = false
+              break
+            end
+          end
+
+          segments_match
+        end
+
+        # If multiple templates match, select the most specific one
+        # (the one with the most static segments)
+        if matching_templates.size > 1
+          matching_templates.max_by do |template|
+            template_data = parse_uri_template(template.uri_template)
+            template_segments = template_data[:path].split("/")
+
+            # Count static segments (not parameters)
+            template_segments.count { |segment| !segment.start_with?("{") }
+          end
+        elsif matching_templates.size == 1
+          matching_templates.first
+        else
+          nil
+        end
+      end
+
+      # Check if a URI matches a specific template
+      def uri_matches_template?(uri, template)
+        uri_data = parse_uri(uri)
+        template_data = parse_uri_template(template.uri_template)
+
+        return false unless uri_data && template_data && uri_data[:schema] == template_data[:schema]
+
+        uri_segments = uri_data[:path].split("/")
+        template_segments = template_data[:path].split("/")
+
+        return false unless uri_segments.length == template_segments.length
+
+        # Check each segment
+        template_segments.each_with_index do |template_segment, index|
+          uri_segment = uri_segments[index]
+
+          # If template segment is a parameter, it matches anything
+          next if template_segment.start_with?("{") && template_segment.end_with?("}")
+
+          # Otherwise, segments must match exactly
+          return false if template_segment != uri_segment
+        end
+
+        true
+      end
+
+      # Extract parameter values from a URI based on a template
+      def extract_parameters(uri, template)
+        return {} unless uri_matches_template?(uri, template)
+
+        uri_data = parse_uri(uri)
+        template_data = parse_uri_template(template.uri_template)
+
+        uri_segments = uri_data[:path].split("/")
+        template_segments = template_data[:path].split("/")
+
+        # Extract parameters
+        params = {}
+        template_segments.each_with_index do |template_segment, index|
+          if template_segment.start_with?("{") && template_segment.end_with?("}")
+            # Extract parameter name without braces
+            param_name = template_segment[1...-1].to_sym
+            params[param_name] = uri_segments[index]
+          end
+        end
+
+        params
+      end
+
+      private
+
+      # Parse a concrete URI
+      def parse_uri(uri)
+        if uri =~ /^([^:]+):\/\/(.+)$/
+          {
+            schema: $1,
+            path: $2,
+            original: uri
+          }
+        else
+          nil
+        end
+      end
+
+      # Parse a URI template
+      def parse_uri_template(template)
+        if template =~ /^([^:]+):\/\/(.+)$/
+          {
+            schema: $1,
+            path: $2,
+            original: template
+          }
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -16,22 +16,46 @@ module ActionMCP
       # @param _metadata [Hash] Optional metadata.
       # @return [Hash] A hash containing the tool's response.
       def tool_call(tool_name, arguments, _metadata = {})
-        tool = find(tool_name)
-        tool = tool.new(arguments)
-        tool.validate
-        if tool.valid?
-          { content: [ tool.call ] }
-        else
-          {
-            content: tool.errors.full_messages.map { |msg| Content::Text.new(msg) },
-            isError: true
-          }
-        end
+        tool_class = find(tool_name)
+        tool = tool_class.new(arguments)
+
+        return error_response(tool.errors.full_messages) unless tool.valid?
+
+        process_result(tool.call)
+      rescue StandardError => e
+        error_response([ "Tool execution failed: #{e.message}" ])
       end
 
       def item_klass
         Tool
       end
+
+      private
+
+      def process_result(result)
+        case result
+        when Hash
+          return result if result[:isError]
+          success_response([ result ])
+        when String
+          success_response([ Content::Text.new(result) ])
+        when Array
+          success_response(result)
+        else
+          success_response([ result ])
+        end
+      end
+
+      def success_response(content)
+        { content: content }
+      end
+
+      def error_response(messages)
+        {
+          content: messages.map { |msg| Content::Text.new(msg) },
+          isError: true
+        }
+      end
     end
   end
 end

data/lib/action_mcp/transport/messaging.rb

@@ -15,6 +15,12 @@ module ActionMCP
         notification = JsonRpc::Notification.new(method: method, params: params)
         write_message(notification)
       end
+
+      def send_jsonrpc_error(request_id, symbol, message, data = nil)
+        error = JsonRpc::JsonRpcError.new(symbol, message:, data:)
+        response = JsonRpc::Response.new(id: request_id, error:)
+        write_message(response)
+      end
     end
   end
 end

data/lib/action_mcp/transport/resources.rb

@@ -3,10 +3,28 @@
 module ActionMCP
   module Transport
     module Resources
+      # Send list of available resources to the client
+      #
+      # @param request_id [String, Integer] The ID of the request to respond to
+      #
+      # @example Input:
+      #   request_id = "req-123"
+      #
+      # @example Output:
+      #   # Sends: {"jsonrpc":"2.0","id":"req-123","result":{"resources":[]}}
       def send_resources_list(request_id)
         send_jsonrpc_response(request_id, result: { resources: [] })
       end
 
+      # Send list of resource templates to the client
+      #
+      # @param request_id [String, Integer] The ID of the request to respond to
+      #
+      # @example Input:
+      #   request_id = "req-456"
+      #
+      # @example Output:
+      #   # Sends: {"jsonrpc":"2.0","id":"req-456","result":{"resourceTemplates":[{"uriTemplate":"db://{table}","name":"Database Table"}]}}
       def send_resource_templates_list(request_id)
         templates = ActionMCP::ResourceTemplatesRegistry.resource_templates.values.map do |template|
           template.to_h
@@ -17,10 +35,41 @@ module ActionMCP
         send_jsonrpc_response(request_id, result: { resourceTemplates: templates })
       end
 
+      # Read and return the contents of a resource
+      #
+      # @param id [String, Integer] The ID of the request to respond to
+      # @param params [Hash] Parameters specifying which resource to read
+      #
+      # @example Input:
+      #   id = "req-789"
+      #   params = { uri: "file:///example.txt" }
+      #
+      # @example Output:
+      #   # Sends: {"jsonrpc":"2.0","id":"req-789","result":{"contents":[{"uri":"file:///example.txt","text":"Example content"}]}}
       def send_resource_read(id, params)
-        send_jsonrpc_response(id, result: {})
+        if  (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
+          record = template.process(params[:uri])
+          if (resource = record.fetch)
+            # if resource is a array or a collection, return each item then it ok
+            # else wrap it in a array
+            resource = [ resource ] unless resource.respond_to?(:each)
+            content = resource.map(&:to_h)
+            send_jsonrpc_response(id, result: { contents: content })
+          else
+            send_jsonrpc_error(id, :resource_not_found, "Resource not found")
+          end
+        else
+          send_jsonrpc_error(id, :invalid_params, "Invalid resource URI")
+        end
       end
 
+      # Log all registered resource templates
+      #
+      # @example Input:
+      #   # No parameters
+      #
+      # @example Output:
+      #   # Logs: "Registered Resource Templates: ["db://{table}", "file://{path}"]"
       def log_resource_templates
         Rails.logger.info("Registered Resource Templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}")
       end

data/lib/action_mcp/version.rb

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

data/lib/generators/action_mcp/resource_template/templates/resource_template.rb.erb

@@ -7,8 +7,22 @@ class <%= class_name %> < MCPResourceTemplate
   parameter :product_id,
             description: "Product identifier",
             required: true
-  
-  def self.retrieve(params)
-    raise NotImplementedError, "resolve must be implemented in the subclass"
+
+  def fetch
+    # Fetch the product from the database or api or whatever
+    # Ruby Magic here
+    if (product = Product.find_by(id: product_id))
+
+      resource = ActionMCP::Content::Resource.new(
+        "ecommerce://orders/#{product_id}",
+        "application/json",
+        text: product.to_json,
+      )
+
+      resource
+
+    else
+      nil # Return nil if resource not found
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 bindir: exe
 cert_chain: []
-date: 2025-03-14 00:00:00.000000000 Z
+date: 2025-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -114,6 +114,7 @@ files:
 - app/models/action_mcp/session/message.rb
 - config/routes.rb
 - db/migrate/20250308122801_create_action_mcp_sessions.rb
+- db/migrate/20250314230152_add_is_ping_to_session_message.rb
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/capability.rb