fix: apply max_message_bytes to remaining HTTP responses

Apply the configured response limit to notification acknowledgements,
replies to server-to-client requests, and session DELETE responses.
Reuse the existing bounded response reader for these requests.

Report an over-limit body as RequestHandlerError, as send_request does.
Keep clearing local session state when close raises.

Author: atesgoral

docs/_client/transports.md

@@ -131,7 +131,8 @@ See the [Progress](/server/progress/) page.
 
 `MCP::Client::HTTP.new` accepts an optional `max_message_bytes:` keyword that caps the bytes buffered in memory for a single message from the server -
 an SSE event or a JSON response body. A message that reaches this limit before completing is rejected as a transport error, preventing unbounded memory growth from
-a server that never terminates an SSE event. It defaults to `4 * 1024 * 1024` (4 MiB); raise it if your server returns larger responses.
+a server that never terminates an SSE event. The same limit applies to the bodies the client reads and drops: the acknowledgement of a notification or of a response
+to a server-to-client request, and the answer to the session DELETE. It defaults to `4 * 1024 * 1024` (4 MiB); raise it if your server returns larger responses.
 
 `MCP::Client::HTTP.new` also accepts `max_reconnection_wait:`, a budget in seconds for resuming a closed SSE stream. It gates every wait between reconnection attempts,
 and what is left of it becomes the read timeout of each resumed stream. The server chooses that wait through the SSE `retry:` field, and resuming happens on the calling thread,

lib/mcp/client/http.rb

@@ -545,8 +545,12 @@ def send_request(request:)
       def send_notification(notification:)
         method = notification[:method] || notification["method"]
 
-        redacting_authorization_header { client.post("", notification, session_headers) }
+        redacting_authorization_header do
+          client.post("", notification, session_headers) { |req| req.options.on_data = bounded_on_data }
+        end
         nil
+      rescue MessageTooLargeError => e
+        raise RequestHandlerError.new(e.message, { method: method }, error_type: :internal_error)
       rescue Faraday::Error => e
         raise RequestHandlerError.new(
           "Failed to send #{method} notification",
@@ -573,7 +577,11 @@ def close
         end
 
         begin
-          redacting_authorization_header { client.delete("", nil, session_headers) }
+          redacting_authorization_header do
+            client.delete("", nil, session_headers) { |req| req.options.on_data = bounded_on_data }
+          end
+        rescue MessageTooLargeError => e
+          raise RequestHandlerError.new(e.message, {}, error_type: :internal_error)
         rescue Faraday::ClientError => e
           raise unless [404, 405].include?(e.response&.dig(:status))
         ensure
@@ -1234,7 +1242,14 @@ def dispatch_server_request(message)
       end
 
       def send_client_response(response)
-        redacting_authorization_header { client.post("", response, session_headers) }
+        redacting_authorization_header do
+          client.post("", response, session_headers) { |req| req.options.on_data = bounded_on_data }
+        end
+      end
+
+      # Applies the same response-reading limit as `send_request` to bodies the client does not use.
+      def bounded_on_data
+        SSEStream.new(abortable: false, max_message_bytes: @max_message_bytes).on_data
       end
 
       def parse_json_buffer(buffer, method, params)

test/mcp/client/http_test.rb

@@ -1338,6 +1338,68 @@ def test_send_request_accepts_sse_events_that_each_stay_within_max_message_bytes
         assert_equal({ "tools" => [] }, response["result"])
       end
 
+      def test_send_notification_rejects_response_body_exceeding_max_message_bytes
+        notification = {
+          jsonrpc: "2.0",
+          method: MCP::Methods::NOTIFICATIONS_CANCELLED,
+          params: { requestId: "req-1" },
+        }
+        client = HTTP.new(url: url, max_message_bytes: 64)
+
+        stub_request(:post, url).with(body: notification.to_json).to_return(status: 202, body: "a" * 128)
+
+        error = assert_raises(RequestHandlerError) do
+          client.send_notification(notification: notification)
+        end
+
+        assert_includes(error.message, "Server response body exceeds 64 bytes")
+        assert_equal(:internal_error, error.error_type)
+      end
+
+      def test_send_request_rejects_pong_acknowledgement_exceeding_max_message_bytes
+        request = {
+          jsonrpc: "2.0",
+          id: "test_id",
+          method: "tools/list",
+        }
+        client = HTTP.new(url: url, max_message_bytes: 128)
+
+        server_ping = { jsonrpc: "2.0", id: 7, method: "ping" }
+        tools_result = { jsonrpc: "2.0", id: "test_id", result: { tools: [] } }
+        stub_request(:post, url).with(
+          body: request.to_json,
+        ).to_return(
+          status: 200,
+          headers: { "Content-Type" => "text/event-stream" },
+          body: "data: #{server_ping.to_json}\n\ndata: #{tools_result.to_json}\n\n",
+        )
+
+        pong = { jsonrpc: "2.0", id: 7, result: {} }
+        stub_request(:post, url).with(body: pong.to_json).to_return(status: 202, body: "a" * 256)
+
+        error = assert_raises(RequestHandlerError) do
+          client.send_request(request: request)
+        end
+
+        assert_includes(error.message, "Server response body exceeds 128 bytes")
+        assert_equal(:internal_error, error.error_type)
+      end
+
+      def test_close_rejects_response_body_exceeding_max_message_bytes_and_still_clears_state
+        client = HTTP.new(url: url, max_message_bytes: 64)
+        stub_initialize
+        client.send_request(request: { jsonrpc: "2.0", id: "1", method: "initialize" })
+
+        stub_request(:delete, url).to_return(status: 200, body: "a" * 128)
+
+        error = assert_raises(RequestHandlerError) do
+          client.close
+        end
+
+        assert_includes(error.message, "Server response body exceeds 64 bytes")
+        assert_nil(client.session_id)
+      end
+
       def test_sse_stream_rejects_unterminated_event_exceeding_max_message_bytes
         stream = HTTP.const_get(:SSEStream).new(abortable: false, max_message_bytes: 64)
         env = stub(response_headers: { "content-type" => "text/event-stream" })