From ebdeba2feef58bc00be5b2ea33278b2bab47a388 Mon Sep 17 00:00:00 2001 From: ai-jz <156989844+ai-jz@users.noreply.github.com> Date: Wed, 30 Sep 2026 20:15:24 -0700 Subject: [PATCH] [Fix] Emit Responses reasoning content-part events (#41789) Co-authored-by: ai-jz Co-authored-by: Yuwei An Co-authored-by: Xinyuan Tong Co-authored-by: Xinyuan Tong <115166877+JustinTong0323@users.noreply.github.com> --- .../entrypoints/openai/serving_responses.py | 33 ++++++ .../openai/test_serving_responses_stream.py | 100 ++++++++++++++++++ 2 files changed, 133 insertions(+) diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py index 66ee1c2a67..b4f467f867 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -21,6 +21,12 @@ from openai.types.responses import ( ResponseOutputText, ResponseReasoningItem, ) +from openai.types.responses.response_content_part_added_event import ( + PartReasoningText as ResponseReasoningTextAddedPart, +) +from openai.types.responses.response_content_part_done_event import ( + PartReasoningText as ResponseReasoningTextDonePart, +) from openai.types.responses.response_custom_tool_call import ResponseCustomToolCall from openai.types.responses.response_function_tool_call import ResponseFunctionToolCall from openai.types.responses.response_output_text import Logprob, LogprobTopLogprob @@ -2130,6 +2136,20 @@ class OpenAIServingResponses(OpenAIServingChat): ) ) ) + events.append( + _send_event( + openai_responses_types.ResponseContentPartDoneEvent( + type="response.content_part.done", + item_id=reasoning_state["item_id"], + sequence_number=-1, + output_index=reasoning_state["output_index"], + content_index=0, + part=ResponseReasoningTextDonePart( + type="reasoning_text", text=text + ), + ) + ) + ) events += [ _send_event( openai_responses_types.ResponseOutputItemDoneEvent( @@ -2367,6 +2387,19 @@ class OpenAIServingResponses(OpenAIServingChat): sequence_number=-1, ) ) + else: + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + item_id=item_id, + output_index=reasoning_state["output_index"], + content_index=0, + part=ResponseReasoningTextAddedPart( + type="reasoning_text", text="" + ), + sequence_number=-1, + ) + ) reasoning_state["text"] += reasoning_chunk if wants_summary: yield _send_event( diff --git a/test/registered/unit/entrypoints/openai/test_serving_responses_stream.py b/test/registered/unit/entrypoints/openai/test_serving_responses_stream.py index f2e30ff028..69912aa0f1 100644 --- a/test/registered/unit/entrypoints/openai/test_serving_responses_stream.py +++ b/test/registered/unit/entrypoints/openai/test_serving_responses_stream.py @@ -27,6 +27,106 @@ register_cpu_ci(est_time=10, suite="base-a-test-cpu") class NonHarmonyStreamTestCase(CustomTestCase): + def test_reasoning_content_part_lifecycle_matches_terminal_output(self): + for finish_reason, status, suffix in ( + ({"type": "stop"}, "completed", "answer"), + ({"type": "length"}, "incomplete", ""), + ( + {"type": "abort", "status_code": 503, "message": "Worker unavailable"}, + "failed", + "", + ), + ): + with self.subTest(status=status): + serving = make_serving() + serving.reasoning_parser = "deepseek-v41" + serving.tool_call_parser = None + request = ResponsesRequest( + model="x", input="hi", stream=True, store=False + ) + chunks = [engine_chunk("wo"), engine_chunk("work")] + terminal_chunk = engine_chunk("work" + suffix, 4, finish=True) + terminal_chunk["meta_info"]["finish_reason"] = finish_reason + chunks.append(terminal_chunk) + events = StreamFixture(serving, request, require_reasoning=True).run( + chunks + ) + payloads = event_payloads(events) + self.assertEqual(payloads[-1]["type"], f"response.{status}") + output = payloads[-1]["response"]["output"] + reasoning = output[0] + self.assertEqual(reasoning["type"], "reasoning") + item_events = [ + p for p in payloads if p.get("item_id") == reasoning["id"] + ] + types = [p["type"] for p in item_events] + self.assertEqual(types[0], "response.content_part.added") + self.assertEqual( + types[-2:], + ["response.reasoning_text.done", "response.content_part.done"], + ) + self.assertEqual(types.count("response.content_part.added"), 1) + self.assertEqual(types.count("response.content_part.done"), 1) + self.assertEqual( + item_events[0]["part"], {"type": "reasoning_text", "text": ""} + ) + self.assertEqual(item_events[-1]["part"], reasoning["content"][0]) + self.assertEqual(item_events[-2]["text"], "work") + self.assertEqual( + "".join( + p["delta"] + for p in item_events + if p["type"] == "response.reasoning_text.delta" + ), + "work", + ) + self.assertTrue( + all( + p["output_index"] == 0 and p["content_index"] == 0 + for p in item_events + ) + ) + done = [ + p["item"] + for p in payloads + if p["type"] == "response.output_item.done" + ] + self.assertEqual(done, output) + self.assertEqual( + [p["sequence_number"] for p in payloads], list(range(len(payloads))) + ) + + def test_reasoning_summary_keeps_its_own_part_events(self): + serving = make_serving() + serving.reasoning_parser = "deepseek-v41" + serving.tool_call_parser = None + request = ResponsesRequest( + model="x", + input="hi", + stream=True, + store=False, + reasoning={"summary": "auto"}, + ) + events = StreamFixture(serving, request, require_reasoning=True).run( + [engine_chunk("workanswer", 4, finish=True)] + ) + payloads = event_payloads(events) + reasoning = find_completed_event(events)["response"]["output"][0] + parts = [p for p in payloads if p.get("item_id") == reasoning["id"]] + self.assertEqual( + [p["type"] for p in parts], + [ + "response.reasoning_summary_part.added", + "response.reasoning_summary_text.delta", + "response.reasoning_summary_text.done", + "response.reasoning_summary_part.done", + ], + ) + self.assertEqual(parts[-1]["part"], reasoning["summary"][0]) + self.assertEqual( + reasoning["content"], [{"type": "reasoning_text", "text": "work"}] + ) + def test_reasoning_parser_uses_processed_reasoning_state(self): serving = make_serving() serving.reasoning_parser = "deepseek-r1"