actionmcp 0.50.1 → 0.50.2

data/lib/action_mcp/instrumentation/controller_runtime.rb

@@ -28,7 +28,7 @@ module ActionMCP
         def log_process_action(payload)
           messages = super
           mcp_runtime = payload[:mcp_runtime]
-          messages << (format("MCP: %.1fms", mcp_runtime.to_f)) if mcp_runtime
+          messages << format("MCP: %.1fms", mcp_runtime.to_f) if mcp_runtime
           messages
         end
       end

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -75,6 +75,7 @@ module ActionMCP
     # @param request [Hash]
     def process_request(request)
       return unless valid_request?(request)
+
       request = request.with_indifferent_access
 
       read(request)

data/lib/action_mcp/log_subscriber.rb

@@ -2,6 +2,11 @@
 
 module ActionMCP
   class LogSubscriber < ActiveSupport::LogSubscriber
+    # Thread-local storage for additional metrics
+    class << self
+      attr_accessor :custom_metrics, :subscribed_events, :formatters, :metric_groups
+    end
+
     def self.reset_runtime
       # Get the combined runtime from both tool and prompt operations
       tool_rt = Thread.current[:mcp_tool_runtime] || 0
@@ -26,6 +31,161 @@ module ActionMCP
       Thread.current[:mcp_prompt_runtime] += event.duration
     end
 
+    # Add a custom metric to be included in logs
+    def self.add_metric(name, value)
+      self.custom_metrics ||= {}
+      self.custom_metrics[name] = value
+    end
+
+    # Measure execution time of a block and add as metric
+    def self.measure_metric(name)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = yield
+      duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0
+
+      add_metric(name, duration)
+      result
+    end
+
+    # Reset all custom metrics
+    def self.reset_metrics
+      self.custom_metrics = nil
+    end
+
+    # Subscribe to a Rails event to capture metrics
+    # @param pattern [String] Event name pattern (e.g., "sql.active_record")
+    # @param metric_name [Symbol] Name to use for the metric
+    # @param options [Hash] Options for capturing the metric
+    def self.subscribe_event(pattern, metric_name, options = {})
+      self.subscribed_events ||= {}
+
+      # Store subscription info
+      self.subscribed_events[pattern] = {
+        metric_name: metric_name,
+        options: options
+      }
+
+      # Create the actual subscription
+      ActiveSupport::Notifications.subscribe(pattern) do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+
+        # Extract value based on options
+        value = if options[:duration]
+                  event.duration
+        elsif options[:extract_value].respond_to?(:call)
+                  options[:extract_value].call(event)
+        else
+                  1 # Default to count
+        end
+
+        # Accumulate or set the metric
+        if options[:accumulate]
+          self.custom_metrics ||= {}
+          self.custom_metrics[metric_name] ||= 0
+          self.custom_metrics[metric_name] += value
+        else
+          add_metric(metric_name, value)
+        end
+      end
+    end
+
+    # Format metrics for display in logs
+    def self.format_metrics
+      return nil if custom_metrics.nil? || custom_metrics.empty?
+
+      # If grouping is enabled, organize metrics by groups
+      if metric_groups.present?
+        grouped_metrics = {}
+
+        # Initialize groups with empty arrays
+        metric_groups.each_key do |group_name|
+          grouped_metrics[group_name] = []
+        end
+
+        # Add "other" group for ungrouped metrics
+        grouped_metrics[:other] = []
+
+        # Assign metrics to their groups
+        custom_metrics.each do |key, value|
+          group = nil
+
+          # Find which group this metric belongs to
+          metric_groups.each do |group_name, metrics|
+            if metrics.include?(key)
+              group = group_name
+              break
+            end
+          end
+
+          # Format the metric
+          formatter = formatters&.dig(key)
+          formatted_value = if formatter.respond_to?(:call)
+                              formatter.call(value)
+          elsif value.is_a?(Float)
+                              format("%.1fms", value)
+          else
+                              value.to_s
+          end
+
+          formatted_metric = "#{key}: #{formatted_value}"
+
+          # Add to appropriate group (or "other")
+          if group
+            grouped_metrics[group] << formatted_metric
+          else
+            grouped_metrics[:other] << formatted_metric
+          end
+        end
+
+        # Join metrics within groups, then join groups
+        grouped_metrics.map do |_group, metrics|
+          next if metrics.empty?
+
+          metrics.join(" | ")
+        end.compact.join(" | ")
+      else
+        # No grouping, just format all metrics
+        custom_metrics.map do |key, value|
+          formatter = formatters&.dig(key)
+          formatted_value = if formatter.respond_to?(:call)
+                              formatter.call(value)
+          elsif value.is_a?(Float)
+                              format("%.1fms", value)
+          else
+                              value.to_s
+          end
+          "#{key}: #{formatted_value}"
+        end.join(" | ")
+      end
+    end
+
+    # Register a custom formatter for a specific metric
+    # @param metric_name [Symbol] The name of the metric
+    # @param block [Proc] The formatter block that takes the value and returns a string
+    def self.register_formatter(metric_name, &block)
+      self.formatters ||= {}
+      self.formatters[metric_name] = block
+    end
+
+    # Define a group of related metrics
+    # @param group_name [Symbol] The name of the metric group
+    # @param metrics [Array<Symbol>] The metrics that belong to this group
+    def self.define_metric_group(group_name, metrics)
+      self.metric_groups ||= {}
+      self.metric_groups[group_name] = metrics
+    end
+
+    # Enhance process_action to include our custom metrics
+    def process_action(event)
+      return unless logger.info?
+
+      return unless self.class.custom_metrics.present?
+
+      metrics_msg = self.class.format_metrics
+      event.payload[:message] = "#{event.payload[:message]} | #{metrics_msg}" if metrics_msg
+      self.class.reset_metrics
+    end
+
     attach_to :action_mcp
   end
 end

data/lib/action_mcp/resource_template.rb

@@ -13,7 +13,7 @@ module ActionMCP
 
     # Track all registered templates
     @registered_templates = []
-    attr_reader :execution_context
+    attr_reader :execution_context, :description, :uri_template, :mime_type
 
     class << self
       attr_reader :registered_templates, :description, :uri_template,
@@ -227,8 +227,6 @@ module ActionMCP
       end
     end
 
-    attr_reader :description, :uri_template, :mime_type
-
     def call
       run_callbacks :resolve do
         resolve

data/lib/action_mcp/server/capabilities.rb

@@ -16,7 +16,8 @@ module ActionMCP
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'protocolVersion'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'protocolVersion'" } } }
         end
         # Check if the protocol version is supported
         unless ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
@@ -25,20 +26,21 @@ module ActionMCP
             requested: client_protocol_version
           }
           send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Unsupported protocol version", data: error_data } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Unsupported protocol version", data: error_data } } }
         end
 
         unless client_info.is_a?(Hash)
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'clientInfo'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'clientInfo'" } } }
         end
         unless client_capabilities.is_a?(Hash)
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'capabilities'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'capabilities'" } } }
         end
 
-
-
         # Store client information
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
@@ -47,12 +49,13 @@ module ActionMCP
         # Initialize the session
         unless session.initialize!
           send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32603, message: "Failed to initialize session" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_603, message: "Failed to initialize session" } } }
         end
 
         # Send the successful response with the protocol version the client requested
         capabilities_payload = session.server_capabilities_payload
-        capabilities_payload[:protocolVersion] = client_protocol_version  # Use the client's requested version
+        capabilities_payload[:protocolVersion] = client_protocol_version # Use the client's requested version
 
         send_jsonrpc_response(request_id, result: capabilities_payload)
         { type: :responses, id: request_id, payload: { jsonrpc: "2.0", id: request_id, result: capabilities_payload } }

data/lib/action_mcp/server/configuration.rb

@@ -39,8 +39,10 @@ module ActionMCP
 
         yaml = ERB.new(File.read(@config_path)).result
         YAML.safe_load(yaml, aliases: true) || {}
-      rescue => e
-        Rails.logger.error("Error loading ActionMCP config: #{e.message}") if defined?(Rails) && Rails.respond_to?(:logger)
+      rescue StandardError => e
+        if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger.error("Error loading ActionMCP config: #{e.message}")
+        end
         {}
       end
 
@@ -52,6 +54,7 @@ module ActionMCP
         while path != "/"
           config_path = File.join(path, "config", "mcp.yml")
           return config_path if File.exist?(config_path)
+
           path = File.dirname(path)
         end
 

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -4,37 +4,30 @@ module ActionMCP
   module Server
     class JsonRpcHandler < JsonRpcHandlerBase
       # Handle server-specific methods
-      # @param rpc_method [String]
-      # @param id [String, Integer]
-      # @param params [Hash]
-      def call(line)
-        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
+      # @param request [JSON_RPC::Request, JSON_RPC::Notification, JSON_RPC::Response]
+      def call(request)
+        read(request.to_h)
+        case request
+        when JSON_RPC::Request
+          handle_request(request)
+        when JSON_RPC::Notification
+          handle_notification(request)
+        when JSON_RPC::Response
+          handle_response(request)
         end
-
-        # Store the request ID for error responses
-        @current_request_id = request["id"] if request.is_a?(Hash)
-
-        process_request(request)
       end
 
-      def handle_method(rpc_method, id, params)
-        # Ensure we have the current request ID
-        @current_request_id = id
+      private
+
+      def handle_request(request)
+        @current_request_id = id = request.id
+        rpc_method = request.method
+        params = request.params
 
         case rpc_method
         when "initialize"
-          transport.send_capabilities(id, params)
+          message = transport.send_capabilities(id, params)
+          extract_message_payload(message, id)
         when %r{^prompts/}
           process_prompts(rpc_method, id, params)
         when %r{^resources/}
@@ -44,104 +37,178 @@ module ActionMCP
         when "completion/complete"
           process_completion_complete(id, params)
         else
-          transport.send_jsonrpc_error(id, :method_not_found, "Method not found #{rpc_method}")
+          error_response(id, :method_not_found, "Method not found: #{rpc_method}")
         end
-      rescue StandardError => e
-        Rails.logger.error("Error handling method #{rpc_method}: #{e.message}")
-        transport.send_jsonrpc_error(id, :internal_error, "Internal error: #{e.message}")
       end
 
+      def handle_notification(notification)
+        @current_request_id = nil
 
-      # Server methods (client → server)
-
-      # @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)
-        # TODO: Not Implemented, but to remove the error message in the inspector
-        transport.send_jsonrpc_response(id, result: { completion: { values: [], total: 0, hasMore: false } })
-        case params["ref"]["type"]
-        when "ref/prompt"
-          # TODO: Implement completion
-        when "ref/resource"
-          # TODO: Implement completion
+        begin
+          method_name = notification.method.to_s
+          params = notification.params || {}
+
+          process_notifications(method_name, params)
+          { type: :notifications_only }
+        rescue StandardError => e
+          Rails.logger.error("Error handling notification #{notification.method}: #{e.message}")
+          Rails.logger.error(e.backtrace.join("\n"))
+          { type: :notifications_only }
         end
       end
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
+      def handle_response(response)
+        Rails.logger.debug("Received response: #{response.inspect}")
+        {
+          type: :responses,
+          request_id: response.id,
+          payload: {
+            jsonrpc: "2.0",
+            id: response.id,
+            result: response.result
+          }
+        }
+      end
+
       def process_prompts(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "prompts/get" # Get specific prompt
-          transport.send_prompts_get(id, params["name"], params["arguments"])
-        when "prompts/list" # List available prompts
-          transport.send_prompts_list(id)
+        when "prompts/get"
+          name = params["name"] || params[:name]
+          arguments = params["arguments"] || params[:arguments] || {}
+          message = transport.send_prompts_get(id, name, arguments)
+          extract_message_payload(message, id)
+        when "prompts/list"
+          message = transport.send_prompts_list(id)
+          extract_message_payload(message, id)
         else
           Rails.logger.warn("Unknown prompts method: #{rpc_method}")
+          error_response(id, :method_not_found, "Unknown prompts method: #{rpc_method}")
         end
       end
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
       def process_tools(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "tools/list" # List available tools
-          transport.send_tools_list(id, params)
-        when "tools/call" # Call a tool
-          transport.send_tools_call(id, params["name"], params["arguments"])
+        when "tools/list"
+          message = transport.send_tools_list(id, params)
+          extract_message_payload(message, id)
+        when "tools/call"
+          name = params["name"] || params[:name]
+          arguments = params["arguments"] || params[:arguments] || {}
+
+          return error_response(id, :invalid_params, "Tool name is required") if name.nil?
+
+          message = transport.send_tools_call(id, name, arguments)
+          extract_message_payload(message, id)
         else
           Rails.logger.warn("Unknown tools method: #{rpc_method}")
+          error_response(id, :method_not_found, "Unknown tools method: #{rpc_method}")
         end
       end
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
       def process_resources(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "resources/list" # List available resources
-          transport.send_resources_list(id)
-        when "resources/templates/list" # List resource templates
-          transport.send_resource_templates_list(id)
-        when "resources/read" # Read resource content
-          transport.send_resource_read(id, params)
-        when "resources/subscribe" # Subscribe to resource updates
-          transport.send_resource_subscribe(id, params["uri"])
-        when "resources/unsubscribe" # Unsubscribe from resource updates
-          transport.send_resource_unsubscribe(id, params["uri"])
+        when "resources/list"
+          message = transport.send_resources_list(id)
+          extract_message_payload(message, id)
+        when "resources/templates/list"
+          message = transport.send_resource_templates_list(id)
+          extract_message_payload(message, id)
+        when "resources/read"
+          return error_response(id, :invalid_params, "Resource URI is required") if params.nil? || params.empty?
+
+          message = transport.send_resource_read(id, params)
+          extract_message_payload(message, id)
+        when "resources/subscribe"
+          uri = params["uri"] || params[:uri]
+          return error_response(id, :invalid_params, "Resource URI is required") if uri.nil?
+
+          message = transport.send_resource_subscribe(id, uri)
+          extract_message_payload(message, id)
+        when "resources/unsubscribe"
+          uri = params["uri"] || params[:uri]
+          return error_response(id, :invalid_params, "Resource URI is required") if uri.nil?
+
+          message = transport.send_resource_unsubscribe(id, uri)
+          extract_message_payload(message, id)
         else
           Rails.logger.warn("Unknown resources method: #{rpc_method}")
+          error_response(id, :method_not_found, "Unknown resources method: #{rpc_method}")
+        end
+      end
+
+      def process_completion_complete(id, params)
+        params ||= {}
+
+        result = transport.send_jsonrpc_response(id, result: {
+          completion: { values: [], total: 0, hasMore: false }
+        })
+
+        if result.is_a?(ActionMCP::Session::Message)
+          extract_message_payload(result, id)
+        else
+          wrap_transport_result(result, id)
         end
       end
 
       def process_notifications(rpc_method, params)
         case rpc_method
-        when "notifications/initialized" # Client initialization complete
-          puts "\e[31mInitialized\e[0m"
+        when "notifications/initialized"
+          Rails.logger.info "Client notified initialization complete"
           transport.initialize!
         else
           super
         end
       end
+
+      def extract_message_payload(message, id)
+        if message.is_a?(ActionMCP::Session::Message)
+          {
+            type: :responses,
+            request_id: id,
+            payload: message.message_json
+          }
+        else
+        message
+        end
+      end
+
+      def wrap_transport_result(transport_result, id)
+        if transport_result.is_a?(Hash) && transport_result[:type]
+          transport_result
+        else
+          {
+            type: :responses,
+            request_id: id,
+            payload: transport_result
+          }
+        end
+      end
+
+      def error_response(id, code, message)
+        error_code = case code
+        when :method_not_found then -32_601
+        when :invalid_params then -32_602
+        when :internal_error then -32_603
+        else -32_000
+        end
+
+        {
+          type: :error,
+          request_id: id,
+          payload: {
+            jsonrpc: "2.0",
+            id: id,
+            error: { code: error_code, message: message }
+          },
+          status: :bad_request
+        }
+      end
     end
   end
 end

data/lib/action_mcp/server/registry_management.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # lib/action_mcp/server/registry_management.rb
 module ActionMCP
   module Server

data/lib/action_mcp/server/simple_pub_sub.rb

@@ -13,7 +13,7 @@ module ActionMCP
       DEFAULT_MIN_THREADS = 5
       DEFAULT_MAX_THREADS = 10
       DEFAULT_MAX_QUEUE = 100
-      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+      DEFAULT_THREAD_TIMEOUT = 60 # seconds
 
       def initialize(options = {})
         @subscriptions = Concurrent::Map.new
@@ -58,6 +58,7 @@ module ActionMCP
       def subscribed_to?(channel)
         channel_subs = @channels[channel]
         return false if channel_subs.nil?
+
         !channel_subs.empty?
       end
 
@@ -91,11 +92,9 @@ module ActionMCP
           next unless subscription && subscription[:message_callback]
 
           @thread_pool.post do
-            begin
-              subscription[:message_callback].call(message)
-            rescue StandardError => e
-              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
-            end
+            subscription[:message_callback].call(message)
+          rescue StandardError => e
+            log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
           end
         end
       end
@@ -106,6 +105,7 @@ module ActionMCP
       def has_subscribers?(channel)
         subscribers = @channels[channel]
         return false unless subscribers
+
         !subscribers.empty?
       end
 
@@ -138,6 +138,7 @@ module ActionMCP
 
       def log_error(message)
         return unless defined?(Rails) && Rails.respond_to?(:logger)
+
         Rails.logger.error("SimplePubSub: #{message}")
       end
     end