[WIP] refactor to configuration classes

Author: sambostock

lib/mcp/prompt.rb

@@ -2,80 +2,29 @@
 # frozen_string_literal: true
 
 module MCP
-  class Prompt
-    class << self
-      NOT_SET = Object.new
-
-      attr_reader :description_value
-      attr_reader :arguments_value
-
-      def template(args, server_context:)
-        raise NotImplementedError, "Subclasses must implement template"
-      end
-
-      def to_h
-        { name: name_value, description: description_value, arguments: arguments_value.map(&:to_h) }.compact
-      end
-
-      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
+  module Prompt
+    class Definition
+      attr_reader :name, :description, :arguments, :to_h
 
-      def name_value
-        @name_value || StringUtils.handle_from_class_name(name)
-      end
+      def initialize(name:, description:, arguments:, &block)
+        @name = name
+        @description = description
+        @arguments = arguments
+        @block = block
 
-      def description(value = NOT_SET)
-        if value == NOT_SET
-          @description_value
-        else
-          @description_value = value
-        end
-      end
+        @to_h = { name:, description:, arguments: arguments.map(&:to_h) }.compact.freeze
 
-      def arguments(value = NOT_SET)
-        if value == NOT_SET
-          @arguments_value
-        else
-          @arguments_value = value
-        end
+        freeze
       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
+      def call(args, server_context:)
+        block.call(args, server_context:)
       end
+    end
 
-      def validate_arguments!(args)
-        missing = required_args - args.keys
-        return if missing.empty?
-
-        raise MCP::Server::RequestHandlerError.new(
-          "Missing required arguments: #{missing.join(", ")}", nil, error_type: :missing_required_arguments
-        )
-      end
-
-      private
-
-      def required_args
-        arguments_value.filter_map { |arg| arg.name.to_sym if arg.required }
+    class << self
+      def define(name:, description: nil, arguments: [], &block)
+        Definition.new(name:, description:, arguments:, &block)
       end
     end
   end

lib/mcp/prompt/argument.rb

@@ -4,17 +4,20 @@
 module MCP
   class 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/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

@@ -201,28 +201,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
+        tool.call(**arguments.transform_keys(&:to_sym), server_context:).to_h
       rescue => e
         raise RequestHandlerError.new("Internal error calling tool #{tool_name}", request, original_error: e)
       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 +236,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.to_sym
+        next if provided_arguments.key?(key)
 
-      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 +291,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

@@ -8,11 +8,10 @@ class Server
     module Transports
       class StdioTransport < Transport
         def initialize(server)
-          @server = server
+          super
           @open = false
           $stdin.set_encoding("UTF-8")
           $stdout.set_encoding("UTF-8")
-          super
         end
 
         def open