From 577db03ef6e803acf0583aac81cc781c4e4a4bca Mon Sep 17 00:00:00 2001 From: pfolex Date: Sat, 24 Oct 2026 19:55:36 -0400 Subject: [PATCH] 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) +