actionmcp 0.14.0 → 0.16.0

data/lib/action_mcp/json_rpc_handler.rb

@@ -17,13 +17,13 @@ module ActionMCP
       request = if line.is_a?(String)
                   line.strip!
                   return if line.empty?
+
                   begin
                     MultiJson.load(line)
                   rescue MultiJson::ParseError => e
                     Rails.logger.error("Failed to parse JSON: #{e.message}")
                     return
                   end
-
       else
                   line
       end
@@ -46,22 +46,35 @@ module ActionMCP
       id = request["id"]
       params = request["params"]
 
+      # Common methods (both directions)
       case rpc_method
-      when "initialize"
+      when "initialize"                # [SERVER] Client initializing the connection
         transport.send_capabilities(id, params)
-      when "ping"
+      when "ping"                      # [BOTH] Client ping
         transport.send_pong(id)
-      when /^notifications\//
-        puts "\e[31mProcessing notifications\e[0m"
-        process_notifications(rpc_method, params)
-      when /^prompts\//
+
+        # Methods that servers must implement (client → server)
+      when %r{^prompts/}               # [SERVER] Prompt-related requests
         process_prompts(rpc_method, id, params)
-      when /^resources\//
+      when %r{^resources/}             # [SERVER] Resource-related requests
         process_resources(rpc_method, id, params)
-      when /^tools\//
+      when %r{^tools/}                 # [SERVER] Tool-related requests
         process_tools(rpc_method, id, params)
-      when "completion/complete"
+      when "completion/complete" # [SERVER] Completion requests
         process_completion_complete(id, params)
+
+        # Methods that clients must implement (server → client)
+      when "client/setLoggingLevel" # [CLIENT] Server configuring client logging
+        process_client_logging(id, params)
+      when %r{^roots/}                 # [CLIENT] Roots management
+        process_roots(rpc_method, id, params)
+      when %r{^sampling/}              # [CLIENT] Sampling requests
+        process_sampling(rpc_method, id, params)
+
+        # Notifications (can go both ways)
+      when %r{^notifications/}
+        puts "\e[31mProcessing notifications\e[0m"
+        process_notifications(rpc_method, params)
       else
         puts "\e[31mUnknown method: #{rpc_method} #{request}\e[0m"
       end
@@ -70,17 +83,31 @@ module ActionMCP
     # @param rpc_method [String]
     def process_notifications(rpc_method, params)
       case rpc_method
-      when "notifications/initialized"
+      when "notifications/initialized"            # [SERVER] Client initialization complete
         puts "\e[31mInitialized\e[0m"
         transport.initialize!
-      when "notifications/cancelled"
-        puts "\e[31m Request #{params["requestId"]} cancelled: #{params["reason"]}\e[0m"
+      when "notifications/cancelled"              # [BOTH] Request cancellation
+        puts "\e[31m Request #{params['requestId']} cancelled: #{params['reason']}\e[0m"
         # we don't need to do anything here
+      when "notifications/resources/updated" # [CLIENT] Resource update notification
+        puts "\e[31m Resource #{params['uri']} was updated\e[0m"
+        # Handle resource update notification
+      when "notifications/tools/list_changed" # [CLIENT] Tool list change notification
+        puts "\e[31m Tool list has changed\e[0m"
+        # Handle tool list change notification
+      when "notifications/prompts/list_changed" # [CLIENT] Prompt list change notification
+        puts "\e[31m Prompt list has changed\e[0m"
+        # Handle prompt list change notification
+      when "notifications/resources/list_changed" # [CLIENT] Resource list change notification
+        puts "\e[31m Resource list has changed\e[0m"
+        # Handle resource list change notification
       else
         Rails.logger.warn("Unknown notifications method: #{rpc_method}")
       end
     end
 
+    # Server methods (client → server)
+
     # @param id [String]
     # @param params [Hash]
     # @example {
@@ -117,9 +144,9 @@ module ActionMCP
     # @param params [Hash]
     def process_prompts(rpc_method, id, params)
       case rpc_method
-      when "prompts/get"
+      when "prompts/get"              # [SERVER] Get specific prompt
         transport.send_prompts_get(id, params["name"], params["arguments"])
-      when "prompts/list"
+      when "prompts/list"             # [SERVER] List available prompts
         transport.send_prompts_list(id)
       else
         Rails.logger.warn("Unknown prompts method: #{rpc_method}")
@@ -129,29 +156,74 @@ module ActionMCP
     # @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"
+      when "resources/list"           # [SERVER] List available resources
         transport.send_resources_list(id)
-      when "resources/templates/list"
+      when "resources/templates/list" # [SERVER] List resource templates
         transport.send_resource_templates_list(id)
-      when "resources/read"
+      when "resources/read"           # [SERVER] Read resource content
         transport.send_resource_read(id, params)
+      when "resources/subscribe"      # [SERVER] Subscribe to resource updates
+        transport.send_resource_subscribe(id, params["uri"])
+      when "resources/unsubscribe"    # [SERVER] Unsubscribe from resource updates
+        transport.send_resource_unsubscribe(id, params["uri"])
       else
         Rails.logger.warn("Unknown resources method: #{rpc_method}")
       end
     end
 
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
     def process_tools(rpc_method, id, params)
       case rpc_method
-      when "tools/list"
+      when "tools/list"               # [SERVER] List available tools
         transport.send_tools_list(id)
-      when "tools/call"
+      when "tools/call"               # [SERVER] Call a tool
         transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
       else
         Rails.logger.warn("Unknown tools method: #{rpc_method}")
       end
     end
+
+    # Client methods (server → client)
+
+    # @param id [String]
+    # @param params [Hash]
+    def process_client_logging(id, params)
+      level = params["level"]
+      transport.set_client_logging_level(id, level)
+    end
+
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    def process_roots(rpc_method, id, params)
+      case rpc_method
+      when "roots/list"               # [CLIENT] List available roots
+        transport.send_roots_list(id)
+      when "roots/add"                # [CLIENT] Add a root
+        transport.send_roots_add(id, params["uri"], params["name"])
+      when "roots/remove"             # [CLIENT] Remove a root
+        transport.send_roots_remove(id, params["uri"])
+      else
+        Rails.logger.warn("Unknown roots method: #{rpc_method}")
+      end
+    end
+
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    def process_sampling(rpc_method, id, params)
+      case rpc_method
+      when "sampling/createMessage" # [CLIENT] Create a message using AI
+        # @param id [String]
+        # @param params [SamplingRequest]
+        transport.send_sampling_create_message(id, params)
+      else
+        Rails.logger.warn("Unknown sampling method: #{rpc_method}")
+      end
+    end
   end
 end

data/lib/action_mcp/log_subscriber.rb

@@ -0,0 +1,28 @@
+# In log_subscriber.rb
+module ActionMCP
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def tool_call(event)
+      # Try both debug and info to ensure output regardless of logger level
+      debug "Tool: #{event.payload[:tool_name]} (#{event.duration.round(2)}ms)"
+      info "Tool: #{event.payload[:tool_name]} (#{event.duration.round(2)}ms)"
+
+      # Track total tool time for summary
+      Thread.current[:tool_runtime] ||= 0
+      Thread.current[:tool_runtime] += event.duration
+    end
+
+    def prompt_call(event)
+      # Add debug output to confirm method is called
+      puts "LogSubscriber#prompt_call called with: #{event.name}"
+
+      # Try both debug and info to ensure output regardless of logger level
+      debug "Prompt: #{event.payload[:prompt_name]} (#{event.duration.round(2)}ms)"
+      info "Prompt: #{event.payload[:prompt_name]} (#{event.duration.round(2)}ms)"
+
+      # Track total prompt time for summary
+      Thread.current[:prompt_runtime] ||= 0
+      Thread.current[:prompt_runtime] += event.duration
+    end
+    attach_to :action_mcp
+  end
+end

data/lib/action_mcp/logging.rb

@@ -11,9 +11,7 @@ module ActionMCP
 
     # Included hook to configure the logger.
     included do
-      logger_instance = ActiveSupport::Logger.new(STDOUT)
-      logger_instance.level = Logger.const_get(ActionMCP.configuration.logging_level.to_s.upcase)
-      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(logger_instance)
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
     end
   end
 end

data/lib/action_mcp/prompt.rb

@@ -3,6 +3,7 @@
 module ActionMCP
   # Abstract base class for Prompts
   class Prompt < Capability
+    include ActionMCP::Callbacks
     class_attribute :_argument_definitions, instance_accessor: false, default: []
 
     # ---------------------------------------------------
@@ -29,6 +30,10 @@ module ActionMCP
 
     class << self
       alias default_capability_name default_prompt_name
+
+      def type
+        :prompt
+      end
     end
 
     # ---------------------------------------------------
@@ -56,9 +61,9 @@ module ActionMCP
       attribute arg_name, :string, default: default
       validates arg_name, presence: true if required
 
-      if enum.present?
-        validates arg_name, inclusion: { in: enum }, allow_blank: !required
-      end
+      return unless enum.present?
+
+      validates arg_name, inclusion: { in: enum }, allow_blank: !required
     end
 
     # Returns the list of argument definitions.
@@ -108,8 +113,10 @@ module ActionMCP
       # Check validations before proceeding
       if valid?
         begin
-          perform # Invoke the subclass-specific logic if valid
-        rescue
+          run_callbacks :perform do
+            perform # Invoke the subclass-specific logic if valid
+          end
+        rescue StandardError
           # Handle exceptions during execution
           @response.mark_as_error!(:internal_error, message: "Unhandled Error executing prompt")
         end
@@ -132,7 +139,9 @@ module ActionMCP
 
       errors_info = errors.any? ? ", errors: #{errors.full_messages}" : ""
 
-      "#<#{self.class.name} #{attributes_hash.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}, #{response_info}#{errors_info}>"
+      "#<#{self.class.name} #{attributes_hash.map do |k, v|
+        "#{k}: #{v.inspect}"
+      end.join(', ')}, #{response_info}#{errors_info}>"
     end
 
     # Override render to collect messages

data/lib/action_mcp/prompt_response.rb

@@ -45,7 +45,7 @@ module ActionMCP
     end
 
     # Alias as_json to to_h for consistency
-    alias_method :as_json, :to_h
+    alias as_json to_h
 
     # Handle to_json directly
     def to_json(options = nil)

data/lib/action_mcp/prompts_registry.rb

@@ -17,6 +17,7 @@ module ActionMCP
       def prompt_call(prompt_name, arguments)
         prompt = find(prompt_name)
         prompt = prompt.new(arguments)
+
         prompt.call
       end
 

data/lib/action_mcp/registry_base.rb

@@ -13,6 +13,7 @@ module ActionMCP
       def items
         @items = item_klass.descendants.each_with_object({}) do |klass, hash|
           next if klass.abstract?
+
           hash[klass.capability_name] = klass
         end
       end

data/lib/action_mcp/resource_callbacks.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/core_ext/module/attribute_accessors"
+
+module ActionMCP
+  # = Action MCP Resource Template \Callbacks
+  #
+  # Action MCP Resource Template Callbacks provide hooks during the resource resolution lifecycle.
+  # These callbacks allow you to trigger logic during the resource resolution process.
+  # Available callbacks are:
+  #
+  # * <tt>before_resolve</tt>
+  # * <tt>around_resolve</tt>
+  # * <tt>after_resolve</tt>
+  module ResourceCallbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    class << self
+      include ActiveSupport::Callbacks
+      define_callbacks :execute
+    end
+
+    included do
+      define_callbacks :resolve, skip_after_callbacks_if_terminated: true
+    end
+
+    # These methods will be included into any Action MCP Resource Template object, adding
+    # callbacks for the +resolve+ method.
+    class_methods do
+      # Defines a callback that will get called right before the
+      # resource template's resolve method is executed.
+      #
+      #   class OrdersTemplate < ApplicationMCPResTemplate
+      #     description "Access order information"
+      #     uri_template "ecommerce://customers/{customer_id}/orders/{order_id}"
+      #     mime_type "application/json"
+      #
+      #     parameter :customer_id,
+      #               description: "Customer identifier",
+      #               required: true
+      #     parameter :order_id,
+      #               description: "Order identifier",
+      #               required: true
+      #
+      #     before_resolve do |template|
+      #       Rails.logger.info("Starting to resolve order: #{template.order_id} for customer: #{template.customer_id}")
+      #     end
+      #
+      #     def resolve
+      #       order = MockOrder.find_by(id: order_id)
+      #       return unless order
+      #
+      #       ActionMCP::Resource.new(
+      #         uri: "ecommerce://orders/#{order_id}",
+      #         name: "Order #{order_id}",
+      #         description: "Order information for order #{order_id}",
+      #         mime_type: "application/json",
+      #         size: order.to_json.length
+      #       )
+      #     end
+      #   end
+      #
+      def before_resolve(*filters, &blk)
+        set_callback(:resolve, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # resource template's resolve method has finished.
+      #
+      #   class OrdersTemplate < ApplicationMCPResTemplate
+      #     description "Access order information"
+      #     uri_template "ecommerce://customers/{customer_id}/orders/{order_id}"
+      #     mime_type "application/json"
+      #
+      #     parameter :customer_id,
+      #               description: "Customer identifier",
+      #               required: true
+      #     parameter :order_id,
+      #               description: "Order identifier",
+      #               required: true
+      #
+      #     after_resolve do |template|
+      #       Rails.logger.info("Finished resolving order resource for order: #{template.order_id}")
+      #     end
+      #
+      #     def resolve
+      #       order = MockOrder.find_by(id: order_id)
+      #       return unless order
+      #
+      #       ActionMCP::Resource.new(
+      #         uri: "ecommerce://orders/#{order_id}",
+      #         name: "Order #{order_id}",
+      #         description: "Order information for order #{order_id}",
+      #         mime_type: "application/json",
+      #         size: order.to_json.length
+      #       )
+      #     end
+      #   end
+      #
+      def after_resolve(*filters, &blk)
+        set_callback(:resolve, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the resource template's resolve method.
+      #
+      #   class OrdersTemplate < ApplicationMCPResTemplate
+      #     description "Access order information"
+      #     uri_template "ecommerce://customers/{customer_id}/orders/{order_id}"
+      #     mime_type "application/json"
+      #
+      #     parameter :customer_id,
+      #               description: "Customer identifier",
+      #               required: true
+      #     parameter :order_id,
+      #               description: "Order identifier",
+      #               required: true
+      #
+      #     around_resolve do |template, block|
+      #       start_time = Time.current
+      #       Rails.logger.info("Starting resolution for order: #{template.order_id}")
+      #
+      #       resource = block.call
+      #
+      #       if resource
+      #         Rails.logger.info("Order #{template.order_id} resolved successfully in #{Time.current - start_time}s")
+      #       else
+      #         Rails.logger.info("Order #{template.order_id} not found")
+      #       end
+      #
+      #       resource
+      #     end
+      #
+      #     def resolve
+      #       order = MockOrder.find_by(id: order_id)
+      #       return unless order
+      #
+      #       ActionMCP::Resource.new(
+      #         uri: "ecommerce://orders/#{order_id}",
+      #         name: "Order #{order_id}",
+      #         description: "Order information for order #{order_id}",
+      #         mime_type: "application/json",
+      #         size: order.to_json.length
+      #       )
+      #     end
+      #   end
+      #
+      # You can access the return value of the resolve method as shown above.
+      #
+      def around_resolve(*filters, &blk)
+        set_callback(:resolve, :around, *filters, &blk)
+      end
+    end
+  end
+end

data/lib/action_mcp/resource_template.rb

@@ -7,12 +7,14 @@ module ActionMCP
     # Add ActiveModel capabilities
     include ActiveModel::Model
     include ActiveModel::Validations
+    include ResourceCallbacks
+    include Logging
 
     # Track all registered templates
     @registered_templates = []
 
     class << self
-      attr_reader :registered_templates
+      attr_reader :registered_templates, :description, :uri_template, :mime_type, :template_name, :parameters
 
       def abstract?
         @abstract ||= false
@@ -29,8 +31,6 @@ module ActionMCP
         subclass.instance_variable_set(:@required_parameters, [])
       end
 
-      attr_reader :description, :uri_template, :mime_type, :template_name, :parameters
-
       # Track required parameters for validation
       def required_parameters
         @required_parameters ||= []
@@ -48,7 +48,7 @@ module ActionMCP
       end
 
       # Alias parameter to attribute for clarity
-      alias_method :attribute, :parameter
+      alias attribute parameter
 
       def parameters
         @parameters || {}
@@ -87,6 +87,7 @@ module ActionMCP
           mimeType: @mime_type
         }.compact
       end
+
       def capability_name
         @capability_name ||= name.demodulize.underscore.sub(/_template$/, "")
       end
@@ -134,7 +135,7 @@ module ActionMCP
 
         # Add any remaining text after the last parameter
         if current_pos < @uri_template.length
-          suffix = Regexp.escape(@uri_template[current_pos..-1])
+          suffix = Regexp.escape(@uri_template[current_pos..])
           regex_parts << suffix
         end
 
@@ -159,9 +160,9 @@ module ActionMCP
       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
+        if template =~ %r{^([^:]+)://(.+)$}
+          schema = ::Regexp.last_match(1)
+          pattern = ::Regexp.last_match(2)
 
           # Replace parameter placeholders with generic markers to compare structure
           normalized_pattern = pattern.gsub(/\{[^}]+\}/, "{param}")
@@ -180,17 +181,17 @@ module ActionMCP
           next if registered_class == self || registered_class.abstract?
           next unless registered_class.uri_template
           # Ignore conflicts with resource templates that have the same name
-          next if registered_class.name == self.name
+          next if registered_class.name == name
 
           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])
+          next unless 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
+          # 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
 
@@ -216,7 +217,7 @@ module ActionMCP
         # 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
+        if param_segments1.positive? && 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" }
@@ -241,11 +242,9 @@ module ActionMCP
     end
 
     # Add custom validation for required parameters
-    validate do |template|
+    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
+        errors.add(param, "can't be blank") if send(param).nil? || send(param).to_s.empty?
       end
     end
 

data/lib/action_mcp/resource_templates_registry.rb

@@ -73,8 +73,6 @@ module ActionMCP
           end
         elsif matching_templates.size == 1
           matching_templates.first
-        else
-          nil
         end
       end
 
@@ -117,11 +115,11 @@ module ActionMCP
         # 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
+          next unless 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
 
         params
@@ -131,28 +129,24 @@ module ActionMCP
 
       # Parse a concrete URI
       def parse_uri(uri)
-        if uri =~ /^([^:]+):\/\/(.+)$/
-          {
-            schema: $1,
-            path: $2,
-            original: uri
-          }
-        else
-          nil
-        end
+        return unless uri =~ %r{^([^:]+)://(.+)$}
+
+        {
+          schema: ::Regexp.last_match(1),
+          path: ::Regexp.last_match(2),
+          original: uri
+        }
       end
 
       # Parse a URI template
       def parse_uri_template(template)
-        if template =~ /^([^:]+):\/\/(.+)$/
-          {
-            schema: $1,
-            path: $2,
-            original: template
-          }
-        else
-          nil
-        end
+        return unless template =~ %r{^([^:]+)://(.+)$}
+
+        {
+          schema: ::Regexp.last_match(1),
+          path: ::Regexp.last_match(2),
+          original: template
+        }
       end
     end
   end