From 161fb93f99f73baa668e711ca64d1b26599b85b0 Mon Sep 17 00:00:00 2001 From: Kaustubh Anil Jain <78426775+kaust1495@users.noreply.github.com> Date: Wed, 7 Oct 2026 03:30:11 +0530 Subject: [PATCH 1/3] fix(responses): serialize sequence_number on every bridged streaming event --- .../streaming_iterator.py | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/litellm/responses/litellm_completion_transformation/streaming_iterator.py b/litellm/responses/litellm_completion_transformation/streaming_iterator.py index e21f706ba60..749f29a1145 100644 --- a/litellm/responses/litellm_completion_transformation/streaming_iterator.py +++ b/litellm/responses/litellm_completion_transformation/streaming_iterator.py @@ -132,6 +132,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): self._next_tool_output_index: int = 1 # output_index=0 reserved for the message item self._final_tool_events_queued: bool = False self._sequence_number: int = 0 + self._emitted_sequence_number: int = 0 self._cached_reasoning_item_id: str | None = None self._sent_reasoning_summary_text_done_event: bool = False self._sent_reasoning_summary_part_done_event: bool = False @@ -975,8 +976,25 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): self._queue_message_item_added_events() return + def _stamp_sequence_number(self, event: Any) -> Any: + """ + Give every emitted event a serialized, strictly increasing sequence_number. + + Writing to ``event.__dict__`` skips pydantic's extra-field storage, so those + values never reach ``model_dump()``/``model_dump_json()``. Setting the + attribute stores it correctly (declared field or allowed extra). + """ + self._emitted_sequence_number += 1 + event.sequence_number = self._emitted_sequence_number + return event + async def __anext__( self, + ) -> ResponsesAPIStreamingResponse | ResponseCompletedEvent | BaseLiteLLMOpenAIResponseObject: + return self._stamp_sequence_number(await self._anext_event()) + + async def _anext_event( + self, ) -> ResponsesAPIStreamingResponse | ResponseCompletedEvent | BaseLiteLLMOpenAIResponseObject: try: while True: @@ -1087,6 +1105,11 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): def __next__( self, + ) -> ResponsesAPIStreamingResponse | ResponseCompletedEvent | BaseLiteLLMOpenAIResponseObject: + return self._stamp_sequence_number(self._next_event()) + + def _next_event( + self, ) -> ResponsesAPIStreamingResponse | ResponseCompletedEvent | BaseLiteLLMOpenAIResponseObject: try: while True: From e13fb713f780f17a16ed91e1e3be86a3b00fe067 Mon Sep 17 00:00:00 2001 From: Kaustubh Anil Jain <78426775+kaust1495@users.noreply.github.com> Date: Wed, 7 Oct 2026 03:30:35 +0530 Subject: [PATCH 2/3] test(responses): cover sequence_number on bridged streaming events --- .../test_streaming_iterator_transformation.py | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py index 041bcf1b6d7..88a3d450273 100644 --- a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py +++ b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py @@ -1171,3 +1171,75 @@ async def test_plain_text_stream_announces_exactly_one_message_item(sync_mode: b ResponsesAPIStreamEvents.OUTPUT_TEXT_DONE, ): assert event.item_id == message_item_adds[0].item.id + + +def _serialized_sequence_numbers(events) -> list[int]: + payloads = [json.loads(event.model_dump_json()) for event in events] + assert all("sequence_number" in payload for payload in payloads), [ + payload["type"] for payload in payloads if "sequence_number" not in payload + ] + return [payload["sequence_number"] for payload in payloads] + + +def _assert_consecutive(sequence_numbers: list[int]) -> None: + assert sequence_numbers == list(range(sequence_numbers[0], sequence_numbers[0] + len(sequence_numbers))) + + +def test_sync_stream_events_serialize_increasing_sequence_numbers(): + """Every event, including output_item.done, serializes a strictly increasing sequence_number.""" + events = list(_build_iterator([_chunk("Hello"), _chunk("!", finish_reason="stop")])) + + sequence_numbers = _serialized_sequence_numbers(events) + _assert_consecutive(sequence_numbers) + done = [e for e in events if getattr(e, "type", None) == ResponsesAPIStreamEvents.OUTPUT_ITEM_DONE] + assert len(done) == 1 + assert json.loads(done[0].model_dump_json())["sequence_number"] > 1 + + +@pytest.mark.asyncio +async def test_async_stream_events_serialize_increasing_sequence_numbers(): + events = [event async for event in _build_iterator([_chunk("Hello"), _chunk("!", finish_reason="stop")])] + + _assert_consecutive(_serialized_sequence_numbers(events)) + + +def test_long_stream_sequence_numbers_stay_unique_and_ordered(): + """Stress: many chunks never produce duplicate or out-of-order sequence numbers.""" + chunks = [_chunk(f"word{i} ") for i in range(300)] + [_chunk("end", finish_reason="stop")] + events = list(_build_iterator(chunks)) + + sequence_numbers = _serialized_sequence_numbers(events) + assert len(events) > 300 + _assert_consecutive(sequence_numbers) + assert len(set(sequence_numbers)) == len(sequence_numbers) + + +def test_tool_call_stream_sequence_numbers_are_serialized_and_increasing(): + chunk = ModelResponseStream( + id="chunk-1", + created=123, + model="test-model", + object="chat.completion.chunk", + choices=[ + StreamingChoices( + finish_reason=None, + index=0, + delta=Delta( + role="assistant", + content="", + tool_calls=[ + { + "id": "call_1", + "type": "function", + "function": {"name": "do_thing", "arguments": '{"x": "' + "a" * 55 + '"}'}, + } + ], + ), + ) + ], + ) + events = list(_build_iterator([chunk, _chunk("", finish_reason="tool_calls")])) + + sequence_numbers = _serialized_sequence_numbers(events) + _assert_consecutive(sequence_numbers) + assert any(e.type == ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DELTA for e in events) From 1ecde9e12576600c529e0f73d7f47d41e20d7958 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Fri, 30 Oct 2026 11:20:56 -0700 Subject: [PATCH 3/3] fix(responses): read undeclared fields through dict accessors and number guardrail block continuations --- .../guardrail_translation/handler.py | 6 +++- .../streaming_iterator.py | 3 -- litellm/types/llms/base.py | 8 ++--- ...test_openai_responses_guardrail_handler.py | 28 ++++++++++++++++++ .../test_streaming_iterator_transformation.py | 9 ++++++ tests/unit/types/llms/test_types_llms_base.py | 29 ++++++++++++++++++- 6 files changed, 74 insertions(+), 9 deletions(-) diff --git a/litellm/llms/openai/responses/guardrail_translation/handler.py b/litellm/llms/openai/responses/guardrail_translation/handler.py index 559daf767c2..64aca9496eb 100644 --- a/litellm/llms/openai/responses/guardrail_translation/handler.py +++ b/litellm/llms/openai/responses/guardrail_translation/handler.py @@ -1974,7 +1974,7 @@ class OpenAIResponsesHandler(BaseTranslation): "annotations": (), "logprobs": None, } - return ( + events: Final = ( *_open_item_closing_events(responses_so_far), OutputItemAddedEvent( type=ResponsesAPIStreamEvents.OUTPUT_ITEM_ADDED, @@ -2019,6 +2019,10 @@ class OpenAIResponsesHandler(BaseTranslation): response=_blocked_response(exc, response_id=response_id, model=model, output_item=item), ), ) + return tuple( + event.model_copy(update={"sequence_number": number}) + for number, event in enumerate(events, start=_next_stream_sequence_number(responses_so_far)) + ) class _BlockedContentPart(TypedDict): diff --git a/litellm/responses/litellm_completion_transformation/streaming_iterator.py b/litellm/responses/litellm_completion_transformation/streaming_iterator.py index 221aac17264..ae58fb0ce79 100644 --- a/litellm/responses/litellm_completion_transformation/streaming_iterator.py +++ b/litellm/responses/litellm_completion_transformation/streaming_iterator.py @@ -849,7 +849,6 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): "type": "response.reasoning_summary_text.done", "item_id": "rs_0c5dae30e53172980069708ba2f59c8197b71ca9820edad07c", "output_index": 0, - "sequence_number": 97, "summary_index": 0, "text": "**Clarifying the first humans**\n\nThe I'm addressing the user's specific interest." } @@ -880,7 +879,6 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): "type": "summary_text", "text": "**Clarifying the first humans**\n\nThe earlier hominins. It feels important to ensure I'm addressing the user's specific interest." }, - "sequence_number": 98, "summary_index": 0 } """ @@ -981,7 +979,6 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator): { "type": "response.output_item.done", "output_index": 0, - "sequence_number": 99, "item": { "id": "rs_0c5dae30e53172980069708ba2f59c8197b71ca9820edad07c", "type": "reasoning", diff --git a/litellm/types/llms/base.py b/litellm/types/llms/base.py index 5a2da071cec..37937892e84 100644 --- a/litellm/types/llms/base.py +++ b/litellm/types/llms/base.py @@ -32,16 +32,16 @@ class BaseLiteLLMOpenAIResponseObject(LiteLLMBaseModel): model_config = ConfigDict(extra="allow", protected_namespaces=()) def __getitem__(self, key): - return self.__dict__[key] + return dict(iter(self))[key] def get(self, key, default=None): - return self.__dict__.get(key, default) + return dict(iter(self)).get(key, default) def __contains__(self, key) -> bool: - return key in self.__dict__ + return key in dict(iter(self)) def items(self): - return self.__dict__.items() + return dict(iter(self)).items() class HiddenParams(OpenAIObject): diff --git a/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py b/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py index 673e880a1c0..8a7bd3b1d3f 100644 --- a/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py +++ b/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py @@ -4509,6 +4509,34 @@ class TestBuildBlockSseChunks: assert completed["output"][0]["content"][0]["text"] == "Blocked by policy." assert completed["usage"] == {"input_tokens": 7, "output_tokens": 21, "total_tokens": 28} + def test_continuation_numbers_every_event_after_the_last_one_relayed(self): + yielded = [ + {"type": "response.created", "sequence_number": 0, "response": {"id": "resp_live", "output": []}}, + { + "type": "response.output_item.added", + "sequence_number": 1, + "output_index": 0, + "item": {"id": "msg_orig", "type": "message", "role": "assistant"}, + }, + { + "type": "response.output_text.delta", + "sequence_number": 2, + "item_id": "msg_orig", + "output_index": 0, + "content_index": 0, + "delta": "partial", + }, + ] + + payloads = self._payloads( + OpenAIResponsesHandler().build_block_sse_chunks( + self._exc(original_response=yielded), stream_started=True, responses_so_far=yielded + ) + ) + + assert payloads[-1]["type"] == "response.completed" + assert [payload.get("sequence_number") for payload in payloads] == list(range(3, 3 + len(payloads))) + def test_continuation_reads_usage_from_typed_completed_event(self): from litellm.types.llms.openai import ( ResponseCompletedEvent, diff --git a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py index c92c1ec4ee1..9c9b3fc4809 100644 --- a/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py +++ b/tests/unit/responses/litellm_completion_transformation/test_streaming_iterator_transformation.py @@ -2019,3 +2019,12 @@ async def test_every_event_serializes_its_position_in_the_stream_from_zero(strea events: Final = list(iterator) if sync_mode else [event async for event in iterator] assert _serialized_sequence_numbers(events) == list(range(len(events))) + + +def test_bridged_events_answer_dict_reads_of_their_number(): + events: Final = list(_build_iterator((_chunk("Hello"), _chunk("!", finish_reason="stop")))) + positions: Final = list(range(len(events))) + + assert [event["sequence_number"] for event in events] == positions + assert [event.get("sequence_number") for event in events] == positions + assert all("sequence_number" in event for event in events) diff --git a/tests/unit/types/llms/test_types_llms_base.py b/tests/unit/types/llms/test_types_llms_base.py index 964689cdeeb..07b641fb392 100644 --- a/tests/unit/types/llms/test_types_llms_base.py +++ b/tests/unit/types/llms/test_types_llms_base.py @@ -9,7 +9,7 @@ from typing import Final import pytest from pydantic import ConfigDict, create_model -from litellm.types.llms.base import LiteLLMBaseModel +from litellm.types.llms.base import BaseLiteLLMOpenAIResponseObject, LiteLLMBaseModel _PROBE: Final = """ from litellm.types.llms.base import LiteLLMBaseModel @@ -142,3 +142,30 @@ def test_concurrent_first_use_of_a_deferred_subclass_always_builds_that_subclass assert _concurrent_first_use_outcomes(child) == {child.__name__}, f"round {round_id}" finally: sys.setswitchinterval(previous_switch_interval) + + +class _ResponseEvent(BaseLiteLLMOpenAIResponseObject): + type: str + + +def test_response_object_answers_dict_reads_for_undeclared_fields(): + event: Final = _ResponseEvent(type="response.created", sequence_number=3) + + assert event["type"] == "response.created" + assert event["sequence_number"] == 3 + assert event.get("sequence_number") == 3 + assert "sequence_number" in event + assert dict(event.items()) == {"type": "response.created", "sequence_number": 3} + + +def test_response_object_answers_dict_reads_for_an_undeclared_field_named_keys(): + assert _ResponseEvent(type="response.created", keys="value")["keys"] == "value" + + +def test_response_object_dict_reads_still_miss_absent_keys(): + event: Final = _ResponseEvent(type="response.created") + + assert event.get("sequence_number", "fallback") == "fallback" + assert "sequence_number" not in event + with pytest.raises(KeyError): + event["sequence_number"]