mcp-rb 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ff3f38b8c9fec5aac8fce9d0906f956a77f481ac0477c273e9b677948d0a8cb
-  data.tar.gz: 116def752685bfa0792c6d2b1dc6bd75e6b029cec03205fb2a67b00d84532cfc
+  metadata.gz: 7c5b2677ddf71a4e2597cae1bb3f5806308e33beb5c5a28032741788a1c0b7b6
+  data.tar.gz: 63c873245f9af796df2b60072167bac6a4810f6233a3f872e9295e52e1d42b38
 SHA512:
-  metadata.gz: 3ed62e7606ff685a999c7f95118167e30d8ecb6a6ff35a260223b60fed2fc65599a79bd22424dfde3b0bfc4cd1b3bdf1cb46dcb6877c7720e8837021f456d8cf
-  data.tar.gz: 5536f506e8e2c89a73fe34acc6edc3981b444672ca8cb3730e089eea22fa9194cee33e6afe26a2442175441487283828aa29103e78b39c8387714d2f1c6a5a82
+  metadata.gz: 9672f55327ee861ba8777447b5b04724d4ffac344a268245a8dc53f9aa5715a048af67f226d8856e2066b28268aff98e7ed5b82fcb8dd59a97710f6f4e4e3ae6
+  data.tar.gz: 2d82cf39dd04173518e7b2365513d07536661dbc80a0db72a38b759401808651ff186f2bb0910c24ac73ecbc613a709db66c4c89c7d9422d71d93b7fd0478665

data/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.2] - 2025-03-07
+
+### Added
+- Add support for Nested Arguments and Array Arguments: https://github.com/funwarioisii/mcp-rb/pull/6
+  - Add validation for nested arguments
+  - Support array type arguments
+
 ## [0.3.1] - 2025-03-05
 
 ### Added

data/README.md

@@ -43,6 +43,27 @@ tool "greet" do
     "Hello, #{args[:name]}!"
   end
 end
+
+# Define a tool with nested arguments
+tool "greet_full_name" do
+  description "Greet someone by their full name"
+  argument :person, required: true, description: "Person to greet" do
+    argument :first_name, String, required: false, description: "First name"
+    argument :last_name, String, required: false, description: "Last name"
+  end
+  call do |args|
+    "Hello, First: #{args[:person][:first_name]} Last: #{args[:person][:last_name]}!"
+  end
+end
+
+# Define a tool with an Array argument
+tool "group_greeting" do
+  description "Greet multiple people at once"
+  argument :people, Array, required: true, items: String, description: "People to greet"
+  call do |args|
+    args[:people].map { |person| "Hello, #{person}!" }.join(", ")
+  end
+end
 ```
 
 ## Supported specifications

data/lib/mcp/app/tool.rb

@@ -7,31 +7,83 @@ module MCP
         @tools ||= {}
       end
 
+      # Builds schemas for arguments, supporting simple types, nested objects, and arrays
+      class SchemaBuilder
+        def initialize
+          @schema = nil
+          @properties = {}
+          @required = []
+        end
+
+        def argument(name, type = nil, required: false, description: "", items: nil, &block)
+          if type == Array
+            if block_given?
+              sub_builder = SchemaBuilder.new
+              sub_builder.instance_eval(&block)
+              item_schema = sub_builder.to_schema
+            elsif items
+              item_schema = {type: ruby_type_to_schema_type(items)}
+            else
+              raise ArgumentError, "Must provide items or a block for array type"
+            end
+            @properties[name] = {type: :array, description: description, items: item_schema}
+          elsif block_given?
+            raise ArgumentError, "Type not allowed with block for objects" if type
+            sub_builder = SchemaBuilder.new
+            sub_builder.instance_eval(&block)
+            @properties[name] = sub_builder.to_schema.merge(description: description)
+          else
+            raise ArgumentError, "Type required for simple arguments" if type.nil?
+            @properties[name] = {type: ruby_type_to_schema_type(type), description: description}
+          end
+          @required << name if required
+        end
+
+        def type(t)
+          @schema = {type: ruby_type_to_schema_type(t)}
+        end
+
+        def to_schema
+          @schema || {type: :object, properties: @properties, required: @required}
+        end
+
+        private
+
+        def ruby_type_to_schema_type(type)
+          if type == String
+            :string
+          elsif type == Integer
+            :integer
+          elsif type == Float
+            :number
+          elsif type == TrueClass || type == FalseClass
+            :boolean
+          elsif type == Array
+            :array
+          else
+            raise ArgumentError, "Unsupported type: #{type}"
+          end
+        end
+      end
+
+      # Constructs tool definitions with enhanced schema support
       class ToolBuilder
-        attr_reader :name, :description, :arguments, :handler
+        attr_reader :name, :arguments, :handler
 
         def initialize(name)
           raise ArgumentError, "Tool name cannot be nil or empty" if name.nil? || name.empty?
           @name = name
           @description = ""
-          @arguments = {}
-          @required_arguments = []
+          @schema_builder = SchemaBuilder.new
           @handler = nil
         end
 
-        # standard:disable Lint/DuplicateMethods
         def description(text = nil)
-          return @description if text.nil?
-          @description = text
+          text ? @description = text : @description
         end
-        # standard:enable Lint/DuplicateMethods
 
-        def argument(name, type, required: false, description: "")
-          @arguments[name] = {
-            type: ruby_type_to_schema_type(type),
-            description: description
-          }
-          @required_arguments << name if required
+        def argument(*args, **kwargs, &block)
+          @schema_builder.argument(*args, **kwargs, &block)
         end
 
         def call(&block)
@@ -43,95 +95,91 @@ module MCP
           {
             name: @name,
             description: @description,
-            input_schema: {
-              type: :object,
-              properties: @arguments,
-              required: @required_arguments
-            },
+            input_schema: @schema_builder.to_schema,
             handler: @handler
           }
         end
-
-        private
-
-        def ruby_type_to_schema_type(type)
-          case type.to_s
-          when "String" then :string
-          when "Integer" then :integer
-          when "Float" then :number
-          when "TrueClass", "FalseClass", "Boolean" then :boolean
-          else :object
-          end
-        end
       end
 
+      # Registers a tool with the given name and block
       def register_tool(name, &block)
         builder = ToolBuilder.new(name)
         builder.instance_eval(&block)
-        tool_hash = builder.to_tool_hash
-        tools[name] = tool_hash
-        tool_hash
+        tools[name] = builder.to_tool_hash
       end
 
+      # Lists tools with pagination
       def list_tools(cursor: nil, page_size: 10)
-        tool_values = tools.values
-        start_index = cursor ? cursor.to_i : 0
-        paginated = tool_values[start_index, page_size]
-        next_cursor = (start_index + page_size < tool_values.length) ? (start_index + page_size).to_s : nil
-
-        {
-          tools: paginated.map { |t| format_tool(t) },
-          nextCursor: next_cursor
-        }
+        start = cursor ? cursor.to_i : 0
+        paginated = tools.values[start, page_size]
+        next_cursor = (start + page_size < tools.length) ? (start + page_size).to_s : nil
+        {tools: paginated.map { |t| {name: t[:name], description: t[:description], inputSchema: t[:input_schema]} }, nextCursor: next_cursor}
       end
 
-      def call_tool(name, **arguments)
+      # Calls a tool with the provided arguments
+      def call_tool(name, **args)
         tool = tools[name]
         raise ArgumentError, "Tool not found: #{name}" unless tool
 
-        begin
-          validate_arguments(tool[:input_schema], arguments)
-          result = tool[:handler].call(arguments)
-          {
-            content: [
-              {
-                type: "text",
-                text: result.to_s
-              }
-            ],
-            isError: false
-          }
-        rescue => e
-          {
-            content: [
-              {
-                type: "text",
-                text: "Error: #{e.message}"
-              }
-            ],
-            isError: true
-          }
-        end
+        validate_arguments(tool[:input_schema], args)
+        {content: [{type: "text", text: tool[:handler].call(args).to_s}], isError: false}
+      rescue => e
+        {content: [{type: "text", text: "Error: #{e.message}"}], isError: true}
       end
 
       private
 
-      def validate_arguments(schema, arguments)
-        return unless schema[:required]
-
-        schema[:required].each do |required_arg|
-          unless arguments.key?(required_arg)
-            raise ArgumentError, "missing keyword: :#{required_arg}"
+      def validate(schema, arg, path = "")
+        errors = []
+        type = schema[:type]
+
+        if type == :object
+          if !arg.is_a?(Hash)
+            errors << (path.empty? ? "Arguments must be a hash" : "Expected object for #{path}, got #{arg.class}")
+          else
+            schema[:required]&.each do |req|
+              unless arg.key?(req)
+                errors << (path.empty? ? "Missing required param :#{req}" : "Missing required param #{path}.#{req}")
+              end
+            end
+            schema[:properties].each do |key, subschema|
+              if arg.key?(key)
+                sub_path = path.empty? ? key : "#{path}.#{key}"
+                sub_errors = validate(subschema, arg[key], sub_path)
+                errors.concat(sub_errors)
+              end
+            end
+          end
+        elsif type == :array
+          if !arg.is_a?(Array)
+            errors << "Expected array for #{path}, got #{arg.class}"
+          else
+            arg.each_with_index do |item, index|
+              sub_path = "#{path}[#{index}]"
+              sub_errors = validate(schema[:items], item, sub_path)
+              errors.concat(sub_errors)
+            end
+          end
+        else
+          valid = case type
+          when :string then arg.is_a?(String)
+          when :integer then arg.is_a?(Integer)
+          when :number then arg.is_a?(Float)
+          when :boolean then arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
+          else false
+          end
+          unless valid
+            errors << "Expected #{type} for #{path}, got #{arg.class}"
           end
         end
+        errors
       end
 
-      def format_tool(tool)
-        {
-          name: tool[:name],
-          description: tool[:description],
-          inputSchema: tool[:input_schema]
-        }
+      def validate_arguments(schema, args)
+        errors = validate(schema, args, "")
+        unless errors.empty?
+          raise ArgumentError, errors.join("\n").to_s
+        end
       end
     end
   end

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mcp-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - funwarioisii
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
+date: 2025-03-08 00:00:00.000000000 Z
 dependencies: []
 description: MCP-RB is a Ruby framework that provides a Sinatra-like DSL for implementing
   Model Context Protocol servers.
@@ -37,6 +38,7 @@ metadata:
   homepage_uri: https://github.com/funwarioisii/mcp-rb
   source_code_uri: https://github.com/funwarioisii/mcp-rb
   changelog_uri: https://github.com/funwarioisii/mcp-rb/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -51,7 +53,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: A lightweight Ruby framework for implementing MCP (Model Context Protocol)
   servers