This commit is contained in:
Mateo Wang 2026-10-26 16:22:37 +03:00 • committed by GitHub
commit 2b3a07375a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 250 additions and 34 deletions

View file

@ -1192,8 +1192,9 @@ class AmazonConverseConfig(BaseConfig):
),
status_code=400,
)
verbose_logger.debug(
"Dropping unsupported `reasoning_effort=%s` for Bedrock model=%s.",
verbose_logger.warning(
"Dropping reasoning_effort=%r for Bedrock model=%r (drop_params=True) because the model map "
"marks that level unsupported.",
value,
model,
)

View file

@ -5,6 +5,7 @@ from collections.abc import Collection
from typing import ClassVar, Final
import litellm
from litellm._logging import verbose_logger
from litellm.utils import (
declared_value_factory,
is_explicitly_disabled_factory,
@ -15,6 +16,12 @@ from .gpt_transformation import OpenAIGPTConfig
_GPT_SERIES_VERSION: Final = re.compile(r"^gpt-(\d+)(?:\.(\d+))?(?=[.-]|$)")
DROP_REFUSED_REASONING_EFFORT_WARNING: Final = (
"Dropping %s=%r for model=%r (drop_params=True) because the model map does not mark that level supported for "
"%r. If the deployment supports it, list every level it supports in model_info.reasoning_effort_levels, or set "
"model_info.base_model when the deployment name is not its underlying model."
)
def _catalogue_declares_default_effort() -> bool:
"""Whether the loaded cost map carries default_reasoning_effort for ANY entry.
@ -342,6 +349,13 @@ class OpenAIGPT5Config(OpenAIGPTConfig):
and self.refuses_reasoning_effort_level(model, requested_effort)
):
if litellm.drop_params or drop_params:
verbose_logger.warning(
DROP_REFUSED_REASONING_EFFORT_WARNING,
"reasoning_effort",
requested_effort,
model,
self._model_map_lookup_name(model),
)
non_default_params.pop("reasoning_effort", None)
optional_params.pop("reasoning_effort", None)
else:

View file

@ -26,6 +26,7 @@ from litellm.litellm_core_utils.safe_json_loads import safe_json_loads
from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
from litellm.llms.base_llm.responses.transformation import BaseResponsesAPIConfig
from litellm.llms.openai.chat.gpt_5_transformation import (
DROP_REFUSED_REASONING_EFFORT_WARNING,
is_gpt_reasoning_series_name,
unsupported_reasoning_effort_message,
)
@ -50,6 +51,9 @@ from ..common_utils import OpenAIError
from ..workload_identity import get_workload_identity_bearer_token, resolve_openai_workload_identity_config
OPENAI_RESPONSES_API_MIN_MAX_OUTPUT_TOKENS: Final = 16
DROP_UNSUPPORTED_REASONING_WARNING: Final = (
"Dropping reasoning=%r for model=%r (drop_params=True) because its model cost map entry lacks supports_reasoning."
)
_RAW_RESPONSE_JSON: Final = TypeAdapter(dict[str, object], config=ConfigDict(strict=True))
if TYPE_CHECKING:
@ -401,7 +405,8 @@ class OpenAIResponsesAPIConfig(BaseResponsesAPIConfig):
and not self._supports_reasoning_param(model=model)
):
if drop_params or litellm.drop_params:
params.pop("reasoning", None)
dropped_reasoning: Final = params.pop("reasoning", None)
verbose_logger.warning(DROP_UNSUPPORTED_REASONING_WARNING, dropped_reasoning, model)
else:
raise litellm.UnsupportedParamsError(
message=(
@ -427,6 +432,9 @@ class OpenAIResponsesAPIConfig(BaseResponsesAPIConfig):
message=unsupported_reasoning_effort_message("reasoning.effort", requested_effort, model),
status_code=400,
)
verbose_logger.warning(
DROP_REFUSED_REASONING_EFFORT_WARNING, "reasoning.effort", requested_effort, model, lookup_name
)
remaining: Final = reasoning.copy()
remaining.pop("effort", None)
if remaining:

View file

@ -426,6 +426,27 @@ def _log_remap(
logged_deployment_id: Final = _single_line(deployment_id)
logged_model_group: Final = _single_line(model_group)
logged_deployment_model: Final = _single_line(deployment_model)
extra: Final = MappingProxyType(
{
"reasoning_effort_deployment_id": logged_deployment_id,
"reasoning_effort_model_group": logged_model_group,
"reasoning_effort_deployment_model": logged_deployment_model,
"reasoning_effort_requested": logged_requested_level,
"reasoning_effort_sent": logged_sent_level,
"reasoning_effort_rounding": rounding,
}
)
if sent_level is None and requested_level != _DEFAULT_EFFORT:
verbose_logger.warning(
"Dropping reasoning level %s (drop_params=True) for deployment %s, model group %s, model %s because its "
"model_info.reasoning_effort_levels does not list that level. List every level the deployment supports.",
logged_requested_level,
logged_deployment_id,
logged_model_group,
logged_deployment_model,
extra=extra,
)
return
verbose_logger.info(
"reasoning_effort %s sent as %s (rounding %s) to deployment %s, model group %s, model %s",
logged_requested_level,
@ -434,14 +455,7 @@ def _log_remap(
logged_deployment_id,
logged_model_group,
logged_deployment_model,
extra={
"reasoning_effort_deployment_id": logged_deployment_id,
"reasoning_effort_model_group": logged_model_group,
"reasoning_effort_deployment_model": logged_deployment_model,
"reasoning_effort_requested": logged_requested_level,
"reasoning_effort_sent": logged_sent_level,
"reasoning_effort_rounding": rounding,
},
extra=extra,
)

View file

@ -4972,6 +4972,14 @@ def _declared_reasoning_efforts(model_info: Mapping[str, object] | None) -> tupl
return deployment_reasoning_effort_levels(model_info) or ()
_DROPPED_REASONING_PARAM_FIXES: Final = MappingProxyType(
{
"reasoning_effort": "If the deployment is a reasoning model, set model_info.base_model to its underlying model.",
"thinking": "If the deployment is a reasoning model, send reasoning_effort instead.",
}
)
def get_optional_params(
# use the openai defaults
# https://platform.openai.com/docs/api-reference/chat/create
@ -5059,19 +5067,27 @@ def get_optional_params(
verbose_logger.info("\nLiteLLM completion() model= %s; provider = %s", model, custom_llm_provider)
verbose_logger.debug("\nLiteLLM: Params passed to completion() %s", passed_params)
verbose_logger.debug("\nLiteLLM: Non-Default params passed to completion() %s", non_default_params)
unsupported_params: Final = {}
for k in non_default_params:
if k not in supported_params:
if k in PROVIDER_UNVALIDATED_PARAMS:
continue
if k == "n" and n == 1: # langchain sends n=1 as a default value
continue # skip this param
unsupported_params[k] = non_default_params[k]
unsupported_params: Final[Mapping[str, object]] = {
k: non_default_params[k]
for k in non_default_params
if k not in supported_params and k not in PROVIDER_UNVALIDATED_PARAMS and not (k == "n" and n == 1)
}
if unsupported_params:
if litellm.drop_params is True or (drop_params is not None and drop_params is True):
for k in unsupported_params:
non_default_params.pop(k, None)
for reasoning_param, fix in _DROPPED_REASONING_PARAM_FIXES.items():
if reasoning_param in unsupported_params:
verbose_logger.warning(
"Dropping %s=%r for model=%r (drop_params=True) because %s does not support %s for it. %s",
reasoning_param,
unsupported_params[reasoning_param],
model,
custom_llm_provider,
reasoning_param,
fix,
)
else:
raise UnsupportedParamsError(
status_code=500,

View file

@ -1,6 +1,7 @@
import base64
import copy
import json
import logging
import os
import re
from collections.abc import Iterator, Mapping
@ -966,7 +967,9 @@ def test_reasoning_effort_maps_to_reasoning_effort_for_openai_gpt5_converse(mode
"us.openai.gpt-6-astra",
],
)
def test_openai_gpt5_converse_rejects_effort_level_disabled_in_model_map(model, local_model_cost_map):
def test_openai_gpt5_converse_rejects_effort_level_disabled_in_model_map(
model: str, local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
config = AmazonConverseConfig()
assert litellm.utils.is_explicitly_disabled_factory(
model=model, custom_llm_provider="bedrock_converse", key="supports_minimal_reasoning_effort"
@ -980,15 +983,18 @@ def test_openai_gpt5_converse_rejects_effort_level_disabled_in_model_map(model,
drop_params=False,
)
optional_params = config.map_openai_params(
non_default_params={"reasoning_effort": "minimal"},
optional_params={},
model=model,
drop_params=True,
)
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
optional_params = config.map_openai_params(
non_default_params={"reasoning_effort": "minimal"},
optional_params={},
model=model,
drop_params=True,
)
_, additional_request_params, _, _ = config._prepare_request_params(optional_params, model)
assert "reasoning" not in additional_request_params
assert "thinking" not in additional_request_params
dropped = [r.getMessage() for r in caplog.records if "Dropping reasoning_effort='minimal'" in r.getMessage()]
assert len(dropped) == 1 and model in dropped[0]
@pytest.mark.parametrize(

View file

@ -337,13 +337,21 @@ class TestDisabledReasoningEffort:
)
@pytest.mark.parametrize("model", ["us.openai.gpt-5.6-luna", MODEL])
def test_effort_level_disabled_in_model_map_is_dropped_with_drop_params(self, model, local_model_cost_map):
params = _cfg().map_openai_params(
response_api_optional_params={"reasoning": {"effort": "minimal", "summary": "auto"}, "max_output_tokens": 64},
model=model,
drop_params=True,
)
def test_effort_level_disabled_in_model_map_is_dropped_with_a_warning(
self, model: str, local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
params = _cfg().map_openai_params(
response_api_optional_params={
"reasoning": {"effort": "minimal", "summary": "auto"},
"max_output_tokens": 64,
},
model=model,
drop_params=True,
)
assert params == {"reasoning": {"summary": "auto"}, "max_output_tokens": 64}
dropped = [r.getMessage() for r in caplog.records if "Dropping reasoning.effort='minimal'" in r.getMessage()]
assert len(dropped) == 1 and model in dropped[0]
def test_effort_only_reasoning_is_removed_when_dropped(self, local_model_cost_map):
params = _cfg().map_openai_params(

View file

@ -1,4 +1,5 @@
import json
import logging
from collections.abc import Callable, Mapping
from types import SimpleNamespace
from typing import Final, cast
@ -2387,6 +2388,57 @@ class TestResponsesSurfaceSharesTheEffortRule:
)
assert mapped["reasoning"] == {"summary": "auto"}
def test_dropping_a_refused_effort_logs_one_warning_naming_the_level_and_the_fix(
self, local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
refused: Final = next(
level
for level in ("none", "minimal", "low")
if litellm.model_cost["gpt-6.1-sol"].get(f"supports_{level}_reasoning_effort") is False
)
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
mapped: Final = OpenAIResponsesAPIConfig().map_openai_params(
response_api_optional_params={"reasoning": {"effort": refused}},
model="gpt-6.1-sol",
drop_params=True,
)
assert "reasoning" not in mapped
drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
assert len(drop_warnings) == 1
assert all(
fragment in drop_warnings[0]
for fragment in (repr(refused), "gpt-6.1-sol", "model_info.reasoning_effort_levels")
)
def test_dropping_reasoning_for_a_model_without_supports_reasoning_logs_one_warning(
self, local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
mapped: Final = OpenAIResponsesAPIConfig().map_openai_params(
response_api_optional_params={"reasoning": {"effort": "medium"}},
model="gpt-4o",
drop_params=True,
)
assert "reasoning" not in mapped
drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
assert len(drop_warnings) == 1
assert all(fragment in drop_warnings[0] for fragment in ("'medium'", "gpt-4o", "supports_reasoning"))
def test_a_forwarded_effort_logs_no_drop_warning(
self, local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
mapped: Final = OpenAIResponsesAPIConfig().map_openai_params(
response_api_optional_params={"reasoning": {"effort": "medium"}},
model="gpt-6.1-sol",
drop_params=True,
)
assert mapped["reasoning"] == {"effort": "medium"}
assert not [record for record in caplog.records if "Dropping" in record.getMessage()]
@pytest.mark.parametrize("level", ["none", "minimal", "low", "medium", "high", "xhigh", "max"])
def test_gpt5_3_codex_forwards_exactly_the_effort_levels_its_map_row_allows(self, local_model_cost_map, level):
"""The gate turns a stale false into a local refusal, so the Responses-only codex row has to

View file

@ -1,3 +1,4 @@
import logging
import re
from collections.abc import Mapping
from typing import Final
@ -1589,3 +1590,44 @@ def test_gpt_6_astra_takes_the_reasoning_series_request_shape():
assert "max_tokens" not in params
assert params["reasoning_effort"] == "max"
assert params["verbosity"] == "low"
@pytest.mark.parametrize(
("custom_llm_provider", "level"),
[("azure", "none"), ("azure", "xhigh"), ("openai", "xhigh")],
)
def test_a_reasoning_effort_the_level_gate_drops_logs_a_warning_naming_the_fix(
caplog: pytest.LogCaptureFixture, custom_llm_provider: str, level: str
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
params: Final = litellm.get_optional_params(
model="gpt-5.6-terra-ptu",
custom_llm_provider=custom_llm_provider,
reasoning_effort=level,
drop_params=True,
)
assert "reasoning_effort" not in params
drop_warnings: Final = [
record.getMessage()
for record in caplog.records
if record.levelno == logging.WARNING and "reasoning_effort" in record.getMessage()
]
assert len(drop_warnings) == 1
assert all(
fragment in drop_warnings[0]
for fragment in (level, "gpt-5.6-terra-ptu", "model_info.base_model", "model_info.reasoning_effort_levels")
)
def test_a_reasoning_effort_the_level_gate_forwards_logs_no_drop_warning(caplog: pytest.LogCaptureFixture) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
params: Final = litellm.get_optional_params(
model="gpt-5.6-terra-ptu",
custom_llm_provider="azure",
reasoning_effort="medium",
drop_params=True,
)
assert params["reasoning_effort"] == "medium"
assert not [record for record in caplog.records if "reasoning_effort" in record.getMessage()]

View file

@ -626,8 +626,9 @@ class TestResolveDeploymentReasoningEffort:
_sent("turbo\nforged line", drop_params=True)
assert [record.getMessage() for record in caplog.records] == [
"reasoning_effort unrecognized sent as None (rounding up) to deployment deployment-1, "
"model group kimi-k3, model hosted_vllm/my-kimi"
"Dropping reasoning level unrecognized (drop_params=True) for deployment deployment-1, model group "
"kimi-k3, model hosted_vllm/my-kimi because its model_info.reasoning_effort_levels does not list that "
"level. List every level the deployment supports."
]
def test_line_breaks_in_logged_names_cannot_forge_a_log_line(self, caplog: pytest.LogCaptureFixture) -> None:
@ -669,6 +670,27 @@ class TestResolveDeploymentReasoningEffort:
"reasoning_effort_rounding": "up",
}
def test_only_a_dropped_level_logs_a_warning(self, caplog: pytest.LogCaptureFixture) -> None:
verbose_logger.addHandler(caplog.handler)
verbose_logger.propagate = False
verbose_logger.setLevel(logging.INFO)
declared: Final = {"reasoning_effort_levels": ["low", "high"]}
_sent("none", declared, drop_params=True)
_sent("medium")
_sent("default", declared, drop_params=True)
_sent("default", declared)
assert [record.levelno for record in caplog.records] == [
logging.WARNING,
logging.INFO,
logging.INFO,
logging.INFO,
]
dropped: Final = caplog.records[0].getMessage()
assert "Dropping reasoning level none" in dropped
assert "model_info.reasoning_effort_levels" in dropped
class TestAzureGpt6SolAndLunaAdvertiseTheOpenAiLevels:
@pytest.mark.parametrize(

View file

@ -1,4 +1,5 @@
import json
import logging
from typing import Final
from unittest.mock import MagicMock, patch
@ -2097,3 +2098,35 @@ def test_supports_system_message_merges_system_prompt_into_user_message() -> Non
]
assert map_system_message_pt(messages=messages) == [{"role": "user", "content": "Listen here! Hello there!"}]
def test_dropping_an_unsupported_reasoning_effort_logs_one_warning(
local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
optional_params: Final = get_optional_params(
model="terra-ptu", custom_llm_provider="azure", reasoning_effort="none", drop_params=True
)
assert "reasoning_effort" not in optional_params
drop_warnings: Final = [
record.getMessage() for record in caplog.records if "Dropping reasoning_effort" in record.getMessage()
]
assert len(drop_warnings) == 1
assert all(fragment in drop_warnings[0] for fragment in ("'none'", "terra-ptu", "model_info.base_model"))
def test_dropping_an_unsupported_thinking_logs_one_warning(
local_model_cost_map: None, caplog: pytest.LogCaptureFixture
) -> None:
with caplog.at_level(logging.WARNING, logger="LiteLLM"):
optional_params: Final = get_optional_params(
model="terra-ptu", custom_llm_provider="azure", thinking={"type": "disabled"}, drop_params=True
)
assert "thinking" not in optional_params
drop_warnings: Final = [
record.getMessage() for record in caplog.records if "Dropping thinking" in record.getMessage()
]
assert len(drop_warnings) == 1
assert all(fragment in drop_warnings[0] for fragment in ("'disabled'", "terra-ptu", "send reasoning_effort"))