model-context-protocol-rb 0.5.1 → 0.6.0

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

data/lib/model_context_protocol/server/streamable_http_transport/message_poller.rb

@@ -6,10 +6,10 @@ module ModelContextProtocol
       POLL_INTERVAL = 0.1  # 100ms
       BATCH_SIZE = 100
 
-      def initialize(redis_client, stream_registry, logger, &message_delivery_block)
+      def initialize(redis_client, stream_registry, client_logger, &message_delivery_block)
         @redis = redis_client
         @stream_registry = stream_registry
-        @logger = logger
+        @client_logger = client_logger
         @message_delivery_block = message_delivery_block
         @running = false
         @poll_thread = nil
@@ -22,14 +22,14 @@ module ModelContextProtocol
         @poll_thread = Thread.new do
           poll_loop
         rescue => e
-          @logger.error("Message poller thread error", error: e.message, backtrace: e.backtrace.first(5))
+          @client_logger.error("Message poller thread error", error: e.message, backtrace: e.backtrace.first(5))
           sleep 1
           retry if @running
         end
 
         @poll_thread.name = "MCP-MessagePoller" if @poll_thread.respond_to?(:name=)
 
-        @logger.debug("Message poller started")
+        @client_logger.debug("Message poller started")
       end
 
       def stop
@@ -37,11 +37,11 @@ module ModelContextProtocol
 
         if @poll_thread&.alive?
           @poll_thread.kill
-          @poll_thread.join(timeout: 5)
+          @poll_thread.join(5)
         end
 
         @poll_thread = nil
-        @logger.debug("Message poller stopped")
+        @client_logger.debug("Message poller stopped")
       end
 
       def running?
@@ -55,7 +55,7 @@ module ModelContextProtocol
           begin
             poll_and_deliver_messages
           rescue => e
-            @logger.error("Error in message polling", error: e.message)
+            @client_logger.error("Error in message polling", error: e.message)
           end
 
           sleep POLL_INTERVAL
@@ -91,9 +91,9 @@ module ModelContextProtocol
         @message_delivery_block&.call(stream, message)
       rescue IOError, Errno::EPIPE, Errno::ECONNRESET
         @stream_registry.unregister_stream(session_id)
-        @logger.debug("Unregistered disconnected stream", session_id: session_id)
+        @client_logger.debug("Unregistered disconnected stream", session_id: session_id)
       rescue => e
-        @logger.error("Error delivering message to stream",
+        @client_logger.error("Error delivering message to stream",
           session_id: session_id, error: e.message)
       end
     end

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

@@ -19,10 +19,10 @@ module ModelContextProtocol
 
       # Register a new request with its associated session
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @param session_id [String] the session identifier (can be nil for sessionless requests)
       # @return [void]
-      def register_request(request_id, session_id = nil)
+      def register_request(jsonrpc_request_id, session_id = nil)
         request_data = {
           session_id: session_id,
           server_instance: @server_instance,
@@ -30,11 +30,11 @@ module ModelContextProtocol
         }
 
         @redis.multi do |multi|
-          multi.set("#{REQUEST_KEY_PREFIX}#{request_id}",
+          multi.set("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}",
             request_data.to_json, ex: @ttl)
 
           if session_id
-            multi.set("#{SESSION_KEY_PREFIX}#{session_id}:#{request_id}",
+            multi.set("#{SESSION_KEY_PREFIX}#{session_id}:#{jsonrpc_request_id}",
               true, ex: @ttl)
           end
         end
@@ -42,34 +42,34 @@ 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
       # @param reason [String] optional reason for cancellation
       # @return [Boolean] true if cancellation was recorded
-      def mark_cancelled(request_id, reason = nil)
+      def mark_cancelled(jsonrpc_request_id, reason = nil)
         cancellation_data = {
           cancelled_at: Time.now.to_f,
           reason: reason
         }
 
-        result = @redis.set("#{CANCELLED_KEY_PREFIX}#{request_id}",
+        result = @redis.set("#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}",
           cancellation_data.to_json, ex: @ttl)
         result == "OK"
       end
 
       # 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)
-        @redis.exists("#{CANCELLED_KEY_PREFIX}#{request_id}") == 1
+      def cancelled?(jsonrpc_request_id)
+        @redis.exists("#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}") == 1
       end
 
       # Get cancellation information for a request
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Hash, nil] cancellation data or nil if not cancelled
-      def get_cancellation_info(request_id)
-        data = @redis.get("#{CANCELLED_KEY_PREFIX}#{request_id}")
+      def get_cancellation_info(jsonrpc_request_id)
+        data = @redis.get("#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}")
         data ? JSON.parse(data) : nil
       rescue JSON::ParserError
         nil
@@ -77,13 +77,13 @@ module ModelContextProtocol
 
       # 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 [void]
-      def unregister_request(request_id)
-        request_data = @redis.get("#{REQUEST_KEY_PREFIX}#{request_id}")
+      def unregister_request(jsonrpc_request_id)
+        request_data = @redis.get("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}")
 
-        keys_to_delete = ["#{REQUEST_KEY_PREFIX}#{request_id}",
-          "#{CANCELLED_KEY_PREFIX}#{request_id}"]
+        keys_to_delete = ["#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}",
+          "#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}"]
 
         if request_data
           begin
@@ -91,7 +91,7 @@ module ModelContextProtocol
             session_id = data["session_id"]
 
             if session_id
-              keys_to_delete << "#{SESSION_KEY_PREFIX}#{session_id}:#{request_id}"
+              keys_to_delete << "#{SESSION_KEY_PREFIX}#{session_id}:#{jsonrpc_request_id}"
             end
           rescue JSON::ParserError
             nil
@@ -103,10 +103,10 @@ module ModelContextProtocol
 
       # 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)
-        data = @redis.get("#{REQUEST_KEY_PREFIX}#{request_id}")
+      def get_request(jsonrpc_request_id)
+        data = @redis.get("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}")
         data ? JSON.parse(data) : nil
       rescue JSON::ParserError
         nil
@@ -114,10 +114,10 @@ module ModelContextProtocol
 
       # Check if a request is currently active
       #
-      # @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 active, false otherwise
-      def active?(request_id)
-        @redis.exists("#{REQUEST_KEY_PREFIX}#{request_id}") == 1
+      def active?(jsonrpc_request_id)
+        @redis.exists("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}") == 1
       end
 
       # Clean up all requests associated with a session
@@ -131,20 +131,20 @@ module ModelContextProtocol
         return [] if request_keys.empty?
 
         # Extract request IDs from the keys
-        request_ids = request_keys.map do |key|
+        jsonrpc_request_ids = request_keys.map do |key|
           key.sub("#{SESSION_KEY_PREFIX}#{session_id}:", "")
         end
 
         # Delete all related keys
         all_keys = []
-        request_ids.each do |request_id|
-          all_keys << "#{REQUEST_KEY_PREFIX}#{request_id}"
-          all_keys << "#{CANCELLED_KEY_PREFIX}#{request_id}"
+        jsonrpc_request_ids.each do |jsonrpc_request_id|
+          all_keys << "#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}"
+          all_keys << "#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}"
         end
         all_keys.concat(request_keys)
 
         @redis.del(*all_keys) unless all_keys.empty?
-        request_ids
+        jsonrpc_request_ids
       end
 
       # Get all active request IDs for a specific session
@@ -196,21 +196,21 @@ module ModelContextProtocol
 
       # Refresh the TTL for an active request
       #
-      # @param request_id [String] the unique request identifier
+      # @param jsonrpc_request_id [String] the unique JSON-RPC request identifier
       # @return [Boolean] true if TTL was refreshed, false if request doesn't exist
-      def refresh_request_ttl(request_id)
-        request_data = @redis.get("#{REQUEST_KEY_PREFIX}#{request_id}")
+      def refresh_request_ttl(jsonrpc_request_id)
+        request_data = @redis.get("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}")
         return false unless request_data
 
         @redis.multi do |multi|
-          multi.expire("#{REQUEST_KEY_PREFIX}#{request_id}", @ttl)
-          multi.expire("#{CANCELLED_KEY_PREFIX}#{request_id}", @ttl)
+          multi.expire("#{REQUEST_KEY_PREFIX}#{jsonrpc_request_id}", @ttl)
+          multi.expire("#{CANCELLED_KEY_PREFIX}#{jsonrpc_request_id}", @ttl)
 
           begin
             data = JSON.parse(request_data)
             session_id = data["session_id"]
             if session_id
-              multi.expire("#{SESSION_KEY_PREFIX}#{session_id}:#{request_id}", @ttl)
+              multi.expire("#{SESSION_KEY_PREFIX}#{session_id}:#{jsonrpc_request_id}", @ttl)
             end
           rescue JSON::ParserError
             nil