ruby-mcp-client 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16280a305c2b9cd19ecc2a71b8f10d3805644015f34f7eaec28d5846f12fa1db
-  data.tar.gz: 48a791c3a88255c25078234819024dace993f7cfc564485f48680a8768b81238
+  metadata.gz: 2ec468ae4d2033287bfc89a788e87acc878ab833552e98bef88c95176fa6a906
+  data.tar.gz: d6f2f676be6932d8dbe641df40674aa77ef64d1296d9fdf4eb7c892537f2fa0c
 SHA512:
-  metadata.gz: d4155463bcc691725b3a88e29dbb7df75a5b05a9ca7693d12a4fcc6f43bb57df06966089042dcaebb6f9f0a3b429a1eaa3138bb478ad161aad98163eb6de2763
-  data.tar.gz: 6acb25bd0f1c72d640570823c262f548bda1f09322c137789ad36d5950dc80eda6d66e707b0c69229805ffdb575aea086ae999747d74aef9304ad65c46e67039
+  metadata.gz: 49f5427d6ffc9bc5632bed9b56e4c03e70ce4894d087331f12fd340b60ce82a539b9b2a362c1ce8d0b9686d9d9a4dae4bea3d11ec732b8a0ae34a3e898ff43b2
+  data.tar.gz: 3e32823ef422661fbcf507caf141d0ce65aedd0661ecb54f3b2a287565b630049d2acdfc4bb7b9a93a965e75403b635e43eb21259f035d8b82810f58e0fff304

data/README.md

@@ -36,6 +36,7 @@ with popular AI services with built-in conversions:
 
 - `to_openai_tools()` - Formats tools for OpenAI API
 - `to_anthropic_tools()` - Formats tools for Anthropic Claude API
+- `to_google_tools()` - Formats tools for Google Vertex AI API (automatically removes "$schema" keys not accepted by Vertex AI)
 
 ## Usage
 
@@ -53,6 +54,8 @@ client = MCPClient.create_client(
       base_url: 'https://api.example.com/sse',
       headers: { 'Authorization' => 'Bearer YOUR_TOKEN' },
       read_timeout: 30, # Optional timeout in seconds (default: 30)
+      ping: 10,         # Optional ping interval in seconds of inactivity (default: 10)
+                        # Connection closes automatically after inactivity (2.5x ping interval)
       retries: 3,       # Optional number of retry attempts (default: 0)
       retry_backoff: 1  # Optional backoff delay in seconds (default: 1)
       # Native support for tool streaming via call_tool_streaming method
@@ -98,6 +101,7 @@ end
 # Format tools for specific AI services
 openai_tools = client.to_openai_tools
 anthropic_tools = client.to_anthropic_tools
+google_tools = client.to_google_tools
 
 # Register for server notifications
 client.on_notification do |server, method, params|
@@ -139,7 +143,10 @@ sse_client = MCPClient.create_client(
   mcp_server_configs: [
     MCPClient.sse_config(
       base_url: 'http://localhost:8931/sse',
-      read_timeout: 30,  # Timeout in seconds
+      read_timeout: 30,  # Timeout in seconds for request fulfillment
+      ping: 10,          # Send ping after 10 seconds of inactivity
+                         # Connection closes automatically after inactivity (2.5x ping interval)
+      retries: 2         # Number of retry attempts on transient errors
     )
   ]
 )
@@ -262,6 +269,7 @@ Complete examples can be found in the `examples/` directory:
 - `ruby_openai_mcp.rb` - Integration with alexrudall/ruby-openai gem
 - `openai_ruby_mcp.rb` - Integration with official openai/openai-ruby gem
 - `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
 
 ## MCP Server Compatibility
@@ -298,7 +306,7 @@ You can define MCP server configurations in JSON files for easier management:
 }
 ```
 
-A simpler example used in the Playwright demo (found in `examples/playwright_server_definition.json`):
+A simpler example used in the Playwright demo (found in `examples/sample_server_definition.json`):
 
 ```json
 {
@@ -349,6 +357,11 @@ Special configuration options:
 The SSE client implementation provides these key features:
 
 - **Robust connection handling**: Properly manages HTTP/HTTPS connections with configurable timeouts and retries
+- **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)
+  - **Automatic disconnection**: Closes idle connections after inactivity (2.5× ping interval)
+  - **MCP compliant**: Any server communication resets the inactivity timer per specification
 - **Thread safety**: All operations are thread-safe using monitors and synchronized access
 - **Reliable error handling**: Comprehensive error handling for network issues, timeouts, and malformed responses
 - **JSON-RPC over SSE**: Full implementation of JSON-RPC 2.0 over SSE transport with initialize handshake
@@ -411,4 +424,4 @@ This gem is available as open source under the [MIT License](LICENSE).
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at
-https://github.com/simonx1/ruby-mcp-client.
+https://github.com/simonx1/ruby-mcp-client.

data/lib/mcp_client/client.rb

@@ -94,6 +94,12 @@ module MCPClient
       tools.map(&:to_anthropic_tool)
     end
 
+    def to_google_tools(tool_names: nil)
+      tools = list_tools
+      tools = tools.select { |t| tool_names.include?(t.name) } if tool_names
+      tools.map(&:to_google_tool)
+    end
+
     # Clean up all server connections
     def cleanup
       servers.each(&:cleanup)

data/lib/mcp_client/server_factory.rb

@@ -21,6 +21,7 @@ module MCPClient
           base_url: config[:base_url],
           headers: config[:headers] || {},
           read_timeout: config[:read_timeout] || 30,
+          ping: config[:ping] || 10,
           retries: config[:retries] || 0,
           retry_backoff: config[:retry_backoff] || 1,
           logger: config[:logger]

data/lib/mcp_client/server_sse.rb

@@ -11,15 +11,20 @@ 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
+    # Ratio of close_after timeout to ping interval
+    CLOSE_AFTER_PING_RATIO = 2.5
+
     attr_reader :base_url, :tools, :server_info, :capabilities
 
     # @param base_url [String] The base URL of the MCP server
     # @param headers [Hash] Additional headers to include in requests
     # @param read_timeout [Integer] Read timeout in seconds (default: 30)
+    # @param ping [Integer] Time in seconds after which to send ping if no activity (default: 10)
     # @param retries [Integer] number of retry attempts on transient errors
     # @param retry_backoff [Numeric] base delay in seconds for exponential backoff
     # @param logger [Logger, nil] optional logger
-    def initialize(base_url:, headers: {}, read_timeout: 30, retries: 0, retry_backoff: 1, logger: nil)
+    def initialize(base_url:, headers: {}, read_timeout: 30, ping: 10,
+                   retries: 0, retry_backoff: 1, logger: nil)
       super()
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
       @logger.progname = self.class.name
@@ -36,6 +41,9 @@ module MCPClient
       # HTTP client is managed via Faraday
       @tools = nil
       @read_timeout = read_timeout
+      @ping_interval = ping
+      # Set close_after to a multiple of the ping interval
+      @close_after = (ping * CLOSE_AFTER_PING_RATIO).to_i
 
       # SSE-provided JSON-RPC endpoint path for POST requests
       @rpc_endpoint = nil
@@ -48,8 +56,13 @@ module MCPClient
       @connection_established = false
       @connection_cv = @mutex.new_cond
       @initialized = false
+      @auth_error = nil
       # Whether to use SSE transport; may disable if handshake fails
       @use_sse = true
+
+      # Time of last activity
+      @last_activity_time = Time.now
+      @activity_timer_thread = nil
     end
 
     # Stream tool call fallback for SSE transport (yields single result)
@@ -131,25 +144,31 @@ module MCPClient
     # @return [Boolean] true if connection was successful
     # @raise [MCPClient::Errors::ConnectionError] if connection fails
     def connect
-      @mutex.synchronize do
-        return true if @connection_established
+      return true if @mutex.synchronize { @connection_established }
 
-        # Start SSE listener using Faraday HTTP client
+      begin
         start_sse_thread
+        effective_timeout = [@read_timeout || 30, 30].min
+        wait_for_connection(timeout: effective_timeout)
+        start_activity_monitor
+        true
+      rescue MCPClient::Errors::ConnectionError => e
+        cleanup
+        # Check for stored auth error first, as it's more specific
+        auth_error = @mutex.synchronize { @auth_error }
+        raise MCPClient::Errors::ConnectionError, auth_error if auth_error
+
+        raise MCPClient::Errors::ConnectionError, e.message if e.message.include?('Authorization failed')
+
+        raise MCPClient::Errors::ConnectionError, "Failed to connect to MCP server at #{@base_url}: #{e.message}"
+      rescue StandardError => e
+        cleanup
+        # Check for stored auth error
+        auth_error = @mutex.synchronize { @auth_error }
+        raise MCPClient::Errors::ConnectionError, auth_error if auth_error
 
-        timeout = 10
-        success = @connection_cv.wait(timeout) { @connection_established }
-
-        unless success
-          cleanup
-          raise MCPClient::Errors::ConnectionError, 'Timed out waiting for SSE connection to be established'
-        end
-
-        @connection_established
+        raise MCPClient::Errors::ConnectionError, "Failed to connect to MCP server at #{@base_url}: #{e.message}"
       end
-    rescue StandardError => e
-      cleanup
-      raise MCPClient::Errors::ConnectionError, "Failed to connect to MCP server at #{@base_url}: #{e.message}"
     end
 
     # Clean up the server connection
@@ -163,6 +182,13 @@ module MCPClient
         end
         @sse_thread = nil
 
+        begin
+          @activity_timer_thread&.kill
+        rescue StandardError
+          nil
+        end
+        @activity_timer_thread = nil
+
         if @http_client
           @http_client.finish if @http_client.started?
           @http_client = nil
@@ -171,6 +197,7 @@ module MCPClient
         @tools = nil
         @connection_established = false
         @sse_connected = false
+        # Don't clear auth error as we need it for reporting the correct error
       end
     end
 
@@ -220,8 +247,75 @@ module MCPClient
       raise MCPClient::Errors::TransportError, "Failed to send notification: #{e.message}"
     end
 
+    # Ping the server to keep the connection alive
+    # @return [Hash] the result of the ping request
+    def ping
+      rpc_request('ping')
+    end
+
     private
 
+    # Start the activity monitor thread
+    # This thread monitors connection activity and:
+    # 1. Sends a ping if there's no activity for @ping_interval seconds
+    # 2. Closes the connection if there's no activity for @close_after seconds
+    def start_activity_monitor
+      return if @activity_timer_thread&.alive?
+
+      @mutex.synchronize { @last_activity_time = Time.now }
+
+      @activity_timer_thread = Thread.new do
+        loop do
+          sleep 1 # Check every second
+
+          last_activity = nil
+          @mutex.synchronize { last_activity = @last_activity_time }
+
+          time_since_activity = Time.now - last_activity
+
+          if @close_after && time_since_activity >= @close_after
+            @logger.info("Closing connection due to inactivity (#{time_since_activity.round(1)}s)")
+            cleanup
+            break
+          elsif @ping_interval && time_since_activity >= @ping_interval
+            begin
+              @logger.debug("Sending ping after #{time_since_activity.round(1)}s of inactivity")
+              ping
+              @mutex.synchronize { @last_activity_time = Time.now }
+            rescue StandardError => e
+              @logger.error("Error sending ping: #{e.message}")
+            end
+          end
+        end
+      rescue StandardError => e
+        @logger.error("Activity monitor error: #{e.message}")
+      end
+    end
+
+    # Record activity to reset the inactivity timer
+    def record_activity
+      @mutex.synchronize { @last_activity_time = Time.now }
+    end
+
+    # Wait for SSE connection to be established with periodic checks
+    # @param timeout [Integer] Maximum time to wait in seconds
+    # @raise [MCPClient::Errors::ConnectionError] if timeout expires
+    def wait_for_connection(timeout:)
+      @mutex.synchronize do
+        deadline = Time.now + timeout
+
+        until @connection_established
+          remaining = [1, deadline - Time.now].min
+          break if remaining <= 0 || @connection_cv.wait(remaining) { @connection_established }
+        end
+
+        unless @connection_established
+          cleanup
+          raise MCPClient::Errors::ConnectionError, 'Timed out waiting for SSE connection to be established'
+        end
+      end
+    end
+
     # Ensure SSE initialization handshake has been performed
     def ensure_initialized
       return if @initialized
@@ -253,34 +347,85 @@ module MCPClient
       @capabilities = result['capabilities'] if result.key?('capabilities')
     end
 
+    # Set up the SSE connection
+    # @param uri [URI] The parsed base URL
+    # @return [Faraday::Connection] The configured Faraday connection
+    def setup_sse_connection(uri)
+      sse_base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+
+      @sse_conn ||= Faraday.new(url: sse_base) do |f|
+        f.options.open_timeout = 10
+        f.options.timeout = nil
+        f.request :retry, max: @max_retries, interval: @retry_backoff, backoff_factor: 2
+        f.adapter Faraday.default_adapter
+      end
+
+      # Use response handling with status check
+      @sse_conn.builder.use Faraday::Response::RaiseError
+      @sse_conn
+    end
+
+    # Handle authorization errors from Faraday
+    # @param error [Faraday::Error] The authorization error
+    # @raise [MCPClient::Errors::ConnectionError] with appropriate message
+    def handle_sse_auth_error(error)
+      error_message = "Authorization failed: HTTP #{error.response[:status]}"
+      @logger.error(error_message)
+
+      @mutex.synchronize do
+        @auth_error = error_message
+        @connection_established = false
+        @connection_cv.broadcast
+      end
+      raise MCPClient::Errors::ConnectionError, error_message
+    end
+
+    # Reset connection state and signal waiting threads
+    def reset_connection_state
+      @mutex.synchronize do
+        @connection_established = false
+        @connection_cv.broadcast
+      end
+    end
+
     # Start the SSE thread to listen for events
     def start_sse_thread
       return if @sse_thread&.alive?
 
       @sse_thread = Thread.new do
         uri = URI.parse(@base_url)
-        sse_base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
         sse_path = uri.request_uri
+        conn = setup_sse_connection(uri)
 
-        @sse_conn ||= Faraday.new(url: sse_base) do |f|
-          f.options.open_timeout = 10
-          f.options.timeout = nil
-          f.adapter Faraday.default_adapter
+        # Reset connection state
+        @mutex.synchronize do
+          @sse_connected = false
+          @connection_established = false
         end
 
-        @sse_conn.get(sse_path) do |req|
-          @headers.each { |k, v| req.headers[k] = v }
-          req.options.on_data = proc do |chunk, _bytes|
-            @logger.debug("SSE chunk received: #{chunk.inspect}")
-            process_sse_chunk(chunk.dup)
+        begin
+          conn.get(sse_path) do |req|
+            @headers.each { |k, v| req.headers[k] = v }
+
+            req.options.on_data = proc do |chunk, _bytes|
+              process_sse_chunk(chunk.dup) if chunk && !chunk.empty?
+            end
           end
+        rescue Faraday::UnauthorizedError, Faraday::ForbiddenError => e
+          handle_sse_auth_error(e)
+        rescue Faraday::Error => e
+          @logger.error("Failed SSE connection: #{e.message}")
+          raise
         end
-      rescue StandardError
-        # On any SSE thread error, signal connection established to unblock connect
-        @mutex.synchronize do
-          @connection_established = true
-          @connection_cv.broadcast
-        end
+      rescue MCPClient::Errors::ConnectionError => e
+        # Re-raise connection errors to propagate them
+        # Signal connect method to stop waiting
+        reset_connection_state
+        raise e
+      rescue StandardError => e
+        @logger.error("SSE connection error: #{e.message}")
+        # Signal connect method to avoid deadlock
+        reset_connection_state
       ensure
         @mutex.synchronize { @sse_connected = false }
       end
@@ -290,18 +435,129 @@ module MCPClient
     # @param chunk [String] the chunk to process
     def process_sse_chunk(chunk)
       @logger.debug("Processing SSE chunk: #{chunk.inspect}")
-      local_buffer = nil
 
+      # Only record activity for real events
+      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'
+
+            @mutex.synchronize do
+              @auth_error = "Authorization failed: #{error_message}"
+
+              @connection_established = false
+              @connection_cv.broadcast
+            end
+
+            raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
+          end
+        rescue JSON::ParserError
+          # Not valid JSON, process normally
+        end
+      end
+
+      event_buffers = nil
       @mutex.synchronize do
         @buffer += chunk
 
+        # Extract all complete events from the buffer
+        event_buffers = []
         while (event_end = @buffer.index("\n\n"))
           event_data = @buffer.slice!(0, event_end + 2)
-          local_buffer = event_data
+          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) }
+    end
+
+    # Handle SSE endpoint event
+    # @param data [String] The endpoint path
+    def handle_endpoint_event(data)
+      @mutex.synchronize do
+        @rpc_endpoint = data
+        @sse_connected = true
+        @connection_established = true
+        @connection_cv.broadcast
+      end
+    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
+    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
+    end
+
+    # Handle authorization error in SSE message
+    # @param error_message [String] The error message from the server
+    def handle_sse_auth_error_message(error_message)
+      @mutex.synchronize do
+        @auth_error = "Authorization failed: #{error_message}"
+        @connection_established = false
+        @connection_cv.broadcast
+      end
+
+      raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
+    end
+
+    # Process error messages in SSE responses
+    # @param data [Hash] The parsed SSE message data
+    def process_error_in_message(data)
+      return unless data['error']
+
+      error_message = data['error']['message'] || 'Unknown server error'
+      error_code = data['error']['code']
+
+      # Handle unauthorized errors (close connection immediately)
+      handle_sse_auth_error_message(error_message) if authorization_error?(error_message, error_code)
+
+      @logger.error("Server error: #{error_message}")
+      true # Error was processed
+    end
+
+    # Process JSON-RPC notifications
+    # @param data [Hash] The parsed SSE message data
+    # @return [Boolean] True if a notification was processed
+    def process_notification(data)
+      return false unless data['method'] && !data.key?('id')
+
+      @notification_callback&.call(data['method'], data['params'])
+      true
+    end
+
+    # Process JSON-RPC responses
+    # @param data [Hash] The parsed SSE message data
+    # @return [Boolean] True if a response was processed
+    def process_response(data)
+      return false unless data['id']
+
+      @mutex.synchronize do
+        # Store tools data if present
+        @tools_data = data['result']['tools'] if data['result'] && data['result']['tools']
+
+        # Store response for the waiting request
+        if data['error']
+          @sse_results[data['id']] = {
+            'isError' => true,
+            'content' => [{ 'type' => 'text', 'text' => data['error'].to_json }]
+          }
+        elsif data['result']
+          @sse_results[data['id']] = data['result']
         end
       end
 
-      parse_and_handle_sse_event(local_buffer) if local_buffer
+      true
     end
 
     # Parse and handle an SSE event
@@ -312,38 +568,35 @@ module MCPClient
 
       case event[:event]
       when 'endpoint'
-        ep = event[:data]
-        @mutex.synchronize do
-          @rpc_endpoint = ep
-          @connection_established = true
-          @connection_cv.broadcast
-        end
+        handle_endpoint_event(event[:data])
+      when 'ping'
+        # Received ping event, no action needed
       when 'message'
-        begin
-          data = JSON.parse(event[:data])
-          # Dispatch JSON-RPC notifications (no id, has method)
-          if data['method'] && !data.key?('id')
-            @notification_callback&.call(data['method'], data['params'])
-            return
-          end
+        handle_message_event(event)
+      end
+    end
 
-          @mutex.synchronize do
-            @tools_data = data['result']['tools'] if data['result'] && data['result']['tools']
-
-            if data['id']
-              if data['error']
-                @sse_results[data['id']] = {
-                  'isError' => true,
-                  'content' => [{ 'type' => 'text', 'text' => data['error'].to_json }]
-                }
-              elsif data['result']
-                @sse_results[data['id']] = data['result']
-              end
-            end
-          end
-        rescue JSON::ParserError
-          nil
-        end
+    # Handle a message event from SSE
+    # @param event [Hash] The parsed SSE event
+    def handle_message_event(event)
+      return if event[:data].empty?
+
+      begin
+        data = JSON.parse(event[:data])
+
+        # Process the message in order of precedence
+        return if process_error_in_message(data)
+
+        return if process_notification(data)
+
+        process_response(data)
+      rescue MCPClient::Errors::ConnectionError
+        # Re-raise connection errors to propagate to the calling code
+        raise
+      rescue JSON::ParserError => e
+        @logger.warn("Failed to parse JSON from event data: #{e.message}")
+      rescue StandardError => e
+        @logger.error("Error processing SSE event: #{e.message}")
       end
     end
 
@@ -351,14 +604,19 @@ module MCPClient
     # @param event_data [String] the event data to parse
     # @return [Hash, nil] the parsed event, or nil if the event is invalid
     def parse_sse_event(event_data)
-      @logger.debug("Parsing SSE event data: #{event_data.inspect}")
       event = { event: 'message', data: '', id: nil }
       data_lines = []
+      has_content = false
 
       event_data.each_line do |line|
         line = line.chomp
         next if line.empty?
 
+        # Skip SSE comments (lines starting with colon)
+        next if line.start_with?(':')
+
+        has_content = true
+
         if line.start_with?('event:')
           event[:event] = line[6..].strip
         elsif line.start_with?('data:')
@@ -369,8 +627,9 @@ module MCPClient
       end
 
       event[:data] = data_lines.join("\n")
-      @logger.debug("Parsed SSE event: #{event.inspect}")
-      event[:data].empty? ? nil : event
+
+      # Return the event even if data is empty as long as we had non-comment content
+      has_content ? event : nil
     end
 
     # Request the tools list using JSON-RPC
@@ -431,6 +690,10 @@ module MCPClient
     # @return [Hash] the result of the request
     def send_jsonrpc_request(request)
       @logger.debug("Sending JSON-RPC request: #{request.to_json}")
+
+      # Record activity when sending a request
+      record_activity
+
       uri = URI.parse(@base_url)
       base = "#{uri.scheme}://#{uri.host}:#{uri.port}"
       rpc_ep = @mutex.synchronize { @rpc_endpoint }
@@ -455,6 +718,9 @@ module MCPClient
       end
       @logger.debug("Received JSON-RPC response: #{response.status} #{response.body}")
 
+      # Record activity when receiving a response
+      record_activity
+
       unless response.success?
         raise MCPClient::Errors::ServerError, "Server returned error: #{response.status} #{response.reason_phrase}"
       end
@@ -463,17 +729,32 @@ module MCPClient
         # Wait for result via SSE channel
         request_id = request[:id]
         start_time = Time.now
+        # Use the specified read_timeout for the overall operation
         timeout = @read_timeout || 10
+
+        # Check every 100ms for the result, with a total timeout from read_timeout
         loop do
           result = nil
           @mutex.synchronize do
             result = @sse_results.delete(request_id) if @sse_results.key?(request_id)
           end
-          return result if result
-          break if Time.now - start_time > timeout
 
+          if result
+            # Record activity when receiving a result
+            record_activity
+            return result
+          end
+
+          current_time = Time.now
+          time_elapsed = current_time - start_time
+
+          # If we've exceeded the timeout, raise an error
+          break if time_elapsed > timeout
+
+          # Sleep for a short time before checking again
           sleep 0.1
         end
+
         raise MCPClient::Errors::ToolCallError, "Timeout waiting for SSE result for request #{request_id}"
       else
         begin

data/lib/mcp_client/tool.rb

@@ -46,5 +46,33 @@ module MCPClient
         input_schema: @schema
       }
     end
+
+    def to_google_tool
+      {
+        name: @name,
+        description: @description,
+        parameters: cleaned_schema(@schema)
+      }
+    end
+
+    private
+
+    # Recursively remove "$schema" keys that are not accepted by Vertex AI
+    # @param obj [Object] schema element (Hash/Array/other)
+    # @return [Object] cleaned schema without "$schema" keys
+    def cleaned_schema(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), h|
+          next if k == '$schema'
+
+          h[k] = cleaned_schema(v)
+        end
+      when Array
+        obj.map { |v| cleaned_schema(v) }
+      else
+        obj
+      end
+    end
   end
 end

data/lib/mcp_client/version.rb

@@ -2,5 +2,5 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.5.1'
+  VERSION = '0.5.3'
 end

data/lib/mcp_client.rb

@@ -58,15 +58,17 @@ module MCPClient
   # @param base_url [String] base URL for the server
   # @param headers [Hash] HTTP headers to include in requests
   # @param read_timeout [Integer] read timeout in seconds (default: 30)
+  # @param ping [Integer] time in seconds after which to send ping if no activity (default: 10)
   # @param retries [Integer] number of retry attempts (default: 0)
   # @param retry_backoff [Integer] backoff delay in seconds (default: 1)
   # @return [Hash] server configuration
-  def self.sse_config(base_url:, headers: {}, read_timeout: 30, retries: 0, retry_backoff: 1)
+  def self.sse_config(base_url:, headers: {}, read_timeout: 30, ping: 10, retries: 0, retry_backoff: 1)
     {
       type: 'sse',
       base_url: base_url,
       headers: headers,
       read_timeout: read_timeout,
+      ping: ping,
       retries: retries,
       retry_backoff: retry_backoff
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mcp-client
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-26 00:00:00.000000000 Z
+date: 2025-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday