model-context-protocol-rb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fffc016471f9e02baa6f9288860d65c7e9f4c9b573589d4abb31d824318b5ea1
-  data.tar.gz: 59b220de0291942879c34d7ca8cc47173b10d692a13e271c1458a59a7f2ff9fb
+  metadata.gz: 0127f55c18cd5b2886b93b9f939b2b1358b14d2700e1f9194b26e5f43935101f
+  data.tar.gz: c0ce5f9bc0891e5b20fb3b30acee6c6dee0ebc2d412fac31078839fcf94f0010
 SHA512:
-  metadata.gz: abda740fa404a916e3b30aa3b8e8c06e1731bb4e810b44b3d60f91742f92298fa66d2b4165f102679a49ee2246da6223ece27ad68302e96040148c2a83d00b3d
-  data.tar.gz: bc71626a2bec6b61a4e8e3de7a6ef8a44fb64a9e8d56f163734ff8a7e4ef42d05f552b0918f16e798ed15749b145fa901cbc4747a798ca9a274ef941b8f08e44
+  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/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [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.
@@ -8,6 +16,7 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.2.0...HEAD
+[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,30 +25,26 @@ Include `model-context-protocol-rb` in your project.
 require 'model-context-protocol-rb'
 ```
 
-# Building an MCP Server
+### 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 = "My MCP Server"
-  config.router = router
+  config.name = "MCP Development Server"
   config.version = "1.0.0"
   config.enable_log = true
-  config.router = ModelContextProtocol::Router.new do
-    prompts do
-      list Prompt::List, broadcast_changes: true
-      get Prompt::Get
+  config.registry = ModelContextProtocol::Server::Registry.new do
+    prompts list_changed: true do
+      register TestPrompt
     end
 
-    resources do
-      list Resource::List, broadcast_changes: true
-      read Resource::Read, allow_subscriptions: true
+    resources list_changed: true, subscribe: true do
+      register TestResource
     end
 
-    tools do
-      list Tool::List, broadcast_changes: true
-      call Tool::Call
+    tools list_changed: true do
+      register TestTool
     end
   end
 end
@@ -41,9 +52,97 @@ end
 server.start
 ```
 
-Messages from the MCP client will be routed to the appropriate custom handler. Your customer handler must respond to `call`; the router will pass the message to the handler as an argument.
+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
 
-Your handler should return a valid JSONRPC 2.0 response.
+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

@@ -1,117 +1,22 @@
-# frozen_string_literal: true
-
 module ModelContextProtocol
-  class Server
-    class Router
-      attr_accessor :server
-
-      def self.new(&block)
-        router = allocate
-        router.send(:initialize)
-        router.instance_eval(&block) if block
-        router
-      end
-
-      def initialize
-        @routes = {}
-        register_protocol_routes
-      end
-
-      def prompts(&block)
-        PromptsMap.new(@routes).instance_eval(&block)
-      end
-
-      def resources(&block)
-        ResourcesMap.new(@routes).instance_eval(&block)
-      end
-
-      def tools(&block)
-        ToolsMap.new(@routes).instance_eval(&block)
-      end
-
-      def route(message)
-        handler_config = @routes[message["method"]]
-        return nil unless handler_config
-
-        handler_config[:handler].call(message)
-      end
-
-      private
-
-      def server_info
-        if server&.configuration
-          {
-            name: server.configuration.name,
-            version: server.configuration.version
-          }
-        else
-          {name: "mcp-server", version: "1.0.0"}
-        end
-      end
+  class Server::Router
+    # Raised when an invalid method is provided.
+    class MethodNotFoundError < StandardError; end
 
-      def register_protocol_routes
-        register("initialize") do |_message|
-          {
-            protocolVersion: ModelContextProtocol::Server::PROTOCOL_VERSION,
-            capabilities: build_capabilities,
-            serverInfo: server_info
-          }
-        end
-
-        register("notifications/initialized") do |_message|
-          nil # No-op notification handler
-        end
-
-        register("ping") do |_message|
-          {} # Simple pong response
-        end
-      end
-
-      def register(method, handler = nil, **options, &block)
-        @routes[method] = {
-          handler: block || handler,
-          options: options
-        }
-      end
-
-      def build_capabilities
-        {
-          prompts: has_prompt_routes? ? {broadcast_changes: prompt_broadcasts_changes?} : nil,
-          resources: has_resource_routes? ? {
-            broadcast_changes: resource_broadcasts_changes?,
-            subscribe: resource_allows_subscriptions?
-          } : nil,
-          tools: has_tool_routes? ? {broadcast_changes: tool_broadcasts_changes?} : nil
-        }.compact
-      end
-
-      def has_prompt_routes?
-        @routes.key?("prompts/list") || @routes.key?("prompts/get")
-      end
-
-      def prompt_broadcasts_changes?
-        @routes.dig("prompts/list", :options, :broadcast_changes)
-      end
-
-      def has_resource_routes?
-        @routes.key?("resources/list") || @routes.key?("resources/read")
-      end
-
-      def resource_broadcasts_changes?
-        @routes.dig("resources/list", :options, :broadcast_changes)
-      end
+    def initialize
+      @handlers = {}
+    end
 
-      def resource_allows_subscriptions?
-        @routes.dig("resources/read", :options, :allow_subscriptions)
-      end
+    def map(method, &handler)
+      @handlers[method] = handler
+    end
 
-      def has_tool_routes?
-        @routes.key?("tools/list") || @routes.key?("tools/call")
-      end
+    def route(message)
+      method = message["method"]
+      handler = @handlers[method]
+      raise MethodNotFoundError, "Method not found: #{method}" unless handler
 
-      def tool_broadcasts_changes?
-        @routes.dig("tools/list", :options, :broadcast_changes)
-      end
+      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

@@ -1,81 +1,112 @@
-require "json"
+require "logger"
 
 module ModelContextProtocol
   class Server
-    class Configuration
-      attr_accessor :enable_log, :name, :router, :version
+    # Raised when invalid parameters are provided.
+    class ParameterValidationError < StandardError; end
 
-      def logging_enabled?
-        enable_log || false
-      end
+    attr_reader :configuration, :router
 
-      def validate!
-        raise InvalidServerNameError unless valid_name?
-        raise InvalidRouterError unless valid_router?
-        raise InvalidServerVersionError unless valid_version?
-      end
+    def initialize
+      @configuration = Configuration.new
+      yield(@configuration) if block_given?
+      @router = Router.new
+      map_handlers
+    end
 
-      private
+    def start
+      configuration.validate!
+      logdev = configuration.logging_enabled? ? $stderr : File::NULL
+      StdioTransport.new(logger: Logger.new(logdev), router:).begin
+    end
 
-      def valid_name?
-        true
-      end
+    private
 
-      def valid_router?
-        true
+    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
 
-      def valid_version?
-        true
+    PingResponse = Data.define do
+      def serialized
+        {}
       end
     end
 
-    PROTOCOL_VERSION = "2024-11-05".freeze
-
-    attr_reader :configuration
-
-    def initialize
-      @configuration = Configuration.new
-      yield(@configuration) if block_given?
-      @configuration.router.server = self if @configuration.router
-    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
 
-    def start
-      log("Server starting")
+      router.map("ping") do
+        PingResponse[]
+      end
 
-      configuration.validate!
+      router.map("resources/list") do
+        configuration.registry.resources_data
+      end
 
-      loop do
-        line = $stdin.gets
-        break unless line
+      router.map("resources/read") do |message|
+        configuration.registry.find_resource(message["params"]["uri"]).call
+      end
 
-        message = JSON.parse(line.chomp)
-        log("Received message: #{message.inspect}")
+      router.map("prompts/list") do
+        configuration.registry.prompts_data
+      end
 
-        response = configuration.router.route(message)
-        send_response(message["id"], response) if response
+      router.map("prompts/get") do |message|
+        configuration.registry.find_prompt(message["params"]["name"]).call(message["params"]["arguments"])
       end
-    rescue => e
-      log("Error: #{e.message}")
-      log(e.backtrace)
-    end
 
-    private
+      router.map("tools/list") do
+        configuration.registry.tools_data
+      end
 
-    def log(output)
-      warn(output) if configuration.logging_enabled?
+      router.map("tools/call") do |message|
+        configuration.registry.find_tool(message["params"]["name"]).call(message["params"]["arguments"])
+      end
     end
 
-    def send_response(id, result)
-      return unless result
-
-      response = {
-        jsonrpc: "2.0",
-        id: id,
-        result: result
-      }
-      $stdout.puts(JSON.generate(response))
-      $stdout.flush
+    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.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-14 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
@@ -27,12 +42,13 @@ files:
 - 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/router/base_map.rb
-- lib/model_context_protocol/server/router/prompts_map.rb
-- lib/model_context_protocol/server/router/protocol_map.rb
-- lib/model_context_protocol/server/router/resources_map.rb
-- lib/model_context_protocol/server/router/tools_map.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:

data/lib/model_context_protocol/server/router/base_map.rb

@@ -1,22 +0,0 @@
-module ModelContextProtocol
-  class Server
-    class Router
-      ##
-      # Base class for route maps.
-      class BaseMap
-        def initialize(routes)
-          @routes = routes
-        end
-
-        private
-
-        def register(method, handler, **options)
-          @routes[method] = {
-            handler: handler,
-            options: options
-          }
-        end
-      end
-    end
-  end
-end

data/lib/model_context_protocol/server/router/prompts_map.rb

@@ -1,17 +0,0 @@
-module ModelContextProtocol
-  class Server
-    class Router
-      ##
-      # Maps prompt operations to handlers.
-      class PromptsMap < BaseMap
-        def list(handler, broadcast_changes: false)
-          register("prompts/list", handler, broadcast_changes:)
-        end
-
-        def get(handler)
-          register("prompts/get", handler)
-        end
-      end
-    end
-  end
-end

data/lib/model_context_protocol/server/router/resources_map.rb

@@ -1,17 +0,0 @@
-module ModelContextProtocol
-  class Server
-    class Router
-      ##
-      # Maps resource operations to handlers.
-      class ResourcesMap < BaseMap
-        def list(handler, broadcast_changes: false)
-          register("resources/list", handler, broadcast_changes:)
-        end
-
-        def read(handler, allow_subscriptions: false)
-          register("resources/read", handler, allow_subscriptions:)
-        end
-      end
-    end
-  end
-end

data/lib/model_context_protocol/server/router/tools_map.rb

@@ -1,17 +0,0 @@
-module ModelContextProtocol
-  class Server
-    class Router
-      ##
-      # Maps tool operations to handlers.
-      class ToolsMap < BaseMap
-        def list(handler, broadcast_changes: false)
-          register("tools/list", handler, broadcast_changes:)
-        end
-
-        def call(handler)
-          register("tools/call", handler)
-        end
-      end
-    end
-  end
-end