ruby-mcp-client 0.5.3 → 0.6.1

data/lib/mcp_client/server_sse/json_rpc_transport.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'mcp_client/json_rpc_common'
+
+module MCPClient
+  class ServerSSE
+    # JSON-RPC request/notification plumbing for SSE transport
+    module JsonRpcTransport
+      include JsonRpcCommon
+      # 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
+      # @raise [MCPClient::Errors::ConnectionError] if connection is not active or reconnect fails
+      # @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 request execution
+      def rpc_request(method, params = {})
+        ensure_initialized
+
+        with_retry do
+          request_id = @mutex.synchronize { @request_id += 1 }
+          request = build_jsonrpc_request(method, params, request_id)
+          send_jsonrpc_request(request)
+        end
+      end
+
+      # Send a JSON-RPC notification (no response expected)
+      # @param method [String] JSON-RPC method name
+      # @param params [Hash] parameters for the notification
+      # @return [void]
+      def rpc_notify(method, params = {})
+        ensure_initialized
+        notif = build_jsonrpc_notification(method, params)
+        post_json_rpc_request(notif)
+      rescue MCPClient::Errors::ServerError, MCPClient::Errors::ConnectionError, Faraday::ConnectionFailed => e
+        raise MCPClient::Errors::TransportError, "Failed to send notification: #{e.message}"
+      end
+
+      private
+
+      # Ensure SSE initialization handshake has been performed.
+      # Attempts to reconnect and reinitialize if the SSE connection is not active.
+      #
+      # @raise [MCPClient::Errors::ConnectionError] if reconnect or initialization fails
+      def ensure_initialized
+        if !@connection_established || !@sse_connected
+          @logger.debug('Connection not active, attempting to reconnect before RPC request')
+          cleanup
+          connect
+          perform_initialize
+          @initialized = true
+          return
+        end
+
+        return if @initialized
+
+        perform_initialize
+        @initialized = true
+      end
+
+      # Perform JSON-RPC initialize handshake with the MCP server
+      # @return [void]
+      def perform_initialize
+        request_id = @mutex.synchronize { @request_id += 1 }
+        json_rpc_request = build_jsonrpc_request('initialize', initialization_params, request_id)
+        @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
+
+      # 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
+      # @raise [MCPClient::Errors::ConnectionError] if connection fails
+      # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
+      # @raise [MCPClient::Errors::ToolCallError] for other errors during request execution
+      def send_jsonrpc_request(request)
+        @logger.debug("Sending JSON-RPC request: #{request.to_json}")
+        record_activity
+
+        begin
+          response = post_json_rpc_request(request)
+
+          if @use_sse
+            wait_for_sse_result(request)
+          else
+            parse_direct_response(response)
+          end
+        rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+          raise
+        rescue JSON::ParserError => e
+          raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
+        rescue Errno::ECONNREFUSED => e
+          raise MCPClient::Errors::ConnectionError, "Server connection lost: #{e.message}"
+        rescue StandardError => e
+          method_name = request[:method] || request['method']
+          raise MCPClient::Errors::ToolCallError, "Error executing request '#{method_name}': #{e.message}"
+        end
+      end
+
+      # Post a JSON-RPC request to the server
+      # @param request [Hash] the JSON-RPC request
+      # @return [Faraday::Response] the HTTP response
+      # @raise [MCPClient::Errors::ConnectionError] if connection fails
+      def post_json_rpc_request(request)
+        uri = URI.parse(@base_url)
+        base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        rpc_ep = @mutex.synchronize { @rpc_endpoint }
+
+        @rpc_conn ||= create_json_rpc_connection(base)
+
+        begin
+          response = send_http_request(@rpc_conn, rpc_ep, request)
+          record_activity
+
+          unless response.success?
+            raise MCPClient::Errors::ServerError, "Server returned error: #{response.status} #{response.reason_phrase}"
+          end
+
+          response
+        rescue Faraday::ConnectionFailed => e
+          raise MCPClient::Errors::ConnectionError, "Server connection lost: #{e.message}"
+        end
+      end
+
+      # Create a Faraday connection for JSON-RPC
+      # @param base_url [String] the base URL for the connection
+      # @return [Faraday::Connection] the configured connection
+      def create_json_rpc_connection(base_url)
+        Faraday.new(url: base_url) 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
+      end
+
+      # Send an HTTP request with the proper headers and body
+      # @param conn [Faraday::Connection] the connection to use
+      # @param endpoint [String] the endpoint to post to
+      # @param request [Hash] the request data
+      # @return [Faraday::Response] the HTTP response
+      def send_http_request(conn, endpoint, request)
+        response = conn.post(endpoint) 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 { |k, v| req.headers[k] = v }
+          req.body = request.to_json
+        end
+
+        msg = "Received JSON-RPC response: #{response.status}"
+        msg += " #{response.body}" if response.respond_to?(:body)
+        @logger.debug(msg)
+        response
+      end
+
+      # Wait for an SSE result to arrive
+      # @param request [Hash] the original JSON-RPC request
+      # @return [Hash] the result data
+      # @raise [MCPClient::Errors::ConnectionError, MCPClient::Errors::ToolCallError] on errors
+      def wait_for_sse_result(request)
+        request_id = request[:id]
+        start_time = Time.now
+        timeout = @read_timeout || 10
+
+        ensure_sse_connection_active
+
+        wait_for_result_with_timeout(request_id, start_time, timeout)
+      end
+
+      # Ensure the SSE connection is active, reconnect if needed
+      def ensure_sse_connection_active
+        return if connection_active?
+
+        @logger.warn('SSE connection is not active, reconnecting before waiting for result')
+        begin
+          cleanup
+          connect
+        rescue MCPClient::Errors::ConnectionError => e
+          raise MCPClient::Errors::ConnectionError, "Failed to reconnect SSE for result: #{e.message}"
+        end
+      end
+
+      # Wait for a result with timeout
+      # @param request_id [Integer] the request ID to wait for
+      # @param start_time [Time] when the wait started
+      # @param timeout [Integer] the timeout in seconds
+      # @return [Hash] the result when available
+      # @raise [MCPClient::Errors::ConnectionError, MCPClient::Errors::ToolCallError] on errors
+      def wait_for_result_with_timeout(request_id, start_time, timeout)
+        loop do
+          result = check_for_result(request_id)
+          return result if result
+
+          unless connection_active?
+            raise MCPClient::Errors::ConnectionError,
+                  'SSE connection lost while waiting for result'
+          end
+
+          time_elapsed = Time.now - start_time
+          break if time_elapsed > timeout
+
+          sleep 0.1
+        end
+
+        raise MCPClient::Errors::ToolCallError, "Timeout waiting for SSE result for request #{request_id}"
+      end
+
+      # Check if a result is available for the given request ID
+      # @param request_id [Integer] the request ID to check
+      # @return [Hash, nil] the result if available, nil otherwise
+      def check_for_result(request_id)
+        result = nil
+        @mutex.synchronize do
+          result = @sse_results.delete(request_id) if @sse_results.key?(request_id)
+        end
+
+        if result
+          record_activity
+          return result
+        end
+
+        nil
+      end
+
+      # Parse a direct (non-SSE) JSON-RPC response
+      # @param response [Faraday::Response] the HTTP response
+      # @return [Hash] the parsed result
+      # @raise [MCPClient::Errors::TransportError] if parsing fails
+      # @raise [MCPClient::Errors::ServerError] if the response contains an error
+      def parse_direct_response(response)
+        data = JSON.parse(response.body)
+        process_jsonrpc_response(data)
+      rescue JSON::ParserError => e
+        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
+      end
+    end
+  end
+end

data/lib/mcp_client/server_sse/reconnect_monitor.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module MCPClient
+  class ServerSSE
+    # Extracted module for back-off, ping, and reconnection logic
+    module ReconnectMonitor
+      # Start an activity monitor thread to maintain the connection
+      # @return [void]
+      def start_activity_monitor
+        return if @activity_timer_thread&.alive?
+
+        @mutex.synchronize do
+          @last_activity_time = Time.now
+          @consecutive_ping_failures = 0
+          @max_ping_failures = DEFAULT_MAX_PING_FAILURES
+          @reconnect_attempts = 0
+          @max_reconnect_attempts = DEFAULT_MAX_RECONNECT_ATTEMPTS
+        end
+
+        @activity_timer_thread = Thread.new do
+          activity_monitor_loop
+        rescue StandardError => e
+          @logger.error("Activity monitor error: #{e.message}")
+        end
+      end
+
+      # Check if the connection is currently active
+      # @return [Boolean] true if connection is established and SSE is connected
+      def connection_active?
+        @mutex.synchronize { @connection_established && @sse_connected }
+      end
+
+      # Main loop for the activity monitor thread
+      # @return [void]
+      # @private
+      def activity_monitor_loop
+        loop do
+          sleep 1
+
+          unless connection_active?
+            @logger.debug('Activity monitor exiting: connection no longer active')
+            return
+          end
+
+          @mutex.synchronize do
+            @consecutive_ping_failures ||= 0
+            @reconnect_attempts ||= 0
+            @max_ping_failures ||= DEFAULT_MAX_PING_FAILURES
+            @max_reconnect_attempts ||= DEFAULT_MAX_RECONNECT_ATTEMPTS
+          end
+
+          return unless connection_active?
+
+          time_since_activity = Time.now - @last_activity_time
+
+          if @close_after && time_since_activity >= @close_after
+            @logger.info("Closing connection due to inactivity (#{time_since_activity.round(1)}s)")
+            cleanup
+            return
+          end
+
+          next unless @ping_interval && time_since_activity >= @ping_interval
+          return unless connection_active?
+
+          if @consecutive_ping_failures >= @max_ping_failures
+            attempt_reconnection
+          else
+            attempt_ping
+          end
+        end
+      end
+
+      # Attempt to reconnect with exponential backoff
+      # @return [void]
+      # @private
+      def attempt_reconnection
+        if @reconnect_attempts < @max_reconnect_attempts
+          begin
+            base_delay = BASE_RECONNECT_DELAY * (2**@reconnect_attempts)
+            jitter = rand * JITTER_FACTOR * base_delay
+            backoff_delay = [base_delay + jitter, MAX_RECONNECT_DELAY].min
+
+            reconnect_msg = "Attempting to reconnect (attempt #{@reconnect_attempts + 1}/#{@max_reconnect_attempts}) "
+            reconnect_msg += "after #{@consecutive_ping_failures} consecutive ping failures. "
+            reconnect_msg += "Waiting #{backoff_delay.round(2)}s before reconnect..."
+            @logger.warn(reconnect_msg)
+            sleep(backoff_delay)
+
+            cleanup
+
+            connect
+            @logger.info('Successfully reconnected after ping failures')
+
+            @mutex.synchronize do
+              @consecutive_ping_failures = 0
+              @reconnect_attempts += 1
+              @last_activity_time = Time.now
+            end
+          rescue StandardError => e
+            @logger.error("Failed to reconnect after ping failures: #{e.message}")
+            @mutex.synchronize { @reconnect_attempts += 1 }
+          end
+        else
+          @logger.error("Exceeded maximum reconnection attempts (#{@max_reconnect_attempts}). Closing connection.")
+          cleanup
+        end
+      end
+
+      # Attempt to ping the server to check if connection is still alive
+      # @return [void]
+      # @private
+      def attempt_ping
+        unless connection_active?
+          @logger.debug('Skipping ping - connection not active')
+          return
+        end
+
+        time_since = Time.now - @last_activity_time
+        @logger.debug("Sending ping after #{time_since.round(1)}s of inactivity")
+
+        begin
+          ping
+          @mutex.synchronize do
+            @last_activity_time = Time.now
+            @consecutive_ping_failures = 0
+          end
+        rescue StandardError => e
+          unless connection_active?
+            @logger.debug("Ignoring ping failure - connection already closed: #{e.message}")
+            return
+          end
+          handle_ping_failure(e)
+        end
+      end
+
+      # Handle ping failures by incrementing a counter and logging
+      # @param error [StandardError] the error that caused the ping failure
+      # @return [void]
+      # @private
+      def handle_ping_failure(error)
+        @mutex.synchronize { @consecutive_ping_failures += 1 }
+        consecutive_failures = @consecutive_ping_failures
+
+        if consecutive_failures == 1
+          @logger.error("Error sending ping: #{error.message}")
+        else
+          error_msg = error.message.split("\n").first
+          @logger.warn("Ping failed (#{consecutive_failures}/#{@max_ping_failures}): #{error_msg}")
+        end
+      end
+
+      # Record activity to prevent unnecessary pings
+      # @return [void]
+      def record_activity
+        @mutex.synchronize { @last_activity_time = Time.now }
+      end
+
+      # Wait for the connection to be established
+      # @param timeout [Numeric] timeout in seconds
+      # @return [void]
+      # @raise [MCPClient::Errors::ConnectionError] if connection times out or fails
+      def wait_for_connection(timeout:)
+        @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
+
+          raise MCPClient::Errors::ConnectionError, @auth_error if @auth_error
+
+          unless @connection_established
+            cleanup
+            error_msg = "Failed to connect to MCP server at #{@base_url}"
+            error_msg += ': Timed out waiting for SSE connection to be established'
+            raise MCPClient::Errors::ConnectionError, error_msg
+          end
+        end
+      end
+
+      # Setup the SSE connection with Faraday
+      # @param uri [URI] the URI to connect to
+      # @return [Faraday::Connection] the configured connection
+      # @private
+      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
+        end
+
+        @sse_conn.builder.use Faraday::Response::RaiseError
+        @sse_conn
+      end
+
+      # Handle authentication errors from SSE
+      # @param error [StandardError] the authentication error
+      # @return [void]
+      # @private
+      def handle_sse_auth_error(error)
+        error_message = "Authorization failed: HTTP #{error.response[:status]}"
+        @logger.error(error_message)
+
+        @mutex.synchronize do
+          @auth_error = error_message
+          @connection_established = false
+          @connection_cv.broadcast
+        end
+      end
+
+      # Reset the connection state
+      # @return [void]
+      # @private
+      def reset_connection_state
+        @mutex.synchronize do
+          @connection_established = false
+          @connection_cv.broadcast
+        end
+      end
+    end
+  end
+end

data/lib/mcp_client/server_sse/sse_parser.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module MCPClient
+  class ServerSSE
+    # === Wire-level SSE parsing & dispatch ===
+    module SseParser
+      # Parse and handle a raw SSE event payload.
+      # @param event_data [String] the raw event chunk
+      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'
+          # no-op
+        when 'message'
+          handle_message_event(event)
+        end
+      end
+
+      # Handle a "message" SSE event (payload is JSON-RPC over SSE)
+      # @param event [Hash] the parsed SSE event (with :data, :id, etc)
+      def handle_message_event(event)
+        return if event[:data].empty?
+
+        begin
+          data = JSON.parse(event[:data])
+
+          return if process_error_in_message(data)
+          return if process_notification(data)
+
+          process_response(data)
+        rescue MCPClient::Errors::ConnectionError
+          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
+
+      # Process a JSON-RPC error() in the SSE stream.
+      # @param data [Hash] the parsed JSON payload
+      # @return [Boolean] true if we saw & handled an error
+      def process_error_in_message(data)
+        return unless data['error']
+
+        error_message = data['error']['message'] || 'Unknown server error'
+        error_code    = data['error']['code']
+
+        handle_sse_auth_error_message(error_message) if authorization_error?(error_message, error_code)
+
+        @logger.error("Server error: #{error_message}")
+        true
+      end
+
+      # Process a JSON-RPC notification (no id => notification)
+      # @param data [Hash] the parsed JSON payload
+      # @return [Boolean] true if we saw & handled a notification
+      def process_notification(data)
+        return false unless data['method'] && !data.key?('id')
+
+        @notification_callback&.call(data['method'], data['params'])
+        true
+      end
+
+      # Process a JSON-RPC response (id => response)
+      # @param data [Hash] the parsed JSON payload
+      # @return [Boolean] true if we saw & handled a response
+      def process_response(data)
+        return false unless data['id']
+
+        @mutex.synchronize do
+          @tools_data = data['result']['tools'] if data['result'] && data['result']['tools']
+
+          @sse_results[data['id']] =
+            if data['error']
+              { 'isError' => true,
+                'content' => [{ 'type' => 'text', 'text' => data['error'].to_json }] }
+            else
+              data['result']
+            end
+        end
+
+        true
+      end
+
+      # Parse a raw SSE chunk into its :event, :data, :id fields
+      # @param event_data [String] the raw SSE block
+      # @return [Hash,nil] parsed fields or nil if it was pure comment/blank
+      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? # blank line
+          next if line.start_with?(':') # SSE comment
+
+          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")
+        has_content ? event : nil
+      end
+
+      # Handle the special "endpoint" control frame (for SSE handshake)
+      # @param data [String] the raw endpoint payload
+      def handle_endpoint_event(data)
+        @mutex.synchronize do
+          @rpc_endpoint = data
+          @sse_connected = true
+          @connection_established = true
+          @connection_cv.broadcast
+        end
+      end
+    end
+  end
+end