ruby-mcp-client 1.0.1 → 1.1.0

data/lib/mcp_client/server_sse.rb

@@ -405,28 +405,42 @@ module MCPClient
         @sse_connected = false
         @initialized = false # Reset initialization state for reconnection
 
+        # Reset the SSE parse buffer so a reconnect never inherits a leftover
+        # partial event from the previous connection.
+        @buffer = ''
+
         # Log cleanup for debugging
         @logger.debug('Cleaning up SSE connection')
 
         # Store threads locally to avoid race conditions
         sse_thread = @sse_thread
+
+        # The activity monitor drives reconnection, and reconnection calls this
+        # method FROM that thread. Killing the current thread here would abort
+        # the reconnect before connect() runs (the historical dead-code bug), so
+        # never kill/clear the activity thread when we are running on it. Leaving
+        # @activity_timer_thread referenced also makes start_activity_monitor
+        # short-circuit, preventing a duplicate monitor after reconnect.
         activity_thread = @activity_timer_thread
+        kill_activity_thread = activity_thread && activity_thread != Thread.current
 
         # Clear thread references first
         @sse_thread = nil
-        @activity_timer_thread = nil
+        @activity_timer_thread = nil if kill_activity_thread
 
-        # Kill threads outside the critical section
+        # Kill threads
         begin
           sse_thread&.kill
         rescue StandardError => e
           @logger.debug("Error killing SSE thread: #{e.message}")
         end
 
-        begin
-          activity_thread&.kill
-        rescue StandardError => e
-          @logger.debug("Error killing activity thread: #{e.message}")
+        if kill_activity_thread
+          begin
+            activity_thread.kill
+          rescue StandardError => e
+            @logger.debug("Error killing activity thread: #{e.message}")
+          end
         end
 
         if @http_client
@@ -476,6 +490,8 @@ module MCPClient
       @logger.debug("Received server request: #{method} (id: #{request_id})")
 
       case method
+      when 'ping'
+        handle_ping(request_id)
       when 'elicitation/create'
         handle_elicitation_create(request_id, params)
       when 'roots/list'
@@ -491,6 +507,21 @@ module MCPClient
       send_error_response(request_id, -32_603, "Internal error: #{e.message}")
     end
 
+    # Handle a server-initiated ping request (MCP ping utility)
+    # The receiver MUST respond promptly with an empty result.
+    # @param request_id [String, Integer] the JSON-RPC request ID
+    # @return [void]
+    def handle_ping(request_id)
+      response = {
+        'jsonrpc' => '2.0',
+        'id' => request_id,
+        'result' => {}
+      }
+      post_jsonrpc_response(response)
+    rescue StandardError => e
+      @logger.error("Error sending ping response: #{e.message}")
+    end
+
     # Handle elicitation/create request from server (MCP 2025-06-18)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param params [Hash] the elicitation parameters
@@ -889,24 +920,14 @@ module MCPClient
     # @private
     def request_prompts_list
       @mutex.synchronize do
-        return @prompts_data if @prompts_data
+        return @prompts_data.dup if @prompts_data
       end
 
-      result = rpc_request('prompts/list')
+      # Follow nextCursor across pages so the full prompt list is returned.
+      prompts = request_paginated_list('prompts/list', 'prompts')
 
-      if result && result['prompts']
-        @mutex.synchronize do
-          @prompts_data = result['prompts']
-        end
-        return @mutex.synchronize { @prompts_data.dup }
-      elsif result
-        @mutex.synchronize do
-          @prompts_data = result
-        end
-        return @mutex.synchronize { @prompts_data.dup }
-      end
-
-      raise MCPClient::Errors::PromptGetError, 'Failed to get prompts list from JSON-RPC request'
+      @mutex.synchronize { @prompts_data = prompts }
+      @mutex.synchronize { @prompts_data.dup }
     end
 
     # Request the resources list using JSON-RPC
@@ -941,24 +962,16 @@ module MCPClient
     # @private
     def request_tools_list
       @mutex.synchronize do
-        return @tools_data if @tools_data
+        return @tools_data.dup if @tools_data
       end
 
-      result = rpc_request('tools/list')
-
-      if result && result['tools']
-        @mutex.synchronize do
-          @tools_data = result['tools']
-        end
-        return @mutex.synchronize { @tools_data.dup }
-      elsif result
-        @mutex.synchronize do
-          @tools_data = result
-        end
-        return @mutex.synchronize { @tools_data.dup }
-      end
+      # Follow nextCursor across pages so the full tool list is returned. The
+      # SSE parser no longer writes @tools_data per page, so this method is the
+      # sole writer and only ever caches the COMPLETE list.
+      tools = request_paginated_list('tools/list', 'tools')
 
-      raise MCPClient::Errors::ToolCallError, 'Failed to get tools list from JSON-RPC request'
+      @mutex.synchronize { @tools_data = tools }
+      @mutex.synchronize { @tools_data.dup }
     end
   end
 end

data/lib/mcp_client/server_stdio/json_rpc_transport.rb

@@ -16,6 +16,7 @@ module MCPClient
 
         connect
         start_reader
+        start_stderr_reader
         perform_initialize
 
         @initialized = true
@@ -44,12 +45,15 @@ module MCPClient
         @stdin.puts(notif.to_json)
       end
 
-      # Generate a new unique request ID
+      # Generate a new unique request ID and mark it as awaiting a response.
+      # Registering the id before the request is sent lets the reader thread
+      # distinguish expected responses from late/unsolicited ones.
       # @return [Integer] a unique request ID
       def next_id
         @mutex.synchronize do
           id = @next_id
           @next_id += 1
+          @awaiting[id] = true
           id
         end
       end
@@ -62,6 +66,10 @@ module MCPClient
         @logger.debug("Sending JSONRPC request: #{req.to_json}")
         @stdin.puts(req.to_json)
       rescue StandardError => e
+        # A request that failed to send will never receive a response, so drop
+        # its awaiting marker; otherwise a broken transport (e.g. the server
+        # exited) would leak an entry per retry/attempt into @awaiting.
+        @mutex.synchronize { @awaiting.delete(req['id']) } if req.is_a?(Hash) && req['id']
         raise MCPClient::Errors::TransportError, "Failed to send JSONRPC request: #{e.message}"
       end
 
@@ -78,8 +86,10 @@ module MCPClient
 
             @cond.wait(@mutex, remaining)
           end
-          msg = @pending[id]
-          @pending[id] = nil
+          # Remove the response and the awaiting marker on both success and
+          # timeout so neither @pending nor @awaiting accumulates entries.
+          msg = @pending.delete(id)
+          @awaiting.delete(id)
           raise MCPClient::Errors::TransportError, "Timeout waiting for JSONRPC response id=#{id}" unless msg
 
           msg

data/lib/mcp_client/server_stdio.rb

@@ -21,6 +21,14 @@ module MCPClient
     # Timeout in seconds for responses
     READ_TIMEOUT = 15
 
+    # Chunk size (bytes) used when draining the subprocess stderr pipe
+    STDERR_READ_CHUNK_SIZE = 8192
+
+    # Maximum bytes buffered for a single unterminated stderr line before it is
+    # flushed. Bounds memory when a server writes to stderr without newlines
+    # (e.g. progress output using carriage returns).
+    STDERR_MAX_LINE_SIZE = 64 * 1024
+
     # Initialize a new ServerStdio instance
     # @param command [String, Array] the stdio command to launch the MCP JSON-RPC server
     #   For improved security, passing an Array is recommended to avoid shell injection issues
@@ -38,6 +46,9 @@ module MCPClient
       @cond = ConditionVariable.new
       @next_id = 1
       @pending = {}
+      # Ids of requests awaiting a response; used to drop late/unsolicited
+      # responses so @pending cannot grow without bound on a long-lived session
+      @awaiting = {}
       @initialized = false
       @server_info = nil
       @capabilities = nil
@@ -49,6 +60,8 @@ module MCPClient
       @elicitation_request_callback = nil # MCP 2025-06-18
       @roots_list_request_callback = nil # MCP 2025-06-18
       @sampling_request_callback = nil # MCP 2025-11-25
+      @reader_thread = nil
+      @stderr_thread = nil
     end
 
     # Server info from the initialize response
@@ -91,6 +104,36 @@ module MCPClient
       end
     end
 
+    # Spawn a thread to continuously drain the subprocess stderr.
+    #
+    # The child's stderr pipe has a fixed OS buffer (typically 64KB). If it is
+    # never read, a server that logs verbosely to stderr eventually blocks on
+    # write once the buffer fills, which stalls the whole subprocess (it stops
+    # producing stdout / reading stdin) and deadlocks the client. Draining
+    # stderr keeps the pipe empty; lines are surfaced at debug level.
+    #
+    # Reads happen in bounded chunks (not IO#each_line) so that a server which
+    # writes to stderr without newline delimiters cannot make the client buffer
+    # a single "line" without limit: any pending fragment larger than
+    # STDERR_MAX_LINE_SIZE is flushed rather than retained.
+    # @return [Thread] the stderr reader thread
+    def start_stderr_reader
+      @stderr_thread = Thread.new do
+        buffer = +''
+        loop do
+          buffer << @stderr.readpartial(STDERR_READ_CHUNK_SIZE)
+          flush_stderr_lines(buffer)
+          flush_stderr_overflow(buffer)
+        end
+      rescue IOError
+        # EOFError (a subclass of IOError) on EOF, or IOError on close;
+        # emit any trailing partial line before exiting
+        @logger.debug("[stderr] #{buffer.chomp}") if buffer && !buffer.empty?
+      rescue StandardError
+        # reader aborted unexpectedly; nothing actionable
+      end
+    end
+
     # Handle a line of output from the stdio server
     # Parses JSON-RPC messages and adds them to pending responses
     # @param line [String] line of output to parse
@@ -116,8 +159,15 @@ module MCPClient
       return unless id
 
       @mutex.synchronize do
-        @pending[id] = msg
-        @cond.broadcast
+        # Only retain a response that corresponds to an outstanding request.
+        # Late responses (arriving after the caller timed out) and unsolicited
+        # responses are dropped so @pending cannot grow without bound.
+        if @awaiting.key?(id)
+          @pending[id] = msg
+          @cond.broadcast
+        else
+          @logger.debug("Discarding response for unknown or expired request id=#{id}")
+        end
       end
     rescue JSON::ParserError
       # Skip non-JSONRPC lines in the output stream
@@ -129,15 +179,21 @@ module MCPClient
     # @raise [MCPClient::Errors::PromptGetError] for other errors during prompt listing
     def list_prompts
       ensure_initialized
-      req_id = next_id
-      req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'prompts/list', 'params' => {} }
-      send_request(req)
-      res = wait_response(req_id)
-      if (err = res['error'])
-        raise MCPClient::Errors::ServerError, err['message']
-      end
+      collect_paginated('prompts') do |cursor|
+        params = {}
+        params['cursor'] = cursor if cursor
+        req_id = next_id
+        req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'prompts/list', 'params' => params }
+        send_request(req)
+        res = wait_response(req_id)
+        if (err = res['error'])
+          raise MCPClient::Errors::ServerError, err['message']
+        end
 
-      (res.dig('result', 'prompts') || []).map { |td| MCPClient::Prompt.from_json(td, server: self) }
+        result = res['result'] || {}
+        prompts = (result['prompts'] || []).map { |td| MCPClient::Prompt.from_json(td, server: self) }
+        [prompts, result['nextCursor']]
+      end
     rescue StandardError => e
       raise MCPClient::Errors::PromptGetError, "Error listing prompts: #{e.message}"
     end
@@ -301,16 +357,22 @@ module MCPClient
     # @raise [MCPClient::Errors::ToolCallError] for other errors during tool listing
     def list_tools
       ensure_initialized
-      req_id = next_id
-      # JSON-RPC method for listing tools
-      req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'tools/list', 'params' => {} }
-      send_request(req)
-      res = wait_response(req_id)
-      if (err = res['error'])
-        raise MCPClient::Errors::ServerError, err['message']
-      end
+      collect_paginated('tools') do |cursor|
+        params = {}
+        params['cursor'] = cursor if cursor
+        req_id = next_id
+        # JSON-RPC method for listing tools
+        req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'tools/list', 'params' => params }
+        send_request(req)
+        res = wait_response(req_id)
+        if (err = res['error'])
+          raise MCPClient::Errors::ServerError, err['message']
+        end
 
-      (res.dig('result', 'tools') || []).map { |td| MCPClient::Tool.from_json(td, server: self) }
+        result = res['result'] || {}
+        tools = (result['tools'] || []).map { |td| MCPClient::Tool.from_json(td, server: self) }
+        [tools, result['nextCursor']]
+      end
     rescue StandardError => e
       raise MCPClient::Errors::ToolCallError, "Error listing tools: #{e.message}"
     end
@@ -427,6 +489,8 @@ module MCPClient
       @logger.debug("Received server request: #{method} (id: #{request_id})")
 
       case method
+      when 'ping'
+        handle_ping(request_id)
       when 'elicitation/create'
         handle_elicitation_create(request_id, params)
       when 'roots/list'
@@ -442,6 +506,19 @@ module MCPClient
       send_error_response(request_id, -32_603, "Internal error: #{e.message}")
     end
 
+    # Handle a server-initiated ping request (MCP ping utility)
+    # The receiver MUST respond promptly with an empty result.
+    # @param request_id [String, Integer] the JSON-RPC request ID
+    # @return [void]
+    def handle_ping(request_id)
+      response = {
+        'jsonrpc' => '2.0',
+        'id' => request_id,
+        'result' => {}
+      }
+      send_message(response)
+    end
+
     # Handle elicitation/create request from server (MCP 2025-06-18)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param params [Hash] the elicitation parameters
@@ -573,6 +650,27 @@ module MCPClient
       @logger.error("Error sending message: #{e.message}")
     end
 
+    # Emit and remove all newline-terminated lines from the stderr buffer.
+    # @param buffer [String] mutable buffer of accumulated stderr bytes
+    # @return [void]
+    def flush_stderr_lines(buffer)
+      while (newline_index = buffer.index("\n"))
+        line = buffer.slice!(0, newline_index + 1)
+        @logger.debug("[stderr] #{line.chomp}")
+      end
+    end
+
+    # Flush an unterminated stderr fragment that has grown past the size cap,
+    # so a newline-less stderr stream cannot buffer without bound.
+    # @param buffer [String] mutable buffer of accumulated stderr bytes
+    # @return [void]
+    def flush_stderr_overflow(buffer)
+      return if buffer.bytesize <= STDERR_MAX_LINE_SIZE
+
+      @logger.debug("[stderr] #{buffer}")
+      buffer.clear
+    end
+
     # Clean up the server connection
     # Closes all stdio handles and terminates any running processes and threads
     # @return [void]
@@ -587,10 +685,16 @@ module MCPClient
         @wait_thread.join(1)
       end
       @reader_thread&.kill
+      @stderr_thread&.kill
     rescue StandardError
       # Clean up resources during unexpected termination
     ensure
-      @stdin = @stdout = @stderr = @wait_thread = @reader_thread = nil
+      # Release any buffered responses / awaiting markers
+      @mutex.synchronize do
+        @pending.clear
+        @awaiting.clear
+      end
+      @stdin = @stdout = @stderr = @wait_thread = @reader_thread = @stderr_thread = nil
     end
   end
 end

data/lib/mcp_client/server_streamable_http.rb

@@ -575,24 +575,15 @@ module MCPClient
     # @raise [MCPClient::Errors::ToolCallError] if tools list retrieval fails
     def request_tools_list
       @mutex.synchronize do
-        return @tools_data if @tools_data
+        return @tools_data.dup if @tools_data
       end
 
-      result = rpc_request('tools/list')
+      # Follow nextCursor across pages so the full tool list is returned even
+      # when the server paginates.
+      tools = request_paginated_list('tools/list', 'tools')
 
-      if result.is_a?(Hash) && result['tools']
-        @mutex.synchronize do
-          @tools_data = result['tools']
-        end
-        return @mutex.synchronize { @tools_data.dup }
-      elsif result.is_a?(Array) || result
-        @mutex.synchronize do
-          @tools_data = result
-        end
-        return @mutex.synchronize { @tools_data.dup }
-      end
-
-      raise MCPClient::Errors::ToolCallError, 'Failed to get tools list from JSON-RPC request'
+      @mutex.synchronize { @tools_data = tools }
+      @mutex.synchronize { @tools_data.dup }
     end
 
     # Request the prompts list using JSON-RPC
@@ -600,24 +591,14 @@ module MCPClient
     # @raise [MCPClient::Errors::PromptGetError] if prompts list retrieval fails
     def request_prompts_list
       @mutex.synchronize do
-        return @prompts_data if @prompts_data
+        return @prompts_data.dup if @prompts_data
       end
 
-      result = rpc_request('prompts/list')
-
-      if result.is_a?(Hash) && result['prompts']
-        @mutex.synchronize do
-          @prompts_data = result['prompts']
-        end
-        return @mutex.synchronize { @prompts_data.dup }
-      elsif result.is_a?(Array) || result
-        @mutex.synchronize do
-          @prompts_data = result
-        end
-        return @mutex.synchronize { @prompts_data.dup }
-      end
+      # Follow nextCursor across pages so the full prompt list is returned.
+      prompts = request_paginated_list('prompts/list', 'prompts')
 
-      raise MCPClient::Errors::PromptGetError, 'Failed to get prompts list from JSON-RPC request'
+      @mutex.synchronize { @prompts_data = prompts }
+      @mutex.synchronize { @prompts_data.dup }
     end
 
     # Request the resources list using JSON-RPC