ruby-mcp-client 0.7.0 → 0.7.2

data/lib/mcp_client/server_http.rb

@@ -6,6 +6,7 @@ require 'monitor'
 require 'logger'
 require 'faraday'
 require 'faraday/retry'
+require 'faraday/follow_redirects'
 
 module MCPClient
   # Implementation of MCP server that communicates via HTTP requests/responses
@@ -37,22 +38,22 @@ module MCPClient
     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
+    # @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])
+      initialize_logger(opts[:logger])
+
+      @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)
@@ -73,23 +74,23 @@ module MCPClient
       end
 
       @base_url = build_base_url.call(uri)
-      @endpoint = if uri.path && !uri.path.empty? && uri.path != '/' && endpoint == '/rpc'
+      @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
-                    endpoint
+                    opts[:endpoint]
                   end
 
       # Set up headers for HTTP requests
-      @headers = headers.merge({
-                                 'Content-Type' => 'application/json',
-                                 'Accept' => 'application/json',
-                                 'User-Agent' => "ruby-mcp-client/#{MCPClient::VERSION}"
-                               })
+      @headers = opts[:headers].merge({
+                                        'Content-Type' => 'application/json',
+                                        'Accept' => 'application/json',
+                                        'User-Agent' => "ruby-mcp-client/#{MCPClient::VERSION}"
+                                      })
 
-      @read_timeout = read_timeout
+      @read_timeout = opts[:read_timeout]
       @tools = nil
       @tools_data = nil
       @request_id = 0
@@ -98,6 +99,7 @@ module MCPClient
       @initialized = false
       @http_conn = nil
       @session_id = nil
+      @oauth_provider = opts[:oauth_provider]
     end
 
     # Connect to the MCP server over HTTP
@@ -183,50 +185,34 @@ module MCPClient
       raise MCPClient::Errors::ToolCallError, "Error calling tool '#{tool_name}': #{e.message}"
     end
 
-    # Override send_http_request to handle session headers for MCP protocol
-    def send_http_request(request)
-      conn = http_connection
+    # Override apply_request_headers to add session headers for MCP protocol
+    def apply_request_headers(req, request)
+      super
 
-      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 session header if we have one (for non-initialize requests)
+      return unless @session_id && request['method'] != 'initialize'
 
-          req.body = request.to_json
-        end
+      req.headers['Mcp-Session-Id'] = @session_id
+      @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+    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
+    # 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?
 
-        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}"
+      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
 
@@ -273,6 +259,21 @@ module MCPClient
 
     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

data/lib/mcp_client/server_sse/json_rpc_transport.rb

@@ -70,6 +70,13 @@ module MCPClient
 
         @server_info = result['serverInfo']
         @capabilities = result['capabilities']
+
+        # Send initialized notification to acknowledge completion of initialization
+        initialized_notification = build_jsonrpc_notification('notifications/initialized', {})
+        post_json_rpc_request(initialized_notification)
+
+        # Small delay to ensure server processes the notification
+        sleep(0.1)
       end
 
       # Send a JSON-RPC request to the server and wait for result
@@ -133,6 +140,7 @@ module MCPClient
       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.response :follow_redirects, limit: 3
           f.options.open_timeout = @read_timeout
           f.options.timeout = @read_timeout
           f.adapter Faraday.default_adapter

data/lib/mcp_client/server_sse/reconnect_monitor.rb

@@ -191,6 +191,7 @@ module MCPClient
           f.options.open_timeout = 10
           f.options.timeout = nil
           f.request :retry, max: @max_retries, interval: @retry_backoff, backoff_factor: 2
+          f.response :follow_redirects, limit: 3
           f.adapter Faraday.default_adapter
         end
 

data/lib/mcp_client/server_sse/sse_parser.rb

@@ -31,9 +31,9 @@ module MCPClient
           data = JSON.parse(event[:data])
 
           return if process_error_in_message(data)
-          return if process_notification(data)
+          return if process_notification?(data)
 
-          process_response(data)
+          process_response?(data)
         rescue MCPClient::Errors::ConnectionError
           raise
         rescue JSON::ParserError => e
@@ -61,7 +61,7 @@ module MCPClient
       # 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)
+      def process_notification?(data)
         return false unless data['method'] && !data.key?('id')
 
         @notification_callback&.call(data['method'], data['params'])
@@ -71,7 +71,7 @@ module MCPClient
       # 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)
+      def process_response?(data)
         return false unless data['id']
 
         @mutex.synchronize do

data/lib/mcp_client/server_sse.rb

@@ -6,6 +6,7 @@ require 'monitor'
 require 'logger'
 require 'faraday'
 require 'faraday/retry'
+require 'faraday/follow_redirects'
 
 module MCPClient
   # Implementation of MCP server that communicates via Server-Sent Events (SSE)
@@ -56,13 +57,11 @@ module MCPClient
     def initialize(base_url:, headers: {}, read_timeout: 30, ping: 10,
                    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" }
+      initialize_logger(logger)
       @max_retries = retries
       @retry_backoff = retry_backoff
-      # Normalize base_url: strip any trailing slash, use exactly as provided
-      @base_url = base_url.chomp('/')
+      # Normalize base_url: preserve trailing slash if explicitly provided for SSE endpoints
+      @base_url = base_url
       @headers = headers.merge({
                                  'Accept' => 'text/event-stream',
                                  'Cache-Control' => 'no-cache',
@@ -369,53 +368,86 @@ module MCPClient
       record_activity if chunk.include?('event:')
 
       # Check for direct JSON error responses (which aren't proper SSE events)
-      if chunk.start_with?('{') && chunk.include?('"error"') &&
-         (chunk.include?('Unauthorized') || chunk.include?('authentication'))
-        begin
-          data = JSON.parse(chunk)
-          if data['error']
-            error_message = data['error']['message'] || 'Unknown server error'
+      handle_json_error_response(chunk)
+
+      event_buffers = extract_complete_events(chunk)
+
+      # Process extracted events outside the mutex to avoid deadlocks
+      event_buffers&.each { |event_data| parse_and_handle_sse_event(event_data) }
+    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)
 
-            @mutex.synchronize do
-              @auth_error = "Authorization failed: #{error_message}"
+      false
+    end
 
-              @connection_established = false
-              @connection_cv.broadcast
-            end
+    # Handle JSON error responses embedded in SSE chunks
+    # @param chunk [String] the chunk to check for JSON errors
+    # @return [void]
+    # @raise [MCPClient::Errors::ConnectionError] if authentication error is found
+    # @private
+    def handle_json_error_response(chunk)
+      return unless chunk.start_with?('{') && chunk.include?('"error"') &&
+                    (chunk.include?('Unauthorized') || chunk.include?('authentication'))
 
-            raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
+      begin
+        data = JSON.parse(chunk)
+        if data['error']
+          error_message = data['error']['message'] || 'Unknown server error'
+
+          @mutex.synchronize do
+            @auth_error = "Authorization failed: #{error_message}"
+            @connection_established = false
+            @connection_cv.broadcast
           end
-        rescue JSON::ParserError
-          # Not valid JSON, process normally
+
+          raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
         end
+      rescue JSON::ParserError
+        # Not valid JSON, process normally
       end
+    end
 
+    # Extract complete SSE events from the buffer
+    # @param chunk [String] the chunk to add to the buffer
+    # @return [Array<String>, nil] array of complete events or nil if none
+    # @private
+    def extract_complete_events(chunk)
       event_buffers = nil
       @mutex.synchronize do
         @buffer += chunk
 
         # Extract all complete events from the buffer
+        # Handle both Unix (\n\n) and Windows (\r\n\r\n) line endings
         event_buffers = []
-        while (event_end = @buffer.index("\n\n"))
-          event_data = @buffer.slice!(0, event_end + 2)
+        while (event_end = @buffer.index("\n\n") || @buffer.index("\r\n\r\n"))
+          event_data = extract_single_event(event_end)
           event_buffers << event_data
         end
       end
-
-      # Process extracted events outside the mutex to avoid deadlocks
-      event_buffers&.each { |event_data| parse_and_handle_sse_event(event_data) }
+      event_buffers
     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
+    # Extract a single event from the buffer
+    # @param event_end [Integer] the position where the event ends
+    # @return [String] the extracted event data
     # @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)
-
-      false
+    def extract_single_event(event_end)
+      # Determine the line ending style and extract accordingly
+      crlf_index = @buffer.index("\r\n\r\n")
+      lf_index = @buffer.index("\n\n")
+      if crlf_index && (lf_index.nil? || crlf_index < lf_index)
+        @buffer.slice!(0, event_end + 4) # \r\n\r\n is 4 chars
+      else
+        @buffer.slice!(0, event_end + 2) # \n\n is 2 chars
+      end
     end
 
     # Handle authorization error in SSE message

data/lib/mcp_client/server_stdio.rb

@@ -39,9 +39,7 @@ module MCPClient
       @next_id = 1
       @pending = {}
       @initialized = false
-      @logger = logger || Logger.new($stdout, level: Logger::WARN)
-      @logger.progname = self.class.name
-      @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
+      initialize_logger(logger)
       @max_retries   = retries
       @retry_backoff = retry_backoff
       @read_timeout  = read_timeout

data/lib/mcp_client/server_streamable_http.rb

@@ -6,6 +6,7 @@ require 'monitor'
 require 'logger'
 require 'faraday'
 require 'faraday/retry'
+require 'faraday/follow_redirects'
 
 module MCPClient
   # Implementation of MCP server that communicates via Streamable HTTP transport
@@ -37,22 +38,14 @@ module MCPClient
     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
+    # @param options [Hash] Server configuration options (same as ServerHTTP)
+    def initialize(base_url:, **options)
+      opts = default_options.merge(options)
+      super(name: opts[:name])
+      initialize_logger(opts[:logger])
+
+      @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)
@@ -73,25 +66,25 @@ module MCPClient
       end
 
       @base_url = build_base_url.call(uri)
-      @endpoint = if uri.path && !uri.path.empty? && uri.path != '/' && endpoint == '/rpc'
+      @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
-                    endpoint
+                    opts[: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
+      @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
@@ -101,6 +94,7 @@ module MCPClient
       @http_conn = nil
       @session_id = nil
       @last_event_id = nil
+      @oauth_provider = opts[:oauth_provider]
     end
 
     # Connect to the MCP server over Streamable HTTP
@@ -196,56 +190,40 @@ module MCPClient
       end
     end
 
-    # Override send_http_request to handle session headers for MCP protocol
-    def send_http_request(request)
-      conn = http_connection
+    # Override apply_request_headers to add session and SSE headers for MCP protocol
+    def apply_request_headers(req, request)
+      super
 
-      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 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
+      # Add Last-Event-ID header for resumability (if available)
+      return unless @last_event_id
 
-          req.body = request.to_json
-        end
+      req.headers['Last-Event-ID'] = @last_event_id
+      @logger.debug("Adding Last-Event-ID header: #{@last_event_id}")
+    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
+    # 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?
 
-        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}"
+      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
 
@@ -282,6 +260,21 @@ module MCPClient
 
     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

data/lib/mcp_client/version.rb

@@ -2,11 +2,8 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.7.0'
+  VERSION = '0.7.2'
 
-  # 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'
+  # MCP protocol version (date-based) - unified across all transports
+  PROTOCOL_VERSION = '2025-03-26'
 end

data/lib/mcp_client.rb

@@ -12,6 +12,8 @@ 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