model-context-protocol-rb 0.3.4 → 0.5.0

data/lib/model_context_protocol/server/tool.rb

@@ -2,6 +2,13 @@ require "json-schema"
 
 module ModelContextProtocol
   class Server::Tool
+    # Raised when output schema validation fails.
+    class OutputSchemaValidationError < StandardError; end
+
+    include ModelContextProtocol::Server::Cancellable
+    include ModelContextProtocol::Server::ContentHelpers
+    include ModelContextProtocol::Server::Progressable
+
     attr_reader :arguments, :context, :logger
 
     def initialize(arguments, logger, context = {})
@@ -15,58 +22,58 @@ module ModelContextProtocol
       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
-
+    Response = Data.define(:content) do
       def serialized
-        {content: [{type: "image", data:, mimeType: mime_type}], isError: false}
+        serialized_contents = content.map(&:serialized)
+        {content: serialized_contents, 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
+    private_constant :Response
 
+    StructuredContentResponse = Data.define(:structured_content, :tool) do
       def serialized
-        {content: [{type: "resource", resource: {uri:, mimeType: mime_type, text:}}], isError: false}
+        json_text = JSON.generate(structured_content)
+        text_content = ModelContextProtocol::Server::Content::Text[
+          meta: nil,
+          annotations: nil,
+          text: json_text
+        ]
+
+        validation_errors = JSON::Validator.fully_validate(
+          tool.class.definition[:outputSchema], structured_content
+        )
+
+        if validation_errors.empty?
+          {
+            structuredContent: structured_content,
+            content: [text_content.serialized],
+            isError: false
+          }
+        else
+          raise OutputSchemaValidationError, validation_errors.join(", ")
+        end
       end
     end
-    private_constant :ResourceResponse
+    private_constant :StructuredContentResponse
 
-    ToolErrorResponse = Data.define(:text) do
+    ErrorResponse = Data.define(:error) do
       def serialized
-        {content: [{type: "text", text:}], isError: true}
+        {content: [{type: "text", text: error}], 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:]
+    private_constant :ErrorResponse
+
+    private def respond_with(**kwargs)
+      case [kwargs]
+      in [{content:}]
+        content_array = content.is_a?(Array) ? content : [content]
+        Response[content: content_array]
+      in [{structured_content:}]
+        StructuredContentResponse[structured_content:, tool: self]
+      in [{error:}]
+        ErrorResponse[error:]
       else
-        raise ModelContextProtocol::Server::ResponseArgumentsError, "Invalid arguments: #{type}, #{options}"
+        raise ModelContextProtocol::Server::ResponseArgumentsError, "Invalid arguments: #{kwargs.inspect}"
       end
     end
 
@@ -75,39 +82,48 @@ module ModelContextProtocol
     end
 
     class << self
-      attr_reader :name, :description, :input_schema
+      attr_reader :name, :description, :title, :input_schema, :output_schema
 
-      def with_metadata(&block)
-        metadata_dsl = MetadataDSL.new
-        metadata_dsl.instance_eval(&block)
+      def define(&block)
+        definition_dsl = DefinitionDSL.new
+        definition_dsl.instance_eval(&block)
 
-        @name = metadata_dsl.name
-        @description = metadata_dsl.description
-        @input_schema = metadata_dsl.input_schema
+        @name = definition_dsl.name
+        @description = definition_dsl.description
+        @title = definition_dsl.title
+        @input_schema = definition_dsl.input_schema
+        @output_schema = definition_dsl.output_schema
       end
 
       def inherited(subclass)
         subclass.instance_variable_set(:@name, @name)
         subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@title, @title)
         subclass.instance_variable_set(:@input_schema, @input_schema)
+        subclass.instance_variable_set(:@output_schema, @output_schema)
       end
 
       def call(arguments, logger, context = {})
         new(arguments, logger, context).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 OutputSchemaValidationError, ModelContextProtocol::Server::ResponseArgumentsError => tool_error
+        raise tool_error, tool_error.message
+      rescue Server::Cancellable::CancellationError
+        raise
       rescue => error
-        ToolErrorResponse[text: error.message]
+        ErrorResponse[error: error.message]
       end
 
-      def metadata
-        {name: @name, description: @description, inputSchema: @input_schema}
+      def definition
+        result = {name: @name, description: @description, inputSchema: @input_schema}
+        result[:title] = @title if @title
+        result[:outputSchema] = @output_schema if @output_schema
+        result
       end
     end
 
-    class MetadataDSL
+    class DefinitionDSL
       def name(value = nil)
         @name = value if value
         @name
@@ -118,10 +134,20 @@ module ModelContextProtocol
         @description
       end
 
+      def title(value = nil)
+        @title = value if value
+        @title
+      end
+
       def input_schema(&block)
         @input_schema = instance_eval(&block) if block_given?
         @input_schema
       end
+
+      def output_schema(&block)
+        @output_schema = instance_eval(&block) if block_given?
+        @output_schema
+      end
     end
   end
 end

data/lib/model_context_protocol/server.rb

@@ -8,7 +8,7 @@ module ModelContextProtocol
     # Raised when invalid parameters are provided.
     class ParameterValidationError < StandardError; end
 
-    attr_reader :configuration, :router
+    attr_reader :configuration, :router, :transport
 
     def initialize
       @configuration = Configuration.new
@@ -20,7 +20,7 @@ module ModelContextProtocol
     def start
       configuration.validate!
 
-      transport = case configuration.transport_type
+      @transport = case configuration.transport_type
       when :stdio, nil
         StdioTransport.new(router: @router, configuration: @configuration)
       when :streamable_http
@@ -32,21 +32,26 @@ module ModelContextProtocol
         raise ArgumentError, "Unknown transport: #{configuration.transport_type}"
       end
 
-      transport.handle
+      @transport.handle
     end
 
     private
 
-    PROTOCOL_VERSION = "2025-06-18".freeze
-    private_constant :PROTOCOL_VERSION
+    SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18"].freeze
+    private_constant :SUPPORTED_PROTOCOL_VERSIONS
 
-    InitializeResponse = Data.define(:protocol_version, :capabilities, :server_info) do
+    LATEST_PROTOCOL_VERSION = SUPPORTED_PROTOCOL_VERSIONS.first
+    private_constant :LATEST_PROTOCOL_VERSION
+
+    InitializeResponse = Data.define(:protocol_version, :capabilities, :server_info, :instructions) do
       def serialized
-        {
+        response = {
           protocolVersion: protocol_version,
           capabilities: capabilities,
           serverInfo: server_info
         }
+        response[:instructions] = instructions if instructions
+        response
       end
     end
 
@@ -63,14 +68,26 @@ module ModelContextProtocol
     end
 
     def map_handlers
-      router.map("initialize") do |_message|
+      router.map("initialize") do |message|
+        client_protocol_version = message["params"]&.dig("protocolVersion")
+
+        negotiated_version = if client_protocol_version && SUPPORTED_PROTOCOL_VERSIONS.include?(client_protocol_version)
+          client_protocol_version
+        else
+          LATEST_PROTOCOL_VERSION
+        end
+
+        server_info = {
+          name: configuration.name,
+          version: configuration.version
+        }
+        server_info[:title] = configuration.title if configuration.title
+
         InitializeResponse[
-          protocol_version: PROTOCOL_VERSION,
+          protocol_version: negotiated_version,
           capabilities: build_capabilities,
-          server_info: {
-            name: configuration.name,
-            version: configuration.version
-          }
+          server_info: server_info,
+          instructions: configuration.instructions
         ]
       end
 
@@ -112,8 +129,28 @@ module ModelContextProtocol
         end
       end
 
-      router.map("resources/list") do
-        configuration.registry.resources_data
+      router.map("resources/list") do |message|
+        params = message["params"] || {}
+
+        if configuration.pagination_enabled? && Server::Pagination.pagination_requested?(params)
+          opts = configuration.pagination_options
+
+          pagination_params = Server::Pagination.extract_pagination_params(
+            params,
+            default_page_size: opts[:default_page_size],
+            max_page_size: opts[:max_page_size]
+          )
+
+          configuration.registry.resources_data(
+            cursor: pagination_params[:cursor],
+            page_size: pagination_params[:page_size],
+            cursor_ttl: opts[:cursor_ttl]
+          )
+        else
+          configuration.registry.resources_data
+        end
+      rescue Server::Pagination::InvalidCursorError => e
+        raise ParameterValidationError, e.message
       end
 
       router.map("resources/read") do |message|
@@ -123,15 +160,55 @@ module ModelContextProtocol
           raise ModelContextProtocol::Server::ParameterValidationError, "resource not found for #{uri}"
         end
 
-        resource.call(configuration.logger, configuration.context)
+        resource.call
       end
 
       router.map("resources/templates/list") do |message|
-        configuration.registry.resource_templates_data
+        params = message["params"] || {}
+
+        if configuration.pagination_enabled? && Server::Pagination.pagination_requested?(params)
+          opts = configuration.pagination_options
+
+          pagination_params = Server::Pagination.extract_pagination_params(
+            params,
+            default_page_size: opts[:default_page_size],
+            max_page_size: opts[:max_page_size]
+          )
+
+          configuration.registry.resource_templates_data(
+            cursor: pagination_params[:cursor],
+            page_size: pagination_params[:page_size],
+            cursor_ttl: opts[:cursor_ttl]
+          )
+        else
+          configuration.registry.resource_templates_data
+        end
+      rescue Server::Pagination::InvalidCursorError => e
+        raise ParameterValidationError, e.message
       end
 
-      router.map("prompts/list") do
-        configuration.registry.prompts_data
+      router.map("prompts/list") do |message|
+        params = message["params"] || {}
+
+        if configuration.pagination_enabled? && Server::Pagination.pagination_requested?(params)
+          opts = configuration.pagination_options
+
+          pagination_params = Server::Pagination.extract_pagination_params(
+            params,
+            default_page_size: opts[:default_page_size],
+            max_page_size: opts[:max_page_size]
+          )
+
+          configuration.registry.prompts_data(
+            cursor: pagination_params[:cursor],
+            page_size: pagination_params[:page_size],
+            cursor_ttl: opts[:cursor_ttl]
+          )
+        else
+          configuration.registry.prompts_data
+        end
+      rescue Server::Pagination::InvalidCursorError => e
+        raise ParameterValidationError, e.message
       end
 
       router.map("prompts/get") do |message|
@@ -143,8 +220,28 @@ module ModelContextProtocol
           .call(symbolized_arguments, configuration.logger, configuration.context)
       end
 
-      router.map("tools/list") do
-        configuration.registry.tools_data
+      router.map("tools/list") do |message|
+        params = message["params"] || {}
+
+        if configuration.pagination_enabled? && Server::Pagination.pagination_requested?(params)
+          opts = configuration.pagination_options
+
+          pagination_params = Server::Pagination.extract_pagination_params(
+            params,
+            default_page_size: opts[:default_page_size],
+            max_page_size: opts[:max_page_size]
+          )
+
+          configuration.registry.tools_data(
+            cursor: pagination_params[:cursor],
+            page_size: pagination_params[:page_size],
+            cursor_ttl: opts[:cursor_ttl]
+          )
+        else
+          configuration.registry.tools_data
+        end
+      rescue Server::Pagination::InvalidCursorError => e
+        raise ParameterValidationError, e.message
       end
 
       router.map("tools/call") do |message|
@@ -184,5 +281,11 @@ module ModelContextProtocol
         end
       end
     end
+
+    class << self
+      def configure_redis(&block)
+        RedisConfig.configure(&block)
+      end
+    end
   end
 end

data/lib/model_context_protocol/version.rb

@@ -1,3 +1,3 @@
 module ModelContextProtocol
-  VERSION = "0.3.4"
+  VERSION = "0.5.0"
 end

data/tasks/mcp.rake

@@ -1,8 +1,8 @@
 require "fileutils"
 
 namespace :mcp do
-  desc "Generate the development server executable with the correct Ruby path"
-  task :generate_executable do
+  desc "Generate the STDIO development server executable with the correct Ruby path"
+  task :generate_stdio_server do
     destination_path = "bin/dev"
     template_path = File.expand_path("templates/dev.erb", __dir__)
 
@@ -27,6 +27,32 @@ namespace :mcp do
     puts "Using Ruby path: #{ruby_path}"
   end
 
+  desc "Generate the streamable HTTP development server executable with the correct Ruby path"
+  task :generate_streamable_http_server do
+    destination_path = "bin/dev-http"
+    template_path = File.expand_path("templates/dev-http.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