diff --git a/litellm/llms/openai/responses/guardrail_translation/handler.py b/litellm/llms/openai/responses/guardrail_translation/handler.py index b0f79552bc5..ba9bd3274af 100644 --- a/litellm/llms/openai/responses/guardrail_translation/handler.py +++ b/litellm/llms/openai/responses/guardrail_translation/handler.py @@ -85,10 +85,17 @@ from litellm.types.llms.openai import ( from litellm.types.responses.main import ( GenericResponseOutputItem, OutputFunctionToolCall, + OutputReasoningText, OutputText, ) from litellm.types.utils import GenericGuardrailAPIInputs +# Content parts a guardrail inspects and may rewrite. Both carry ``text``. +# ``reasoning`` items type their parts as ``reasoning_text``; until that type +# existed they were emitted as ``output_text``, so checking ``OutputText`` +# alone would silently stop scanning reasoning content. +GUARDRAIL_TEXT_CONTENT_PARTS: Final = (OutputText, OutputReasoningText) + if TYPE_CHECKING: from fastapi import HTTPException @@ -1020,7 +1027,7 @@ class OpenAIResponsesHandler(BaseTranslation): if content: for content_item in content: # Check if it's an OutputText with text - if isinstance(content_item, OutputText): + if isinstance(content_item, GUARDRAIL_TEXT_CONTENT_PARTS): if content_item.text: return True elif isinstance(content_item, dict): @@ -1100,7 +1107,7 @@ class OpenAIResponsesHandler(BaseTranslation): # Iterate through content items (list of OutputText objects) for content_idx, content_item in enumerate(content): # Handle both OutputText objects and dicts - if isinstance(content_item, OutputText): + if isinstance(content_item, GUARDRAIL_TEXT_CONTENT_PARTS): text_content = content_item.text elif isinstance(content_item, dict): text_content = content_item.get("text") @@ -1144,7 +1151,7 @@ class OpenAIResponsesHandler(BaseTranslation): if isinstance(output_item, GenericResponseOutputItem): if output_item.content and content_idx < len(output_item.content): content_item = output_item.content[content_idx] - if isinstance(content_item, OutputText): + if isinstance(content_item, GUARDRAIL_TEXT_CONTENT_PARTS): content_item.text = guardrail_response elif isinstance(content_item, dict): content_item["text"] = guardrail_response @@ -1154,7 +1161,7 @@ class OpenAIResponsesHandler(BaseTranslation): generic_item = GenericResponseOutputItem.model_validate(output_item.model_dump()) if generic_item.content and content_idx < len(generic_item.content): content_item = generic_item.content[content_idx] - if isinstance(content_item, OutputText): + if isinstance(content_item, GUARDRAIL_TEXT_CONTENT_PARTS): content_item.text = guardrail_response # Update the original response output if hasattr(output_item, "content") and output_item.content: diff --git a/litellm/types/responses/main.py b/litellm/types/responses/main.py index 35413b7dbe7..1abe5ccf162 100644 --- a/litellm/types/responses/main.py +++ b/litellm/types/responses/main.py @@ -1,3 +1,7 @@ +# `Union` is no longer referenced in this module, but +# `litellm/llms/base_llm/image_edit/transformation.py` does +# `from litellm.types.responses.main import *` and annotates with it, so +# dropping it here breaks that import at class-definition time. from typing import Final, Literal, Optional, Union from openai.types.responses.response_function_tool_call import ResponseFunctionToolCall @@ -124,9 +128,7 @@ class GenericResponseOutputItem(BaseLiteLLMOpenAIResponseObject): id: str status: str # "completed", "in_progress", etc. role: str # "assistant", "user", etc. - # `reasoning` items carry `reasoning_text` parts; `message` items carry - # `output_text` ones. - content: list[Union[OutputText, OutputReasoningText]] + content: list[OutputText | OutputReasoningText] phase: Phase = None diff --git a/tests/test_litellm/llms/openai/responses/guardrail_translation/test_reasoning_text_guardrails.py b/tests/test_litellm/llms/openai/responses/guardrail_translation/test_reasoning_text_guardrails.py new file mode 100644 index 00000000000..d0063f43411 --- /dev/null +++ b/tests/test_litellm/llms/openai/responses/guardrail_translation/test_reasoning_text_guardrails.py @@ -0,0 +1,70 @@ +"""Reasoning content parts must stay visible to output guardrails. + +Before `reasoning_text` existed, a reasoning item's parts were emitted as +`output_text`, so the guardrail handler's `isinstance(..., OutputText)` checks +saw them. Introducing `OutputReasoningText` would have silently removed +reasoning text from guardrail inspection and rewriting, which fails open: the +guardrail keeps reporting success while no longer reading the content. +""" + +from litellm.llms.openai.responses.guardrail_translation.handler import ( + GUARDRAIL_TEXT_CONTENT_PARTS, + OpenAIResponsesHandler, +) +from litellm.types.responses.main import ( + GenericResponseOutputItem, + OutputReasoningText, + OutputText, +) + + +def _reasoning_item(text: str) -> GenericResponseOutputItem: + return GenericResponseOutputItem( + type="reasoning", + id="rs_1", + status="completed", + role="assistant", + content=[OutputReasoningText(type="reasoning_text", text=text)], + ) + + +def _message_item(text: str) -> GenericResponseOutputItem: + return GenericResponseOutputItem( + type="message", + id="msg_1", + status="completed", + role="assistant", + content=[OutputText(type="output_text", text=text, annotations=None)], + ) + + +def test_both_content_part_types_are_inspected(): + assert OutputText in GUARDRAIL_TEXT_CONTENT_PARTS + assert OutputReasoningText in GUARDRAIL_TEXT_CONTENT_PARTS + + +def test_reasoning_text_is_extracted_for_checking(): + handler = OpenAIResponsesHandler() + texts: list[str] = [] + images: list[str] = [] + mappings: list[tuple[int, int]] = [] + + handler._extract_output_text_and_images( + _reasoning_item("secret chain of thought"), 0, texts, images, mappings + ) + + assert texts == ["secret chain of thought"] + assert mappings == [(0, 0)] + + +def test_message_text_is_still_extracted(): + handler = OpenAIResponsesHandler() + texts: list[str] = [] + images: list[str] = [] + mappings: list[tuple[int, int]] = [] + + handler._extract_output_text_and_images( + _message_item("the answer"), 0, texts, images, mappings + ) + + assert texts == ["the answer"]