fix(proxy/hooks): populate llm_provider on internal rate-limit errors

[mateo-berri]

Problem

From the Slack thread that motivated #27687:

The provider field is missing when a request fails due to a LiteLLM rate limit error. It looks like the exception is thrown in pre_call_hook before litellm.get_llm_provider is invoked. Is this by design, or a bug?

It's a bug. Every internal rate-limit hook (parallel_request_limiter, dynamic_rate_limiter, batch_rate_limiter, max_budget_limiter, max_iterations_limiter, max_budget_per_session_limiter, plus the v3 variants) raises its 429 from inside async_pre_call_hook before litellm.get_llm_provider runs anywhere in the request lifecycle. The Prometheus failure metric, the StandardLoggingPayload, and the raised exception itself all carry no provider info — making it impossible to slice litellm-side rate-limit metrics by provider.

This is a follow-up to #27687, which standardized the rate-limit error class but kept llm_provider hardcoded to "litellm_proxy" on the proxy-side raise sites.

Fix

Resolve the LLM provider from the request's model (data["model"]) at every limiter raise site via litellm.get_llm_provider(...). If the model is unknown / unparseable, fall back to "litellm_proxy" so a malformed model value never breaks the request path with a new exception masquerading as the original 429.

The resolved provider attaches to the raised exception's .llm_provider attribute. The Prometheus failure metric reads provider via _get_exception_class_name(exc) → exception.llm_provider, so the label flips from the legacy "HTTPException" (or "Litellm_proxy.ProxyHTTPRateLimitError") to "Openai.ProxyHTTPRateLimitError" / "Bedrock.ProxyHTTPRateLimitError" etc. automatically — no Prometheus-side plumbing needed.

Limiters updated

File	Raise sites
parallel_request_limiter.py	3 (RPM / TPM / max_parallel)
parallel_request_limiter_v3.py	2 (pre-check + TPM atomic-reservation)
dynamic_rate_limiter.py	2
dynamic_rate_limiter_v3.py	3 (saturation, priority, fail-closed)
batch_rate_limiter.py	1
max_budget_limiter.py	1
max_iterations_limiter.py	1
max_budget_per_session_limiter.py	1

A new litellm/proxy/hooks/rate_limiter_utils.py module hosts:

• resolve_llm_provider_for_rate_limit(model) — defensive wrapper around get_llm_provider. Returns "litellm_proxy" on any failure (including missing/empty model).
• ProxyHTTPRateLimitError — local 429 helper that carries model + llm_provider.

Naming note (deliberate)

The new class is ProxyHTTPRateLimitError, not ProxyRateLimitError, to avoid colliding with the same-named class introduced in #27687. The two PRs are kept independently mergeable. When both land, the natural follow-up is to consolidate them into a single class — the tests pin endswith("ProxyHTTPRateLimitError") rather than the full string so the rename is a low-friction follow-up.

Before / after

# Before (label snippet from trho's Prometheus output, edited)
litellm_proxy_failed_requests_metric_total{
  exception_class="HTTPException",
  exception_status="429",
  requested_model="gpt-4o-mini",
  ...
} 1.0

# After
litellm_proxy_failed_requests_metric_total{
  exception_class="Openai.ProxyHTTPRateLimitError",
  exception_status="429",
  requested_model="gpt-4o-mini",
  ...
} 1.0

Tests

tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py — 35 tests covering:

• Each limiter, when tripped, raises a RateLimitError whose model and llm_provider match what litellm.get_llm_provider returns for the requested model.
• Fallback path: when data["model"] is missing, None, or unparseable, llm_provider == "litellm_proxy" and no second exception leaks.
• Resolver helper unit tests across openai / anthropic / bedrock / vertex / unknown / empty / malformed inputs.

$ uv run pytest tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py -x -vv
... 35 passed in 2.64s

$ uv run pytest tests/test_litellm/proxy/hooks/ -x -q
... 219 passed, 1 skipped in 7.18s

$ uv run pytest tests/test_litellm/proxy/ -k 'rate_limit or budget' -x -q
... 373 passed, 1 skipped in 17.35s

uv run black / uv run ruff check clean on touched files.

Out of scope

• The model_id Prometheus label still reads from litellm_params.model_info.id, which is router-side and only populated after dispatch. Internal rate-limit errors fire pre-dispatch so model_id stays "None" — fixing that is a separate router/metadata-plumbing change.
• Rename consolidation with feat: standardize rate limit errors with category, rate_limit_type, model, and llm_provider fields #27687's ProxyRateLimitError (intentional, see above).

Slack Thread

  

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[CLAassistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you all sign our Contributor License Agreement before we can accept your contribution.
1 out of 2 committers have signed the CLA.

✅ mateo-berri
❌ cursoragent
_{You have signed the CLA already but the status is still pending? Let us recheck it.}

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

Autofix Details

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Missing attributes cause AttributeError when stringifying exception
  • Initialized self.num_retries and self.max_retries to None in ProxyHTTPRateLimitError.__init__ so that RateLimitError.__str__ (resolved via MRO) no longer raises AttributeError when the exception is stringified.

Preview (af811ec81e)

diff --git a/litellm/proxy/hooks/batch_rate_limiter.py b/litellm/proxy/hooks/batch_rate_limiter.py
--- a/litellm/proxy/hooks/batch_rate_limiter.py
+++ b/litellm/proxy/hooks/batch_rate_limiter.py
@@ -31,6 +31,10 @@
 )
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 
 if TYPE_CHECKING:
     from opentelemetry.trace import Span as _Span
@@ -104,6 +108,7 @@
         descriptors: List["RateLimitDescriptor"],
         batch_usage: BatchFileUsage,
         limit_type: str,
+        requested_model: Optional[str] = None,
     ) -> None:
         """Raise HTTPException for rate limit exceeded."""
         from datetime import datetime
@@ -148,7 +153,10 @@
                 f"Limit resets at: {reset_time_formatted}"
             )
 
-        raise HTTPException(
+        resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+            requested_model
+        )
+        raise ProxyHTTPRateLimitError(
             status_code=429,
             detail=detail,
             headers={
@@ -156,6 +164,8 @@
                 "rate_limit_type": limit_type,
                 "reset_at": reset_time_formatted,
             },
+            model=resolved_model,
+            llm_provider=llm_provider,
         )
 
     async def _check_and_increment_batch_counters(
@@ -197,6 +207,7 @@
         )
 
         if rate_limit_response["overall_code"] == "OVER_LIMIT":
+            requested_model = data.get("model") if data else None
             for status in rate_limit_response["statuses"]:
                 if status["code"] == "OVER_LIMIT":
                     self._raise_rate_limit_error(
@@ -204,6 +215,7 @@
                         descriptors,
                         batch_usage,
                         status["rate_limit_type"],
+                        requested_model=requested_model,
                     )
 
     async def count_input_file_usage(

diff --git a/litellm/proxy/hooks/dynamic_rate_limiter.py b/litellm/proxy/hooks/dynamic_rate_limiter.py
--- a/litellm/proxy/hooks/dynamic_rate_limiter.py
+++ b/litellm/proxy/hooks/dynamic_rate_limiter.py
@@ -6,21 +6,22 @@
 import os
 from typing import List, Optional, Tuple, Union
 
-from fastapi import HTTPException
-
 import litellm
 from litellm import ModelResponse, Router
 from litellm._logging import verbose_proxy_logger
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    convert_priority_to_percent,
+    resolve_llm_provider_for_rate_limit,
+)
 from litellm.types.router import ModelGroupInfo
 from litellm.types.utils import CallTypesLiteral
 from litellm.utils import get_utc_datetime
 
-from .rate_limiter_utils import convert_priority_to_percent
 
-
 class DynamicRateLimiterCache:
     """
     Thin wrapper on DualCache for this file.
@@ -218,7 +219,10 @@
             )
             ### CHECK TPM ###
             if available_tpm is not None and available_tpm == 0:
-                raise HTTPException(
+                resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                    data.get("model")
+                )
+                raise ProxyHTTPRateLimitError(
                     status_code=429,
                     detail={
                         "error": "Key={} over available TPM={}. Model TPM={}, Active keys={}".format(
@@ -228,10 +232,15 @@
                             active_projects,
                         )
                     },
+                    model=resolved_model,
+                    llm_provider=llm_provider,
                 )
             ### CHECK RPM ###
             elif available_rpm is not None and available_rpm == 0:
-                raise HTTPException(
+                resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                    data.get("model")
+                )
+                raise ProxyHTTPRateLimitError(
                     status_code=429,
                     detail={
                         "error": "Key={} over available RPM={}. Model RPM={}, Active keys={}".format(
@@ -241,6 +250,8 @@
                             active_projects,
                         )
                     },
+                    model=resolved_model,
+                    llm_provider=llm_provider,
                 )
             elif available_rpm is not None or available_tpm is not None:
                 ## UPDATE CACHE WITH ACTIVE PROJECT

diff --git a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py
--- a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py
+++ b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py
@@ -19,7 +19,11 @@
     RateLimitDescriptorRateLimitObject,
     _PROXY_MaxParallelRequestsHandler_v3,
 )
-from litellm.proxy.hooks.rate_limiter_utils import convert_priority_to_percent
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    convert_priority_to_percent,
+    resolve_llm_provider_for_rate_limit,
+)
 from litellm.proxy.utils import InternalUsageCache
 from litellm.types.router import ModelGroupInfo
 from litellm.types.utils import CallTypesLiteral
@@ -487,12 +491,13 @@
         )
 
         if atomic_response["overall_code"] == "OVER_LIMIT":
+            resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(model)
             for status in atomic_response["statuses"]:
                 if status["code"] != "OVER_LIMIT":
                     continue
                 descriptor_key = status["descriptor_key"]
                 if descriptor_key == "model_saturation_check":
-                    raise HTTPException(
+                    raise ProxyHTTPRateLimitError(
                         status_code=429,
                         detail={
                             "error": f"Model capacity reached for {model}. "
@@ -507,13 +512,15 @@
                             "rate_limit_type": str(status["rate_limit_type"]),
                             "x-litellm-priority": priority or "default",
                         },
+                        model=resolved_model,
+                        llm_provider=llm_provider,
                     )
                 if descriptor_key == "priority_model":
                     verbose_proxy_logger.debug(
                         f"Enforcing priority limits for {model}, saturation: {saturation:.1%}, "
                         f"priority: {priority}"
                     )
-                    raise HTTPException(
+                    raise ProxyHTTPRateLimitError(
                         status_code=429,
                         detail={
                             "error": f"Priority-based rate limit exceeded. "
@@ -531,6 +538,8 @@
                             "x-litellm-priority": priority or "default",
                             "x-litellm-saturation": f"{saturation:.2%}",
                         },
+                        model=resolved_model,
+                        llm_provider=llm_provider,
                     )
 
             # Fail-closed guard: overall_code says OVER_LIMIT but no status
@@ -547,7 +556,7 @@
                 f"Dynamic rate limiter: OVER_LIMIT response with unknown "
                 f"descriptor_key(s) — refusing request. response={atomic_response}"
             )
-            raise HTTPException(
+            raise ProxyHTTPRateLimitError(
                 status_code=429,
                 detail={
                     "error": "Rate limit exceeded",
@@ -562,6 +571,8 @@
                     "retry-after": str(self.v3_limiter.window_size),
                     "x-litellm-priority": priority or "default",
                 },
+                model=resolved_model,
+                llm_provider=llm_provider,
             )
 
         # If priority is NOT enforced (saturation below threshold) but

diff --git a/litellm/proxy/hooks/max_budget_limiter.py b/litellm/proxy/hooks/max_budget_limiter.py
--- a/litellm/proxy/hooks/max_budget_limiter.py
+++ b/litellm/proxy/hooks/max_budget_limiter.py
@@ -5,6 +5,10 @@
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 
 
 class _PROXY_MaxBudgetLimiter(CustomLogger):
@@ -63,7 +67,15 @@
 
             # CHECK IF REQUEST ALLOWED
             if curr_spend >= max_budget:
-                raise HTTPException(status_code=429, detail="Max budget limit reached.")
+                resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                    data.get("model") if data else None
+                )
+                raise ProxyHTTPRateLimitError(
+                    status_code=429,
+                    detail="Max budget limit reached.",
+                    model=resolved_model,
+                    llm_provider=llm_provider,
+                )
         except HTTPException as e:
             raise e
         except Exception as e:

diff --git a/litellm/proxy/hooks/max_budget_per_session_limiter.py b/litellm/proxy/hooks/max_budget_per_session_limiter.py
--- a/litellm/proxy/hooks/max_budget_per_session_limiter.py
+++ b/litellm/proxy/hooks/max_budget_per_session_limiter.py
@@ -17,12 +17,14 @@
 import os
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from fastapi import HTTPException
-
 from litellm import DualCache
 from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 
 if TYPE_CHECKING:
     from litellm.proxy.utils import InternalUsageCache as _InternalUsageCache
@@ -112,13 +114,18 @@
         )
 
         if current_spend >= max_budget:
-            raise HTTPException(
+            resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                data.get("model") if data else None
+            )
+            raise ProxyHTTPRateLimitError(
                 status_code=429,
                 detail=(
                     f"Session budget exceeded for session {session_id}. "
                     f"Current spend: ${current_spend:.4f}, "
                     f"max_budget_per_session: ${max_budget:.2f}."
                 ),
+                model=resolved_model,
+                llm_provider=llm_provider,
             )
 
         return None

diff --git a/litellm/proxy/hooks/max_iterations_limiter.py b/litellm/proxy/hooks/max_iterations_limiter.py
--- a/litellm/proxy/hooks/max_iterations_limiter.py
+++ b/litellm/proxy/hooks/max_iterations_limiter.py
@@ -13,12 +13,14 @@
 import os
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from fastapi import HTTPException
-
 from litellm import DualCache
 from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 
 if TYPE_CHECKING:
     from litellm.proxy.utils import InternalUsageCache as _InternalUsageCache
@@ -116,12 +118,17 @@
         current_count = await self._increment_and_get(cache_key)
 
         if current_count > max_iterations:
-            raise HTTPException(
+            resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                data.get("model") if data else None
+            )
+            raise ProxyHTTPRateLimitError(
                 status_code=429,
                 detail=(
                     f"Max iterations exceeded for session {session_id}. "
                     f"Current count: {current_count}, max_iterations: {max_iterations}."
                 ),
+                model=resolved_model,
+                llm_provider=llm_provider,
             )
 
         verbose_proxy_logger.debug(

diff --git a/litellm/proxy/hooks/parallel_request_limiter.py b/litellm/proxy/hooks/parallel_request_limiter.py
--- a/litellm/proxy/hooks/parallel_request_limiter.py
+++ b/litellm/proxy/hooks/parallel_request_limiter.py
@@ -17,6 +17,10 @@
     get_key_model_rpm_limit,
     get_key_model_tpm_limit,
 )
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 
 if TYPE_CHECKING:
     from opentelemetry.trace import Span as _Span
@@ -73,7 +77,8 @@
             if max_parallel_requests == 0 or tpm_limit == 0 or rpm_limit == 0:
                 # base case
                 raise self.raise_rate_limit_error(
-                    additional_details=f"{CommonProxyErrors.max_parallel_request_limit_reached.value}. Hit limit for {rate_limit_type}. Current limits: max_parallel_requests: {max_parallel_requests}, tpm_limit: {tpm_limit}, rpm_limit: {rpm_limit}"
+                    additional_details=f"{CommonProxyErrors.max_parallel_request_limit_reached.value}. Hit limit for {rate_limit_type}. Current limits: max_parallel_requests: {max_parallel_requests}, tpm_limit: {tpm_limit}, rpm_limit: {rpm_limit}",
+                    requested_model=data.get("model") if data else None,
                 )
             new_val = {
                 "current_requests": 1,
@@ -95,10 +100,16 @@
             values_to_update_in_cache.append((request_count_api_key, new_val))
 
         else:
-            raise HTTPException(
+            requested_model = data.get("model") if data else None
+            resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                requested_model
+            )
+            raise ProxyHTTPRateLimitError(
                 status_code=429,
                 detail=f"LiteLLM Rate Limit Handler for rate limit type = {rate_limit_type}. {CommonProxyErrors.max_parallel_request_limit_reached.value}. current rpm: {current['current_rpm']}, rpm limit: {rpm_limit}, current tpm: {current['current_tpm']}, tpm limit: {tpm_limit}, current max_parallel_requests: {current['current_requests']}, max_parallel_requests: {max_parallel_requests}",
                 headers={"retry-after": str(self.time_to_next_minute())},
+                model=resolved_model,
+                llm_provider=llm_provider,
             )
 
         await self.internal_usage_cache.async_batch_set_cache(
@@ -122,18 +133,31 @@
         return seconds_to_next_minute
 
     def raise_rate_limit_error(
-        self, additional_details: Optional[str] = None
+        self,
+        additional_details: Optional[str] = None,
+        requested_model: Optional[str] = None,
     ) -> HTTPException:
         """
-        Raise an HTTPException with a 429 status code and a retry-after header
+        Raise an HTTPException with a 429 status code and a retry-after header.
+
+        ``requested_model`` is resolved via :func:`get_llm_provider` so the
+        raised exception carries ``llm_provider`` for downstream loggers
+        (Prometheus failure metric, observability callbacks). Falls back to
+        ``llm_provider="litellm_proxy"`` when the model is missing or
+        unparseable — see ``resolve_llm_provider_for_rate_limit``.
         """
         error_message = "Max parallel request limit reached"
         if additional_details is not None:
             error_message = error_message + " " + additional_details
-        raise HTTPException(
+        resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+            requested_model
+        )
+        raise ProxyHTTPRateLimitError(
             status_code=429,
-            detail=f"Max parallel request limit reached {additional_details}",
+            detail=error_message,
             headers={"retry-after": str(self.time_to_next_minute())},
+            model=resolved_model,
+            llm_provider=llm_provider,
         )
 
     async def get_all_cache_objects(
@@ -225,7 +249,8 @@
             # if above -> raise error
             if current_global_requests >= global_max_parallel_requests:
                 return self.raise_rate_limit_error(
-                    additional_details=f"Hit Global Limit: Limit={global_max_parallel_requests}, current: {current_global_requests}"
+                    additional_details=f"Hit Global Limit: Limit={global_max_parallel_requests}, current: {current_global_requests}",
+                    requested_model=data.get("model") if data else None,
                 )
             # if below -> increment
             else:

diff --git a/litellm/proxy/hooks/parallel_request_limiter_v3.py b/litellm/proxy/hooks/parallel_request_limiter_v3.py
--- a/litellm/proxy/hooks/parallel_request_limiter_v3.py
+++ b/litellm/proxy/hooks/parallel_request_limiter_v3.py
@@ -23,8 +23,6 @@
     cast,
 )
 
-from fastapi import HTTPException
-
 from litellm import DualCache
 from litellm._logging import verbose_proxy_logger
 from litellm.constants import DYNAMIC_RATE_LIMIT_ERROR_THRESHOLD_PER_MINUTE
@@ -34,6 +32,10 @@
 )
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.proxy.auth.auth_utils import get_model_rate_limit_from_metadata
+from litellm.proxy.hooks.rate_limiter_utils import (
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
 from litellm.types.caching import RedisPipelineIncrementOperation
 from litellm.types.llms.openai import BaseLiteLLMOpenAIResponseObject
 from litellm.types.utils import ModelResponse, Usage
@@ -1837,6 +1839,7 @@
         self,
         response: RateLimitResponse,
         descriptors: List[RateLimitDescriptor],
+        requested_model: Optional[str] = None,
     ) -> None:
         """Handle rate limit exceeded error by raising HTTPException."""
         for status in response["statuses"]:
@@ -1869,7 +1872,10 @@
                     f"Limit resets at: {reset_time_formatted}"
                 )
 
-                raise HTTPException(
+                resolved_model, llm_provider = resolve_llm_provider_for_rate_limit(
+                    requested_model
+                )
+                raise ProxyHTTPRateLimitError(
                     status_code=429,
                     detail=detail,
                     headers={
@@ -1877,6 +1883,8 @@
                         "rate_limit_type": str(status["rate_limit_type"]),
                         "reset_at": reset_time_formatted,
                     },
+                    model=resolved_model,
+                    llm_provider=llm_provider,
                 )
 
     async def async_pre_call_hook(
@@ -1977,6 +1985,7 @@
                 self._handle_rate_limit_error(
                     response=response,
                     descriptors=descriptors,
+                    requested_model=requested_model,
                 )
             else:
                 # add descriptors to request headers
@@ -2022,6 +2031,7 @@
                     self._handle_rate_limit_error(
                         response=tpm_response,
                         descriptors=descriptors,
+                        requested_model=requested_model,
                     )
                 else:
                     data["_litellm_rate_limit_descriptors"] = descriptors

diff --git a/litellm/proxy/hooks/rate_limiter_utils.py b/litellm/proxy/hooks/rate_limiter_utils.py
--- a/litellm/proxy/hooks/rate_limiter_utils.py
+++ b/litellm/proxy/hooks/rate_limiter_utils.py
@@ -2,12 +2,106 @@
 Shared utility functions for rate limiter hooks.
 """
 
-from typing import Optional, Union
+from typing import Any, Optional, Tuple, Union
 
+from fastapi import HTTPException
+
+import litellm
+from litellm._logging import verbose_proxy_logger
+from litellm.exceptions import RateLimitError
 from litellm.types.router import ModelGroupInfo
 from litellm.types.utils import PriorityReservationDict
 
+PROXY_LLM_PROVIDER_FALLBACK = "litellm_proxy"
 
+
+def resolve_llm_provider_for_rate_limit(
+    model: Optional[str],
+) -> Tuple[str, str]:
+    """
+    Resolve ``(model, llm_provider)`` for a request being rejected by an
+    internal proxy-side rate-limit hook.
+
+    These hooks fire from ``async_pre_call_hook`` — well before
+    :func:`litellm.get_llm_provider` is invoked anywhere else in the request
+    lifecycle — so the raised 429 would otherwise have an empty
+    ``llm_provider`` field, making the resulting Prometheus
+    ``litellm_proxy_failed_requests_metric`` show up with
+    ``exception_class="RateLimitError"`` and no provider attribution.
+
+    Wrapped defensively: if ``model`` is missing, malformed, or
+    ``get_llm_provider`` raises (unknown alias, router-only model, etc.) we
+    fall back to ``("", "litellm_proxy")`` so we never break the request path
+    by piling a second exception on top of the rate-limit one we're trying to
+    raise.
+    """
+    if not model:
+        return "", PROXY_LLM_PROVIDER_FALLBACK
+    try:
+        resolved_model, custom_llm_provider, _, _ = litellm.get_llm_provider(
+            model=model,
+        )
+        return (
+            resolved_model or model,
+            custom_llm_provider or PROXY_LLM_PROVIDER_FALLBACK,
+        )
+    except Exception as e:
+        verbose_proxy_logger.debug(
+            "rate_limiter_utils.resolve_llm_provider_for_rate_limit: "
+            "could not resolve provider for model=%s, falling back to %s. err=%s",
+            model,
+            PROXY_LLM_PROVIDER_FALLBACK,
+            str(e),
+        )
+        return model, PROXY_LLM_PROVIDER_FALLBACK
+
+
+class ProxyHTTPRateLimitError(HTTPException, RateLimitError):
+    """
+    HTTPException raised by proxy-side rate-limit hooks that *also* exposes
+    ``model`` and ``llm_provider`` attributes.
+
+    Why both base classes:
+
+    - The proxy server's exception handler keys off ``HTTPException`` to render
+      a 429 response, so we must remain an ``HTTPException``.
+    - Downstream loggers (Prometheus ``async_post_call_failure_hook``,
+      structured logging, observability callbacks) read ``exception.llm_provider``
+      via :meth:`litellm.integrations.prometheus.PrometheusLogger._get_exception_class_name`
+      and ``isinstance(exc, RateLimitError)`` for category routing. Inheriting
+      from :class:`litellm.exceptions.RateLimitError` keeps that wiring intact.
+
+    We intentionally do not call ``RateLimitError.__init__`` (which constructs
+    an httpx.Response) — it isn't needed here and just adds failure surface.
+    Attribute parity is what downstream consumers rely on.
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any = None,
+        headers: Optional[dict] = None,
+        *,
+        model: str = "",
+        llm_provider: str = PROXY_LLM_PROVIDER_FALLBACK,
+    ) -> None:
+        HTTPException.__init__(
+            self, status_code=status_code, detail=detail, headers=headers
+        )
+        self.status_code = status_code
+        self.model = model or ""
+        self.llm_provider = llm_provider or PROXY_LLM_PROVIDER_FALLBACK
+        # `message` is what RateLimitError.__str__ would print and what some
+        # observability callbacks log. Keep it human-readable.
+        self.message = detail if isinstance(detail, str) else str(detail)
+        # `RateLimitError.__str__` (resolved via MRO since Starlette's
+        # HTTPException doesn't define `__str__`) unconditionally reads
+        # these attributes. Set them so `str(exc)` doesn't raise
+        # AttributeError from logging/traceback paths.
+        self.num_retries: Optional[int] = None
+        self.max_retries: Optional[int] = None
+
+
 def convert_priority_to_percent(
     value: Union[float, PriorityReservationDict], model_info: Optional[ModelGroupInfo]
 ) -> float:

diff --git a/tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py b/tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py
new file mode 100644
--- /dev/null
+++ b/tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py
@@ -1,0 +1,968 @@
+"""
+Regression tests for the "provider field missing" bug on proxy-side
+rate-limit errors.
+
+Background
+----------
+The proxy's internal rate-limit hooks (parallel_request_limiter,
+parallel_request_limiter_v3, dynamic_rate_limiter, dynamic_rate_limiter_v3,
+batch_rate_limiter, max_budget_limiter, max_iterations_limiter,
+max_budget_per_session_limiter) all fire from ``async_pre_call_hook`` —
+*before* :func:`litellm.get_llm_provider` runs anywhere else in the request
+lifecycle.
+
+Until now, those hooks raised a bare ``HTTPException(429, ...)`` which carries
+no ``llm_provider`` / ``model`` attribute. Downstream:
+
+- The Prometheus ``litellm_proxy_failed_requests_metric`` reads
+  ``exception.llm_provider`` via ``_get_exception_class_name`` — it came back
+  empty, so dashboards showed ``exception_class="HTTPException"`` with no
+  provider attribution.
+- Observability callbacks that ``isinstance(e, RateLimitError)`` for
+  category routing missed these entirely.
+
+The fix wraps every internal raise site in
+:class:`ProxyHTTPRateLimitError` (an ``HTTPException`` *and* a
+``litellm.RateLimitError``), and resolves ``model`` / ``llm_provider`` from
+``data["model"]`` via :func:`get_llm_provider`. When the model is missing or
+unparseable we fall back to ``llm_provider="litellm_proxy"`` so we never break
+the request path with a second exception.
+
+These tests pin both the happy path (provider correctly resolved) and the
+fallback path (unknown model, missing model) for every limiter.
+"""
+
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import HTTPException
+
+import litellm
+from litellm.caching.caching import DualCache
+from litellm.exceptions import RateLimitError
+from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy.hooks.batch_rate_limiter import (
+    BatchFileUsage,
+    _PROXY_BatchRateLimiter,
+)
+from litellm.proxy.hooks.dynamic_rate_limiter import _PROXY_DynamicRateLimitHandler
+from litellm.proxy.hooks.dynamic_rate_limiter_v3 import (
+    _PROXY_DynamicRateLimitHandlerV3,
+)
+from litellm.proxy.hooks.max_budget_limiter import _PROXY_MaxBudgetLimiter
+from litellm.proxy.hooks.max_budget_per_session_limiter import (
+    _PROXY_MaxBudgetPerSessionHandler,
+)
+from litellm.proxy.hooks.max_iterations_limiter import _PROXY_MaxIterationsHandler
+from litellm.proxy.hooks.parallel_request_limiter import (
+    _PROXY_MaxParallelRequestsHandler,
+)
+from litellm.proxy.hooks.parallel_request_limiter_v3 import (
+    _PROXY_MaxParallelRequestsHandler_v3,
+)
+from litellm.proxy.hooks.rate_limiter_utils import (
+    PROXY_LLM_PROVIDER_FALLBACK,
+    ProxyHTTPRateLimitError,
+    resolve_llm_provider_for_rate_limit,
+)
+from litellm.proxy.utils import InternalUsageCache
+from litellm.types.agents import AgentResponse
+
+
+# ---------------------------------------------------------------------------
+# Helper class itself
+# ---------------------------------------------------------------------------
+
+
+class TestProxyHTTPRateLimitErrorClass:
+    """Pin the dual ``HTTPException`` + ``RateLimitError`` shape."""
+
+    def test_is_both_http_exception_and_rate_limit_error(self):
+        e = ProxyHTTPRateLimitError(
+            status_code=429,
+            detail="boom",
+            model="gpt-4o-mini",
+            llm_provider="openai",
+        )
+        # FastAPI handler keys off HTTPException to render the 429.
+        assert isinstance(e, HTTPException)
+        # Prometheus / observability key off RateLimitError + .llm_provider.
+        assert isinstance(e, RateLimitError)
+        assert e.status_code == 429
+        assert e.model == "gpt-4o-mini"
+        assert e.llm_provider == "openai"
+        assert e.message == "boom"
+        assert e.detail == "boom"
+
+    def test_dict_detail_is_stringified_for_message(self):
+        # Some hooks pass a dict detail (e.g. dynamic_rate_limiter v1) — the
+        # `message` attr (read by RateLimitError.__str__ and observability
+        # callbacks) must still be a string.
+        e = ProxyHTTPRateLimitError(
+            status_code=429,
+            detail={"error": "over rpm"},
+            model="claude-3-5-sonnet",
+            llm_provider="anthropic",
+        )
+        assert isinstance(e.message, str)
+        assert "over rpm" in e.message
+
+    def test_defaults_to_litellm_proxy_provider(self):
+        e = ProxyHTTPRateLimitError(status_code=429, detail="x")
+        assert e.llm_provider == PROXY_LLM_PROVIDER_FALLBACK
+        assert e.model == ""
+
+    def test_none_provider_normalized_to_fallback(self):
+        e = ProxyHTTPRateLimitError(
+            status_code=429,
+            detail="x",
+            model=None,  # type: ignore[arg-type]
+            llm_provider=None,  # type: ignore[arg-type]
+        )
+        assert e.llm_provider == PROXY_LLM_PROVIDER_FALLBACK
+        assert e.model == ""
+
+
+class TestResolveLLMProviderForRateLimit:
+    @pytest.mark.parametrize(
+        "model, expected_provider",
+        [
+            ("gpt-4o-mini", "openai"),
+            ("anthropic/claude-3-5-sonnet", "anthropic"),
+            ("bedrock/meta.llama3-1-70b-instruct-v1:0", "bedrock"),
+        ],
+    )
+    def test_known_models_resolve_provider(self, model, expected_provider):
+        resolved_model, provider = resolve_llm_provider_for_rate_limit(model)
+        assert provider == expected_provider
+        assert resolved_model  # non-empty
+
+    @pytest.mark.parametrize("model", [None, "", "totally-not-a-real-model-name"])
+    def test_missing_or_unknown_model_falls_back(self, model):
+        # Must never raise — the resolver wraps `get_llm_provider` defensively
+        # because raising here would mask the rate-limit error we're trying
+        # to surface to the user.
+        resolved_model, provider = resolve_llm_provider_for_rate_limit(model)
+        assert provider == PROXY_LLM_PROVIDER_FALLBACK
+        # Resolver returns the input model verbatim on the unknown branch so
+        # the `.model` attribute is never silently swapped to a different one.
+        if not model:
+            assert resolved_model == ""
+        else:
+            assert resolved_model == model
+
+    def test_get_llm_provider_raising_is_swallowed(self):
+        # If get_llm_provider itself blows up (unexpected error), we still
+        # fall back rather than letting the secondary exception escape.
+        with patch.object(
+            litellm,
+            "get_llm_provider",
+            side_effect=RuntimeError("boom"),
+        ):
+            resolved_model, provider = resolve_llm_provider_for_rate_limit("anything")
+        assert provider == PROXY_LLM_PROVIDER_FALLBACK
+        assert resolved_model == "anything"
+
+
+# ---------------------------------------------------------------------------
+# parallel_request_limiter v1
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_parallel_request_limiter_v1_populates_provider_when_at_rpm_limit():
+    """
+    Trip the per-key RPM cap and assert the raised exception carries
+    ``model`` / ``llm_provider`` resolved from ``data["model"]``.
+    """
+    handler = _PROXY_MaxParallelRequestsHandler(
+        internal_usage_cache=InternalUsageCache(DualCache())
+    )
+    user_api_key_dict = UserAPIKeyAuth(
+        api_key="sk-rl-test",
+        max_parallel_requests=10,
+        rpm_limit=1,
+        tpm_limit=10,
+    )
+    data = {"model": "gpt-4o-mini"}
+
+    # First request consumes the budget.
+    await handler.async_pre_call_hook(
+        user_api_key_dict=user_api_key_dict,
+        cache=DualCache(),
+        data=data,
+        call_type="completion",
+    )
+
+    with pytest.raises(HTTPException) as exc_info:
+        await handler.async_pre_call_hook(
+            user_api_key_dict=user_api_key_dict,
+            cache=DualCache(),
+            data=data,
+            call_type="completion",
+        )
+
+    exc = exc_info.value
+    assert exc.status_code == 429
... diff truncated: showing 800 of 1561 lines

_{You can send follow-ups to the cloud agent here.}

[greptile-apps]

Greptile Summary

This PR fixes a missing llm_provider field on proxy-side rate-limit 429 errors by resolving the provider from data["model"] at every internal limiter raise site before the exception is raised. A new ProxyHTTPRateLimitError class (dual-inheriting HTTPException + RateLimitError) is introduced in rate_limiter_utils.py to carry both fields, and 35 regression tests cover happy-path and fallback cases for all 8 limiters.

• rate_limiter_utils.py gains resolve_llm_provider_for_rate_limit (a defensive wrapper around litellm.get_llm_provider that falls back to \"litellm_proxy\" on any failure) and ProxyHTTPRateLimitError.
• All 8 limiter files replace their bare HTTPException(429, ...) raises with ProxyHTTPRateLimitError, threading model/llm_provider through each raise site.
• A subtle but intentional behavior improvement: raise_rate_limit_error in parallel_request_limiter.py previously produced \"Max parallel request limit reached None\" when additional_details was absent; it now correctly omits the None suffix.

Confidence Score: 5/5

Safe to merge — all changes are additive improvements to error metadata; the defensive fallback ensures a get_llm_provider failure never replaces the 429 with a secondary exception.

Every raise site is wrapped defensively, the new ProxyHTTPRateLimitError correctly sets the attributes required by RateLimitError.str, and the 35 regression tests cover both happy-path provider resolution and the fallback path across all 8 limiters. No existing test assertions are weakened and no hot request path is affected.

No files require special attention.

Important Files Changed

Filename	Overview
litellm/proxy/hooks/rate_limiter_utils.py	New ProxyHTTPRateLimitError class and resolve_llm_provider_for_rate_limit helper; well-documented MRO trade-offs, defensive fallback, and required attributes (message, num_retries, max_retries) all set.
litellm/proxy/hooks/parallel_request_limiter.py	Three raise sites updated to ProxyHTTPRateLimitError; raise_rate_limit_error gains requested_model param and fixes the pre-existing 'None' suffix bug in the detail message.
litellm/proxy/hooks/parallel_request_limiter_v3.py	_handle_rate_limit_error gains optional requested_model; resolve_llm_provider_for_rate_limit is called inside the loop but always raises on the first matching status so only one resolution happens per error path.
litellm/proxy/hooks/dynamic_rate_limiter.py	Two raise sites (TPM and RPM zero-check) updated; fastapi.HTTPException import removed and replaced by import from rate_limiter_utils.
litellm/proxy/hooks/dynamic_rate_limiter_v3.py	Provider resolution moved before the status loop so all three raise sites (saturation, priority, fail-closed) share one resolver call — consistent and correct.
litellm/proxy/hooks/batch_rate_limiter.py	requested_model captured from data before the status loop and threaded through _raise_rate_limit_error; single raise site updated correctly.
litellm/proxy/hooks/max_budget_limiter.py	Single raise site replaced with ProxyHTTPRateLimitError; data.get('model') if data else None guard is consistent with other limiters.
litellm/proxy/hooks/max_budget_per_session_limiter.py	Single raise site updated; fastapi.HTTPException import dropped, replaced by rate_limiter_utils import.
litellm/proxy/hooks/max_iterations_limiter.py	Single raise site updated; same pattern as max_budget_per_session_limiter — clean and consistent.
tests/test_litellm/proxy/hooks/test_proxy_rate_limit_provider_field.py	35 new mock-only tests covering happy-path provider resolution, fallback on unknown/missing model, and Prometheus label format for all 8 limiters; no real network calls.

_{Reviews (2): Last reviewed commit: "fix(mypy): silence base-class status_cod..." | Re-trigger Greptile}

[mateo-berri]

@greptileai

[Sameerlite]

bugbot run

[cursor]

✅ Bugbot reviewed your changes and found no new issues!

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit d00ad1d. Configure here.}

[Sameerlite]

LGTM, thanks