ruby-mcp-client 0.6.2 → 0.7.0

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

data/lib/mcp_client/server_streamable_http.rb

@@ -0,0 +1,338 @@
+# 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 endpoint [String] The 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 [Numeric] base delay in seconds for exponential backoff (default: 1)
+    # @param name [String, nil] optional name for this server
+    # @param logger [Logger, nil] optional logger
+    def initialize(base_url:, endpoint: '/rpc', headers: {}, read_timeout: DEFAULT_READ_TIMEOUT,
+                   retries: DEFAULT_MAX_RETRIES, 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" }
+
+      @max_retries = retries
+      @retry_backoff = 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 != '/' && 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
+                    endpoint
+                  end
+
+      # Set up headers for Streamable HTTP requests
+      @headers = 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 = 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
+    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 send_http_request to handle session headers for MCP protocol
+    def send_http_request(request)
+      conn = http_connection
+
+      begin
+        response = conn.post(@endpoint) do |req|
+          # Apply all headers including custom ones
+          @headers.each { |k, v| req.headers[k] = v }
+
+          # 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)
+          if @last_event_id
+            req.headers['Last-Event-ID'] = @last_event_id
+            @logger.debug("Adding Last-Event-ID header: #{@last_event_id}")
+          end
+
+          req.body = request.to_json
+        end
+
+        handle_http_error_response(response) unless response.success?
+
+        # Capture session ID from initialize response with validation
+        if 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
+
+        log_response(response)
+        response
+      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::ConnectionFailed => e
+        raise MCPClient::Errors::ConnectionError, "Server connection lost: #{e.message}"
+      rescue Faraday::Error => e
+        raise MCPClient::Errors::TransportError, "HTTP request failed: #{e.message}"
+      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
+
+    # 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.0'
 
   # 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,6 +6,8 @@ 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'
@@ -33,7 +35,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 +43,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 +96,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.0
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-20 00:00:00.000000000 Z
+date: 2025-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -108,15 +108,20 @@ files:
 - 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/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