fix(exception-mapping): update request_id fix for latest main

Rebase onto current main (60fc121c): resolve conflicts with upstream
changes since Oct 22, including the #47789 typing refactor (route the new
_validated_error_body helper through attribute_or_none) and the #47954,
#32537, #49079, #48616, #48837, #43290 exception-mapping changes. No
change to the #47839 fix itself or its tests; all 7 request_id tests pass
on the rebased tree.
This commit is contained in:
Zhong Zhiyi 2026-11-02 11:24:07 +08:00
parent 33fc58d7a0
commit 44bebe0687
2 changed files with 456 additions and 38 deletions

View file

@ -16,8 +16,10 @@ from litellm.litellm_core_utils.bug_report import (
build_bug_report,
should_report_bug,
)
from litellm.litellm_core_utils.core_helpers import as_str_mapping
from litellm.litellm_core_utils.core_helpers import as_str_mapping, attribute_or_none
from litellm.litellm_core_utils.secret_redaction import redact_string as redact_secret_string
from litellm.llms.bedrock.common_utils import bedrock_model_reaches_converse_by_default
from litellm.llms.bigmodel.common_utils import raise_bigmodel_business_error
from litellm.types.utils import LlmProviders
from ..exceptions import (
@ -36,6 +38,7 @@ from ..exceptions import (
ServiceUnavailableError,
Timeout,
UnprocessableEntityError,
error_response_without_credentials,
)
@ -95,6 +98,7 @@ class ExceptionCheckers:
known_exception_substrings: Final = [
"exceed context limit",
"this model's maximum context length is",
"requested token count exceeds the model's maximum context length",
"string too long. expected a string with maximum length",
"model's maximum context limit",
"is longer than the model's context length",
@ -102,6 +106,7 @@ class ExceptionCheckers:
"`inputs` tokens + `max_new_tokens` must be",
"exceeds the available context size", # llama.cpp/Lemonade
"exceeds the maximum number of tokens allowed", # Gemini
'"code": "context_length_exceeded"',
]
for substring in known_exception_substrings:
if substring in _error_str_lowercase:
@ -163,9 +168,6 @@ def get_error_message(error_obj) -> str | None:
}
"""
try:
if error_obj is None:
return None
extracted_message: Final = _extract_error_message(error_obj)
if extracted_message is None:
return None
@ -274,7 +276,7 @@ _ERROR_BODY_ADAPTER: Final = TypeAdapter(dict[str, object])
def _validated_error_body(error_obj: _ProviderHTTPException) -> Mapping[str, object] | None:
"""The exception's parsed error body as a dict, or None when it is not one."""
raw_body: Final = error_obj.body
raw_body: Final = attribute_or_none(error_obj, "body")
if raw_body is None:
return None
try:
@ -360,6 +362,16 @@ def _litellm_proxy_response(
)
def _without_credentials(response: httpx.Response | None) -> httpx.Response | None:
if not isinstance(response, httpx.Response):
return response
return error_response_without_credentials(response.status_code, response, "https://docs.litellm.ai/docs")
def _upstream_reply(response: httpx.Response | None) -> httpx.Response | None:
return response if response is not None and (response.headers or response.content) else None
def _map_openai_exception(
*,
model: str,
@ -370,7 +382,7 @@ def _map_openai_exception(
exception_provider: str,
extra_information: str,
) -> None:
response: Final = _litellm_proxy_response(original_exception, custom_llm_provider)
response: Final = _without_credentials(_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}",
@ -433,6 +445,7 @@ def _map_openai_exception(
model=model,
llm_provider=custom_llm_provider,
litellm_debug_info=extra_information,
response=_upstream_reply(response),
)
elif (
("invalid_request_error" in error_str and "content_policy_violation" in error_str)
@ -468,6 +481,25 @@ def _map_openai_exception(
body=getattr(original_exception, "body", None),
)
elif "invalid_request_error" in error_str and "Incorrect API key provided" not in error_str:
invalid_request_status: Final = getattr(original_exception, "status_code", None)
if invalid_request_status == 401:
raise AuthenticationError(
message=f"{exception_provider} - {message}",
llm_provider=custom_llm_provider,
model=model,
response=response,
litellm_debug_info=extra_information,
body=getattr(original_exception, "body", None),
)
if invalid_request_status == 404:
raise NotFoundError(
message=f"{exception_provider} - {message}",
model=model,
llm_provider=custom_llm_provider,
response=response,
litellm_debug_info=extra_information,
body=getattr(original_exception, "body", None),
)
raise BadRequestError(
message=f"{exception_provider} - {message}",
llm_provider=custom_llm_provider,
@ -485,6 +517,7 @@ def _map_openai_exception(
model=model,
llm_provider=custom_llm_provider,
body=getattr(original_exception, "body", None),
response=_upstream_reply(response),
)
elif "Request too large" in error_str:
raise RateLimitError(
@ -515,6 +548,7 @@ def _map_openai_exception(
model=model,
request=_request,
litellm_debug_info=extra_information,
response=_upstream_reply(response),
)
elif hasattr(original_exception, "status_code"):
if original_exception.status_code == 400:
@ -548,6 +582,7 @@ def _map_openai_exception(
model=model,
llm_provider=custom_llm_provider,
litellm_debug_info=extra_information,
response=_upstream_reply(response),
)
elif original_exception.status_code == 422:
raise BadRequestError(
@ -599,6 +634,7 @@ def _map_openai_exception(
llm_provider=custom_llm_provider,
litellm_debug_info=extra_information,
exception_status_code=original_exception.status_code,
response=_upstream_reply(response),
)
else:
raise APIError(
@ -608,6 +644,7 @@ def _map_openai_exception(
model=model,
request=getattr(original_exception, "request", None),
litellm_debug_info=extra_information,
response=_upstream_reply(response),
)
else:
# if no status code then it is an APIConnectionError: https://github.com/openai/openai-python#handling-errors
@ -957,13 +994,22 @@ _BEDROCK_MANTLE_CONTEXT_WINDOW_GENERIC_MESSAGE: Final = (
)
def _bedrock_mantle_context_window_response(original_exception: _ProviderHTTPException) -> httpx.Response:
def _bedrock_response_with_status(original_exception: _ProviderHTTPException, status_code: int) -> httpx.Response:
original_response: Final = getattr(original_exception, "response", None)
if not isinstance(original_response, httpx.Response) or getattr(original_response, "_request", None) is None:
return httpx.Response(status_code=400, request=httpx.Request(method="POST", url="https://api.openai.com/v1/"))
if original_response.status_code == 400:
return httpx.Response(
status_code=status_code, request=httpx.Request(method="POST", url="https://api.openai.com/v1/")
)
if original_response.status_code == status_code:
return original_response
return httpx.Response(status_code=400, headers=original_response.headers, request=original_response.request)
return httpx.Response(status_code=status_code, headers=original_response.headers, request=original_response.request)
def _came_from_bedrock_converse(original_exception: _ProviderHTTPException) -> bool:
original_response: Final = getattr(original_exception, "response", None)
if not isinstance(original_response, httpx.Response) or getattr(original_response, "_request", None) is None:
return False
return original_response.request.url.path.endswith(("/converse", "/converse-stream"))
def _get_bedrock_mantle_context_window_message(error_str: str) -> str | None:
@ -999,7 +1045,7 @@ def _map_bedrock_exception(
message=mantle_context_window_message,
model=model,
llm_provider=custom_llm_provider,
response=_bedrock_mantle_context_window_response(original_exception),
response=_bedrock_response_with_status(original_exception, 400),
)
if (
"too many tokens" in error_str
@ -1022,6 +1068,18 @@ def _map_bedrock_exception(
llm_provider="bedrock",
response=getattr(original_exception, "response", None),
)
elif (
"The provided model identifier is invalid" in error_str
and bool(model)
and _came_from_bedrock_converse(original_exception)
and bedrock_model_reaches_converse_by_default(model)
):
raise NotFoundError(
message=f"BedrockException - {error_str}",
model=model,
llm_provider="bedrock",
response=_bedrock_response_with_status(original_exception, 404),
)
elif "Malformed input request" in error_str:
raise BadRequestError(
message=f"BedrockException - {error_str}",
@ -2055,6 +2113,7 @@ def _map_azure_exception(
exception_provider: str,
extra_information: str,
) -> None:
response: Final = _without_credentials(getattr(original_exception, "response", None))
message = get_error_message(error_obj=original_exception)
if message is None:
if hasattr(original_exception, "message"):
@ -2090,15 +2149,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
)
elif "This model's maximum context length is" in error_str:
raise ContextWindowExceededError(
message=f"AzureException ContextWindowExceededError - {message}",
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif "DeploymentNotFound" in error_str:
raise NotFoundError(
@ -2106,7 +2157,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif azure_error_code == "content_policy_violation" or ExceptionCheckers.is_azure_content_policy_violation_error(
error_str
@ -2120,6 +2171,7 @@ def _map_azure_exception(
model=model,
extra_information=extra_information,
original_exception=original_exception,
response=response,
)
elif azure_error_code == "invalid_encrypted_content" or "could not be verified" in error_str:
helpful_message: Final = (
@ -2138,7 +2190,19 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
body=getattr(original_exception, "body", None),
)
elif getattr(original_exception, "status_code", None) in (None, 400) and (
azure_error_code == "context_length_exceeded"
or ExceptionCheckers.is_error_str_context_window_exceeded(error_str)
):
raise ContextWindowExceededError(
message=f"AzureException ContextWindowExceededError - {message}",
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=response,
body=getattr(original_exception, "body", None),
)
elif "invalid_request_error" in error_str and getattr(original_exception, "status_code", None) in (None, 400):
@ -2147,7 +2211,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
body=getattr(original_exception, "body", None),
)
elif "The api_key client option must be set either by passing api_key to the client or by setting" in error_str:
@ -2156,7 +2220,7 @@ def _map_azure_exception(
llm_provider=custom_llm_provider,
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif "Connection error" in error_str:
raise APIConnectionError(
@ -2172,7 +2236,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
body=getattr(original_exception, "body", None),
)
elif original_exception.status_code == 401:
@ -2181,7 +2245,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 404:
raise NotFoundError(
@ -2189,7 +2253,7 @@ def _map_azure_exception(
llm_provider="azure",
model=model,
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 408:
raise Timeout(
@ -2197,6 +2261,7 @@ def _map_azure_exception(
model=model,
litellm_debug_info=extra_information,
llm_provider="azure",
response=_upstream_reply(response),
)
elif original_exception.status_code == 422:
raise BadRequestError(
@ -2204,7 +2269,7 @@ def _map_azure_exception(
model=model,
llm_provider="azure",
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 429:
raise RateLimitError(
@ -2212,7 +2277,7 @@ def _map_azure_exception(
model=model,
llm_provider="azure",
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 502:
raise BadGatewayError(
@ -2220,7 +2285,7 @@ def _map_azure_exception(
model=model,
llm_provider="azure",
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 503:
raise ServiceUnavailableError(
@ -2228,7 +2293,7 @@ def _map_azure_exception(
model=model,
llm_provider="azure",
litellm_debug_info=extra_information,
response=getattr(original_exception, "response", None),
response=response,
)
elif original_exception.status_code == 504: # gateway timeout error
raise Timeout(
@ -2237,6 +2302,7 @@ def _map_azure_exception(
litellm_debug_info=extra_information,
llm_provider="azure",
exception_status_code=original_exception.status_code,
response=_upstream_reply(response),
)
else:
raise APIError(
@ -2246,6 +2312,7 @@ def _map_azure_exception(
litellm_debug_info=extra_information,
model=model,
request=httpx.Request(method="POST", url="https://openai.com/"),
response=_upstream_reply(response),
)
else:
# if no status code then it is an APIConnectionError: https://github.com/openai/openai-python#handling-errors
@ -2621,17 +2688,20 @@ def exception_type(
model=model,
llm_provider=custom_llm_provider,
litellm_debug_info=extra_information,
response=_upstream_reply(
_without_credentials(_litellm_proxy_response(mappable_exception, custom_llm_provider))
),
)
if (
custom_llm_provider == "litellm_proxy"
): # handle special case where calling litellm proxy + exception str contains error message
extract_and_raise_litellm_exception(
response=_litellm_proxy_response(mappable_exception, custom_llm_provider),
response=_without_credentials(_litellm_proxy_response(mappable_exception, custom_llm_provider)),
error_str=error_str,
model=model,
custom_llm_provider=custom_llm_provider,
body=getattr(original_exception, "body", None),
body=getattr(mappable_exception, "body", None),
)
if (
custom_llm_provider == "openai"
@ -2814,6 +2884,8 @@ def exception_type(
exception_provider=exception_provider,
extra_information=extra_information,
)
if custom_llm_provider == "bigmodel":
raise_bigmodel_business_error(model, f"{exception_provider} - {error_str}", original_exception) # pyright: ignore[reportUnknownArgumentType] # exception_type takes untyped parameters
if custom_llm_provider == "openrouter":
_map_openrouter_exception(
model=model,

View file

@ -25,6 +25,8 @@ from litellm.llms.base_llm.chat.transformation import BaseLLMException
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.llms.vertex_ai.common_utils import VertexAIError
from litellm.proxy.common_utils.openai_error_payload import openai_error_type
from litellm.types.utils import LlmProviders
@ -54,12 +56,11 @@ def test_openai_cyber_policy_uses_the_structured_error_code(shape: str, code: st
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.status_code == 400
assert caught.value.request.url == request.url
assert caught.value.response.headers["x-request-id"] == "cyber-policy-request"
def _debug_info_for_api_base(configured_api_base: str) -> str:
request: Final = httpx.Request("POST", "https://gateway.example/v1/chat/completions")
original: Final = OpenAIError(
@ -161,6 +162,12 @@ def test_api_base_line_keeps_an_at_sign_in_the_path(api_base: str) -> None:
# Tuple format: (error_message, expected_result)
context_window_test_cases = [
# Positive cases (should return True)
(
'"{\n "error": {\n "message": "Your input exceeds the context window of this model. '
'Please adjust your input and try again.",\n "type": "invalid_request_error",\n'
' "param": "input",\n "code": "context_length_exceeded"\n }\n}"',
True,
),
(
"An error occurred: The input exceeds the model's maximum context limit of 8192 tokens.",
True,
@ -434,6 +441,67 @@ def test_gemini_context_window_error_mapping(error_message, should_raise_context
)
@pytest.mark.parametrize("sync_mode", [True, False])
@pytest.mark.parametrize("streaming", [True, False])
@pytest.mark.parametrize(
("error_message", "expected_type"),
[
(
(
"Requested token count exceeds the model's maximum context length of 131072 tokens. "
"You requested a total of 140000 tokens: 130000 tokens from the input messages and "
"10000 tokens for the completion. Please reduce the number of tokens in the input "
"messages or the completion to fit within the limit."
),
litellm.ContextWindowExceededError,
),
(
(
"requested token count exceeds the model's maximum context length of 8192 tokens. "
"you requested a total of 9000 tokens"
),
litellm.ContextWindowExceededError,
),
("max_tokens must be a positive integer", litellm.BadRequestError),
],
ids=["sglang-context-overflow", "lowercase-context-overflow", "unrelated-bad-request"],
)
@pytest.mark.asyncio
async def test_sglang_context_window_error_mapping(
sync_mode: bool,
streaming: bool,
error_message: str,
expected_type: type[litellm.BadRequestError],
) -> None:
def reject_request(request: httpx.Request) -> httpx.Response:
return httpx.Response(
400,
request=request,
json={"object": "error", "message": error_message, "type": "BadRequestError", "param": None, "code": 400},
)
transport: Final = httpx.MockTransport(reject_request)
if sync_mode:
with (
httpx.Client(transport=transport) as http_client,
OpenAI(api_key="sk-test", max_retries=0, http_client=http_client) as client,
pytest.raises(litellm.BadRequestError) as caught,
):
_call_openai_api_sync("openai/sglang-model", "chat_completion", streaming, client)
else:
async with (
httpx.AsyncClient(transport=transport) as async_http_client,
AsyncOpenAI(api_key="sk-test", max_retries=0, http_client=async_http_client) as async_client,
):
with pytest.raises(litellm.BadRequestError) as caught:
await _call_openai_api_async("openai/sglang-model", "chat_completion", streaming, async_client)
assert type(caught.value) is expected_type
assert caught.value.status_code == 400
assert error_message in str(caught.value)
assert caught.value.llm_provider == "openai"
def test_lemonade_context_window_error_mapping():
"""Lemonade's llama.cpp backend should map context overflows to LiteLLM's standard error."""
@ -1102,6 +1170,138 @@ def test_azure_404_with_invalid_request_error_type_maps_to_not_found():
assert "Response with id 'resp_abc' not found." in excinfo.value.message
@pytest.mark.parametrize("provider", ["openai", "groq", "deepseek"])
@pytest.mark.parametrize(
"status_code, message, expected_exception",
[
(400, "Invalid 'temperature'", litellm.BadRequestError),
(401, "Invalid API key", litellm.AuthenticationError),
(404, "The model does not exist", litellm.NotFoundError),
],
)
def test_openai_invalid_request_error_respects_status_code(
provider: str, status_code: int, message: str, expected_exception: type[openai.APIStatusError]
) -> None:
error_message: Final = json.dumps({"error": {"message": message, "type": "invalid_request_error"}})
original_exception: Final = OpenAIError(status_code=status_code, message=error_message, headers={})
with pytest.raises(openai.APIError) as excinfo:
exception_type(
model="some-model",
original_exception=original_exception,
custom_llm_provider=provider,
)
assert type(excinfo.value) is expected_exception
assert excinfo.value.status_code == status_code
assert message in excinfo.value.message
@pytest.mark.parametrize("provider", ["openai", "groq", "deepseek"])
def test_openai_invalid_request_error_without_a_status_code_maps_to_bad_request(provider: str) -> None:
message: Final = "Missing required parameter: 'input'."
original_exception: Final = Exception(json.dumps({"error": {"message": message, "type": "invalid_request_error"}}))
with pytest.raises(openai.APIError) as excinfo:
exception_type(
model="some-model",
original_exception=original_exception,
custom_llm_provider=provider,
)
assert type(excinfo.value) is litellm.BadRequestError
assert message in excinfo.value.message
@pytest.mark.parametrize("provider", ["openai", "groq", "deepseek"])
@pytest.mark.parametrize("status_code", [403, 409, 422, 429, 500, 503])
def test_openai_invalid_request_error_keeps_bad_request_for_statuses_other_than_401_and_404(
provider: str, status_code: int
) -> None:
message: Final = "Cannot cancel a batch that is already completed."
error_message: Final = json.dumps({"error": {"message": message, "type": "invalid_request_error"}})
original_exception: Final = OpenAIError(status_code=status_code, message=error_message, headers={})
with pytest.raises(openai.APIError) as excinfo:
exception_type(
model="some-model",
original_exception=original_exception,
custom_llm_provider=provider,
)
assert type(excinfo.value) is litellm.BadRequestError
assert message in excinfo.value.message
def _openai_sdk_error(
sdk_error: type[openai.APIStatusError], status_code: int, provider_error: dict[str, str | None]
) -> openai.APIStatusError:
request: Final = httpx.Request("POST", "https://api.openai.com/v1/chat/completions")
return sdk_error(
f"Error code: {status_code} - {{'error': {provider_error}}}",
response=httpx.Response(status_code, request=request),
body=provider_error,
)
@pytest.mark.parametrize(
"sdk_error, status_code, expected_exception, param, code",
[
(openai.AuthenticationError, 401, litellm.AuthenticationError, "organization", "mismatched_organization"),
(openai.NotFoundError, 404, litellm.NotFoundError, "id", None),
],
)
def test_openai_invalid_request_error_401_and_404_keep_the_provider_error_fields(
sdk_error: type[openai.APIStatusError],
status_code: int,
expected_exception: type[openai.APIStatusError],
param: str,
code: str | None,
) -> None:
provider_error: Final = {
"message": "The request was rejected.",
"type": "invalid_request_error",
"param": param,
"code": code,
}
with pytest.raises(openai.APIError) as excinfo:
exception_type(
model="gpt-5-mini",
original_exception=_openai_sdk_error(sdk_error, status_code, provider_error),
custom_llm_provider="openai",
)
assert type(excinfo.value) is expected_exception
assert (excinfo.value.status_code, excinfo.value.type, excinfo.value.param, excinfo.value.code) == (
status_code,
"invalid_request_error",
param,
code,
)
assert excinfo.value.body == provider_error
assert openai_error_type(excinfo.value, status_code) == "invalid_request_error"
assert excinfo.value.message.count(expected_exception.__name__) == 1
def test_openai_incorrect_api_key_keeps_the_proxy_authentication_error_type() -> None:
provider_error: Final = {
"message": "Incorrect API key provided: sk-litellmqa.",
"type": "invalid_request_error",
"param": None,
"code": "invalid_api_key",
}
with pytest.raises(litellm.AuthenticationError) as excinfo:
exception_type(
model="gpt-5-mini",
original_exception=_openai_sdk_error(openai.AuthenticationError, 401, provider_error),
custom_llm_provider="openai",
)
assert openai_error_type(excinfo.value, 401) == "authentication_error"
class _UpstreamHTTPError(Exception):
def __init__(self, status_code: int) -> None:
super().__init__("upstream failure")
@ -1555,6 +1755,75 @@ def test_bedrock_mantle_400_maps_to_bad_request():
assert type(excinfo.value) is litellm.BadRequestError
class _ErrorWithoutResponse(Exception):
def __init__(self, message: str, status_code: int) -> None:
super().__init__(message)
self.message = message
self.status_code = status_code
def test_bedrock_mantle_context_overflow_without_a_provider_response_answers_400():
with pytest.raises(litellm.ContextWindowExceededError) as excinfo:
exception_type(
model="openai.gpt-5.6-sol",
original_exception=_ErrorWithoutResponse(
'{"error":{"code":"context_length_exceeded","message":"too long"}}', 400
),
custom_llm_provider="bedrock_mantle",
)
assert excinfo.value.response.status_code == 400
def _invalid_model_identifier_from(url: str) -> BedrockError:
return BedrockError(
status_code=400,
message='{"message":"The provided model identifier is invalid."}',
response=httpx.Response(status_code=400, request=httpx.Request(method="POST", url=url)),
)
@pytest.mark.parametrize(
"path",
["/model/us.newvendor.typo-1/converse", "/model/us.newvendor.typo-1/converse-stream"],
)
def test_bedrock_converse_rejecting_an_id_with_no_invoke_provider_answers_404(path):
with pytest.raises(litellm.NotFoundError) as excinfo:
exception_type(
model="us.newvendor.typo-1",
original_exception=_invalid_model_identifier_from(f"https://bedrock-runtime.us-east-1.amazonaws.com{path}"),
custom_llm_provider="bedrock",
)
assert excinfo.value.response.status_code == 404
@pytest.mark.parametrize(
"original_exception",
[
_invalid_model_identifier_from("https://bedrock-runtime.us-east-1.amazonaws.com/model/claude-typo-9/invoke"),
_ErrorWithoutResponse("The provided model identifier is invalid.", 400),
],
ids=["invoke", "no-response"],
)
def test_bedrock_invalid_model_identifier_not_from_converse_stays_a_bad_request(original_exception):
with pytest.raises(litellm.BadRequestError) as excinfo:
exception_type(model="claude-typo-9", original_exception=original_exception, custom_llm_provider="bedrock")
assert excinfo.value.status_code == 400
def test_bedrock_invalid_model_identifier_without_a_model_stays_a_bad_request():
with pytest.raises(litellm.BadRequestError) as excinfo:
exception_type(
model=None,
original_exception=_ErrorWithoutResponse("The provided model identifier is invalid.", 400),
custom_llm_provider="bedrock",
)
assert excinfo.value.status_code == 400
def test_bedrock_mantle_context_overflow_maps_to_context_window_exceeded():
from litellm.llms.base_llm.chat.transformation import BaseLLMException
@ -1603,9 +1872,9 @@ def test_bedrock_mantle_openai_envelope_context_overflow_maps_to_context_window_
def test_bedrock_mantle_streamed_context_overflow_event_maps_to_context_window_exceeded():
from litellm.responses.streaming_iterator import _map_stream_error_to_exception
from litellm.responses.streaming_iterator import map_stream_error_to_exception
mapped_exception = _map_stream_error_to_exception(
mapped_exception = map_stream_error_to_exception(
{
"code": "context_length_exceeded",
"message": "Your input exceeds the context window of this model. Please adjust your input and try again.",
@ -2894,3 +3163,80 @@ def test_transport_timeout_maps_to_timeout(
assert exc_info.value.status_code == 408
assert f"Request timed out. Error_str: {reason}" in str(exc_info.value)
def test_bedrock_server_error_keeps_the_aws_body_without_the_signed_request() -> None:
body: Final = '{"message":"Bedrock is unable to process your request."}'
signed_request: Final = httpx.Request(
"POST",
"https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-opus-5-5/converse",
headers={"authorization": "AWS4-HMAC-SHA256 Credential=AKIDSIGNED/20261029/us-east-1/bedrock/aws4_request"},
content=b'{"messages":[{"role":"user","content":[{"text":"hi"}]}]}',
)
upstream: Final = httpx.Response(
500, content=body, headers={"x-amzn-requestid": "req-aws"}, request=signed_request
)
with pytest.raises(litellm.ServiceUnavailableError) as raised:
exception_type(
model="bedrock/anthropic.claude-opus-5-5",
original_exception=BedrockError(status_code=500, message=body, response=upstream),
custom_llm_provider="bedrock",
)
assert raised.value.response.text == body
assert raised.value.response.headers["x-amzn-requestid"] == "req-aws"
assert "AKIDSIGNED" not in str(raised.value.request.headers)
assert raised.value.request.content == b""
@pytest.mark.parametrize("provider", ("gemini", "vertex_ai"))
def test_gemini_server_error_response_carries_the_upstream_error_body(provider: str) -> None:
body: Final = '{"error":{"code":500,"message":"Internal error encountered.","status":"INTERNAL"}}'
with pytest.raises(litellm.InternalServerError) as raised:
exception_type(
model="gemini-3.1-pro",
original_exception=VertexAIError(status_code=500, message=body, headers=None),
custom_llm_provider=provider,
)
assert raised.value.response.status_code == 500
assert raised.value.response.json() == json.loads(body)
@pytest.mark.parametrize(
("status_code", "message", "mapped_error"),
(
(500, "The server had an error processing your request. Sorry about that!", litellm.InternalServerError),
(520, "Web server is returning an unknown error", litellm.InternalServerError),
(504, "A timeout occurred", litellm.Timeout),
(500, "Mistral API raised a streaming error", litellm.APIError),
),
)
def test_openai_error_matched_by_its_message_keeps_the_upstream_body(
status_code: int, message: str, mapped_error: type[Exception]
) -> None:
body: Final = json.dumps({"error": {"message": message, "type": "server_error", "param": None, "code": None}})
sent_request: Final = httpx.Request(
"POST",
"https://api.openai.com/v1/chat/completions",
headers={"authorization": "Bearer sk-openai-secret"},
content=b'{"messages":[{"role":"user","content":"hi"}]}',
)
upstream: Final = httpx.Response(
status_code, content=body, headers={"x-request-id": "req-openai"}, request=sent_request
)
with pytest.raises(mapped_error) as raised:
exception_type(
model="gpt-5.6",
original_exception=openai.APIStatusError(message, response=upstream, body=json.loads(body)),
custom_llm_provider="openai",
)
error_response: Final = getattr(raised.value, "response")
assert error_response.text == body
assert error_response.headers["x-request-id"] == "req-openai"
assert "sk-openai-secret" not in str(error_response.request.headers)
assert error_response.request.content == b""