[WIP] refactor to configuration classes

tests

stuff

Author: sambostock

lib/mcp/prompt.rb

@@ -2,81 +2,36 @@
 # frozen_string_literal: true
 
 module MCP
-  class Prompt
-    class << self
-      NOT_SET = Object.new
-
-      attr_reader :description_value
-      attr_reader :arguments_value
+  module Prompt
+    attr_reader :name, :description, :arguments, :to_h
 
-      def template(args, server_context:)
-        raise NotImplementedError, "Subclasses must implement template"
-      end
+    class << self
+      def define(...) = new(...)
+      private :new
 
-      def to_h
-        { name: name_value, description: description_value, arguments: arguments_value.map(&:to_h) }.compact
-      end
+      private
 
       def inherited(subclass)
         super
-        subclass.instance_variable_set(:@name_value, nil)
-        subclass.instance_variable_set(:@description_value, nil)
-        subclass.instance_variable_set(:@arguments_value, nil)
-      end
-
-      def prompt_name(value = NOT_SET)
-        if value == NOT_SET
-          @name_value
-        else
-          @name_value = value
-        end
-      end
-
-      def name_value
-        @name_value || StringUtils.handle_from_class_name(name)
-      end
-
-      def description(value = NOT_SET)
-        if value == NOT_SET
-          @description_value
-        else
-          @description_value = value
-        end
-      end
-
-      def arguments(value = NOT_SET)
-        if value == NOT_SET
-          @arguments_value
-        else
-          @arguments_value = value
-        end
+        raise TypeError, "#{self} should no longer be subclassed. Use #{self}.define factory method instead."
       end
+    end
 
-      def define(name: nil, description: nil, arguments: [], &block)
-        Class.new(self) do
-          prompt_name name
-          description description
-          arguments arguments
-          define_singleton_method(:template) do |args, server_context:|
-            instance_exec(args, server_context:, &block)
-          end
-        end
-      end
+    def initialize(name:, description:, arguments:, &block)
+      arguments = arguments.map { |arg| Hash === arg ? Argument.new(**arg) : arg }
 
-      def validate_arguments!(args)
-        missing = required_args - args.keys
-        return if missing.empty?
+      @name = name
+      @description = description
+      @arguments = arguments
+      @block = block
 
-        raise MCP::Server::RequestHandlerError.new(
-          "Missing required arguments: #{missing.join(", ")}", nil, error_type: :missing_required_arguments
-        )
-      end
+      @to_h = { name:, description:, arguments: arguments.map(&:to_h) }.compact.freeze
 
-      private
+      freeze
+    end
 
-      def required_args
-        arguments_value.filter_map { |arg| arg.name.to_sym if arg.required }
-      end
+    def call(args, server_context:)
+      @block.call(args, server_context:)
     end
   end
 end

lib/mcp/prompt/argument.rb

@@ -2,19 +2,22 @@
 # frozen_string_literal: true
 
 module MCP
-  class Prompt
+  module Prompt
     class Argument
-      attr_reader :name, :description, :required, :arguments
+      attr_reader :name, :description, :required, :to_h
 
       def initialize(name:, description: nil, required: false)
         @name = name
         @description = description
         @required = required
-        @arguments = arguments
-      end
 
-      def to_h
-        { name:, description:, required: }.compact
+        @to_h = {
+          name:,
+          description:,
+          required:,
+        }.compact.freeze
+
+        freeze
       end
     end
   end

lib/mcp/prompt/message.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module MCP
-  class Prompt
+  module Prompt
     class Message
       attr_reader :role, :content
 

lib/mcp/prompt/result.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module MCP
-  class Prompt
+  module Prompt
     class Result
       attr_reader :description, :messages
 

lib/mcp/resource/contents.rb

@@ -20,25 +20,25 @@ class TextContents < Contents
       attr_reader :text
 
       def initialize(text:, uri:, mime_type:)
-        super(uri: uri, mime_type: mime_type)
+        super(uri:, mime_type:)
         @text = text
       end
 
       def to_h
-        super.merge(text: text)
+        super.merge(text:)
       end
     end
 
     class BlobContents < Contents
       attr_reader :data
 
       def initialize(data:, uri:, mime_type:)
-        super(uri: uri, mime_type: mime_type)
+        super(uri:, mime_type:)
         @data = data
       end
 
       def to_h
-        super.merge(data: data)
+        super.merge(data:)
       end
     end
   end

lib/mcp/resource/embedded.rb

@@ -7,6 +7,7 @@ class Embedded
       attr_reader :resource, :annotations
 
       def initialize(resource:, annotations: nil)
+        @resource = resource
         @annotations = annotations
       end
 

lib/mcp/resource_template.rb

@@ -3,22 +3,22 @@
 
 module MCP
   class ResourceTemplate
-    attr_reader :uri_template, :name, :description, :mime_type
+    attr_reader :uri_template, :name, :description, :mime_type, :to_h
 
     def initialize(uri_template:, name:, description: nil, mime_type: nil)
       @uri_template = uri_template
       @name = name
       @description = description
       @mime_type = mime_type
-    end
 
-    def to_h
-      {
+      @to_h = {
         uriTemplate: @uri_template,
         name: @name,
         description: @description,
         mimeType: @mime_type,
-      }.compact
+      }.compact.freeze
+
+      freeze
     end
   end
 end

lib/mcp/server.rb

@@ -11,13 +11,11 @@ class Server
 
     class RequestHandlerError < StandardError
       attr_reader :error_type
-      attr_reader :original_error
 
-      def initialize(message, request, error_type: :internal_error, original_error: nil)
+      def initialize(message, request, error_type: :internal_error)
         super(message)
         @request = request
         @error_type = error_type
-        @original_error = original_error
       end
     end
 
@@ -39,8 +37,8 @@ def initialize(
     )
       @name = name
       @version = version
-      @tools = tools.to_h { |t| [t.name_value, t] }
-      @prompts = prompts.to_h { |p| [p.name_value, p] }
+      @tools = tools.to_h { |t| [t.name, t] }
+      @prompts = prompts.to_h { |p| [p.name, p] }
       @resources = resources
       @resource_templates = resource_templates
       @resource_index = index_resources_by_uri(resources)
@@ -88,12 +86,12 @@ def handle_json(request)
 
     def define_tool(name: nil, description: nil, input_schema: nil, annotations: nil, &block)
       tool = Tool.define(name:, description:, input_schema:, annotations:, &block)
-      @tools[tool.name_value] = tool
+      @tools[tool.name] = tool
     end
 
     def define_prompt(name: nil, description: nil, arguments: [], &block)
       prompt = Prompt.define(name:, description:, arguments:, &block)
-      @prompts[prompt.name_value] = prompt
+      @prompts[prompt.name] = prompt
     end
 
     def resources_list_handler(&block)
@@ -156,14 +154,14 @@ def handle_request(request, method)
             @handlers[method].call(params)
           end
         rescue => e
-          report_exception(e, { request: request })
+          report_exception(e, { request: })
           if e.is_a?(RequestHandlerError)
             add_instrumentation_data(error: e.error_type)
             raise e
           end
 
           add_instrumentation_data(error: :internal_error)
-          raise RequestHandlerError.new("Internal error handling #{method} request", request, original_error: e)
+          raise RequestHandlerError.new("Internal error handling #{method} request", request)
         end
       }
     end
@@ -201,28 +199,24 @@ def call_tool(request)
       arguments = request[:arguments]
       add_instrumentation_data(tool_name:)
 
-      if tool.input_schema&.missing_required_arguments?(arguments)
-        add_instrumentation_data(error: :missing_required_arguments)
-        raise RequestHandlerError.new(
-          "Missing required arguments: #{tool.input_schema.missing_required_arguments(arguments).join(", ")}",
-          request,
-          error_type: :missing_required_arguments,
-        )
-      end
+      validate_tool_arguments!(tool, arguments, request)
 
       begin
-        call_params = tool_call_parameters(tool)
-
-        if call_params.include?(:server_context)
-          tool.call(**arguments.transform_keys(&:to_sym), server_context:).to_h
-        else
-          tool.call(**arguments.transform_keys(&:to_sym)).to_h
-        end
-      rescue => e
-        raise RequestHandlerError.new("Internal error calling tool #{tool_name}", request, original_error: e)
+        tool.call(arguments.transform_keys(&:to_sym), server_context:).to_h
+      rescue
+        raise RequestHandlerError.new("Internal error calling tool #{tool_name}", request)
       end
     end
 
+    def validate_tool_arguments!(tool, arguments, request)
+      input_schema = tool.input_schema
+      return unless input_schema
+
+      missing_arguments = input_schema.required - arguments.keys.map(&:to_sym)
+
+      missing_required_arguments!(missing_arguments, request) unless missing_arguments.empty?
+    end
+
     def list_prompts(request)
       add_instrumentation_data(method: Methods::PROMPTS_LIST)
       @prompts.map { |_, prompt| prompt.to_h }
@@ -240,9 +234,31 @@ def get_prompt(request)
       add_instrumentation_data(prompt_name:)
 
       prompt_args = request[:arguments]
-      prompt.validate_arguments!(prompt_args)
+      validate_prompt_arguments!(prompt, prompt_args, request)
+
+      prompt.call(prompt_args, server_context:).to_h
+    end
+
+    def validate_prompt_arguments!(prompt, provided_arguments, request)
+      missing_arguments = prompt.arguments.filter_map do |configured_argument|
+        next unless configured_argument.required
+
+        key = configured_argument.name
+        next if provided_arguments.key?(key.to_s) || provided_arguments.key?(key.to_sym)
 
-      prompt.template(prompt_args, server_context:).to_h
+        key
+      end
+
+      missing_required_arguments!(missing_arguments, request) unless missing_arguments.empty?
+    end
+
+    def missing_required_arguments!(missing_arguments, request)
+      add_instrumentation_data(error: :missing_required_arguments)
+      raise RequestHandlerError.new(
+        "Missing required arguments: #{missing_arguments.join(", ")}",
+        request,
+        error_type: :missing_required_arguments,
+      )
     end
 
     def list_resources(request)
@@ -273,24 +289,5 @@ def index_resources_by_uri(resources)
         hash[resource.uri] = resource
       end
     end
-
-    def tool_call_parameters(tool)
-      method_def = tool_call_method_def(tool)
-      method_def.parameters.flatten
-    end
-
-    def tool_call_method_def(tool)
-      method = tool.method(:call)
-
-      if defined?(T::Utils) && T::Utils.respond_to?(:signature_for_method)
-        sorbet_typed_method_definition = T::Utils.signature_for_method(method)&.method
-
-        # Return the Sorbet typed method definition if it exists, otherwise fallback to original method
-        # definition if Sorbet is defined but not used by this tool.
-        sorbet_typed_method_definition || method
-      else
-        method
-      end
-    end
   end
 end

lib/mcp/server/transports/stdio_transport.rb

@@ -10,11 +10,10 @@ class StdioTransport < Transport
         STATUS_INTERRUPTED = Signal.list["INT"] + 128
 
         def initialize(server)
-          @server = server
+          super
           @open = false
           $stdin.set_encoding("UTF-8")
           $stdout.set_encoding("UTF-8")
-          super
         end
 
         def open