ruby-mcp-client 0.6.2 → 0.7.1

data/lib/mcp_client/server_streamable_http.rb

@@ -0,0 +1,332 @@
+# 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 Streamable HTTP transport
+  # This transport uses HTTP POST requests but expects Server-Sent Event formatted responses
+  # It's designed for servers that support streaming responses over HTTP
+  class ServerStreamableHTTP < ServerBase
+    require_relative 'server_streamable_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 (same as ServerHTTP)
+    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 Streamable HTTP requests
+      @headers = opts[:headers].merge({
+                                        'Content-Type' => 'application/json',
+                                        'Accept' => 'text/event-stream, application/json',
+                                        'Accept-Encoding' => 'gzip, deflate',
+                                        'User-Agent' => "ruby-mcp-client/#{MCPClient::VERSION}",
+                                        'Cache-Control' => 'no-cache'
+                                      })
+
+      @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
+      @last_event_id = nil
+      @oauth_provider = opts[:oauth_provider]
+    end
+
+    # Connect to the MCP server over Streamable 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 (with string keys for backward compatibility)
+    # @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
+
+    # 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
+
+    # Override apply_request_headers to add session and SSE headers for MCP protocol
+    def apply_request_headers(req, request)
+      super
+
+      # Add session header if we have one (for non-initialize requests)
+      if @session_id && request['method'] != 'initialize'
+        req.headers['Mcp-Session-Id'] = @session_id
+        @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+      end
+
+      # Add Last-Event-ID header for resumability (if available)
+      return unless @last_event_id
+
+      req.headers['Last-Event-ID'] = @last_event_id
+      @logger.debug("Adding Last-Event-ID header: #{@last_event_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
+
+    # 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 Streamable 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.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'
+    end
+  end
+end

data/lib/mcp_client/tool.rb

@@ -31,10 +31,11 @@ module MCPClient
     # @return [MCPClient::Tool] tool instance
     def self.from_json(data, server: nil)
       # Some servers (Playwright MCP CLI) use 'inputSchema' instead of 'schema'
-      schema = data['inputSchema'] || data['schema']
+      # Handle both string and symbol keys
+      schema = data['inputSchema'] || data[:inputSchema] || data['schema'] || data[:schema]
       new(
-        name: data['name'],
-        description: data['description'],
+        name: data['name'] || data[:name],
+        description: data['description'] || data[:description],
         schema: schema,
         server: server
       )

data/lib/mcp_client/version.rb

@@ -2,8 +2,11 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.6.2'
+  VERSION = '0.7.1'
 
   # JSON-RPC handshake protocol version (date-based)
   PROTOCOL_VERSION = '2024-11-05'
+
+  # Protocol version for HTTP and Streamable HTTP transports
+  HTTP_PROTOCOL_VERSION = '2025-03-26'
 end

data/lib/mcp_client.rb

@@ -6,10 +6,14 @@ require_relative 'mcp_client/tool'
 require_relative 'mcp_client/server_base'
 require_relative 'mcp_client/server_stdio'
 require_relative 'mcp_client/server_sse'
+require_relative 'mcp_client/server_http'
+require_relative 'mcp_client/server_streamable_http'
 require_relative 'mcp_client/server_factory'
 require_relative 'mcp_client/client'
 require_relative 'mcp_client/version'
 require_relative 'mcp_client/config_parser'
+require_relative 'mcp_client/auth'
+require_relative 'mcp_client/oauth_client'
 
 # Model Context Protocol (MCP) Client module
 # Provides a standardized way for agents to communicate with external tools and services
@@ -33,7 +37,6 @@ module MCPClient
       parsed.each_value do |cfg|
         case cfg[:type].to_s
         when 'stdio'
-          # Build command list with args and propagate environment
           cmd_list = [cfg[:command]] + Array(cfg[:args])
           configs << MCPClient.stdio_config(
             command: cmd_list,
@@ -42,9 +45,14 @@ module MCPClient
             env: cfg[:env]
           )
         when 'sse'
-          # Use 'url' from parsed config as 'base_url' for SSE config
           configs << MCPClient.sse_config(base_url: cfg[:url], headers: cfg[:headers] || {}, name: cfg[:name],
                                           logger: logger)
+        when 'http'
+          configs << MCPClient.http_config(base_url: cfg[:url], endpoint: cfg[:endpoint],
+                                           headers: cfg[:headers] || {}, name: cfg[:name], logger: logger)
+        when 'streamable_http'
+          configs << MCPClient.streamable_http_config(base_url: cfg[:url], endpoint: cfg[:endpoint],
+                                                      headers: cfg[:headers] || {}, name: cfg[:name], logger: logger)
         end
       end
     end
@@ -90,4 +98,55 @@ module MCPClient
       logger: logger
     }
   end
+
+  # Create a standard server configuration for HTTP
+  # @param base_url [String] base URL for the server
+  # @param endpoint [String] JSON-RPC endpoint path (default: '/rpc')
+  # @param headers [Hash] HTTP headers to include in requests
+  # @param read_timeout [Integer] read timeout in seconds (default: 30)
+  # @param retries [Integer] number of retry attempts (default: 3)
+  # @param retry_backoff [Integer] backoff delay in seconds (default: 1)
+  # @param name [String, nil] optional name for this server
+  # @param logger [Logger, nil] optional logger for server operations
+  # @return [Hash] server configuration
+  def self.http_config(base_url:, endpoint: '/rpc', headers: {}, read_timeout: 30, retries: 3, retry_backoff: 1,
+                       name: nil, logger: nil)
+    {
+      type: 'http',
+      base_url: base_url,
+      endpoint: endpoint,
+      headers: headers,
+      read_timeout: read_timeout,
+      retries: retries,
+      retry_backoff: retry_backoff,
+      name: name,
+      logger: logger
+    }
+  end
+
+  # Create configuration for Streamable HTTP transport
+  # This transport uses HTTP POST requests but expects Server-Sent Event formatted responses
+  # @param base_url [String] Base URL of the MCP server
+  # @param endpoint [String] JSON-RPC endpoint path (default: '/rpc')
+  # @param headers [Hash] Additional headers to include in requests
+  # @param read_timeout [Integer] Read timeout in seconds (default: 30)
+  # @param retries [Integer] Number of retry attempts on transient errors (default: 3)
+  # @param retry_backoff [Integer] Backoff delay in seconds (default: 1)
+  # @param name [String, nil] Optional name for this server
+  # @param logger [Logger, nil] Optional logger for server operations
+  # @return [Hash] server configuration
+  def self.streamable_http_config(base_url:, endpoint: '/rpc', headers: {}, read_timeout: 30, retries: 3,
+                                  retry_backoff: 1, name: nil, logger: nil)
+    {
+      type: 'streamable_http',
+      base_url: base_url,
+      endpoint: endpoint,
+      headers: headers,
+      read_timeout: read_timeout,
+      retries: retries,
+      retry_backoff: retry_backoff,
+      name: name,
+      logger: logger
+    }
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mcp-client
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.1
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-20 00:00:00.000000000 Z
+date: 2025-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -105,18 +105,26 @@ files:
 - LICENSE
 - README.md
 - lib/mcp_client.rb
+- lib/mcp_client/auth.rb
+- lib/mcp_client/auth/oauth_provider.rb
 - lib/mcp_client/client.rb
 - lib/mcp_client/config_parser.rb
 - lib/mcp_client/errors.rb
+- lib/mcp_client/http_transport_base.rb
 - lib/mcp_client/json_rpc_common.rb
+- lib/mcp_client/oauth_client.rb
 - lib/mcp_client/server_base.rb
 - lib/mcp_client/server_factory.rb
+- lib/mcp_client/server_http.rb
+- lib/mcp_client/server_http/json_rpc_transport.rb
 - lib/mcp_client/server_sse.rb
 - lib/mcp_client/server_sse/json_rpc_transport.rb
 - lib/mcp_client/server_sse/reconnect_monitor.rb
 - lib/mcp_client/server_sse/sse_parser.rb
 - lib/mcp_client/server_stdio.rb
 - lib/mcp_client/server_stdio/json_rpc_transport.rb
+- lib/mcp_client/server_streamable_http.rb
+- lib/mcp_client/server_streamable_http/json_rpc_transport.rb
 - lib/mcp_client/tool.rb
 - lib/mcp_client/version.rb
 homepage: https://github.com/simonx1/ruby-mcp-client