model-context-protocol-rb 0.5.0 → 0.6.0

data/lib/model_context_protocol/server/cancellable.rb

@@ -24,8 +24,8 @@ module ModelContextProtocol
       executing_thread = Concurrent::AtomicReference.new(nil)
 
       timer_task = Concurrent::TimerTask.new(execution_interval: interval) do
-        if context && context[:request_store] && context[:request_id]
-          if context[:request_store].cancelled?(context[:request_id])
+        if context && context[:request_store] && context[:jsonrpc_request_id]
+          if context[:request_store].cancelled?(context[:jsonrpc_request_id])
             thread = executing_thread.get
             thread&.raise(CancellationError, "Request was cancelled") if thread&.alive?
           end
@@ -35,9 +35,9 @@ module ModelContextProtocol
       begin
         executing_thread.set(Thread.current)
 
-        if context && context[:request_store] && context[:request_id]
-          if context[:request_store].cancelled?(context[:request_id])
-            raise CancellationError, "Request #{context[:request_id]} was cancelled"
+        if context && context[:request_store] && context[:jsonrpc_request_id]
+          if context[:request_store].cancelled?(context[:jsonrpc_request_id])
+            raise CancellationError, "Request #{context[:jsonrpc_request_id]} was cancelled"
           end
         end
 

data/lib/model_context_protocol/server/{mcp_logger.rb → client_logger.rb}

@@ -3,11 +3,13 @@ require "forwardable"
 require "json"
 
 module ModelContextProtocol
-  class Server::MCPLogger
+  class Server::ClientLogger
     extend Forwardable
 
     def_delegators :@internal_logger, :datetime_format=, :formatter=, :progname, :progname=
 
+    VALID_LOG_LEVELS = %w[debug info notice warning error critical alert emergency].freeze
+
     LEVEL_MAP = {
       "debug" => Logger::DEBUG,
       "info" => Logger::INFO,
@@ -29,11 +31,10 @@ module ModelContextProtocol
     }.freeze
 
     attr_accessor :transport
-    attr_reader :logger_name, :enabled
+    attr_reader :logger_name
 
-    def initialize(logger_name: "server", level: "info", enabled: true)
+    def initialize(logger_name: "server", level: "info")
       @logger_name = logger_name
-      @enabled = enabled
       @internal_logger = Logger.new(nil)
       @internal_logger.level = LEVEL_MAP[level] || Logger::INFO
       @transport = nil
@@ -42,13 +43,11 @@ module ModelContextProtocol
 
     %i[debug info warn error fatal unknown].each do |severity|
       define_method(severity) do |message = nil, **data, &block|
-        return true unless @enabled
         add(Logger.const_get(severity.to_s.upcase), message, data, &block)
       end
     end
 
     def add(severity, message = nil, data = {}, &block)
-      return true unless @enabled
       return true if severity < @internal_logger.level
 
       message = block.call if message.nil? && block_given?
@@ -70,14 +69,12 @@ module ModelContextProtocol
 
     def connect_transport(transport)
       @transport = transport
-      flush_queued_messages if @enabled
+      flush_queued_messages
     end
 
     private
 
     def send_notification(severity, message, data)
-      return unless @enabled
-
       notification_params = {
         level: REVERSE_LEVEL_MAP[severity] || "info",
         logger: @logger_name,
@@ -99,7 +96,7 @@ module ModelContextProtocol
     end
 
     def flush_queued_messages
-      return unless @transport && @enabled
+      return unless @transport
       @queued_messages.each do |params|
         @transport.send_notification("notifications/message", params)
       end

data/lib/model_context_protocol/server/configuration.rb

@@ -1,5 +1,3 @@
-require_relative "mcp_logger"
-
 module ModelContextProtocol
   class Server::Configuration
     # Raised when configured with invalid name.
@@ -23,48 +21,25 @@ module ModelContextProtocol
     # Raised when transport configuration is invalid
     class InvalidTransportError < StandardError; end
 
-    # Raised when an invalid log level is provided
-    class InvalidLogLevelError < StandardError; end
-
     # Raised when pagination configuration is invalid
     class InvalidPaginationError < StandardError; end
 
-    # Valid MCP log levels per the specification
-    VALID_LOG_LEVELS = %w[debug info notice warning error critical alert emergency].freeze
-
     attr_accessor :name, :registry, :version, :transport, :pagination, :title, :instructions
-    attr_reader :logger
+    attr_reader :client_logger, :server_logger
 
     def initialize
-      @logging_enabled = true
-      @default_log_level = "info"
-      @logger = ModelContextProtocol::Server::MCPLogger.new(
+      @client_logger = ModelContextProtocol::Server::ClientLogger.new(
         logger_name: "server",
-        level: @default_log_level,
-        enabled: @logging_enabled
+        level: "info"
       )
-    end
 
-    def logging_enabled?
-      @logging_enabled
-    end
-
-    def logging_enabled=(value)
-      @logging_enabled = value
-      @logger = ModelContextProtocol::Server::MCPLogger.new(
-        logger_name: "server",
-        level: @default_log_level,
-        enabled: value
-      )
-    end
-
-    def default_log_level=(level)
-      unless VALID_LOG_LEVELS.include?(level.to_s)
-        raise InvalidLogLevelError, "Invalid log level: #{level}. Valid levels are: #{VALID_LOG_LEVELS.join(", ")}"
+      server_logger_params = if ModelContextProtocol::Server::GlobalConfig::ServerLogging.configured?
+        ModelContextProtocol::Server::GlobalConfig::ServerLogging.logger_params
+      else
+        {}
       end
 
-      @default_log_level = level.to_s
-      @logger.set_mcp_level(@default_log_level)
+      @server_logger = ModelContextProtocol::Server::ServerLogger.new(**server_logger_params)
     end
 
     def transport_type
@@ -123,12 +98,13 @@ module ModelContextProtocol
       raise InvalidServerNameError unless valid_name?
       raise InvalidRegistryError unless valid_registry?
       raise InvalidServerVersionError unless valid_version?
+
       validate_transport!
       validate_pagination!
       validate_title!
       validate_instructions!
-
       validate_environment_variables!
+      validate_server_logging_transport_constraints!
     end
 
     def environment_variables
@@ -176,6 +152,13 @@ module ModelContextProtocol
       end
     end
 
+    def validate_server_logging_transport_constraints!
+      return unless transport_type == :stdio && server_logger.logdev == $stdout
+
+      raise ModelContextProtocol::Server::ServerLogger::StdoutNotAllowedError,
+        "StdioTransport cannot log to stdout. Use stderr or a file instead."
+    end
+
     def valid_name?
       name&.is_a?(String)
     end

data/lib/model_context_protocol/server/global_config/server_logging.rb

@@ -0,0 +1,78 @@
+require "singleton"
+
+module ModelContextProtocol
+  module Server::GlobalConfig
+    class ServerLogging
+      include Singleton
+
+      class NotConfiguredError < StandardError
+        def initialize
+          super("Server logging not configured. Call ModelContextProtocol::Server.configure_server_logging first")
+        end
+      end
+
+      class LoggerConfig
+        attr_accessor :logdev, :level, :formatter, :progname
+
+        def initialize
+          @level = Logger::INFO
+          @progname = "MCP-Server"
+        end
+
+        def to_h
+          {
+            logdev: @logdev,
+            level: @level,
+            formatter: @formatter,
+            progname: @progname
+          }.compact
+        end
+      end
+
+      def self.configure(&block)
+        instance.configure(&block)
+      end
+
+      def self.configured?
+        instance.configured?
+      end
+
+      def self.logger_params
+        instance.logger_params
+      end
+
+      def self.reset!
+        instance.reset!
+      end
+
+      def configure(&block)
+        raise ArgumentError, "Configuration block required" unless block_given?
+
+        @config = LoggerConfig.new
+        yield(@config)
+        @configured = true
+      end
+
+      def configured?
+        @configured == true
+      end
+
+      def logger_params
+        raise NotConfiguredError unless configured?
+
+        @config.to_h
+      end
+
+      def reset!
+        @configured = false
+        @config = nil
+      end
+
+      private
+
+      def initialize
+        reset!
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/progressable.rb

@@ -16,56 +16,78 @@ module ModelContextProtocol
     #   end
     def progressable(max_duration:, message: nil, &block)
       context = Thread.current[:mcp_context]
-
       return yield unless context && context[:progress_token] && context[:transport]
 
       progress_token = context[:progress_token]
       transport = context[:transport]
+      jsonrpc_request_id = context[:jsonrpc_request_id]
+      request_store = context[:request_store]
+      stream_id = context[:stream_id]
+
       start_time = Time.now
       update_interval = [1.0, max_duration * 0.05].max
 
       timer_task = Concurrent::TimerTask.new(execution_interval: update_interval) do
-        elapsed_seconds = Time.now - start_time
-        progress_pct = [(elapsed_seconds / max_duration) * 100, 99].min
-
-        progress_message = if message
-          "#{message} (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
-        else
-          "Processing... (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
-        end
+        Thread.current[:mcp_context] = {jsonrpc_request_id:}
 
         begin
-          transport.send_notification("notifications/progress", {
-            progressToken: progress_token,
-            progress: progress_pct.round(1),
-            total: 100,
-            message: progress_message
-          })
-        rescue
-          nil
-        end
+          if request_store && jsonrpc_request_id
+            break if request_store.cancelled?(jsonrpc_request_id)
+          end
+
+          elapsed_seconds = Time.now - start_time
+          progress_pct = [(elapsed_seconds / max_duration) * 100, 99].min
+
+          progress_message = if message
+            "#{message} (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
+          else
+            "Processing... (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
+          end
+
+          begin
+            transport.send_notification("notifications/progress", {
+              progressToken: progress_token,
+              progress: progress_pct.round(1),
+              total: 100,
+              message: progress_message
+            }, session_id: stream_id)
+          rescue
+            break
+          end
 
-        timer_task.shutdown if elapsed_seconds >= max_duration
+          timer_task.shutdown if elapsed_seconds >= max_duration
+        ensure
+          Thread.current[:mcp_context] = nil
+        end
       end
 
       begin
         timer_task.execute
+
         result = yield
 
+        original_context = Thread.current[:mcp_context]
+        Thread.current[:mcp_context] = {jsonrpc_request_id:}
+
         begin
           transport.send_notification("notifications/progress", {
             progressToken: progress_token,
             progress: 100,
             total: 100,
             message: "Completed"
-          })
+          }, session_id: stream_id)
         rescue
           nil
+        ensure
+          Thread.current[:mcp_context] = original_context
         end
 
         result
       ensure
-        timer_task&.shutdown if timer_task&.running?
+        if timer_task&.running?
+          timer_task.shutdown
+          sleep(0.1) if timer_task.running?
+        end
       end
     end
   end

data/lib/model_context_protocol/server/prompt.rb

@@ -4,13 +4,14 @@ module ModelContextProtocol
     include ModelContextProtocol::Server::ContentHelpers
     include ModelContextProtocol::Server::Progressable
 
-    attr_reader :arguments, :context, :logger
+    attr_reader :arguments, :context, :client_logger, :server_logger
 
-    def initialize(arguments, logger, context = {})
+    def initialize(arguments, client_logger, server_logger, context = {})
       validate!(arguments)
       @arguments = arguments
       @context = context
-      @logger = logger
+      @client_logger = client_logger
+      @server_logger = server_logger
     end
 
     def call
@@ -90,8 +91,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@defined_arguments, @defined_arguments&.dup)
       end
 
-      def call(arguments, logger, context = {})
-        new(arguments, logger, context).call
+      def call(arguments, client_logger, server_logger, context = {})
+        new(arguments, client_logger, server_logger, context).call
       rescue ArgumentError => error
         raise ModelContextProtocol::Server::ParameterValidationError, error.message
       end
@@ -127,8 +128,12 @@ module ModelContextProtocol
         @prompt_instance.context
       end
 
-      def logger
-        @prompt_instance.logger
+      def client_logger
+        @prompt_instance.client_logger
+      end
+
+      def server_logger
+        @prompt_instance.server_logger
       end
 
       def user_message(&block)

data/lib/model_context_protocol/server/redis_pool_manager.rb

@@ -48,7 +48,7 @@ module ModelContextProtocol
     def reap_now
       return unless @pool
 
-      @pool.reap(@reaper_config[:idle_timeout]) do |conn|
+      @pool.reap(idle_seconds: @reaper_config[:idle_timeout]) do |conn|
         conn.close
       end
     end

data/lib/model_context_protocol/server/resource.rb

@@ -3,11 +3,14 @@ module ModelContextProtocol
     include ModelContextProtocol::Server::Cancellable
     include ModelContextProtocol::Server::Progressable
 
-    attr_reader :mime_type, :uri
+    attr_reader :mime_type, :uri, :client_logger, :server_logger, :context
 
-    def initialize
+    def initialize(client_logger, server_logger, context = {})
       @mime_type = self.class.mime_type
       @uri = self.class.uri
+      @client_logger = client_logger
+      @server_logger = server_logger
+      @context = context
     end
 
     def call
@@ -71,8 +74,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@annotations, @annotations&.dup)
       end
 
-      def call
-        new.call
+      def call(client_logger, server_logger, context = {})
+        new(client_logger, server_logger, context).call
       end
 
       def definition

data/lib/model_context_protocol/server/router.rb

@@ -20,23 +20,24 @@ module ModelContextProtocol
     # @param request_store [Object] the request store for tracking cancellation
     # @param session_id [String, nil] the session ID for HTTP transport
     # @param transport [Object, nil] the transport for sending notifications
+    # @param stream_id [String, nil] the specific stream ID for targeted notifications
     # @return [Object] the handler result, or nil if cancelled
-    def route(message, request_store: nil, session_id: nil, transport: nil)
+    def route(message, request_store: nil, session_id: nil, transport: nil, stream_id: nil)
       method = message["method"]
       handler = @handlers[method]
       raise MethodNotFoundError, "Method not found: #{method}" unless handler
 
-      request_id = message["id"]
+      jsonrpc_request_id = message["id"]
       progress_token = message.dig("params", "_meta", "progressToken")
 
-      if request_id && request_store
-        request_store.register_request(request_id, session_id)
+      if jsonrpc_request_id && request_store
+        request_store.register_request(jsonrpc_request_id, session_id)
       end
 
       result = nil
       begin
         with_environment(@configuration&.environment_variables) do
-          context = {request_id:, request_store:, session_id:, progress_token:, transport:}
+          context = {jsonrpc_request_id:, request_store:, session_id:, progress_token:, transport:, stream_id:}
 
           Thread.current[:mcp_context] = context
 
@@ -45,8 +46,8 @@ module ModelContextProtocol
       rescue Server::Cancellable::CancellationError
         return nil
       ensure
-        if request_id && request_store
-          request_store.unregister_request(request_id)
+        if jsonrpc_request_id && request_store
+          request_store.unregister_request(jsonrpc_request_id)
         end
 
         Thread.current[:mcp_context] = nil

data/lib/model_context_protocol/server/server_logger.rb

@@ -0,0 +1,28 @@
+require "logger"
+require "json"
+
+module ModelContextProtocol
+  class Server::ServerLogger < Logger
+    class StdoutNotAllowedError < StandardError; end
+
+    attr_reader :logdev
+
+    def initialize(logdev: $stderr, level: Logger::INFO, formatter: nil, progname: "MCP-Server")
+      super(logdev)
+      @logdev = logdev
+
+      self.level = level
+      self.progname = progname
+
+      self.formatter = formatter || proc do |severity, datetime, progname, msg|
+        timestamp = datetime.strftime("%Y-%m-%d %H:%M:%S.%3N")
+        prog_name = progname ? "[#{progname}]" : ""
+        mcp_context = Thread.current[:mcp_context]
+        request_id = mcp_context&.dig(:jsonrpc_request_id)
+        request_id_str = request_id ? " [#{request_id}]" : ""
+
+        "[#{timestamp}] #{prog_name}#{request_id_str} #{severity}: #{msg}\n"
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/stdio_transport/request_store.rb

@@ -10,12 +10,12 @@ module ModelContextProtocol
 
       # Register a new request with its associated thread
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @param thread [Thread] the thread processing this request (defaults to current thread)
       # @return [void]
-      def register_request(request_id, thread = Thread.current)
+      def register_request(jsonrpc_request_id, thread = Thread.current)
         @mutex.synchronize do
-          @requests[request_id] = {
+          @requests[jsonrpc_request_id] = {
             thread:,
             cancelled: false,
             started_at: Time.now
@@ -25,11 +25,11 @@ module ModelContextProtocol
 
       # Mark a request as cancelled
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Boolean] true if request was found and marked cancelled, false otherwise
-      def mark_cancelled(request_id)
+      def mark_cancelled(jsonrpc_request_id)
         @mutex.synchronize do
-          if (request = @requests[request_id])
+          if (request = @requests[jsonrpc_request_id])
             request[:cancelled] = true
             return true
           end
@@ -39,31 +39,31 @@ module ModelContextProtocol
 
       # Check if a request has been cancelled
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Boolean] true if the request is cancelled, false otherwise
-      def cancelled?(request_id)
+      def cancelled?(jsonrpc_request_id)
         @mutex.synchronize do
-          @requests[request_id]&.fetch(:cancelled, false) || false
+          @requests[jsonrpc_request_id]&.fetch(:cancelled, false) || false
         end
       end
 
       # Unregister a request (typically called when request completes)
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Hash, nil] the removed request data, or nil if not found
-      def unregister_request(request_id)
+      def unregister_request(jsonrpc_request_id)
         @mutex.synchronize do
-          @requests.delete(request_id)
+          @requests.delete(jsonrpc_request_id)
         end
       end
 
       # Get information about a specific request
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Hash, nil] request information or nil if not found
-      def get_request(request_id)
+      def get_request(jsonrpc_request_id)
         @mutex.synchronize do
-          @requests[request_id]&.dup
+          @requests[jsonrpc_request_id]&.dup
         end
       end
 
@@ -85,9 +85,9 @@ module ModelContextProtocol
         removed_ids = []
 
         @mutex.synchronize do
-          @requests.delete_if do |request_id, data|
+          @requests.delete_if do |jsonrpc_request_id, data|
             if data[:started_at] < cutoff_time
-              removed_ids << request_id
+              removed_ids << jsonrpc_request_id
               true
             else
               false

data/lib/model_context_protocol/server/stdio_transport.rb

@@ -1,5 +1,3 @@
-require_relative "stdio_transport/request_store"
-
 module ModelContextProtocol
   class Server::StdioTransport
     Response = Data.define(:id, :result) do
@@ -14,16 +12,19 @@ module ModelContextProtocol
       end
     end
 
-    attr_reader :router, :configuration, :request_store
+    attr_reader :router, :client_logger, :server_logger, :configuration, :request_store
 
     def initialize(router:, configuration:)
       @router = router
       @configuration = configuration
-      @request_store = RequestStore.new
+      @client_logger = configuration.client_logger
+      @server_logger = configuration.server_logger
+      @request_store = ModelContextProtocol::Server::StdioTransport::RequestStore.new
     end
 
     def handle
-      @configuration.logger.connect_transport(self)
+      client_logger.connect_transport(self)
+      server_logger.info("Starting stdio transport handler")
 
       loop do
         line = receive_message
@@ -45,17 +46,21 @@ module ModelContextProtocol
             send_message(Response[id: message["id"], result: result.serialized])
           end
         rescue ModelContextProtocol::Server::ParameterValidationError => validation_error
-          @configuration.logger.error("Validation error", error: validation_error.message)
+          client_logger.error("Validation error", error: validation_error.message)
+          server_logger.error("Parameter validation failed in stdio transport: #{validation_error.message}")
           send_message(
             ErrorResponse[id: message["id"], error: {code: -32602, message: validation_error.message}]
           )
         rescue JSON::ParserError => parser_error
-          @configuration.logger.error("Parser error", error: parser_error.message)
+          client_logger.error("Parser error", error: parser_error.message)
+          server_logger.error("JSON parsing failed in stdio transport: #{parser_error.message}")
           send_message(
             ErrorResponse[id: "", error: {code: -32700, message: parser_error.message}]
           )
         rescue => error
-          @configuration.logger.error("Internal error", error: error.message, backtrace: error.backtrace.first(5))
+          client_logger.error("Internal error", error: error.message, backtrace: error.backtrace.first(5))
+          server_logger.error("Internal error in stdio transport: #{error.message}")
+          server_logger.debug("Backtrace: #{error.backtrace.join("\n")}")
           send_message(
             ErrorResponse[id: message["id"], error: {code: -32603, message: error.message}]
           )
@@ -72,7 +77,8 @@ module ModelContextProtocol
       $stdout.puts(JSON.generate(notification))
       $stdout.flush
     rescue IOError => e
-      @configuration.logger.debug("Failed to send notification", error: e.message) if @configuration.logging_enabled?
+      @configuration.client_logger.debug("Failed to send notification", error: e.message)
+      @configuration.server_logger.debug("Failed to send notification via stdio: #{e.message}")
     end
 
     private
@@ -84,10 +90,10 @@ module ModelContextProtocol
       params = message["params"]
       return unless params
 
-      request_id = params["requestId"]
-      return unless request_id
+      jsonrpc_request_id = params["requestId"]
+      return unless jsonrpc_request_id
 
-      @request_store.mark_cancelled(request_id)
+      @request_store.mark_cancelled(jsonrpc_request_id)
     rescue
       nil
     end