ruby-mcp-client 0.5.3 → 0.6.1

data/lib/mcp_client/server_sse.rb

@@ -11,9 +11,34 @@ module MCPClient
   # Implementation of MCP server that communicates via Server-Sent Events (SSE)
   # Useful for communicating with remote MCP servers over HTTP
   class ServerSSE < ServerBase
+    require 'mcp_client/server_sse/sse_parser'
+    require 'mcp_client/server_sse/json_rpc_transport'
+
+    include SseParser
+    include JsonRpcTransport
+    require 'mcp_client/server_sse/reconnect_monitor'
+
+    include ReconnectMonitor
     # Ratio of close_after timeout to ping interval
     CLOSE_AFTER_PING_RATIO = 2.5
 
+    # Default values for connection monitoring
+    DEFAULT_MAX_PING_FAILURES = 3
+    DEFAULT_MAX_RECONNECT_ATTEMPTS = 5
+
+    # Reconnection backoff constants
+    BASE_RECONNECT_DELAY = 0.5
+    MAX_RECONNECT_DELAY = 30
+    JITTER_FACTOR = 0.25
+
+    # @!attribute [r] base_url
+    #   @return [String] The base URL of the MCP server
+    # @!attribute [r] tools
+    #   @return [Array<MCPClient::Tool>, nil] List of available tools (nil if not fetched yet)
+    # @!attribute [r] server_info
+    #   @return [Hash, nil] Server information from initialize response
+    # @!attribute [r] capabilities
+    #   @return [Hash, nil] Server capabilities from initialize response
     attr_reader :base_url, :tools, :server_info, :capabilities
 
     # @param base_url [String] The base URL of the MCP server
@@ -22,10 +47,11 @@ module MCPClient
     # @param ping [Integer] Time in seconds after which to send ping if no activity (default: 10)
     # @param retries [Integer] number of retry attempts on transient errors
     # @param retry_backoff [Numeric] base delay in seconds for exponential backoff
+    # @param name [String, nil] optional name for this server
     # @param logger [Logger, nil] optional logger
     def initialize(base_url:, headers: {}, read_timeout: 30, ping: 10,
-                   retries: 0, retry_backoff: 1, logger: nil)
-      super()
+                   retries: 0, retry_backoff: 1, name: nil, logger: nil)
+      super(name: name)
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
       @logger.progname = self.class.name
       @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
@@ -85,22 +111,20 @@ module MCPClient
         return @tools if @tools
       end
 
-      ensure_initialized
-
       begin
+        ensure_initialized
+
         tools_data = request_tools_list
         @mutex.synchronize do
           @tools = tools_data.map do |tool_data|
-            MCPClient::Tool.from_json(tool_data)
+            MCPClient::Tool.from_json(tool_data, server: self)
           end
         end
 
         @mutex.synchronize { @tools }
-      rescue MCPClient::Errors::TransportError
-        # Re-raise TransportError directly
+      rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+        # Re-raise these errors directly
         raise
-      rescue JSON::ParserError => e
-        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
       rescue StandardError => e
         raise MCPClient::Errors::ToolCallError, "Error listing tools: #{e.message}"
       end
@@ -113,31 +137,18 @@ module MCPClient
     # @raise [MCPClient::Errors::ServerError] if server returns an error
     # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
     # @raise [MCPClient::Errors::ToolCallError] for other errors during tool execution
+    # @raise [MCPClient::Errors::ConnectionError] if server is disconnected
     def call_tool(tool_name, parameters)
-      ensure_initialized
-
-      begin
-        request_id = @mutex.synchronize { @request_id += 1 }
-
-        json_rpc_request = {
-          jsonrpc: '2.0',
-          id: request_id,
-          method: 'tools/call',
-          params: {
-            name: tool_name,
-            arguments: parameters
-          }
-        }
-
-        send_jsonrpc_request(json_rpc_request)
-      rescue MCPClient::Errors::TransportError
-        # Re-raise TransportError directly
-        raise
-      rescue JSON::ParserError => e
-        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
-      rescue StandardError => e
-        raise MCPClient::Errors::ToolCallError, "Error calling tool '#{tool_name}': #{e.message}"
-      end
+      rpc_request('tools/call', {
+                    name: tool_name,
+                    arguments: parameters
+                  })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      # Re-raise connection/transport errors directly to match test expectations
+      raise
+    rescue StandardError => e
+      # For all other errors, wrap in ToolCallError
+      raise MCPClient::Errors::ToolCallError, "Error calling tool '#{tool_name}': #{e.message}"
     end
 
     # Connect to the MCP server over HTTP/HTTPS with SSE
@@ -146,7 +157,13 @@ module MCPClient
     def connect
       return true if @mutex.synchronize { @connection_established }
 
+      # Check for pre-existing auth error (needed for tests)
+      pre_existing_auth_error = @mutex.synchronize { @auth_error }
+
       begin
+        # Don't reset auth error if it's pre-existing
+        @mutex.synchronize { @auth_error = nil } unless pre_existing_auth_error
+
         start_sse_thread
         effective_timeout = [@read_timeout || 30, 30].min
         wait_for_connection(timeout: effective_timeout)
@@ -154,16 +171,12 @@ module MCPClient
         true
       rescue MCPClient::Errors::ConnectionError => e
         cleanup
-        # Check for stored auth error first, as it's more specific
-        auth_error = @mutex.synchronize { @auth_error }
-        raise MCPClient::Errors::ConnectionError, auth_error if auth_error
-
-        raise MCPClient::Errors::ConnectionError, e.message if e.message.include?('Authorization failed')
-
-        raise MCPClient::Errors::ConnectionError, "Failed to connect to MCP server at #{@base_url}: #{e.message}"
+        # Simply pass through any ConnectionError without wrapping it again
+        # This prevents duplicate error messages in the stack
+        raise e
       rescue StandardError => e
         cleanup
-        # Check for stored auth error
+        # Check for stored auth error first as it's more specific
         auth_error = @mutex.synchronize { @auth_error }
         raise MCPClient::Errors::ConnectionError, auth_error if auth_error
 
@@ -172,263 +185,171 @@ module MCPClient
     end
 
     # Clean up the server connection
-    # Properly closes HTTP connections and clears cached tools
+    # Properly closes HTTP connections and clears cached state
+    #
+    # @note This method preserves ping failure and reconnection metrics between
+    #   reconnection attempts, allowing the client to track failures across
+    #   multiple connection attempts. This is essential for proper reconnection
+    #   logic and exponential backoff.
     def cleanup
       @mutex.synchronize do
+        # Set flags first before killing threads to prevent race conditions
+        # where threads might check flags after they're set but before they're killed
+        @connection_established = false
+        @sse_connected = false
+        @initialized = false # Reset initialization state for reconnection
+
+        # Log cleanup for debugging
+        @logger.debug('Cleaning up SSE connection')
+
+        # Store threads locally to avoid race conditions
+        sse_thread = @sse_thread
+        activity_thread = @activity_timer_thread
+
+        # Clear thread references first
+        @sse_thread = nil
+        @activity_timer_thread = nil
+
+        # Kill threads outside the critical section
         begin
-          @sse_thread&.kill
-        rescue StandardError
-          nil
+          sse_thread&.kill
+        rescue StandardError => e
+          @logger.debug("Error killing SSE thread: #{e.message}")
         end
-        @sse_thread = nil
 
         begin
-          @activity_timer_thread&.kill
-        rescue StandardError
-          nil
+          activity_thread&.kill
+        rescue StandardError => e
+          @logger.debug("Error killing activity thread: #{e.message}")
         end
-        @activity_timer_thread = nil
 
         if @http_client
           @http_client.finish if @http_client.started?
           @http_client = nil
         end
 
+        # Close Faraday connections if they exist
+        @rpc_conn = nil
+        @sse_conn = nil
+
         @tools = nil
-        @connection_established = false
-        @sse_connected = false
         # Don't clear auth error as we need it for reporting the correct error
+        # Don't reset @consecutive_ping_failures or @reconnect_attempts as they're tracked across reconnections
       end
     end
 
-    # Generic JSON-RPC request: send method with params and return result
-    # @param method [String] JSON-RPC method name
-    # @param params [Hash] parameters for the request
-    # @return [Object] result from JSON-RPC response
-    def rpc_request(method, params = {})
-      ensure_initialized
-      with_retry do
-        request_id = @mutex.synchronize { @request_id += 1 }
-        request = { jsonrpc: '2.0', id: request_id, method: method, params: params }
-        send_jsonrpc_request(request)
+    private
+
+    # Start the SSE thread to listen for events
+    # This thread handles the long-lived Server-Sent Events connection
+    # @return [Thread] the SSE thread
+    # @private
+    def start_sse_thread
+      return if @sse_thread&.alive?
+
+      @sse_thread = Thread.new do
+        handle_sse_connection
       end
     end
 
-    # Send a JSON-RPC notification (no response expected)
-    # @param method [String] JSON-RPC method name
-    # @param params [Hash] parameters for the notification
+    # Handle the SSE connection in a separate method to reduce method size
     # @return [void]
-    def rpc_notify(method, params = {})
-      ensure_initialized
+    # @private
+    def handle_sse_connection
       uri = URI.parse(@base_url)
-      base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-      rpc_ep = @mutex.synchronize { @rpc_endpoint }
-      @rpc_conn ||= Faraday.new(url: base) do |f|
-        f.request :retry, max: @max_retries, interval: @retry_backoff, backoff_factor: 2
-        f.options.open_timeout = @read_timeout
-        f.options.timeout = @read_timeout
-        f.adapter Faraday.default_adapter
-      end
-      response = @rpc_conn.post(rpc_ep) do |req|
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['Accept'] = 'application/json'
-        (@headers.dup.tap do |h|
-          h.delete('Accept')
-          h.delete('Cache-Control')
-        end).each do |k, v|
-          req.headers[k] = v
-        end
-        req.body = { jsonrpc: '2.0', method: method, params: params }.to_json
-      end
-      unless response.success?
-        raise MCPClient::Errors::ServerError, "Notification failed: #{response.status} #{response.reason_phrase}"
-      end
-    rescue StandardError => e
-      raise MCPClient::Errors::TransportError, "Failed to send notification: #{e.message}"
-    end
+      sse_path = uri.request_uri
+      conn = setup_sse_connection(uri)
 
-    # Ping the server to keep the connection alive
-    # @return [Hash] the result of the ping request
-    def ping
-      rpc_request('ping')
-    end
-
-    private
+      reset_sse_connection_state
 
-    # Start the activity monitor thread
-    # This thread monitors connection activity and:
-    # 1. Sends a ping if there's no activity for @ping_interval seconds
-    # 2. Closes the connection if there's no activity for @close_after seconds
-    def start_activity_monitor
-      return if @activity_timer_thread&.alive?
-
-      @mutex.synchronize { @last_activity_time = Time.now }
-
-      @activity_timer_thread = Thread.new do
-        loop do
-          sleep 1 # Check every second
-
-          last_activity = nil
-          @mutex.synchronize { last_activity = @last_activity_time }
-
-          time_since_activity = Time.now - last_activity
-
-          if @close_after && time_since_activity >= @close_after
-            @logger.info("Closing connection due to inactivity (#{time_since_activity.round(1)}s)")
-            cleanup
-            break
-          elsif @ping_interval && time_since_activity >= @ping_interval
-            begin
-              @logger.debug("Sending ping after #{time_since_activity.round(1)}s of inactivity")
-              ping
-              @mutex.synchronize { @last_activity_time = Time.now }
-            rescue StandardError => e
-              @logger.error("Error sending ping: #{e.message}")
-            end
-          end
-        end
+      begin
+        establish_sse_connection(conn, sse_path)
+      rescue MCPClient::Errors::ConnectionError => e
+        reset_connection_state
+        raise e
       rescue StandardError => e
-        @logger.error("Activity monitor error: #{e.message}")
+        @logger.error("SSE connection error: #{e.message}")
+        reset_connection_state
+      ensure
+        @mutex.synchronize { @sse_connected = false }
       end
     end
 
-    # Record activity to reset the inactivity timer
-    def record_activity
-      @mutex.synchronize { @last_activity_time = Time.now }
-    end
-
-    # Wait for SSE connection to be established with periodic checks
-    # @param timeout [Integer] Maximum time to wait in seconds
-    # @raise [MCPClient::Errors::ConnectionError] if timeout expires
-    def wait_for_connection(timeout:)
+    # Reset SSE connection state
+    # @return [void]
+    # @private
+    def reset_sse_connection_state
       @mutex.synchronize do
-        deadline = Time.now + timeout
-
-        until @connection_established
-          remaining = [1, deadline - Time.now].min
-          break if remaining <= 0 || @connection_cv.wait(remaining) { @connection_established }
-        end
-
-        unless @connection_established
-          cleanup
-          raise MCPClient::Errors::ConnectionError, 'Timed out waiting for SSE connection to be established'
-        end
+        @sse_connected = false
+        @connection_established = false
       end
     end
 
-    # Ensure SSE initialization handshake has been performed
-    def ensure_initialized
-      return if @initialized
-
-      connect
-      perform_initialize
-
-      @initialized = true
-    end
-
-    # Perform JSON-RPC initialize handshake with the MCP server
-    def perform_initialize
-      request_id = @mutex.synchronize { @request_id += 1 }
-      json_rpc_request = {
-        jsonrpc: '2.0',
-        id: request_id,
-        method: 'initialize',
-        params: {
-          'protocolVersion' => MCPClient::VERSION,
-          'capabilities' => {},
-          'clientInfo' => { 'name' => 'ruby-mcp-client', 'version' => MCPClient::VERSION }
-        }
-      }
-      @logger.debug("Performing initialize RPC: #{json_rpc_request}")
-      result = send_jsonrpc_request(json_rpc_request)
-      return unless result.is_a?(Hash)
-
-      @server_info = result['serverInfo'] if result.key?('serverInfo')
-      @capabilities = result['capabilities'] if result.key?('capabilities')
-    end
+    # Establish SSE connection with error handling
+    # @param conn [Faraday::Connection] the Faraday connection to use
+    # @param sse_path [String] the SSE endpoint path
+    # @return [void]
+    # @private
+    def establish_sse_connection(conn, sse_path)
+      conn.get(sse_path) do |req|
+        @headers.each { |k, v| req.headers[k] = v }
 
-    # Set up the SSE connection
-    # @param uri [URI] The parsed base URL
-    # @return [Faraday::Connection] The configured Faraday connection
-    def setup_sse_connection(uri)
-      sse_base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-
-      @sse_conn ||= Faraday.new(url: sse_base) do |f|
-        f.options.open_timeout = 10
-        f.options.timeout = nil
-        f.request :retry, max: @max_retries, interval: @retry_backoff, backoff_factor: 2
-        f.adapter Faraday.default_adapter
+        req.options.on_data = proc do |chunk, _bytes|
+          process_sse_chunk(chunk.dup) if chunk && !chunk.empty?
+        end
       end
-
-      # Use response handling with status check
-      @sse_conn.builder.use Faraday::Response::RaiseError
-      @sse_conn
+    rescue Faraday::UnauthorizedError, Faraday::ForbiddenError => e
+      handle_sse_auth_response_error(e)
+    rescue Faraday::ConnectionFailed => e
+      handle_sse_connection_failed(e)
+    rescue Faraday::Error => e
+      handle_sse_general_error(e)
     end
 
-    # Handle authorization errors from Faraday
-    # @param error [Faraday::Error] The authorization error
-    # @raise [MCPClient::Errors::ConnectionError] with appropriate message
-    def handle_sse_auth_error(error)
-      error_message = "Authorization failed: HTTP #{error.response[:status]}"
-      @logger.error(error_message)
+    # Handle auth errors from SSE response
+    # @param err [Faraday::Error] the authorization error
+    # @return [void]
+    # @private
+    def handle_sse_auth_response_error(err)
+      error_status = err.response ? err.response[:status] : 'unknown'
+      auth_error = "Authorization failed: HTTP #{error_status}"
 
       @mutex.synchronize do
-        @auth_error = error_message
+        @auth_error = auth_error
         @connection_established = false
         @connection_cv.broadcast
       end
-      raise MCPClient::Errors::ConnectionError, error_message
+      @logger.error(auth_error)
     end
 
-    # Reset connection state and signal waiting threads
-    def reset_connection_state
+    # Handle connection failures in SSE
+    # @param err [Faraday::ConnectionFailed] the connection failure error
+    # @return [void]
+    # @raise [Faraday::ConnectionFailed] re-raises the original error
+    # @private
+    def handle_sse_connection_failed(err)
+      @logger.error("Failed to connect to MCP server at #{@base_url}: #{err.message}")
+
       @mutex.synchronize do
         @connection_established = false
         @connection_cv.broadcast
       end
+      raise
     end
 
-    # Start the SSE thread to listen for events
-    def start_sse_thread
-      return if @sse_thread&.alive?
-
-      @sse_thread = Thread.new do
-        uri = URI.parse(@base_url)
-        sse_path = uri.request_uri
-        conn = setup_sse_connection(uri)
-
-        # Reset connection state
-        @mutex.synchronize do
-          @sse_connected = false
-          @connection_established = false
-        end
-
-        begin
-          conn.get(sse_path) do |req|
-            @headers.each { |k, v| req.headers[k] = v }
+    # Handle general Faraday errors in SSE
+    # @param err [Faraday::Error] the general Faraday error
+    # @return [void]
+    # @raise [Faraday::Error] re-raises the original error
+    # @private
+    def handle_sse_general_error(err)
+      @logger.error("Failed SSE connection: #{err.message}")
 
-            req.options.on_data = proc do |chunk, _bytes|
-              process_sse_chunk(chunk.dup) if chunk && !chunk.empty?
-            end
-          end
-        rescue Faraday::UnauthorizedError, Faraday::ForbiddenError => e
-          handle_sse_auth_error(e)
-        rescue Faraday::Error => e
-          @logger.error("Failed SSE connection: #{e.message}")
-          raise
-        end
-      rescue MCPClient::Errors::ConnectionError => e
-        # Re-raise connection errors to propagate them
-        # Signal connect method to stop waiting
-        reset_connection_state
-        raise e
-      rescue StandardError => e
-        @logger.error("SSE connection error: #{e.message}")
-        # Signal connect method to avoid deadlock
-        reset_connection_state
-      ensure
-        @mutex.synchronize { @sse_connected = false }
+      @mutex.synchronize do
+        @connection_established = false
+        @connection_cv.broadcast
       end
+      raise
     end
 
     # Process an SSE chunk from the server
@@ -477,21 +398,11 @@ module MCPClient
       event_buffers&.each { |event_data| parse_and_handle_sse_event(event_data) }
     end
 
-    # Handle SSE endpoint event
-    # @param data [String] The endpoint path
-    def handle_endpoint_event(data)
-      @mutex.synchronize do
-        @rpc_endpoint = data
-        @sse_connected = true
-        @connection_established = true
-        @connection_cv.broadcast
-      end
-    end
-
     # Check if the error represents an authorization error
     # @param error_message [String] The error message from the server
     # @param error_code [Integer, nil] The error code if available
     # @return [Boolean] True if it's an authorization error
+    # @private
     def authorization_error?(error_message, error_code)
       return true if error_message.include?('Unauthorized') || error_message.include?('authentication')
       return true if [401, -32_000].include?(error_code)
@@ -501,6 +412,9 @@ module MCPClient
 
     # Handle authorization error in SSE message
     # @param error_message [String] The error message from the server
+    # @return [void]
+    # @raise [MCPClient::Errors::ConnectionError] with an authentication error message
+    # @private
     def handle_sse_auth_error_message(error_message)
       @mutex.synchronize do
         @auth_error = "Authorization failed: #{error_message}"
@@ -511,144 +425,16 @@ module MCPClient
       raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
     end
 
-    # Process error messages in SSE responses
-    # @param data [Hash] The parsed SSE message data
-    def process_error_in_message(data)
-      return unless data['error']
-
-      error_message = data['error']['message'] || 'Unknown server error'
-      error_code = data['error']['code']
-
-      # Handle unauthorized errors (close connection immediately)
-      handle_sse_auth_error_message(error_message) if authorization_error?(error_message, error_code)
-
-      @logger.error("Server error: #{error_message}")
-      true # Error was processed
-    end
-
-    # Process JSON-RPC notifications
-    # @param data [Hash] The parsed SSE message data
-    # @return [Boolean] True if a notification was processed
-    def process_notification(data)
-      return false unless data['method'] && !data.key?('id')
-
-      @notification_callback&.call(data['method'], data['params'])
-      true
-    end
-
-    # Process JSON-RPC responses
-    # @param data [Hash] The parsed SSE message data
-    # @return [Boolean] True if a response was processed
-    def process_response(data)
-      return false unless data['id']
-
-      @mutex.synchronize do
-        # Store tools data if present
-        @tools_data = data['result']['tools'] if data['result'] && data['result']['tools']
-
-        # Store response for the waiting request
-        if data['error']
-          @sse_results[data['id']] = {
-            'isError' => true,
-            'content' => [{ 'type' => 'text', 'text' => data['error'].to_json }]
-          }
-        elsif data['result']
-          @sse_results[data['id']] = data['result']
-        end
-      end
-
-      true
-    end
-
-    # Parse and handle an SSE event
-    # @param event_data [String] the event data to parse
-    def parse_and_handle_sse_event(event_data)
-      event = parse_sse_event(event_data)
-      return if event.nil?
-
-      case event[:event]
-      when 'endpoint'
-        handle_endpoint_event(event[:data])
-      when 'ping'
-        # Received ping event, no action needed
-      when 'message'
-        handle_message_event(event)
-      end
-    end
-
-    # Handle a message event from SSE
-    # @param event [Hash] The parsed SSE event
-    def handle_message_event(event)
-      return if event[:data].empty?
-
-      begin
-        data = JSON.parse(event[:data])
-
-        # Process the message in order of precedence
-        return if process_error_in_message(data)
-
-        return if process_notification(data)
-
-        process_response(data)
-      rescue MCPClient::Errors::ConnectionError
-        # Re-raise connection errors to propagate to the calling code
-        raise
-      rescue JSON::ParserError => e
-        @logger.warn("Failed to parse JSON from event data: #{e.message}")
-      rescue StandardError => e
-        @logger.error("Error processing SSE event: #{e.message}")
-      end
-    end
-
-    # Parse an SSE event
-    # @param event_data [String] the event data to parse
-    # @return [Hash, nil] the parsed event, or nil if the event is invalid
-    def parse_sse_event(event_data)
-      event = { event: 'message', data: '', id: nil }
-      data_lines = []
-      has_content = false
-
-      event_data.each_line do |line|
-        line = line.chomp
-        next if line.empty?
-
-        # Skip SSE comments (lines starting with colon)
-        next if line.start_with?(':')
-
-        has_content = true
-
-        if line.start_with?('event:')
-          event[:event] = line[6..].strip
-        elsif line.start_with?('data:')
-          data_lines << line[5..].strip
-        elsif line.start_with?('id:')
-          event[:id] = line[3..].strip
-        end
-      end
-
-      event[:data] = data_lines.join("\n")
-
-      # Return the event even if data is empty as long as we had non-comment content
-      has_content ? event : nil
-    end
-
     # Request the tools list using JSON-RPC
     # @return [Array<Hash>] the tools data
+    # @raise [MCPClient::Errors::ToolCallError] if tools list retrieval fails
+    # @private
     def request_tools_list
       @mutex.synchronize do
         return @tools_data if @tools_data
       end
 
-      request_id = @mutex.synchronize { @request_id += 1 }
-
-      json_rpc_request = {
-        jsonrpc: '2.0',
-        id: request_id,
-        method: 'tools/list',
-        params: {}
-      }
-
-      result = send_jsonrpc_request(json_rpc_request)
+      result = rpc_request('tools/list')
 
       if result && result['tools']
         @mutex.synchronize do
@@ -664,106 +450,5 @@ module MCPClient
 
       raise MCPClient::Errors::ToolCallError, 'Failed to get tools list from JSON-RPC request'
     end
-
-    # Helper: execute block with retry/backoff for transient errors
-    # @yield block to execute
-    # @return result of block
-    def with_retry
-      attempts = 0
-      begin
-        yield
-      rescue MCPClient::Errors::TransportError, MCPClient::Errors::ServerError, IOError, Errno::ETIMEDOUT,
-             Errno::ECONNRESET => e
-        attempts += 1
-        if attempts <= @max_retries
-          delay = @retry_backoff * (2**(attempts - 1))
-          @logger.debug("Retry attempt #{attempts} after error: #{e.message}, sleeping #{delay}s")
-          sleep(delay)
-          retry
-        end
-        raise
-      end
-    end
-
-    # Send a JSON-RPC request to the server and wait for result
-    # @param request [Hash] the JSON-RPC request
-    # @return [Hash] the result of the request
-    def send_jsonrpc_request(request)
-      @logger.debug("Sending JSON-RPC request: #{request.to_json}")
-
-      # Record activity when sending a request
-      record_activity
-
-      uri = URI.parse(@base_url)
-      base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-      rpc_ep = @mutex.synchronize { @rpc_endpoint }
-
-      @rpc_conn ||= Faraday.new(url: base) do |f|
-        f.request :retry, max: @max_retries, interval: @retry_backoff, backoff_factor: 2
-        f.options.open_timeout = @read_timeout
-        f.options.timeout = @read_timeout
-        f.adapter Faraday.default_adapter
-      end
-
-      response = @rpc_conn.post(rpc_ep) do |req|
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['Accept'] = 'application/json'
-        (@headers.dup.tap do |h|
-          h.delete('Accept')
-          h.delete('Cache-Control')
-        end).each do |k, v|
-          req.headers[k] = v
-        end
-        req.body = request.to_json
-      end
-      @logger.debug("Received JSON-RPC response: #{response.status} #{response.body}")
-
-      # Record activity when receiving a response
-      record_activity
-
-      unless response.success?
-        raise MCPClient::Errors::ServerError, "Server returned error: #{response.status} #{response.reason_phrase}"
-      end
-
-      if @use_sse
-        # Wait for result via SSE channel
-        request_id = request[:id]
-        start_time = Time.now
-        # Use the specified read_timeout for the overall operation
-        timeout = @read_timeout || 10
-
-        # Check every 100ms for the result, with a total timeout from read_timeout
-        loop do
-          result = nil
-          @mutex.synchronize do
-            result = @sse_results.delete(request_id) if @sse_results.key?(request_id)
-          end
-
-          if result
-            # Record activity when receiving a result
-            record_activity
-            return result
-          end
-
-          current_time = Time.now
-          time_elapsed = current_time - start_time
-
-          # If we've exceeded the timeout, raise an error
-          break if time_elapsed > timeout
-
-          # Sleep for a short time before checking again
-          sleep 0.1
-        end
-
-        raise MCPClient::Errors::ToolCallError, "Timeout waiting for SSE result for request #{request_id}"
-      else
-        begin
-          data = JSON.parse(response.body)
-          data['result']
-        rescue JSON::ParserError => e
-          raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
-        end
-      end
-    end
   end
 end