actionmcp 0.19.1 → 0.22.0

data/lib/action_mcp/client/tools.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    module Tools
+      # List all available tools from the server
+      # @return [Array<Hash>] List of available tools with their metadata
+      def list_tools
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("tools/list", id: request_id)
+      end
+
+      # Call a specific tool on the server
+      # @param name [String] Name of the tool to call
+      # @param arguments [Hash] Arguments to pass to the tool
+      # @return [Hash] The result of the tool execution
+      def call_tool(name, arguments)
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("tools/call",
+                             params: {
+                               name: name,
+                               arguments: arguments
+                             },
+                             id: request_id
+        )
+      end
+    end
+  end
+end

data/lib/action_mcp/client.rb

@@ -1,243 +1,32 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  # Create a client appropriate for the given endpoint
-  # @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))
+  # Creates a client appropriate for the given endpoint.
+  #
+  # @param endpoint [String] The endpoint to connect to (URL or command).
+  # @param logger [Logger] The logger to use. Default is Logger.new($stdout).
+  # @param options [Hash] Additional options to pass to the client constructor.
+  #
+  # @return [Client::SSEClient, Client::StdioClient] An instance of either SSEClient or StdioClient
+  #   depending on the format of the endpoint.
+  #
+  # @example
+  #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
+  #   client.connect
+  #
+  # @example
+  #   client = ActionMCP.create_client("some_command")
+  #   client.execute
+  def self.create_client(endpoint, logger: Logger.new($stdout), **options)
     if endpoint =~ %r{\Ahttps?://}
       logger.info("Creating SSE client for endpoint: #{endpoint}")
-      SSEClient.new(endpoint, logger: logger)
+      Client::SSEClient.new(endpoint, logger: logger, **options)
     else
       logger.info("Creating STDIO client for command: #{endpoint}")
-      StdioClient.new(endpoint, logger: logger)
+      Client::StdioClient.new(endpoint, logger: logger, **options)
     end
   end
 
-  # Base client class for MCP protocol
-  class Client
-    attr_reader :logger, :capabilities, :type, :connection_error
-
-    def initialize(logger: Logger.new($stdout))
-      @logger = logger
-      @connected = false
-      @initialize_request_id = SecureRandom.uuid_v7
-      @server_capabilities = nil
-      @message_callback = nil
-      @error_callback = nil
-      @connection_error = nil
-    end
-
-    def connect
-      return true if @connected
-
-      begin
-        logger.info("Connecting to MCP server...")
-        @connection_error = nil
-
-        # Start transport with proper error handling
-        success = start_transport
-
-        unless success
-          logger.error("Failed to establish connection to MCP server")
-          return false
-        end
-
-        @connected = true
-        logger.info("Connected to MCP server")
-        true
-      rescue StandardError => e
-        @connection_error = e.message
-        logger.error("Failed to connect to MCP server: #{e.message}")
-        false
-      end
-    end
-
-    # Disconnect from the MCP server
-    # @return [Boolean] true if disconnection was successful
-    def disconnect
-      return true unless @connected
-
-      begin
-        stop_transport
-        @connected = false
-        logger.info("Disconnected from MCP server")
-        true
-      rescue StandardError => e
-        logger.error("Error disconnecting from MCP server: #{e.message}")
-        false
-      end
-    end
-
-    # Send a request to the MCP server
-    # @param payload [Hash, String] The request payload
-    # @return [Boolean] true if the request was sent successfully
-    def send_request(payload)
-      unless @connected
-        logger.error("Cannot send request - not connected")
-        return false
-      end
-
-      begin
-        json = prepare_payload(payload)
-        send_message(json)
-        true
-      rescue StandardError => e
-        logger.error("Failed to send request: #{e.message}")
-        false
-      end
-    end
-
-    # Check if the client is ready to send requests
-    # @return [Boolean] true if the client is connected and ready
-    def ready?
-      @connected && transport_ready?
-    end
-
-    # Set a callback for incoming messages
-    # @yield [message] Called when a message is received
-    # @yieldparam message The received message
-    def on_message(&block)
-      @message_callback = block
-    end
-
-    # Set a callback for errors
-    # @yield [error] Called when an error occurs
-    # @yieldparam error The error that occurred
-    def on_error(&block)
-      @error_callback = block
-    end
-
-    # Get the server capabilities
-    # @return [Hash, nil] The server capabilities, or nil if not connected
-    attr_reader :server_capabilities
-
-    protected
-
-    # Start the transport - implemented by subclasses
-    def start_transport
-      raise NotImplementedError, "Subclasses must implement start_transport"
-    end
-
-    # Stop the transport
-    def stop_transport
-      @transport.stop
-    end
-
-    # Send a message through the transport
-    def send_message(json)
-      @transport.send_message(json)
-    end
-
-    # Check if the transport is ready
-    def transport_ready?
-      @transport.ready?
-    end
-
-    private
-
-    # Prepare a payload for sending
-    # @param payload [Hash, String] The payload to prepare
-    # @return [String] The JSON-encoded payload
-    def prepare_payload(payload)
-      case payload
-      when String
-        # Assume it's already JSON
-        payload
-      else
-        # Try to convert to JSON
-        MultiJson.dump(payload)
-      end
-    end
-  end
-
-  # MCP client using Server-Sent Events (SSE) transport
-  class SSEClient < Client
-    # 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))
-      super(logger: logger)
-      @endpoint = endpoint
-      @transport = Transport::SSEClient.new(endpoint, logger: logger)
-      @type = :sse
-
-      # Set up callbacks after transport is initialized
-      setup_callbacks
-    end
-
-    protected
-
-    def start_transport
-      @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
-
-    def setup_callbacks
-      @transport.on_message do |message|
-        # Check if this is a response to our initialize request
-        puts @initialize_request_id
-        if message&.id == @initialize_request_id
-          @transport.handle_initialize_response(message)
-        else
-          puts "\e[32mCalling message callback\e[0m"
-          @message_callback&.call(message)
-        end
-      end
-
-      @transport.on_error do |error|
-        @error_callback&.call(error)
-      end
-    end
-  end
-
-  # MCP client using Standard I/O (STDIO) transport
-  class StdioClient < Client
-    # 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))
-      super(logger: logger)
-      @command = command
-      @transport = Transport::StdioClient.new(command, logger: logger)
-      @type = :stdio
-
-      # Set up callbacks after transport is initialized
-      setup_callbacks
-    end
-
-    protected
-
-    def start_transport
-      @transport.start
-      # For STDIO, we'll send the capabilities from the connect method
-      # after this method completes and @connected is set to true
-    end
-
-    private
-
-    def setup_callbacks
-      @transport.on_message do |message|
-        # Check if this is a response to our initialize request
-        @transport.handle_initialize_response(message) if message&.id && message.id == @initialize_request_id
-
-        @message_callback&.call(message)
-      end
-
-      @transport.on_error do |error|
-        @error_callback&.call(error)
-      end
-    end
+  module Client
   end
 end

data/lib/action_mcp/engine.rb

@@ -36,9 +36,7 @@ module ActionMCP
 
     # Initialize the ActionMCP logger.
     initializer "action_mcp.logger" do
-      ActiveSupport.on_load(:action_mcp) do
-        self.logger = ::Rails.logger
-      end
+      ActionMCP.logger = ::Rails.logger
     end
   end
 end

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 << ("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/instrumentation/instrumentation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Instrumentation
     module Instrumentation # :nodoc:

data/lib/action_mcp/instrumentation/resource_instrumentation.rb

@@ -12,6 +12,7 @@ module ActionMCP
       end
 
       private
+
       def instrument(operation, payload = {}, &block)
         payload[:resource_template] = self
         payload[:uri_template] = uri_template if respond_to?(:uri_template)

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class JsonRpcHandlerBase
+    delegate :initialize!, :initialized?, to: :transport
+    delegate :write, :read, to: :transport
+    attr_reader :transport
+
+    # @param transport [ActionMCP::TransportHandler]
+    def initialize(transport)
+      @transport = transport
+    end
+
+    # Process a single line of input.
+    # @param line [String, Hash]
+    def call(line)
+      request = if line.is_a?(String)
+                  line.strip!
+                  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
+      process_request(request)
+    end
+
+    protected
+
+    # Validate if the request follows JSON-RPC 2.0 specification
+    # @param request [Hash]
+    # @return [Boolean]
+    def valid_request?(request)
+      if request["jsonrpc"] != "2.0"
+        puts "Invalid request: #{request}"
+        return false
+      end
+      true
+    end
+
+    # Handle common methods for both client and server
+    # @param rpc_method [String]
+    # @param id [String, Integer]
+    # @param params [Hash]
+    # @return [Boolean] true if handled, false otherwise
+    def handle_common_methods(rpc_method, id, params)
+      case rpc_method
+      when "ping"
+        transport.send_pong(id)
+        true
+      when %r{^notifications/}
+        puts "\e[31mProcessing notifications\e[0m"
+        process_notifications(rpc_method, params)
+        true
+      else
+        false
+      end
+    end
+
+    # Method to be overridden by subclasses to handle specific RPC methods
+    # @param rpc_method [String]
+    # @param id [String, Integer]
+    # @param params [Hash]
+    def handle_method(rpc_method, id, params)
+      raise NotImplementedError, "Subclasses must implement handle_method"
+    end
+
+    private
+
+    # @param request [Hash]
+    def process_request(request)
+      return unless valid_request?(request)
+      read(request)
+
+      id = request["id"]
+
+      unless (rpc_method = request["method"])
+        # this is a response or a bobo
+        return process_response(id, request["result"]) if request["result"]
+        return process_error(id, request["error"]) if request["error"]
+      end
+
+      params = request["params"]
+      # Try to handle common methods first
+      return if handle_common_methods(rpc_method, id, params)
+
+      # Delegate to subclass-specific handling
+      handle_method(rpc_method, id, params)
+    end
+
+    def process_notifications(rpc_method, params)
+      case rpc_method
+      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
+      else
+        Rails.logger.warn("Unknown notifications method: #{rpc_method}")
+      end
+    end
+  end
+end

data/lib/action_mcp/log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   class LogSubscriber < ActiveSupport::LogSubscriber
     def self.reset_runtime

data/lib/action_mcp/logging.rb

@@ -11,7 +11,7 @@ module ActionMCP
 
     # Included hook to configure the logger.
     included do
-      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
     end
   end
 end

data/lib/action_mcp/prompt.rb

@@ -46,8 +46,9 @@ module ActionMCP
     # @param required [Boolean] Whether the argument is required.
     # @param default [Object] The default value of the argument.
     # @param enum [Array<String>] The list of allowed values for the argument.
+    # @param type [Symbol] The type of the argument (e.g., :string, :integer, :boolean). Defaults to :string.
     # @return [void]
-    def self.argument(arg_name, description: "", required: false, default: nil, enum: nil)
+    def self.argument(arg_name, description: "", required: false, default: nil, enum: nil, type: :string)
       arg_def = {
         name: arg_name.to_s,
         description: description,
@@ -58,7 +59,7 @@ module ActionMCP
       self._argument_definitions += [ arg_def ]
 
       # Register the attribute so it's recognized by ActiveModel
-      attribute arg_name, :string, default: default
+      attribute arg_name, type, default: default
       validates arg_name, presence: true if required
 
       return unless enum.present?
@@ -81,7 +82,7 @@ module ActionMCP
       {
         name: prompt_name,
         description: description.presence,
-        arguments: arguments.map { |arg| arg.slice(:name, :description, :required) }
+        arguments: arguments.map { |arg| arg.slice(:name, :description, :required, :type) }
       }.compact
     end
 

data/lib/action_mcp/prompt_response.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  class PromptResponse
-    include Enumerable
-    attr_reader :messages, :is_error
+  class PromptResponse < BaseResponse
+    attr_reader :messages
 
     # Delegate methods to the underlying messages array
     delegate :empty?, :size, :each, :find, :map, to: :messages
 
     def initialize
+      super
       @messages = []
-      @is_error = false
     end
 
     # Add a message to the response
@@ -25,64 +24,21 @@ module ActionMCP
       self
     end
 
-    def mark_as_error!(symbol = :invalid_request, message: nil, data: nil)
-      @is_error = true
-      @symbol = symbol
-      @error_message = message
-      @error_data = data
-      self
-    end
-
-    # Convert to hash format expected by MCP protocol
-    def to_h
-      if @is_error
-        JsonRpc::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
-      else
-        {
-          messages: @messages
-        }
-      end
-    end
-
-    # Alias as_json to to_h for consistency
-    alias as_json to_h
-
-    # Handle to_json directly
-    def to_json(options = nil)
-      to_h.to_json(options)
-    end
-
-    # Compare with hash for easier testing
-    def ==(other)
-      case other
-      when Hash
-        # Convert both to normalized format for comparison
-        hash_self = to_h.deep_transform_keys { |key| key.to_s.underscore }
-        hash_other = other.deep_transform_keys { |key| key.to_s.underscore }
-        hash_self == hash_other
-      when PromptResponse
-        messages == other.messages
-      else
-        super
-      end
-    end
-
-    # Implement eql? for hash key comparison
-    def eql?(other)
-      self == other
-    end
-
-    # Implement hash method for hash key usage
-    def hash
-      [ messages ].hash
+    # Implementation of build_success_hash for PromptResponse
+    def build_success_hash
+      {
+        messages: @messages
+      }
     end
 
-    def success?
-      !is_error
+    # Implementation of compare_with_same_class for PromptResponse
+    def compare_with_same_class(other)
+      messages == other.messages
     end
 
-    def error?
-      is_error
+    # Implementation of hash_components for PromptResponse
+    def hash_components
+      [ messages ]
     end
 
     # Pretty print for better debugging

data/lib/action_mcp/{transport → server}/capabilities.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Capabilities
       def send_capabilities(request_id, params = {})
-        # TODO fix this if client send incorrect params
+        # TODO: fix this if client send incorrect params
         # TODO refuse connection if protocol version is not supported
         @protocol_version = params["protocolVersion"]
         @client_info = params["clientInfo"]