From 577db03ef6e803acf0583aac81cc781c4e4a4bca Mon Sep 17 00:00:00 2001 From: pfolex Date: Sat, 24 Oct 2026 19:55:36 -0400 Subject: [PATCH 1/7] fix(cost_calculator): prevent provider leakage and preserve custom_llm_provider for OpenAI-aliased completions (#48226) --- litellm/cost_calculator.py | 29 ++++++-- .../llms/openai_like/chat/transformation.py | 20 +++++- .../llms/groq/test_groq_cost_calculator.py | 69 +++++++++++++++++++ 3 files changed, 112 insertions(+), 6 deletions(-) diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py index a0da0f6ddca..8d8e83f5edd 100644 --- a/litellm/cost_calculator.py +++ b/litellm/cost_calculator.py @@ -1658,14 +1658,27 @@ def completion_cost( explicit_pricing, ) requested_model: Final = model - request_pricing_provider: Final = custom_llm_provider if isinstance(custom_llm_provider, str) else None + request_pricing_provider: Final = ( + custom_llm_provider + if isinstance(custom_llm_provider, str) + else _get_provider_for_cost_calc(model) + ) raw_candidates: Final = ( ( selected_model, base_model_provider if base_model_provider is not None else request_pricing_provider, ), (_get_response_model(completion_response), request_pricing_provider), - *(((model, request_pricing_provider),) if model is not None else ()), + *( + ( + ( + model, + request_pricing_provider or _get_provider_for_cost_calc(model), + ), + ) + if model is not None + else () + ), ) potential_model_names: Final = ( raw_candidates if custom_pricing is True else _priced_candidates_before_unpriced_rules(raw_candidates) @@ -1673,6 +1686,9 @@ def completion_cost( for idx, (model, candidate_pricing_provider) in enumerate(potential_model_names): try: + candidate_custom_llm_provider: str | None = ( + candidate_pricing_provider or request_pricing_provider + ) if verbose_logger.isEnabledFor(logging.DEBUG): verbose_logger.debug("selected model name for cost calculation: %s", model) @@ -1742,10 +1758,15 @@ def completion_cost( hidden_params = getattr(completion_response, "_hidden_params", None) if hidden_params is not None: - custom_llm_provider = pricing_provider or hidden_params.get( - "custom_llm_provider", custom_llm_provider or None + custom_llm_provider = ( + candidate_pricing_provider + or pricing_provider + or hidden_params.get("custom_llm_provider") + or candidate_custom_llm_provider ) region_name = hidden_params.get("region_name", region_name) + else: + custom_llm_provider = candidate_pricing_provider or candidate_custom_llm_provider else: if model is None: diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index e07b5627256..03bdd623e60 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -122,8 +122,15 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): returned_response: Final = ModelResponse(**response_json) set_provider_response_headers_in_hidden_params(returned_response, response.headers) + if hasattr(model_response, "_hidden_params") and model_response._hidden_params: + for k, v in model_response._hidden_params.items(): + if k not in returned_response._hidden_params: + returned_response._hidden_params[k] = v + if custom_llm_provider is not None: - returned_response.model = custom_llm_provider + "/" + (returned_response.model or "") + returned_response._hidden_params["custom_llm_provider"] = custom_llm_provider + if returned_response.model and not returned_response.model.startswith(f"{custom_llm_provider}/"): + returned_response.model = custom_llm_provider + "/" + returned_response.model if base_model is not None: returned_response.hidden_params["model"] = base_model @@ -143,6 +150,15 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): api_key: str | None = None, json_mode: bool | None = None, ) -> ModelResponse: + resolved_custom_llm_provider = ( + litellm_params.get("custom_llm_provider") + if isinstance(litellm_params, dict) + else None + ) or ( + getattr(model_response, "_hidden_params", {}).get("custom_llm_provider") + if hasattr(model_response, "_hidden_params") and isinstance(getattr(model_response, "_hidden_params"), dict) + else None + ) return OpenAILikeChatConfig._transform_response( model=model, response=raw_response, @@ -156,7 +172,7 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): print_verbose=None, encoding=None, json_mode=json_mode, - custom_llm_provider=None, + custom_llm_provider=resolved_custom_llm_provider, base_model=None, ) diff --git a/tests/unit/llms/groq/test_groq_cost_calculator.py b/tests/unit/llms/groq/test_groq_cost_calculator.py index bc3b8058b7f..0ddee5ed2ec 100644 --- a/tests/unit/llms/groq/test_groq_cost_calculator.py +++ b/tests/unit/llms/groq/test_groq_cost_calculator.py @@ -54,3 +54,72 @@ def test_bills_visit_website_per_open(): def test_bills_searches_and_opens_together(): cost = cost_per_web_search_request(usage=_usage_with_actions(2, opens=3), model_info=PRICED_MODEL_INFO) assert cost == pytest.approx(2 * 0.005 + 3 * 0.001) + + +def test_groq_openai_aliased_completion_cost(): + """Regression test for Issue #48226: completion_cost for Groq models prefixed with openai/.""" + import json + import threading + from http.server import BaseHTTPRequestHandler, HTTPServer + + import litellm + from litellm.types.utils import Choices, Message, ModelResponse + + body = { + "id": "chatcmpl-x", + "object": "chat.completion", + "created": 1761100000, + "model": "openai/gpt-oss-120b", + "choices": [{"index": 0, "finish_reason": "stop", "message": {"role": "assistant", "content": "ok"}}], + "usage": {"prompt_tokens": 77, "completion_tokens": 19, "total_tokens": 96}, + "service_tier": "on_demand", + "system_fingerprint": "fp_x", + "x_groq": {"id": "req_x"}, + } + + class MockHandler(BaseHTTPRequestHandler): + def do_POST(self): + self.rfile.read(int(self.headers.get("content-length", 0))) + data = json.dumps(body).encode() + self.send_response(200) + self.send_header("content-type", "application/json") + self.send_header("content-length", str(len(data))) + self.end_headers() + self.wfile.write(data) + + def log_message(self, *a): + pass + + srv = HTTPServer(("127.0.0.1", 0), MockHandler) + threading.Thread(target=srv.serve_forever, daemon=True).start() + + resp = litellm.completion( + model="groq/openai/gpt-oss-120b", + messages=[{"role": "user", "content": "hi"}], + api_base=f"http://127.0.0.1:{srv.server_port}/openai/v1", + api_key="test", + ) + + assert resp._hidden_params.get("custom_llm_provider") == "groq" + assert resp.model == "groq/openai/gpt-oss-120b" + assert resp._hidden_params.get("response_cost") == pytest.approx(2.295e-05) + + c1 = litellm.completion_cost(completion_response=resp) + assert c1 == pytest.approx(2.295e-05) + + c2 = litellm.completion_cost(completion_response=resp, model="groq/openai/gpt-oss-120b") + assert c2 == pytest.approx(2.295e-05) + + c3 = litellm.completion_cost(completion_response=resp, custom_llm_provider="groq") + assert c3 == pytest.approx(2.295e-05) + + # Raw response without hidden params must also resolve when explicit model is passed + raw_resp = ModelResponse( + id="chatcmpl-x", + model="openai/gpt-oss-120b", + choices=[Choices(message=Message(content="ok", role="assistant"))], + usage=Usage(prompt_tokens=77, completion_tokens=19, total_tokens=96), + ) + c_raw = litellm.completion_cost(completion_response=raw_resp, model="groq/openai/gpt-oss-120b") + assert c_raw == pytest.approx(2.295e-05) + From 491401c7fa699817c6cdb0ddcf4595837e244f00 Mon Sep 17 00:00:00 2001 From: pfolex Date: Sun, 25 Oct 2026 11:00:48 -0400 Subject: [PATCH 2/7] style: format modified files with ruff --- litellm/cost_calculator.py | 8 ++------ litellm/llms/openai_like/chat/transformation.py | 4 +--- tests/unit/llms/groq/test_groq_cost_calculator.py | 1 - 3 files changed, 3 insertions(+), 10 deletions(-) diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py index 8d8e83f5edd..a17c40b3438 100644 --- a/litellm/cost_calculator.py +++ b/litellm/cost_calculator.py @@ -1659,9 +1659,7 @@ def completion_cost( ) requested_model: Final = model request_pricing_provider: Final = ( - custom_llm_provider - if isinstance(custom_llm_provider, str) - else _get_provider_for_cost_calc(model) + custom_llm_provider if isinstance(custom_llm_provider, str) else _get_provider_for_cost_calc(model) ) raw_candidates: Final = ( ( @@ -1686,9 +1684,7 @@ def completion_cost( for idx, (model, candidate_pricing_provider) in enumerate(potential_model_names): try: - candidate_custom_llm_provider: str | None = ( - candidate_pricing_provider or request_pricing_provider - ) + candidate_custom_llm_provider: str | None = candidate_pricing_provider or request_pricing_provider if verbose_logger.isEnabledFor(logging.DEBUG): verbose_logger.debug("selected model name for cost calculation: %s", model) diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index 03bdd623e60..23a47db9947 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -151,9 +151,7 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): json_mode: bool | None = None, ) -> ModelResponse: resolved_custom_llm_provider = ( - litellm_params.get("custom_llm_provider") - if isinstance(litellm_params, dict) - else None + litellm_params.get("custom_llm_provider") if isinstance(litellm_params, dict) else None ) or ( getattr(model_response, "_hidden_params", {}).get("custom_llm_provider") if hasattr(model_response, "_hidden_params") and isinstance(getattr(model_response, "_hidden_params"), dict) diff --git a/tests/unit/llms/groq/test_groq_cost_calculator.py b/tests/unit/llms/groq/test_groq_cost_calculator.py index 0ddee5ed2ec..eab925b53c9 100644 --- a/tests/unit/llms/groq/test_groq_cost_calculator.py +++ b/tests/unit/llms/groq/test_groq_cost_calculator.py @@ -122,4 +122,3 @@ def test_groq_openai_aliased_completion_cost(): ) c_raw = litellm.completion_cost(completion_response=raw_resp, model="groq/openai/gpt-oss-120b") assert c_raw == pytest.approx(2.295e-05) - From 35da226610b806d8b3fb16178abb0a05aa152d3e Mon Sep 17 00:00:00 2001 From: pfolex Date: Wed, 28 Oct 2026 09:51:31 -0400 Subject: [PATCH 3/7] fix(cost_calculator): resolve B009 lint and preserve provider fallback for bare models --- litellm/cost_calculator.py | 8 +++++--- litellm/llms/openai_like/chat/transformation.py | 17 +++++++++++++---- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py index a17c40b3438..36f561e2553 100644 --- a/litellm/cost_calculator.py +++ b/litellm/cost_calculator.py @@ -1757,11 +1757,13 @@ def completion_cost( custom_llm_provider = ( candidate_pricing_provider or pricing_provider - or hidden_params.get("custom_llm_provider") - or candidate_custom_llm_provider + or hidden_params.get( + "custom_llm_provider", + candidate_custom_llm_provider or custom_llm_provider or None, + ) ) region_name = hidden_params.get("region_name", region_name) - else: + elif candidate_pricing_provider or candidate_custom_llm_provider: custom_llm_provider = candidate_pricing_provider or candidate_custom_llm_provider else: diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index 23a47db9947..5a7bd809e4d 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -153,11 +153,11 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): resolved_custom_llm_provider = ( litellm_params.get("custom_llm_provider") if isinstance(litellm_params, dict) else None ) or ( - getattr(model_response, "_hidden_params", {}).get("custom_llm_provider") - if hasattr(model_response, "_hidden_params") and isinstance(getattr(model_response, "_hidden_params"), dict) + model_response._hidden_params.get("custom_llm_provider") + if isinstance(model_response._hidden_params, dict) else None ) - return OpenAILikeChatConfig._transform_response( + transformed_response = OpenAILikeChatConfig._transform_response( model=model, response=raw_response, model_response=model_response, @@ -170,9 +170,18 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): print_verbose=None, encoding=None, json_mode=json_mode, - custom_llm_provider=resolved_custom_llm_provider, + custom_llm_provider=None, base_model=None, ) + if resolved_custom_llm_provider is not None and isinstance(transformed_response._hidden_params, dict): + transformed_response._hidden_params.setdefault("custom_llm_provider", resolved_custom_llm_provider) + if ( + transformed_response.model + and "/" in transformed_response.model + and not transformed_response.model.startswith(f"{resolved_custom_llm_provider}/") + ): + transformed_response.model = f"{resolved_custom_llm_provider}/{transformed_response.model}" + return transformed_response def map_openai_params( self, From c9b1a9772f821db3b02b39a32469732c06602acb Mon Sep 17 00:00:00 2001 From: pfolex Date: Wed, 28 Oct 2026 12:17:14 -0400 Subject: [PATCH 4/7] style(lint): annotate Final bindings (LIT010) and remove extra provider rebind (LIT011) --- litellm/cost_calculator.py | 2 -- litellm/llms/openai_like/chat/transformation.py | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/litellm/cost_calculator.py b/litellm/cost_calculator.py index 36f561e2553..ee25b56143e 100644 --- a/litellm/cost_calculator.py +++ b/litellm/cost_calculator.py @@ -1763,8 +1763,6 @@ def completion_cost( ) ) region_name = hidden_params.get("region_name", region_name) - elif candidate_pricing_provider or candidate_custom_llm_provider: - custom_llm_provider = candidate_pricing_provider or candidate_custom_llm_provider else: if model is None: diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index 5a7bd809e4d..7e6e5f91ee4 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -150,14 +150,14 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): api_key: str | None = None, json_mode: bool | None = None, ) -> ModelResponse: - resolved_custom_llm_provider = ( + resolved_custom_llm_provider: Final = ( litellm_params.get("custom_llm_provider") if isinstance(litellm_params, dict) else None ) or ( model_response._hidden_params.get("custom_llm_provider") if isinstance(model_response._hidden_params, dict) else None ) - transformed_response = OpenAILikeChatConfig._transform_response( + transformed_response: Final = OpenAILikeChatConfig._transform_response( model=model, response=raw_response, model_response=model_response, From 1554fd81b3659a800f26ee937ef6b0cdb6f61d14 Mon Sep 17 00:00:00 2001 From: pfolex Date: Wed, 28 Oct 2026 13:27:19 -0400 Subject: [PATCH 5/7] style(types): use public hidden_params and satisfy basedpyright delta gate --- .../llms/openai_like/chat/transformation.py | 57 +++++++++++-------- 1 file changed, 33 insertions(+), 24 deletions(-) diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index 7e6e5f91ee4..f8467670f3c 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -122,15 +122,31 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): returned_response: Final = ModelResponse(**response_json) set_provider_response_headers_in_hidden_params(returned_response, response.headers) - if hasattr(model_response, "_hidden_params") and model_response._hidden_params: - for k, v in model_response._hidden_params.items(): - if k not in returned_response._hidden_params: - returned_response._hidden_params[k] = v + src_hidden: Final[dict[str, object]] = ( + model_response.hidden_params + ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict + dst_hidden: Final[dict[str, object]] = ( + returned_response.hidden_params + ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict + for k, v in src_hidden.items(): + if k not in dst_hidden: + dst_hidden[k] = v + resolved_provider: Final = custom_llm_provider or ( + src_hidden["custom_llm_provider"] + if "custom_llm_provider" in src_hidden and isinstance(src_hidden["custom_llm_provider"], str) + else None + ) if custom_llm_provider is not None: - returned_response._hidden_params["custom_llm_provider"] = custom_llm_provider - if returned_response.model and not returned_response.model.startswith(f"{custom_llm_provider}/"): - returned_response.model = custom_llm_provider + "/" + returned_response.model + returned_response.model = custom_llm_provider + "/" + (returned_response.model or "") + elif resolved_provider is not None: + dst_hidden["custom_llm_provider"] = resolved_provider + if ( + returned_response.model + and "/" in returned_response.model + and not returned_response.model.startswith(f"{resolved_provider}/") + ): + returned_response.model = f"{resolved_provider}/{returned_response.model}" if base_model is not None: returned_response.hidden_params["model"] = base_model @@ -150,14 +166,16 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): api_key: str | None = None, json_mode: bool | None = None, ) -> ModelResponse: - resolved_custom_llm_provider: Final = ( - litellm_params.get("custom_llm_provider") if isinstance(litellm_params, dict) else None - ) or ( - model_response._hidden_params.get("custom_llm_provider") - if isinstance(model_response._hidden_params, dict) - else None - ) - transformed_response: Final = OpenAILikeChatConfig._transform_response( + if "custom_llm_provider" in litellm_params and isinstance( + litellm_params["custom_llm_provider"], # pyright: ignore[reportUnknownArgumentType] # litellm_params is untyped dict + str, + ): + model_hidden: Final[dict[str, object]] = ( + model_response.hidden_params + ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict + if "custom_llm_provider" not in model_hidden: + model_hidden["custom_llm_provider"] = litellm_params["custom_llm_provider"] # pyright: ignore[reportUnknownArgumentType] # litellm_params is untyped dict + return OpenAILikeChatConfig._transform_response( model=model, response=raw_response, model_response=model_response, @@ -173,15 +191,6 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): custom_llm_provider=None, base_model=None, ) - if resolved_custom_llm_provider is not None and isinstance(transformed_response._hidden_params, dict): - transformed_response._hidden_params.setdefault("custom_llm_provider", resolved_custom_llm_provider) - if ( - transformed_response.model - and "/" in transformed_response.model - and not transformed_response.model.startswith(f"{resolved_custom_llm_provider}/") - ): - transformed_response.model = f"{resolved_custom_llm_provider}/{transformed_response.model}" - return transformed_response def map_openai_params( self, From 0ed318377b680e9b77ead076f7400de6f8390483 Mon Sep 17 00:00:00 2001 From: pfolex Date: Wed, 28 Oct 2026 13:28:06 -0400 Subject: [PATCH 6/7] style(lint): keep mutable-ok annotations on single lines for LIT001 check --- .../llms/openai_like/chat/transformation.py | 30 ++++++++----------- 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index f8467670f3c..89f4139e932 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -122,25 +122,21 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): returned_response: Final = ModelResponse(**response_json) set_provider_response_headers_in_hidden_params(returned_response, response.headers) - src_hidden: Final[dict[str, object]] = ( - model_response.hidden_params - ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict - dst_hidden: Final[dict[str, object]] = ( - returned_response.hidden_params - ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict - for k, v in src_hidden.items(): - if k not in dst_hidden: - dst_hidden[k] = v + sh: Final[dict[str, object]] = model_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped + dh: Final[dict[str, object]] = returned_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped + for k, v in sh.items(): + if k not in dh: + dh[k] = v resolved_provider: Final = custom_llm_provider or ( - src_hidden["custom_llm_provider"] - if "custom_llm_provider" in src_hidden and isinstance(src_hidden["custom_llm_provider"], str) + sh["custom_llm_provider"] + if "custom_llm_provider" in sh and isinstance(sh["custom_llm_provider"], str) else None ) if custom_llm_provider is not None: returned_response.model = custom_llm_provider + "/" + (returned_response.model or "") elif resolved_provider is not None: - dst_hidden["custom_llm_provider"] = resolved_provider + dh["custom_llm_provider"] = resolved_provider if ( returned_response.model and "/" in returned_response.model @@ -167,14 +163,12 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): json_mode: bool | None = None, ) -> ModelResponse: if "custom_llm_provider" in litellm_params and isinstance( - litellm_params["custom_llm_provider"], # pyright: ignore[reportUnknownArgumentType] # litellm_params is untyped dict + litellm_params["custom_llm_provider"], # pyright: ignore[reportUnknownArgumentType] # untyped str, ): - model_hidden: Final[dict[str, object]] = ( - model_response.hidden_params - ) # mutable-ok: ModelResponse.hidden_params is a mutable dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # ModelResponse.hidden_params is untyped dict - if "custom_llm_provider" not in model_hidden: - model_hidden["custom_llm_provider"] = litellm_params["custom_llm_provider"] # pyright: ignore[reportUnknownArgumentType] # litellm_params is untyped dict + mh: Final[dict[str, object]] = model_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped + if "custom_llm_provider" not in mh: + mh["custom_llm_provider"] = litellm_params["custom_llm_provider"] # pyright: ignore[reportUnknownArgumentType] # untyped return OpenAILikeChatConfig._transform_response( model=model, response=raw_response, From 5d0de99c2d037b68a7a9fad2d16441d16b0088d5 Mon Sep 17 00:00:00 2001 From: pfolex Date: Wed, 28 Oct 2026 14:09:53 -0400 Subject: [PATCH 7/7] style(lint): use bare Final for hidden_params aliases to satisfy ruff format and LIT001 --- litellm/llms/openai_like/chat/transformation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/litellm/llms/openai_like/chat/transformation.py b/litellm/llms/openai_like/chat/transformation.py index 89f4139e932..689cba8d8f3 100644 --- a/litellm/llms/openai_like/chat/transformation.py +++ b/litellm/llms/openai_like/chat/transformation.py @@ -122,9 +122,9 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): returned_response: Final = ModelResponse(**response_json) set_provider_response_headers_in_hidden_params(returned_response, response.headers) - sh: Final[dict[str, object]] = model_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped - dh: Final[dict[str, object]] = returned_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped - for k, v in sh.items(): + sh: Final = model_response.hidden_params # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # raw + dh: Final = returned_response.hidden_params # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # raw + for k, v in sh.items(): # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # raw if k not in dh: dh[k] = v @@ -166,7 +166,7 @@ class OpenAILikeChatConfig(OpenAIGPTConfig): litellm_params["custom_llm_provider"], # pyright: ignore[reportUnknownArgumentType] # untyped str, ): - mh: Final[dict[str, object]] = model_response.hidden_params # mutable-ok: dict # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # untyped + mh: Final = model_response.hidden_params # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # raw if "custom_llm_provider" not in mh: mh["custom_llm_provider"] = litellm_params["custom_llm_provider"] # pyright: ignore[reportUnknownArgumentType] # untyped return OpenAILikeChatConfig._transform_response(