ruby-mcp-client 2.0.0 → 2.1.0

data/lib/mcp_client/server_sse.rb

@@ -40,6 +40,13 @@ module MCPClient
     MAX_RECONNECT_DELAY = 30
     JITTER_FACTOR = 0.25
 
+    # Maximum bytes the SSE parse buffer may hold while waiting for an event
+    # terminator. The stream is peer-controlled: without a cap, a hostile
+    # server could withhold the blank-line delimiter forever and grow the
+    # buffer until the host runs out of memory. Generous enough for any
+    # legitimate JSON-RPC response event.
+    MAX_SSE_BUFFER_BYTES = 32 * 1024 * 1024
+
     # @!attribute [r] base_url
     #   @return [String] The base URL of the MCP server
     # @!attribute [r] tools
@@ -91,8 +98,14 @@ module MCPClient
       @tools_data = nil
       @request_id = 0
       @sse_results = {}
+      # Ids of requests a caller is actively waiting on. Only responses for
+      # these ids are stored in @sse_results — everything else on the peer
+      # controlled stream is unsolicited and discarded.
+      @pending_request_ids = Set.new
       @mutex = Monitor.new
-      @buffer = ''
+      @buffer = +''
+      # How much of @buffer has already been searched for an event terminator
+      @buffer_scanned = 0
       @sse_connected = false
       @connection_established = false
       @connection_cv = @mutex.new_cond
@@ -423,7 +436,18 @@ module MCPClient
 
         # Reset the SSE parse buffer so a reconnect never inherits a leftover
         # partial event from the previous connection.
-        @buffer = ''
+        @buffer = +''
+        @buffer_scanned = 0
+
+        # Drop results nobody is waiting for, so peer-supplied state cannot
+        # accumulate across reconnects. Results for still-pending requests are
+        # KEPT: a response can arrive while its POST is still returning, and
+        # the waiter (which reconnects through ensure_sse_connection_active)
+        # is about to consume it. Discarding those reported a timeout for a
+        # tool call the server had already executed — inviting a duplicate
+        # manual retry. unregister_pending_request clears each entry when its
+        # request finishes, so nothing lingers.
+        @sse_results.select! { |id, _| @pending_request_ids.include?(id) }
 
         # Log cleanup for debugging
         @logger.debug('Cleaning up SSE connection')
@@ -519,8 +543,11 @@ module MCPClient
         send_error_response(request_id, -32_601, "Method not found: #{method}")
       end
     rescue StandardError => e
+      # The exception message is host-internal (file paths, connection
+      # strings, library internals): log it locally, but answer the peer with
+      # a constant message so failures cannot be used to probe the host.
       @logger.error("Error handling server request: #{e.message}")
-      send_error_response(request_id, -32_603, "Internal error: #{e.message}")
+      send_error_response(request_id, -32_603, 'Internal error')
     end
 
     # Handle a server-initiated ping request (MCP ping utility)
@@ -717,7 +744,7 @@ module MCPClient
         req.body = json_body
       end
 
-      @logger.debug("Sent response via HTTP POST: #{json_body}")
+      @logger.debug("Sent response via HTTP POST: #{describe_jsonrpc_message(response)}")
     rescue StandardError => e
       @logger.error("Failed to send response via HTTP POST: #{e.message}")
     end
@@ -839,7 +866,9 @@ module MCPClient
     # Process an SSE chunk from the server
     # @param chunk [String] the chunk to process
     def process_sse_chunk(chunk)
-      @logger.debug("Processing SSE chunk: #{chunk.inspect}")
+      # Size only: the chunk is raw wire data carrying sampling prompts,
+      # elicitation content and tool results.
+      @logger.debug("Processing SSE chunk (#{describe_body_size(chunk)})")
 
       # Only record activity for real events
       record_activity if chunk.include?('event:')
@@ -897,21 +926,61 @@ module MCPClient
     # @return [Array<String>, nil] array of complete events or nil if none
     # @private
     def extract_complete_events(chunk)
-      event_buffers = nil
+      event_buffers = []
       @mutex.synchronize do
-        @buffer += chunk
-
-        # Extract all complete events from the buffer
-        # Handle both Unix (\n\n) and Windows (\r\n\r\n) line endings
-        event_buffers = []
-        while (event_end = @buffer.index("\n\n") || @buffer.index("\r\n\r\n"))
-          event_data = extract_single_event(event_end)
-          event_buffers << event_data
+        # Append in place. `@buffer += chunk` allocates and copies the whole
+        # buffer on every callback, so an unterminated event delivered in N
+        # chunks costs O(N^2) copying — memory stays capped but a peer can
+        # still burn CPU and thrash the allocator on the way there.
+        @buffer << chunk
+
+        # Rescan only the newly arrived bytes, backing up by the longest
+        # delimiter minus one so one split across two chunks is still found.
+        scan_from = [@buffer_scanned - 3, 0].max
+        while (event_end = next_event_end(scan_from))
+          event_buffers << extract_single_event(event_end)
+          # The buffer shifted; what remains is short (one event at most).
+          scan_from = 0
+          @buffer_scanned = 0
         end
+        @buffer_scanned = @buffer.length
+
+        # Whatever is left is a partial event still awaiting its terminator.
+        # The cap is applied here rather than before appending so a single
+        # oversized chunk that DOES contain complete events is still parsed.
+        fail_oversized_sse_buffer! if @buffer.bytesize > MAX_SSE_BUFFER_BYTES
       end
       event_buffers
     end
 
+    # Index of the earliest event terminator at or after an offset.
+    # @param offset [Integer] character offset to start searching from
+    # @return [Integer, nil] index of the terminator, or nil if none yet
+    def next_event_end(offset)
+      lf = @buffer.index("\n\n", offset)
+      crlf = @buffer.index("\r\n\r\n", offset)
+      [lf, crlf].compact.min
+    end
+
+    # Drop an oversized partial event and fail the connection.
+    #
+    # Recording the cause matters: this runs inside Faraday's on_data callback
+    # on the SSE worker thread, whose generic rescue would otherwise leave
+    # callers with a bare "connection lost" and no reason. Mirrors the
+    # endpoint-URI failure path so wait_for_connection surfaces it promptly.
+    # @raise [MCPClient::Errors::ConnectionError] always
+    def fail_oversized_sse_buffer!
+      message = "SSE event exceeded the maximum buffered size (#{MAX_SSE_BUFFER_BYTES} bytes) " \
+                'without a terminator'
+      @buffer = +''
+      @buffer_scanned = 0
+      @connection_error = message
+      @connection_established = false
+      @connection_cv.broadcast
+      @logger.error(message)
+      raise MCPClient::Errors::ConnectionError, message
+    end
+
     # Extract a single event from the buffer
     # @param event_end [Integer] the position where the event ends
     # @return [String] the extracted event data

data/lib/mcp_client/server_stdio/json_rpc_transport.rb

@@ -66,7 +66,7 @@ module MCPClient
       # @return [void]
       # @raise [MCPClient::Errors::TransportError] on write errors
       def send_request(req)
-        @logger.debug("Sending JSONRPC request: #{req.to_json}")
+        @logger.debug("Sending JSONRPC request: #{describe_jsonrpc_message(req)}")
         @stdin.puts(req.to_json)
       rescue StandardError => e
         # A request that failed to send will never receive a response, so drop
@@ -118,7 +118,7 @@ module MCPClient
       # @raise [MCPClient::Errors::ToolCallError] on tool call errors
       def rpc_request(method, params = {}, timeout: nil)
         ensure_initialized
-        with_retry do
+        with_retry(method) do
           req_id = next_id
           req = build_jsonrpc_request(method, params, req_id)
           send_request(req)

data/lib/mcp_client/server_stdio.rb

@@ -160,7 +160,7 @@ module MCPClient
     # @return [void]
     def handle_line(line)
       msg = JSON.parse(line)
-      @logger.debug("Received line: #{line.chomp}")
+      @logger.debug("Received line: #{describe_jsonrpc_message(msg)}")
 
       # A JSON-parseable line that is not an object cannot be a JSON-RPC
       # message; skip it rather than raising inside the reader thread
@@ -542,8 +542,11 @@ module MCPClient
         send_error_response(request_id, -32_601, "Method not found: #{method}")
       end
     rescue StandardError => e
+      # The exception message is host-internal (file paths, connection
+      # strings, library internals): log it locally, answer the peer with a
+      # constant message, matching the SSE and Streamable HTTP transports.
       @logger.error("Error handling server request: #{e.message}")
-      send_error_response(request_id, -32_603, "Internal error: #{e.message}")
+      send_error_response(request_id, -32_603, 'Internal error')
     end
 
     # Handle a server-initiated ping request (MCP ping utility)
@@ -694,7 +697,7 @@ module MCPClient
       json = JSON.generate(message)
       @stdin.puts(json)
       @stdin.flush
-      @logger.debug("Sent message: #{json}")
+      @logger.debug("Sent message: #{describe_jsonrpc_message(message)}")
     rescue StandardError => e
       @logger.error("Error sending message: #{e.message}")
     end

data/lib/mcp_client/server_streamable_http/json_rpc_transport.rb

@@ -12,12 +12,45 @@ module MCPClient
     module JsonRpcTransport
       include HttpTransportBase
 
+      # Default ceiling on the expanded size of a gzip-encoded response body.
+      # The peer controls the compression ratio, so without a bound a tiny
+      # compressed response ("gzip bomb") could expand to an arbitrarily large
+      # string and exhaust host memory before JSON parsing.
+      #
+      # Hosts that legitimately exchange very large payloads (e.g. base64
+      # resource blobs or audio) can raise it per server with the
+      # max_decompressed_body_bytes option, so that whether a response is
+      # accepted does not depend on the server's choice to gzip it.
+      MAX_DECOMPRESSED_BODY_BYTES = 64 * 1024 * 1024
+      DECOMPRESS_CHUNK_BYTES = 64 * 1024
+
       private
 
+      # Whether a server-supplied SSE event id may be retained as the
+      # resumption cursor: non-empty, bounded, and safe to place in an HTTP
+      # header. Shared by every SSE parsing path (GET events stream, POST
+      # response stream, and resumed GET), since all three feed the same
+      # Last-Event-ID header.
+      # @param id [String, nil] the raw id field
+      # @return [Boolean]
+      def retainable_event_id?(id)
+        return false if id.nil? || id.empty?
+
+        if id.length > MAX_EVENT_ID_LENGTH
+          @logger.warn("Ignoring oversized SSE event id (#{id.length} chars)")
+          return false
+        end
+
+        return true if id.match?(EVENT_ID_PATTERN)
+
+        @logger.warn('Ignoring SSE event id with characters illegal in a header value')
+        false
+      end
+
       # Log HTTP response for Streamable HTTP
       # @param response [Faraday::Response] the HTTP response
       def log_response(response)
-        @logger.debug("Received Streamable HTTP response: #{response.status} #{response.body}")
+        @logger.debug("Received Streamable HTTP response: #{response.status} (#{describe_body_size(response.body)})")
       end
 
       # Parse a Streamable HTTP JSON-RPC response (JSON or SSE format)
@@ -31,7 +64,7 @@ module MCPClient
         content_type = response.headers['content-type'] || response.headers['Content-Type'] || ''
         content_encoding = response.headers['content-encoding'] || response.headers['Content-Encoding'] || ''
 
-        body = Zlib::GzipReader.new(StringIO.new(body)).read if content_encoding.include?('gzip')
+        body = decompress_gzip(body) if content_encoding.include?('gzip')
         body = body&.strip
 
         # Determine response format based on Content-Type header per MCP 2025 spec
@@ -45,7 +78,37 @@ module MCPClient
 
         process_jsonrpc_response(data)
       rescue JSON::ParserError => e
-        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
+        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{describe_parse_error(e)}"
+      end
+
+      # Incrementally decompress a gzip response body, aborting once the
+      # expanded output exceeds the configured ceiling.
+      # @param body [String] the gzip-compressed response body
+      # @return [String] the decompressed body
+      # @raise [MCPClient::Errors::ResponseTooLargeError] if the expansion limit is exceeded
+      def decompress_gzip(body)
+        limit = max_decompressed_body_bytes
+        reader = Zlib::GzipReader.new(StringIO.new(body))
+        decompressed = +''
+        while (chunk = reader.read(DECOMPRESS_CHUNK_BYTES))
+          decompressed << chunk
+          next unless decompressed.bytesize > limit
+
+          # ResponseTooLargeError (not a plain TransportError) so with_retry
+          # does not re-POST a request the server has already executed.
+          raise MCPClient::Errors::ResponseTooLargeError,
+                "Gzip response expanded beyond #{limit} bytes"
+        end
+        decompressed
+      ensure
+        reader&.close
+      end
+
+      # Configured ceiling for decompressed response bodies.
+      # @return [Integer] positive byte limit
+      def max_decompressed_body_bytes
+        configured = defined?(@max_decompressed_body_bytes) ? @max_decompressed_body_bytes : nil
+        configured || MAX_DECOMPRESSED_BODY_BYTES
       end
 
       # Parse a Server-Sent Event formatted response body.
@@ -88,7 +151,9 @@ module MCPClient
       # @raise [MCPClient::Errors::ServerError] when resumption fails
       # @raise [MCPClient::Errors::TransportError] when no cursor was received
       def resume_or_fail(events, request_id, retry_ms = nil)
-        cursor = events.reverse.find { |e| e[:id] && !e[:id].empty? }&.dig(:id)
+        # Only a validated id may become a cursor: it is sent back as a
+        # Last-Event-ID header on the resumption GET.
+        cursor = events.reverse.find { |e| retainable_event_id?(e[:id]) }&.dig(:id)
         if request_id && cursor
           # Resume with THIS stream's cursor and retry directive (both are
           # per-stream), not the shared @last_event_id / @sse_retry_ms which a
@@ -162,7 +227,10 @@ module MCPClient
 
         events.each do |event|
           if event[:id] && !event[:id].empty?
-            @mutex.synchronize { @last_event_id = event[:id] }
+            # The POST SSE stream is peer-controlled like the GET one, so its
+            # ids get the same bound/charset check before being retained or
+            # echoed in a Last-Event-ID header.
+            @mutex.synchronize { @last_event_id = event[:id] } if retainable_event_id?(event[:id])
             @logger.debug("Tracking event ID for resumability: #{event[:id]}")
           end
           next unless event[:type] == 'message'
@@ -190,10 +258,12 @@ module MCPClient
         message = JSON.parse(json_data)
         return message if message.is_a?(Hash)
 
-        @logger.warn("Skipping non-object JSON-RPC message in SSE event: #{message.inspect}")
+        # Type only: the value is peer-controlled payload and may carry tool
+        # arguments, results or elicitation content.
+        @logger.warn("Skipping non-object JSON-RPC message in SSE event (#{message.class})")
         nil
       rescue JSON::ParserError => e
-        @logger.warn("Skipping invalid JSON in SSE event: #{e.message}")
+        @logger.warn("Skipping invalid JSON in SSE event: #{describe_parse_error(e, json_data)}")
         :invalid
       end