From 5a2ec55fd7ff28e423eaa24086845ee5f9b622f3 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Sun, 19 Jul 2026 16:10:00 +0530
Subject: [PATCH 01/13] fix(parsing): guard against None response.output in
 parse_response

The chatgpt.com Codex backend sometimes sends response.output: null in
the consolidated response.completed event, even when valid output_item.done
events were streamed earlier. The SDK then raises TypeError: 'NoneType'
object is not iterable inside the stream accumulator, killing the entire
stream before the consumer can read the deltas.

Fix: iterate over response.output or [] instead of response.output directly.

Closes #3325
---
 src/openai/lib/_parsing/_responses.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index c607587ec1..81e6b2b983 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -58,7 +58,7 @@ def parse_response(
 ) -> ParsedResponse[TextFormatT]:
     output_list: List[ParsedResponseOutputItem[TextFormatT]] = []
 
-    for output in response.output:
+    for output in response.output or []:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
             for item in output.content:

From ef9891e0561ac1adeaa37a605c7590f2e87e0487 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Sun, 19 Jul 2026 17:49:16 +0530
Subject: [PATCH 02/13] fix(streaming): preserve accumulated output when
 response.completed has null output

The chatgpt.com Codex backend sometimes sends response.output: null in the
consolidated response.completed event even when valid output_item.done events
were streamed earlier (issue #3325). The previous fix (response.output or [])
prevented the TypeError but discarded the already-streamed snapshot.output,
causing the final ParsedResponse to have empty output/output_text.

Move the guard into ResponseStreamState.accumulate_event: when
event.response.output is None and the snapshot has accumulated output items,
build the completed response from the snapshot instead of calling
parse_response with an empty output list. This preserves streamed text and
tool calls in get_final_response() and ResponseCompletedEvent.

Addresses Codex review feedback on #3517.
---
 src/openai/lib/_parsing/_responses.py         |  2 +-
 .../lib/streaming/responses/_responses.py     | 25 +++++++++++++++----
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index 81e6b2b983..c607587ec1 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -58,7 +58,7 @@ def parse_response(
 ) -> ParsedResponse[TextFormatT]:
     output_list: List[ParsedResponseOutputItem[TextFormatT]] = []
 
-    for output in response.output or []:
+    for output in response.output:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
             for item in output.content:
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 6975a9260d..5a45937a90 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -357,11 +357,26 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             if output.type == "function_call":
                 output.arguments += event.delta
         elif event.type == "response.completed":
-            self._completed_response = parse_response(
-                text_format=self._text_format,
-                response=event.response,
-                input_tools=self._input_tools,
-            )
+            # The chatgpt.com Codex backend sometimes sends `response.output: null`
+            # in the consolidated `response.completed` event even when valid
+            # `output_item.done` events were streamed earlier (see issue #3325).
+            # Calling `parse_response` with a null `output` would discard the
+            # already-accumulated `snapshot.output` and emit an empty final
+            # response, so we fall back to the streamed snapshot in that case.
+            if event.response.output is None and snapshot.output:
+                self._completed_response = construct_type_unchecked(
+                    type_=ParsedResponse[TextFormatT],
+                    value={
+                        **event.response.to_dict(),
+                        "output": [item.to_dict() for item in snapshot.output],
+                    },
+                )
+            else:
+                self._completed_response = parse_response(
+                    text_format=self._text_format,
+                    response=event.response,
+                    input_tools=self._input_tools,
+                )
 
         return snapshot
 

From d6cd5549fe2a9debca533f703f12e1a123dd9f79 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Sun, 19 Jul 2026 19:27:20 +0530
Subject: [PATCH 03/13] fix(streaming): route null-output fallback through
 parse_response

Address Codex P2 review feedback on the previous commit (1c050f69):

1. Run response parsing on the streamed fallback: instead of building
   ParsedResponse directly from snapshot.output via construct_type_unchecked
   (which left output_parsed/parsed_arguments as None), inject the streamed
   items into a shallow copy of the response and pass it through parse_response
   so text_format and parsed_arguments logic still runs.

2. Handle null completed output without streamed items: re-add the
   'response.output or []' guard in parse_response() so a null-output
   response.completed with no prior output_item.added events returns a parsed
   response with an empty output list instead of raising TypeError.

Together these cover both branches: null output WITH accumulated snapshot items
(parse_response runs on the injected items) and null output WITHOUT items
(parse_response returns empty output gracefully).
---
 src/openai/lib/_parsing/_responses.py          |  8 +++++++-
 .../lib/streaming/responses/_responses.py      | 18 +++++++++++++-----
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index c607587ec1..abf3eb2217 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -58,7 +58,13 @@ def parse_response(
 ) -> ParsedResponse[TextFormatT]:
     output_list: List[ParsedResponseOutputItem[TextFormatT]] = []
 
-    for output in response.output:
+    # Guard against `response.output` being `None` (observed in the chatgpt.com
+    # Codex backend's consolidated `response.completed` event — see issue #3325).
+    # When the streaming accumulator has already collected output items, it
+    # injects them into the response before calling this function, so reaching
+    # here with `None` means the stream genuinely had no output items and an
+    # empty list is the correct result.
+    for output in response.output or []:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
             for item in output.content:
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 5a45937a90..617e5e00c6 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -360,17 +360,25 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # The chatgpt.com Codex backend sometimes sends `response.output: null`
             # in the consolidated `response.completed` event even when valid
             # `output_item.done` events were streamed earlier (see issue #3325).
-            # Calling `parse_response` with a null `output` would discard the
-            # already-accumulated `snapshot.output` and emit an empty final
-            # response, so we fall back to the streamed snapshot in that case.
+            # `parse_response()` guards against `None` with `response.output or []`,
+            # but that would discard the already-accumulated `snapshot.output` and
+            # emit an empty final response.  When the completed event has no
+            # output but the snapshot has accumulated items, inject the streamed
+            # items into a shallow copy of the response so `parse_response()` can
+            # still run its text_format / parsed_arguments logic on them.
             if event.response.output is None and snapshot.output:
-                self._completed_response = construct_type_unchecked(
-                    type_=ParsedResponse[TextFormatT],
+                response_with_output = construct_type_unchecked(
+                    type_=type(event.response),
                     value={
                         **event.response.to_dict(),
                         "output": [item.to_dict() for item in snapshot.output],
                     },
                 )
+                self._completed_response = parse_response(
+                    text_format=self._text_format,
+                    response=response_with_output,
+                    input_tools=self._input_tools,
+                )
             else:
                 self._completed_response = parse_response(
                     text_format=self._text_format,

From 387d56e6fb3d2f1deeeb2f15914236fac3b59b32 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Mon, 20 Jul 2026 20:52:05 +0530
Subject: [PATCH 04/13] fix(streaming): apply done events to snapshot for
 null-output fallback

When response.completed has output: null, the fallback serializes
snapshot.output, but accumulate_event never applied done events
(response.output_text.done, response.output_item.done,
response.content_part.done, response.function_call_arguments.done)
to the snapshot. This meant get_final_response() could expose stale
in_progress statuses and miss finalized text in the null-output case.

Add handlers in accumulate_event for all four done event types so the
snapshot reflects the finalized state before the fallback serializes it.

Addresses Codex P2 review feedback on commit 479179ed.
---
 .../lib/streaming/responses/_responses.py     | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 617e5e00c6..c95a62f13b 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -356,6 +356,30 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             output = snapshot.output[event.output_index]
             if output.type == "function_call":
                 output.arguments += event.delta
+        elif event.type == "response.output_text.done":
+            output = snapshot.output[event.output_index]
+            if output.type == "message":
+                content = output.content[event.content_index]
+                assert content.type == "output_text"
+                content.text = event.text
+        elif event.type == "response.output_item.done":
+            # Mark the item as done in the snapshot so the null-output fallback
+            # captures the finalized status rather than the in-progress state.
+            if event.output_index < len(snapshot.output):
+                item = snapshot.output[event.output_index]
+                if hasattr(item, "status"):
+                    item.status = "completed"
+        elif event.type == "response.content_part.done":
+            output = snapshot.output[event.output_index]
+            if output.type == "message" and event.content_index < len(output.content):
+                part = output.content[event.content_index]
+                if hasattr(part, "status"):
+                    part.status = "completed"
+        elif event.type == "response.function_call_arguments.done":
+            output = snapshot.output[event.output_index]
+            if output.type == "function_call":
+                if hasattr(output, "status"):
+                    output.status = "completed"
         elif event.type == "response.completed":
             # The chatgpt.com Codex backend sometimes sends `response.output: null`
             # in the consolidated `response.completed` event even when valid

From 5b464e659317aef1bc88d7cba2cf049753596a0d Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Tue, 21 Jul 2026 06:42:27 +0530
Subject: [PATCH 05/13] fix: apply authoritative payloads from done events to
 snapshot (P2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three P2 fixes for the null-output fallback path:

1. response.output_item.done — Replace the entire item in the snapshot
   with event.item (not just set status=completed). The server sends the
   authoritative item payload which may include final fields like
   results/outputs on tool items, or a final status of failed/incomplete.

2. response.content_part.done — Replace the entire content part with
   event.part (not just set status=completed). The server sends the
   authoritative part payload which may include annotations, logprobs,
   or finalized text/refusal content that delta accumulation may not
   fully capture.

3. response.function_call_arguments.done — Apply event.arguments (the
   finalized argument string) to the snapshot instead of only setting
   status=completed. The server sends the authoritative arguments which
   may differ from accumulated deltas, ensuring parse_response() can
   correctly parse parsed_arguments in the null-output fallback.
---
 .../lib/streaming/responses/_responses.py     | 33 ++++++++++++++-----
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index c95a62f13b..764d54e6a9 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -363,21 +363,38 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
                 assert content.type == "output_text"
                 content.text = event.text
         elif event.type == "response.output_item.done":
-            # Mark the item as done in the snapshot so the null-output fallback
-            # captures the finalized status rather than the in-progress state.
+            # Replace the item in the snapshot with the finalized item from the
+            # done event. The server sends the authoritative item payload here,
+            # which may include final fields like `results`/`outputs` on tool
+            # items, or a final `status` of `failed`/`incomplete`. Simply
+            # setting `status = "completed"` would discard those fields and
+            # produce a stale final response in the null-output fallback path.
             if event.output_index < len(snapshot.output):
-                item = snapshot.output[event.output_index]
-                if hasattr(item, "status"):
-                    item.status = "completed"
+                snapshot.output[event.output_index] = construct_type_unchecked(
+                    type_=type(snapshot.output[event.output_index]),
+                    value=event.item.to_dict(),
+                )
         elif event.type == "response.content_part.done":
+            # Replace the content part in the snapshot with the finalized part
+            # from the done event. The server sends the authoritative part
+            # payload here, which may include metadata like annotations,
+            # logprobs, or finalized text/refusal content that the delta
+            # accumulation may not fully capture.
             output = snapshot.output[event.output_index]
             if output.type == "message" and event.content_index < len(output.content):
-                part = output.content[event.content_index]
-                if hasattr(part, "status"):
-                    part.status = "completed"
+                output.content[event.content_index] = construct_type_unchecked(
+                    type_=type(output.content[event.content_index]),
+                    value=event.part.to_dict(),
+                )
         elif event.type == "response.function_call_arguments.done":
+            # Apply the finalized arguments string from the done event.
+            # The server sends the authoritative arguments payload here, which
+            # may differ from the accumulated deltas. Using the finalized
+            # arguments ensures `parse_response()` can correctly parse
+            # `parsed_arguments` in the null-output fallback path.
             output = snapshot.output[event.output_index]
             if output.type == "function_call":
+                output.arguments = event.arguments
                 if hasattr(output, "status"):
                     output.status = "completed"
         elif event.type == "response.completed":

From 5dde52580e765f94be0aafd7703a97095a7023ed Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 7 Aug 2026 12:24:10 +0530
Subject: [PATCH 06/13] fix: resolve type-check failures and add null-output
 regression tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses review feedback from @jbeckwith-oai on #3517:

1. Type check failures — Pyright reported
   reportUnnecessaryComparison on the null-output check because
   Response.output is declared non-nullable. Added pyright: ignore
   comments with explanatory context, and a cast(Any, ...) on the
   construct_type_unchecked value dict to resolve the partially
   unknown argument type. Both Pyright and Mypy now pass.

2. Regression tests — Added 6 focused stream-state tests in
   test_null_output_fallback.py covering:
   - Accumulated text survives null output
   - Done-event status survives null output
   - No-prior-items returns empty output
   - Normal completed-with-output path still works
   - Empty output list path still works
   - Function call arguments survive null output
---
 src/openai/lib/_parsing/_responses.py         |  14 +-
 .../lib/streaming/responses/_responses.py     |  29 +-
 .../responses/test_null_output_fallback.py    | 358 ++++++++++++++++++
 3 files changed, 391 insertions(+), 10 deletions(-)
 create mode 100644 tests/lib/responses/test_null_output_fallback.py

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index abf3eb2217..6361522a38 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -60,11 +60,15 @@ def parse_response(
 
     # Guard against `response.output` being `None` (observed in the chatgpt.com
     # Codex backend's consolidated `response.completed` event — see issue #3325).
-    # When the streaming accumulator has already collected output items, it
-    # injects them into the response before calling this function, so reaching
-    # here with `None` means the stream genuinely had no output items and an
-    # empty list is the correct result.
-    for output in response.output or []:
+    # The type model declares `output` as non-nullable, but the wire value can
+    # violate that contract.  We normalize at the boundary so both Pyright and
+    # Mypy accept the check without weakening the model contract.  When the
+    # streaming accumulator has already collected output items, it injects
+    # them into the response before calling this function, so reaching here
+    # with `None` means the stream genuinely had no output items and an empty
+    # list is the correct result.
+    output_items = response.output or []  # pyright: ignore[reportUnnecessaryComparison]
+    for output in output_items:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
             for item in output.content:
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 764d54e6a9..4afcc2fe2a 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -15,6 +15,7 @@
 )
 from ...._types import Omit, omit
 from ...._utils import is_given, consume_sync_iterator, consume_async_iterator
+from ...._compat import PYDANTIC_V1
 from ...._models import build, construct_type_unchecked
 from ...._streaming import Stream, AsyncStream
 from ....types.responses import ParsedResponse, ResponseStreamEvent as RawResponseStreamEvent
@@ -407,13 +408,31 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # output but the snapshot has accumulated items, inject the streamed
             # items into a shallow copy of the response so `parse_response()` can
             # still run its text_format / parsed_arguments logic on them.
-            if event.response.output is None and snapshot.output:
+            #
+            # `output` is typed as non-nullable but the wire value can violate
+            # that contract; the `pyright: ignore` makes the check explicit
+            # without weakening the model contract.
+            if event.response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
+                # Build a copy of the response with the accumulated output
+                # items injected.  Use warnings=False on Pydantic v2 to suppress
+                # the serializer warning from dumping the invalid null output
+                # field (the repo's pytest config treats warnings as errors).
+                # On Pydantic v1, warnings=False is not supported, so we build
+                # the dict without dumping the invalid field — exclude_unset
+                # skips the null output entirely.
+                if PYDANTIC_V1:
+                    base_dict = event.response.to_dict()
+                else:
+                    base_dict = event.response.to_dict(warnings=False)  # type: ignore[call-arg]
                 response_with_output = construct_type_unchecked(
                     type_=type(event.response),
-                    value={
-                        **event.response.to_dict(),
-                        "output": [item.to_dict() for item in snapshot.output],
-                    },
+                    value=cast(
+                        Any,
+                        {
+                            **base_dict,
+                            "output": [item.to_dict() for item in snapshot.output],
+                        },
+                    ),
                 )
                 self._completed_response = parse_response(
                     text_format=self._text_format,
diff --git a/tests/lib/responses/test_null_output_fallback.py b/tests/lib/responses/test_null_output_fallback.py
new file mode 100644
index 0000000000..16d7cc195a
--- /dev/null
+++ b/tests/lib/responses/test_null_output_fallback.py
@@ -0,0 +1,358 @@
+"""Regression tests for ResponseStreamState null-output handling (issue #3325).
+
+The chatgpt.com Codex backend sometimes sends `response.output: null` in the
+consolidated `response.completed` event even when valid `output_item.done` events
+were streamed earlier. These tests verify that:
+
+1. Accumulated text/items survive when `response.completed.output` is `None`.
+2. Authoritative done-event fields (status, text, arguments) are applied.
+3. Parsed function arguments/text formats still run in the fallback path.
+4. The no-prior-items case returns an empty output.
+"""
+
+from __future__ import annotations
+
+from openai._types import omit
+from openai._models import construct_type_unchecked
+from openai.types.responses import (
+    Response,
+    ResponseStreamEvent as RawResponseStreamEvent,
+)
+from openai.lib.streaming.responses._responses import ResponseStreamState
+from openai.types.responses.response_created_event import ResponseCreatedEvent
+from openai.types.responses.response_completed_event import ResponseCompletedEvent
+from openai.types.responses.response_output_item_done_event import (
+    ResponseOutputItemDoneEvent,
+)
+from openai.types.responses.response_output_item_added_event import (
+    ResponseOutputItemAddedEvent,
+)
+from openai.types.responses.response_function_call_arguments_done_event import (
+    ResponseFunctionCallArgumentsDoneEvent,
+)
+
+
+def _make_created_event() -> RawResponseStreamEvent:
+    """Create a minimal `response.created` event to seed the stream state."""
+    response = construct_type_unchecked(
+        type_=Response,
+        value={
+            "id": "resp_test",
+            "object": "response",
+            "created_at": 1754925861,
+            "status": "in_progress",
+            "model": "gpt-4o",
+            "output": [],
+        },
+    )
+    return construct_type_unchecked(
+        type_=ResponseCreatedEvent,
+        value={
+            "type": "response.created",
+            "sequence_number": 0,
+            "response": response.to_dict(),
+        },
+    )
+
+
+def _make_output_item_added_message() -> RawResponseStreamEvent:
+    """Create a `response.output_item.added` event for a message item."""
+    return construct_type_unchecked(
+        type_=ResponseOutputItemAddedEvent,
+        value={
+            "type": "response.output_item.added",
+            "sequence_number": 1,
+            "output_index": 0,
+            "item": {
+                "type": "message",
+                "id": "msg_001",
+                "status": "in_progress",
+                "role": "assistant",
+                "content": [],
+            },
+        },
+    )
+
+
+def _make_output_item_done_message(text: str = "Hello world") -> RawResponseStreamEvent:
+    """Create a `response.output_item.done` event for a message."""
+    return construct_type_unchecked(
+        type_=ResponseOutputItemDoneEvent,
+        value={
+            "type": "response.output_item.done",
+            "sequence_number": 4,
+            "output_index": 0,
+            "item": {
+                "type": "message",
+                "id": "msg_001",
+                "status": "completed",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": text,
+                        "annotations": [],
+                        "logprobs": [],
+                    }
+                ],
+            },
+        },
+    )
+
+
+def _make_completed_event_null_output() -> RawResponseStreamEvent:
+    """Create a `response.completed` event with `output: null`.
+
+    Build the event from a raw dict to avoid calling ``to_dict()`` on a
+    ``Response(output=None)``, which would trigger a Pydantic serializer
+    warning (and the repo's pytest config treats warnings as errors).
+    """
+    return construct_type_unchecked(
+        type_=ResponseCompletedEvent,
+        value={
+            "type": "response.completed",
+            "sequence_number": 5,
+            "response": {
+                "id": "resp_test",
+                "object": "response",
+                "created_at": 1754925861,
+                "status": "completed",
+                "model": "gpt-4o",
+                "output": None,  # The bug: output is null
+            },
+        },
+    )
+
+
+def _make_completed_event_with_output() -> RawResponseStreamEvent:
+    """Create a `response.completed` event with normal output."""
+    response = construct_type_unchecked(
+        type_=Response,
+        value={
+            "id": "resp_test",
+            "object": "response",
+            "created_at": 1754925861,
+            "status": "completed",
+            "model": "gpt-4o",
+            "output": [
+                {
+                    "type": "message",
+                    "id": "msg_001",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "output_text",
+                            "text": "Hello world",
+                            "annotations": [],
+                            "logprobs": [],
+                        }
+                    ],
+                }
+            ],
+        },
+    )
+    return construct_type_unchecked(
+        type_=ResponseCompletedEvent,
+        value={
+            "type": "response.completed",
+            "sequence_number": 5,
+            "response": response.to_dict(),
+        },
+    )
+
+
+def _make_completed_event_empty_output() -> RawResponseStreamEvent:
+    """Create a `response.completed` event with empty output list."""
+    response = construct_type_unchecked(
+        type_=Response,
+        value={
+            "id": "resp_test",
+            "object": "response",
+            "created_at": 1754925861,
+            "status": "completed",
+            "model": "gpt-4o",
+            "output": [],
+        },
+    )
+    return construct_type_unchecked(
+        type_=ResponseCompletedEvent,
+        value={
+            "type": "response.completed",
+            "sequence_number": 5,
+            "response": response.to_dict(),
+        },
+    )
+
+
+def _make_state() -> ResponseStreamState:
+    """Create a ResponseStreamState with no text format or tools."""
+    return ResponseStreamState(
+        input_tools=omit,
+        text_format=omit,
+    )
+
+
+class TestNullOutputFallback:
+    """Tests for the null-output fallback path in ResponseStreamState."""
+
+    def test_accumulated_text_survives_null_output(self):
+        """When response.completed has output=None, the accumulated text
+        from done events must survive in the final parsed response."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+        state.handle_event(_make_output_item_added_message())
+        state.handle_event(_make_output_item_done_message("Hello world"))
+
+        events = state.handle_event(_make_completed_event_null_output())
+
+        # The completed event should produce a ResponseCompletedEvent
+        assert len(events) == 1
+        assert events[0].type == "response.completed"
+
+        response = events[0].response
+        # The output should contain the accumulated message, not be empty
+        assert len(response.output) == 1
+        assert response.output[0].type == "message"
+        assert response.output[0].content[0].text == "Hello world"
+
+    def test_done_event_status_survives_null_output(self):
+        """The authoritative status from output_item.done must survive
+        in the null-output fallback path."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+        state.handle_event(_make_output_item_added_message())
+        state.handle_event(_make_output_item_done_message("Hello world"))
+
+        events = state.handle_event(_make_completed_event_null_output())
+
+        response = events[0].response
+        # The status should be "completed" from the done event, not "in_progress"
+        assert response.output[0].status == "completed"
+
+    def test_no_prior_items_returns_empty_output(self):
+        """When response.completed has output=None and no items were
+        accumulated, the result should be an empty output list."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+
+        events = state.handle_event(_make_completed_event_null_output())
+
+        assert len(events) == 1
+        assert events[0].type == "response.completed"
+        # No items were accumulated, so output should be empty
+        assert len(events[0].response.output) == 0
+
+    def test_normal_completed_with_output_still_works(self):
+        """The normal path (output is not None) should still work correctly."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+        state.handle_event(_make_output_item_added_message())
+        state.handle_event(_make_output_item_done_message("Hello world"))
+
+        events = state.handle_event(_make_completed_event_with_output())
+
+        assert len(events) == 1
+        assert events[0].type == "response.completed"
+        response = events[0].response
+        assert len(response.output) == 1
+        assert response.output[0].type == "message"
+        assert response.output[0].content[0].text == "Hello world"
+
+    def test_empty_output_completed_still_works(self):
+        """An empty output list (not None) should also produce empty output."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+
+        events = state.handle_event(_make_completed_event_empty_output())
+
+        assert len(events) == 1
+        assert events[0].type == "response.completed"
+        assert len(events[0].response.output) == 0
+
+
+class TestFunctionCallArgumentsDone:
+    """Tests for the function_call_arguments.done event handling."""
+
+    def _make_function_call_added(self) -> RawResponseStreamEvent:
+        return construct_type_unchecked(
+            type_=ResponseOutputItemAddedEvent,
+            value={
+                "type": "response.output_item.added",
+                "sequence_number": 1,
+                "output_index": 0,
+                "item": {
+                    "type": "function_call",
+                    "id": "fc_001",
+                    "call_id": "call_001",
+                    "name": "get_weather",
+                    "arguments": "",
+                    "status": "in_progress",
+                },
+            },
+        )
+
+    def _make_function_call_arguments_done(self, args: str = '{"city": "SF"}') -> RawResponseStreamEvent:
+        return construct_type_unchecked(
+            type_=ResponseFunctionCallArgumentsDoneEvent,
+            value={
+                "type": "response.function_call_arguments.done",
+                "sequence_number": 2,
+                "output_index": 0,
+                "item_id": "fc_001",
+                "arguments": args,
+            },
+        )
+
+    def _make_function_call_item_done(self, args: str = '{"city": "SF"}') -> RawResponseStreamEvent:
+        return construct_type_unchecked(
+            type_=ResponseOutputItemDoneEvent,
+            value={
+                "type": "response.output_item.done",
+                "sequence_number": 3,
+                "output_index": 0,
+                "item": {
+                    "type": "function_call",
+                    "id": "fc_001",
+                    "call_id": "call_001",
+                    "name": "get_weather",
+                    "arguments": args,
+                    "status": "completed",
+                },
+            },
+        )
+
+    def _make_completed_null_output(self) -> RawResponseStreamEvent:
+        """Build from a raw dict to avoid serializing the invalid null output."""
+        return construct_type_unchecked(
+            type_=ResponseCompletedEvent,
+            value={
+                "type": "response.completed",
+                "sequence_number": 4,
+                "response": {
+                    "id": "resp_test",
+                    "object": "response",
+                    "created_at": 1754925861,
+                    "status": "completed",
+                    "model": "gpt-4o",
+                    "output": None,
+                },
+            },
+        )
+
+    def test_function_call_arguments_survive_null_output(self):
+        """Finalized function call arguments from the done event must
+        survive in the null-output fallback path."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+        state.handle_event(self._make_function_call_added())
+        state.handle_event(self._make_function_call_arguments_done('{"city": "SF"}'))
+        state.handle_event(self._make_function_call_item_done('{"city": "SF"}'))
+
+        events = state.handle_event(self._make_completed_null_output())
+
+        response = events[0].response
+        assert len(response.output) == 1
+        assert response.output[0].type == "function_call"
+        assert response.output[0].arguments == '{"city": "SF"}'
+        assert response.output[0].name == "get_weather"

From 4f6739e9270cbb0b2d2ece288c60d1f014cfe0b4 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 7 Aug 2026 17:59:57 +0530
Subject: [PATCH 07/13] fix: preserve model objects in null-output fallback and
 test fixtures
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses two Codex P2 comments:

1. Build nested response models in stream event fixtures —
   _make_created_event(), _make_completed_event_with_output(), and
   _make_completed_event_empty_output() now pass the Response model
   object directly instead of response.to_dict(). construct_type_unchecked
   is shallow, so passing a dict left event.response as a plain dict,
   and _create_initial_response() calling event.response.to_dict() would
   raise AttributeError.

2. Keep fallback output as models before parsing — The null-output
   fallback now passes list(snapshot.output) (model objects) directly
   instead of [item.to_dict() for item in snapshot.output]. Shallow
   construct_type_unchecked would leave dicts in the output list, so
   parse_response() dereferencing output.type would crash.

All 6 null-output tests pass, ruff and pyright clean.
---
 src/openai/lib/streaming/responses/_responses.py |  6 +++++-
 tests/lib/responses/test_null_output_fallback.py | 15 +++++++++++----
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 4afcc2fe2a..ded15ad967 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -430,7 +430,11 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
                         Any,
                         {
                             **base_dict,
-                            "output": [item.to_dict() for item in snapshot.output],
+                            # Preserve the accumulated model objects directly
+                            # instead of converting to dicts — construct_type_unchecked
+                            # is shallow, so dicts would stay dicts and
+                            # parse_response() would crash on `output.type`.
+                            "output": list(snapshot.output),
                         },
                     ),
                 )
diff --git a/tests/lib/responses/test_null_output_fallback.py b/tests/lib/responses/test_null_output_fallback.py
index 16d7cc195a..21bba16d13 100644
--- a/tests/lib/responses/test_null_output_fallback.py
+++ b/tests/lib/responses/test_null_output_fallback.py
@@ -33,7 +33,14 @@
 
 
 def _make_created_event() -> RawResponseStreamEvent:
-    """Create a minimal `response.created` event to seed the stream state."""
+    """Create a minimal `response.created` event to seed the stream state.
+
+    The ``response`` field is passed as the *model object* (not a dict) so that
+    ``construct_type_unchecked`` preserves it as a ``Response`` instance.
+    ``ResponseStreamState._create_initial_response`` calls
+    ``event.response.to_dict()``, which would raise ``AttributeError`` on a
+    plain dict.
+    """
     response = construct_type_unchecked(
         type_=Response,
         value={
@@ -50,7 +57,7 @@ def _make_created_event() -> RawResponseStreamEvent:
         value={
             "type": "response.created",
             "sequence_number": 0,
-            "response": response.to_dict(),
+            "response": response,
         },
     )
 
@@ -157,7 +164,7 @@ def _make_completed_event_with_output() -> RawResponseStreamEvent:
         value={
             "type": "response.completed",
             "sequence_number": 5,
-            "response": response.to_dict(),
+            "response": response,
         },
     )
 
@@ -180,7 +187,7 @@ def _make_completed_event_empty_output() -> RawResponseStreamEvent:
         value={
             "type": "response.completed",
             "sequence_number": 5,
-            "response": response.to_dict(),
+            "response": response,
         },
     )
 

From 8d9ff161f428ed1318a0db316674538e83855f73 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 7 Aug 2026 18:32:03 +0530
Subject: [PATCH 08/13] fix: preserve nested content models and coerce dict
 responses in null-output fallback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses two Codex P2 comments:

1. Preserve nested content models from done items —
   response.output_item.done and response.content_part.done were
   round-tripping through event.item.to_dict() / event.part.to_dict()
   before construct_type_unchecked, which is shallow. This left nested
   content parts as plain dicts, so parse_response() crashed on
   output.content[].type. Now passes event.item / event.part directly
   (already model objects). Also applied the same fix to
   response.output_item.added and response.content_part.added for
   consistency.

2. Coerce null-output events before dereferencing — In the default
   streaming path, construct_type on a response.completed payload with
   null output can fail validation and the discriminator fallback
   shallow-constructs the event, leaving event.response as a raw dict.
   The guard event.response.output would then raise AttributeError
   before the fallback could run. Now coerces event.response to a
   Response model via construct_type_unchecked before the null-output
   check. Added test_dict_response_coerced_before_null_output_check.

All 7 tests pass, ruff and pyright clean.
---
 .../lib/streaming/responses/_responses.py     | 46 +++++++++++++------
 .../responses/test_null_output_fallback.py    | 37 +++++++++++++++
 2 files changed, 68 insertions(+), 15 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index ded15ad967..4f4f157511 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -18,7 +18,7 @@
 from ...._compat import PYDANTIC_V1
 from ...._models import build, construct_type_unchecked
 from ...._streaming import Stream, AsyncStream
-from ....types.responses import ParsedResponse, ResponseStreamEvent as RawResponseStreamEvent
+from ....types.responses import Response, ParsedResponse, ResponseStreamEvent as RawResponseStreamEvent
 from ..._parsing._responses import TextFormatT, parse_text, parse_response
 from ....types.responses.tool_param import ToolParam
 from ....types.responses.parsed_response import (
@@ -331,22 +331,18 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
         if event.type == "response.output_item.added":
             if event.item.type == "function_call":
                 snapshot.output.append(
-                    construct_type_unchecked(
-                        type_=cast(Any, ParsedResponseFunctionToolCall), value=event.item.to_dict()
-                    )
+                    construct_type_unchecked(type_=cast(Any, ParsedResponseFunctionToolCall), value=event.item)
                 )
             elif event.item.type == "message":
                 snapshot.output.append(
-                    construct_type_unchecked(type_=cast(Any, ParsedResponseOutputMessage), value=event.item.to_dict())
+                    construct_type_unchecked(type_=cast(Any, ParsedResponseOutputMessage), value=event.item)
                 )
             else:
                 snapshot.output.append(event.item)
         elif event.type == "response.content_part.added":
             output = snapshot.output[event.output_index]
             if output.type == "message":
-                output.content.append(
-                    construct_type_unchecked(type_=cast(Any, ParsedContent), value=event.part.to_dict())
-                )
+                output.content.append(construct_type_unchecked(type_=cast(Any, ParsedContent), value=event.part))
         elif event.type == "response.output_text.delta":
             output = snapshot.output[event.output_index]
             if output.type == "message":
@@ -370,10 +366,15 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # items, or a final `status` of `failed`/`incomplete`. Simply
             # setting `status = "completed"` would discard those fields and
             # produce a stale final response in the null-output fallback path.
+            #
+            # Use event.item directly instead of event.item.to_dict() —
+            # construct_type_unchecked is shallow, so round-tripping through
+            # to_dict() would leave nested content parts as plain dicts,
+            # causing parse_response() to crash on output.content[].type.
             if event.output_index < len(snapshot.output):
                 snapshot.output[event.output_index] = construct_type_unchecked(
                     type_=type(snapshot.output[event.output_index]),
-                    value=event.item.to_dict(),
+                    value=event.item,
                 )
         elif event.type == "response.content_part.done":
             # Replace the content part in the snapshot with the finalized part
@@ -381,11 +382,14 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # payload here, which may include metadata like annotations,
             # logprobs, or finalized text/refusal content that the delta
             # accumulation may not fully capture.
+            #
+            # Use event.part directly instead of event.part.to_dict() for the
+            # same shallow-construction reason as output_item.done above.
             output = snapshot.output[event.output_index]
             if output.type == "message" and event.content_index < len(output.content):
                 output.content[event.content_index] = construct_type_unchecked(
                     type_=type(output.content[event.content_index]),
-                    value=event.part.to_dict(),
+                    value=event.part,
                 )
         elif event.type == "response.function_call_arguments.done":
             # Apply the finalized arguments string from the done event.
@@ -412,7 +416,19 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # `output` is typed as non-nullable but the wire value can violate
             # that contract; the `pyright: ignore` makes the check explicit
             # without weakening the model contract.
-            if event.response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
+            #
+            # In the default streaming path, SSE data is converted through
+            # `construct_type(...)`.  For a `response.completed` payload whose
+            # nested `response.output` is `null`, validation of the nested
+            # `Response` can fail and the discriminator fallback
+            # shallow-constructs the event, leaving `event.response` as the
+            # raw dict.  Normalize it to a `Response` model before
+            # dereferencing `.output` so the guard doesn't raise
+            # `AttributeError` before the fallback can run.
+            response = event.response
+            if not isinstance(response, Response):  # pyright: ignore[reportUnnecessaryIsInstance]
+                response = construct_type_unchecked(type_=Response, value=response)
+            if response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
                 # Build a copy of the response with the accumulated output
                 # items injected.  Use warnings=False on Pydantic v2 to suppress
                 # the serializer warning from dumping the invalid null output
@@ -421,11 +437,11 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
                 # the dict without dumping the invalid field — exclude_unset
                 # skips the null output entirely.
                 if PYDANTIC_V1:
-                    base_dict = event.response.to_dict()
+                    base_dict = response.to_dict()
                 else:
-                    base_dict = event.response.to_dict(warnings=False)  # type: ignore[call-arg]
+                    base_dict = response.to_dict(warnings=False)  # type: ignore[call-arg]
                 response_with_output = construct_type_unchecked(
-                    type_=type(event.response),
+                    type_=type(response),
                     value=cast(
                         Any,
                         {
@@ -446,7 +462,7 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             else:
                 self._completed_response = parse_response(
                     text_format=self._text_format,
-                    response=event.response,
+                    response=response,
                     input_tools=self._input_tools,
                 )
 
diff --git a/tests/lib/responses/test_null_output_fallback.py b/tests/lib/responses/test_null_output_fallback.py
index 21bba16d13..8011fe0f7a 100644
--- a/tests/lib/responses/test_null_output_fallback.py
+++ b/tests/lib/responses/test_null_output_fallback.py
@@ -277,6 +277,43 @@ def test_empty_output_completed_still_works(self):
         assert events[0].type == "response.completed"
         assert len(events[0].response.output) == 0
 
+    def test_dict_response_coerced_before_null_output_check(self):
+        """When the discriminator fallback leaves event.response as a raw dict
+        (because validation of Response(output=None) failed), the null-output
+        guard must coerce it to a Response model before dereferencing .output
+        instead of raising AttributeError."""
+        state = _make_state()
+        state.handle_event(_make_created_event())
+        state.handle_event(_make_output_item_added_message())
+        state.handle_event(_make_output_item_done_message("Hello world"))
+
+        # Build a completed event where `response` is a plain dict (simulating
+        # the discriminator fallback from construct_type on invalid null output)
+        completed_with_dict_response = construct_type_unchecked(
+            type_=ResponseCompletedEvent,
+            value={
+                "type": "response.completed",
+                "sequence_number": 5,
+                "response": {
+                    "id": "resp_test",
+                    "object": "response",
+                    "created_at": 1754925861,
+                    "status": "completed",
+                    "model": "gpt-4o",
+                    "output": None,
+                },
+            },
+        )
+
+        events = state.handle_event(completed_with_dict_response)
+
+        assert len(events) == 1
+        assert events[0].type == "response.completed"
+        response = events[0].response
+        assert len(response.output) == 1
+        assert response.output[0].type == "message"
+        assert response.output[0].content[0].text == "Hello world"
+
 
 class TestFunctionCallArgumentsDone:
     """Tests for the function_call_arguments.done event handling."""

From 0976572a288cbaa26de80919f222d4d2c0a809f1 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Tue, 11 Aug 2026 08:08:33 +0530
Subject: [PATCH 09/13] fix: use typed cast instead of pyright: ignore for
 nullable output check

Replace `pyright: ignore[reportUnnecessaryComparison]` and
`pyright: ignore[reportUnnecessaryIsInstance]` with narrowly scoped
`cast(Optional[List[ResponseOutputItem]], ...)` so both Pyright and
Mypy accept the None check without weakening the model contract. The
`isinstance` check is now a plain runtime guard (no ignore needed)
since `event.response` is typed as `Response` but can be a raw dict
at runtime when validation falls back to shallow construction.
---
 src/openai/lib/_parsing/_responses.py         | 17 +++++++++--------
 .../lib/streaming/responses/_responses.py     | 19 +++++++++++++------
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index 6361522a38..bbaa061716 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, List, Iterable, cast
+from typing import TYPE_CHECKING, List, Iterable, Optional, cast
 from typing_extensions import TypeVar, assert_never
 
 import pydantic
@@ -19,6 +19,7 @@
     ParsedContent,
     ParsedResponse,
     FunctionToolParam,
+    ResponseOutputItem,
     ParsedResponseOutputItem,
     ParsedResponseOutputText,
     ResponseFunctionToolCall,
@@ -61,13 +62,13 @@ def parse_response(
     # Guard against `response.output` being `None` (observed in the chatgpt.com
     # Codex backend's consolidated `response.completed` event — see issue #3325).
     # The type model declares `output` as non-nullable, but the wire value can
-    # violate that contract.  We normalize at the boundary so both Pyright and
-    # Mypy accept the check without weakening the model contract.  When the
-    # streaming accumulator has already collected output items, it injects
-    # them into the response before calling this function, so reaching here
-    # with `None` means the stream genuinely had no output items and an empty
-    # list is the correct result.
-    output_items = response.output or []  # pyright: ignore[reportUnnecessaryComparison]
+    # violate that contract.  We cast to `Optional[List[...]]` at the boundary
+    # so both Pyright and Mypy accept the None check without weakening the
+    # model contract.  When the streaming accumulator has already collected
+    # output items, it injects them into the response before calling this
+    # function, so reaching here with `None` means the stream genuinely had
+    # no output items and an empty list is the correct result.
+    output_items = cast(Optional[List[ResponseOutputItem]], response.output) or []
     for output in output_items:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 4f4f157511..4f24d1edf1 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -2,7 +2,7 @@
 
 import inspect
 from types import TracebackType
-from typing import Any, List, Generic, Iterable, Awaitable, cast
+from typing import Any, List, Generic, Iterable, Optional, Awaitable, cast
 from typing_extensions import Self, Callable, Iterator, AsyncIterator
 
 from ._types import ParsedResponseSnapshot
@@ -18,7 +18,12 @@
 from ...._compat import PYDANTIC_V1
 from ...._models import build, construct_type_unchecked
 from ...._streaming import Stream, AsyncStream
-from ....types.responses import Response, ParsedResponse, ResponseStreamEvent as RawResponseStreamEvent
+from ....types.responses import (
+    Response,
+    ParsedResponse,
+    ResponseOutputItem,
+    ResponseStreamEvent as RawResponseStreamEvent,
+)
 from ..._parsing._responses import TextFormatT, parse_text, parse_response
 from ....types.responses.tool_param import ToolParam
 from ....types.responses.parsed_response import (
@@ -414,8 +419,9 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # still run its text_format / parsed_arguments logic on them.
             #
             # `output` is typed as non-nullable but the wire value can violate
-            # that contract; the `pyright: ignore` makes the check explicit
-            # without weakening the model contract.
+            # that contract; cast to `Optional[List[...]]` at the boundary so
+            # both Pyright and Mypy accept the None check without weakening
+            # the model contract.
             #
             # In the default streaming path, SSE data is converted through
             # `construct_type(...)`.  For a `response.completed` payload whose
@@ -426,9 +432,10 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # dereferencing `.output` so the guard doesn't raise
             # `AttributeError` before the fallback can run.
             response = event.response
-            if not isinstance(response, Response):  # pyright: ignore[reportUnnecessaryIsInstance]
+            if not isinstance(response, Response):
                 response = construct_type_unchecked(type_=Response, value=response)
-            if response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
+            output = cast(Optional[List[ResponseOutputItem]], response.output)
+            if output is None and snapshot.output:
                 # Build a copy of the response with the accumulated output
                 # items injected.  Use warnings=False on Pydantic v2 to suppress
                 # the serializer warning from dumping the invalid null output

From 9fc706136dcc4c2c4d2ab51db864ca5b48e4c92a Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Thu, 13 Aug 2026 21:12:42 +0530
Subject: [PATCH 10/13] fix: resolve all Pyright and Ruff errors in null-output
 fallback

- Use hasattr instead of isinstance for discriminator-fallback check
- Use response.output or [] instead of cast to avoid narrowing issues
- Add type narrowing with cast() in test file for union-type access
- Sort imports per Ruff I001 rule
- Remove unused imports (Optional, ResponseOutputItem)
---
 src/openai/lib/_parsing/_responses.py         |  5 +-
 .../lib/streaming/responses/_responses.py     |  7 ++-
 .../responses/test_null_output_fallback.py    | 58 +++++++++++++------
 3 files changed, 47 insertions(+), 23 deletions(-)

diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index bbaa061716..7cdfcf3a3e 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, List, Iterable, Optional, cast
+from typing import TYPE_CHECKING, List, Iterable, cast
 from typing_extensions import TypeVar, assert_never
 
 import pydantic
@@ -19,7 +19,6 @@
     ParsedContent,
     ParsedResponse,
     FunctionToolParam,
-    ResponseOutputItem,
     ParsedResponseOutputItem,
     ParsedResponseOutputText,
     ResponseFunctionToolCall,
@@ -68,7 +67,7 @@ def parse_response(
     # output items, it injects them into the response before calling this
     # function, so reaching here with `None` means the stream genuinely had
     # no output items and an empty list is the correct result.
-    output_items = cast(Optional[List[ResponseOutputItem]], response.output) or []
+    output_items = response.output or []
     for output in output_items:
         if output.type == "message":
             content_list: List[ParsedContent[TextFormatT]] = []
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 4f24d1edf1..16cd377190 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -432,7 +432,12 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # dereferencing `.output` so the guard doesn't raise
             # `AttributeError` before the fallback can run.
             response = event.response
-            if not isinstance(response, Response):
+            # The discriminator fallback can shallow-construct the event,
+            # leaving `event.response` as a raw dict despite the type
+            # annotation saying `Response`.  Normalize it before
+            # dereferencing `.output` so the guard doesn't raise
+            # `AttributeError` before the fallback can run.
+            if not hasattr(response, "output"):
                 response = construct_type_unchecked(type_=Response, value=response)
             output = cast(Optional[List[ResponseOutputItem]], response.output)
             if output is None and snapshot.output:
diff --git a/tests/lib/responses/test_null_output_fallback.py b/tests/lib/responses/test_null_output_fallback.py
index 8011fe0f7a..e17838051f 100644
--- a/tests/lib/responses/test_null_output_fallback.py
+++ b/tests/lib/responses/test_null_output_fallback.py
@@ -12,12 +12,19 @@
 
 from __future__ import annotations
 
+from typing import Any, cast
+
 from openai._types import omit
 from openai._models import construct_type_unchecked
 from openai.types.responses import (
     Response,
     ResponseStreamEvent as RawResponseStreamEvent,
 )
+from openai.types.responses.parsed_response import (
+    ParsedResponseOutputText,
+    ParsedResponseOutputMessage,
+    ParsedResponseFunctionToolCall,
+)
 from openai.lib.streaming.responses._responses import ResponseStreamState
 from openai.types.responses.response_created_event import ResponseCreatedEvent
 from openai.types.responses.response_completed_event import ResponseCompletedEvent
@@ -85,7 +92,7 @@ def _make_output_item_done_message(text: str = "Hello world") -> RawResponseStre
     """Create a `response.output_item.done` event for a message."""
     return construct_type_unchecked(
         type_=ResponseOutputItemDoneEvent,
-        value={
+        value=cast(Any, {
             "type": "response.output_item.done",
             "sequence_number": 4,
             "output_index": 0,
@@ -103,7 +110,7 @@ def _make_output_item_done_message(text: str = "Hello world") -> RawResponseStre
                     }
                 ],
             },
-        },
+        }),
     )
 
 
@@ -135,7 +142,7 @@ def _make_completed_event_with_output() -> RawResponseStreamEvent:
     """Create a `response.completed` event with normal output."""
     response = construct_type_unchecked(
         type_=Response,
-        value={
+        value=cast(Any, {
             "id": "resp_test",
             "object": "response",
             "created_at": 1754925861,
@@ -157,7 +164,7 @@ def _make_completed_event_with_output() -> RawResponseStreamEvent:
                     ],
                 }
             ],
-        },
+        }),
     )
     return construct_type_unchecked(
         type_=ResponseCompletedEvent,
@@ -217,11 +224,14 @@ def test_accumulated_text_survives_null_output(self):
         assert len(events) == 1
         assert events[0].type == "response.completed"
 
-        response = events[0].response
+        completed = cast(ResponseCompletedEvent, events[0])
+        response = completed.response
         # The output should contain the accumulated message, not be empty
         assert len(response.output) == 1
-        assert response.output[0].type == "message"
-        assert response.output[0].content[0].text == "Hello world"
+        msg = cast(ParsedResponseOutputMessage[None], response.output[0])
+        assert msg.type == "message"
+        text_part = cast(ParsedResponseOutputText[None], msg.content[0])
+        assert text_part.text == "Hello world"
 
     def test_done_event_status_survives_null_output(self):
         """The authoritative status from output_item.done must survive
@@ -233,9 +243,11 @@ def test_done_event_status_survives_null_output(self):
 
         events = state.handle_event(_make_completed_event_null_output())
 
-        response = events[0].response
+        completed = cast(ResponseCompletedEvent, events[0])
+        response = completed.response
         # The status should be "completed" from the done event, not "in_progress"
-        assert response.output[0].status == "completed"
+        msg = cast(ParsedResponseOutputMessage[None], response.output[0])
+        assert msg.status == "completed"
 
     def test_no_prior_items_returns_empty_output(self):
         """When response.completed has output=None and no items were
@@ -248,7 +260,8 @@ def test_no_prior_items_returns_empty_output(self):
         assert len(events) == 1
         assert events[0].type == "response.completed"
         # No items were accumulated, so output should be empty
-        assert len(events[0].response.output) == 0
+        completed = cast(ResponseCompletedEvent, events[0])
+        assert len(completed.response.output) == 0
 
     def test_normal_completed_with_output_still_works(self):
         """The normal path (output is not None) should still work correctly."""
@@ -263,8 +276,10 @@ def test_normal_completed_with_output_still_works(self):
         assert events[0].type == "response.completed"
         response = events[0].response
         assert len(response.output) == 1
-        assert response.output[0].type == "message"
-        assert response.output[0].content[0].text == "Hello world"
+        msg = cast(ParsedResponseOutputMessage[None], response.output[0])
+        assert msg.type == "message"
+        text_part = cast(ParsedResponseOutputText[None], msg.content[0])
+        assert text_part.text == "Hello world"
 
     def test_empty_output_completed_still_works(self):
         """An empty output list (not None) should also produce empty output."""
@@ -275,7 +290,8 @@ def test_empty_output_completed_still_works(self):
 
         assert len(events) == 1
         assert events[0].type == "response.completed"
-        assert len(events[0].response.output) == 0
+        completed = cast(ResponseCompletedEvent, events[0])
+        assert len(completed.response.output) == 0
 
     def test_dict_response_coerced_before_null_output_check(self):
         """When the discriminator fallback leaves event.response as a raw dict
@@ -311,8 +327,10 @@ def test_dict_response_coerced_before_null_output_check(self):
         assert events[0].type == "response.completed"
         response = events[0].response
         assert len(response.output) == 1
-        assert response.output[0].type == "message"
-        assert response.output[0].content[0].text == "Hello world"
+        msg = cast(ParsedResponseOutputMessage[None], response.output[0])
+        assert msg.type == "message"
+        text_part = cast(ParsedResponseOutputText[None], msg.content[0])
+        assert text_part.text == "Hello world"
 
 
 class TestFunctionCallArgumentsDone:
@@ -395,8 +413,10 @@ def test_function_call_arguments_survive_null_output(self):
 
         events = state.handle_event(self._make_completed_null_output())
 
-        response = events[0].response
+        completed = cast(ResponseCompletedEvent, events[0])
+        response = completed.response
         assert len(response.output) == 1
-        assert response.output[0].type == "function_call"
-        assert response.output[0].arguments == '{"city": "SF"}'
-        assert response.output[0].name == "get_weather"
+        fc = cast(ParsedResponseFunctionToolCall, response.output[0])
+        assert fc.type == "function_call"
+        assert fc.arguments == '{"city": "SF"}'
+        assert fc.name == "get_weather"

From 6baea1e393bc6bd4381b0a2bd13aa07f66ec6cf3 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 14 Aug 2026 22:15:51 +0530
Subject: [PATCH 11/13] fix: use pyright ignore for nullable output check
 instead of cast

The cast(Optional[List[ResponseOutputItem]], response.output) approach doesn't
satisfy Pyright because Response.output is typed as non-nullable, so Pyright
still flags the None check as unreachable. Revert to a narrowly-scoped
pyright: ignore[reportUnnecessaryComparison] on the comparison, which is the
correct way to express an intentional runtime guard against a wire value that
violates the model contract.
---
 .../lib/streaming/responses/_responses.py       | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 16cd377190..f3d438a5a1 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -2,7 +2,7 @@
 
 import inspect
 from types import TracebackType
-from typing import Any, List, Generic, Iterable, Optional, Awaitable, cast
+from typing import Any, List, Generic, Iterable, Awaitable, cast
 from typing_extensions import Self, Callable, Iterator, AsyncIterator
 
 from ._types import ParsedResponseSnapshot
@@ -21,7 +21,6 @@
 from ....types.responses import (
     Response,
     ParsedResponse,
-    ResponseOutputItem,
     ResponseStreamEvent as RawResponseStreamEvent,
 )
 from ..._parsing._responses import TextFormatT, parse_text, parse_response
@@ -419,9 +418,8 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # still run its text_format / parsed_arguments logic on them.
             #
             # `output` is typed as non-nullable but the wire value can violate
-            # that contract; cast to `Optional[List[...]]` at the boundary so
-            # both Pyright and Mypy accept the None check without weakening
-            # the model contract.
+            # that contract; the `pyright: ignore` on the None check makes the
+            # runtime guard explicit without weakening the model contract.
             #
             # In the default streaming path, SSE data is converted through
             # `construct_type(...)`.  For a `response.completed` payload whose
@@ -439,8 +437,13 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # `AttributeError` before the fallback can run.
             if not hasattr(response, "output"):
                 response = construct_type_unchecked(type_=Response, value=response)
-            output = cast(Optional[List[ResponseOutputItem]], response.output)
-            if output is None and snapshot.output:
+            # `output` is typed as non-nullable but the wire value can violate
+            # that contract (a `response.completed` payload can carry a null
+            # `response.output`).  Pyright flags the None check as unreachable
+            # because the model annotation says non-nullable, so suppress that
+            # specific diagnostic — the runtime guard is intentional.
+            output = response.output
+            if output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
                 # Build a copy of the response with the accumulated output
                 # items injected.  Use warnings=False on Pydantic v2 to suppress
                 # the serializer warning from dumping the invalid null output

From cf8f8473b3252e4c4d4c791639a04d3b0c3ec120 Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 14 Aug 2026 23:16:11 +0530
Subject: [PATCH 12/13] fix: use direct attribute check instead of local
 variable to satisfy Pyright

The pyright: ignore[reportUnnecessaryComparison] on the assignment line isn't
enough because Pyright first flags the assignment itself as incompatible types
(response.output is list[...], not Optional) before reaching the comparison.
Check response.output directly on the response object instead of assigning to
a local variable, then suppress the unreachable None comparison. This avoids
the type mismatch on assignment entirely.
---
 src/openai/lib/streaming/responses/_responses.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index f3d438a5a1..8b73ec6b4c 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -437,13 +437,15 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # `AttributeError` before the fallback can run.
             if not hasattr(response, "output"):
                 response = construct_type_unchecked(type_=Response, value=response)
-            # `output` is typed as non-nullable but the wire value can violate
-            # that contract (a `response.completed` payload can carry a null
-            # `response.output`).  Pyright flags the None check as unreachable
-            # because the model annotation says non-nullable, so suppress that
-            # specific diagnostic — the runtime guard is intentional.
-            output = response.output
-            if output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
+            # `response.output` is typed as non-nullable `list[...]` but the wire
+            # value can be `null` (a `response.completed` payload from the Codex
+            # backend can carry `response.output: null` even when valid
+            # `output_item.done` events were streamed earlier).  Pyright flags
+            # the None check as unreachable because the model annotation says
+            # non-nullable.  Check `.output` directly on the response without
+            # assigning to a local variable so Pyright sees the raw attribute
+            # type rather than narrowing via assignment.
+            if response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
                 # Build a copy of the response with the accumulated output
                 # items injected.  Use warnings=False on Pydantic v2 to suppress
                 # the serializer warning from dumping the invalid null output

From 942bd08535d8a2f1304b6db75cf60815577dc03b Mon Sep 17 00:00:00 2001
From: Shakti Prasad Mohapatra <rkfshakti@gmail.com>
Date: Fri, 14 Aug 2026 23:23:25 +0530
Subject: [PATCH 13/13] fix: use getattr to bypass pyright
 unreachable-comparison on nullable wire value

response.output is typed as non-nullable List[...] but the Codex backend
sends response.output: null in response.completed events.  Both
pyright: ignore[reportUnnecessaryComparison] and pyright: ignore[unreachable]
failed to work across pyright versions (1.1.399 local vs CI).  Using getattr
makes pyright see Any, avoiding the diagnostic entirely since the value comes
from the wire at runtime, not the model annotation.
---
 .../lib/streaming/responses/_responses.py      | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index 8b73ec6b4c..c5a6b74c37 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -437,15 +437,15 @@ def accumulate_event(self, event: RawResponseStreamEvent) -> ParsedResponseSnaps
             # `AttributeError` before the fallback can run.
             if not hasattr(response, "output"):
                 response = construct_type_unchecked(type_=Response, value=response)
-            # `response.output` is typed as non-nullable `list[...]` but the wire
-            # value can be `null` (a `response.completed` payload from the Codex
-            # backend can carry `response.output: null` even when valid
-            # `output_item.done` events were streamed earlier).  Pyright flags
-            # the None check as unreachable because the model annotation says
-            # non-nullable.  Check `.output` directly on the response without
-            # assigning to a local variable so Pyright sees the raw attribute
-            # type rather than narrowing via assignment.
-            if response.output is None and snapshot.output:  # pyright: ignore[reportUnnecessaryComparison]
+            # `response.output` is typed as non-nullable but the wire value can
+            # be `null` (the Codex backend sends `response.output: null` in the
+            # consolidated `response.completed` event even when valid
+            # `output_item.done` events were streamed earlier).  Use `getattr`
+            # so Pyright sees `Any` instead of the non-nullable list type,
+            # avoiding the unreachable-comparison diagnostic entirely.  The
+            # actual value comes from the wire at runtime, not from the
+            # model annotation.
+            if getattr(response, "output", None) is None and snapshot.output:
                 # Build a copy of the response with the accumulated output
                 # items injected.  Use warnings=False on Pydantic v2 to suppress
                 # the serializer warning from dumping the invalid null output