Add basic HTTP client support

Author: jcat4

Gemfile

@@ -22,3 +22,7 @@ gem "activesupport"
 gem "debug"
 gem "rake", "~> 13.0"
 gem "sorbet-static-and-runtime"
+
+group :test do
+  gem "webmock"
+end

lib/mcp/client.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# require "json_rpc_handler"
+# require_relative "shared/instrumentation"
+# require_relative "shared/methods"
+
+module ModelContextProtocol
+  module Client
+    # Can be made an abstract class if we need shared behavior
+  end
+end

lib/mcp/client/http.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# require "json_rpc_handler"
+# require_relative "shared/instrumentation"
+# require_relative "shared/methods"
+
+module ModelContextProtocol
+  module Client
+    class Http
+      DEFAULT_VERSION = "0.1.0"
+
+      attr_reader :url, :version
+
+      def initialize(url:, version: DEFAULT_VERSION)
+        @url = url
+        @version = version
+      end
+
+      def tools
+        response = client.post(
+          "",
+          method: "tools/list",
+          jsonrpc: "2.0",
+          id: request_id,
+          mcp: { method: "tools/list", jsonrpc: "2.0", id: request_id },
+        ).body
+
+        ::ModelContextProtocol::Client::Tools.new(response)
+      end
+
+      def call_tool(tool:, input:)
+        response = client.post(
+          "",
+          {
+            jsonrpc: "2.0",
+            id: request_id,
+            method: "tools/call",
+            params: { name: tool.name, arguments: input },
+            mcp: { jsonrpc: "2.0", id: request_id, method: "tools/call", params: { name: tool.name, arguments: input } },
+          },
+        ).body
+
+        response.dig("result", "content", 0, "text")
+      end
+
+      private
+
+      def client
+        @client ||= Faraday.new(url) do |faraday|
+          faraday.request(:json)
+          faraday.response(:json)
+          # TODO: error middleware?
+        end
+      end
+
+      def request_id
+        SecureRandom.uuid_v7
+      end
+    end
+  end
+end

lib/mcp/client/tool.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module Client
+    class Tool
+      attr_reader :payload
+
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def name
+        payload["name"]
+      end
+
+      def description
+        payload["description"]
+      end
+
+      def input_schema
+        payload["inputSchema"]
+      end
+    end
+  end
+end

lib/mcp/client/tools.rb

@@ -0,0 +1,30 @@
+# typed: false
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module Client
+    class Tools
+      include Enumerable
+
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def each(&block)
+        tools.each(&block)
+      end
+
+      def all
+        tools
+      end
+
+      private
+
+      def tools
+        @tools ||= @response.dig("result", "tools")&.map { |tool| Tool.new(tool) } || []
+      end
+    end
+  end
+end

mcp.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency("faraday", ">= 2.0")
   spec.add_dependency("json_rpc_handler", "~> 0.1")
   spec.add_dependency("json-schema", ">= 4.1")
 end

test/model_context_protocol/client/http_test.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "faraday"
+require "securerandom"
+require "webmock/minitest"
+
+module ModelContextProtocol
+  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:, version: custom_version)
+        assert_equal(custom_version, client.version)
+      end
+
+      def test_tools_returns_tools_instance
+        stub_request(:post, url)
+          .with(
+            body: {
+              method: "tools/list",
+              jsonrpc: "2.0",
+              id: mock_request_id,
+              mcp: {
+                method: "tools/list",
+                jsonrpc: "2.0",
+                id: mock_request_id,
+              },
+            },
+          )
+          .to_return(
+            status: 200,
+            headers: {
+              "Content-Type" => "application/json",
+            },
+            body: {
+              result: {
+                tools: [
+                  {
+                    name: "test_tool",
+                    description: "A test tool",
+                    inputSchema: {
+                      type: "object",
+                      properties: {},
+                    },
+                  },
+                ],
+              },
+            }.to_json,
+          )
+
+        tools = client.tools
+        assert_instance_of(Tools, 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" => {
+            "type" => "object",
+            "properties" => {},
+          },
+        )
+        input = { "param" => "value" }
+
+        stub_request(:post, url)
+          .with(
+            body: {
+              jsonrpc: "2.0",
+              id: mock_request_id,
+              method: "tools/call",
+              params: {
+                name: "test_tool",
+                arguments: input,
+              },
+              mcp: {
+                jsonrpc: "2.0",
+                id: mock_request_id,
+                method: "tools/call",
+                params: {
+                  name: "test_tool",
+                  arguments: input,
+                },
+              },
+            },
+          )
+          .to_return(
+            status: 200,
+            headers: {
+              "Content-Type" => "application/json",
+            },
+            body: {
+              result: {
+                content: [
+                  {
+                    text: "Tool response",
+                  },
+                ],
+              },
+            }.to_json,
+          )
+
+        response = client.call_tool(tool: tool, input: input)
+        assert_equal("Tool response", response)
+      end
+
+      def test_call_tool_handles_empty_response
+        tool = Tool.new(
+          "name" => "test_tool",
+          "description" => "A test tool",
+          "inputSchema" => {
+            "type" => "object",
+            "properties" => {},
+          },
+        )
+        input = { "param" => "value" }
+
+        stub_request(:post, url)
+          .with(
+            body: {
+              jsonrpc: "2.0",
+              id: mock_request_id,
+              method: "tools/call",
+              params: {
+                name: "test_tool",
+                arguments: input,
+              },
+              mcp: {
+                jsonrpc: "2.0",
+                id: mock_request_id,
+                method: "tools/call",
+                params: {
+                  name: "test_tool",
+                  arguments: input,
+                },
+              },
+            },
+          )
+          .to_return(
+            status: 200,
+            headers: {
+              "Content-Type" => "application/json",
+            },
+            body: {
+              result: {
+                content: [],
+              },
+            }.to_json,
+          )
+
+        response = client.call_tool(tool: tool, input: input)
+        assert_nil(response)
+      end
+
+      private
+
+      def stub_request(method, url)
+        WebMock.stub_request(method, url)
+      end
+
+      def mock_request_id
+        "random_request_id"
+      end
+
+      def url
+        "http://example.com"
+      end
+
+      def client
+        @client ||= begin
+          client = Http.new(url:)
+          client.stubs(:request_id).returns(mock_request_id)
+          client
+        end
+      end
+    end
+  end
+end

test/model_context_protocol/client/tool_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module ModelContextProtocol
+  module Client
+    class ToolTest < Minitest::Test
+      def test_name_returns_name_from_payload
+        tool = Tool.new("name" => "test_tool")
+        assert_equal("test_tool", tool.name)
+      end
+
+      def test_name_returns_nil_when_not_in_payload
+        tool = Tool.new({})
+        assert_nil(tool.name)
+      end
+
+      def test_description_returns_description_from_payload
+        tool = Tool.new("description" => "A test tool")
+        assert_equal("A test tool", tool.description)
+      end
+
+      def test_description_returns_nil_when_not_in_payload
+        tool = Tool.new({})
+        assert_nil(tool.description)
+      end
+
+      def test_input_schema_returns_input_schema_from_payload
+        schema = { "type" => "object", "properties" => { "foo" => { "type" => "string" } } }
+        tool = Tool.new("inputSchema" => schema)
+        assert_equal(schema, tool.input_schema)
+      end
+
+      def test_input_schema_returns_nil_when_not_in_payload
+        tool = Tool.new({})
+        assert_nil(tool.input_schema)
+      end
+
+      def test_payload_is_accessible
+        payload = { "name" => "test", "description" => "desc", "inputSchema" => {} }
+        tool = Tool.new(payload)
+        assert_equal(payload, tool.payload)
+      end
+    end
+  end
+end