Spec passes for tools manifest

Author: bradgessler

lib/modelcontextprotocol.rb

@@ -21,14 +21,24 @@ def camelize_hash_keys(obj)
         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_key = modify_key(key.to_s)
           new_hash[new_key] = camelize_hash_keys(value)
         end
       else
         obj
       end
     end
 
+    def modify_key(key)
+      # In some cases, we want to emit keys that don't get snake cased, so for that
+      # we freeze strings and leave them alone.
+      if key.is_a?(String) and key.frozen?
+        key
+      else
+        camelize key
+      end
+    end
+
     def camelize(snake_str)
       parts = snake_str.split('_')
       parts[0] + parts[1..-1].map(&:capitalize).join
@@ -54,10 +64,8 @@ def initialize(name:, type:, description:, required: false)
 
     def to_h
       {
-        name: name,
         type: type,
-        description: description,
-        required: required
+        description: description
       }
     end
   end
@@ -86,10 +94,17 @@ def property(...)
       self
     end
 
+    def properties_hash
+      properties.each_with_object Hash.new do |prop, hash|
+        hash[prop.name.freeze] = prop.to_h
+      end
+    end
+
     def to_h
       {
         type: type,
-        properties: properties.map(&:to_h)
+        properties: properties_hash,
+        required: properties.select(&:required).map(&:name)
       }
     end
   end

spec/modelcontextprotocol_spec.rb

@@ -21,8 +21,8 @@
 
       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)
+      expect(input_schema[:properties]["test_property"][:type]).to eq("string")
+      expect(input_schema[:properties]["test_property"][:description]).to eq("A test property")
     end
 
     it "serializes to camelCase JSON" do
@@ -43,8 +43,8 @@
       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")
+      expect(parsed["inputSchema"]["properties"]["test_property"]).to have_key("type")
+      expect(parsed["inputSchema"]["properties"]["test_property"]).to have_key("description")
     end
   end
 
@@ -82,30 +82,31 @@
     tools.add_tool(tool)
 
     # Expected output hash
-    expected_hash = {
-      "jsonrpc" => "2.0",
-      "id" => 1,
-      "result" => {
-        "tools" => [
+    expected_hash = JSON.parse <<~JSON
+    {
+      "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
+            "name": "get_weather",
+            "description": "Get current weather information for a location",
+            "inputSchema": {
+              "type": "object",
+              "properties": {
+                "location": {
+                  "type": "string",
+                  "description": "City name or zip code"
                 }
-              ]
+              },
+              "required": ["location"]
             }
           }
         ],
-        "nextCursor" => "next-page-cursor"
+        "nextCursor": "next-page-cursor"
       }
     }
+    JSON
 
     json_output = tools.to_json
     parsed_output = JSON.parse(json_output)