ruby-mcp-client 0.5.3 → 0.6.0

data/lib/mcp_client/server_stdio.rb

@@ -17,9 +17,10 @@ module MCPClient
     # @param retries [Integer] number of retry attempts on transient errors
     # @param retry_backoff [Numeric] base delay in seconds for exponential backoff
     # @param read_timeout [Numeric] timeout in seconds for reading responses
+    # @param name [String, nil] optional name for this server
     # @param logger [Logger, nil] optional logger
-    def initialize(command:, retries: 0, retry_backoff: 1, read_timeout: READ_TIMEOUT, logger: nil)
-      super()
+    def initialize(command:, retries: 0, retry_backoff: 1, read_timeout: READ_TIMEOUT, name: nil, logger: nil)
+      super(name: name)
       @command = command.is_a?(Array) ? command.join(' ') : command
       @mutex = Mutex.new
       @cond = ConditionVariable.new
@@ -93,7 +94,7 @@ module MCPClient
         raise MCPClient::Errors::ServerError, err['message']
       end
 
-      (res.dig('result', 'tools') || []).map { |td| MCPClient::Tool.from_json(td) }
+      (res.dig('result', 'tools') || []).map { |td| MCPClient::Tool.from_json(td, server: self) }
     rescue StandardError => e
       raise MCPClient::Errors::ToolCallError, "Error listing tools: #{e.message}"
     end

data/lib/mcp_client/tool.rb

@@ -3,24 +3,40 @@
 module MCPClient
   # Representation of an MCP tool
   class Tool
-    attr_reader :name, :description, :schema
+    # @!attribute [r] name
+    #   @return [String] the name of the tool
+    # @!attribute [r] description
+    #   @return [String] the description of the tool
+    # @!attribute [r] schema
+    #   @return [Hash] the JSON schema for the tool
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this tool belongs to
+    attr_reader :name, :description, :schema, :server
 
-    def initialize(name:, description:, schema:)
+    # Initialize a new Tool
+    # @param name [String] the name of the tool
+    # @param description [String] the description of the tool
+    # @param schema [Hash] the JSON schema for the tool
+    # @param server [MCPClient::ServerBase, nil] the server this tool belongs to
+    def initialize(name:, description:, schema:, server: nil)
       @name = name
       @description = description
       @schema = schema
+      @server = server
     end
 
     # Create a Tool instance from JSON data
     # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this tool belongs to
     # @return [MCPClient::Tool] tool instance
-    def self.from_json(data)
+    def self.from_json(data, server: nil)
       # Some servers (Playwright MCP CLI) use 'inputSchema' instead of 'schema'
       schema = data['inputSchema'] || data['schema']
       new(
         name: data['name'],
         description: data['description'],
-        schema: schema
+        schema: schema,
+        server: server
       )
     end
 
@@ -47,6 +63,8 @@ module MCPClient
       }
     end
 
+    # Convert tool to Google Vertex AI tool specification format
+    # @return [Hash] Google Vertex AI tool specification with cleaned schema
     def to_google_tool
       {
         name: @name,

data/lib/mcp_client/version.rb

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

data/lib/mcp_client.rb

@@ -19,38 +19,44 @@ module MCPClient
   # @param mcp_server_configs [Array<Hash>] configurations for MCP servers
   # @param server_definition_file [String, nil] optional path to a JSON file defining server configurations
   #   The JSON may be a single server object or an array of server objects.
+  # @param logger [Logger, nil] optional logger for client operations
   # @return [MCPClient::Client] new client instance
-  def self.create_client(mcp_server_configs: [], server_definition_file: nil)
+  def self.create_client(mcp_server_configs: [], server_definition_file: nil, logger: nil)
     require 'json'
     # Start with any explicit configs provided
     configs = Array(mcp_server_configs)
     # Load additional configs from a JSON file if specified
     if server_definition_file
       # Parse JSON definitions into clean config hashes
-      parser = MCPClient::ConfigParser.new(server_definition_file)
+      parser = MCPClient::ConfigParser.new(server_definition_file, logger: logger)
       parsed = parser.parse
       parsed.each_value do |cfg|
         case cfg[:type].to_s
         when 'stdio'
           # Build command list with args
           cmd_list = [cfg[:command]] + Array(cfg[:args])
-          configs << MCPClient.stdio_config(command: cmd_list)
+          configs << MCPClient.stdio_config(command: cmd_list, name: cfg[:name], logger: logger)
         when 'sse'
           # Use 'url' from parsed config as 'base_url' for SSE config
-          configs << MCPClient.sse_config(base_url: cfg[:url], headers: cfg[:headers] || {})
+          configs << MCPClient.sse_config(base_url: cfg[:url], headers: cfg[:headers] || {}, name: cfg[:name],
+                                          logger: logger)
         end
       end
     end
-    MCPClient::Client.new(mcp_server_configs: configs)
+    MCPClient::Client.new(mcp_server_configs: configs, logger: logger)
   end
 
   # Create a standard server configuration for stdio
   # @param command [String, Array<String>] command to execute
+  # @param name [String, nil] optional name for this server
+  # @param logger [Logger, nil] optional logger for server operations
   # @return [Hash] server configuration
-  def self.stdio_config(command:)
+  def self.stdio_config(command:, name: nil, logger: nil)
     {
       type: 'stdio',
-      command: command
+      command: command,
+      name: name,
+      logger: logger
     }
   end
 
@@ -61,8 +67,11 @@ module MCPClient
   # @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)
+  # @param name [String, nil] optional name for this server
+  # @param logger [Logger, nil] optional logger for server operations
   # @return [Hash] server configuration
-  def self.sse_config(base_url:, headers: {}, read_timeout: 30, ping: 10, retries: 0, retry_backoff: 1)
+  def self.sse_config(base_url:, headers: {}, read_timeout: 30, ping: 10, retries: 0, retry_backoff: 1,
+                      name: nil, logger: nil)
     {
       type: 'sse',
       base_url: base_url,
@@ -70,7 +79,9 @@ module MCPClient
       read_timeout: read_timeout,
       ping: ping,
       retries: retries,
-      retry_backoff: retry_backoff
+      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.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-13 00:00:00.000000000 Z
+date: 2025-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday