added notification spec for handling unknown notification types and log ignore unknown types

Author: patvice

lib/ruby_llm/mcp/notification_handler.rb

@@ -27,8 +27,7 @@ def execute(notification)
         when "notifications/cancelled"
           # TODO: - do nothing at the moment until we support client operations
         else
-          message = "Unknown notification type: #{notification.type} params:#{notification.params.to_h}"
-          raise Errors::UnknownNotification.new(message: message)
+          process_unknown_notification(notification)
         end
       end
 
@@ -75,6 +74,11 @@ def default_process_logging_message(notification, logger: RubyLLM::MCP.logger)
           logger.fatal(message["message"])
         end
       end
+
+      def process_unknown_notification(notification)
+        message = "Unknown notification type: #{notification.type} params: #{notification.params.to_h}"
+        RubyLLM::MCP.logger.error(message)
+      end
     end
   end
 end

lib/ruby_llm/mcp/response_handler.rb

@@ -10,7 +10,7 @@ def initialize(coordinator)
         @client = coordinator.client
       end
 
-      def execute(result)
+      def execute(result) # rubocop:disable Metrics/PredicateMethod
         if result.ping?
           coordinator.ping_response(id: result.id)
           true
@@ -21,9 +21,9 @@ def execute(result)
           handle_sampling_response(result)
           true
         else
-          # Handle server-initiated requests
-          # Currently, we do not support any client operations but will
-          raise RubyLLM::MCP::Errors::UnknownRequest.new(message: "Unknown request type: #{result.inspect}")
+          handle_unknown_request(result)
+          RubyLLM::MCP.logger.error("MCP client was sent unknown method type and could not respond: #{result.inspect}")
+          false
         end
       end
 
@@ -47,6 +47,12 @@ def handle_sampling_response(result)
         RubyLLM::MCP.logger.info("Sampling response: #{result.inspect}")
         Sample.new(result, coordinator).execute
       end
+
+      def handle_unknown_request(result)
+        coordinator.error_response(id: result.id,
+                                   message: "Unknown method and could not respond: #{result.method}",
+                                   code: -32_000)
+      end
     end
   end
 end

lib/ruby_llm/mcp/result.rb

@@ -12,7 +12,7 @@ def initialize(response)
     end
 
     class Result
-      attr_reader :result, :error, :params, :id, :response, :session_id
+      attr_reader :result, :error, :params, :id, :response, :session_id, :method
 
       REQUEST_METHODS = {
         ping: "ping",

spec/ruby_llm/mcp/notification_handler_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class FakeLogger
+  def error(message)
+    @error_message = message
+  end
+
+  attr_reader :error_message
+end
+
+RSpec.describe RubyLLM::MCP::NotificationHandler do
+  let(:coordinator) { instance_double(RubyLLM::MCP::Coordinator) }
+  let(:notification_handler) { RubyLLM::MCP::NotificationHandler.new(coordinator) }
+
+  before do
+    allow(coordinator).to receive(:client)
+  end
+
+  after do
+    MCPTestConfiguration.reset_config!
+  end
+
+  it "calling cancelled at the moment will do nothing" do
+    notification = RubyLLM::MCP::Notification.new(
+      { "type" => "notifications/cancelled" }
+    )
+
+    expect { notification_handler.execute(notification) }.not_to raise_error
+  end
+
+  it "calling an unknown notification will log an error and do nothing else" do
+    logger = FakeLogger.new
+    RubyLLM::MCP.configure do |config|
+      config.logger = logger
+    end
+
+    notification = RubyLLM::MCP::Notification.new(
+      { "method" => "notifications/unknown", "params" => {} }
+    )
+
+    notification_handler.execute(notification)
+    expect(logger.error_message).to eq("Unknown notification type: notifications/unknown params: {}")
+  end
+end

spec/ruby_llm/mcp/response_handler_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe RubyLLM::MCP::ResponseHandler do
+  let(:coordinator) { instance_double(RubyLLM::MCP::Coordinator) }
+  let(:request_handler) { RubyLLM::MCP::ResponseHandler.new(coordinator) }
+
+  before do
+    allow(coordinator).to receive(:client)
+    allow(coordinator).to receive(:error_response).and_return(true)
+  end
+
+  it "response with an error code if the request is unknown" do
+    result = RubyLLM::MCP::Result.new(
+      { "id" => "123", "method" => "unknown/request", "params" => {} }
+    )
+
+    request_handler.execute(result)
+    error_message = "Unknown method and could not respond: #{result.method}"
+    expect(coordinator).to have_received(:error_response).with(id: "123", message: error_message, code: -32_000)
+  end
+end

spec/ruby_llm/mcp/sample_spec.rb

@@ -178,7 +178,7 @@
         expect(model_preferences).to be_a(RubyLLM::MCP::Sample::Hint)
       end
 
-      it "client calls a block to determine the preferred model, and raises an error it will send an error message back" do
+      it "client calls a block to determine the preferred model, and raises an error it will send an error back" do
         RubyLLM::MCP.configure do |config|
           config.sampling.enabled = true