actionmcp 0.14.0 → 0.17.0

data/lib/action_mcp/base_json_rpc_handler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Base handler for common functionality
+  class BaseJsonRpcHandler
+    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 = parse_request(line)
+      return unless request
+
+      process_request(request)
+    end
+
+    protected
+
+    def parse_request(line)
+      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}")
+          nil
+        end
+      else
+        line
+      end
+    end
+
+    # @param request [Hash]
+    def process_request(request)
+      unless request["jsonrpc"] == "2.0"
+        puts "Invalid request: #{request}"
+        return
+      end
+      read(request)
+      return if request["error"]
+      return if request["result"] == {} # Probably a pong
+
+      rpc_method = request["method"]
+      id = request["id"]
+      params = request["params"]
+
+      # Common methods (both directions)
+      case rpc_method
+      when "ping"                      # [BOTH] Ping message
+        transport.send_pong(id)
+      when "initialize"                # [BOTH] Initialization
+        handle_initialize(id, params)
+      when %r{^notifications/}
+        process_common_notifications(rpc_method, params)
+      else
+        handle_specific_method(rpc_method, id, params)
+      end
+    end
+
+    # Override in subclasses
+    def handle_initialize(id, params)
+      raise NotImplementedError, "Subclasses must implement #handle_initialize"
+    end
+
+    # Override in subclasses
+    def handle_specific_method(rpc_method, id, params)
+      raise NotImplementedError, "Subclasses must implement #handle_specific_method"
+    end
+
+    def process_common_notifications(rpc_method, params)
+      case rpc_method
+      when "notifications/initialized"            # [BOTH] Initialization complete
+        puts "Initialized"
+        transport.initialize!
+      when "notifications/cancelled"              # [BOTH] Request cancellation
+        puts "Request #{params['requestId']} cancelled: #{params['reason']}"
+        # Handle cancellation
+      else
+        handle_specific_notification(rpc_method, params)
+      end
+    end
+
+    # Override in subclasses
+    def handle_specific_notification(rpc_method, params)
+      raise NotImplementedError, "Subclasses must implement #handle_specific_notification"
+    end
+  end
+end

data/lib/action_mcp/callbacks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/core_ext/module/attribute_accessors"
+
+module ActionMCP
+  # = Action MCP \Callbacks
+  #
+  # Action MCP provides hooks during the life cycle of a message, command, or process.
+  # Callbacks allow you to trigger logic during this cycle. Available callbacks are:
+  #
+  # * <tt>before_perform</tt>
+  # * <tt>around_perform</tt>
+  # * <tt>after_perform</tt>
+  module Callbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    class << self
+      include ActiveSupport::Callbacks
+      define_callbacks :execute
+    end
+
+    included do
+      define_callbacks :perform, skip_after_callbacks_if_terminated: true
+    end
+
+    # These methods will be included into any Action MCP capability, adding
+    # callbacks for the +perform+ method.
+    class_methods do
+      # Defines a callback that will get called right before the
+      # object's perform method is executed.
+      #
+      #   class AnalyzeCsvTool < ApplicationMCPTool
+      #     description "Analyze a CSV file"
+      #
+      #     property :filepath, type: "string", description: "Path to CSV file"
+      #     collection :operations, type: "string", description: "Operations to perform"
+      #
+      #     validates :operations, inclusion: { in: %w[sum average count] }
+      #
+      #     before_perform do |mcp|
+      #       Rails.logger.info("Starting CSV analysis for: #{mcp.filepath}")
+      #     end
+      #
+      #     def perform
+      #       result = operations.to_h { |op| [ op, rand(1..100) ] }
+      #       render text: result.to_json
+      #     end
+      #   end
+      #
+      def before_perform(*filters, &blk)
+        set_callback(:perform, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # object's perform method has finished.
+      #
+      #   class GreetingPrompt < ApplicationMCPPrompt
+      #     description "Generates a personalized greeting message"
+      #
+      #     argument :name, description: "The name to greet", required: true
+      #     argument :style, description: "Style of greeting", enum: %w[formal casual friendly], default: "friendly"
+      #
+      #     after_perform do |mcp|
+      #       Rails.logger.info("Generated #{mcp.style} greeting for #{mcp.name}")
+      #     end
+      #
+      #     def perform
+      #       render text: "Please create a greeting for #{name}"
+      #       render text: "I'd be happy to create a #{style} greeting for #{name}!", role: "assistant"
+      #       render text: "The greeting should be in #{style} style."
+      #     end
+      #   end
+      #
+      def after_perform(*filters, &blk)
+        set_callback(:perform, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the object's perform method.
+      #
+      #   class AnalyzeCsvTool < ApplicationMCPTool
+      #     description "Analyze a CSV file"
+      #
+      #     property :filepath, type: "string", description: "Path to CSV file"
+      #     collection :operations, type: "string", description: "Operations to perform"
+      #
+      #     validates :operations, inclusion: { in: %w[sum average count] }
+      #
+      #     around_perform do |mcp, block|
+      #       start_time = Time.current
+      #       Rails.logger.info("Starting CSV analysis for: #{mcp.filepath}")
+      #       block.call
+      #       duration = Time.current - start_time
+      #       Rails.logger.info("Completed CSV analysis in #{duration}s")
+      #     end
+      #
+      #     def perform
+      #       result = operations.to_h { |op| [ op, rand(1..100) ] }
+      #       render text: result.to_json
+      #     end
+      #   end
+      #
+      # You can access the return value of the perform only if the execution wasn't halted.
+      #
+      #   class GreetingPrompt < ApplicationMCPPrompt
+      #     around_perform do |mcp, block|
+      #       value = block.call
+      #       puts value # => Result of render operations
+      #     end
+      #
+      #     def perform
+      #       render text: "Hello #{name}!"
+      #     end
+      #   end
+      #
+      def around_perform(*filters, &blk)
+        set_callback(:perform, :around, *filters, &blk)
+      end
+    end
+  end
+end

data/lib/action_mcp/capability.rb

@@ -6,6 +6,9 @@ module ActionMCP
   class Capability
     include ActiveModel::Model
     include ActiveModel::Attributes
+    include Callbacks
+    include Instrumentation::Instrumentation
+    include Logging
     include Renderable
 
     class_attribute :_capability_name, instance_accessor: false
@@ -17,11 +20,11 @@ module ActionMCP
     end
 
     def self.abstract_capability
-      @abstract_tool ||= false # Default to false, unique to each class
+      @abstract_capability ||= false # Default to false, unique to each class
     end
 
     def self.abstract_capability=(value)
-      @abstract_tool = value
+      @abstract_capability = value
     end
 
     # Marks this tool as abstract so that it won’t be available for use.
@@ -39,7 +42,6 @@ module ActionMCP
       abstract_capability
     end
 
-
     def self.description(text = nil)
       if text
         self._description = text
@@ -47,5 +49,6 @@ module ActionMCP
         _description
       end
     end
+    ActiveSupport.run_load_hooks(:active_mcp, self)
   end
 end

data/lib/action_mcp/client.rb

@@ -5,8 +5,8 @@ module ActionMCP
   # @param endpoint [String] The endpoint to connect to (URL or command)
   # @param logger [Logger] The logger to use
   # @return [Client] An SSEClient or StdioClient depending on the endpoint
-  def self.create_client(endpoint, logger: Logger.new(STDOUT))
-    if endpoint =~ /\Ahttps?:\/\//
+  def self.create_client(endpoint, logger: Logger.new($stdout))
+    if endpoint =~ %r{\Ahttps?://}
       logger.info("Creating SSE client for endpoint: #{endpoint}")
       SSEClient.new(endpoint, logger: logger)
     else
@@ -19,7 +19,7 @@ module ActionMCP
   class Client
     attr_reader :logger, :capabilities, :type, :connection_error
 
-    def initialize(logger: Logger.new(STDOUT))
+    def initialize(logger: Logger.new($stdout))
       @logger = logger
       @connected = false
       @initialize_request_id = SecureRandom.uuid_v7
@@ -47,7 +47,7 @@ module ActionMCP
         @connected = true
         logger.info("Connected to MCP server")
         true
-      rescue => e
+      rescue StandardError => e
         @connection_error = e.message
         logger.error("Failed to connect to MCP server: #{e.message}")
         false
@@ -64,7 +64,7 @@ module ActionMCP
         @connected = false
         logger.info("Disconnected from MCP server")
         true
-      rescue => e
+      rescue StandardError => e
         logger.error("Error disconnecting from MCP server: #{e.message}")
         false
       end
@@ -83,7 +83,7 @@ module ActionMCP
         json = prepare_payload(payload)
         send_message(json)
         true
-      rescue => e
+      rescue StandardError => e
         logger.error("Failed to send request: #{e.message}")
         false
       end
@@ -111,9 +111,7 @@ module ActionMCP
 
     # Get the server capabilities
     # @return [Hash, nil] The server capabilities, or nil if not connected
-    def server_capabilities
-      @server_capabilities
-    end
+    attr_reader :server_capabilities
 
     protected
 
@@ -159,7 +157,7 @@ module ActionMCP
     # Initialize an SSE client
     # @param endpoint [String] The SSE endpoint URL
     # @param logger [Logger] The logger to use
-    def initialize(endpoint, logger: Logger.new(STDOUT))
+    def initialize(endpoint, logger: Logger.new($stdout))
       super(logger: logger)
       @endpoint = endpoint
       @transport = Transport::SSEClient.new(endpoint, logger: logger)
@@ -172,18 +170,16 @@ module ActionMCP
     protected
 
     def start_transport
-      begin
-        @transport.start(@initialize_request_id)
-        true
-      rescue Transport::SSEClient::ConnectionError => e
-        @connection_error = e.message
-        @error_callback&.call(e)
-        false
-      rescue => e
-        @connection_error = e.message
-        @error_callback&.call(e)
-        false
-      end
+      @transport.start(@initialize_request_id)
+      true
+    rescue Transport::SSEClient::ConnectionError => e
+      @connection_error = e.message
+      @error_callback&.call(e)
+      false
+    rescue StandardError => e
+      @connection_error = e.message
+      @error_callback&.call(e)
+      false
     end
 
     private
@@ -211,7 +207,7 @@ module ActionMCP
     # Initialize a STDIO client
     # @param command [String] The command to execute
     # @param logger [Logger] The logger to use
-    def initialize(command, logger: Logger.new(STDOUT))
+    def initialize(command, logger: Logger.new($stdout))
       super(logger: logger)
       @command = command
       @transport = Transport::StdioClient.new(command, logger: logger)
@@ -234,9 +230,7 @@ module ActionMCP
     def setup_callbacks
       @transport.on_message do |message|
         # Check if this is a response to our initialize request
-        if message && message.id && message.id == @initialize_request_id
-          @transport.handle_initialize_response(message)
-        end
+        @transport.handle_initialize_response(message) if message&.id && message.id == @initialize_request_id
 
         @message_callback&.call(message)
       end

data/lib/action_mcp/client_json_rpc_handler.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Handler for client-side requests (server -> client)
+  class ClientJsonRpcHandler < BaseJsonRpcHandler
+    def handle_initialize(id, params)
+      # Client-specific initialization
+      transport.send_client_capabilities(id, params)
+    end
+
+    def handle_specific_method(rpc_method, id, params)
+      case rpc_method
+      when "client/setLoggingLevel" # [CLIENT] Server configuring client logging
+        transport.set_client_logging_level(id, params["level"])
+      when %r{^roots/}                 # [CLIENT] Roots management
+        process_roots(rpc_method, id, params)
+      when %r{^sampling/}              # [CLIENT] Sampling requests
+        process_sampling(rpc_method, id, params)
+      else
+        Rails.logger.warn("Unknown client method: #{rpc_method}")
+      end
+    end
+
+    def handle_specific_notification(rpc_method, params)
+      case rpc_method
+      when "notifications/resources/updated" # [CLIENT] Resource update notification
+        puts "Resource #{params['uri']} was updated"
+        # Handle resource update notification
+      when "notifications/tools/list_changed" # [CLIENT] Tool list change notification
+        puts "Tool list has changed"
+        # Handle tool list change notification
+      when "notifications/prompts/list_changed" # [CLIENT] Prompt list change notification
+        puts "Prompt list has changed"
+        # Handle prompt list change notification
+      when "notifications/resources/list_changed" # [CLIENT] Resource list change notification
+        puts "Resource list has changed"
+        # Handle resource list change notification
+      else
+        Rails.logger.warn("Unknown client notification: #{rpc_method}")
+      end
+    end
+
+    private
+
+    # @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)
+      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
+        transport.send_sampling_create_message(id, params)
+      else
+        Rails.logger.warn("Unknown sampling method: #{rpc_method}")
+      end
+    end
+  end
+end

data/lib/action_mcp/configuration.rb

@@ -25,7 +25,6 @@ module ActionMCP
     #
     # @return [void]
 
-
     def initialize
       @logging_enabled = true
       @list_changed = false
@@ -54,20 +53,21 @@ module ActionMCP
       capabilities[:resources] = {} if ResourceTemplatesRegistry.non_abstract.any?
       capabilities
     end
+
     private
+
     def has_rails_version
-      begin
-        gem "rails_app_version"
-        require "rails_app_version/railtie"
-        true
-      rescue LoadError
-        false
-      end
+      gem "rails_app_version"
+      require "rails_app_version/railtie"
+      true
+    rescue LoadError
+      false
     end
   end
 
   class << self
     attr_accessor :server
+
     # Returns the configuration instance.
     #
     # @return [Configuration] the configuration instance

data/lib/action_mcp/content/resource.rb

@@ -17,7 +17,7 @@ module ActionMCP
       # @param mime_type [String] The MIME type of the resource.
       # @param text [String, nil] The text content of the resource (optional).
       # @param blob [String, nil] The base64-encoded blob of the resource (optional).
-      def initialize(uri, mime_type, text: nil, blob: nil)
+      def initialize(uri, mime_type = "text/plain", text: nil, blob: nil)
         super("resource")
         @uri = uri
         @mime_type = mime_type

data/lib/action_mcp/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   # Returns the currently loaded version of Active MCP as a +Gem::Version+.
   #

data/lib/action_mcp/instrumentation/controller_runtime.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attr_internal"
+
+module ActionMCP
+  module Instrumentation
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      protected
+
+      attr_internal :mcp_runtime
+
+      def cleanup_view_runtime
+        mcp_rt_before_render = LogSubscriber.reset_runtime
+        runtime = super
+        mcp_rt_after_render = LogSubscriber.reset_runtime
+        self.mcp_runtime = mcp_rt_before_render + mcp_rt_after_render
+        runtime - mcp_rt_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:mcp_runtime] = (mcp_runtime || 0) + LogSubscriber.reset_runtime
+      end
+
+      class_methods do
+        def log_process_action(payload)
+          messages = super
+          mcp_runtime = payload[:mcp_runtime]
+          messages << ("mcp: %.1fms" % mcp_runtime.to_f) if mcp_runtime
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/instrumentation/instrumentation.rb

@@ -0,0 +1,26 @@
+module ActionMCP
+  module Instrumentation
+    module Instrumentation # :nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform do |_, block|
+          instrument(:perform, &block)
+        end
+      end
+
+      private
+
+      def instrument(operation, payload = {}, &block)
+        payload[:mcp] = self
+
+        # Include type information (tool/prompt)
+        payload[:type] = self.class.type
+
+        ActiveSupport::Notifications.instrument("#{operation}.action_mcp", payload) do
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/instrumentation/resource_instrumentation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Instrumentation
+    module ResourceInstrumentation # :nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        around_resolve do |_, block|
+          instrument(:resolve, &block)
+        end
+      end
+
+      private
+      def instrument(operation, payload = {}, &block)
+        payload[:resource_template] = self
+        payload[:uri_template] = uri_template if respond_to?(:uri_template)
+        payload[:mime_type] = mime_type if respond_to?(:mime_type)
+
+        ActiveSupport::Notifications.instrument("#{operation}.action_mcp_resource", payload) do
+          value = block.call if block
+          if value
+            payload[:success] = true
+            payload[:resource] = value
+          else
+            payload[:success] = false
+          end
+          payload[:aborted] = @_halted_callback_hook_called if defined?(@_halted_callback_hook_called)
+          @_halted_callback_hook_called = nil
+          value
+        end
+      end
+
+      def halted_callback_hook(*)
+        super
+        @_halted_callback_hook_called = true
+      end
+    end
+  end
+end

data/lib/action_mcp/json_rpc/response.rb

@@ -55,8 +55,24 @@ module ActionMCP
       end
 
       def transform_value_to_hash!(result, error)
-        result = result.is_a?(String) ? (MultiJson.load(result) rescue result) : result
-        error = error.is_a?(String) ? (MultiJson.load(error) rescue error) : error
+        result = if result.is_a?(String)
+                   begin
+                     MultiJson.load(result)
+                   rescue StandardError
+                     result
+                   end
+        else
+                   result
+        end
+        error = if error.is_a?(String)
+                  begin
+                    MultiJson.load(error)
+                  rescue StandardError
+                    error
+                  end
+        else
+                  error
+        end
         [ result, error ]
       end
     end