Implement tools

Author: bradgessler

Gemfile

@@ -9,3 +9,5 @@ gem "irb"
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+
+gem "thor", "~> 1.3"

Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    modelcontextprotocol (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    date (3.4.1)
+    diff-lcs (1.5.1)
+    io-console (0.8.0)
+    irb (1.15.1)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    pp (0.6.2)
+      prettyprint
+    prettyprint (0.2.0)
+    psych (5.2.3)
+      date
+      stringio
+    rake (13.2.1)
+    rdoc (6.12.0)
+      psych (>= 4.0.0)
+    reline (0.6.0)
+      io-console (~> 0.5)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.2)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.2)
+    stringio (3.1.5)
+    thor (1.3.2)
+
+PLATFORMS
+  arm64-darwin-24
+  ruby
+
+DEPENDENCIES
+  irb
+  modelcontextprotocol!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  thor (~> 1.3)
+
+BUNDLED WITH
+   2.6.5

lib/modelcontextprotocol.rb

@@ -2,7 +2,159 @@
 
 require_relative "modelcontextprotocol/version"
 
+require 'json'
+
 module ModelContextProtocol
   class Error < StandardError; end
-  # Your code goes here...
+
+  # Module to automatically convert snake_case keys to camelCase when serializing to JSON.
+  module CamelCaseJson
+    def to_json(*options)
+      JSON.generate(camelize_hash_keys(to_h), *options)
+    end
+
+    private
+
+    def camelize_hash_keys(obj)
+      case obj
+      when Array
+        obj.map { |item| camelize_hash_keys(item) }
+      when Hash
+        obj.each_with_object({}) do |(key, value), new_hash|
+          new_key = camelize(key.to_s)
+          new_hash[new_key] = camelize_hash_keys(value)
+        end
+      else
+        obj
+      end
+    end
+
+    def camelize(snake_str)
+      parts = snake_str.split('_')
+      parts[0] + parts[1..-1].map(&:capitalize).join
+    end
+  end
+
+  # Represents a single property for an input schema, you filthy fuckface.
+  class Property
+    include CamelCaseJson
+
+    attr_accessor :name, :type, :description, :required
+
+    # @param name [String] The property name.
+    # @param type [String] The type of the property (e.g., "string", "number").
+    # @param description [String] Description of the property.
+    # @param required [Boolean] Whether the property is required.
+    def initialize(name:, type:, description:, required: false)
+      @name = name
+      @type = type
+      @description = description
+      @required = required
+    end
+
+    def to_h
+      {
+        name: name,
+        type: type,
+        description: description,
+        required: required
+      }
+    end
+  end
+
+  # Represents the input schema for a tool with properties as a collection of Property objects.
+  class Input
+    include CamelCaseJson
+
+    attr_accessor :type, :properties
+
+    # @param type [String] The type of the input (default: "object").
+    # @param properties [Array<Property>] An array of Property objects.
+    def initialize(type: "object", properties: [])
+      @type = type
+      @properties = properties
+    end
+
+    # Builder method for adding a property.
+    # @param name [String] The property name.
+    # @param type [String] The type of the property.
+    # @param description [String] Description of the property.
+    # @param required [Boolean] Whether the property is required.
+    # @return [Input] Returns self for chaining.
+    def property(name:, type:, description:, required: false)
+      @properties << Property.new(name: name, type: type, description: description, required: required)
+      self
+    end
+
+    def to_h
+      {
+        type: type,
+        properties: properties.map(&:to_h)
+      }
+    end
+  end
+
+  # Represents a tool definition in MCP.
+  class Tool
+    include CamelCaseJson
+
+    attr_accessor :name, :description, :input_schema
+
+    # @param name [String] Unique identifier for the tool.
+    # @param description [String] Human-readable description of the tool.
+    def initialize(name:, description:)
+      @name = name
+      @description = description
+      @input_schema = nil
+    end
+
+    # Builder method for setting up the input schema.
+    # @param type [String] The type for the input schema (default: "object").
+    # @yieldparam [Input] Yields the input instance to allow adding properties.
+    # @return [Tool] Returns self for chaining.
+    def input(type: "object")
+      @input_schema ||= Input.new(type: type)
+      yield(@input_schema) if block_given?
+      self
+    end
+
+    def to_h
+      {
+        name: name,
+        description: description,
+        input_schema: input_schema ? input_schema.to_h : nil
+      }
+    end
+  end
+
+  # Represents a collection of tools with pagination.
+  class Tools
+    include CamelCaseJson
+
+    attr_accessor :id, :tools, :next_cursor
+
+    # id defaults to 1, and next_cursor is optional.
+    def initialize(id: 1, tools: [], next_cursor: nil)
+      @id = id
+      @tools = tools
+      @next_cursor = next_cursor
+    end
+
+    # Builder method for adding a tool.
+    def add_tool(tool)
+      @tools << tool
+      self
+    end
+
+    def to_h
+      {
+        jsonrpc: "2.0",
+        id: id,
+        result: {
+          tools: tools.map(&:to_h),
+          next_cursor: next_cursor
+        }
+      }
+    end
+  end
 end

spec/modelcontextprotocol_spec.rb

@@ -4,8 +4,111 @@
   it "has a version number" do
     expect(ModelContextProtocol::VERSION).not_to be nil
   end
+end
+
+RSpec.describe ModelContextProtocol::Tool do
+  describe "#input" do
+    it "allows building an input schema with properties" do
+      tool = ModelContextProtocol::Tool.new(name: "test_tool", description: "A test tool")
+      tool.input do |inp|
+        inp.property(
+          name: "test_property",
+          type: "string",
+          description: "A test property",
+          required: true
+        )
+      end
+
+      input_schema = tool.to_h[:input_schema]
+      expect(input_schema[:type]).to eq("object")
+      expect(input_schema[:properties].first[:name]).to eq("test_property")
+      expect(input_schema[:properties].first[:required]).to eq(true)
+    end
+
+    it "serializes to camelCase JSON" do
+      tool = ModelContextProtocol::Tool.new(name: "test_tool", description: "A test tool")
+      tool.input do |inp|
+        inp.property(
+          name: "test_property",
+          type: "string",
+          description: "A test property",
+          required: true
+        )
+      end
+
+      json_output = tool.to_json
+      parsed = JSON.parse(json_output)
+      expect(parsed).to have_key("name")
+      expect(parsed).to have_key("description")
+      expect(parsed).to have_key("inputSchema")
+      expect(parsed["inputSchema"]).to have_key("type")
+      expect(parsed["inputSchema"]).to have_key("properties")
+      expect(parsed["inputSchema"]["properties"].first).to have_key("name")
+      expect(parsed["inputSchema"]["properties"].first).to have_key("required")
+    end
+  end
+
+  describe "Property builder" do
+    it "creates properties correctly" do
+      input = ModelContextProtocol::Input.new
+      input.property(name: "location", type: "string", description: "City name", required: true)
+      expect(input.properties.size).to eq(1)
+      prop = input.properties.first
+      expect(prop.name).to eq("location")
+      expect(prop.type).to eq("string")
+      expect(prop.description).to eq("City name")
+      expect(prop.required).to be true
+    end
+  end
+end
+
+RSpec.describe ModelContextProtocol::Tools do
+  it "serializes the tools collection exactly as expected" do
+    # Build a tool with input schema
+    tool = ModelContextProtocol::Tool.new(
+      name: "get_weather",
+      description: "Get current weather information for a location"
+    ).input do |inp|
+      inp.property(
+        name: "location",
+        type: "string",
+        description: "City name or zip code",
+        required: true
+      )
+    end
+
+    # Build the tools collection
+    tools = ModelContextProtocol::Tools.new(next_cursor: "next-page-cursor")
+    tools.add_tool(tool)
+
+    # Expected output hash
+    expected_hash = {
+      "jsonrpc" => "2.0",
+      "id" => 1,
+      "result" => {
+        "tools" => [
+          {
+            "name" => "get_weather",
+            "description" => "Get current weather information for a location",
+            "inputSchema" => {
+              "type" => "object",
+              "properties" => [
+                {
+                  "name" => "location",
+                  "type" => "string",
+                  "description" => "City name or zip code",
+                  "required" => true
+                }
+              ]
+            }
+          }
+        ],
+        "nextCursor" => "next-page-cursor"
+      }
+    }
 
-  it "does something useful" do
-    expect(false).to eq(true)
+    json_output = tools.to_json
+    parsed_output = JSON.parse(json_output)
+    expect(parsed_output).to eq(expected_hash)
   end
 end