model-context-protocol-rb 0.3.1 → 0.3.3

data/lib/model_context_protocol/server/stdio_transport.rb

@@ -12,16 +12,19 @@ module ModelContextProtocol
       end
     end
 
-    attr_reader :logger, :router
+    attr_reader :router, :configuration
 
-    def initialize(logger:, router:)
-      @logger = logger
+    def initialize(router:, configuration:)
       @router = router
+      @configuration = configuration
     end
 
-    def begin
+    def handle
+      # Connect logger to transport
+      @configuration.logger.connect_transport(self)
+
       loop do
-        line = $stdin.gets
+        line = receive_message
         break unless line
 
         begin
@@ -31,18 +34,17 @@ module ModelContextProtocol
           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}")
+          @configuration.logger.error("Validation error", 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}")
+          @configuration.logger.error("Parser error", 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)
+          @configuration.logger.error("Internal error", error: error.message, backtrace: error.backtrace.first(5))
           send_message(
             ErrorResponse[id: message["id"], error: {code: -32603, message: error.message}]
           )
@@ -50,10 +52,23 @@ module ModelContextProtocol
       end
     end
 
+    def send_notification(method, params)
+      notification = {
+        jsonrpc: "2.0",
+        method: method,
+        params: params
+      }
+      $stdout.puts(JSON.generate(notification))
+      $stdout.flush
+    rescue IOError => e
+      # Handle broken pipe gracefully
+      @configuration.logger.debug("Failed to send notification", error: e.message) if @configuration.logging_enabled?
+    end
+
     private
 
-    def log(output, level = :error)
-      logger.send(level.to_sym, output)
+    def receive_message
+      $stdin.gets
     end
 
     def send_message(message)

data/lib/model_context_protocol/server/streamable_http_transport.rb

@@ -0,0 +1,291 @@
+require "json"
+require "securerandom"
+
+module ModelContextProtocol
+  class Server::StreamableHttpTransport
+    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
+    def initialize(router:, configuration:)
+      @router = router
+      @configuration = configuration
+
+      transport_options = @configuration.transport_options
+      @redis = transport_options[:redis_client]
+
+      @session_store = ModelContextProtocol::Server::SessionStore.new(
+        @redis,
+        ttl: transport_options[:session_ttl] || 3600
+      )
+
+      @server_instance = "#{Socket.gethostname}-#{Process.pid}-#{SecureRandom.hex(4)}"
+      @local_streams = {}
+      @notification_queue = []
+
+      setup_redis_subscriber
+    end
+
+    def handle
+      @configuration.logger.connect_transport(self)
+
+      request = @configuration.transport_options[:request]
+      response = @configuration.transport_options[:response]
+
+      unless request && response
+        raise ArgumentError, "StreamableHTTP transport requires request and response objects in transport_options"
+      end
+
+      case request.method
+      when "POST"
+        handle_post_request(request)
+      when "GET"
+        handle_sse_request(request, response)
+      when "DELETE"
+        handle_delete_request(request)
+      else
+        error_response = ErrorResponse[id: nil, error: {code: -32601, message: "Method not allowed"}]
+        {json: error_response.serialized, status: 405}
+      end
+    end
+
+    def send_notification(method, params)
+      notification = {
+        jsonrpc: "2.0",
+        method: method,
+        params: params
+      }
+
+      if has_active_streams?
+        deliver_to_active_streams(notification)
+      else
+        @notification_queue << notification
+      end
+    end
+
+    private
+
+    def handle_post_request(request)
+      body_string = request.body.read
+      body = JSON.parse(body_string)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      case body["method"]
+      when "initialize"
+        handle_initialization(body)
+      else
+        handle_regular_request(body, session_id)
+      end
+    rescue JSON::ParserError
+      error_response = ErrorResponse[id: "", error: {code: -32700, message: "Parse error"}]
+      {json: error_response.serialized, status: 400}
+    rescue ModelContextProtocol::Server::ParameterValidationError => validation_error
+      @configuration.logger.error("Validation error", error: validation_error.message)
+      error_response = ErrorResponse[id: body&.dig("id"), error: {code: -32602, message: validation_error.message}]
+      {json: error_response.serialized, status: 400}
+    rescue => e
+      @configuration.logger.error("Error handling POST request", error: e.message, backtrace: e.backtrace.first(5))
+      error_response = ErrorResponse[id: body&.dig("id"), error: {code: -32603, message: "Internal error"}]
+      {json: error_response.serialized, status: 500}
+    end
+
+    def handle_initialization(body)
+      session_id = SecureRandom.uuid
+
+      @session_store.create_session(session_id, {
+        server_instance: @server_instance,
+        context: @configuration.context || {},
+        created_at: Time.now.to_f
+      })
+
+      result = @router.route(body)
+      response = Response[id: body["id"], result: result.serialized]
+
+      {
+        json: response.serialized,
+        status: 200,
+        headers: {"Mcp-Session-Id" => session_id}
+      }
+    end
+
+    def handle_regular_request(body, session_id)
+      unless session_id && @session_store.session_exists?(session_id)
+        error_response = ErrorResponse[id: body["id"], error: {code: -32600, message: "Invalid or missing session ID"}]
+        return {json: error_response.serialized, status: 400}
+      end
+
+      result = @router.route(body)
+      response = Response[id: body["id"], result: result.serialized]
+
+      if @session_store.session_has_active_stream?(session_id)
+        deliver_to_session_stream(session_id, response.serialized)
+        {json: {accepted: true}, status: 200}
+      else
+        {json: response.serialized, status: 200}
+      end
+    end
+
+    def handle_sse_request(request, response)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      unless session_id && @session_store.session_exists?(session_id)
+        error_response = ErrorResponse[id: nil, error: {code: -32600, message: "Invalid or missing session ID"}]
+        return {json: error_response.serialized, status: 400}
+      end
+
+      @session_store.mark_stream_active(session_id, @server_instance)
+
+      {
+        stream: true,
+        headers: {
+          "Content-Type" => "text/event-stream",
+          "Cache-Control" => "no-cache",
+          "Connection" => "keep-alive"
+        },
+        stream_proc: create_sse_stream_proc(session_id)
+      }
+    end
+
+    def handle_delete_request(request)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      if session_id
+        cleanup_session(session_id)
+      end
+
+      {json: {success: true}, status: 200}
+    end
+
+    def create_sse_stream_proc(session_id)
+      proc do |stream|
+        register_local_stream(session_id, stream)
+
+        flush_notifications_to_stream(stream)
+
+        start_keepalive_thread(session_id, stream)
+
+        loop do
+          break unless stream_connected?(stream)
+          sleep 0.1
+        end
+      ensure
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def register_local_stream(session_id, stream)
+      @local_streams[session_id] = stream
+    end
+
+    def cleanup_local_stream(session_id)
+      @local_streams.delete(session_id)
+      @session_store.mark_stream_inactive(session_id)
+    end
+
+    def stream_connected?(stream)
+      return false unless stream
+
+      begin
+        stream.write(": ping\n\n")
+        stream.flush if stream.respond_to?(:flush)
+        true
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+        false
+      end
+    end
+
+    def start_keepalive_thread(session_id, stream)
+      Thread.new do
+        loop do
+          sleep 30
+          break unless stream_connected?(stream)
+
+          begin
+            send_ping_to_stream(stream)
+          rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+            break
+          end
+        end
+      rescue => e
+        @configuration.logger.error("Keepalive thread error", error: e.message)
+      ensure
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def send_ping_to_stream(stream)
+      stream.write(": ping #{Time.now.iso8601}\n\n")
+      stream.flush if stream.respond_to?(:flush)
+    end
+
+    def send_to_stream(stream, data)
+      message = data.is_a?(String) ? data : data.to_json
+      stream.write("data: #{message}\n\n")
+      stream.flush if stream.respond_to?(:flush)
+    end
+
+    def deliver_to_session_stream(session_id, data)
+      if @local_streams[session_id]
+        begin
+          send_to_stream(@local_streams[session_id], data)
+          return true
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+          cleanup_local_stream(session_id)
+        end
+      end
+
+      @session_store.route_message_to_session(session_id, data)
+    end
+
+    def cleanup_session(session_id)
+      cleanup_local_stream(session_id)
+      @session_store.cleanup_session(session_id)
+    end
+
+    def setup_redis_subscriber
+      Thread.new do
+        @session_store.subscribe_to_server(@server_instance) do |data|
+          session_id = data["session_id"]
+          message = data["message"]
+
+          if @local_streams[session_id]
+            begin
+              send_to_stream(@local_streams[session_id], message)
+            rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+              cleanup_local_stream(session_id)
+            end
+          end
+        end
+      rescue => e
+        @configuration.logger.error("Redis subscriber error", error: e.message, backtrace: e.backtrace.first(5))
+        sleep 5
+        retry
+      end
+    end
+
+    def has_active_streams?
+      @local_streams.any?
+    end
+
+    def deliver_to_active_streams(notification)
+      @local_streams.each do |session_id, stream|
+        send_to_stream(stream, notification)
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def flush_notifications_to_stream(stream)
+      while (notification = @notification_queue.shift)
+        send_to_stream(stream, notification)
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/tool.rb

@@ -2,11 +2,13 @@ require "json-schema"
 
 module ModelContextProtocol
   class Server::Tool
-    attr_reader :params
+    attr_reader :params, :context, :logger
 
-    def initialize(params)
+    def initialize(params, logger, context = {})
       validate!(params)
       @params = params
+      @context = context
+      @logger = logger
     end
 
     def call
@@ -76,11 +78,12 @@ module ModelContextProtocol
       attr_reader :name, :description, :input_schema
 
       def with_metadata(&block)
-        metadata = instance_eval(&block)
+        metadata_dsl = MetadataDSL.new
+        metadata_dsl.instance_eval(&block)
 
-        @name = metadata[:name]
-        @description = metadata[:description]
-        @input_schema = metadata[:inputSchema]
+        @name = metadata_dsl.name
+        @description = metadata_dsl.description
+        @input_schema = metadata_dsl.input_schema
       end
 
       def inherited(subclass)
@@ -89,8 +92,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@input_schema, @input_schema)
       end
 
-      def call(params)
-        new(params).call
+      def call(params, logger, context = {})
+        new(params, logger, context).call
       rescue JSON::Schema::ValidationError => validation_error
         raise ModelContextProtocol::Server::ParameterValidationError, validation_error.message
       rescue ModelContextProtocol::Server::ResponseArgumentsError => response_arguments_error
@@ -103,5 +106,22 @@ module ModelContextProtocol
         {name: @name, description: @description, inputSchema: @input_schema}
       end
     end
+
+    class MetadataDSL
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+
+      def input_schema(&block)
+        @input_schema = instance_eval(&block) if block_given?
+        @input_schema
+      end
+    end
   end
 end

data/lib/model_context_protocol/server.rb

@@ -19,13 +19,25 @@ module ModelContextProtocol
 
     def start
       configuration.validate!
-      logdev = configuration.logging_enabled? ? $stderr : File::NULL
-      StdioTransport.new(logger: Logger.new(logdev), router:).begin
+
+      transport = case configuration.transport_type
+      when :stdio, nil
+        StdioTransport.new(router: @router, configuration: @configuration)
+      when :streamable_http
+        StreamableHttpTransport.new(
+          router: @router,
+          configuration: @configuration
+        )
+      else
+        raise ArgumentError, "Unknown transport: #{configuration.transport_type}"
+      end
+
+      transport.handle
     end
 
     private
 
-    PROTOCOL_VERSION = "2024-11-05".freeze
+    PROTOCOL_VERSION = "2025-06-18".freeze
     private_constant :PROTOCOL_VERSION
 
     InitializeResponse = Data.define(:protocol_version, :capabilities, :server_info) do
@@ -44,6 +56,12 @@ module ModelContextProtocol
       end
     end
 
+    LoggingSetLevelResponse = Data.define do
+      def serialized
+        {}
+      end
+    end
+
     def map_handlers
       router.map("initialize") do |_message|
         InitializeResponse[
@@ -60,12 +78,56 @@ module ModelContextProtocol
         PingResponse[]
       end
 
+      router.map("logging/setLevel") do |message|
+        level = message["params"]["level"]
+
+        unless Configuration::VALID_LOG_LEVELS.include?(level)
+          raise ParameterValidationError, "Invalid log level: #{level}. Valid levels are: #{Configuration::VALID_LOG_LEVELS.join(", ")}"
+        end
+
+        configuration.logger.set_mcp_level(level)
+        LoggingSetLevelResponse[]
+      end
+
+      router.map("completion/complete") do |message|
+        type = message["params"]["ref"]["type"]
+
+        completion_source = case type
+        when "ref/prompt"
+          name = message["params"]["ref"]["name"]
+          configuration.registry.find_prompt(name)
+        when "ref/resource"
+          uri = message["params"]["ref"]["uri"]
+          configuration.registry.find_resource_template(uri)
+        else
+          raise ModelContextProtocol::Server::ParameterValidationError, "ref/type invalid"
+        end
+
+        arg_name, arg_value = message["params"]["argument"].values_at("name", "value")
+
+        if completion_source
+          completion_source.complete_for(arg_name, arg_value)
+        else
+          ModelContextProtocol::Server::NullCompletion.call(arg_name, arg_value)
+        end
+      end
+
       router.map("resources/list") do
         configuration.registry.resources_data
       end
 
       router.map("resources/read") do |message|
-        configuration.registry.find_resource(message["params"]["uri"]).call
+        uri = message["params"]["uri"]
+        resource = configuration.registry.find_resource(uri)
+        unless resource
+          raise ModelContextProtocol::Server::ParameterValidationError, "resource not found for #{uri}"
+        end
+
+        resource.call(configuration.logger, configuration.context)
+      end
+
+      router.map("resources/templates/list") do |message|
+        configuration.registry.resource_templates_data
       end
 
       router.map("prompts/list") do
@@ -73,7 +135,12 @@ module ModelContextProtocol
       end
 
       router.map("prompts/get") do |message|
-        configuration.registry.find_prompt(message["params"]["name"]).call(message["params"]["arguments"])
+        arguments = message["params"]["arguments"]
+        symbolized_arguments = arguments.transform_keys(&:to_sym)
+        configuration
+          .registry
+          .find_prompt(message["params"]["name"])
+          .call(symbolized_arguments, configuration.logger, configuration.context)
       end
 
       router.map("tools/list") do
@@ -81,12 +148,18 @@ module ModelContextProtocol
       end
 
       router.map("tools/call") do |message|
-        configuration.registry.find_tool(message["params"]["name"]).call(message["params"]["arguments"])
+        arguments = message["params"]["arguments"]
+        symbolized_arguments = arguments.transform_keys(&:to_sym)
+        configuration
+          .registry
+          .find_tool(message["params"]["name"])
+          .call(symbolized_arguments, configuration.logger, configuration.context)
       end
     end
 
     def build_capabilities
       {}.tap do |capabilities|
+        capabilities[:completions] = {}
         capabilities[:logging] = {} if configuration.logging_enabled?
 
         registry = configuration.registry
@@ -94,7 +167,7 @@ module ModelContextProtocol
         if registry.prompts_options.any? && !registry.instance_variable_get(:@prompts).empty?
           capabilities[:prompts] = {
             listChanged: registry.prompts_options[:list_changed]
-          }.compact
+          }.except(:completions).compact
         end
 
         if registry.resources_options.any? && !registry.instance_variable_get(:@resources).empty?

data/lib/model_context_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ModelContextProtocol
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/model_context_protocol.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+require "addressable/template"
 
 Dir[File.join(__dir__, "model_context_protocol/", "**", "*.rb")].sort.each { |file| require_relative file }
 

data/tasks/templates/dev.erb

@@ -1,6 +1,7 @@
 #!/usr/bin/env <%= @ruby_path %>
 
 require "bundler/setup"
+require "securerandom"
 require_relative "../lib/model_context_protocol"
 
 Dir[File.join(__dir__, "../spec/support/**/*.rb")].each { |file| require file }
@@ -8,7 +9,15 @@ 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.logging_enabled = true
+
+  config.set_environment_variable("MCP_ENV", "development")
+
+  config.context = {
+    user_id: "123456",
+    request_id: SecureRandom.uuid
+  }
+
   config.registry = ModelContextProtocol::Server::Registry.new do
     prompts list_changed: true do
       register TestPrompt
@@ -19,6 +28,10 @@ server = ModelContextProtocol::Server.new do |config|
       register TestBinaryResource
     end
 
+    resource_templates do
+      register TestResourceTemplate
+    end
+
     tools list_changed: true do
       register TestToolWithTextResponse
       register TestToolWithImageResponse

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-05 00:00:00.000000000 Z
+date: 2025-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 description:
 email:
 - dick@hey.com
@@ -42,12 +56,17 @@ files:
 - Rakefile
 - lib/model_context_protocol.rb
 - 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/mcp_logger.rb
 - lib/model_context_protocol/server/prompt.rb
 - lib/model_context_protocol/server/registry.rb
 - lib/model_context_protocol/server/resource.rb
+- lib/model_context_protocol/server/resource_template.rb
 - lib/model_context_protocol/server/router.rb
+- lib/model_context_protocol/server/session_store.rb
 - lib/model_context_protocol/server/stdio_transport.rb
+- lib/model_context_protocol/server/streamable_http_transport.rb
 - lib/model_context_protocol/server/tool.rb
 - lib/model_context_protocol/version.rb
 - tasks/mcp.rake