fix(openai): drop response item ids when store is false (#38372)

Some Responses API conversations can safely replay prior response item
IDs because the server stored those items. That assumption breaks when
`store=False`: prior `rs_*` reasoning items and `msg_*` assistant
message IDs are not available on the server for the next turn, so
replaying them can crash with `Item with id 'rs_...' not found` or
similar item lookup errors.

This updates the Responses API payload builder to treat `store=False` as
a stateless replay mode. The visible assistant text is still preserved
in history, but server-side response item IDs are not sent back unless
they are usable without server persistence.

In practical terms:

- Bare `rs_*` reasoning items are dropped for `store=False` because they
only reference server-side state that was not stored.
- Reasoning items with `encrypted_content` are preserved because OpenAI
uses them as the stateless/ZDR way to carry reasoning context forward.
- Prior assistant `msg_*` IDs are omitted for `store=False`; the
assistant message is replayed as ordinary assistant text instead of as a
reference to a stored server item.

Dropping `msg_*` IDs in this case should not remove useful user-visible
context: the text content remains in the request. It only removes an
item identity that the server cannot reliably resolve when
`store=False`. Persisted `store=True` Responses flows continue to replay
item IDs as before.

The regression test mirrors the minimal user story: make one
Responses/Codex call, reuse the returned `AIMessage` in a follow-up
request, and verify the next payload keeps the visible assistant message
and encrypted reasoning context while omitting unresolvable bare item
references.

Author: mdrxy

libs/partners/openai/langchain_openai/chat_models/base.py

@@ -4183,7 +4183,9 @@ def _construct_responses_api_payload(
     ):
         payload.pop("temperature", None)
 
-    payload["input"] = _construct_responses_api_input(messages)
+    payload["input"] = _construct_responses_api_input(
+        messages, store=payload.get("store")
+    )
     if tools := payload.pop("tools", None):
         new_tools: list = []
         for tool in tools:
@@ -4415,8 +4417,29 @@ def _pop_index_and_sub_index(block: dict) -> dict:
     return new_block
 
 
-def _construct_responses_api_input(messages: Sequence[BaseMessage]) -> list:
-    """Construct the input for the OpenAI Responses API."""
+def _construct_responses_api_input(
+    messages: Sequence[BaseMessage], *, store: bool | None = None
+) -> list:
+    """Construct the input for the OpenAI Responses API.
+
+    Args:
+        messages: Conversation history to serialize into Responses API input items.
+        store: Mirrors the request's `store` flag, controlling stateless-replay
+            behavior.
+
+            When `False`, the server does not persist response items, so
+            previously returned item IDs cannot be resolved on the next turn.
+            Assistant message IDs (`msg_*`) are therefore omitted and reasoning
+            blocks are dropped unless they carry `encrypted_content` (which can be
+            replayed without server-side storage).
+
+            When `True` or `None` (the default, matching the server's
+            stored-by-default behavior), item IDs and reasoning blocks
+            are preserved.
+
+    Returns:
+        A list of Responses API input items derived from `messages`.
+    """
     input_ = []
     for lc_msg in messages:
         if isinstance(lc_msg, AIMessage):
@@ -4505,13 +4528,16 @@ def _construct_responses_api_input(messages: Sequence[BaseMessage]) -> list:
                                     "type": "message",
                                     "content": [new_block],
                                     "role": "assistant",
-                                    "id": msg_id,
                                 }
+                                if store is not False:
+                                    new_item["id"] = msg_id
                                 if phase is not None:
                                     new_item["phase"] = phase
                                 input_.append(new_item)
+                        elif block_type == "reasoning":
+                            if store is not False or "encrypted_content" in block:
+                                input_.append(_pop_index_and_sub_index(block))
                         elif block_type in (
-                            "reasoning",
                             "compaction",
                             "web_search_call",
                             "file_search_call",
@@ -4530,9 +4556,17 @@ def _construct_responses_api_input(messages: Sequence[BaseMessage]) -> list:
                             input_.append(_pop_index_and_sub_index(block))
                         elif block_type == "image_generation_call":
                             # A previous image generation call can be referenced by ID
-                            input_.append(
-                                {"type": "image_generation_call", "id": block["id"]}
-                            )
+                            if store is not False:
+                                input_.append(
+                                    {"type": "image_generation_call", "id": block["id"]}
+                                )
+                            else:
+                                # ID-only references require stored server state. For
+                                # stateless requests, replay full items and drop bare
+                                # references that the backend cannot resolve.
+                                image_generation_call = _pop_index_and_sub_index(block)
+                                if set(image_generation_call) - {"type", "id"}:
+                                    input_.append(image_generation_call)
                         else:
                             pass
             elif isinstance(msg.get("content"), str):

libs/partners/openai/tests/cassettes/TestChatOpenAICodexStandard.test_anthropic_inputs.yaml.gz

@@ -2771,6 +2771,103 @@ def test__construct_responses_api_input_human_message_with_image_url_conversion(
     assert result[0]["content"][1]["detail"] == "high"
 
 
+def test__construct_responses_api_input_store_false_replays_stateless_history() -> None:
+    ai_message = AIMessage(
+        content=[
+            {"type": "reasoning", "id": "rs_123", "summary": []},
+            {
+                "type": "reasoning",
+                "id": "rs_456",
+                "summary": [],
+                "encrypted_content": "",
+            },
+            {"type": "text", "text": "Use pathlib.rglob.", "id": "msg_123"},
+        ],
+        response_metadata={"id": "resp_123"},
+    )
+
+    result = _construct_responses_api_input([ai_message], store=False)
+
+    assert result == [
+        {
+            "type": "reasoning",
+            "id": "rs_456",
+            "summary": [],
+            "encrypted_content": "",
+        },
+        {
+            "type": "message",
+            "content": [
+                {"type": "output_text", "text": "Use pathlib.rglob.", "annotations": []}
+            ],
+            "role": "assistant",
+        },
+    ]
+
+
+@pytest.mark.parametrize("store", [None, True])
+def test__construct_responses_api_input_store_enabled_keeps_item_ids(
+    store: bool | None,
+) -> None:
+    ai_message = AIMessage(
+        content=[
+            {"type": "reasoning", "id": "rs_123", "summary": []},
+            {"type": "text", "text": "Use pathlib.rglob.", "id": "msg_123"},
+        ],
+        response_metadata={"id": "resp_123"},
+    )
+
+    result = _construct_responses_api_input([ai_message], store=store)
+
+    assert result == [
+        {"type": "reasoning", "id": "rs_123", "summary": []},
+        {
+            "type": "message",
+            "content": [
+                {"type": "output_text", "text": "Use pathlib.rglob.", "annotations": []}
+            ],
+            "role": "assistant",
+            "id": "msg_123",
+        },
+    ]
+
+
+def test__construct_responses_api_input_store_false_keeps_full_tool_call_items() -> (
+    None
+):
+    ai_message = AIMessage(
+        content=[
+            {
+                "type": "function_call",
+                "name": "get_weather",
+                "arguments": '{"location": "San Francisco"}',
+                "call_id": "call_123",
+                "id": "fc_456",
+            }
+        ],
+        tool_calls=[
+            {
+                "id": "call_123",
+                "name": "get_weather",
+                "args": {"location": "San Francisco"},
+                "type": "tool_call",
+            }
+        ],
+    )
+
+    result = _construct_responses_api_input([ai_message], store=False)
+
+    assert result == [
+        {
+            "type": "function_call",
+            "name": "get_weather",
+            "arguments": '{"location": "San Francisco"}',
+            "call_id": "call_123",
+            "id": "fc_456",
+        }
+    ]
+
+
 def test__construct_responses_api_input_ai_message_with_tool_calls() -> None:
     """Test that AI messages with tool calls are properly converted."""
     tool_calls = [

libs/partners/openai/tests/cassettes/TestChatOpenAICodexStandard.test_tool_message_histories_list_content.yaml.gz

@@ -7,7 +7,7 @@
 from typing import Any
 
 import pytest
-from langchain_core.messages import ChatMessage, HumanMessage, SystemMessage
+from langchain_core.messages import AIMessage, ChatMessage, HumanMessage, SystemMessage
 
 import langchain_openai.chat_models.codex as codex_module
 from langchain_openai.chat_models.base import ChatOpenAI
@@ -289,6 +289,89 @@ def test_request_payload_sends_store_false_and_stream_true() -> None:
     assert payload["stream"] is True
 
 
+def test_request_payload_with_store_false_drops_reasoning_item_references() -> None:
+    model = _build_model()
+    payload = model._get_request_payload(
+        [
+            HumanMessage("Explain recursive file search."),
+            AIMessage(
+                content=[
+                    {"type": "reasoning", "id": "rs_123", "summary": []},
+                    {
+                        "type": "reasoning",
+                        "id": "rs_456",
+                        "summary": [],
+                        "encrypted_content": "encrypted-context",
+                    },
+                    {"type": "text", "text": "Use pathlib.rglob.", "id": "msg_123"},
+                ],
+                response_metadata={"id": "resp_123"},
+            ),
+            HumanMessage("Make it shorter."),
+        ]
+    )
+
+    assert payload["store"] is False
+    assert [item.get("type") for item in payload["input"]] == [
+        "message",
+        "reasoning",
+        "message",
+        "message",
+    ]
+    assert payload["input"][1] == {
+        "type": "reasoning",
+        "id": "rs_456",
+        "summary": [],
+        "encrypted_content": "encrypted-context",
+    }
+    assert payload["input"][2]["content"] == [
+        {"type": "output_text", "text": "Use pathlib.rglob.", "annotations": []}
+    ]
+    assert "id" not in payload["input"][2]
+
+
+def test_request_payload_with_store_false_drops_image_call_references() -> None:
+    model = _build_model()
+    payload = model._get_request_payload(
+        [
+            HumanMessage("Draw a word."),
+            AIMessage(
+                content=[
+                    {"type": "image_generation_call", "id": "ig_reference_only"},
+                    {
+                        "type": "image_generation_call",
+                        "id": "ig_with_result",
+                        "result": "base64-image",
+                        "status": "completed",
+                        "index": 0,
+                    },
+                    {"type": "text", "text": "Done.", "id": "msg_123"},
+                ],
+                response_metadata={"id": "resp_123"},
+            ),
+            HumanMessage("Change the color."),
+        ]
+    )
+
+    assert payload["store"] is False
+    assert [item.get("type") for item in payload["input"]] == [
+        "message",
+        "image_generation_call",
+        "message",
+        "message",
+    ]
+    assert payload["input"][1] == {
+        "type": "image_generation_call",
+        "id": "ig_with_result",
+        "result": "base64-image",
+        "status": "completed",
+    }
+    assert payload["input"][2]["content"] == [
+        {"type": "output_text", "text": "Done.", "annotations": []}
+    ]
+    assert "id" not in payload["input"][2]
+
+
 def test_request_payload_sets_default_instructions() -> None:
     """The Codex backend 400s without `instructions`; default must be injected."""
     model = _build_model()