ruby-mcp-client 0.6.2 → 0.7.1

data/lib/mcp_client/server_http.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'json'
+require 'monitor'
+require 'logger'
+require 'faraday'
+require 'faraday/retry'
+
+module MCPClient
+  # Implementation of MCP server that communicates via HTTP requests/responses
+  # Useful for communicating with MCP servers that support HTTP-based transport
+  # without Server-Sent Events streaming
+  class ServerHTTP < ServerBase
+    require_relative 'server_http/json_rpc_transport'
+
+    include JsonRpcTransport
+
+    # Default values for connection settings
+    DEFAULT_READ_TIMEOUT = 30
+    DEFAULT_MAX_RETRIES = 3
+
+    # @!attribute [r] base_url
+    #   @return [String] The base URL of the MCP server
+    # @!attribute [r] endpoint
+    #   @return [String] The JSON-RPC endpoint path
+    # @!attribute [r] tools
+    #   @return [Array<MCPClient::Tool>, nil] List of available tools (nil if not fetched yet)
+    attr_reader :base_url, :endpoint, :tools
+
+    # Server information from initialize response
+    # @return [Hash, nil] Server information
+    attr_reader :server_info
+
+    # Server capabilities from initialize response
+    # @return [Hash, nil] Server capabilities
+    attr_reader :capabilities
+
+    # @param base_url [String] The base URL of the MCP server
+    # @param options [Hash] Server configuration options
+    # @option options [String] :endpoint JSON-RPC endpoint path (default: '/rpc')
+    # @option options [Hash] :headers Additional headers to include in requests
+    # @option options [Integer] :read_timeout Read timeout in seconds (default: 30)
+    # @option options [Integer] :retries Retry attempts on transient errors (default: 3)
+    # @option options [Numeric] :retry_backoff Base delay for exponential backoff (default: 1)
+    # @option options [String, nil] :name Optional name for this server
+    # @option options [Logger, nil] :logger Optional logger
+    # @option options [MCPClient::Auth::OAuthProvider, nil] :oauth_provider Optional OAuth provider
+    def initialize(base_url:, **options)
+      opts = default_options.merge(options)
+      super(name: opts[:name])
+      @logger = opts[:logger] || Logger.new($stdout, level: Logger::WARN)
+      @logger.progname = self.class.name
+      @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
+
+      @max_retries = opts[:retries]
+      @retry_backoff = opts[:retry_backoff]
+
+      # Validate and normalize base_url
+      raise ArgumentError, "Invalid or insecure server URL: #{base_url}" unless valid_server_url?(base_url)
+
+      # Normalize base_url and handle cases where full endpoint is provided in base_url
+      uri = URI.parse(base_url.chomp('/'))
+
+      # Helper to build base URL without default ports
+      build_base_url = lambda do |parsed_uri|
+        port_part = if parsed_uri.port &&
+                       !((parsed_uri.scheme == 'http' && parsed_uri.port == 80) ||
+                         (parsed_uri.scheme == 'https' && parsed_uri.port == 443))
+                      ":#{parsed_uri.port}"
+                    else
+                      ''
+                    end
+        "#{parsed_uri.scheme}://#{parsed_uri.host}#{port_part}"
+      end
+
+      @base_url = build_base_url.call(uri)
+      @endpoint = if uri.path && !uri.path.empty? && uri.path != '/' && opts[:endpoint] == '/rpc'
+                    # If base_url contains a path and we're using default endpoint,
+                    # treat the path as the endpoint and use the base URL without path
+                    uri.path
+                  else
+                    # Standard case: base_url is just scheme://host:port, endpoint is separate
+                    opts[:endpoint]
+                  end
+
+      # Set up headers for HTTP requests
+      @headers = opts[:headers].merge({
+                                        'Content-Type' => 'application/json',
+                                        'Accept' => 'application/json',
+                                        'User-Agent' => "ruby-mcp-client/#{MCPClient::VERSION}"
+                                      })
+
+      @read_timeout = opts[:read_timeout]
+      @tools = nil
+      @tools_data = nil
+      @request_id = 0
+      @mutex = Monitor.new
+      @connection_established = false
+      @initialized = false
+      @http_conn = nil
+      @session_id = nil
+      @oauth_provider = opts[:oauth_provider]
+    end
+
+    # Connect to the MCP server over HTTP
+    # @return [Boolean] true if connection was successful
+    # @raise [MCPClient::Errors::ConnectionError] if connection fails
+    def connect
+      return true if @mutex.synchronize { @connection_established }
+
+      begin
+        @mutex.synchronize do
+          @connection_established = false
+          @initialized = false
+        end
+
+        # Test connectivity with a simple HTTP request
+        test_connection
+
+        # Perform MCP initialization handshake
+        perform_initialize
+
+        @mutex.synchronize do
+          @connection_established = true
+          @initialized = true
+        end
+
+        true
+      rescue MCPClient::Errors::ConnectionError => e
+        cleanup
+        raise e
+      rescue StandardError => e
+        cleanup
+        raise MCPClient::Errors::ConnectionError, "Failed to connect to MCP server at #{@base_url}: #{e.message}"
+      end
+    end
+
+    # List all tools available from the MCP server
+    # @return [Array<MCPClient::Tool>] list of available tools
+    # @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 listing
+    def list_tools
+      @mutex.synchronize do
+        return @tools if @tools
+      end
+
+      begin
+        ensure_connected
+
+        tools_data = request_tools_list
+        @mutex.synchronize do
+          @tools = tools_data.map do |tool_data|
+            MCPClient::Tool.from_json(tool_data, server: self)
+          end
+        end
+
+        @mutex.synchronize { @tools }
+      rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+        # Re-raise these errors directly
+        raise
+      rescue StandardError => e
+        raise MCPClient::Errors::ToolCallError, "Error listing tools: #{e.message}"
+      end
+    end
+
+    # Call a tool with the given parameters
+    # @param tool_name [String] the name of the tool to call
+    # @param parameters [Hash] the parameters to pass to the tool
+    # @return [Object] the result of the tool invocation
+    # @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)
+      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
+
+    # Override apply_request_headers to add session headers for MCP protocol
+    def apply_request_headers(req, request)
+      super
+
+      # Add session header if we have one (for non-initialize requests)
+      return unless @session_id && request['method'] != 'initialize'
+
+      req.headers['Mcp-Session-Id'] = @session_id
+      @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+    end
+
+    # Override handle_successful_response to capture session ID
+    def handle_successful_response(response, request)
+      super
+
+      # Capture session ID from initialize response with validation
+      return unless request['method'] == 'initialize' && response.success?
+
+      session_id = response.headers['mcp-session-id'] || response.headers['Mcp-Session-Id']
+      if session_id
+        if valid_session_id?(session_id)
+          @session_id = session_id
+          @logger.debug("Captured session ID: #{@session_id}")
+        else
+          @logger.warn("Invalid session ID format received: #{session_id.inspect}")
+        end
+      else
+        @logger.warn('No session ID found in initialize response headers')
+      end
+    end
+
+    # Stream tool call (default implementation returns single-value stream)
+    # @param tool_name [String] the name of the tool to call
+    # @param parameters [Hash] the parameters to pass to the tool
+    # @return [Enumerator] stream of results
+    def call_tool_streaming(tool_name, parameters)
+      Enumerator.new do |yielder|
+        yielder << call_tool(tool_name, parameters)
+      end
+    end
+
+    # Terminate the current session (if any)
+    # @return [Boolean] true if termination was successful or no session exists
+    def terminate_session
+      @mutex.synchronize do
+        return true unless @session_id
+
+        super
+      end
+    end
+
+    # Clean up the server connection
+    # Properly closes HTTP connections and clears cached state
+    def cleanup
+      @mutex.synchronize do
+        # Attempt to terminate session before cleanup
+        terminate_session if @session_id
+
+        @connection_established = false
+        @initialized = false
+
+        @logger.debug('Cleaning up HTTP connection')
+
+        # Close HTTP connection if it exists
+        @http_conn = nil
+        @session_id = nil
+
+        @tools = nil
+        @tools_data = nil
+      end
+    end
+
+    private
+
+    # Default options for server initialization
+    # @return [Hash] Default options
+    def default_options
+      {
+        endpoint: '/rpc',
+        headers: {},
+        read_timeout: DEFAULT_READ_TIMEOUT,
+        retries: DEFAULT_MAX_RETRIES,
+        retry_backoff: 1,
+        name: nil,
+        logger: nil,
+        oauth_provider: nil
+      }
+    end
+
+    # Test basic connectivity to the HTTP endpoint
+    # @return [void]
+    # @raise [MCPClient::Errors::ConnectionError] if connection test fails
+    def test_connection
+      create_http_connection
+
+      # Simple connectivity test - we'll use the actual initialize call
+      # since there's no standard HTTP health check endpoint
+    rescue Faraday::ConnectionFailed => e
+      raise MCPClient::Errors::ConnectionError, "Cannot connect to server at #{@base_url}: #{e.message}"
+    rescue Faraday::UnauthorizedError, Faraday::ForbiddenError => e
+      error_status = e.response ? e.response[:status] : 'unknown'
+      raise MCPClient::Errors::ConnectionError, "Authorization failed: HTTP #{error_status}"
+    rescue Faraday::Error => e
+      raise MCPClient::Errors::ConnectionError, "HTTP connection error: #{e.message}"
+    end
+
+    # Ensure connection is established
+    # @return [void]
+    # @raise [MCPClient::Errors::ConnectionError] if connection is not established
+    def ensure_connected
+      return if @mutex.synchronize { @connection_established && @initialized }
+
+      @logger.debug('Connection not active, attempting to reconnect before request')
+      cleanup
+      connect
+    end
+
+    # Request the tools list using JSON-RPC
+    # @return [Array<Hash>] the tools data
+    # @raise [MCPClient::Errors::ToolCallError] if tools list retrieval fails
+    def request_tools_list
+      @mutex.synchronize do
+        return @tools_data 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
+
+      raise MCPClient::Errors::ToolCallError, 'Failed to get tools list from JSON-RPC request'
+    end
+  end
+end

data/lib/mcp_client/server_sse/json_rpc_transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'mcp_client/json_rpc_common'
+require_relative '../json_rpc_common'
 
 module MCPClient
   class ServerSSE
@@ -68,8 +68,8 @@ module MCPClient
         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')
+        @server_info = result['serverInfo']
+        @capabilities = result['capabilities']
       end
 
       # Send a JSON-RPC request to the server and wait for result
@@ -97,7 +97,7 @@ module MCPClient
         rescue Errno::ECONNREFUSED => e
           raise MCPClient::Errors::ConnectionError, "Server connection lost: #{e.message}"
         rescue StandardError => e
-          method_name = request[:method] || request['method']
+          method_name = request['method']
           raise MCPClient::Errors::ToolCallError, "Error executing request '#{method_name}': #{e.message}"
         end
       end
@@ -166,7 +166,7 @@ module MCPClient
       # @return [Hash] the result data
       # @raise [MCPClient::Errors::ConnectionError, MCPClient::Errors::ToolCallError] on errors
       def wait_for_sse_result(request)
-        request_id = request[:id]
+        request_id = request['id']
         start_time = Time.now
         timeout = @read_timeout || 10
 

data/lib/mcp_client/server_sse.rb

@@ -11,12 +11,12 @@ 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'
+    require_relative 'server_sse/sse_parser'
+    require_relative 'server_sse/json_rpc_transport'
 
     include SseParser
     include JsonRpcTransport
-    require 'mcp_client/server_sse/reconnect_monitor'
+    require_relative 'server_sse/reconnect_monitor'
 
     include ReconnectMonitor
     # Ratio of close_after timeout to ping interval
@@ -35,11 +35,15 @@ module MCPClient
     #   @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
+    attr_reader :base_url, :tools
+
+    # Server information from initialize response
+    # @return [Hash, nil] Server information
+    attr_reader :server_info
+
+    # Server capabilities from initialize response
+    # @return [Hash, nil] Server capabilities
+    attr_reader :capabilities
 
     # @param base_url [String] The base URL of the MCP server
     # @param headers [Hash] Additional headers to include in requests
@@ -138,6 +142,10 @@ module MCPClient
     # @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
+    # Call a tool with the given parameters
+    # @param tool_name [String] the name of the tool to call
+    # @param parameters [Hash] the parameters to pass to the tool
+    # @return [Object] the result of the tool invocation (with string keys for backward compatibility)
     def call_tool(tool_name, parameters)
       rpc_request('tools/call', {
                     name: tool_name,

data/lib/mcp_client/server_stdio/json_rpc_transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'mcp_client/json_rpc_common'
+require_relative '../json_rpc_common'
 
 module MCPClient
   class ServerStdio

data/lib/mcp_client/server_stdio.rb

@@ -8,7 +8,7 @@ require 'logger'
 module MCPClient
   # JSON-RPC implementation of MCP server over stdio.
   class ServerStdio < ServerBase
-    require 'mcp_client/server_stdio/json_rpc_transport'
+    require_relative 'server_stdio/json_rpc_transport'
 
     include JsonRpcTransport
 

data/lib/mcp_client/server_streamable_http/json_rpc_transport.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../http_transport_base'
+
+module MCPClient
+  class ServerStreamableHTTP
+    # JSON-RPC request/notification plumbing for Streamable HTTP transport
+    # This transport uses HTTP POST requests but expects Server-Sent Event formatted responses
+    module JsonRpcTransport
+      include HttpTransportBase
+
+      private
+
+      # 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}")
+      end
+
+      # Parse a Streamable HTTP JSON-RPC response (JSON or SSE format)
+      # @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_response(response)
+        body = response.body.strip
+        content_type = response.headers['content-type'] || response.headers['Content-Type'] || ''
+
+        # Determine response format based on Content-Type header per MCP 2025 spec
+        data = if content_type.include?('text/event-stream')
+                 # Parse SSE-formatted response for streaming
+                 parse_sse_response(body)
+               else
+                 # Parse regular JSON response (default for Streamable HTTP)
+                 JSON.parse(body)
+               end
+
+        process_jsonrpc_response(data)
+      rescue JSON::ParserError => e
+        raise MCPClient::Errors::TransportError, "Invalid JSON response from server: #{e.message}"
+      end
+
+      # Parse Server-Sent Event formatted response with event ID tracking
+      # @param sse_body [String] the SSE formatted response body
+      # @return [Hash] the parsed JSON data
+      # @raise [MCPClient::Errors::TransportError] if no data found in SSE response
+      def parse_sse_response(sse_body)
+        # Extract JSON data and event ID from SSE format
+        # SSE format: event: message\nid: 123\ndata: {...}\n\n
+        data_lines = []
+        event_id = nil
+
+        sse_body.lines.each do |line|
+          line = line.strip
+          if line.start_with?('data:')
+            data_lines << line.sub(/^data:\s*/, '').strip
+          elsif line.start_with?('id:')
+            event_id = line.sub(/^id:\s*/, '').strip
+          end
+        end
+
+        raise MCPClient::Errors::TransportError, 'No data found in SSE response' if data_lines.empty?
+
+        # Track the last event ID for resumability
+        if event_id && !event_id.empty?
+          @last_event_id = event_id
+          @logger.debug("Tracking event ID for resumability: #{event_id}")
+        end
+
+        # Join multiline data fields according to SSE spec
+        json_data = data_lines.join("\n")
+        JSON.parse(json_data)
+      end
+    end
+  end
+end