mcp-rb 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 131c29522f8eb44f7f613f51d92db433370d99950dcfcd27340ab9917b306dd3
-  data.tar.gz: a676110b09851f7018205bc012b09a6f22d1c7730555ba569b9b7ae475c06009
+  metadata.gz: 7c5b2677ddf71a4e2597cae1bb3f5806308e33beb5c5a28032741788a1c0b7b6
+  data.tar.gz: 63c873245f9af796df2b60072167bac6a4810f6233a3f872e9295e52e1d42b38
 SHA512:
-  metadata.gz: ebe914ec0fa9ba0ef97650f83454d0fe5bf5c924717365d5cea3bdd73bfb06b5e0ede7d49c6da2caa8d38c5a337bae3c98c22b86d5f1c25740785c66ac195509
-  data.tar.gz: 719f1f95950ca24c0695316af978866e1b8834b5112c962701324d8279faa9e5705151157d23a66e7f9e6572313df18f7c4acfc247037965d059f12bdcacb883
+  metadata.gz: 9672f55327ee861ba8777447b5b04724d4ffac344a268245a8dc53f9aa5715a048af67f226d8856e2066b28268aff98e7ed5b82fcb8dd59a97710f6f4e4e3ae6
+  data.tar.gz: 2d82cf39dd04173518e7b2365513d07536661dbc80a0db72a38b759401808651ff186f2bb0910c24ac73ecbc613a709db66c4c89c7d9422d71d93b7fd0478665

data/CHANGELOG.md

@@ -5,6 +5,18 @@ 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
+- Add `resources/templates/list` method: https://github.com/funwarioisii/mcp-rb/pull/5
+
 ## [0.3.0] - 2025-02-19
 
 - Allow specifying the version via DSL keyword: https://github.com/funwarioisii/mcp-rb/pull/2

data/README.md

@@ -19,6 +19,8 @@ require 'mcp'
 
 name "hello-world"
 
+version "1.0.0"
+
 # Define a resource
 resource "hello://world" do
   name "Hello World"
@@ -26,6 +28,13 @@ resource "hello://world" do
   call { "Hello, World!" }
 end
 
+# Define a resource template
+resource_template "hello://{user_name}" do
+  name "Hello User"
+  description "A simple hello user message"
+  call { |args| "Hello, #{args[:user_name]}!" }
+end
+
 # Define a tool
 tool "greet" do
   description "Greet someone by name"
@@ -34,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
@@ -47,6 +77,7 @@ Reference: [MCP 2024-11-05](https://spec.modelcontextprotocol.io/specification/2
   - Resources
     - resources/read
     - resources/list
+    - resources/templates/list
   - Tools
     - tools/list
     - tools/call
@@ -102,4 +133,3 @@ gem push mcp-rb-*.gem
 ## Changelog
 
 See [CHANGELOG.md](CHANGELOG.md)
-

data/lib/mcp/app/resource.rb

@@ -69,11 +69,11 @@ module MCP
 
         if page_size.nil?
           paginated = values[start_index..]
-          next_cursor = ""
+          next_cursor = nil
         else
           paginated = values[start_index, page_size]
           has_next = start_index + page_size < values.length
-          next_cursor = has_next ? (start_index + page_size).to_s : ""
+          next_cursor = has_next ? (start_index + page_size).to_s : nil
         end
 
         {
@@ -84,6 +84,29 @@ module MCP
 
       def read_resource(uri)
         resource = resources[uri]
+
+        # If no direct match, check if it matches a template
+        if resource.nil? && respond_to?(:find_matching_template)
+          template, variable_values = find_matching_template(uri)
+
+          if template
+            begin
+              # Call the template handler with the extracted variables
+              content = template[:handler].call(variable_values)
+              return {
+                contents: [{
+                  uri: uri,
+                  mimeType: template[:mime_type],
+                  text: content
+                }]
+              }
+            rescue => e
+              raise ArgumentError, "Error reading resource from template: #{e.message}"
+            end
+          end
+        end
+
+        # If we still don't have a resource, raise an error
         raise ArgumentError, "Resource not found: #{uri}" unless resource
 
         begin

data/lib/mcp/app/resource_template.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "resource"
+
+module MCP
+  class App
+    module ResourceTemplate
+      def resource_templates
+        @resource_templates ||= {}
+      end
+
+      class ResourceTemplateBuilder
+        attr_reader :uri_template, :name, :description, :mime_type, :handler
+
+        def initialize(uri_template)
+          raise ArgumentError, "Resource URI template cannot be nil or empty" if uri_template.nil? || uri_template.empty?
+          @uri_template = uri_template
+          @name = ""
+          @description = ""
+          @mime_type = "text/plain"
+          @handler = nil
+          @variables = extract_variables(uri_template)
+        end
+
+        # standard:disable Lint/DuplicateMethods,Style/TrivialAccessors
+        def name(value)
+          @name = value
+        end
+        # standard:enable Lint/DuplicateMethods,Style/TrivialAccessors
+
+        # standard:disable Lint/DuplicateMethods,Style/TrivialAccessors
+        def description(text)
+          @description = text
+        end
+        # standard:enable Lint/DuplicateMethods,Style/TrivialAccessors
+
+        # standard:disable Lint/DuplicateMethods,Style/TrivialAccessors
+        def mime_type(value)
+          @mime_type = value
+        end
+        # standard:enable Lint/DuplicateMethods,Style/TrivialAccessors
+
+        def call(&block)
+          @handler = block
+        end
+
+        def to_resource_template_hash
+          raise ArgumentError, "Name must be provided" if @name.empty?
+
+          {
+            uri_template: @uri_template,
+            name: @name,
+            mime_type: @mime_type,
+            description: @description,
+            handler: @handler,
+            variables: @variables
+          }
+        end
+
+        # Extract variables from a URI template
+        # e.g., "channels://{channel_id}" => ["channel_id"]
+        def extract_variables(uri_template)
+          variables = []
+          uri_template.scan(/\{([^}]+)\}/) do |match|
+            variables << match[0]&.to_sym
+          end
+          variables
+        end
+
+        # Creates a pattern for matching URIs against this template
+        def to_pattern
+          pattern_string = Regexp.escape(@uri_template).gsub(/\\\{[^}]+\\\}/) do |match|
+            "([^/]+)"
+          end
+          Regexp.new("^#{pattern_string}$")
+        end
+
+        # Extract variable values from a concrete URI based on the template
+        # e.g., template: "channels://{channel_id}", uri: "channels://123" => {"channel_id" => "123"}
+        def extract_variable_values(uri)
+          pattern = to_pattern
+          match = pattern.match(uri)
+          return {} unless match
+
+          result = {}
+          @variables.each_with_index do |var_name, index|
+            result[var_name] = match[index + 1]
+          end
+          result
+        end
+      end
+
+      def register_resource_template(uri_template, &block)
+        builder = ResourceTemplateBuilder.new(uri_template)
+        builder.instance_eval(&block)
+        template_hash = builder.to_resource_template_hash
+        resource_templates[uri_template] = template_hash
+        template_hash
+      end
+
+      # Find a template that matches the given URI and extract variable values
+      def find_matching_template(uri)
+        resource_templates.each do |template_uri, template|
+          builder = ResourceTemplateBuilder.new(template_uri)
+          variable_values = builder.extract_variable_values(uri)
+          return [template, variable_values] unless variable_values.empty?
+        end
+        [nil, {}]
+      end
+
+      def list_resource_templates(cursor: nil, page_size: nil)
+        start_index = cursor&.to_i || 0
+        values = resource_templates.values
+
+        if page_size.nil?
+          paginated = values[start_index..]
+          next_cursor = nil
+        else
+          paginated = values[start_index, page_size]
+          has_next = start_index + page_size < values.length
+          next_cursor = has_next ? (start_index + page_size).to_s : nil
+        end
+
+        {
+          resourceTemplates: paginated.map { |t| format_resource_template(t) },
+          nextCursor: next_cursor
+        }
+      end
+
+      private
+
+      def format_resource_template(template)
+        {
+          uriTemplate: template[:uri_template],
+          name: template[:name],
+          description: template[:description],
+          mimeType: template[:mime_type]
+        }
+      end
+    end
+  end
+end

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 : ""
-
-        {
-          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/app.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "app/resource"
+require_relative "app/resource_template"
 require_relative "app/tool"
 
 module MCP
   class App
     include Resource
+    include ResourceTemplate
     include Tool
   end
 end

data/lib/mcp/delegator.rb

@@ -15,6 +15,6 @@ module MCP
       end
     end
 
-    delegate :name, :version, :resource, :tool
+    delegate :name, :version, :resource, :resource_template, :tool
   end
 end

data/lib/mcp/server.rb

@@ -28,6 +28,7 @@ module MCP
       return @version if value.nil?
 
       @version = value
+      @supported_protocol_versions << value
     end
 
     def tool(name, &block)
@@ -38,6 +39,10 @@ module MCP
       @app.register_resource(uri, &block)
     end
 
+    def resource_template(uri_template, &block)
+      @app.register_resource_template(uri_template, &block)
+    end
+
     def run
       while (input = $stdin.gets)
         process_input(input)
@@ -56,6 +61,10 @@ module MCP
       @app.list_resources[:resources]
     end
 
+    def list_resource_templates
+      @app.list_resource_templates[:resourceTemplates]
+    end
+
     def read_resource(uri)
       @app.read_resource(uri).dig(:contents, 0, :text)
     end
@@ -172,6 +181,12 @@ module MCP
       success_response(request[:id], result)
     end
 
+    def handle_list_resources_templates(request)
+      cursor = request.dig(:params, :cursor)
+      result = @app.list_resource_templates(cursor:)
+      success_response(request[:id], result)
+    end
+
     def handle_read_resource(request)
       uri = request.dig(:params, :uri)
       result = @app.read_resource(uri)

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "0.3.0"
+  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.0
+  version: 0.3.2
 platform: ruby
 authors:
 - funwarioisii
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-19 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.
@@ -23,6 +24,7 @@ files:
 - lib/mcp.rb
 - lib/mcp/app.rb
 - lib/mcp/app/resource.rb
+- lib/mcp/app/resource_template.rb
 - lib/mcp/app/tool.rb
 - lib/mcp/client.rb
 - lib/mcp/constants.rb
@@ -36,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
@@ -50,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