model-context-protocol-rb 0.3.3 → 0.4.0

data/lib/model_context_protocol/server.rb

@@ -37,16 +37,21 @@ module ModelContextProtocol
 
     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|

data/lib/model_context_protocol/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module ModelContextProtocol
-  VERSION = "0.3.3"
+  VERSION = "0.4.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

data/tasks/templates/dev-http.erb

@@ -0,0 +1,244 @@
+#!/usr/bin/env <%= @ruby_path %>
+
+require "bundler/setup"
+require "rack"
+require 'rackup/handler/webrick'
+require "webrick"
+require "securerandom"
+require "redis"
+require "logger"
+require "json"
+require 'stringio'
+
+require_relative "../lib/model_context_protocol"
+
+Dir[File.join(__dir__, "../spec/support/**/*.rb")].each { |file| require file }
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::INFO
+logger.formatter = proc do |severity, datetime, progname, msg|
+  request_id = Thread.current[:request_id] || "----"
+  "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity} [#{request_id}]: #{msg}\n"
+end
+
+
+class MCPHttpApp
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def call(env)
+    request_id = SecureRandom.hex(4)
+    Thread.current[:request_id] = request_id
+
+    request = Rack::Request.new(env)
+    body_content = request.body.read
+
+    case env['REQUEST_METHOD']
+    when 'POST'
+      begin
+        request_json = JSON.parse(body_content)
+        method = request_json['method']
+        id = request_json['id']
+
+        if method&.start_with?('notifications/')
+          @logger.info("→ #{method} [NOTIFICATION]")
+        elsif id.nil?
+          @logger.info("→ #{method} [NOTIFICATION]")
+        else
+          @logger.info("→ #{method} (id: #{id}) [REQUEST]")
+        end
+        @logger.info("  Request: #{body_content}")
+      rescue JSON::ParserError
+        @logger.info("→ POST #{env['PATH_INFO']} [INVALID JSON]")
+        @logger.info("  Request: #{body_content}")
+      end
+    when 'GET'
+      accept_header = env['HTTP_ACCEPT'] || ''
+      if accept_header.include?('text/event-stream')
+        @logger.info("→ GET #{env['PATH_INFO']} [SSE STREAM REQUEST]")
+      else
+        @logger.info("→ GET #{env['PATH_INFO']}")
+      end
+      @logger.info("  Headers: Accept=#{accept_header}") unless accept_header.empty?
+    when 'DELETE'
+      session_id = env['HTTP_MCP_SESSION_ID']
+      if session_id
+        @logger.info("→ DELETE #{env['PATH_INFO']} [SESSION CLEANUP: #{session_id}]")
+      else
+        @logger.info("→ DELETE #{env['PATH_INFO']} [SESSION CLEANUP]")
+      end
+    else
+      @logger.info("→ #{env['REQUEST_METHOD']} #{env['PATH_INFO']}")
+      @logger.info("  Request: #{body_content}") unless body_content.empty?
+    end
+
+    env['rack.input'] = StringIO.new(body_content)
+    request = Rack::Request.new(env)
+
+    unless request.path == "/mcp"
+      return [404, {"Content-Type" => "application/json"}, ['{"error": "Not found"}']]
+    end
+
+    if request.request_method == "OPTIONS"
+      return [200, {
+        "Access-Control-Allow-Origin" => "*",
+        "Access-Control-Allow-Methods" => "GET, POST, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers" => "Content-Type, Accept, Mcp-Session-Id, MCP-Protocol-Version, Origin",
+        "Access-Control-Max-Age" => "86400"
+      }, [""]]
+    end
+
+    begin
+      redis_client = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      @logger.debug("Testing Redis connection...")
+      redis_client.ping
+      @logger.info("Redis connected successfully")
+    end
+
+    transport_config = {
+      type: :streamable_http,
+      env: env,
+      redis_client: redis_client,
+      require_sessions: false,  # Optional sessions for easier testing
+      session_ttl: 3600,
+      validate_origin: false,   # Disable for testing
+      allowed_origins: ["*"]
+    }
+
+    @logger.debug("Creating MCP server with transport config")
+    server = create_mcp_server(transport_config)
+
+    begin
+      @logger.debug("Starting MCP server")
+      result = server.start
+
+      case result
+      when Hash
+        if result[:stream]
+          @logger.info("← SSE STREAM OPENED [PERSISTENT CONNECTION]")
+          @logger.info("  Connection will remain open for real-time notifications")
+          headers = result[:headers] || {}
+          headers["Access-Control-Allow-Origin"] = "*"
+          headers["Access-Control-Allow-Methods"] = "GET, POST, DELETE, OPTIONS"
+          headers["Access-Control-Allow-Headers"] = "Content-Type, Accept, Mcp-Session-Id, MCP-Protocol-Version, Origin"
+
+          return [200, headers, result[:stream_proc]]
+        elsif result[:json]
+          response_body = result[:json].to_json
+          status = result[:status] || 200
+
+          begin
+            response_json = result[:json]
+            if response_json[:error]
+              @logger.info("← ERROR RESPONSE (code: #{response_json[:error][:code]})")
+            elsif status == 202
+              @logger.info("← NOTIFICATION ACCEPTED [NO RESPONSE REQUIRED]")
+            elsif response_json[:result]
+              method = request_json['method'] rescue 'unknown'
+              @logger.info("← #{method} RESPONSE (id: #{response_json[:id]})")
+            else
+              @logger.info("← RESPONSE (status: #{status})")
+            end
+            @logger.info("  Response: #{response_body}") unless status == 202 && response_body == '{}'
+          rescue
+            @logger.info("← RESPONSE (status: #{status})")
+            @logger.info("  Response: #{response_body}") unless response_body.empty?
+          end
+
+          headers = result[:headers] || {}
+          headers["Content-Type"] = "application/json"
+          headers["Access-Control-Allow-Origin"] = "*"
+          headers["Access-Control-Allow-Methods"] = "GET, POST, DELETE, OPTIONS" 
+          headers["Access-Control-Allow-Headers"] = "Content-Type, Accept, Mcp-Session-Id, MCP-Protocol-Version, Origin"
+
+          [result[:status] || 200, headers, [response_body]]
+        else
+          # Fallback
+          @logger.error("← Invalid transport response")
+          [500, {"Content-Type" => "application/json"}, ['{"error": "Invalid transport response"}']]
+        end
+      else
+        @logger.error("← Unexpected response format")
+        [500, {"Content-Type" => "application/json"}, ['{"error": "Unexpected response format"}']]
+      end
+    rescue => e
+      @logger.error("Error handling request: #{e.message}")
+      @logger.debug("Full backtrace:\n#{e.backtrace.join("\n")}")
+      [500, {"Content-Type" => "application/json"}, [%Q({"error": "Internal server error: #{e.message}"})]]
+    ensure
+      Thread.current[:request_id] = nil
+    end
+  end
+
+  private
+
+  def create_mcp_server(transport_config)
+    ModelContextProtocol::Server.new do |config|
+      config.name = "MCP Development Server"
+      config.version = "1.0.0"
+      config.logging_enabled = true
+
+      config.pagination = {
+        default_page_size: 2,
+        max_page_size: 3,
+        cursor_ttl: 1800
+      }
+
+      config.set_environment_variable("MCP_ENV", "development")
+
+      config.context = {
+        user_id: "123456",
+        request_id: Thread.current[:request_id]
+      }
+
+      config.transport = transport_config
+
+      config.registry = ModelContextProtocol::Server::Registry.new do
+        prompts list_changed: true do
+          register TestPrompt
+          register TestPromptWithCompletionClass
+        end
+
+        resources list_changed: true, subscribe: true do
+          register TestResource
+          register TestAnnotatedResource
+          register TestBinaryResource
+        end
+
+        resource_templates do
+          register TestResourceTemplate
+        end
+
+        tools list_changed: true do
+          register TestToolWithStructuredContentResponse
+          register TestToolWithTextResponse
+          register TestToolWithImageResponse
+          register TestToolWithMixedContentResponse
+          register TestToolWithResourceResponse
+          register TestToolWithToolErrorResponse
+        end
+      end
+    end
+  end
+end
+
+logger.info("Starting MCP HTTP Development Server on http://localhost:9292/mcp")
+
+app = Rack::Builder.new do
+  map '/mcp' do
+    run MCPHttpApp.new(logger)
+  end
+end
+
+server = WEBrick::HTTPServer.new(Port: 9292, Host: '0.0.0.0')
+server.mount '/', Rackup::Handler::WEBrick, app
+
+['INT', 'TERM'].each do |signal|
+  Signal.trap(signal) do
+    server.shutdown
+    exit(0)
+  end
+end
+
+server.start

data/tasks/templates/dev.erb

@@ -11,6 +11,12 @@ server = ModelContextProtocol::Server.new do |config|
   config.version = "1.0.0"
   config.logging_enabled = true
 
+  config.pagination = {
+    default_page_size: 10,
+    max_page_size: 20,
+    cursor_ttl: 1800
+  }
+
   config.set_environment_variable("MCP_ENV", "development")
 
   config.context = {
@@ -25,6 +31,7 @@ server = ModelContextProtocol::Server.new do |config|
 
     resources list_changed: true, subscribe: true do
       register TestResource
+      register TestAnnotatedResource
       register TestBinaryResource
     end
 
@@ -37,7 +44,6 @@ server = ModelContextProtocol::Server.new do |config|
       register TestToolWithImageResponse
       register TestToolWithImageResponseDefaultMimeType
       register TestToolWithResourceResponse
-      register TestToolWithResourceResponseDefaultMimeType
       register TestToolWithToolErrorResponse
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-02 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -58,7 +58,10 @@ files:
 - lib/model_context_protocol/server.rb
 - lib/model_context_protocol/server/completion.rb
 - lib/model_context_protocol/server/configuration.rb
+- lib/model_context_protocol/server/content.rb
+- lib/model_context_protocol/server/content_helpers.rb
 - lib/model_context_protocol/server/mcp_logger.rb
+- lib/model_context_protocol/server/pagination.rb
 - lib/model_context_protocol/server/prompt.rb
 - lib/model_context_protocol/server/registry.rb
 - lib/model_context_protocol/server/resource.rb
@@ -70,6 +73,7 @@ files:
 - lib/model_context_protocol/server/tool.rb
 - lib/model_context_protocol/version.rb
 - tasks/mcp.rake
+- tasks/templates/dev-http.erb
 - tasks/templates/dev.erb
 homepage: https://github.com/dickdavis/model-context-protocol-rb
 licenses: