remove version and Tools, make client a wrapper class

Author: jcat4

README.md

@@ -603,7 +603,7 @@ gem 'faraday', '>= 2.0'
 The `MCP::Client::Http` class provides a simple HTTP client for interacting with MCP servers:
 
 ```ruby
-client = MCP::Client::Http.new(url: "https://api.example.com/mcp")
+client = MCP::Client::HTTP.new(url: "https://api.example.com/mcp")
 
 # List available tools
 tools = client.tools
@@ -632,7 +632,7 @@ The HTTP client supports:
 By default, the HTTP client has no authentication, but it supports custom headers for authentication. For example, to use Bearer token authentication:
 
 ```ruby
-client = MCP::Client::Http.new(
+client = MCP::Client::HTTP.new(
   url: "https://api.example.com/mcp",
   headers: {
     "Authorization" => "Bearer my_token"
@@ -646,12 +646,11 @@ You can add any custom headers needed for your authentication scheme. The client
 
 ### Tool Objects
 
-The client provides wrapper objects for tools returned by the server:
+The client provides a wrapper class for tools returned by the server:
 
 - `MCP::Client::Tool` - Represents a single tool with its metadata
-- `MCP::Client::Tools` - Collection of tools with enumerable functionality
 
-These objects provide easy access to tool properties like name, description, and input schema.
+This class provide easy access to tool properties like name, description, and input schema.
 
 ## Releases
 

lib/mcp.rb

@@ -22,6 +22,9 @@
 require_relative "mcp/tool/annotations"
 require_relative "mcp/transport"
 require_relative "mcp/version"
+require_relative "mcp/client"
+require_relative "mcp/client/http"
+require_relative "mcp/client/tool"
 
 module MCP
   class << self

lib/mcp/client.rb

@@ -1,12 +1,58 @@
 # frozen_string_literal: true
 
-# require "json_rpc_handler"
-# require_relative "shared/instrumentation"
-# require_relative "shared/methods"
-
 module MCP
-  module Client
-    # Can be made an abstract class if we need shared behavior
+  class Client
+    # Initializes a new MCP::Client instance.
+    #
+    # @param transport [Object] The transport object to use for communication with the server.
+    #   The transport should be a duck type that responds to both `#tools` and `#call_tool`.
+    #   This allows the client to list available tools and invoke tool calls via the transport.
+    #
+    # @example
+    #   transport = MCP::Client::HTTP.new(url: "http://localhost:3000")
+    #   client = MCP::Client.new(transport: transport)
+    #
+    # @note
+    #   The transport does not need to be a specific class, but must implement:
+    #     - #tools
+    #     - #call_tool(tool:, input:)
+    def initialize(transport:)
+      @transport = transport
+    end
+
+    # The user may want to access additional transport-specific methods/attributes
+    # So keeping it public
+    attr_reader :transport
+
+    # Returns the list of tools available from the server.
+    #
+    # @return [Array<MCP::Client::Tool>] An array of available tools.
+    #
+    # @example
+    #   tools = client.tools
+    #   tools.each do |tool|
+    #     puts tool.name
+    #   end
+    def tools
+      @tools ||= transport.tools
+    end
+
+    # Calls a tool via the transport layer.
+    #
+    # @param tool [MCP::Client::Tool] The tool to be called.
+    # @param input [Object, nil] The input to pass to the tool.
+    # @return [Object] The result of the tool call, as returned by the transport.
+    #
+    # @example
+    #   tool = client.tools.first
+    #   result = client.call_tool(tool: tool, input: { foo: "bar" })
+    #
+    # @note
+    #   The exact requirements for `input` are determined by the transport layer in use.
+    #   Consult the documentation for your transport (e.g., MCP::Client::HTTP) for details.
+    def call_tool(tool:, input: nil)
+      transport.call_tool(tool: tool, input: input)
+    end
 
     class RequestHandlerError < StandardError
       attr_reader :error_type, :original_error, :request

lib/mcp/client/http.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
 module MCP
-  module Client
-    class Http
-      DEFAULT_VERSION = "0.1.0"
+  class Client
+    class HTTP
+      attr_reader :url
 
-      attr_reader :url, :version
-
-      def initialize(url:, version: DEFAULT_VERSION, headers: {})
+      def initialize(url:, headers: {})
         @url = url
-        @version = version
         @headers = headers
       end
 
       def tools
         response = send_request(method: "tools/list").body
 
-        ::MCP::Client::Tools.new(response)
+        response.dig("result", "tools")&.map do |tool|
+          Tool.new(
+            name: tool["name"],
+            description: tool["description"],
+            input_schema: tool["inputSchema"],
+          )
+        end || []
       end
 
       def call_tool(tool:, input:)

lib/mcp/client/tool.rb

@@ -2,24 +2,14 @@
 # frozen_string_literal: true
 
 module MCP
-  module Client
+  class Client
     class Tool
-      attr_reader :payload
+      attr_reader :name, :description, :input_schema
 
-      def initialize(payload)
-        @payload = payload
-      end
-
-      def name
-        payload["name"]
-      end
-
-      def description
-        payload["description"]
-      end
-
-      def input_schema
-        payload["inputSchema"]
+      def initialize(name:, description:, input_schema:)
+        @name = name
+        @description = description
+        @input_schema = input_schema
       end
     end
   end

lib/mcp/client/tools.rb

@@ -6,28 +6,27 @@
 require "webmock/minitest"
 require "mcp/client/http"
 require "mcp/client/tool"
-require "mcp/client/tools"
 require "mcp/client"
 
 module MCP
-  module Client
-    class HttpTest < Minitest::Test
-      def test_initialization_with_default_version
-        assert_equal("0.1.0", client.version)
-        assert_equal(url, client.url)
-      end
-
-      def test_initialization_with_custom_version
-        custom_version = "1.2.3"
-        client = Http.new(url: url, version: custom_version)
-        assert_equal(custom_version, client.version)
-      end
+  class Client
+    class HTTPTest < Minitest::Test
+      # def test_initialization_with_default_version
+      #   assert_equal("0.1.0", client.version)
+      #   assert_equal(url, client.url)
+      # end
+
+      # def test_initialization_with_custom_version
+      #   custom_version = "1.2.3"
+      #   client = HTTP.new(url: url, version: custom_version)
+      #   assert_equal(custom_version, client.version)
+      # end
 
       def test_raises_load_error_when_faraday_not_available
-        client = Http.new(url: url)
+        client = HTTP.new(url: url)
 
         # simulate Faraday not being available
-        Http.any_instance.stubs(:require).with("faraday").raises(LoadError, "cannot load such file -- faraday")
+        HTTP.any_instance.stubs(:require).with("faraday").raises(LoadError, "cannot load such file -- faraday")
 
         error = assert_raises(LoadError) do
           # I picked #tools arbitrarily.
@@ -41,7 +40,7 @@ def test_raises_load_error_when_faraday_not_available
 
       def test_headers_are_added_to_the_request
         headers = { "Authorization" => "Bearer token" }
-        client = Http.new(url: url, headers: headers)
+        client = HTTP.new(url: url, headers: headers)
         client.stubs(:request_id).returns(mock_request_id)
 
         stub_request(:post, url)
@@ -108,16 +107,16 @@ def test_tools_returns_tools_instance
           )
 
         tools = client.tools
-        assert_instance_of(Tools, tools)
+        assert_instance_of(Array, tools)
         assert_equal(1, tools.count)
         assert_equal("test_tool", tools.first.name)
       end
 
       def test_call_tool_returns_tool_response
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -172,9 +171,9 @@ def test_call_tool_returns_tool_response
 
       def test_call_tool_handles_empty_response
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -220,9 +219,9 @@ def test_call_tool_handles_empty_response
 
       def test_raises_bad_request_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -263,9 +262,9 @@ def test_raises_bad_request_error
 
       def test_raises_unauthorized_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -306,9 +305,9 @@ def test_raises_unauthorized_error
 
       def test_raises_forbidden_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -349,9 +348,9 @@ def test_raises_forbidden_error
 
       def test_raises_not_found_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -392,9 +391,9 @@ def test_raises_not_found_error
 
       def test_raises_unprocessable_entity_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -435,9 +434,9 @@ def test_raises_unprocessable_entity_error
 
       def test_raises_internal_error
         tool = Tool.new(
-          "name" => "test_tool",
-          "description" => "A test tool",
-          "inputSchema" => {
+          name: "test_tool",
+          description: "A test tool",
+          input_schema: {
             "type" => "object",
             "properties" => {},
           },
@@ -492,7 +491,7 @@ def url
 
       def client
         @client ||= begin
-          client = Http.new(url: url)
+          client = HTTP.new(url: url)
           client.stubs(:request_id).returns(mock_request_id)
           client
         end