fix: drop arbitrary 20x cap on r3/v1 decompressed size

ZstdCompressor.compress() (used by the gateway-side r3_serializer)
embeds the uncompressed size in the frame header, so passing
max_output_size=len(compressed)*20 was both unnecessary and incorrect:
highly compressible router-replay payloads (e.g. tokens routing to a
small subset of experts) routinely exceed a 20:1 ratio, and would have
failed deserialization with ZstdError.

Removing the cap lets the library auto-allocate from the embedded
content size.  Verified locally: a 64 KiB zero-filled matrix payload
compresses to ~35 bytes (>1800x ratio) and now deserializes cleanly.

Adds a regression test covering the high-compression case.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: SunnySoldier357

eval_protocol/adapters/r3_deserializer.py

@@ -118,8 +118,10 @@ def decompress_and_parse_r3(
     """
     compressed = base64.b64decode(data_b64)
 
+    # ZstdCompressor.compress() embeds the uncompressed size in the frame
+    # header by default, so the library can auto-allocate the output buffer.
     decompressor = zstd.ZstdDecompressor()
-    raw = decompressor.decompress(compressed, max_output_size=len(compressed) * 20)
+    raw = decompressor.decompress(compressed)
 
     header = _parse_header(raw)
 

tests/adapters/test_r3_deserializer.py

@@ -266,6 +266,30 @@ def test_zero_replayed_tokens(self):
         assert all(m is None for m in matrices)
         assert metadata["replayed_token_count"] == 0
 
+    def test_high_compression_ratio_payload(self):
+        """Highly compressible payloads (e.g. tokens routing to the same
+        experts) can compress much better than 20:1; the deserializer must
+        not impose an arbitrary cap on the decompressed size."""
+        # 64 KiB of zeros compresses to ~35 bytes (>1000x ratio).
+        total_tokens = 1024
+        matrix_elem_size = 64  # bytes/token
+        matrix_data = b"\x00" * (total_tokens * matrix_elem_size)
+
+        raw = _make_raw_r3(
+            total_token_count=total_tokens,
+            replayed_token_count=total_tokens,
+            matrix_data=matrix_data,
+        )
+        blob = _compress_and_b64(raw)
+        # Sanity: compression really is >> 20x for this case.
+        assert len(base64.b64decode(blob)) * 20 < len(raw)
+
+        matrices, metadata = decompress_and_parse_r3(blob)
+        assert len(matrices) == total_tokens
+        assert metadata["replayed_token_count"] == total_tokens
+        for m in matrices:
+            assert base64.b64decode(m) == b"\x00" * matrix_elem_size
+
 
 class TestRoundTrip:
     """Round-trip test using the gateway's serializer and EP's deserializer."""