actionmcp 0.20.0 → 0.24.0

data/lib/action_mcp/{transport → client}/sse_client.rb

@@ -4,34 +4,37 @@ require "faraday"
 require "uri"
 
 module ActionMCP
-  module Transport
-    class SSEClient < TransportBase
-      TIMEOUT = 10 # Increased from 1 second
-      ENDPOINT_TIMEOUT = 5 # Seconds
-
+  module Client
+    # MCP client using Server-Sent Events (SSE) transport
+    class SSEClient < Base
       # Define a custom error class for connection issues
       class ConnectionError < StandardError; end
 
-      def initialize(url, **options)
-        super(**options)
+      SSE_TIMEOUT = 10
+      ENDPOINT_TIMEOUT = 5 # Seconds
+
+      attr_reader :base_url, :sse_path, :post_url, :session
+
+      def initialize(url, connect: true, logger: ActionMCP.logger, **_options)
+        super(logger: logger)
+        @type = :sse
         setup_connection(url)
-        @buffer = ""
+        @buffer = +""
         @stop_requested = false
         @endpoint_received = false
         @endpoint_mutex = Mutex.new
         @endpoint_condition = ConditionVariable.new
-
-        # Add connection state management
         @connection_mutex = Mutex.new
         @connection_condition = ConditionVariable.new
-        @connection_error = nil
-        @connected = false
+
+        self.connect if connect
       end
 
-      def start(initialize_request_id)
-        log_info("Connecting to #{@base_url}#{@sse_path}...")
+      protected
+
+      def start_transport
+        log_debug("Connecting to #{@base_url}#{@sse_path}...")
         @stop_requested = false
-        @initialize_request_id = initialize_request_id
 
         # Reset connection state before starting
         @connection_mutex.synchronize do
@@ -42,10 +45,49 @@ module ActionMCP
         # Start connection thread
         @sse_thread = Thread.new { listen_sse }
 
-        # Wait for endpoint instead of connection completion
+        # Wait for endpoint
         wait_for_endpoint
       end
 
+      def stop_transport
+        log_debug("Stopping SSE connection...")
+        @stop_requested = true
+        cleanup_sse_thread
+      end
+
+      def send_message(json_rpc)
+        response = @conn.post(post_url,
+                              json_rpc,
+                              { "Content-Type" => "application/json" })
+        response.success?
+      end
+
+      def ready?
+        endpoint_ready?
+      end
+
+      private
+
+      def setup_connection(url)
+        uri = URI.parse(url)
+        @base_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        @sse_path = uri.path
+
+        @conn = Faraday.new(url: @base_url) do |f|
+          f.headers["User-Agent"] = user_agent
+          f.options.timeout = nil # No read timeout
+          f.options.open_timeout = SSE_TIMEOUT # Connection timeout
+
+          # Use Net::HTTP adapter explicitly as it works well with streaming
+          f.adapter :net_http do |http|
+            http.read_timeout = nil # No read timeout at adapter level too
+            http.open_timeout = SSE_TIMEOUT # Connection timeout
+          end
+        end
+
+        @post_url = nil
+      end
+
       def wait_for_endpoint
         success = false
         error = nil
@@ -80,62 +122,12 @@ module ActionMCP
         success
       end
 
-      def send_message(json_rpc)
-        # Wait for endpoint if not yet received
-        unless endpoint_ready?
-          log_info("Waiting for endpoint before sending message...")
-          wait_for_endpoint
-        end
-
-        validate_post_endpoint
-        log_debug("\e[34m--> #{json_rpc}\e[0m")
-        send_http_request(json_rpc)
-      end
-
-      def stop
-        log_info("Stopping SSE connection...")
-        @stop_requested = true
-        cleanup_sse_thread
-      end
-
-      def ready?
-        endpoint_ready?
-      end
-
-      private
-
-      def setup_connection(url)
-        uri = URI.parse(url)
-        @base_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-        @sse_path = uri.path
-
-        @conn = Faraday.new(url: @base_url) do |f|
-          f.headers["User-Agent"] = user_agent
-
-          f.options.timeout = nil        # No read timeout
-          f.options.open_timeout = 10    # Connection timeout
-
-          # Use Net::HTTP adapter explicitly as it works well with streaming
-          f.adapter :net_http do |http|
-            # Configure the adapter directly
-            http.read_timeout = nil      # No read timeout at adapter level too
-            http.open_timeout = 10       # Connection timeout
-          end
-
-          # Add logger middleware
-          # f.response :logger, @logger, headers: true, bodies: true
-        end
-
-        @post_url = nil
-      end
-
       def endpoint_ready?
         @endpoint_mutex.synchronize { @endpoint_received }
       end
 
-      # The listen_sse method should NOT mark connection as successful at the end
       def listen_sse
-        log_info("Starting SSE listener...")
+        log_debug("Starting SSE listener...")
 
         begin
           @conn.get(@sse_path) do |req|
@@ -151,8 +143,6 @@ module ActionMCP
           # as the SSE connection stays open
         rescue Faraday::ConnectionFailed => e
           handle_connection_error(format_connection_error(e))
-        rescue StandardError => e
-          handle_connection_error("Unexpected error: #{e.message}")
         end
       end
 
@@ -164,26 +154,18 @@ module ActionMCP
         end
       end
 
-      def handle_connection_error(message)
-        log_error("SSE connection failed: #{message}")
-
-        # Set error and notify waiting threads
+      def connection_error=(message)
         @connection_mutex.synchronize do
           @connection_error = message
           @connection_condition.broadcast
         end
-
-        @on_error&.call(StandardError.new(message))
       end
 
-      # Send the initialized notification to the server
-      def send_initialized_notification
-        notification = JsonRpc::Notification.new(
-          method: "notifications/initialized"
-        )
-
-        logger.info("Sent initialized notification to server")
-        send_message(notification.to_json)
+      def handle_connection_error(message)
+        log_error("SSE connection failed: #{message}")
+        self.connection_error = message
+        @connected = false
+        @error_callback&.call(StandardError.new(message))
       end
 
       def handle_sse_data(chunk, _overall_bytes)
@@ -195,9 +177,9 @@ module ActionMCP
         @buffer << chunk
         # If the buffer does not contain a newline but appears to be a complete JSON object,
         # flush it as a complete event.
-        if @buffer.strip.start_with?("{") && @buffer.strip.end_with?("}")
+        if @buffer.strip.match?(/^\{.*\}$/)
           (@current_event ||= []) << @buffer.strip
-          @buffer = ""
+          @buffer = +""
           return handle_complete_event
         end
         process_buffer while @buffer.include?("\n")
@@ -227,7 +209,7 @@ module ActionMCP
       end
 
       def parse_event(lines)
-        event_data = { type: "message", data: "" }
+        event_data = { type: "message", data: +"" }
         has_data_prefix = false
 
         lines.each do |line|
@@ -248,15 +230,13 @@ module ActionMCP
         case event_data[:type]
         when "endpoint" then set_post_endpoint(event_data[:data])
         when "message" then handle_raw_message(event_data[:data])
-        when "ping" then log_debug("Received ping")
         else log_error("Unknown event type: #{event_data[:type]}")
         end
       end
 
-      # Modify set_post_endpoint to mark connection as ready
       def set_post_endpoint(endpoint_path)
         @post_url = build_post_url(endpoint_path)
-        log_info("Received POST endpoint: #{@post_url}")
+        log_debug("Received POST endpoint: #{post_url}")
 
         # Signal that we have received the endpoint
         @endpoint_mutex.synchronize do
@@ -274,31 +254,10 @@ module ActionMCP
         "#{@base_url}#{endpoint_path}"
       end
 
-      def validate_post_endpoint
-        raise "MCP endpoint not set (no 'endpoint' event received)" unless @post_url
-      end
-
-      def send_http_request(json_rpc)
-        response = @conn.post(@post_url,
-                              json_rpc,
-                              { "Content-Type" => "application/json" })
-        handle_http_response(response)
-      end
-
-      def handle_http_response(response)
-        return if response.success?
-
-        log_error("HTTP POST failed: #{response.status} - #{response.body}")
-      end
-
       def cleanup_sse_thread
         return unless @sse_thread
 
-        @sse_thread.join(TIMEOUT) || @sse_thread.kill
-      end
-
-      def user_agent
-        "ActionMCP-sse-client"
+        @sse_thread.join(SSE_TIMEOUT) || @sse_thread.kill
       end
     end
   end

data/lib/action_mcp/{transport → client}/stdio_client.rb

@@ -1,65 +1,55 @@
 # frozen_string_literal: true
 
 require "open3"
-module ActionMCP
-  module Transport
-    class StdioClient < TransportBase
-      attr_reader :received_server_message
 
-      def initialize(command, **options)
-        super(**options)
-        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(command)
+module ActionMCP
+  module Client
+    # MCP client using Standard I/O (STDIO) transport, Not tested for now
+    class StdioClient < Base
+      def initialize(command, logger: ActionMCP.logger, **_options)
+        super(logger: logger)
+        @type = :stdio
+        @command = command
         @threads_started = false
         @received_server_message = false
         @capabilities_sent = false
       end
 
-      def start
+      protected
+
+      def start_transport
+        setup_stdio_process
         start_output_threads
 
         # Just log that connection is established but don't send capabilities yet
         if @threads_started && @wait_thr.alive?
-          log_info("STDIO connection established")
+          log_debug("STDIO connection established")
+          true
         else
-          log_error("Failed to start STDIO threads or process is not alive")
+          log_debug("Failed to start STDIO threads or process is not alive")
+          false
         end
       end
 
+      def stop_transport
+        cleanup_resources
+      end
+
       def send_message(json)
         log_debug("\e[34m--> #{json}\e[0m")
         @stdin.puts("#{json}\n\n")
       end
 
-      def stop
-        cleanup_resources
-      end
-
       def ready?
-        true
-      end
-
-      # Check if we've received any message from the server
-      def received_server_message?
         @received_server_message
       end
 
-      # Mark the client as ready and send initial capabilities if not already sent
-      def mark_ready_and_send_capabilities
-        return if @received_server_message
-
-        @received_server_message = true
-        log_info("Received first server message")
-
-        # Send initial capabilities if not already sent
-        return if @capabilities_sent
+      private
 
-        log_info("Server is ready, sending initial capabilities...")
-        send_initial_capabilities
-        @capabilities_sent = true
+      def setup_stdio_process
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(@command)
       end
 
-      private
-
       def start_output_threads
         @stdout_thread = Thread.new do
           @stdout.each_line do |line|
@@ -75,7 +65,6 @@ module ActionMCP
         @stderr_thread = Thread.new do
           @stderr.each_line do |line|
             line = line.chomp
-            log_info(line)
 
             # Check stderr for server messages
             mark_ready_and_send_capabilities if line.include?("MCP Server") || line.include?("running on stdio")
@@ -85,6 +74,21 @@ module ActionMCP
         @threads_started = true
       end
 
+      # Mark the client as ready and send initial capabilities if not already sent
+      def mark_ready_and_send_capabilities
+        return if @received_server_message
+
+        @received_server_message = true
+        log_debug("Received first server message")
+
+        # Send initial capabilities if not already sent
+        return if @capabilities_sent
+
+        log_debug("Server is ready, sending initial capabilities...")
+        send_initial_capabilities
+        @capabilities_sent = true
+      end
+
       def cleanup_resources
         @stdin.close
         wait_for_server_exit
@@ -106,10 +110,6 @@ module ActionMCP
         @stdout_thread&.kill
         @stderr_thread&.kill
       end
-
-      def user_agent
-        "ActionMCP-stdio-client"
-      end
     end
   end
 end

data/lib/action_mcp/client/toolbox.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Toolbox
+    #
+    # A collection that manages and provides access to tools from the server.
+    # This class stores tool definitions along with their input schemas and
+    # provides methods for retrieving, filtering, and accessing tools.
+    #
+    # Example usage:
+    #   tools_data = client.list_tools # Returns array of tool definitions
+    #   toolbox = Toolbox.new(tools_data)
+    #
+    #   # Access a specific tool by name
+    #   weather_tool = toolbox.find("weather_forecast")
+    #
+    #   # Get all tools matching a criteria
+    #   calculation_tools = toolbox.filter { |t| t.name.include?("calculate") }
+    #
+    class Toolbox < Collection
+      # Initialize a new Toolbox with tool definitions
+      #
+      # @param tools [Array<Hash>] Array of tool definition hashes, each containing
+      #   name, description, and inputSchema keys
+      def initialize(tools, client)
+        super(tools, client)
+        self.tools = @collection_data
+        @load_method = :list_tools
+      end
+
+      # Find a tool by name
+      #
+      # @param name [String] Name of the tool to find
+      # @return [Tool, nil] The tool with the given name, or nil if not found
+      def find(name)
+        all.find { |tool| tool.name == name }
+      end
+
+      # Filter tools based on a given block
+      #
+      # @yield [tool] Block that determines whether to include a tool
+      # @yieldparam tool [Tool] A tool from the collection
+      # @yieldreturn [Boolean] true to include the tool, false to exclude it
+      # @return [Array<Tool>] Tools that match the filter criteria
+      def filter(&block)
+        all.select(&block)
+      end
+
+      # Get a list of all tool names
+      #
+      # @return [Array<String>] Names of all tools in the collection
+      def names
+        all.map(&:name)
+      end
+
+      # Number of tools in the collection
+      #
+      # @return [Integer] The number of tools
+      def size
+        all.size
+      end
+
+      # Check if the collection contains a tool with the given name
+      #
+      # @param name [String] The tool name to check for
+      # @return [Boolean] true if a tool with the name exists
+      def contains?(name)
+        all.any? { |tool| tool.name == name }
+      end
+
+      # Get tools by category or type
+      #
+      # @param keyword [String] Keyword to search for in tool names and descriptions
+      # @return [Array<Tool>] Tools containing the keyword
+      def search(keyword)
+        all.select do |tool|
+          tool.name.include?(keyword) ||
+            (tool.description && tool.description.downcase.include?(keyword.downcase))
+        end
+      end
+
+      # Generate a hash representation of all tools in the collection based on provider format
+      #
+      # @param provider [Symbol] The provider format to use (:claude, :openai, or :default)
+      # @return [Hash] Hash containing all tools formatted for the specified provider
+      def to_h(provider = :default)
+        case provider
+        when :claude
+          # Claude format
+          { "tools" => all.map(&:to_claude_h) }
+        when :openai
+          # OpenAI format
+          { "tools" => all.map(&:to_openai_h) }
+        else
+          # Default format (same as original)
+          { "tools" => all.map(&:to_h) }
+        end
+      end
+
+      def tools=(tools)
+        @collection_data = tools.map { |tool_data| Tool.new(tool_data) }
+      end
+
+      # Internal Tool class to represent individual tools
+      class Tool
+        attr_reader :name, :description, :input_schema
+
+        # Initialize a new Tool instance
+        #
+        # @param data [Hash] Tool definition hash containing name, description, and inputSchema
+        def initialize(data)
+          @name = data["name"]
+          @description = data["description"]
+          @input_schema = data["inputSchema"] || {}
+        end
+
+        # Get all required properties for this tool
+        #
+        # @return [Array<String>] Array of required property names
+        def required_properties
+          @input_schema["required"] || []
+        end
+
+        # Get all properties for this tool
+        #
+        # @return [Hash] Hash of property definitions
+        def properties
+          @input_schema.dig("properties") || {}
+        end
+
+        # Check if the tool requires a specific property
+        #
+        # @param name [String] Name of the property to check
+        # @return [Boolean] true if the property is required
+        def requires?(name)
+          required_properties.include?(name)
+        end
+
+        # Check if the tool has a specific property
+        #
+        # @param name [String] Name of the property to check
+        # @return [Boolean] true if the property exists
+        def has_property?(name)
+          properties.key?(name)
+        end
+
+        # Get property details by name
+        #
+        # @param name [String] Name of the property
+        # @return [Hash, nil] Property details or nil if not found
+        def property(name)
+          properties[name]
+        end
+
+        # Generate a hash representation of the tool (default format)
+        #
+        # @return [Hash] Hash containing tool details
+        def to_h
+          {
+            "name" => @name,
+            "description" => @description,
+            "inputSchema" => @input_schema
+          }
+        end
+
+        # Generate a hash representation of the tool in Claude format
+        #
+        # @return [Hash] Hash containing tool details formatted for Claude
+        def to_claude_h
+          {
+            "name" => @name,
+            "description" => @description,
+            "input_schema" => @input_schema.transform_keys { |k| k == "inputSchema" ? "input_schema" : k }
+          }
+        end
+
+        # Generate a hash representation of the tool in OpenAI format
+        #
+        # @return [Hash] Hash containing tool details formatted for OpenAI
+        def to_openai_h
+          {
+            "type" => "function",
+            "function" => {
+              "name" => @name,
+              "description" => @description,
+              "parameters" => @input_schema
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/client/tools.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    module Tools
+      # List all available tools from the server
+      # @return [String] Request ID for tracking the request
+      def list_tools
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("tools/list", id: request_id)
+
+        # Return request ID for timeout tracking
+        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 [String] Request ID for tracking the request
+      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
+        )
+
+        # Return request ID for tracking the request
+        request_id
+      end
+    end
+  end
+end