actionmcp 0.20.0 → 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/{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"]

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    class JsonRpcHandler < JsonRpcHandlerBase
+      protected
+
+      # Handle server-specific methods
+      # @param rpc_method [String]
+      # @param id [String, Integer]
+      # @param params [Hash]
+      def handle_method(rpc_method, id, params)
+        case rpc_method
+        when "initialize" # [SERVER] Client initializing the connection
+          transport.send_capabilities(id, params)
+        when %r{^prompts/} # Prompt-related requests
+          process_prompts(rpc_method, id, params)
+        when %r{^resources/} # Resource-related requests
+          process_resources(rpc_method, id, params)
+        when %r{^tools/} # Tool-related requests
+          process_tools(rpc_method, id, params)
+        when "completion/complete" # Completion requests
+          process_completion_complete(id, params)
+        else
+          puts "\e[31mUnknown client method: #{rpc_method}\e[0m"
+        end
+      end
+
+      # 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
+        end
+      end
+
+      # @param rpc_method [String]
+      # @param id [String]
+      # @param params [Hash]
+      def process_prompts(rpc_method, id, 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)
+        else
+          Rails.logger.warn("Unknown prompts 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" # List available tools
+          transport.send_tools_list(id)
+        when "tools/call" # Call a tool
+          transport.send_tools_call(id, params["name"], params["arguments"])
+        else
+          Rails.logger.warn("Unknown tools method: #{rpc_method}")
+        end
+      end
+
+      # @param rpc_method [String]
+      # @param id [String]
+      # @param params [Hash]
+      def process_resources(rpc_method, id, 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"])
+        else
+          Rails.logger.warn("Unknown resources method: #{rpc_method}")
+        end
+      end
+
+      def process_notifications(rpc_method, params)
+        case rpc_method
+        when "notifications/initialized" # Client initialization complete
+          puts "\e[31mInitialized\e[0m"
+          transport.initialize!
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/messaging.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Messaging
+      def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
+        request = JsonRpc::Request.new(id: id, method: method, params: params)
+        write_message(request)
+      end
+
+      def send_jsonrpc_response(request_id, result: nil, error: nil)
+        response = JsonRpc::Response.new(id: request_id, result: result, error: error)
+        write_message(response)
+      end
+
+      def send_jsonrpc_notification(method, params = nil)
+        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 → server}/notifications.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Notifications
       # Notify client that the resources list has changed
       def send_resources_list_changed_notification

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Prompts
       def send_prompts_list(request_id)
         prompts = format_registry_items(PromptsRegistry.non_abstract)

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Resources
       # Send list of available resources to the client
       #
@@ -61,23 +61,6 @@ module ActionMCP
         end
       end
 
-      def send_resource_subscribe(id, uri)
-        session.resource_subscribe(uri)
-        send_jsonrpc_response(id, result: {})
-      end
-
-      def send_resource_unsubscribe(id, uri)
-        session.resource_unsubscribe(uri)
-        send_jsonrpc_response(id, result: {})
-      end
-
-      # Client logging
-      def set_client_logging_level(id, level)
-        # Store the client's preferred log level
-        @client_log_level = level
-        send_jsonrpc_response(id, result: {})
-      end
-
       private
 
       # Log all registered resource templates

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Roots
       def send_roots_list(id)
         send_jsonrpc_response(id, result: { roots: [] })

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Server
     module Sampling
       # @param [String] id
       # @param [SamplingRequest] request