diff --git a/litellm/litellm_core_utils/exception_mapping_utils.py b/litellm/litellm_core_utils/exception_mapping_utils.py index 0ba466ec324..b875f7c09a6 100644 --- a/litellm/litellm_core_utils/exception_mapping_utils.py +++ b/litellm/litellm_core_utils/exception_mapping_utils.py @@ -7,6 +7,7 @@ from types import MappingProxyType from typing import Final, Protocol, cast import httpx +from pydantic import TypeAdapter, ValidationError import litellm from litellm._logging import _ENABLE_SECRET_REDACTION, redact_string, verbose_logger @@ -256,6 +257,23 @@ class _ProviderHTTPException(Protocol): llm_provider: str +_ERROR_BODY_ADAPTER: Final = TypeAdapter(dict[str, object]) + + +def _openai_cyber_policy_body(original_exception: _ProviderHTTPException) -> Mapping[str, object] | None: + raw_body: Final[object] = getattr(original_exception, "body", None) + try: + body: Final = ( + _ERROR_BODY_ADAPTER.validate_python(raw_body) + if raw_body is not None + else _ERROR_BODY_ADAPTER.validate_json(getattr(original_exception, "message", "")) + ) + error: Final = _ERROR_BODY_ADAPTER.validate_python(body.get("error", body)) + except ValidationError: + return None + return error if error.get("code") == "cyber_policy" else None + + def _litellm_proxy_response( original_exception: _ProviderHTTPException, custom_llm_provider: str ) -> httpx.Response | None: @@ -284,6 +302,15 @@ def _map_openai_exception( extra_information: str, ) -> None: response: Final = _litellm_proxy_response(original_exception, custom_llm_provider) + if (cyber_policy_body := _openai_cyber_policy_body(original_exception)) is not None: + raise ContentPolicyViolationError( + message=f"ContentPolicyViolationError: {exception_provider} - {original_exception}", + llm_provider=custom_llm_provider, + model=model, + response=response, + litellm_debug_info=extra_information, + body=dict(cyber_policy_body), + ) # custom_llm_provider is openai, make it OpenAI message = get_error_message(error_obj=original_exception) if message is None: diff --git a/litellm/responses/streaming_iterator.py b/litellm/responses/streaming_iterator.py index 32a4f4284be..00688782d2a 100644 --- a/litellm/responses/streaming_iterator.py +++ b/litellm/responses/streaming_iterator.py @@ -216,6 +216,7 @@ _ERROR_CODE_HTTP_STATUS: Final[Mapping[str, int]] = MappingProxyType( "invalid_request_error": 400, "context_length_exceeded": 400, "content_policy_violation": 400, + "cyber_policy": 400, "model_not_found": 400, } ) diff --git a/tests/unit/litellm_core_utils/test_exception_mapping_utils.py b/tests/unit/litellm_core_utils/test_exception_mapping_utils.py index 1bae82014cf..fa8b437a64b 100644 --- a/tests/unit/litellm_core_utils/test_exception_mapping_utils.py +++ b/tests/unit/litellm_core_utils/test_exception_mapping_utils.py @@ -1,12 +1,17 @@ +import json +import traceback from collections.abc import Awaitable, Callable -from typing import Final, Literal +from typing import Any, Final, Literal, Optional, Union +from unittest.mock import MagicMock, patch import httpx import openai import pytest from fastapi import HTTPException +from openai import AsyncOpenAI, OpenAI import litellm +from litellm import completion from litellm.exceptions import GuardrailRaisedException from litellm.litellm_core_utils.exception_mapping_utils import ( ExceptionCheckers, @@ -19,13 +24,38 @@ from litellm.llms.bedrock.common_utils import BedrockError from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler from litellm.llms.openai.common_utils import OpenAIError from litellm.types.utils import LlmProviders -import traceback -from typing import Any -from unittest.mock import MagicMock, patch -from openai import AsyncOpenAI -from litellm import completion -from openai import OpenAI -from typing import Optional, Union + + +@pytest.mark.parametrize("shape", ["sdk", "http"]) +@pytest.mark.parametrize("code", ["cyber_policy", "invalid_prompt"]) +def test_openai_cyber_policy_uses_the_structured_error_code(shape: str, code: str) -> None: + body: Final = {"code": code, "message": "Request mentions cyber_policy", "type": "invalid_request_error"} + request: Final = httpx.Request("POST", "https://provider.example/v1/responses") + response: Final = httpx.Response(400, request=request, headers={"x-request-id": "cyber-policy-request"}) + original: Final = OpenAIError( + status_code=400, + message=json.dumps({"error": body}), + request=request, + response=response, + body=body if shape == "sdk" else None, + ) + with pytest.raises(litellm.BadRequestError) as caught: + exception_type( + model="gpt-6-astra", + original_exception=original, + custom_llm_provider="openai", + completion_kwargs={}, + extra_kwargs={}, + ) + assert isinstance(caught.value, litellm.ContentPolicyViolationError) == (code == "cyber_policy") + if code == "cyber_policy": + assert caught.value.code == code + assert caught.value.body == body + assert caught.value.status_code == 400 + assert caught.value.response is response + assert caught.value.request is request + assert caught.value.response.headers["x-request-id"] == "cyber-policy-request" + # Test cases for is_error_str_context_window_exceeded # Tuple format: (error_message, expected_result) @@ -1629,9 +1659,7 @@ def test_guardrail_block_raised_inside_an_llm_call_is_returned_unmapped(block: E "failure", [ImportError("Run 'pip install boto3'."), ModuleNotFoundError(name="unrelated_dependency")] ) def test_bedrock_import_errors_preserve_the_original_exception(provider, failure): - assert exception_type( - model="test-model", original_exception=failure, custom_llm_provider=provider - ) is failure + assert exception_type(model="test-model", original_exception=failure, custom_llm_provider=provider) is failure def test_guardrail_provider_failure_status_is_still_mapped(): @@ -2000,11 +2028,7 @@ def test_exception_mapping(provider): except Exception as e: traceback.print_exc() response = "{}".format(str(e)) - pytest.fail( - "Did not raise expected exception. Expected={}, Return={},".format( - expected_exception, response - ) - ) + pytest.fail("Did not raise expected exception. Expected={}, Return={},".format(expected_exception, response)) pass @@ -2088,9 +2112,7 @@ def test_fireworks_ai_exception_mapping(): ] for error_str in rate_limit_strings: - assert ExceptionCheckers.is_error_str_rate_limit( - error_str - ), f"Should detect rate limit in: {error_str}" + assert ExceptionCheckers.is_error_str_rate_limit(error_str), f"Should detect rate limit in: {error_str}" # Test cases that should return False (not rate limit) non_rate_limit_strings = [ @@ -2104,9 +2126,7 @@ def test_fireworks_ai_exception_mapping(): ] for error_str in non_rate_limit_strings: - assert not ExceptionCheckers.is_error_str_rate_limit( - error_str - ), f"Should NOT detect rate limit in: {error_str}" + assert not ExceptionCheckers.is_error_str_rate_limit(error_str), f"Should NOT detect rate limit in: {error_str}" # Test edge cases assert not ExceptionCheckers.is_error_str_rate_limit(None) # type: ignore @@ -2203,9 +2223,7 @@ async def test_exception_with_headers( ) @pytest.mark.usefixtures("fake_provider_credentials") @pytest.mark.asyncio -async def test_exception_with_headers_httpx( - sync_mode, provider, model, call_type, streaming -): +async def test_exception_with_headers_httpx(sync_mode, provider, model, call_type, streaming): """ User feedback: litellm says "No deployments available for selected model, Try again in 60 seconds" but Azure says to retry in at most 9s @@ -2268,9 +2286,7 @@ async def test_exception_with_headers_httpx( ): new_retry_after_mock_client = MagicMock(return_value=-1) - litellm.utils._get_retry_after_from_exception_header = ( - new_retry_after_mock_client - ) + litellm.utils._get_retry_after_from_exception_header = new_retry_after_mock_client async def call_and_drain(): if sync_mode: @@ -2288,9 +2304,7 @@ async def test_exception_with_headers_httpx( with pytest.raises(litellm.RateLimitError) as exc_info: await call_and_drain() - assert ( - exc_info.value.litellm_response_headers is not None - ), "litellm_response_headers is None" + assert exc_info.value.litellm_response_headers is not None, "litellm_response_headers is None" print("e.litellm_response_headers", exc_info.value.litellm_response_headers) assert int(exc_info.value.litellm_response_headers["retry-after"]) == cooldown_time @@ -2390,9 +2404,7 @@ def _pre_call_utils_httpx( @pytest.mark.parametrize("dependency", ["boto3", "botocore"]) def test_missing_aws_dependency_is_not_mapped_to_provider_failure(provider, dependency): failure = ModuleNotFoundError(f"No module named '{dependency}'", name=dependency) - assert exception_type( - model="test-model", original_exception=failure, custom_llm_provider=provider - ) is failure + assert exception_type(model="test-model", original_exception=failure, custom_llm_provider=provider) is failure @pytest.mark.parametrize("failure", [ImportError("broken import"), ModuleNotFoundError(name="unrelated_dependency")]) diff --git a/tests/unit/responses/test_streaming_iterator_error_events.py b/tests/unit/responses/test_streaming_iterator_error_events.py index 2286aadc894..a29b9877c0d 100644 --- a/tests/unit/responses/test_streaming_iterator_error_events.py +++ b/tests/unit/responses/test_streaming_iterator_error_events.py @@ -25,7 +25,6 @@ from unittest.mock import Mock, patch import pytest - import litellm from litellm.exceptions import MidStreamFallbackError from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj @@ -163,6 +162,7 @@ def test_maybe_raise_for_response_failed_event_wraps_content_policy_violation(): "error_type,error_code,expected_exception", [ ("invalid_request_error", "content_policy_violation", litellm.ContentPolicyViolationError), + ("invalid_request_error", "cyber_policy", litellm.ContentPolicyViolationError), ("tokens", "rate_limit_exceeded", litellm.RateLimitError), ("invalid_request_error", "insufficient_quota", litellm.RateLimitError), ("server_error", "internal_error", litellm.InternalServerError), @@ -354,20 +354,22 @@ def test_response_failed_numeric_code_maps_to_its_http_status(code: int | str): assert isinstance(exc_info.value.original_exception, litellm.RateLimitError) -def test_response_failed_unknown_code_keeps_upstream_code_and_message_on_mapped_exception(): +@pytest.mark.parametrize("code", ["cyber_policy", "unrecognized_failure"]) +def test_response_failed_keeps_upstream_code_and_uses_content_policy_fallback_for_cyber_policy(code: str): iterator = _make_iterator() upstream_message = "This content was flagged for possible cybersecurity risk." mock_response_obj = Mock() - mock_response_obj.error = {"code": "cyber_policy", "message": upstream_message} + mock_response_obj.error = {"code": code, "message": upstream_message} chunk = Mock() chunk.type = "response.failed" chunk.response = mock_response_obj with pytest.raises(MidStreamFallbackError) as exc_info: iterator._maybe_raise_for_error_event(chunk) mapped = exc_info.value.original_exception - assert isinstance(mapped, litellm.InternalServerError) - assert mapped.code == "cyber_policy" - assert mapped.body == {"message": upstream_message, "type": None, "code": "cyber_policy"} + expected = litellm.ContentPolicyViolationError if code == "cyber_policy" else litellm.InternalServerError + assert isinstance(mapped, expected) + assert mapped.code == code + assert mapped.body == {"message": upstream_message, "type": None, "code": code} def test_maybe_raise_for_error_event_null_error_obj():