model-context-protocol-rb 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9da483d392c30f83fc52293db51b1d807bc054889e6cd29d54d1dd96e9043ea6
-  data.tar.gz: 07f07aa7d469b674d57718ce3cb4d7abfffc64f1f0b4a159613dd6bfb13b4957
+  metadata.gz: 0127f55c18cd5b2886b93b9f939b2b1358b14d2700e1f9194b26e5f43935101f
+  data.tar.gz: c0ce5f9bc0891e5b20fb3b30acee6c6dee0ebc2d412fac31078839fcf94f0010
 SHA512:
-  metadata.gz: 37f34d68b99ebf423c8500def91c848662820bdf3c8b295e443e8aaecd588ed030b2b76838e8e94b42f5e488e5bf85c4b9f5390cfd910676993309b6152344cb
-  data.tar.gz: 22b094b711874327767cddbf77c95a8f0ab35d23710656925cc8bcadab0aa6fcf01d602dedeb90d05d3fb7320b034150f85590e54539d4045392722426d2e967
+  metadata.gz: f17f3371c5c07b264b2a495fbc8b3e47fc8d18993cc3bd64f9fe91f4475720dde9ec536f266af1f22e7c7eb30ffd0bc4e5680f0a53f8a39c08d2eff034206e9f
+  data.tar.gz: 564433c1386b063560c17502b7346ae7db2cc523c47ab4ecd62fb986c51fba178432331a4ceed699ec9469c8d63e719acddce669c03d68969b8fc7086a85e640

data/.solargraph.yml

@@ -0,0 +1,13 @@
+include:
+  - "**/*.rb"
+exclude:
+  - spec/**/*
+  - ".bundle/**"
+require: []
+domains: []
+require_paths: []
+plugins:
+  - solargraph-standardrb
+reporters:
+  - standardrb
+max_files: 5000

data/.standard.yml

@@ -1,3 +1,3 @@
 # For available configuration options, see:
 #   https://github.com/testdouble/standard
-ruby_version: 2.6
+ruby_version: 3.2

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-03-11
+
+- (Breaking) Replaced router initialization in favor of registry initialization during server configuration. The server now relies on the registry for auto-discovery of prompts, resources, and tools; this requires the use of SDK-provided builders to facilitate.
+- (Breaking) Implemented the use of `Data` objects across the implementation. As a result, responses from custom handlers must now respond with an object that responds to `serialized`.
+- Refactored the implementation to maintain separation of concerns and improve testability/maintainability.
+- Improved test coverage.
+- Improved development tooling.
+
+## [0.2.0] - 2025-01-13
+
+- Added a basic, synchronous server implementation that routes requests to custom handlers.
+
 ## [0.1.0] - 2025-01-10
 
 - Initial release
+
+[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/dickdavis/model-context-protocol-rb/releases/tag/v0.1.0

data/README.md

@@ -2,6 +2,21 @@
 
 An implementation of the [Model Context Protocol (MCP)](https://spec.modelcontextprotocol.io/specification/2024-11-05/) in Ruby.
 
+This SDK is experimental and subject to change. The initial focus is to implement MCP server support with the goal of providing a stable API by version `0.4`. MCP client support will follow. 
+
+You are welcome to contribute.
+
+TODO's:
+
+* [Completion](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/completion/)
+* [Logging](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/logging/)
+* [Pagination](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/pagination/)
+* [Prompt list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/#list-changed-notification)
+* [Resource list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#list-changed-notification)
+* [Resource subscriptions](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#subscriptions)
+* [Resource templates](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#resource-templates)
+* [Tool list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/#list-changed-notification)
+
 ## Usage
 
 Include `model-context-protocol-rb` in your project.
@@ -10,7 +25,124 @@ Include `model-context-protocol-rb` in your project.
 require 'model-context-protocol-rb'
 ```
 
-TODO: Write usage instructions here once implementation lands
+### Building an MCP Server
+
+Build a simple MCP server by routing methods to your custom handlers. Then, configure and run the server.
+
+```ruby
+server = ModelContextProtocol::Server.new do |config|
+  config.name = "MCP Development Server"
+  config.version = "1.0.0"
+  config.enable_log = true
+  config.registry = ModelContextProtocol::Server::Registry.new do
+    prompts list_changed: true do
+      register TestPrompt
+    end
+
+    resources list_changed: true, subscribe: true do
+      register TestResource
+    end
+
+    tools list_changed: true do
+      register TestTool
+    end
+  end
+end
+
+server.start
+```
+
+Messages from the MCP client will be routed to the appropriate custom handler. This SDK provides several classes that should be used to build your handlers.
+
+#### ModelContextProtocol::Server::Prompt
+
+The `Prompt` class is used to define a prompt that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/) in the `with_metadata` block, and then implement the call method to build your prompt. The `call` method should return a `Response` data object.
+
+```ruby
+class TestPrompt < ModelContextProtocol::Server::Prompt
+  with_metadata do
+    {
+      name: "Test Prompt",
+      description: "A test prompt",
+      arguments: [
+        {
+          name: "message",
+          description: "The thing to do",
+          required: true
+        },
+        {
+          name: "other",
+          description: "Another thing to do",
+          required: false
+        }
+      ]
+    }
+  end
+
+  def call
+    messages = [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: "Do this: #{params["message"]}"
+        }
+      }
+    ]
+
+    Response[messages:, prompt: self]
+  end
+end
+```
+
+#### ModelContextProtocol::Server::Resource
+
+The `Resource` class is used to define a resource that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/) in the `with_metadata` block, and then implement the 'call' method to build your prompt. The `call` method should return a `TextResponse` or a `BinaryResponse` data object.
+
+```ruby
+class TestResource < ModelContextProtocol::Server::Resource
+  with_metadata do
+    {
+      name: "Test Resource",
+      description: "A test resource",
+      mime_type: "text/plain",
+      uri: "resource://test-resource"
+    }
+  end
+
+  def call
+    TextResponse[resource: self, text: "Here's the data"]
+  end
+end
+```
+
+#### ModelContextProtocol::Server::Tool
+
+The `Tool` class is used to define a tool that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/) in the `with_metadata` block, and then implement the `call` method to build your prompt. The `call` method should return a `TextResponse`, `ImageResponse`, `ResourceResponse`, or `ToolErrorResponse` data object.
+
+```ruby
+class TestTool < ModelContextProtocol::Server::Tool
+  with_metadata do
+    {
+      name: "test-tool",
+      description: "A test tool",
+      inputSchema: {
+        type: "object",
+        properties: {
+          message: {
+            type: "string"
+          }
+        },
+        required: ["message"]
+      }
+    }
+  end
+
+  def call
+    TextResponse[text: "You said: #{params["message"]}"]
+  end
+end
+```
 
 ## Installation
 

data/lib/model_context_protocol/server/configuration.rb

@@ -0,0 +1,38 @@
+module ModelContextProtocol
+  class Server::Configuration
+    # Raised when configured with invalid name.
+    class InvalidServerNameError < StandardError; end
+
+    # Raised when configured with invalid version.
+    class InvalidServerVersionError < StandardError; end
+
+    # Raised when configured with invalid registry.
+    class InvalidRegistryError < StandardError; end
+
+    attr_accessor :enable_log, :name, :registry, :version
+
+    def logging_enabled?
+      enable_log || false
+    end
+
+    def validate!
+      raise InvalidServerNameError unless valid_name?
+      raise InvalidRegistryError unless valid_registry?
+      raise InvalidServerVersionError unless valid_version?
+    end
+
+    private
+
+    def valid_name?
+      name&.is_a?(String)
+    end
+
+    def valid_registry?
+      registry&.is_a?(ModelContextProtocol::Server::Registry)
+    end
+
+    def valid_version?
+      version&.is_a?(String)
+    end
+  end
+end

data/lib/model_context_protocol/server/prompt.rb

@@ -0,0 +1,67 @@
+module ModelContextProtocol
+  class Server::Prompt
+    attr_reader :params, :description
+
+    Response = Data.define(:messages, :prompt) do
+      def serialized
+        {description: prompt.description, messages:}
+      end
+    end
+
+    def initialize(params)
+      validate!(params)
+      @description = self.class.description
+      @params = params
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    private def validate!(params = {})
+      arguments = self.class.arguments || []
+      required_args = arguments.select { |arg| arg[:required] }.map { |arg| arg[:name] }
+      valid_arg_names = arguments.map { |arg| arg[:name] }
+
+      missing_args = required_args - params.keys
+      unless missing_args.empty?
+        missing_args_list = missing_args.join(", ")
+        raise ArgumentError, "Missing required arguments: #{missing_args_list}"
+      end
+
+      extra_args = params.keys - valid_arg_names
+      unless extra_args.empty?
+        extra_args_list = extra_args.join(", ")
+        raise ArgumentError, "Unexpected arguments: #{extra_args_list}"
+      end
+    end
+
+    class << self
+      attr_reader :name, :description, :arguments
+
+      def with_metadata(&block)
+        metadata = instance_eval(&block)
+
+        @name = metadata[:name]
+        @description = metadata[:description]
+        @arguments = metadata[:arguments]
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@name, @name)
+        subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@arguments, @arguments)
+      end
+
+      def call(params)
+        new(params).call
+      rescue ArgumentError => error
+        raise ModelContextProtocol::Server::ParameterValidationError, error.message
+      end
+
+      def metadata
+        {name: @name, description: @description, arguments: @arguments}
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/registry.rb

@@ -0,0 +1,102 @@
+module ModelContextProtocol
+  class Server::Registry
+    attr_reader :prompts_options, :resources_options, :tools_options
+
+    def self.new(&block)
+      registry = allocate
+      registry.send(:initialize)
+      registry.instance_eval(&block) if block
+      registry
+    end
+
+    def initialize
+      @prompts = []
+      @resources = []
+      @tools = []
+      @prompts_options = {}
+      @resources_options = {}
+      @tools_options = {}
+    end
+
+    def prompts(options = {}, &block)
+      @prompts_options = options
+      instance_eval(&block) if block
+    end
+
+    def resources(options = {}, &block)
+      @resources_options = options
+      instance_eval(&block) if block
+    end
+
+    def tools(options = {}, &block)
+      @tools_options = options
+      instance_eval(&block) if block
+    end
+
+    def register(klass)
+      metadata = klass.metadata
+      entry = {klass: klass}.merge(metadata)
+
+      case klass.ancestors
+      when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::Prompt) }
+        @prompts << entry
+      when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::Resource) }
+        @resources << entry
+      when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::Tool) }
+        @tools << entry
+      else
+        raise ArgumentError, "Unknown class type: #{klass}"
+      end
+    end
+
+    def find_prompt(name)
+      find_by_name(@prompts, name)
+    end
+
+    def find_resource(uri)
+      entry = @resources.find { |r| r[:uri] == uri }
+      entry ? entry[:klass] : nil
+    end
+
+    def find_tool(name)
+      find_by_name(@tools, name)
+    end
+
+    def prompts_data
+      PromptsData[prompts: @prompts.map { |entry| entry.except(:klass) }]
+    end
+
+    def resources_data
+      ResourcesData[resources: @resources.map { |entry| entry.except(:klass) }]
+    end
+
+    def tools_data
+      ToolsData[tools: @tools.map { |entry| entry.except(:klass) }]
+    end
+
+    private
+
+    PromptsData = Data.define(:prompts) do
+      def serialized
+        {prompts:}
+      end
+    end
+
+    ResourcesData = Data.define(:resources) do
+      def serialized
+        {resources:}
+      end
+    end
+
+    ToolsData = Data.define(:tools) do
+      def serialized
+        {tools:}
+      end
+    end
+
+    def find_by_name(collection, name)
+      entry = collection.find { |item| item[:name] == name }
+      entry ? entry[:klass] : nil
+    end
+  end
+end

data/lib/model_context_protocol/server/resource.rb

@@ -0,0 +1,54 @@
+module ModelContextProtocol
+  class Server::Resource
+    attr_reader :mime_type, :uri
+
+    TextResponse = Data.define(:resource, :text) do
+      def serialized
+        {contents: [{mimeType: resource.mime_type, text:, uri: resource.uri}]}
+      end
+    end
+
+    BinaryResponse = Data.define(:blob, :resource) do
+      def serialized
+        {contents: [{blob:, mimeType: resource.mime_type, uri: resource.uri}]}
+      end
+    end
+
+    def initialize
+      @mime_type = self.class.mime_type
+      @uri = self.class.uri
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    class << self
+      attr_reader :name, :description, :mime_type, :uri
+
+      def with_metadata(&block)
+        metadata = instance_eval(&block)
+
+        @name = metadata[:name]
+        @description = metadata[:description]
+        @mime_type = metadata[:mime_type]
+        @uri = metadata[:uri]
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@name, @name)
+        subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@mime_type, @mime_type)
+        subclass.instance_variable_set(:@uri, @uri)
+      end
+
+      def call
+        new.call
+      end
+
+      def metadata
+        {name: @name, description: @description, mime_type: @mime_type, uri: @uri}
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/router.rb

@@ -0,0 +1,22 @@
+module ModelContextProtocol
+  class Server::Router
+    # Raised when an invalid method is provided.
+    class MethodNotFoundError < StandardError; end
+
+    def initialize
+      @handlers = {}
+    end
+
+    def map(method, &handler)
+      @handlers[method] = handler
+    end
+
+    def route(message)
+      method = message["method"]
+      handler = @handlers[method]
+      raise MethodNotFoundError, "Method not found: #{method}" unless handler
+
+      handler.call(message)
+    end
+  end
+end

data/lib/model_context_protocol/server/stdio_transport.rb

@@ -0,0 +1,65 @@
+module ModelContextProtocol
+  class Server::StdioTransport
+    Response = Data.define(:id, :result) do
+      def serialized
+        {jsonrpc: "2.0", id:, result:}
+      end
+    end
+
+    ErrorResponse = Data.define(:id, :error) do
+      def serialized
+        {jsonrpc: "2.0", id:, error:}
+      end
+    end
+
+    attr_reader :logger, :router
+
+    def initialize(logger:, router:)
+      @logger = logger
+      @router = router
+    end
+
+    def begin
+      loop do
+        line = $stdin.gets
+        break unless line
+
+        begin
+          message = JSON.parse(line.chomp)
+          next if message["method"].start_with?("notifications")
+
+          result = router.route(message)
+          send_message(Response[id: message["id"], result: result.serialized])
+        rescue ModelContextProtocol::Server::ParameterValidationError => validation_error
+          log("Validation error: #{validation_error.message}")
+          send_message(
+            ErrorResponse[id: message["id"], error: {code: -32602, message: validation_error.message}]
+          )
+        rescue JSON::ParserError => parser_error
+          log("Parser error: #{parser_error.message}")
+          send_message(
+            ErrorResponse[id: "", error: {code: -32700, message: parser_error.message}]
+          )
+        rescue => error
+          log("Internal error: #{error.message}")
+          log(error.backtrace)
+          send_message(
+            ErrorResponse[id: message["id"], error: {code: -32603, message: error.message}]
+          )
+        end
+      end
+    end
+
+    private
+
+    def log(output, level = :error)
+      logger.send(level.to_sym, output)
+    end
+
+    def send_message(message)
+      message_json = JSON.generate(message.serialized)
+      $stdout.puts(message_json)
+      $stdout.flush
+    end
+  end
+end

data/lib/model_context_protocol/server/tool.rb

@@ -0,0 +1,82 @@
+require "json-schema"
+
+module ModelContextProtocol
+  class Server::Tool
+    attr_reader :params
+
+    TextResponse = Data.define(:text) do
+      def serialized
+        {content: [{type: "text", text:}], isError: false}
+      end
+    end
+
+    ImageResponse = Data.define(:data, :mime_type) do
+      def initialize(data:, mime_type: "image/png")
+        super
+      end
+
+      def serialized
+        {content: [{type: "image", data:, mimeType: mime_type}], isError: false}
+      end
+    end
+
+    ResourceResponse = Data.define(:uri, :text, :mime_type) do
+      def initialize(uri:, text:, mime_type: "text/plain")
+        super
+      end
+
+      def serialized
+        {content: [{type: "resource", resource: {uri:, mimeType: mime_type, text:}}], isError: false}
+      end
+    end
+
+    ToolErrorResponse = Data.define(:text) do
+      def serialized
+        {content: [{type: "text", text:}], isError: true}
+      end
+    end
+
+    def initialize(params)
+      validate!(params)
+      @params = params
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    private def validate!(params)
+      JSON::Validator.validate!(self.class.input_schema, params)
+    end
+
+    class << self
+      attr_reader :name, :description, :input_schema
+
+      def with_metadata(&block)
+        metadata = instance_eval(&block)
+
+        @name = metadata[:name]
+        @description = metadata[:description]
+        @input_schema = metadata[:inputSchema]
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@name, @name)
+        subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@input_schema, @input_schema)
+      end
+
+      def call(params)
+        new(params).call
+      rescue JSON::Schema::ValidationError => error
+        raise ModelContextProtocol::Server::ParameterValidationError, error.message
+      rescue => error
+        ToolErrorResponse[text: error.message]
+      end
+
+      def metadata
+        {name: @name, description: @description, inputSchema: @input_schema}
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server.rb

@@ -0,0 +1,112 @@
+require "logger"
+
+module ModelContextProtocol
+  class Server
+    # Raised when invalid parameters are provided.
+    class ParameterValidationError < StandardError; end
+
+    attr_reader :configuration, :router
+
+    def initialize
+      @configuration = Configuration.new
+      yield(@configuration) if block_given?
+      @router = Router.new
+      map_handlers
+    end
+
+    def start
+      configuration.validate!
+      logdev = configuration.logging_enabled? ? $stderr : File::NULL
+      StdioTransport.new(logger: Logger.new(logdev), router:).begin
+    end
+
+    private
+
+    PROTOCOL_VERSION = "2024-11-05".freeze
+    private_constant :PROTOCOL_VERSION
+
+    InitializeResponse = Data.define(:protocol_version, :capabilities, :server_info) do
+      def serialized
+        {
+          protocolVersion: protocol_version,
+          capabilities: capabilities,
+          serverInfo: server_info
+        }
+      end
+    end
+
+    PingResponse = Data.define do
+      def serialized
+        {}
+      end
+    end
+
+    def map_handlers
+      router.map("initialize") do |_message|
+        InitializeResponse[
+          protocol_version: PROTOCOL_VERSION,
+          capabilities: build_capabilities,
+          server_info: {
+            name: configuration.name,
+            version: configuration.version
+          }
+        ]
+      end
+
+      router.map("ping") do
+        PingResponse[]
+      end
+
+      router.map("resources/list") do
+        configuration.registry.resources_data
+      end
+
+      router.map("resources/read") do |message|
+        configuration.registry.find_resource(message["params"]["uri"]).call
+      end
+
+      router.map("prompts/list") do
+        configuration.registry.prompts_data
+      end
+
+      router.map("prompts/get") do |message|
+        configuration.registry.find_prompt(message["params"]["name"]).call(message["params"]["arguments"])
+      end
+
+      router.map("tools/list") do
+        configuration.registry.tools_data
+      end
+
+      router.map("tools/call") do |message|
+        configuration.registry.find_tool(message["params"]["name"]).call(message["params"]["arguments"])
+      end
+    end
+
+    def build_capabilities
+      {}.tap do |capabilities|
+        capabilities[:logging] = {} if configuration.logging_enabled?
+
+        registry = configuration.registry
+
+        if registry.prompts_options.any? && !registry.instance_variable_get(:@prompts).empty?
+          capabilities[:prompts] = {
+            listChanged: registry.prompts_options[:list_changed]
+          }.compact
+        end
+
+        if registry.resources_options.any? && !registry.instance_variable_get(:@resources).empty?
+          capabilities[:resources] = {
+            subscribe: registry.resources_options[:subscribe],
+            listChanged: registry.resources_options[:list_changed]
+          }.compact
+        end
+
+        if registry.tools_options.any? && !registry.instance_variable_get(:@tools).empty?
+          capabilities[:tools] = {
+            listChanged: registry.tools_options[:list_changed]
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ModelContextProtocol
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/model_context_protocol.rb

@@ -5,5 +5,4 @@ Dir[File.join(__dir__, "model_context_protocol/", "**", "*.rb")].sort.each { |fi
 ##
 # Top-level namespace
 module ModelContextProtocol
-  # TODO: everything
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-11 00:00:00.000000000 Z
-dependencies: []
+date: 2025-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
 description:
 email:
 - dick@hey.com
@@ -19,6 +33,7 @@ extra_rdoc_files: []
 files:
 - ".reek.yml"
 - ".rspec"
+- ".solargraph.yml"
 - ".standard.yml"
 - ".tool-versions"
 - CHANGELOG.md
@@ -26,6 +41,14 @@ files:
 - README.md
 - Rakefile
 - lib/model_context_protocol.rb
+- lib/model_context_protocol/server.rb
+- lib/model_context_protocol/server/configuration.rb
+- lib/model_context_protocol/server/prompt.rb
+- lib/model_context_protocol/server/registry.rb
+- lib/model_context_protocol/server/resource.rb
+- lib/model_context_protocol/server/router.rb
+- lib/model_context_protocol/server/stdio_transport.rb
+- lib/model_context_protocol/server/tool.rb
 - lib/model_context_protocol/version.rb
 homepage: https://github.com/dickdavis/model-context-protocol-rb
 licenses:
@@ -43,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="