diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py index 98322aecf6a..da56470fc89 100644 --- a/litellm/completion_extras/litellm_responses_transformation/transformation.py +++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py @@ -490,9 +490,10 @@ def _fold_choices_into_one( choices: Sequence["Choices"], tool_calls: Sequence[Mapping[str, object]], trailing_reasoning_content: str | None, - trailing_reasoning_item: _BuiltReasoningItem | None, - tool_search_items: Sequence[Mapping[str, object]], + trailing_reasoning_item: _BuiltReasoningItem | None = None, + tool_search_items: Sequence[Mapping[str, object]] = (), structured_output: bool = False, + trailing_reasoning_items: Sequence[_BuiltReasoningItem] = (), ) -> "Choices": """Clients that only read choices[0] must still see every text and tool call. @@ -507,9 +508,13 @@ def _fold_choices_into_one( offsets: Final = (0, *accumulate(len(text) for text in texts)) annotations: Final = tuple(_shifted_annotations(content_messages, offsets)) reasoning_contents: Final = (*(_message_reasoning_content(m) for m in messages), trailing_reasoning_content) + accumulated_trailing_items: Final = ( + *trailing_reasoning_items, + *(() if trailing_reasoning_item is None else (trailing_reasoning_item,)), + ) reasoning_items: Final = ( *chain.from_iterable(_message_reasoning_items(m) for m in messages), - *(() if trailing_reasoning_item is None else (trailing_reasoning_item,)), + *accumulated_trailing_items, ) return Choices( message=Message( @@ -526,6 +531,24 @@ def _fold_choices_into_one( ) +def _append_reasoning_if_present( + item: object, + pending: list[_BuiltReasoningItem], # mutable-ok: accumulator + current_content: str | None, +) -> tuple[bool, str | None]: + """Extract reasoning item if present, append to pending, and update concatenated summary.""" + reasoning_item: Final = _reasoning_item_from_output_item(item) + if reasoning_item is None: + return False, current_content + pending.append(reasoning_item) + summary_texts: Final = [s["text"] for s in reasoning_item["summary"] if s.get("text")] + if not summary_texts: + return True, current_content + step_text: Final = " ".join(summary_texts) + merged_content: Final = f"{current_content} {step_text}".strip() if current_content else step_text + return True, merged_content + + def _responses_event_type(chunk: Mapping[str, object]) -> object: event_type: Final = chunk.get("type") return event_type.value if isinstance(event_type, ResponsesAPIStreamEvents) else event_type @@ -1181,7 +1204,6 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): from openai.types.responses import ( ResponseFunctionToolCall, ResponseOutputMessage, - ResponseReasoningItem, ) try: @@ -1196,7 +1218,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): choices: Final[list[Choices]] = [] index = 0 reasoning_content: str | None = None - pending_reasoning_item: _BuiltReasoningItem | None = None + pending_reasoning_items: Final[list[_BuiltReasoningItem]] = [] # mutable-ok: accumulator # Collect all tool calls to put them in a single choice # (Chat Completions API expects all tool calls in one message) @@ -1204,13 +1226,11 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): tool_call_index = 0 for item in output_items: - if isinstance(item, ResponseReasoningItem): - pending_reasoning_item = _build_reasoning_item( - item_id=item.id, - encrypted_content=getattr(item, "encrypted_content", None), - summary_raw=item.summary, - ) - reasoning_content = " ".join(s["text"] for s in pending_reasoning_item["summary"] if s.get("text")) + is_reasoning, reasoning_content = _append_reasoning_if_present( + item, pending_reasoning_items, reasoning_content + ) + if is_reasoning: + continue elif isinstance(item, ResponseOutputMessage): for content in item.content: @@ -1225,10 +1245,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): content=response_text if response_text else "", reasoning_content=reasoning_content, annotations=annotations, - reasoning_items=cast( - list[ChatCompletionReasoningItem] | None, - ([pending_reasoning_item] if pending_reasoning_item is not None else None), - ), + reasoning_items=_as_chat_reasoning_items(pending_reasoning_items), ) choices.append( @@ -1240,7 +1257,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): ) reasoning_content = None # flush - pending_reasoning_item = None # flush + pending_reasoning_items.clear() # flush index += 1 elif isinstance(item, ResponseFunctionToolCall): @@ -1305,7 +1322,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): choices=choices, tool_calls=accumulated_tool_calls, trailing_reasoning_content=reasoning_content, - trailing_reasoning_item=pending_reasoning_item, + trailing_reasoning_items=pending_reasoning_items, tool_search_items=tool_search_items, structured_output=structured_output, ) diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py index 9aa494c1aab..07a5cb2cef0 100644 --- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py +++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py @@ -6060,3 +6060,132 @@ def test_stream_structured_output_drops_text_after_first_message_item( content: Final = "".join(chunk.choices[0].delta.content or "" for chunk in chunks) assert content == expected_content assert chunks[-1].choices[0].finish_reason == "stop" + + +@pytest.mark.parametrize( + "raw_output_items, expected_reasoning_ids, expected_summary_text, target_type", + [ + pytest.param( + [ + { + "type": "reasoning", + "id": "rs_1", + "summary": [{"type": "summary_text", "text": "Step 1"}], + "encrypted_content": "enc1", + }, + { + "type": "reasoning", + "id": "rs_2", + "summary": [{"type": "summary_text", "text": "Step 2"}], + "encrypted_content": "enc2", + }, + { + "type": "function_call", + "id": "fc_1", + "call_id": "call_1", + "name": "search", + "arguments": "{}", + "status": "completed", + }, + ], + ["rs_1", "rs_2"], + "Step 1 Step 2", + "tool_calls", + id="multiple_reasoning_items_before_tool_call", + ), + pytest.param( + [ + { + "type": "reasoning", + "id": "rs_alpha", + "summary": [{"type": "summary_text", "text": "Analysis"}], + "encrypted_content": "enc_a", + }, + { + "type": "reasoning", + "id": "rs_beta", + "summary": [{"type": "summary_text", "text": "Conclusion"}], + "encrypted_content": "enc_b", + }, + ], + ["rs_alpha", "rs_beta"], + "Analysis Conclusion", + "message", + id="multiple_reasoning_items_before_output_message", + ), + pytest.param( + [ + { + "type": "reasoning", + "id": "rs_raw_1", + "summary": [{"type": "summary_text", "text": "Raw Step 1"}], + "encrypted_content": "enc_raw", + }, + { + "type": "message", + "role": "assistant", + "content": [{"type": "output_text", "text": "Raw response text"}], + }, + ], + ["rs_raw_1"], + "Raw Step 1", + "raw_dict_message", + id="reasoning_items_before_raw_dict_message", + ), + pytest.param( + [ + { + "type": "function_call", + "id": "fc_solo", + "call_id": "call_solo", + "name": "lookup", + "arguments": "{}", + "status": "completed", + } + ], + None, + None, + "tool_calls", + id="zero_reasoning_items_returns_none", + ), + ], +) +def test_convert_response_output_to_choices_preserves_all_reasoning_items( + raw_output_items: list[dict[str, object]], + expected_reasoning_ids: list[str] | None, + expected_summary_text: str | None, + target_type: str, +) -> None: + """Verify non-streaming Responses API bridge retains all reasoning items across message and tool call turns.""" + from openai.types.responses import ResponseOutputMessage + from openai.types.responses.response_output_message import ResponseOutputText + + items_to_pass: Final[list[object]] = list(raw_output_items) # mutable-ok: fixture setup + if target_type == "message": + items_to_pass.append( + ResponseOutputMessage( + id="msg_1", + role="assistant", + status="completed", + type="message", + content=[ResponseOutputText(annotations=[], text="Done", type="output_text", logprobs=[])], + ) + ) + + handler: Final = LiteLLMResponsesTransformationHandler() + choices: Final = handler._convert_response_output_to_choices( + items_to_pass, + handle_raw_dict_callback=handler._handle_raw_dict_response_item, + ) + + assert len(choices) == 1 + msg = choices[0].message + reasoning_items = getattr(msg, "reasoning_items", None) + reasoning_content = getattr(msg, "reasoning_content", None) + if expected_reasoning_ids is None: + assert reasoning_items is None + assert reasoning_content is None + else: + assert reasoning_items is not None + assert [item["id"] for item in reasoning_items] == expected_reasoning_ids + assert reasoning_content == expected_summary_text