From 09676018655a24f895cf58fa631ddf0cbc9fc396 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Fri, 30 Oct 2026 01:15:25 -0700 Subject: [PATCH] fix(responses): keep off-catalog reasoning keys, read reasoning lists from the loaded cost map, drop non-object reasoning and tool_choice --- .../llms/openai/responses/transformation.py | 10 ++- litellm/responses/utils.py | 83 ++++++++++++------- .../test_openai_responses_transformation.py | 39 +++++++-- tests/unit/responses/test_responses_utils.py | 6 +- 4 files changed, 99 insertions(+), 39 deletions(-) diff --git a/litellm/llms/openai/responses/transformation.py b/litellm/llms/openai/responses/transformation.py index e3b1973f505..e6dd20ef15b 100644 --- a/litellm/llms/openai/responses/transformation.py +++ b/litellm/llms/openai/responses/transformation.py @@ -335,7 +335,7 @@ def _tool_mappings(tools: object) -> tuple[Mapping[str, object], ...]: def _names_a_sent_tool(tool_choice: object, tools: tuple[Mapping[str, object], ...]) -> bool: choice: Final = as_str_mapping(tool_choice) if choice is None: - return True + return False match choice.get("type"): case "allowed_tools": allowed: Final = choice.get("tools") @@ -375,6 +375,8 @@ def _is_well_formed(name: str, value: object, params: Mapping[str, object]) -> b return value is None or isinstance(value, bool) case "previous_response_id": return value is None or (isinstance(value, str) and value != "") + case "reasoning": + return value is None or as_str_mapping(value) is not None case _: return True @@ -536,8 +538,10 @@ class OpenAIResponsesAPIConfig(BaseResponsesAPIConfig): def _accepted_reasoning(self, reasoning: Mapping[str, object], model: str) -> Mapping[str, object]: if self.custom_llm_provider not in _PROVIDERS_CHECKED_FOR_MALFORMED_VALUES: return reasoning - if self.custom_llm_provider != LlmProviders.OPENAI or not OpenAIGPTConfig.is_openai_catalog_model(model): - return openai_api_well_formed_reasoning(reasoning) + if self.custom_llm_provider != LlmProviders.OPENAI: + return openai_api_well_formed_reasoning(reasoning, keeps_unlisted_keys=False) + if not OpenAIGPTConfig.is_openai_catalog_model(model): + return openai_api_well_formed_reasoning(reasoning, keeps_unlisted_keys=True) return openai_well_formed_reasoning(reasoning, model, model_reasons=self._supports_reasoning_param(model=model)) def _is_well_formed_effort(self, effort: object, declared_reasoning_efforts: Collection[str] | None) -> bool: diff --git a/litellm/responses/utils.py b/litellm/responses/utils.py index c0365e530ca..e2540656197 100644 --- a/litellm/responses/utils.py +++ b/litellm/responses/utils.py @@ -7,7 +7,7 @@ from itertools import chain from types import MappingProxyType from typing import Any, Final, Optional, TypeVar, Union, cast, get_args, get_type_hints, overload -from pydantic import BaseModel, ConfigDict, TypeAdapter +from pydantic import BaseModel, TypeAdapter from typing_extensions import TypedDict as ExtraItemsTypedDict from typing_extensions import TypeIs # noqa: TID251 # narrows untyped wire payloads without a runtime conversion @@ -15,7 +15,6 @@ import litellm from litellm._logging import verbose_logger from litellm.litellm_core_utils.core_helpers import as_str_mapping, attribute_or_none, iter_items from litellm.litellm_core_utils.dot_notation_indexing import delete_nested_value, is_nested_path -from litellm.litellm_core_utils.get_model_cost_map import GetModelCostMap from litellm.litellm_core_utils.get_provider_specific_headers import ProviderSpecificHeaderUtils from litellm.llms.base_llm.responses.transformation import BaseResponsesAPIConfig, ReasoningSummaryLevel from litellm.types.llms.openai import ( @@ -1423,29 +1422,46 @@ def _openai_model_info(model: str) -> ModelInfo | None: return None if isinstance(model_info, ModelInfoLookupMiss) else model_info -class _ReasoningDeclarations(BaseModel): - model_config = ConfigDict(frozen=True, extra="ignore") - - litellm_provider: str | None = None - reasoning_modes: tuple[str, ...] | None = None - reasoning_contexts: tuple[str, ...] | None = None +def _declared_strings(rows: Iterable[Mapping[str, object]], field: str) -> frozenset[str]: + return frozenset(chain.from_iterable(_string_items(row.get(field)) for row in rows)) -_BUNDLED_REASONING_DECLARATIONS: Final = TypeAdapter(dict[str, _ReasoningDeclarations]) +def _string_items(values: object) -> tuple[str, ...]: + listed: Final = iter_items(values) if type(values) in (list, tuple) else () + return tuple(value for value in listed if isinstance(value, str)) + + +_NO_COST_MAP: Final[Mapping[str, object]] = MappingProxyType({}) + + +def _model_cost() -> Mapping[str, object]: + model_cost: Final = as_str_mapping(attribute_or_none(litellm, "model_cost")) + return _NO_COST_MAP if model_cost is None else model_cost @lru_cache(maxsize=1) -def _reasoning_values_any_openai_row_declares() -> Mapping[str, frozenset[str]]: - bundled: Final = _BUNDLED_REASONING_DECLARATIONS.validate_json(GetModelCostMap.read_local_model_cost_map_text()) - openai_rows: Final = tuple(row for row in bundled.values() if row.litellm_provider == "openai") +def _reasoning_values_declared_in_cost_map( + _cost_map_id: int, _cost_map_generation: int +) -> Mapping[str, frozenset[str]]: + openai_rows: Final = tuple( + row + for row in map(as_str_mapping, tuple(_model_cost().values())) + if row is not None and row.get("litellm_provider") == "openai" + ) return MappingProxyType( { - "mode": frozenset(chain.from_iterable(row.reasoning_modes or () for row in openai_rows)), - "context": frozenset(chain.from_iterable(row.reasoning_contexts or () for row in openai_rows)), + "mode": _declared_strings(openai_rows, "reasoning_modes"), + "context": _declared_strings(openai_rows, "reasoning_contexts"), } ) +def _reasoning_values_any_openai_row_declares() -> Mapping[str, frozenset[str]]: + from litellm.utils import get_model_cost_mutation_generation + + return _reasoning_values_declared_in_cost_map(id(_model_cost()), get_model_cost_mutation_generation()) + + def _declared_values(values: Sequence[str] | None, undeclared: frozenset[str]) -> frozenset[str | None]: return undeclared if values is None else frozenset(values) @@ -1463,38 +1479,49 @@ def _openai_declared_reasoning_field_values(model_info: ModelInfo | None) -> Map ) -def _openai_reasoning_field_values(model: str) -> Mapping[str, frozenset[str | None] | None]: - model_info: Final = _openai_model_info(model) - if model_info is not None and not model_info.get("supports_reasoning"): - return MappingProxyType({}) - return _openai_declared_reasoning_field_values(model_info) - - def _openai_accepts_reasoning_field( - key: str, value: object, values_by_field: Mapping[str, frozenset[str | None] | None] + key: str, + value: object, + values_by_field: Mapping[str, frozenset[str | None] | None], + *, + keeps_unlisted_keys: bool, ) -> bool: if key == "effort": return True if key not in values_by_field: - return False + return keeps_unlisted_keys allowed: Final = values_by_field[key] return allowed is None or (isinstance(value, str | None) and value in allowed) def _reasoning_with_accepted_fields( - reasoning: Mapping[str, object], values_by_field: Mapping[str, frozenset[str | None] | None] + reasoning: Mapping[str, object], + values_by_field: Mapping[str, frozenset[str | None] | None], + *, + keeps_unlisted_keys: bool = False, ) -> Mapping[str, object]: return { - key: value for key, value in reasoning.items() if _openai_accepts_reasoning_field(key, value, values_by_field) + key: value + for key, value in reasoning.items() + if _openai_accepts_reasoning_field(key, value, values_by_field, keeps_unlisted_keys=keeps_unlisted_keys) } def _openai_accepted_reasoning(reasoning: Mapping[str, object], model: str) -> Mapping[str, object]: - return _reasoning_with_accepted_fields(reasoning, _openai_reasoning_field_values(model)) + model_info: Final = _openai_model_info(model) + if model_info is None: + return openai_api_well_formed_reasoning(reasoning, keeps_unlisted_keys=True) + if not model_info.get("supports_reasoning"): + return _reasoning_with_accepted_fields(reasoning, MappingProxyType({})) + return _reasoning_with_accepted_fields(reasoning, _openai_declared_reasoning_field_values(model_info)) -def openai_api_well_formed_reasoning(reasoning: Mapping[str, object]) -> Mapping[str, object]: - return _reasoning_with_accepted_fields(reasoning, _openai_declared_reasoning_field_values(None)) +def openai_api_well_formed_reasoning( + reasoning: Mapping[str, object], *, keeps_unlisted_keys: bool +) -> Mapping[str, object]: + return _reasoning_with_accepted_fields( + reasoning, _openai_declared_reasoning_field_values(None), keeps_unlisted_keys=keeps_unlisted_keys + ) def openai_well_formed_reasoning( diff --git a/tests/unit/llms/openai/responses/test_openai_responses_transformation.py b/tests/unit/llms/openai/responses/test_openai_responses_transformation.py index d693df4d72c..031f27a6699 100644 --- a/tests/unit/llms/openai/responses/test_openai_responses_transformation.py +++ b/tests/unit/llms/openai/responses/test_openai_responses_transformation.py @@ -1,5 +1,6 @@ import json import logging +import time from collections.abc import Callable, Mapping from types import SimpleNamespace from typing import Final, cast @@ -12,6 +13,7 @@ from openai.types.responses.response_compaction_item import ResponseCompactionIt from pydantic import JsonValue, TypeAdapter import litellm +from litellm.litellm_core_utils.get_model_cost_map import adopt_model_cost_map from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj from litellm.llms.azure.responses.o_series_transformation import AzureOpenAIOSeriesResponsesAPIConfig from litellm.llms.azure.responses.transformation import AzureOpenAIResponsesAPIConfig @@ -36,7 +38,6 @@ from litellm.types.llms.openai import ( from litellm.types.router import GenericLiteLLMParams from litellm.types.utils import Choices, Message, ModelResponse from tests.unit.proxy.conftest import httpx_transport -import time _ARTIFACT_FIELD_PATTERN: Final = r'^(?!__.*__$)[^\p{Cc}\p{Cf}\p{Zl}\p{Zp}"\\./[\]]{1,200}$' @@ -3348,6 +3349,9 @@ class TestMalformedParamsFollowDropParams: pytest.param({"parallel_tool_calls": "true"}, id="parallel-tool-calls-string"), pytest.param({"previous_response_id": 12}, id="previous-response-id-int"), pytest.param({"previous_response_id": ""}, id="previous-response-id-empty"), + pytest.param({"tool_choice": 5, "tools": [_WEATHER_TOOL]}, id="tool-choice-a-number-with-tools"), + pytest.param({"tool_choice": ["get_time"], "tools": [_WEATHER_TOOL]}, id="tool-choice-a-list-with-tools"), + pytest.param({"reasoning": "high"}, id="reasoning-not-an-object"), ], ) def test_a_malformed_value_is_dropped_under_drop_params_and_sent_as_is_without( @@ -3419,7 +3423,6 @@ class TestMalformedParamsFollowDropParams: "params", [ pytest.param({"tool_choice": {"name": "get_time"}, "tools": [_WEATHER_TOOL]}, id="choice-without-a-type"), - pytest.param({"tool_choice": ["get_time"], "tools": [_WEATHER_TOOL]}, id="choice-not-an-object"), pytest.param( {"tool_choice": {"type": "function", "name": "get_time"}, "tools": _WEATHER_TOOL}, id="tools-not-a-list" ), @@ -3536,11 +3539,10 @@ class TestMalformedParamsFollowDropParams: [ (AzureOpenAIResponsesAPIConfig(), "gpt-6.1-sol"), (AzureOpenAIOSeriesResponsesAPIConfig(), "o_series/gpt-6.1-sol"), - (OpenAIResponsesAPIConfig(), "my-fine-tuned-model"), ], - ids=["azure", "azure-o-series", "outside-openai-catalog"], + ids=["azure", "azure-o-series"], ) - def test_reasoning_values_no_openai_row_declares_are_dropped_where_the_openai_catalog_does_not_apply( + def test_azure_drops_reasoning_values_and_keys_no_openai_row_declares( self, local_model_cost_map, monkeypatch, config, model ): monkeypatch.setattr(litellm, "drop_params", False) @@ -3567,6 +3569,33 @@ class TestMalformedParamsFollowDropParams: assert kept["reasoning"] == declared assert sent["reasoning"] == malformed + def test_an_openai_model_outside_the_catalog_keeps_reasoning_keys_openai_does_not_define( + self, local_model_cost_map, monkeypatch + ): + monkeypatch.setattr(litellm, "drop_params", False) + server_keys: Final = {"max_tokens": 2000, "exclude": True} + requested: Final = {"effort": "high", "mode": "turbo", "context": "forever", "summary": "sometimes", **server_keys} + + dropped: Final = OpenAIResponsesAPIConfig().map_openai_params( + {"reasoning": dict(requested)}, "my-org/qwen3-32b", True + ) + + assert dropped["reasoning"] == {"effort": "high", **server_keys} + + def test_a_reasoning_mode_a_reloaded_cost_map_declares_is_kept_on_azure(self, local_model_cost_map): + row: Final = litellm.model_cost["gpt-6.1-sol"] + new_mode: Final = "-".join(row["reasoning_modes"]) + "-next" + request: Final = {"reasoning": {"effort": "high", "mode": new_mode}} + + before_reload: Final = AzureOpenAIResponsesAPIConfig().map_openai_params(dict(request), "gpt-6.1-sol", True) + adopt_model_cost_map( + {**litellm.model_cost, "gpt-6.1-sol": {**row, "reasoning_modes": [*row["reasoning_modes"], new_mode]}} + ) + after_reload: Final = AzureOpenAIResponsesAPIConfig().map_openai_params(dict(request), "gpt-6.1-sol", True) + + assert before_reload["reasoning"] == {"effort": "high"} + assert after_reload == request + @pytest.mark.asyncio async def test_openai_responses_litellm_router_no_metadata(): diff --git a/tests/unit/responses/test_responses_utils.py b/tests/unit/responses/test_responses_utils.py index a9db0127ca6..b4c67d083c3 100644 --- a/tests/unit/responses/test_responses_utils.py +++ b/tests/unit/responses/test_responses_utils.py @@ -1039,11 +1039,11 @@ def test_the_chat_bridge_drops_a_reasoning_value_no_openai_row_declares_under_dr assert bridged(True) == {"effort": "high", "summary": "auto"} assert bridged(False) == requested -def test_the_chat_bridge_drops_a_reasoning_value_no_openai_row_declares_outside_the_openai_catalog( +def test_the_chat_bridge_outside_the_openai_catalog_drops_undeclared_values_and_keeps_other_keys( local_model_cost_map, ): declared_mode: Final = litellm.model_cost["gpt-6.1-sol"]["reasoning_modes"][-1] - requested: Final = {"effort": "high", "mode": declared_mode, "context": "forever", "generate_summary": "auto"} + requested: Final = {"effort": "high", "mode": declared_mode, "context": "forever", "max_tokens": 2000} def bridged(drop_params: bool) -> object: return openai_bridge_reasoning( @@ -1055,7 +1055,7 @@ def test_the_chat_bridge_drops_a_reasoning_value_no_openai_row_declares_outside_ additional_drop_params=None, ) - assert bridged(True) == {"effort": "high", "mode": declared_mode} + assert bridged(True) == {"effort": "high", "mode": declared_mode, "max_tokens": 2000} assert bridged(False) == requested