model-context-protocol-rb 0.2.0 → 0.3.1

data/lib/model_context_protocol/server/resource.rb

@@ -0,0 +1,67 @@
+module ModelContextProtocol
+  class Server::Resource
+    attr_reader :mime_type, :uri
+
+    def initialize
+      @mime_type = self.class.mime_type
+      @uri = self.class.uri
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    TextResponse = Data.define(:resource, :text) do
+      def serialized
+        {contents: [{mimeType: resource.mime_type, text:, uri: resource.uri}]}
+      end
+    end
+    private_constant :TextResponse
+
+    BinaryResponse = Data.define(:blob, :resource) do
+      def serialized
+        {contents: [{blob:, mimeType: resource.mime_type, uri: resource.uri}]}
+      end
+    end
+    private_constant :BinaryResponse
+
+    private def respond_with(type, **options)
+      case [type, options]
+      in [:text, {text:}]
+        TextResponse[resource: self, text:]
+      in [:binary, {blob:}]
+        BinaryResponse[blob:, resource: self]
+      else
+        raise ModelContextProtocol::Server::ResponseArgumentsError, "Invalid arguments: #{type}, #{options}"
+      end
+    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,36 @@
-# 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
-
-      def register_protocol_routes
-        register("initialize") do |_message|
-          {
-            protocolVersion: ModelContextProtocol::Server::PROTOCOL_VERSION,
-            capabilities: build_capabilities,
-            serverInfo: server_info
-          }
-        end
+  class Server::Router
+    # Raised when an invalid method is provided.
+    class MethodNotFoundError < StandardError; 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 initialize(configuration: nil)
+      @handlers = {}
+      @configuration = configuration
+    end
 
-      def has_resource_routes?
-        @routes.key?("resources/list") || @routes.key?("resources/read")
-      end
+    def map(method, &handler)
+      @handlers[method] = handler
+    end
 
-      def resource_broadcasts_changes?
-        @routes.dig("resources/list", :options, :broadcast_changes)
-      end
+    def route(message)
+      method = message["method"]
+      handler = @handlers[method]
+      raise MethodNotFoundError, "Method not found: #{method}" unless handler
 
-      def resource_allows_subscriptions?
-        @routes.dig("resources/read", :options, :allow_subscriptions)
+      with_environment(@configuration&.environment_variables) do
+        handler.call(message)
       end
+    end
 
-      def has_tool_routes?
-        @routes.key?("tools/list") || @routes.key?("tools/call")
-      end
+    private
 
-      def tool_broadcasts_changes?
-        @routes.dig("tools/list", :options, :broadcast_changes)
-      end
+    def with_environment(vars)
+      original = ENV.to_h
+      vars&.each { |key, value| ENV[key] = value }
+      yield
+    ensure
+      ENV.clear
+      original.each { |key, value| ENV[key] = value }
     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,107 @@
+require "json-schema"
+
+module ModelContextProtocol
+  class Server::Tool
+    attr_reader :params
+
+    def initialize(params)
+      validate!(params)
+      @params = params
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    TextResponse = Data.define(:text) do
+      def serialized
+        {content: [{type: "text", text:}], isError: false}
+      end
+    end
+    private_constant :TextResponse
+
+    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
+    private_constant :ImageResponse
+
+    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
+    private_constant :ResourceResponse
+
+    ToolErrorResponse = Data.define(:text) do
+      def serialized
+        {content: [{type: "text", text:}], isError: true}
+      end
+    end
+    private_constant :ToolErrorResponse
+
+    private def respond_with(type, **options)
+      case [type, options]
+      in [:text, {text:}]
+        TextResponse[text:]
+      in [:image, {data:, mime_type:}]
+        ImageResponse[data:, mime_type:]
+      in [:image, {data:}]
+        ImageResponse[data:]
+      in [:resource, {mime_type:, text:, uri:}]
+        ResourceResponse[mime_type:, text:, uri:]
+      in [:resource, {text:, uri:}]
+        ResourceResponse[text:, uri:]
+      in [:error, {text:}]
+        ToolErrorResponse[text:]
+      else
+        raise ModelContextProtocol::Server::ResponseArgumentsError, "Invalid arguments: #{type}, #{options}"
+      end
+    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 => validation_error
+        raise ModelContextProtocol::Server::ParameterValidationError, validation_error.message
+      rescue ModelContextProtocol::Server::ResponseArgumentsError => response_arguments_error
+        raise response_arguments_error
+      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,115 @@
-require "json"
+require "logger"
 
 module ModelContextProtocol
   class Server
-    class Configuration
-      attr_accessor :enable_log, :name, :router, :version
+    # Raised when invalid response arguments are provided.
+    class ResponseArgumentsError < StandardError; end
 
-      def logging_enabled?
-        enable_log || false
-      end
+    # Raised when invalid parameters are provided.
+    class ParameterValidationError < StandardError; end
 
-      def validate!
-        raise InvalidServerNameError unless valid_name?
-        raise InvalidRouterError unless valid_router?
-        raise InvalidServerVersionError unless valid_version?
-      end
+    attr_reader :configuration, :router
 
-      private
+    def initialize
+      @configuration = Configuration.new
+      yield(@configuration) if block_given?
+      @router = Router.new(configuration:)
+      map_handlers
+    end
 
-      def valid_name?
-        true
-      end
+    def start
+      configuration.validate!
+      logdev = configuration.logging_enabled? ? $stderr : File::NULL
+      StdioTransport.new(logger: Logger.new(logdev), router:).begin
+    end
 
-      def valid_router?
-        true
-      end
+    private
 
-      def valid_version?
-        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
 
-    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
+    PingResponse = Data.define do
+      def serialized
+        {}
+      end
     end
 
-    def start
-      log("Server starting")
+    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
 
-      configuration.validate!
+      router.map("ping") do
+        PingResponse[]
+      end
 
-      loop do
-        line = $stdin.gets
-        break unless line
+      router.map("resources/list") do
+        configuration.registry.resources_data
+      end
 
-        message = JSON.parse(line.chomp)
-        log("Received message: #{message.inspect}")
+      router.map("resources/read") do |message|
+        configuration.registry.find_resource(message["params"]["uri"]).call
+      end
 
-        response = configuration.router.route(message)
-        send_response(message["id"], response) if response
+      router.map("prompts/list") do
+        configuration.registry.prompts_data
       end
-    rescue => e
-      log("Error: #{e.message}")
-      log(e.backtrace)
-    end
 
-    private
+      router.map("prompts/get") do |message|
+        configuration.registry.find_prompt(message["params"]["name"]).call(message["params"]["arguments"])
+      end
 
-    def log(output)
-      warn(output) if configuration.logging_enabled?
-    end
+      router.map("tools/list") do
+        configuration.registry.tools_data
+      end
 
-    def send_response(id, result)
-      return unless result
+      router.map("tools/call") do |message|
+        configuration.registry.find_tool(message["params"]["name"]).call(message["params"]["arguments"])
+      end
+    end
 
-      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.1"
 end

data/tasks/mcp.rake

@@ -0,0 +1,62 @@
+require "fileutils"
+
+namespace :mcp do
+  desc "Generate the development server executable with the correct Ruby path"
+  task :generate_executable do
+    destination_path = "bin/dev"
+    template_path = File.expand_path("templates/dev.erb", __dir__)
+
+    # Create directory if it doesn't exist
+    FileUtils.mkdir_p(File.dirname(destination_path))
+
+    # Get the Ruby path
+    ruby_path = detect_ruby_path
+
+    # Read and process the template
+    template = File.read(template_path)
+    content = template.gsub("<%= @ruby_path %>", ruby_path)
+
+    # Write the executable
+    File.write(destination_path, content)
+
+    # Set permissions
+    FileUtils.chmod(0o755, destination_path)
+
+    # Show success message
+    puts "\nCreated executable at: #{File.expand_path(destination_path)}"
+    puts "Using Ruby path: #{ruby_path}"
+  end
+
+  def detect_ruby_path
+    # Get Ruby version from project config
+    ruby_version = get_project_ruby_version
+
+    if ruby_version && ruby_version.strip != ""
+      # Find the absolute path to the Ruby executable via ASDF
+      asdf_ruby_path = `asdf where ruby #{ruby_version}`.strip
+
+      if asdf_ruby_path && !asdf_ruby_path.empty? && File.directory?(asdf_ruby_path)
+        return File.join(asdf_ruby_path, "bin", "ruby")
+      end
+    end
+
+    # Fallback to current Ruby
+    `which ruby`.strip
+  end
+
+  def get_project_ruby_version
+    # Try ASDF first
+    if File.exist?(".tool-versions")
+      content = File.read(".tool-versions")
+      ruby_line = content.lines.find { |line| line.start_with?("ruby ") }
+      return ruby_line.split[1].strip if ruby_line
+    end
+
+    # Try .ruby-version file
+    if File.exist?(".ruby-version")
+      return File.read(".ruby-version").strip
+    end
+
+    nil
+  end
+end

data/tasks/templates/dev.erb

@@ -0,0 +1,33 @@
+#!/usr/bin/env <%= @ruby_path %>
+
+require "bundler/setup"
+require_relative "../lib/model_context_protocol"
+
+Dir[File.join(__dir__, "../spec/support/**/*.rb")].each { |file| require file }
+
+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
+      register TestBinaryResource
+    end
+
+    tools list_changed: true do
+      register TestToolWithTextResponse
+      register TestToolWithImageResponse
+      register TestToolWithImageResponseDefaultMimeType
+      register TestToolWithResourceResponse
+      register TestToolWithResourceResponseDefaultMimeType
+      register TestToolWithToolErrorResponse
+    end
+  end
+end
+
+server.start