ruby-mcp-client 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94f8597a5cddfa1f86b6e09401b652d2c7aa3bd4eefc8771712b7c03d99772a8
-  data.tar.gz: b303e3056719fea1a62cf4eeff76156e6e3ed68d134d48aa3ce969e8095d85be
+  metadata.gz: e71d5420a77345079ef2da077240e6a578900c3acfd2c16c904b0a2bf84a8bb7
+  data.tar.gz: ea4f41ebef3d5898d3dd0786d50d08dbbd19057bbbd5b7aa8cc046d5a1608d7c
 SHA512:
-  metadata.gz: da1d04e7aee8207ff32a2db24df14c2b832b8f5fd6acf36c6b8f22b86cf802d99de5514a608a6336f1973949a34a8829c8f71a5b2dadc68ebff50ed7d4d23bc7
-  data.tar.gz: e75630074326e81fddbc006f3bcd8b848c474792ac73c2e9f883722b49b0aeb2da31bb824263234599b279974c7c2445ce6d4d06766a0e447753e8060b248d8f
+  metadata.gz: a837ba7337913a453e5ae2567c67fed453b5e1cab3712705689c74b2efff27fa5c257750c834b5ac5bfff04333f08f1999b6813982d0c548ee92f4992c4d6aad
+  data.tar.gz: e10f2262b5dd10f0323dbbf870daa9f2d25d2d9f6a7f0c053870a8e0a5453ed9c5ed2c667211dfcf094c4fd56e7c12fbc1407c358e955fb14b4cbf4601312226

data/README.md

@@ -47,6 +47,8 @@ This Ruby MCP Client implements key features from the latest MCP specification (
 ### Implemented Features
 - **OAuth 2.1 Authorization Framework** - Complete authentication with PKCE, dynamic client registration, server discovery, and runtime configuration
 - **Streamable HTTP Transport** - Enhanced transport with Server-Sent Event formatted responses and session management
+- **HTTP Redirect Support** - Automatic redirect handling for both SSE and HTTP transports with configurable limits
+- **FastMCP Compatibility** - Full compatibility with FastMCP servers including proper line ending handling
 
 ## Usage
 
@@ -333,6 +335,48 @@ sse_client.cleanup
 
 See `examples/mcp_sse_server_example.rb` for the full Playwright SSE example.
 
+### FastMCP Example
+
+The repository includes a complete FastMCP server example that demonstrates the Ruby MCP client working with a Python FastMCP server:
+
+```ruby
+# Start the FastMCP server
+# python examples/echo_server.py
+
+# Run the Ruby client
+# bundle exec ruby examples/echo_server_client.rb
+
+require 'mcp_client'
+
+# Connect to FastMCP server
+client = MCPClient.create_client(
+  mcp_server_configs: [
+    MCPClient.sse_config(
+      base_url: 'http://127.0.0.1:8000/sse/',
+      read_timeout: 30
+    )
+  ]
+)
+
+# List available tools
+tools = client.list_tools
+puts "Found #{tools.length} tools:"
+tools.each { |tool| puts "- #{tool.name}: #{tool.description}" }
+
+# Use the tools
+result = client.call_tool('echo', { message: 'Hello from Ruby!' })
+result = client.call_tool('reverse', { text: 'FastMCP rocks!' })
+
+client.cleanup
+```
+
+The FastMCP example includes:
+- **`echo_server.py`** - A Python FastMCP server with 4 interactive tools
+- **`echo_server_client.rb`** - Ruby client demonstrating all features
+- **`README_ECHO_SERVER.md`** - Complete setup and usage instructions
+
+This example showcases redirect support, proper line ending handling, and seamless integration between Ruby and Python MCP implementations.
+
 ### Integration Examples
 
 The repository includes examples for integrating with popular AI APIs:
@@ -421,6 +465,7 @@ Complete examples can be found in the `examples/` directory:
 - `ruby_anthropic_mcp.rb` - Integration with alexrudall/ruby-anthropic gem
 - `gemini_ai_mcp.rb` - Integration with Google Vertex AI and Gemini models
 - `mcp_sse_server_example.rb` - SSE transport with Playwright MCP
+- `echo_server.py` & `echo_server_client.rb` - FastMCP server example with full setup
 
 ## MCP Server Compatibility
 
@@ -428,6 +473,7 @@ This client works with any MCP-compatible server, including:
 
 - [@modelcontextprotocol/server-filesystem](https://www.npmjs.com/package/@modelcontextprotocol/server-filesystem) - File system access
 - [@playwright/mcp](https://www.npmjs.com/package/@playwright/mcp) - Browser automation
+- [FastMCP](https://github.com/jlowin/fastmcp) - Python framework for building MCP servers
 - Custom servers implementing the MCP protocol
 
 ### Server Definition Files
@@ -645,6 +691,7 @@ For complete OAuth documentation, see [OAUTH.md](OAUTH.md).
 The SSE client implementation provides these key features:
 
 - **Robust connection handling**: Properly manages HTTP/HTTPS connections with configurable timeouts and retries
+- **Automatic redirect support**: Follows HTTP redirects up to 3 hops for seamless server integration
 - **Advanced connection management**:
   - **Inactivity tracking**: Monitors connection activity to detect idle connections
   - **Automatic ping**: Sends ping requests after a configurable period of inactivity (default: 10 seconds)
@@ -674,6 +721,7 @@ The SSE client implementation provides these key features:
 The HTTP transport provides a simpler, stateless communication mechanism for MCP servers:
 
 - **Request/Response Model**: Standard HTTP request/response cycle for each JSON-RPC call
+- **Automatic redirect support**: Follows HTTP redirects up to 3 hops for seamless server integration
 - **JSON-Only Responses**: Accepts only `application/json` responses (no SSE support)
 - **Session Support**: Automatic session header (`Mcp-Session-Id`) capture and injection for session-based MCP servers
 - **Session Termination**: Proper session cleanup with HTTP DELETE requests during connection teardown

data/lib/mcp_client/config_parser.rb

@@ -27,7 +27,7 @@ module MCPClient
 
       result = {}
       servers_data.each do |server_name, config|
-        next unless validate_server_config(config, server_name)
+        next unless valid_server_config?(config, server_name)
 
         server_config = process_server_config(config, server_name)
         next unless server_config
@@ -66,7 +66,7 @@ module MCPClient
     # @param config [Object] server configuration to validate
     # @param server_name [String] name of the server
     # @return [Boolean] true if valid, false otherwise
-    def validate_server_config(config, server_name)
+    def valid_server_config?(config, server_name)
       return true if config.is_a?(Hash)
 
       @logger.warn("Configuration for server '#{server_name}' is not an object; skipping.")
@@ -86,11 +86,11 @@ module MCPClient
       when 'stdio'
         parse_stdio_config(clean, config, server_name)
       when 'sse'
-        return nil unless parse_sse_config(clean, config, server_name)
+        return nil unless parse_sse_config?(clean, config, server_name)
       when 'streamable_http'
-        return nil unless parse_streamable_http_config(clean, config, server_name)
+        return nil unless parse_streamable_http_config?(clean, config, server_name)
       when 'http'
-        return nil unless parse_http_config(clean, config, server_name)
+        return nil unless parse_http_config?(clean, config, server_name)
       else
         @logger.warn("Unrecognized type '#{type}' for server '#{server_name}'; skipping.")
         return nil
@@ -164,7 +164,7 @@ module MCPClient
     # @param config [Hash] raw configuration from JSON
     # @param server_name [String] name of the server for error reporting
     # @return [Boolean] true if parsing succeeded, false if required elements are missing
-    def parse_sse_config(clean, config, server_name)
+    def parse_sse_config?(clean, config, server_name)
       # URL is required
       source = config['url']
       unless source
@@ -192,7 +192,7 @@ module MCPClient
     # @param config [Hash] raw configuration from JSON
     # @param server_name [String] name of the server for error reporting
     # @return [Boolean] true if parsing succeeded, false if required elements are missing
-    def parse_streamable_http_config(clean, config, server_name)
+    def parse_streamable_http_config?(clean, config, server_name)
       # URL is required
       source = config['url']
       unless source
@@ -225,7 +225,7 @@ module MCPClient
     # @param config [Hash] raw configuration from JSON
     # @param server_name [String] name of the server for error reporting
     # @return [Boolean] true if parsing succeeded, false if required elements are missing
-    def parse_http_config(clean, config, server_name)
+    def parse_http_config?(clean, config, server_name)
       # URL is required
       source = config['url']
       unless source

data/lib/mcp_client/http_transport_base.rb

@@ -119,7 +119,7 @@ module MCPClient
     # @return [Hash] the initialization parameters
     def initialization_params
       {
-        'protocolVersion' => MCPClient::HTTP_PROTOCOL_VERSION,
+        'protocolVersion' => MCPClient::PROTOCOL_VERSION,
         'capabilities' => {},
         'clientInfo' => { 'name' => 'ruby-mcp-client', 'version' => MCPClient::VERSION }
       }

data/lib/mcp_client/server_base.rb

@@ -77,5 +77,23 @@ module MCPClient
     def on_notification(&block)
       @notification_callback = block
     end
+
+    protected
+
+    # Initialize logger with proper formatter handling
+    # Preserves custom formatter if logger is provided, otherwise sets a default formatter
+    # @param logger [Logger, nil] custom logger to use, or nil to create a default one
+    # @return [Logger] the configured logger
+    def initialize_logger(logger)
+      if logger
+        @logger = logger
+        @logger.progname = self.class.name
+      else
+        @logger = Logger.new($stdout, level: Logger::WARN)
+        @logger.progname = self.class.name
+        @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
+      end
+      @logger
+    end
   end
 end

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
@@ -49,9 +50,7 @@ module MCPClient
     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" }
+      initialize_logger(opts[:logger])
 
       @max_retries = opts[:retries]
       @retry_backoff = opts[:retry_backoff]

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
@@ -41,9 +42,7 @@ module MCPClient
     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" }
+      initialize_logger(opts[:logger])
 
       @max_retries = opts[:retries]
       @retry_backoff = opts[:retry_backoff]

data/lib/mcp_client/version.rb

@@ -2,11 +2,8 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.7.1'
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mcp-client
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-20 00:00:00.000000000 Z
+date: 2025-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: faraday-retry
   requirement: !ruby/object:Gem::Requirement