From 7b87ed9181f3e4299408fa7baa8b69a75628b3da Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Fri, 16 Oct 2026 20:27:58 +0530 Subject: [PATCH 1/6] fix(proxy): enforce team member overall budget on fallback targets (#46874) Signed-off-by: AAKASH S S --- litellm/proxy/auth/auth_checks.py | 2 ++ litellm/proxy/auth/fallback_budget.py | 22 ++++++++++++++++--- litellm/proxy/auth/user_api_key_auth.py | 2 ++ litellm/types/proxy/auth/user_api_key_auth.py | 2 ++ tests/unit/proxy/auth/test_fallback_budget.py | 18 +++++++++++++++ 5 files changed, 43 insertions(+), 3 deletions(-) diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 8b32eb450e8..dceef71e068 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -6753,6 +6753,8 @@ async def _check_team_member_budget( ) if team_member_budget is not None: + valid_token.max_budget_in_team = team_member_budget + valid_token.team_member_max_budget = team_member_budget team_member_spend = (loaded_membership.spend if loaded_membership is not None else 0.0) or 0.0 # Read from cross-pod counter (Redis-first) if available diff --git a/litellm/proxy/auth/fallback_budget.py b/litellm/proxy/auth/fallback_budget.py index a126a53821b..0d40c759680 100644 --- a/litellm/proxy/auth/fallback_budget.py +++ b/litellm/proxy/auth/fallback_budget.py @@ -11,9 +11,9 @@ attempted, mirroring `fallback_model_access.py`. It deliberately leaves the prim a zero-cost model is never blocked by budget, and only the paid fallback is refused. On by default; set `general_settings.enforce_fallback_budget: false` to restore the unguarded behaviour. -Scope: the key's and the user's `max_budget`, plus the team member's per-model caps. Not covered yet, -and each needs a read-only evaluation path before it can be: team and team-member overall, end-user, -org, global and other per-model budgets, whose auth-path functions enforce rather than report (they +Scope: the key's and the user's `max_budget`, the team member's overall budget (`max_budget_in_team`), +plus the team member's per-model caps. Not covered yet, and each needs a read-only evaluation path before +it can be: team overall, end-user, org, global and other per-model budgets, whose auth-path functions enforce rather than report (they raise), so reusing them would fire threshold alerts and take spend reservations for a target that is then skipped; and the key's rolling `budget_limits` windows, whose accumulated spend lives only in per-window counters (`spend:key:{token}:window:{budget_duration}`), so enforcing them means more @@ -156,6 +156,22 @@ async def is_token_within_budget_for_model( if user_spend >= user_budget: return False + team_member_budget: Final = getattr(valid_token, "max_budget_in_team", None) or getattr( + valid_token, "team_member_max_budget", None + ) + if ( + team_member_budget is not None + and valid_token.user_id is not None + and valid_token.team_id is not None + ): + team_member_spend: Final = await _counter_spend( + counter_key=f"spend:team_member:{valid_token.user_id}:{valid_token.team_id}", + fallback_spend=valid_token.team_member_spend or 0.0, + max_budget=team_member_budget, + ) + if team_member_spend >= team_member_budget: + return False + team_member_model_max_budget: Final = valid_token.team_member_model_max_budget if ( team_member_model_budget_limiter is not None diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py index a1abed202a2..cd02487d417 100644 --- a/litellm/proxy/auth/user_api_key_auth.py +++ b/litellm/proxy/auth/user_api_key_auth.py @@ -2957,6 +2957,8 @@ async def validate_resolved_virtual_key( # noqa: C901 # Preserve ordering of e now=datetime.now(timezone.utc), ) if team_member_budget is not None and team_member_budget > 0: + valid_token.max_budget_in_team = team_member_budget + valid_token.team_member_max_budget = team_member_budget # Read from cross-pod counter (Redis-first) if available from litellm.proxy.proxy_server import get_current_spend diff --git a/litellm/types/proxy/auth/user_api_key_auth.py b/litellm/types/proxy/auth/user_api_key_auth.py index c2f7c487b7b..d68f6daf1a1 100644 --- a/litellm/types/proxy/auth/user_api_key_auth.py +++ b/litellm/types/proxy/auth/user_api_key_auth.py @@ -78,6 +78,8 @@ class LiteLLM_VerificationTokenView(LiteLLM_VerificationToken): team_member_spend: float | None = None team_member_tpm_limit: int | None = None team_member_rpm_limit: int | None = None + max_budget_in_team: float | None = None + team_member_max_budget: float | None = None # End User Params end_user_id: str | None = None diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 1117ca43657..042f440d3da 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -116,6 +116,24 @@ async def test_paid_target_refused_when_over_user_budget(): assert await is_token_within_budget_for_model(model="paid-model", valid_token=token, llm_router=_router()) is False +@pytest.mark.asyncio +async def test_paid_target_refused_when_over_team_member_overall_budget(): + token = _token(user_id="u1", team_id="t1", max_budget_in_team=50.0, team_member_spend=100.0) + assert await is_token_within_budget_for_model(model="paid-model", valid_token=token, llm_router=_router()) is False + + +@pytest.mark.asyncio +async def test_paid_target_allowed_when_under_team_member_overall_budget(): + token = _token(user_id="u1", team_id="t1", max_budget_in_team=50.0, team_member_spend=10.0) + assert await is_token_within_budget_for_model(model="paid-model", valid_token=token, llm_router=_router()) is True + + +@pytest.mark.asyncio +async def test_free_target_allowed_even_when_over_team_member_overall_budget(): + token = _token(user_id="u1", team_id="t1", max_budget_in_team=50.0, team_member_spend=100.0) + assert await is_token_within_budget_for_model(model="free-model", valid_token=token, llm_router=_router()) is True + + @pytest.mark.asyncio async def test_team_member_budget_refuses_an_exhausted_paid_target() -> None: member_caps: Final = {"paid-model": {"max_budget": 5.0, "budget_duration": "1d"}} From 33e2ef7ac528bda86478c7a73586b06008bb96a7 Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Fri, 16 Oct 2026 20:41:07 +0530 Subject: [PATCH 2/6] fix(proxy): pre-populate team member overall budget and safely check zero budget Signed-off-by: AAKASH S S --- litellm/proxy/auth/fallback_budget.py | 7 +++- litellm/proxy/auth/user_api_key_auth.py | 16 ++++++++ tests/unit/proxy/auth/test_fallback_budget.py | 37 ++++++++++++++++++- 3 files changed, 57 insertions(+), 3 deletions(-) diff --git a/litellm/proxy/auth/fallback_budget.py b/litellm/proxy/auth/fallback_budget.py index 0d40c759680..ac13c8e47e7 100644 --- a/litellm/proxy/auth/fallback_budget.py +++ b/litellm/proxy/auth/fallback_budget.py @@ -156,8 +156,11 @@ async def is_token_within_budget_for_model( if user_spend >= user_budget: return False - team_member_budget: Final = getattr(valid_token, "max_budget_in_team", None) or getattr( - valid_token, "team_member_max_budget", None + member_team_budget: Final = getattr(valid_token, "max_budget_in_team", None) + team_member_budget: Final = ( + member_team_budget + if member_team_budget is not None + else getattr(valid_token, "team_member_max_budget", None) ) if ( team_member_budget is not None diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py index cd02487d417..7dee9fa0524 100644 --- a/litellm/proxy/auth/user_api_key_auth.py +++ b/litellm/proxy/auth/user_api_key_auth.py @@ -3398,6 +3398,15 @@ async def _load_team_member_default_model_budget( user_api_key_cache=user_api_key_cache, proxy_logging_obj=proxy_logging_obj, ) + if membership is not None: + user_api_key_auth_obj.team_member_spend = membership.spend + member_budget_row_early: Final = membership.litellm_budget_table + if member_budget_row_early is not None: + member_budget: Final = member_budget_row_early.effective_max_budget(now=datetime.now(timezone.utc)) + if member_budget is not None: + user_api_key_auth_obj.max_budget_in_team = member_budget + user_api_key_auth_obj.team_member_max_budget = member_budget + member_budget_row: Final = membership.litellm_budget_table if membership is not None else None member_budget_value: Final[object] = ( getattr(member_budget_row, "model_max_budget", None) if member_budget_row is not None else None @@ -3421,6 +3430,13 @@ async def _load_team_member_default_model_budget( user_api_key_cache=user_api_key_cache, raise_on_lookup_error=True, ) + if ( + user_api_key_auth_obj.max_budget_in_team is None + and team_member_default_budget is not None + and team_member_default_budget.max_budget is not None + ): + user_api_key_auth_obj.max_budget_in_team = team_member_default_budget.max_budget + user_api_key_auth_obj.team_member_max_budget = team_member_default_budget.max_budget except Exception: if not skip_budget_checks: raise diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 042f440d3da..437ddd90b75 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -1,6 +1,6 @@ from collections.abc import Mapping, Sequence from typing import Final -from unittest.mock import AsyncMock, MagicMock +from unittest.mock import AsyncMock, MagicMock, patch import litellm import pytest @@ -134,6 +134,41 @@ async def test_free_target_allowed_even_when_over_team_member_overall_budget(): assert await is_token_within_budget_for_model(model="free-model", valid_token=token, llm_router=_router()) is True +@pytest.mark.asyncio +async def test_paid_target_refused_when_team_member_budget_is_zero(): + token = _token(user_id="u1", team_id="t1", max_budget_in_team=0.0, team_member_spend=0.0) + assert await is_token_within_budget_for_model(model="paid-model", valid_token=token, llm_router=_router()) is False + + +@pytest.mark.asyncio +async def test_load_team_member_budget_populates_token_when_budget_checks_skipped(): + from litellm.proxy.auth.user_api_key_auth import _load_team_member_default_model_budget + + token = _token(user_id="u1", team_id="t1") + assert token.max_budget_in_team is None + + mock_membership = MagicMock() + mock_membership.spend = 15.0 + mock_budget_row = MagicMock() + mock_budget_row.effective_max_budget.return_value = 50.0 + mock_budget_row.model_max_budget = None + mock_membership.litellm_budget_table = mock_budget_row + mock_membership.budget_id = None + + with patch("litellm.proxy.auth.user_api_key_auth.get_team_membership", new=AsyncMock(return_value=mock_membership)): + await _load_team_member_default_model_budget( + user_api_key_auth_obj=token, + team_object=None, + prisma_client=MagicMock(), + user_api_key_cache=MagicMock(), + skip_budget_checks=True, + proxy_logging_obj=None, + ) + + assert token.max_budget_in_team == 50.0 + assert token.team_member_spend == 15.0 + + @pytest.mark.asyncio async def test_team_member_budget_refuses_an_exhausted_paid_target() -> None: member_caps: Final = {"paid-model": {"max_budget": 5.0, "budget_duration": "1d"}} From c5365d9e5f58bf5c1b8570fac6045f7679661de5 Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Sat, 17 Oct 2026 16:20:18 +0530 Subject: [PATCH 3/6] fix(proxy): treat zero team default budget as no-cap and apply active increases Signed-off-by: AAKASH S S --- litellm/proxy/auth/user_api_key_auth.py | 10 +++++-- tests/unit/proxy/auth/test_fallback_budget.py | 29 +++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py index 7dee9fa0524..e3e481662ec 100644 --- a/litellm/proxy/auth/user_api_key_auth.py +++ b/litellm/proxy/auth/user_api_key_auth.py @@ -3434,9 +3434,15 @@ async def _load_team_member_default_model_budget( user_api_key_auth_obj.max_budget_in_team is None and team_member_default_budget is not None and team_member_default_budget.max_budget is not None + and team_member_default_budget.max_budget > 0 ): - user_api_key_auth_obj.max_budget_in_team = team_member_default_budget.max_budget - user_api_key_auth_obj.team_member_max_budget = team_member_default_budget.max_budget + default_max: Final = team_member_default_budget.max_budget + ( + member_budget_row.active_temp_budget_increase(now=datetime.now(timezone.utc)) + if member_budget_row is not None + else 0.0 + ) + user_api_key_auth_obj.max_budget_in_team = default_max + user_api_key_auth_obj.team_member_max_budget = default_max except Exception: if not skip_budget_checks: raise diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 437ddd90b75..acf0ac620f9 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -169,6 +169,35 @@ async def test_load_team_member_budget_populates_token_when_budget_checks_skippe assert token.team_member_spend == 15.0 +@pytest.mark.asyncio +async def test_load_team_member_default_budget_zero_treated_as_no_cap(): + from litellm.proxy.auth.user_api_key_auth import _load_team_member_default_model_budget + + token = _token(user_id="u1", team_id="t1") + assert token.max_budget_in_team is None + + mock_team = MagicMock() + mock_team.metadata = {"team_member_budget_id": "b-default"} + + mock_default_budget = MagicMock() + mock_default_budget.max_budget = 0.0 + + with ( + patch("litellm.proxy.auth.user_api_key_auth.get_team_membership", new=AsyncMock(return_value=None)), + patch("litellm.proxy.auth.user_api_key_auth.get_team_member_default_budget", new=AsyncMock(return_value=mock_default_budget)), + ): + await _load_team_member_default_model_budget( + user_api_key_auth_obj=token, + team_object=mock_team, + prisma_client=MagicMock(), + user_api_key_cache=MagicMock(), + skip_budget_checks=True, + proxy_logging_obj=None, + ) + + assert token.max_budget_in_team is None + + @pytest.mark.asyncio async def test_team_member_budget_refuses_an_exhausted_paid_target() -> None: member_caps: Final = {"paid-model": {"max_budget": 5.0, "budget_duration": "1d"}} From 93cdda188931c08f19b7e361a50fd09e7317a4fd Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Sat, 17 Oct 2026 21:04:55 +0530 Subject: [PATCH 4/6] test(proxy): add e2e auth-to-fallback test and document default budget filter Add an end-to-end test running the centralized auth gate with a zero-cost primary model and asserting that a paid fallback target is refused when the team member budget is exceeded. Update validate_resolved_virtual_key to support 0.0 membership budget and document team-level 0 default as unset. Addresses review feedback on #46874. Signed-off-by: AAKASH S S --- litellm/proxy/auth/user_api_key_auth.py | 3 +- tests/unit/proxy/auth/test_fallback_budget.py | 59 +++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-) diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py index e3e481662ec..c7767a3bf2c 100644 --- a/litellm/proxy/auth/user_api_key_auth.py +++ b/litellm/proxy/auth/user_api_key_auth.py @@ -2956,7 +2956,7 @@ async def validate_resolved_virtual_key( # noqa: C901 # Preserve ordering of e team_member_budget: Final = team_member_info.litellm_budget_table.effective_max_budget( now=datetime.now(timezone.utc), ) - if team_member_budget is not None and team_member_budget > 0: + if team_member_budget is not None: valid_token.max_budget_in_team = team_member_budget valid_token.team_member_max_budget = team_member_budget # Read from cross-pod counter (Redis-first) if available @@ -3430,6 +3430,7 @@ async def _load_team_member_default_model_budget( user_api_key_cache=user_api_key_cache, raise_on_lookup_error=True, ) + # Team-level default budget of 0 denotes unset / no cap (individual membership row can explicitly set 0.0 to block). if ( user_api_key_auth_obj.max_budget_in_team is None and team_member_default_budget is not None diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index acf0ac620f9..796da467c53 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -198,6 +198,65 @@ async def test_load_team_member_default_budget_zero_treated_as_no_cap(): assert token.max_budget_in_team is None +@pytest.mark.asyncio +async def test_e2e_auth_zero_cost_primary_populates_member_budget_and_refuses_paid_fallback(monkeypatch): + """ + End-to-end auth -> fallback test (#46874): + Run the auth path (run_centralized_common_checks) with a zero-cost primary model + (so skip_budget_checks=True), verify team member budget and spend are populated onto the token, + and assert is_token_within_budget_for_model refuses the paid fallback target when spend >= budget. + """ + import litellm.proxy.proxy_server as _proxy_server_mod + from fastapi import Request + from starlette.datastructures import URL + from litellm.proxy.auth.user_api_key_auth import run_centralized_common_checks + from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache + + router = _router() + token = _token(user_id="u1", team_id="t1") + assert token.max_budget_in_team is None + assert token.team_member_spend is None + + mock_membership = MagicMock() + mock_membership.spend = 50.0 + mock_budget_row = MagicMock() + mock_budget_row.effective_max_budget.return_value = 50.0 + mock_budget_row.model_max_budget = None + mock_membership.litellm_budget_table = mock_budget_row + mock_membership.budget_id = None + + key_cache = UserApiKeyCache() + monkeypatch.setattr(_proxy_server_mod, "llm_router", router, raising=False) + monkeypatch.setattr(_proxy_server_mod, "general_settings", {}, raising=False) + monkeypatch.setattr(_proxy_server_mod, "prisma_client", MagicMock(), raising=False) + monkeypatch.setattr(_proxy_server_mod, "user_api_key_cache", key_cache, raising=False) + monkeypatch.setattr(_proxy_server_mod, "proxy_logging_obj", None, raising=False) + monkeypatch.setattr(_proxy_server_mod, "master_key", "sk-master", raising=False) + + request = Request(scope={"type": "http"}) + request._url = URL(url="/chat/completions") + + with ( + patch("litellm.proxy.auth.user_api_key_auth.get_team_membership", new=AsyncMock(return_value=mock_membership)), + patch("litellm.proxy.auth.user_api_key_auth.get_team_object", new=AsyncMock(return_value=None)), + patch("litellm.proxy.auth.user_api_key_auth.get_user_object", new=AsyncMock(return_value=None)), + patch("litellm.proxy.auth.user_api_key_auth.common_checks", new=AsyncMock(return_value=True)), + ): + await run_centralized_common_checks( + user_api_key_auth_obj=token, + request=request, + request_data={"model": "free-model", "messages": [{"role": "user", "content": "hi"}]}, + route="/chat/completions", + ) + + # 1. Token has team member budget and spend stamped despite zero-cost skip + assert token.max_budget_in_team == 50.0 + assert token.team_member_spend == 50.0 + + # 2. Fallback evaluator refuses the paid fallback target because spend >= budget + assert await is_token_within_budget_for_model(model="paid-model", valid_token=token, llm_router=router) is False + + @pytest.mark.asyncio async def test_team_member_budget_refuses_an_exhausted_paid_target() -> None: member_caps: Final = {"paid-model": {"max_budget": 5.0, "budget_duration": "1d"}} From 5503565d382437895fca846314dde76345ea15ac Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Wed, 21 Oct 2026 01:05:12 +0530 Subject: [PATCH 5/6] style(proxy): clean up unused import and ordering in test_fallback_budget Signed-off-by: AAKASH S S --- tests/unit/proxy/auth/test_fallback_budget.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 796da467c53..05ad458d7a8 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -2,7 +2,6 @@ from collections.abc import Mapping, Sequence from typing import Final from unittest.mock import AsyncMock, MagicMock, patch -import litellm import pytest from litellm import Router @@ -206,9 +205,10 @@ async def test_e2e_auth_zero_cost_primary_populates_member_budget_and_refuses_pa (so skip_budget_checks=True), verify team member budget and spend are populated onto the token, and assert is_token_within_budget_for_model refuses the paid fallback target when spend >= budget. """ - import litellm.proxy.proxy_server as _proxy_server_mod from fastapi import Request from starlette.datastructures import URL + + import litellm.proxy.proxy_server as _proxy_server_mod from litellm.proxy.auth.user_api_key_auth import run_centralized_common_checks from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache From 41334bfcfe8f9c826d96e25210798ee62377a9f1 Mon Sep 17 00:00:00 2001 From: AAKASH S S Date: Fri, 23 Oct 2026 12:54:49 +0530 Subject: [PATCH 6/6] style(proxy): format fallback_budget and test_fallback_budget with ruff --- litellm/proxy/auth/fallback_budget.py | 10 ++-------- tests/unit/proxy/auth/test_fallback_budget.py | 12 ++++++------ 2 files changed, 8 insertions(+), 14 deletions(-) diff --git a/litellm/proxy/auth/fallback_budget.py b/litellm/proxy/auth/fallback_budget.py index ac13c8e47e7..5bff83c1d3f 100644 --- a/litellm/proxy/auth/fallback_budget.py +++ b/litellm/proxy/auth/fallback_budget.py @@ -158,15 +158,9 @@ async def is_token_within_budget_for_model( member_team_budget: Final = getattr(valid_token, "max_budget_in_team", None) team_member_budget: Final = ( - member_team_budget - if member_team_budget is not None - else getattr(valid_token, "team_member_max_budget", None) + member_team_budget if member_team_budget is not None else getattr(valid_token, "team_member_max_budget", None) ) - if ( - team_member_budget is not None - and valid_token.user_id is not None - and valid_token.team_id is not None - ): + if team_member_budget is not None and valid_token.user_id is not None and valid_token.team_id is not None: team_member_spend: Final = await _counter_spend( counter_key=f"spend:team_member:{valid_token.user_id}:{valid_token.team_id}", fallback_spend=valid_token.team_member_spend or 0.0, diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 05ad458d7a8..f7e8083d6bc 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -183,7 +183,10 @@ async def test_load_team_member_default_budget_zero_treated_as_no_cap(): with ( patch("litellm.proxy.auth.user_api_key_auth.get_team_membership", new=AsyncMock(return_value=None)), - patch("litellm.proxy.auth.user_api_key_auth.get_team_member_default_budget", new=AsyncMock(return_value=mock_default_budget)), + patch( + "litellm.proxy.auth.user_api_key_auth.get_team_member_default_budget", + new=AsyncMock(return_value=mock_default_budget), + ), ): await _load_team_member_default_model_budget( user_api_key_auth_obj=token, @@ -591,9 +594,7 @@ async def test_router_skips_the_paid_fallback_target_when_over_budget(): is False ) assert ( - await _is_fallback_target_within_budget( - router, "paid-model", "free-model", under, attempted=under_attempted - ) + await _is_fallback_target_within_budget(router, "paid-model", "free-model", under, attempted=under_attempted) is True ) assert over_attempted.skipped == (SkippedFallbackTarget("paid-model", FallbackSkipReason.OVER_BUDGET),) @@ -608,8 +609,7 @@ async def test_router_without_a_budget_check_attempts_every_fallback(): attempted: Final = AttemptedFallbackTargets() assert ( - await _is_fallback_target_within_budget(router, "paid-model", "free-model", over, attempted=attempted) - is True + await _is_fallback_target_within_budget(router, "paid-model", "free-model", over, attempted=attempted) is True )