From 35e3210edbf647543348d5e596acd0e13654e29b Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 15:02:34 -0700 Subject: [PATCH] feat(teams): move custom member budgets onto a new team default in one update /team/update takes team_member_budget_backfill (none, raise_to_default, lower_to_default, all_to_default) next to team_member_budget. The server picks which members with their own budget move onto the new default, comparing permanent budgets of members on the default's reset schedule, and reports how many moved. The default row, the member moves and the team row now commit in one transaction under the team lock, so a failed update leaves nothing half applied. One update moves at most 50,000 members. The Admin UI prompt becomes a choice between keeping, raising, lowering or both, sent in that same request instead of chunked bulk updates, and team admins who may edit the member budget get it too. Clearing a member's last limit used to unlink them from every budget row, so their spend never reset again. They are linked back to the team default now, and default member budget cache evictions reach every worker. Resolves LIT-8926 --- litellm/litellm_core_utils/duration_parser.py | 18 + litellm/proxy/_types.py | 26 + litellm/proxy/auth/auth_checks.py | 3 +- .../proxy/common_utils/user_api_key_cache.py | 4 + .../budget_management_endpoints.py | 11 +- .../management_endpoints/common_utils.py | 25 +- .../team_admin_field_permissions.py | 11 +- .../management_endpoints/team_endpoints.py | 410 +++----- .../bulk_team_member_budgets.py | 14 +- .../team_member_default_budget.py | 321 ++++++ .../spend_tracking/budget_reservation.py | 3 +- .../test_team_member_budget_backfill.py | 253 +++++ .../test_duration_parser.py | 26 +- .../test_upsert_budget_membership.py | 20 + .../management_v1/test_teams.py | 23 +- .../test_team_admin_field_permissions.py | 31 +- .../test_team_endpoints.py | 969 +----------------- .../test_management_helpers_utils.py | 224 +--- .../test_team_member_default_budget.py | 88 ++ .../src/components/networking.tsx | 7 +- .../team/ResetMemberBudgetsDialog.test.tsx | 148 ++- .../team/ResetMemberBudgetsDialog.tsx | 129 ++- .../team/TeamInfo.integration.test.tsx | 386 ++----- .../src/components/team/TeamInfo.test.tsx | 49 + .../src/components/team/TeamInfo.tsx | 64 +- .../components/team/memberBudgetReset.test.ts | 151 ++- .../src/components/team/memberBudgetReset.ts | 77 +- .../team/useMemberBudgetReset.test.tsx | 357 ++----- .../components/team/useMemberBudgetReset.ts | 116 +-- ui/litellm-dashboard/src/lib/http/schema.d.ts | 10 + 30 files changed, 1649 insertions(+), 2325 deletions(-) create mode 100644 litellm/proxy/management_helpers/team_member_default_budget.py create mode 100644 tests/integration/management/test_team_member_budget_backfill.py create mode 100644 tests/unit/proxy/management_helpers/test_team_member_default_budget.py diff --git a/litellm/litellm_core_utils/duration_parser.py b/litellm/litellm_core_utils/duration_parser.py index d52716951df..ad79ef1a293 100644 --- a/litellm/litellm_core_utils/duration_parser.py +++ b/litellm/litellm_core_utils/duration_parser.py @@ -9,6 +9,7 @@ duration_in_seconds is used in diff parts of the code base, example import re import time as time_module from datetime import datetime, time, timedelta, timezone, tzinfo +from types import MappingProxyType from typing import Final from zoneinfo import ZoneInfo @@ -22,10 +23,27 @@ _BUDGET_DURATION_WORD_ALIASES: Final[dict[str, str]] = { } +_FIXED_UNIT_SECONDS: Final = MappingProxyType({"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}) + + def _normalize_duration(duration: str) -> str: return _BUDGET_DURATION_WORD_ALIASES.get(duration.strip().lower(), duration) +def budget_reset_period_key(duration: str | None) -> str | None: + """Equal keys mean the same reset schedule: fixed-length periods compare by length, so "7d" matches "1w", + while a calendar month only matches the same number of months.""" + if duration is None: + return None + normalized: Final = _normalize_duration(duration).strip() + parsed: Final = re.fullmatch(r"(\d+)(mo|[smhdw])", normalized) + if parsed is None: + return normalized + value: Final = int(parsed[1]) + unit: Final = parsed[2] + return f"{value}mo" if unit == "mo" else f"{value * _FIXED_UNIT_SECONDS[unit]}s" + + def _extract_from_regex(duration: str) -> tuple[int, str]: match: Final = re.match(r"(\d+)(mo|[smhdw]?)", duration) diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py index 28d3c08bb31..32be562d237 100644 --- a/litellm/proxy/_types.py +++ b/litellm/proxy/_types.py @@ -1936,6 +1936,9 @@ class GlobalEndUsersSpend(LiteLLMPydanticObjectBase): endTime: datetime | None = None +TeamMemberBudgetBackfill: TypeAlias = Literal["none", "raise_to_default", "lower_to_default", "all_to_default"] + + class UpdateTeamRequest(LiteLLMPydanticObjectBase): """ UpdateTeamRequest, used by /team/update when you need to update a team @@ -1978,6 +1981,14 @@ class UpdateTeamRequest(LiteLLMPydanticObjectBase): team_member_model_max_budget: GenericBudgetConfigType | None = None team_member_rpm_limit: int | None = None team_member_tpm_limit: int | None = None + team_member_budget_backfill: TeamMemberBudgetBackfill | None = Field( + default=None, + description=( + "Which members with their own budget move onto the team_member_budget sent in the same request: " + "'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. " + "Members whose budget resets on a different schedule than the default are left alone" + ), + ) team_member_key_duration: str | None = None allowed_passthrough_routes: list | None = None denied_passthrough_routes: list[str] | None = None @@ -2003,6 +2014,21 @@ class UpdateTeamRequest(LiteLLMPydanticObjectBase): ), ) + @model_validator(mode="after") + def _backfill_needs_a_positive_default(self) -> "UpdateTeamRequest": + if self.team_member_budget_backfill in (None, "none"): + return self + if self.team_member_budget is None or self.team_member_budget <= 0: + raise ValueError("team_member_budget_backfill needs a positive team_member_budget in the same request") + return self + + +class TeamMemberBudgetBackfillResult(LiteLLMBaseModel): + model_config = ConfigDict(frozen=True) + + moved_to_default: int + skipped_other_reset_period: int + class PatchTeamRequest(UpdateTeamRequest): """ diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 8887d86570a..6c5385d5654 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -128,6 +128,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_spend_counter_key, tag_cache_key, tag_registry_cache_key, + team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -1766,7 +1767,7 @@ async def get_team_member_default_budget( if prisma_client is None: return None - cache_key: Final = f"team_member_default_budget:{budget_id}" + cache_key: Final = team_member_default_budget_cache_key(budget_id) cached_budget: Final = await user_api_key_cache.async_get_cache( key=cache_key, diff --git a/litellm/proxy/common_utils/user_api_key_cache.py b/litellm/proxy/common_utils/user_api_key_cache.py index e64fd755ef9..e5e217a067c 100644 --- a/litellm/proxy/common_utils/user_api_key_cache.py +++ b/litellm/proxy/common_utils/user_api_key_cache.py @@ -392,6 +392,10 @@ def team_membership_reservation_cache_key(user_id: str, team_id: str) -> str: return f"team_membership:{user_id}:{team_id}" +def team_member_default_budget_cache_key(budget_id: str) -> str: + return f"team_member_default_budget:{budget_id}" + + #: Cached under ``team_membership_reservation_cache_key`` when a member has no ``LiteLLM_TeamMembership`` #: row, so a session-token member without a per-member budget costs no DB read per request. Lives beside #: the key builder because it is part of the same cache protocol: every reader of the key must know that diff --git a/litellm/proxy/management_endpoints/budget_management_endpoints.py b/litellm/proxy/management_endpoints/budget_management_endpoints.py index b3f372327dc..4862435a8c7 100644 --- a/litellm/proxy/management_endpoints/budget_management_endpoints.py +++ b/litellm/proxy/management_endpoints/budget_management_endpoints.py @@ -20,10 +20,11 @@ from typing import Final from fastapi import APIRouter, Depends, HTTPException from litellm._internal_context import service_target -from litellm._logging import verbose_proxy_logger from litellm.proxy._types import * from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import evict_and_broadcast from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time +from litellm.proxy.common_utils.user_api_key_cache import team_member_default_budget_cache_key from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # legacy module exports _user_has_admin_view, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export user_api_key_has_admin_view, @@ -202,10 +203,10 @@ async def update_budget( data=budget_obj_jsonified, ) with service_target("team_member_budgets"): - try: - await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_obj.budget_id}") - except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update. - verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True) + await evict_and_broadcast( + cache_keys=(team_member_default_budget_cache_key(budget_obj.budget_id),), + user_api_key_cache=user_api_key_cache, + ) return response diff --git a/litellm/proxy/management_endpoints/common_utils.py b/litellm/proxy/management_endpoints/common_utils.py index adf89c29279..0f05a14c519 100644 --- a/litellm/proxy/management_endpoints/common_utils.py +++ b/litellm/proxy/management_endpoints/common_utils.py @@ -619,7 +619,7 @@ def _is_set_budget_value(value: object) -> bool: return True -def _has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: +def has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: """A budget is meaningful if at least one limit is actually set; an empty list (no model restriction) and None both count as unset.""" return any(_is_set_budget_value(budget_values.get(field)) for field in _TEAM_MEMBER_BUDGET_LIMIT_FIELDS) @@ -642,8 +642,9 @@ async def upsert_budget_and_membership( ``budget_patch`` holds only the budget columns the caller explicitly sent (RFC 7396 semantics): a value sets the column, ``None`` clears it, and a column that is absent from the dict is left untouched. Once the patch is - applied, if the budget has no meaningful limit left the member's private - budget is disconnected so they fall back to the team default. + applied, if the budget has no meaningful limit left the member is linked + back to the team default budget, so their spend keeps resetting on its + schedule, or unlinked when the team has none. ``team_default_budget_id`` is the team's shared default member budget id (from team metadata.team_member_budget_id). When the membership still @@ -687,18 +688,24 @@ async def upsert_budget_and_membership( ) temp_only: Final = frozenset(write_data) <= _TEMP_BUDGET_FIELDS - async def _disconnect(): + async def _fall_back_to_team_default(): await tx.litellm_teammembership.update( where={"user_id_team_id": {"user_id": user_id, "team_id": team_id}}, - data={"litellm_budget_table": {"disconnect": True}}, + data={ + "litellm_budget_table": ( + {"disconnect": True} + if team_default_budget_id is None + else {"connect": {"budget_id": team_default_budget_id}} + ) + }, ) if existing_budget_id is not None and not is_shared_default: existing_budget: Final = await tx.litellm_budgettable.find_unique(where={"budget_id": existing_budget_id}) merged: Final = existing_budget.model_dump() if existing_budget is not None else {} merged.update(write_data) - if not _has_meaningful_budget_limit(merged): - await _disconnect() + if not has_meaningful_budget_limit(merged): + await _fall_back_to_team_default() return await tx.litellm_budgettable.update( where={"budget_id": existing_budget_id}, @@ -739,9 +746,9 @@ async def upsert_budget_and_membership( if create_data.get("budget_reset_at") is None: create_data.pop("budget_reset_at", None) - if not _has_meaningful_budget_limit(create_data): + if not has_meaningful_budget_limit(create_data): if existing_budget_id is not None and not temp_only: - await _disconnect() + await _fall_back_to_team_default() return new_budget: Final = await tx.litellm_budgettable.create( diff --git a/litellm/proxy/management_endpoints/team_admin_field_permissions.py b/litellm/proxy/management_endpoints/team_admin_field_permissions.py index 0ece14eb90a..a30ec44e474 100644 --- a/litellm/proxy/management_endpoints/team_admin_field_permissions.py +++ b/litellm/proxy/management_endpoints/team_admin_field_permissions.py @@ -123,6 +123,7 @@ class TeamMemberDefaults: TEAM_MEMBER_DEFAULT_FIELDS: Final[frozenset[str]] = frozenset( {"team_member_budget", "team_member_budget_duration", "team_member_tpm_limit", "team_member_rpm_limit"} ) +_MEMBER_BUDGET_BACKFILL_FIELD: Final = "team_member_budget_backfill" @dataclass(frozen=True, slots=True) @@ -447,7 +448,10 @@ def _only_changes(data: UpdateTeamRequest, changed: frozenset[str]) -> UpdateTea such as a resent budget_duration pushing budget_reset_at back.""" sent: Final = frozenset(data.model_fields_set) via_metadata: Final = frozenset({"metadata"}) if changed - sent else frozenset[str]() - kept: Final = frozenset({"team_id"}) | (changed & sent) | via_metadata + backfilled_default: Final = ( + frozenset({"team_member_budget"}) & sent if _MEMBER_BUDGET_BACKFILL_FIELD in changed else frozenset[str]() + ) + kept: Final = frozenset({"team_id"}) | (changed & sent) | via_metadata | backfilled_default return UpdateTeamRequest.model_validate(data.model_dump(include=MappingProxyType({field: True for field in kept}))) @@ -466,7 +470,10 @@ def team_admin_edit_verdict( if controlled: return TeamAdminMetadataKeyProxyControlled(key=controlled[0]) changed: Final = changed_team_fields(data, existing, member_defaults) - blocked: Final = sorted(changed - permitted) + may_backfill: Final = ( + frozenset({_MEMBER_BUDGET_BACKFILL_FIELD}) if "team_member_budget" in permitted else frozenset[str]() + ) + blocked: Final = sorted(changed - permitted - may_backfill) if blocked: return TeamAdminFieldNotPermitted(field=blocked[0]) cleared: Final = sorted( diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index d9763f72741..11e83150d8c 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -88,6 +88,8 @@ from litellm.proxy._types import ( TeamInfoResponseObjectTeamTable, TeamListResponseObject, TeamMemberAddRequest, + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, TeamMemberBudgetSource, TeamMemberDeleteRequest, TeamMemberResetBudgetResponse, @@ -131,6 +133,7 @@ from litellm.proxy.common_utils.callback_utils import encrypt_callback_vars from litellm.proxy.common_utils.json_merge_patch import apply_json_merge_patch from litellm.proxy.common_utils.user_api_key_cache import ( UserApiKeyCache, + team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -202,6 +205,15 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa: set_object_permission, ) from litellm.proxy.management_helpers.ptu_share_guard import raise_if_teams_hold_ptu_shares +from litellm.proxy.management_helpers.team_member_default_budget import ( + MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE, + MovedMemberBudgets, + TeamMemberDefaultBudgetWrite, + TooManyMemberBudgetsToMove, + move_member_budgets_to_default, + plan_team_member_default_budget_write, + write_team_member_default_budget, +) from litellm.proxy.management_helpers.team_member_permission_checks import ( TeamMemberPermissionChecks, ) @@ -643,10 +655,9 @@ class TeamMemberBudgetHandler: user_api_key_cache: UserApiKeyCache | None, ) -> None: if user_api_key_cache is not None: - try: - await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_id}") - except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update. - verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True) + await evict_and_broadcast( + cache_keys=(team_member_default_budget_cache_key(budget_id),), user_api_key_cache=user_api_key_cache + ) @staticmethod async def create_team_member_budget_table( @@ -716,89 +727,6 @@ class TeamMemberBudgetHandler: return new_team_data_json - @staticmethod - async def upsert_team_member_budget_table( - team_table: _TeamBudgetRow, - user_api_key_dict: UserAPIKeyAuth, - updated_kv: dict, - team_member_budget: float | None = None, - team_member_rpm_limit: int | None = None, - team_member_tpm_limit: int | None = None, - team_member_budget_duration: str | None = None, - team_member_model_max_budget: GenericBudgetConfigType | None = None, - user_api_key_cache: UserApiKeyCache | None = None, - explicitly_set_fields: AbstractSet[str] = frozenset(), - ) -> dict: - """Upsert team member budget table with provided limits. - - A field the caller explicitly sent as null is written as null, so a - team can keep a member budget while dropping its reset period. - """ - from litellm.proxy._types import BudgetNewRequest - from litellm.proxy.management_endpoints.budget_management_endpoints import ( - update_budget, - ) - - if team_table.metadata is None: - team_table.metadata = {} - - team_member_budget_id: Final = team_table.metadata.get("team_member_budget_id") - if team_member_budget_id is not None and isinstance(team_member_budget_id, str): - # Budget exists - create update request with only provided values - budget_request: Final = BudgetNewRequest(budget_id=team_member_budget_id) - - if team_member_budget is not None or "team_member_budget" in explicitly_set_fields: - budget_request.max_budget = team_member_budget - if team_member_rpm_limit is not None or "team_member_rpm_limit" in explicitly_set_fields: - budget_request.rpm_limit = team_member_rpm_limit - if team_member_tpm_limit is not None or "team_member_tpm_limit" in explicitly_set_fields: - budget_request.tpm_limit = team_member_tpm_limit - if team_member_budget_duration is not None or "team_member_budget_duration" in explicitly_set_fields: - budget_request.budget_duration = team_member_budget_duration - if team_member_budget_duration is None: - budget_request.budget_reset_at = None - if team_member_model_max_budget is not None or "team_member_model_max_budget" in explicitly_set_fields: - budget_request.model_max_budget = ( - {} if team_member_model_max_budget is None else team_member_model_max_budget - ) - - budget_row: Final = await _as_budget_write(update_budget)( - budget_obj=budget_request, - user_api_key_dict=user_api_key_dict, - ) - await TeamMemberBudgetHandler._evict_default_budget_cache( - budget_id=team_member_budget_id, - user_api_key_cache=user_api_key_cache, - ) - verbose_proxy_logger.info( - "Updated team member budget table: %s, with team_member_budget=%s, team_member_rpm_limit=%s, team_member_tpm_limit=%s", - budget_row.budget_id, - team_member_budget, - team_member_rpm_limit, - team_member_tpm_limit, - ) - if updated_kv.get("metadata") is None: - updated_kv["metadata"] = {} - updated_kv["metadata"]["team_member_budget_id"] = budget_row.budget_id - - else: # budget does not exist - updated_kv = await TeamMemberBudgetHandler.create_team_member_budget_table( - data=team_table, - new_team_data_json=updated_kv, - user_api_key_dict=user_api_key_dict, - team_member_budget=team_member_budget, - team_member_rpm_limit=team_member_rpm_limit, - team_member_tpm_limit=team_member_tpm_limit, - team_member_budget_duration=team_member_budget_duration, - team_member_model_max_budget=team_member_model_max_budget, - user_api_key_cache=user_api_key_cache, - explicitly_set_fields=explicitly_set_fields, - ) - - # Remove team member fields from updated_kv - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) - return updated_kv - @staticmethod def clean_team_member_fields(data_dict: dict) -> None: """Remove team member fields from data dictionary""" @@ -809,119 +737,12 @@ class TeamMemberBudgetHandler: data_dict.pop( # pyright: ignore[reportUnknownMemberType] # legacy raw dict lacks key typing "team_member_model_max_budget", None ) + data_dict.pop( # pyright: ignore[reportUnknownMemberType] # legacy raw dict lacks key typing + "team_member_budget_backfill", None + ) _clean_team_member_fields = clean_team_member_fields - @staticmethod - async def clear_team_member_budget_fields( - team_table: _TeamBudgetRow, - user_api_key_dict: "UserAPIKeyAuth", - updated_kv: dict, - explicitly_set_fields: set, - user_api_key_cache: UserApiKeyCache | None = None, - ) -> dict: - """Clear explicitly-nulled fields on the team member budget row.""" - from litellm.proxy._types import BudgetNewRequest - from litellm.proxy.management_endpoints.budget_management_endpoints import ( - update_budget, - ) - - if team_table.metadata is None: - team_table.metadata = {} - - team_member_budget_id: Final = team_table.metadata.get("team_member_budget_id") - if team_member_budget_id is not None and isinstance(team_member_budget_id, str): - budget_request: Final = BudgetNewRequest(budget_id=team_member_budget_id) - if "team_member_budget" in explicitly_set_fields: - budget_request.max_budget = None - if "team_member_budget_duration" in explicitly_set_fields: - budget_request.budget_duration = None - budget_request.budget_reset_at = None - if "team_member_rpm_limit" in explicitly_set_fields: - budget_request.rpm_limit = None - if "team_member_tpm_limit" in explicitly_set_fields: - budget_request.tpm_limit = None - if "team_member_model_max_budget" in explicitly_set_fields: - budget_request.model_max_budget = {} - await update_budget( - budget_obj=budget_request, - user_api_key_dict=user_api_key_dict, - ) - await TeamMemberBudgetHandler._evict_default_budget_cache( - budget_id=team_member_budget_id, - user_api_key_cache=user_api_key_cache, - ) - - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) - return updated_kv - - @staticmethod - async def backfill_team_member_budget_entries( - team_id: str, - members_with_roles: Sequence[Member | dict[str, object]], - team_member_budget_id: str, - prisma_client: PrismaClient, - ) -> None: - """ - Ensure every team member has a TeamMembership row linked to the - team_member_budget. - - Called after team_member_budget is set/updated on a team. Creates - rows for members who don't have one, and populates budget_id on - existing rows where it is NULL. Rows with a non-NULL budget_id - are left untouched, which preserves per-member overrides but also - means rows pointing to a prior team-default budget_id are not - migrated to the new one. - """ - if not members_with_roles: - return - - # Batch-fetch existing memberships for this team (avoids N+1 queries) - existing_memberships: Final = await _team_membership_db(prisma_client).find_many(where={"team_id": team_id}) - existing_user_ids: Final = {m.user_id for m in existing_memberships} - - # Identify members with no existing membership row. - # members_with_roles may contain Member instances or raw dicts depending - # on how the team was fetched/deserialized. - missing: Final = [] - for m in members_with_roles: - user_id = m.get("user_id") if isinstance(m, dict) else m.user_id - if user_id is not None and user_id not in existing_user_ids: - missing.append( - { - "team_id": team_id, - "user_id": user_id, - "budget_id": team_member_budget_id, - } - ) - - if missing: - await _team_membership_db(prisma_client).create_many( - data=missing, - skip_duplicates=True, # safety net against concurrent races - ) - verbose_proxy_logger.info( - "Backfilled %d team_memberships for team %s with budget %s", - len(missing), - _sanitize_for_log(team_id), - _sanitize_for_log(team_member_budget_id), - ) - - # Heal existing membership rows that predate the team_member_budget - # configuration: populate budget_id where it is currently NULL. - # Rows with an explicit budget_id (per-member override) are left alone. - updated: Final = await _team_membership_db(prisma_client).update_many( - where={"team_id": team_id, "budget_id": None}, - data={"budget_id": team_member_budget_id}, - ) - if updated: - verbose_proxy_logger.info( - "Populated budget_id on %d existing team_memberships for team %s with budget %s", - updated, - _sanitize_for_log(team_id), - _sanitize_for_log(team_member_budget_id), - ) - def _get_default_team_param(field: str) -> object: """ @@ -1382,6 +1203,8 @@ def _check_team_budget_update_authority( return guard +_TEAM_MEMBER_BUDGET_TX_TIMEOUT: Final = timedelta(seconds=60) + _TEAM_UPDATE_INCLUDE: Final = MappingProxyType( { "litellm_model_table": True, @@ -1394,26 +1217,96 @@ _TEAM_UPDATE_INCLUDE: Final = MappingProxyType( async def _write_team_update( - prisma_client: PrismaClient | None, + teams: "TableActions[prisma_models.LiteLLM_TeamTable]", team_id: str, team_update_data: Mapping[str, object], max_budget_guard: _MaxBudgetGuard | None, ) -> "prisma_models.LiteLLM_TeamTable | None": by_id: Final[_TeamIdWhere] = {"team_id": team_id} if max_budget_guard is None: - return await _team_db(prisma_client).update(where=by_id, data=team_update_data, include=_TEAM_UPDATE_INCLUDE) + return await teams.update(where=by_id, data=team_update_data, include=_TEAM_UPDATE_INCLUDE) as_checked: Final[_TeamBudgetGuardWhere] = { "team_id": team_id, "max_budget": max_budget_guard.max_budget, "organization_id": max_budget_guard.organization_id, } - written: Final = await _team_db(prisma_client).update_many(where=as_checked, data=team_update_data) + written: Final = await teams.update_many(where=as_checked, data=team_update_data) if written == 0: conflict: Final[_ErrorDetail] = { "error": "The team's organization or max_budget changed during this update. Reload the team and try again." } raise HTTPException(status_code=409, detail=conflict) - return await _team_db(prisma_client).find_unique(where=by_id, include=_TEAM_UPDATE_INCLUDE) + return await teams.find_unique(where=by_id, include=_TEAM_UPDATE_INCLUDE) + + +@dataclass(frozen=True, slots=True) +class _TeamWrite: + team_row: "prisma_models.LiteLLM_TeamTable | None" + linked_member_user_ids: tuple[str, ...] + moved_member_budgets: MovedMemberBudgets | None + + def backfill_response(self) -> Mapping[str, TeamMemberBudgetBackfillResult]: + if self.moved_member_budgets is None: + return MappingProxyType({}) + return MappingProxyType({"team_member_budget_backfill_result": self.moved_member_budgets.result()}) + + def backfill_audit(self) -> Mapping[str, object]: + return MappingProxyType({key: result.model_dump() for key, result in self.backfill_response().items()}) + + def changed_member_user_ids(self) -> tuple[str, ...]: + moved: Final = () if self.moved_member_budgets is None else self.moved_member_budgets.user_ids + return tuple(dict.fromkeys((*self.linked_member_user_ids, *moved))) + + +async def _write_team_with_member_default_budget( + prisma_client: PrismaClient, + *, + team_id: str, + team_update_data: Mapping[str, object], + max_budget_guard: _MaxBudgetGuard | None, + default_budget_write: TeamMemberDefaultBudgetWrite, + backfill: TeamMemberBudgetBackfill, + user_api_key_dict: UserAPIKeyAuth, + changed_by: str, +) -> _TeamWrite: + """One transaction under the team lock, so the default, every member it reaches and the team row commit + together or not at all.""" + async with prisma_client.tx(timeout=_TEAM_MEMBER_BUDGET_TX_TIMEOUT) as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, team_id) + members: Final = await TeamRepository(prisma_client).get_members_with_roles_locked(tx, team_id) + if members is None: + raise HTTPException( + status_code=404, detail={"error": f"Team={team_id} was deleted while this update was running"} + ) + member_user_ids: Final = tuple(member.user_id for member in members if member.user_id is not None) + await write_team_member_default_budget( + tx, default_budget_write, team_id=team_id, member_user_ids=member_user_ids, changed_by=changed_by + ) + moved: Final = await move_member_budgets_to_default( + tx, + team_id=team_id, + default_budget_id=default_budget_write.budget_id, + backfill=backfill, + changed_by=user_api_key_dict, + ) + if isinstance(moved, TooManyMemberBudgetsToMove): + raise HTTPException( + status_code=422, + detail={ + "error": ( + f"{moved.count} members would move onto the new default, more than the " + f"{MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE} one update can move. Save with " + "team_member_budget_backfill set to 'none', then move members in batches with " + f"POST /management/v1/teams/{team_id}/members/bulk_update" + ) + }, + ) + team_row: Final = await _write_team_update(_team_tx_db(tx), team_id, team_update_data, max_budget_guard) + return _TeamWrite( + team_row=team_row, + linked_member_user_ids=member_user_ids if default_budget_write.links_members else (), + moved_member_budgets=moved if backfill != "none" else None, + ) def _existing_model_cap(raw_budget_config: object) -> BudgetConfig | None: @@ -2244,15 +2137,6 @@ def validate_team_org_change( return True -def _member_user_ids(members_with_roles: Sequence[dict[str, object]]) -> tuple[str, ...]: - """Extract the string ``user_id`` of each team member, dropping rows without one. - - ``members_with_roles`` is a Prisma-deserialized JSON column, so its ``user_id`` is typed - ``object``; the ``isinstance`` narrows it to the ``str`` ``invalidate_team_member_spend_state`` needs. - """ - return tuple(user_id for member in members_with_roles if isinstance((user_id := member.get("user_id")), str)) - - async def _evict_created_membership_caches( user_ids: Iterable[str], team_id: str, @@ -2321,6 +2205,7 @@ async def update_team( - team_member_model_max_budget: Optional[dict] - Per-model budgets shared by team members without an override. - team_member_rpm_limit: Optional[int] - The RPM (Requests Per Minute) limit for individual team members. - team_member_tpm_limit: Optional[int] - The TPM (Tokens Per Minute) limit for individual team members. + - team_member_budget_backfill: Optional[str] - Moves members with their own budget onto the team_member_budget sent in the same request: "raise_to_default" (those below it), "lower_to_default" (those above it), "all_to_default" (both) or "none". Members on a different reset schedule are skipped, and the response's team_member_budget_backfill_result counts who moved. - team_member_key_duration: Optional[str] - The duration for a team member's key. e.g. "1d", "1w", "1mo" - allowed_passthrough_routes: Optional[List[str]] - List of allowed pass through routes for the team. - denied_passthrough_routes: Optional[List[str]] - List of pass through routes the team's keys may not call, even if allowed. Applies together with each key's `denied_passthrough_routes`. @@ -2662,50 +2547,18 @@ async def update_team( }, } - if _team_member_fields_in_request and TeamMemberBudgetHandler.should_create_budget( - team_member_budget=data.team_member_budget, - team_member_rpm_limit=data.team_member_rpm_limit, - team_member_tpm_limit=data.team_member_tpm_limit, - team_member_budget_duration=data.team_member_budget_duration, - team_member_model_max_budget=data.team_member_model_max_budget, - ): - updated_kv = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=existing_team_row, - user_api_key_dict=user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=data.team_member_budget, - team_member_rpm_limit=data.team_member_rpm_limit, - team_member_tpm_limit=data.team_member_tpm_limit, - team_member_budget_duration=data.team_member_budget_duration, - team_member_model_max_budget=data.team_member_model_max_budget, - user_api_key_cache=user_api_key_cache, - explicitly_set_fields=_team_member_fields_in_request, - ) - # Backfill team_memberships for members who joined before the - # budget was configured — they won't have a membership row yet. - _backfill_budget_id: Final = (updated_kv.get("metadata") or {}).get("team_member_budget_id") - if _backfill_budget_id and existing_team_row.members_with_roles: - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=data.team_id, - members_with_roles=existing_team_row.members_with_roles, - team_member_budget_id=_backfill_budget_id, - prisma_client=prisma_client, - ) - await _evict_created_membership_caches( - user_ids=_member_user_ids(existing_team_row.members_with_roles), - team_id=data.team_id, - user_api_key_cache=user_api_key_cache, - ) - elif _team_member_fields_in_request: - updated_kv = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=existing_team_row, - user_api_key_dict=user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields=_team_member_fields_in_request, - user_api_key_cache=user_api_key_cache, - ) - else: - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) + default_budget_write: Final = plan_team_member_default_budget_write( + data=data, + existing_budget_id=stored_team_member_budget_id(existing_team), + team_alias=existing_team_row.team_alias, + team_budget_duration=existing_team_row.budget_duration, + ) + if default_budget_write is not None: + updated_kv["metadata"] = { + **(updated_kv.get("metadata") or {}), + "team_member_budget_id": default_budget_write.budget_id, + } + TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) # Check object permission if data.object_permission is not None: @@ -2744,7 +2597,27 @@ async def update_team( updated_kv = prisma_client.jsonify_team_object(db_data=updated_kv) team_update_data: Final[Mapping[str, object]] = updated_kv - team_row: Final = await _write_team_update(prisma_client, data.team_id, team_update_data, max_budget_guard) + team_write: Final = ( + _TeamWrite( + team_row=await _write_team_update( + _team_db(prisma_client), data.team_id, team_update_data, max_budget_guard + ), + linked_member_user_ids=(), + moved_member_budgets=None, + ) + if default_budget_write is None + else await _write_team_with_member_default_budget( + prisma_client, + team_id=data.team_id, + team_update_data=team_update_data, + max_budget_guard=max_budget_guard, + default_budget_write=default_budget_write, + backfill=data.team_member_budget_backfill or "none", + user_api_key_dict=user_api_key_dict, + changed_by=user_api_key_dict.user_id or litellm_proxy_admin_name, + ) + ) + team_row: Final = team_write.team_row if team_row is None or team_row.team_id is None: raise HTTPException( @@ -2753,6 +2626,16 @@ async def update_team( ) verbose_proxy_logger.info("Successfully updated team - %s, info", team_row.team_id) + if default_budget_write is not None: + await TeamMemberBudgetHandler._evict_default_budget_cache( + budget_id=default_budget_write.budget_id, user_api_key_cache=user_api_key_cache + ) + await _evict_team_member_cache_keys( + team_id=team_row.team_id, + member_user_ids=team_write.changed_member_user_ids(), + cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids())), + user_api_key_cache=user_api_key_cache, + ) await sync_team_access_group_membership(prisma_client=prisma_client, team_id=team_row.team_id) await invalidate_cached_object_permissions( object_permission_ids=(existing_team.object_permission_id, team_row.object_permission_id), @@ -2767,14 +2650,14 @@ async def update_team( if is_audit_logging_enabled(): await _create_team_update_audit_log( existing_team_row=existing_team_row, - updated_kv=updated_kv, + updated_kv=updated_kv | team_write.backfill_audit(), team_id=data.team_id, litellm_changed_by=litellm_changed_by, user_api_key_dict=user_api_key_dict, litellm_proxy_admin_name=litellm_proxy_admin_name, ) - return {"team_id": team_row.team_id, "data": team_row} + return {"team_id": team_row.team_id, "data": team_row} | team_write.backfill_response() except Exception as e: raise handle_exception_on_proxy(e) @@ -4094,6 +3977,7 @@ async def team_member_update( ### upsert new budget budget_patch: Final = member_budget_patch(data) async with prisma_client.tx() as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, data.team_id) role_change: Final = ( await _update_team_member_role( tx=tx, @@ -4955,22 +4839,23 @@ async def _invalidate_deleted_team_member_cache( user_api_key_cache: UserApiKeyCache, ) -> None: for team_id, member_user_ids in member_ids_per_team: - await _evict_deleted_team_member_cache( + await _evict_team_member_cache_keys( team_id=team_id, member_user_ids=member_user_ids, + cache_keys=tuple(member_cache_keys(team_id, member_user_ids)), user_api_key_cache=user_api_key_cache, ) -async def _evict_deleted_team_member_cache( +async def _evict_team_member_cache_keys( team_id: str, member_user_ids: Sequence[str], + cache_keys: Sequence[str], user_api_key_cache: UserApiKeyCache, ) -> None: _ = await asyncio.gather( *(await_inflight_team_membership_load(user_id=user_id, team_id=team_id) for user_id in member_user_ids) ) - cache_keys: Final = tuple(member_cache_keys(team_id, member_user_ids)) evict_local(cache_keys=cache_keys, user_api_key_cache=user_api_key_cache) await evict_shared(cache_keys=cache_keys, cache=user_api_key_cache) await broadcast_evictions(cache_keys=cache_keys) @@ -4979,6 +4864,11 @@ async def _evict_deleted_team_member_cache( def member_cache_keys(team_id: str, user_ids: Sequence[str]) -> Iterator[str]: for user_id in user_ids: yield user_id + yield from team_membership_cache_keys(team_id, (user_id,)) + + +def team_membership_cache_keys(team_id: str, user_ids: Sequence[str]) -> Iterator[str]: + for user_id in user_ids: yield team_membership_auth_cache_key(team_id=team_id, user_id=user_id) yield team_membership_reservation_cache_key(user_id=user_id, team_id=team_id) diff --git a/litellm/proxy/management_helpers/bulk_team_member_budgets.py b/litellm/proxy/management_helpers/bulk_team_member_budgets.py index 08169eab761..11f54cb02d5 100644 --- a/litellm/proxy/management_helpers/bulk_team_member_budgets.py +++ b/litellm/proxy/management_helpers/bulk_team_member_budgets.py @@ -30,6 +30,7 @@ from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # l member_budget_patch, upsert_budget_and_membership, # pyright: ignore[reportPrivateUsage] # the single-member write, shared so the two surfaces cannot drift ) +from litellm.proxy.management_helpers.access_group_team_sync import TEAM_ADVISORY_LOCK_SQL from litellm.proxy.management_helpers.audit_logs import create_object_audit_log from litellm.proxy.management_helpers.bulk_user_deletion import ( _duplicate_member_indexes, # pyright: ignore[reportPrivateUsage] # same duplicate rule as members/bulk_delete @@ -141,6 +142,7 @@ def _result( user_id: str | None, error: str | None, budget_of: "MappingProxyType[str, prisma_models.LiteLLM_BudgetTable | None]", + team_default_budget_id: str | None, team_default_max_budget: float | None, ) -> TeamMemberBudgetUpdateResult: if error is not None or user_id is None: @@ -151,7 +153,8 @@ def _result( error=error or "User not found in team", ) budget: Final = budget_of.get(user_id) - own_max_budget: Final = budget.max_budget if budget is not None else None + on_team_default: Final = budget is not None and budget.budget_id == team_default_budget_id + own_max_budget: Final = budget.max_budget if budget is not None and not on_team_default else None inherits: Final = own_max_budget is None and team_default_max_budget is not None and team_default_max_budget > 0 return TeamMemberBudgetUpdateResult( user_id=user_id, @@ -198,7 +201,12 @@ async def bulk_update_team_member_budgets( if not applied: return tuple( _result( - member, None, "Duplicate member in request" if index in duplicates else None, MappingProxyType({}), None + member, + None, + "Duplicate member in request" if index in duplicates else None, + MappingProxyType({}), + None, + None, ) for index, member in enumerate(data.members) ) @@ -208,6 +216,7 @@ async def bulk_update_team_member_budgets( team_members_filter: Final = _team_users_filter(team_id, user_ids) async with prisma_client.tx(timeout=_BATCH_TX_TIMEOUT) as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, team_id) memberships: Final = await _membership_tx_db(tx).find_many(where=team_members_filter, include=_WITH_BUDGET) budget_id_of: Final = MappingProxyType({m.user_id: m.budget_id for m in memberships}) shared: Final = await _shared_budget_ids( @@ -254,6 +263,7 @@ async def bulk_update_team_member_budgets( named[index], "Duplicate member in request" if index in duplicates else None, budget_of, + default_budget_id, team_default.max_budget if team_default is not None else None, ) for index, member in enumerate(data.members) diff --git a/litellm/proxy/management_helpers/team_member_default_budget.py b/litellm/proxy/management_helpers/team_member_default_budget.py new file mode 100644 index 00000000000..a8d2721ae38 --- /dev/null +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -0,0 +1,321 @@ +import json +import uuid +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from datetime import datetime +from types import MappingProxyType +from typing import TYPE_CHECKING, Final, assert_never + +from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, field_validator + +from litellm.litellm_core_utils.duration_parser import budget_reset_period_key +from litellm.proxy._types import ( + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, + UpdateTeamRequest, + UserAPIKeyAuth, +) +from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time +from litellm.proxy.management_endpoints.common_utils import ( + has_meaningful_budget_limit, + upsert_budget_and_membership, +) +from litellm.proxy.utils import jsonify_object + +if TYPE_CHECKING: + from prisma import Prisma + from prisma import models as prisma_models + + from litellm.repositories.prisma_protocols import TableActions + +MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: Final = 50_000 + +_DEFAULT_BUDGET_COLUMNS: Final = MappingProxyType( + { + "team_member_budget": "max_budget", + "team_member_rpm_limit": "rpm_limit", + "team_member_tpm_limit": "tpm_limit", + "team_member_budget_duration": "budget_duration", + "team_member_model_max_budget": "model_max_budget", + } +) + +_LINK_MISSING_MEMBERSHIPS_SQL: Final = """ +INSERT INTO "LiteLLM_TeamMembership" (user_id, team_id, budget_id) +SELECT member.user_id, $1, $2 FROM unnest($3::text[]) AS member(user_id) +ON CONFLICT (user_id, team_id) DO NOTHING +""" +_LINK_UNBUDGETED_MEMBERSHIPS_SQL: Final = ( + 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND budget_id IS NULL' +) +_RELINK_TO_DEFAULT_SQL: Final = ( + 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND user_id = ANY($3::text[])' +) +_CLEAR_MAX_BUDGET_SQL: Final = """ +UPDATE "LiteLLM_BudgetTable" SET max_budget = NULL, updated_by = $2, updated_at = (NOW() AT TIME ZONE 'UTC') +WHERE budget_id = ANY($1::text[]) +""" +_SHARED_BUDGET_IDS_SQL: Final = """ +SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[]) +GROUP BY budget_id HAVING COUNT(*) > 1 +""" +_CANDIDATES_BY_SCHEDULE_SQL: Final = """ +SELECT b.budget_duration AS duration, COUNT(*)::int AS members +FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id +WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} +GROUP BY b.budget_duration +""" +_CANDIDATES_SQL: Final = """ +SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, + b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry +FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id +WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} + AND (b.budget_duration = ANY($4::text[]) OR ($5::boolean AND b.budget_duration IS NULL)) +""" + + +@dataclass(frozen=True, slots=True) +class TeamMemberDefaultBudgetWrite: + budget_id: str + update: Mapping[str, object] + create: Mapping[str, object] + links_members: bool + + +@dataclass(frozen=True, slots=True) +class MovedMemberBudgets: + user_ids: tuple[str, ...] + skipped_other_reset_period: int + + def result(self) -> TeamMemberBudgetBackfillResult: + return TeamMemberBudgetBackfillResult( + moved_to_default=len(self.user_ids), skipped_other_reset_period=self.skipped_other_reset_period + ) + + +@dataclass(frozen=True, slots=True) +class TooManyMemberBudgetsToMove: + count: int + + +class _ScheduleCount(BaseModel): + model_config = ConfigDict(frozen=True) + + duration: str | None + members: int + + +class _BudgetLimits(BaseModel): + model_config = ConfigDict(frozen=True) + + soft_budget: float | None = None + max_parallel_requests: int | None = None + tpm_limit: int | None = None + rpm_limit: int | None = None + model_max_budget: JsonValue = None + budget_duration: str | None = None + allowed_models: tuple[str, ...] | None = None + temp_budget_increase: float | None = None + temp_budget_expiry: datetime | None = None + + @field_validator("model_max_budget", mode="before") + @classmethod + def _decode_json_column(cls, value: object) -> object: + return json.loads(value) if isinstance(value, str) else value + + def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool: + return has_meaningful_budget_limit( + {field: value for field, value in self.model_dump().items() if value != getattr(default, field)} + ) + + +class _MemberBudgetRef(BaseModel): + model_config = ConfigDict(frozen=True) + + user_id: str + budget_id: str + + +@dataclass(frozen=True, slots=True) +class _CustomMemberBudget: + ref: _MemberBudgetRef + keeps_own_limits: bool + + +class _BudgetIdRow(BaseModel): + model_config = ConfigDict(frozen=True) + + budget_id: str + + +_SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...]) +_MEMBER_BUDGET_REFS: Final = TypeAdapter(tuple[_MemberBudgetRef, ...]) +_MEMBER_BUDGET_LIMITS: Final = TypeAdapter(tuple[_BudgetLimits, ...]) +_BUDGET_IDS: Final = TypeAdapter(tuple[_BudgetIdRow, ...]) + + +def plan_team_member_default_budget_write( + data: UpdateTeamRequest, + existing_budget_id: str | None, + team_alias: str | None, + team_budget_duration: str | None, +) -> TeamMemberDefaultBudgetWrite | None: + requested: Final = data.model_dump(include=frozenset(_DEFAULT_BUDGET_COLUMNS) & data.model_fields_set) + sent: Final = MappingProxyType({_DEFAULT_BUDGET_COLUMNS[field]: value for field, value in requested.items()}) + links_members: Final = any(value is not None for value in sent.values()) + if not sent or (existing_budget_id is None and not links_members): + return None + create_duration: Final = sent["budget_duration"] if "budget_duration" in sent else team_budget_duration + created: Final = {**sent, "budget_duration": create_duration} + return TeamMemberDefaultBudgetWrite( + budget_id=existing_budget_id or _new_default_budget_id(team_alias), + update=_with_reset_at( + {column: {} if column == "model_max_budget" and value is None else value for column, value in sent.items()} + ), + create=_with_reset_at({column: value for column, value in created.items() if value is not None}), + links_members=links_members, + ) + + +async def write_team_member_default_budget( + tx: "Prisma", + write: TeamMemberDefaultBudgetWrite, + *, + team_id: str, + member_user_ids: Sequence[str], + changed_by: str, +) -> None: + """The caller holds the team advisory lock on ``tx``, so the members linked here are the whole roster.""" + stamps: Final = {"updated_by": changed_by} + await _budget_tx_db(tx).upsert( + where={"budget_id": write.budget_id}, + data={ + "create": jsonify_object( + {**write.create, **stamps, "budget_id": write.budget_id, "created_by": changed_by} + ), + "update": jsonify_object({**write.update, **stamps}), + }, + ) + if not write.links_members: + return + await tx.execute_raw(_LINK_MISSING_MEMBERSHIPS_SQL, team_id, write.budget_id, list(member_user_ids)) + await tx.execute_raw(_LINK_UNBUDGETED_MEMBERSHIPS_SQL, team_id, write.budget_id) + + +async def move_member_budgets_to_default( + tx: "Prisma", + *, + team_id: str, + default_budget_id: str, + backfill: TeamMemberBudgetBackfill, + changed_by: UserAPIKeyAuth, +) -> MovedMemberBudgets | TooManyMemberBudgetsToMove: + """Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move. + A member whose other limits all match the default is linked to the default row, while one holding a limit of its + own keeps its row with ``max_budget`` cleared.""" + direction: Final = _direction_sql(backfill) + if direction is None: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id}) + if default is None or default.max_budget is None: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + schedule: Final = budget_reset_period_key(default.budget_duration) + counts: Final = _SCHEDULE_COUNTS.validate_python( + await tx.query_raw( + _CANDIDATES_BY_SCHEDULE_SQL.format(direction=direction), team_id, default_budget_id, default.max_budget + ) + ) + matching: Final = tuple(count for count in counts if budget_reset_period_key(count.duration) == schedule) + moving: Final = sum(count.members for count in matching) + skipped: Final = sum(count.members for count in counts) - moving + if moving > MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: + return TooManyMemberBudgetsToMove(count=moving) + if moving == 0: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=skipped) + rows: Final = await tx.query_raw( + _CANDIDATES_SQL.format(direction=direction), + team_id, + default_budget_id, + default.max_budget, + [count.duration for count in matching if count.duration is not None], + any(count.duration is None for count in matching), + ) + default_limits: Final = _BudgetLimits.model_validate(default.model_dump()) + candidates: Final = tuple( + _CustomMemberBudget(ref=ref, keeps_own_limits=limits.has_own_limits_beyond(default_limits)) + for ref, limits in zip( + _MEMBER_BUDGET_REFS.validate_python(rows), _MEMBER_BUDGET_LIMITS.validate_python(rows), strict=True + ) + ) + await _move_to_default(tx, candidates, team_id=team_id, default_budget_id=default_budget_id, changed_by=changed_by) + return MovedMemberBudgets( + user_ids=tuple(candidate.ref.user_id for candidate in candidates), skipped_other_reset_period=skipped + ) + + +async def _move_to_default( + tx: "Prisma", + candidates: Sequence[_CustomMemberBudget], + *, + team_id: str, + default_budget_id: str, + changed_by: UserAPIKeyAuth, +) -> None: + keeping: Final = tuple(candidate.ref for candidate in candidates if candidate.keeps_own_limits) + relinking: Final = tuple(candidate.ref.user_id for candidate in candidates if not candidate.keeps_own_limits) + shared: Final = frozenset( + row.budget_id + for row in _BUDGET_IDS.validate_python( + await tx.query_raw(_SHARED_BUDGET_IDS_SQL, list({ref.budget_id for ref in keeping})) + ) + ) + await tx.execute_raw(_RELINK_TO_DEFAULT_SQL, team_id, default_budget_id, list(relinking)) + await tx.execute_raw( + _CLEAR_MAX_BUDGET_SQL, + list({ref.budget_id for ref in keeping if ref.budget_id not in shared}), + changed_by.user_id or "", + ) + for ref in keeping: + if ref.budget_id in shared: + await upsert_budget_and_membership( + tx, + team_id=team_id, + user_id=ref.user_id, + existing_budget_id=ref.budget_id, + user_api_key_dict=changed_by, + budget_patch=MappingProxyType({"max_budget": None}), + team_default_budget_id=default_budget_id, + shared_budget_ids=shared, + ) + + +def _budget_tx_db(tx: "Prisma") -> "TableActions[prisma_models.LiteLLM_BudgetTable]": + return tx.litellm_budgettable # pyright: ignore[reportReturnType] # TableActions widens the generated inputs to Mapping, as the repositories do + + +def _direction_sql(backfill: TeamMemberBudgetBackfill) -> str | None: + match backfill: + case "none": + return None + case "raise_to_default": + return "b.max_budget < $3::double precision" + case "lower_to_default": + return "b.max_budget > $3::double precision" + case "all_to_default": + return "b.max_budget <> $3::double precision" + case _: + assert_never(backfill) + + +def _with_reset_at(columns: Mapping[str, object]) -> Mapping[str, object]: + if "budget_duration" not in columns: + return MappingProxyType(dict(columns)) + duration: Final = columns["budget_duration"] + reset_at: Final = get_budget_reset_time(budget_duration=duration) if isinstance(duration, str) else None + return MappingProxyType({**columns, "budget_reset_at": reset_at}) + + +def _new_default_budget_id(team_alias: str | None) -> str: + if team_alias is None: + return f"team-budget-{uuid.uuid4().hex}" + return f"team-{team_alias.replace(' ', '-')}-budget-{uuid.uuid4().hex}" diff --git a/litellm/proxy/spend_tracking/budget_reservation.py b/litellm/proxy/spend_tracking/budget_reservation.py index 803df9f83ca..6e5322cdb32 100644 --- a/litellm/proxy/spend_tracking/budget_reservation.py +++ b/litellm/proxy/spend_tracking/budget_reservation.py @@ -37,6 +37,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_cache_key, project_spend_counter_key, tag_cache_key, + team_member_default_budget_cache_key, team_membership_reservation_cache_key, ) from litellm.proxy.spend_tracking.input_tokens import count_input_tokens, count_input_tokens_for_model @@ -744,7 +745,7 @@ async def _get_team_member_budget_counter( default_budget_id: Final = (team_object.metadata or {}).get("team_member_budget_id") if isinstance(default_budget_id, str): default_budget: Final = _CACHED_VALUE.validate_python( - await user_api_key_cache.async_get_cache(key=f"team_member_default_budget:{default_budget_id}") + await user_api_key_cache.async_get_cache(key=team_member_default_budget_cache_key(default_budget_id)) ) default_cap: Final = _to_float(_get_value(default_budget, "max_budget")) if default_cap is not None and default_cap > 0: diff --git a/tests/integration/management/test_team_member_budget_backfill.py b/tests/integration/management/test_team_member_budget_backfill.py new file mode 100644 index 00000000000..fbf64f80b29 --- /dev/null +++ b/tests/integration/management/test_team_member_budget_backfill.py @@ -0,0 +1,253 @@ +from collections.abc import Mapping +from dataclasses import dataclass + +import pytest +from prisma import Json + +from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE +from tests.integration._support.actors import create_scratch_team + +pytestmark = pytest.mark.asyncio(loop_scope="session") + +_OLD_DEFAULT = 40.0 +_NEW_DEFAULT = 50.0 +_PERIOD = "30d" + + +@dataclass(frozen=True) +class _Budget: + max_budget: float + budget_duration: str | None = _PERIOD + rpm_limit: int | None = None + + +_ROSTER: Mapping[str, _Budget | None] = { + "below": _Budget(20.0), + "above": _Budget(80.0), + "equal": _Budget(_NEW_DEFAULT), + "weekly": _Budget(10.0, budget_duration="7d"), + "own_rpm": _Budget(20.0, rpm_limit=5), + "on_default": None, +} + + +async def _seed_budget(db, budget_id: str, budget: _Budget) -> str: + await db.db.litellm_budgettable.create( + data={ + "budget_id": budget_id, + "max_budget": budget.max_budget, + "budget_duration": budget.budget_duration, + "rpm_limit": budget.rpm_limit, + "created_by": "backfill-test", + "updated_by": "backfill-test", + } + ) + return budget_id + + +async def _seed_membership(db, resources, name: str, budget_id: str | None) -> None: + key = {"user_id": resources.tag(name), "team_id": resources.prefix} + await db.db.litellm_teammembership.upsert( + where={"user_id_team_id": key}, + data={"create": {**key, "budget_id": budget_id}, "update": {"budget_id": budget_id}}, + ) + + +async def _seed_team( + db, + resources, + roster: Mapping[str, _Budget | None], + *, + unbudgeted: tuple[str, ...] = (), + rowless: tuple[str, ...] = (), +) -> str: + """``roster`` members hold their own budget, or the default when None. ``unbudgeted`` members have a membership + row with no budget, ``rowless`` ones are on the team with no membership row at all.""" + default_budget_id = await _seed_budget(db, resources.tag("default"), _Budget(_OLD_DEFAULT)) + await create_scratch_team( + db, resources.prefix, member_user_ids=[resources.tag(name) for name in (*roster, *unbudgeted, *rowless)] + ) + await db.db.litellm_teamtable.update( + where={"team_id": resources.prefix}, data={"metadata": Json({"team_member_budget_id": default_budget_id})} + ) + for name, budget in roster.items(): + own = None if budget is None else await _seed_budget(db, resources.tag(f"own-{name}"), budget) + await _seed_membership(db, resources, name, own or default_budget_id) + for name in unbudgeted: + await _seed_membership(db, resources, name, None) + await db.db.litellm_teammembership.delete_many( + where={"team_id": resources.prefix, "user_id": {"in": [resources.tag(name) for name in rowless]}} + ) + return default_budget_id + + +def _update_team(db, team_id: str, body: Mapping[str, object]): + return db.gateway.request("POST", "/team/update", {"team_id": team_id, **body}) + + +async def _member_budget(db, resources, name: str): + membership = await db.db.litellm_teammembership.find_unique( + where={"user_id_team_id": {"user_id": resources.tag(name), "team_id": resources.prefix}}, + include={"litellm_budget_table": True}, + ) + assert membership is not None + return membership + + +@pytest.mark.parametrize( + "backfill,moved,skipped", + [ + ("raise_to_default", {"below", "own_rpm"}, 1), + ("lower_to_default", {"above"}, 0), + ("all_to_default", {"below", "own_rpm", "above"}, 1), + ], +) +async def test_backfill_moves_only_members_on_the_chosen_side_of_the_new_default( + backfill: str, moved: set[str], skipped: int, db, resources +): + default_budget_id = await _seed_team(db, resources, _ROSTER) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": backfill}, + ) + + assert response.status_code == 200, response.text + assert response.json()["team_member_budget_backfill_result"] == { + "moved_to_default": len(moved), + "skipped_other_reset_period": skipped, + } + for name, budget in _ROSTER.items(): + membership = await _member_budget(db, resources, name) + if name == "own_rpm" and name in moved: + assert membership.budget_id == resources.tag("own-own_rpm") + assert membership.litellm_budget_table.max_budget is None + assert membership.litellm_budget_table.rpm_limit == 5 + elif name in moved or budget is None: + assert membership.budget_id == default_budget_id, name + else: + assert membership.litellm_budget_table.max_budget == budget.max_budget, name + default = await db.db.litellm_budgettable.find_unique(where={"budget_id": default_budget_id}) + assert default.max_budget == _NEW_DEFAULT + + +async def test_saving_a_new_default_without_backfill_keeps_every_custom_budget(db, resources): + await _seed_team(db, resources, _ROSTER) + + response = _update_team(db, resources.prefix, {"team_member_budget": _NEW_DEFAULT}) + + assert response.status_code == 200, response.text + assert "team_member_budget_backfill_result" not in response.json() + for name, budget in _ROSTER.items(): + if budget is not None: + assert (await _member_budget(db, resources, name)).litellm_budget_table.max_budget == budget.max_budget + + +async def test_backfill_gives_members_sharing_a_custom_budget_their_own_copy(db, resources): + await _seed_team(db, resources, {}) + shared_budget_id = await _seed_budget(db, resources.tag("shared"), _Budget(20.0, rpm_limit=5)) + for name in ("first", "second"): + await _seed_membership(db, resources, name, shared_budget_id) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + copies = [await _member_budget(db, resources, name) for name in ("first", "second")] + assert len({copy.budget_id for copy in copies} | {shared_budget_id}) == 3 + assert [(copy.litellm_budget_table.max_budget, copy.litellm_budget_table.rpm_limit) for copy in copies] == [ + (None, 5), + (None, 5), + ] + shared = await db.db.litellm_budgettable.find_unique(where={"budget_id": shared_budget_id}) + assert shared.max_budget == 20.0 + + +async def test_backfill_links_members_sharing_a_plain_custom_budget_to_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {}) + shared_budget_id = await _seed_budget(db, resources.tag("shared"), _Budget(20.0)) + for name in ("first", "second"): + await _seed_membership(db, resources, name, shared_budget_id) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + assert [(await _member_budget(db, resources, name)).budget_id for name in ("first", "second")] == [ + default_budget_id, + default_budget_id, + ] + shared = await db.db.litellm_budgettable.find_unique(where={"budget_id": shared_budget_id}) + assert shared.max_budget == 20.0 + + +async def test_backfill_over_the_member_cap_rolls_back_the_new_default(db, resources): + default_budget_id = await _seed_team(db, resources, {}) + over_cap = MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1 + await db.db.execute_raw( + """ + WITH members AS (SELECT $1 || '-bulk-' || n AS user_id FROM generate_series(1, $3::int) AS n), + budgets AS ( + INSERT INTO "LiteLLM_BudgetTable" (budget_id, max_budget, budget_duration, created_by, updated_by) + SELECT user_id, 20.0, $4, 'backfill-test', 'backfill-test' FROM members RETURNING budget_id + ) + INSERT INTO "LiteLLM_TeamMembership" (user_id, team_id, budget_id) + SELECT budget_id, $2, budget_id FROM budgets + """, + resources.prefix, + resources.prefix, + over_cap, + _PERIOD, + ) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 422, response.text + assert str(over_cap) in response.text + default = await db.db.litellm_budgettable.find_unique(where={"budget_id": default_budget_id}) + assert default.max_budget == _OLD_DEFAULT + sample = await db.db.litellm_budgettable.find_unique(where={"budget_id": f"{resources.prefix}-bulk-1"}) + assert sample.max_budget == 20.0 + + +async def test_backfill_without_a_new_default_is_rejected(resources, db): + await _seed_team(db, resources, {}) + + response = _update_team(db, resources.prefix, {"team_member_budget_backfill": "raise_to_default"}) + + assert response.status_code == 422, response.text + assert "team_member_budget_backfill needs a positive team_member_budget" in response.text + + +async def test_clearing_a_members_only_limit_links_them_back_to_the_team_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"capped": _Budget(20.0, budget_duration=None)}) + + response = db.gateway.request( + "POST", + f"/management/v1/teams/{resources.prefix}/members/bulk_update", + {"members": [{"user_id": resources.tag("capped"), "max_budget_in_team": None}]}, + ) + + assert response.status_code == 200, response.text + assert (await _member_budget(db, resources, "capped")).budget_id == default_budget_id + + +async def test_saving_a_default_links_every_roster_member_without_a_budget_to_it(db, resources): + default_budget_id = await _seed_team(db, resources, {}, unbudgeted=("no-budget",), rowless=("no-row",)) + + response = _update_team(db, resources.prefix, {"team_member_budget": _NEW_DEFAULT}) + + assert response.status_code == 200, response.text + for name in ("no-row", "no-budget"): + assert (await _member_budget(db, resources, name)).budget_id == default_budget_id, name diff --git a/tests/unit/litellm_core_utils/test_duration_parser.py b/tests/unit/litellm_core_utils/test_duration_parser.py index f14015effe6..4414542b019 100644 --- a/tests/unit/litellm_core_utils/test_duration_parser.py +++ b/tests/unit/litellm_core_utils/test_duration_parser.py @@ -6,8 +6,9 @@ from zoneinfo import ZoneInfo import pytest -import litellm.litellm_core_utils.duration_parser as duration_parser +from litellm.litellm_core_utils import duration_parser from litellm.litellm_core_utils.duration_parser import ( + budget_reset_period_key, duration_in_seconds, duration_in_seconds_from, get_budget_window_start, @@ -407,3 +408,26 @@ def test_a_month_starting_now_matches_duration_in_seconds(): if __name__ == "__main__": unittest.main() + + +@pytest.mark.parametrize( + "first,second,same_schedule", + [ + ("7d", "1w", True), + ("24h", "1d", True), + ("daily", "1d", True), + ("60s", "1m", True), + ("monthly", "30d", True), + (" 30d ", "30d", True), + ("1mo", "1mo", True), + (None, None, True), + ("1mo", "30d", False), + ("2mo", "1mo", False), + ("7d", "1d", False), + ("30d", None, False), + ("garbage", "garbage", True), + ("garbage", "30d", False), + ], +) +def test_budget_reset_period_key_matches_only_identical_schedules(first, second, same_schedule): + assert (budget_reset_period_key(first) == budget_reset_period_key(second)) is same_schedule diff --git a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py index 1f7154f0a74..9bd3217067a 100644 --- a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py +++ b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py @@ -85,6 +85,26 @@ async def test_empty_patch_is_noop(mock_tx, fake_user): mock_tx.litellm_budgettable.create.assert_not_called() +@pytest.mark.asyncio +async def test_clearing_all_limits_links_the_member_to_the_team_default(mock_tx, fake_user): + mock_tx.litellm_budgettable.find_unique = AsyncMock(return_value=budget_row(max_budget=100.0)) + + await upsert_budget_and_membership( + mock_tx, + team_id="team-1", + user_id="user-1", + existing_budget_id="bud-1", + user_api_key_dict=fake_user, + budget_patch={"max_budget": None}, + team_default_budget_id="team-default", + ) + + mock_tx.litellm_teammembership.update.assert_awaited_once_with( + where={"user_id_team_id": {"user_id": "user-1", "team_id": "team-1"}}, + data={"litellm_budget_table": {"connect": {"budget_id": "team-default"}}}, + ) + + # TEST: clearing every limit on a member's private budget disconnects it, so the # member falls back to the team default instead of keeping an empty private row. @pytest.mark.asyncio diff --git a/tests/unit/proxy/management_endpoints/management_v1/test_teams.py b/tests/unit/proxy/management_endpoints/management_v1/test_teams.py index 5d1c658b143..9b47e0575bd 100644 --- a/tests/unit/proxy/management_endpoints/management_v1/test_teams.py +++ b/tests/unit/proxy/management_endpoints/management_v1/test_teams.py @@ -137,6 +137,8 @@ class _MembershipTable: relation: Final = data.get("litellm_budget_table") if isinstance(relation, dict) and relation.get("disconnect"): self.rows[index] = self.rows[index].model_copy(update={"budget_id": None}) + if isinstance(relation, dict) and isinstance(connected := relation.get("connect"), dict): + self.rows[index] = self.rows[index].model_copy(update={"budget_id": connected["budget_id"]}) return self.rows[index] async def upsert(self, where: Mapping[str, Mapping[str, str]], data: Mapping[str, object]) -> _MembershipRow: @@ -180,6 +182,9 @@ class _Db: self.litellm_budgettable = _BudgetTable(budgets) self.litellm_teammembership = _MembershipTable(self.litellm_budgettable, memberships) + async def query_raw(self, query: str, *args: object) -> list[object]: + return [] + class _FakePrisma: def __init__( @@ -406,6 +411,20 @@ async def test_an_omitted_field_is_kept_an_explicit_null_clears_it_and_clearing_ assert _budget_id_of(prisma, "m1") is None +@pytest.mark.asyncio +async def test_clearing_the_last_limit_links_the_member_back_to_the_team_default(): + prisma = _FakePrisma( + teams=[_team("m1", default_budget_id="team-default")], + memberships=[_membership("m1", "priv-m1")], + budgets=[_budget("team-default", max_budget=50.0), _budget("priv-m1", max_budget=10.0)], + ) + + emptied = await _bulk_update(prisma, [{"user_id": "m1", "max_budget_in_team": None}]) + + assert emptied[0].success is True + assert _budget_id_of(prisma, "m1") == "team-default" + + @pytest.mark.asyncio async def test_budget_duration_seeds_a_reset_time_derived_from_the_duration_and_clearing_it_clears_the_reset(): prisma = _FakePrisma( @@ -566,8 +585,8 @@ async def test_an_explicit_cap_reports_as_the_members_own_while_clearing_one_fal ("m1", 50.0, "member"), ("m2", 25.0, "team_default"), ] - assert results[1].budget_id is None - assert _budget_id_of(prisma, "m2") is None + assert results[1].budget_id == "team-default" + assert _budget_id_of(prisma, "m2") == "team-default" assert prisma.db.litellm_budgettable.rows["team-default"].max_budget == 25.0 diff --git a/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py b/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py index 4af57a83395..d3da03c51a8 100644 --- a/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py +++ b/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py @@ -19,7 +19,11 @@ from litellm.proxy.management_endpoints.team_admin_field_permissions import ( TeamAdminEditingDisabled, TeamAdminFieldNotPermitted, TeamAdminKeyEditAllowed, + TeamAdminMemberKeyCreationAllowed, + TeamAdminMemberKeyCreationDisabled, TeamAdminMemberKeyEditingDisabled, + TeamAdminMemberKeyOwnerNotPermitted, + TeamAdminMemberKeyTypeNotPermitted, TeamAdminMetadataKeyProxyControlled, TeamMemberDefaults, changed_key_fields, @@ -34,10 +38,6 @@ from litellm.proxy.management_endpoints.team_admin_field_permissions import ( team_admin_may_raise_max_budget, team_admin_member_key_creation_or_raise, team_admin_member_key_creation_verdict, - TeamAdminMemberKeyCreationAllowed, - TeamAdminMemberKeyCreationDisabled, - TeamAdminMemberKeyOwnerNotPermitted, - TeamAdminMemberKeyTypeNotPermitted, team_admin_request_or_raise, ) @@ -240,6 +240,29 @@ class TestTeamMemberDefaultEdits: assert isinstance(verdict, TeamAdminEditAllowed) assert verdict.request.model_dump(exclude_unset=True) == {"team_id": "team-1", "tpm_limit": 6} + def test_backfill_onto_the_unchanged_default_keeps_the_default_it_compares_against(self): + data: Final = UpdateTeamRequest( + team_id="team-1", team_member_budget=10.0, team_member_budget_backfill="raise_to_default" + ) + verdict: Final = team_admin_edit_verdict( + data, _team(), _permitted("team_member_budget"), _STORED_MEMBER_DEFAULTS + ) + assert isinstance(verdict, TeamAdminEditAllowed) + assert verdict.request.model_dump(exclude_unset=True) == { + "team_id": "team-1", + "team_member_budget": 10.0, + "team_member_budget_backfill": "raise_to_default", + } + + def test_backfill_needs_the_member_budget_enabled(self): + data: Final = UpdateTeamRequest( + team_id="team-1", team_member_budget=10.0, team_member_budget_backfill="lower_to_default" + ) + verdict: Final = team_admin_edit_verdict( + data, _team(), _permitted("team_member_budget_duration"), _STORED_MEMBER_DEFAULTS + ) + assert verdict == TeamAdminFieldNotPermitted(field="team_member_budget_backfill") + def test_nulls_resent_for_a_team_without_member_defaults_are_dropped(self): data: Final = UpdateTeamRequest( team_id="team-1", diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 37028558af3..9e3946daaec 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -1,4 +1,5 @@ import asyncio +import contextlib import json from collections.abc import Mapping, Sequence from contextlib import AbstractContextManager, ExitStack, asynccontextmanager, contextmanager @@ -2866,172 +2867,6 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): assert exc_info.value.detail == {"error": "Team not found, passed team_id=team-1234"} -@pytest.mark.asyncio -async def test_update_team_team_member_budget_not_passed_to_db( - disable_audit_logging_for_mocked_team, -): - """ - Test that 'team_member_budget' is never passed to prisma_client.db.litellm_teamtable.update - regardless of whether the value is set or None. - - This ensures that team_member_budget is properly handled via the separate budget table - and not accidentally passed to the team table update operation. - """ - from unittest.mock import AsyncMock, MagicMock, Mock, patch - - from fastapi import Request - - from litellm.proxy._types import LitellmUserRoles, UpdateTeamRequest, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import update_team - - # Mock dependencies - mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, - patch("litellm.proxy.proxy_server.llm_router") as mock_llm_router, - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, - patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_logging, - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", - new_callable=AsyncMock, - ) as mock_cache_team, - patch( - "litellm.proxy.management_endpoints.team_endpoints.TeamMemberBudgetHandler.upsert_team_member_budget_table" - ) as mock_upsert_budget, - ): - # Setup mock prisma client - mock_existing_team = MagicMock() - mock_existing_team.model_dump.return_value = { - "team_id": "test_team_id", - "team_alias": "test_team", - "metadata": {"team_member_budget_id": "budget_123"}, - } - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) - - # Mock the update return value - mock_updated_team = MagicMock() - mock_updated_team.team_id = "test_team_id" - mock_updated_team.model_dump.return_value = {"team_id": "test_team_id"} - mock_prisma_client.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) - mock_prisma_client.jsonify_team_object = MagicMock( - side_effect=lambda db_data: db_data - ) - - # Mock budget upsert to return updated_kv without team_member_budget - def mock_upsert_side_effect( - team_table, - user_api_key_dict, - updated_kv, - team_member_budget=None, - team_member_rpm_limit=None, - team_member_tpm_limit=None, - team_member_budget_duration=None, - team_member_model_max_budget=None, - user_api_key_cache=None, - explicitly_set_fields=frozenset(), - ): - # Remove team_member_budget from updated_kv as the real function does - result_kv = updated_kv.copy() - result_kv.pop("team_member_budget", None) - return result_kv - - mock_upsert_budget.side_effect = mock_upsert_side_effect - - # Test Case 1: team_member_budget is set (not None) - update_request_with_budget = UpdateTeamRequest( - team_id="test_team_id", team_member_budget=100.0, team_alias="updated_alias" - ) - - result = await update_team( - data=update_request_with_budget, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - # Verify other fields are present (team_alias should be there) - assert "team_alias" in update_data or "team_id" in str( - call_args - ), "Expected team update fields should be present" - - # Reset mock for second test - mock_prisma_client.db.litellm_teamtable.update.reset_mock() - - # Test Case 2: team_member_budget is None - update_request_without_budget = UpdateTeamRequest( - team_id="test_team_id", - team_member_budget=None, - team_alias="updated_alias_2", - ) - - result = await update_team( - data=update_request_without_budget, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called again - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments for second call - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - # Test Case 3: No team_member_budget field at all (excluded from request) - mock_prisma_client.db.litellm_teamtable.update.reset_mock() - - update_request_no_budget_field = UpdateTeamRequest( - team_id="test_team_id", - team_alias="updated_alias_3", - # team_member_budget not specified at all - ) - - result = await update_team( - data=update_request_no_budget_field, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called again - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments for third call - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - print( - "✅ All test cases passed: team_member_budget is properly excluded from database update operations" - ) def test_clean_team_member_fields(): @@ -3197,165 +3032,10 @@ async def test_create_team_member_budget_table_without_team_alias(): assert budget_request.budget_id.startswith("team-budget-") -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_existing_budget(): - """ - Test that upsert_team_member_budget_table updates an existing budget when team_member_budget_id exists. - """ - from unittest.mock import AsyncMock, MagicMock, patch - - from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {"team_member_budget_id": "existing_budget_123"} - - updated_kv = { - "team_id": "test_team_id", - "team_member_budget": 200.0, - "team_member_budget_duration": "60d", - "team_member_rpm_limit": 100, - } - - mock_budget_response = MagicMock() - mock_budget_response.budget_id = "existing_budget_123" - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - mock_update_budget.return_value = mock_budget_response - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=200.0, - team_member_budget_duration="60d", - team_member_rpm_limit=100, - ) - - assert mock_update_budget.called - call_args = mock_update_budget.call_args - budget_request = call_args[1]["budget_obj"] - - assert budget_request.budget_id == "existing_budget_123" - assert budget_request.max_budget == 200.0 - assert budget_request.budget_duration == "60d" - assert budget_request.rpm_limit == 100 - - assert "team_member_budget_id" in result["metadata"] - assert result["metadata"]["team_member_budget_id"] == "existing_budget_123" - - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result - assert "team_member_rpm_limit" not in result -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_no_existing_budget(): - """ - Test that upsert_team_member_budget_table creates a new budget when team_member_budget_id does not exist. - """ - from unittest.mock import AsyncMock, MagicMock, patch - - from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {} - team_table.team_alias = "Test Team" - team_table.budget_duration = None - - updated_kv = { - "team_id": "test_team_id", - "team_member_budget": 150.0, - "team_member_budget_duration": "45d", - } - - mock_budget_response = MagicMock() - mock_budget_response.budget_id = "new_budget_456" - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.new_budget", - new_callable=AsyncMock, - ) as mock_new_budget: - mock_new_budget.return_value = mock_budget_response - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=150.0, - team_member_budget_duration="45d", - ) - - assert mock_new_budget.called - assert "team_member_budget_id" in result["metadata"] - assert result["metadata"]["team_member_budget_id"] == "new_budget_456" - - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_clears_duration_kept_budget(mock_db_client): - """ - A request that keeps team_member_budget but explicitly nulls - team_member_budget_duration must clear the reset period and its reset time. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {"team_member_budget_id": "existing_budget_123"} - - mock_db_client.db.litellm_budgettable.update = AsyncMock( - side_effect=lambda where, data: SimpleNamespace(**data) - ) - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv={ - "team_id": "test_team_id", - "team_member_budget": 100.0, - "team_member_budget_duration": None, - }, - team_member_budget=100.0, - team_member_budget_duration=None, - explicitly_set_fields={ - "team_member_budget", - "team_member_budget_duration", - }, - ) - - written = mock_db_client.db.litellm_budgettable.update.call_args.kwargs["data"] - assert written["max_budget"] == 100.0 - assert written["budget_duration"] is None - assert written["budget_reset_at"] is None - assert "rpm_limit" not in written - assert "tpm_limit" not in written - assert result["metadata"]["team_member_budget_id"] == "existing_budget_123" - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result @pytest.mark.asyncio @@ -3442,299 +3122,14 @@ async def test_create_team_member_budget_table_inherits_team_duration_when_durat assert result["metadata"]["team_member_budget_id"] == written["budget_id"] -@pytest.mark.asyncio -async def test_update_team_with_team_member_budget_duration( - disable_audit_logging_for_mocked_team, -): - """ - Test that team/update endpoint properly handles team_member_budget_duration. - """ - from unittest.mock import AsyncMock, MagicMock, Mock, patch - - from fastapi import Request - - from litellm.proxy._types import LitellmUserRoles, UpdateTeamRequest, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import update_team - - mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, - patch("litellm.proxy.proxy_server.llm_router") as mock_llm_router, - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, - patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_logging, - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", - new_callable=AsyncMock, - ) as mock_cache_team, - patch( - "litellm.proxy.management_endpoints.team_endpoints.TeamMemberBudgetHandler.upsert_team_member_budget_table" - ) as mock_upsert_budget, - ): - mock_existing_team = MagicMock() - mock_existing_team.model_dump.return_value = { - "team_id": "test_team_id", - "team_alias": "test_team", - "metadata": {"team_member_budget_id": "budget_123"}, - } - mock_existing_team.metadata = {"team_member_budget_id": "budget_123"} - mock_existing_team.members_with_roles = [] - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) - - mock_updated_team = MagicMock() - mock_updated_team.team_id = "test_team_id" - mock_updated_team.model_dump.return_value = {"team_id": "test_team_id"} - mock_prisma_client.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) - mock_prisma_client.jsonify_team_object = MagicMock( - side_effect=lambda db_data: db_data - ) - - def mock_upsert_side_effect( - team_table, - user_api_key_dict, - updated_kv, - team_member_budget=None, - team_member_rpm_limit=None, - team_member_tpm_limit=None, - team_member_budget_duration=None, - team_member_model_max_budget=None, - user_api_key_cache=None, - explicitly_set_fields=frozenset(), - ): - result_kv = updated_kv.copy() - result_kv.pop("team_member_budget", None) - result_kv.pop("team_member_budget_duration", None) - return result_kv - - mock_upsert_budget.side_effect = mock_upsert_side_effect - - update_request = UpdateTeamRequest( - team_id="test_team_id", - team_alias="updated_alias", - team_member_budget=100.0, - team_member_budget_duration="30d", - ) - - result = await update_team( - data=update_request, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - assert mock_upsert_budget.called - call_args = mock_upsert_budget.call_args - assert call_args[1]["team_member_budget"] == 100.0 - assert call_args[1]["team_member_budget_duration"] == "30d" - - assert mock_prisma_client.db.litellm_teamtable.update.called - update_call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = update_call_args[1]["data"] - - assert "team_member_budget" not in update_data - assert "team_member_budget_duration" not in update_data -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_creates_missing_memberships(): - """ - When backfill_team_member_budget_entries is called, it should create - team_memberships rows only for members that don't already have one. - - Regression test for: https://github.com/BerriAI/litellm/issues/25506 - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - # user-A already has a membership; user-B does not - existing_membership = MagicMock() - existing_membership.user_id = "user-A" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_membership] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=0) - - # Test with Member instances - members = [ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - # find_many should have been called to fetch existing memberships - mock_prisma.db.litellm_teammembership.find_many.assert_awaited_once_with( - where={"team_id": team_id} - ) - - # create_many should only create an entry for user-B (user-A already has one) - mock_prisma.db.litellm_teammembership.create_many.assert_awaited_once_with( - data=[{"team_id": team_id, "user_id": "user-B", "budget_id": budget_id}], - skip_duplicates=True, - ) - - # Also test with raw dicts (members_with_roles may be dicts when deserialized from DB) - mock_prisma.db.litellm_teammembership.find_many.reset_mock() - mock_prisma.db.litellm_teammembership.create_many.reset_mock() - mock_prisma.db.litellm_teammembership.update_many.reset_mock() - - members_as_dicts = [ - {"user_id": "user-A", "role": "user"}, - {"user_id": "user-B", "role": "user"}, - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members_as_dicts, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_awaited_once_with( - data=[{"team_id": team_id, "user_id": "user-B", "budget_id": budget_id}], - skip_duplicates=True, - ) -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_no_op_when_all_exist(): - """ - backfill_team_member_budget_entries should not call create_many when all - members already have a team_memberships entry. - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - existing_a = MagicMock() - existing_a.user_id = "user-A" - existing_b = MagicMock() - existing_b.user_id = "user-B" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_a, existing_b] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=0) - - members = [ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_populates_null_budget_id_on_existing_rows(): - """ - backfill_team_member_budget_entries should populate budget_id on - existing TeamMembership rows where it is currently NULL, so admins - can configure a team member budget after members have already joined - and have enforcement apply to those pre-existing members. - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - # Both members already have rows, so create_many must not fire; - # update_many must fire with the NULL-budget_id filter. - existing_a = MagicMock() - existing_a.user_id = "user-A" - existing_b = MagicMock() - existing_b.user_id = "user-B" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_a, existing_b] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=2) - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=[ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ], - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() - mock_prisma.db.litellm_teammembership.update_many.assert_awaited_once_with( - where={"team_id": team_id, "budget_id": None}, - data={"budget_id": budget_id}, - ) -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_empty_members(): - """ - backfill_team_member_budget_entries should be a no-op when the member list - is empty (no DB queries at all). - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock(return_value=[]) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id="team-abc", - members_with_roles=[], - team_member_budget_id="budget-xyz", - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.find_many.assert_not_awaited() - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() @pytest.mark.asyncio @@ -9978,7 +9373,7 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo team_membership_auth_cache_key, team_membership_reservation_cache_key, ) - from litellm.proxy.management_endpoints.team_endpoints import _evict_deleted_team_member_cache + from litellm.proxy.management_endpoints.team_endpoints import _evict_team_member_cache_keys, member_cache_keys redis: Final = _BroadcastRecordingRedis(round_trip_seconds=0.001) monkeypatch.setattr(pubsub_module, "coordination_redis_cache", lambda: redis) @@ -9986,8 +9381,11 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo monkeypatch.setattr(pubsub_module, "_in_flight_publishes", asyncio.Semaphore(16)) members: Final = tuple(f"member-{index:03d}" for index in range(500)) - await _evict_deleted_team_member_cache( - team_id="team-large", member_user_ids=members, user_api_key_cache=UserApiKeyCache() + await _evict_team_member_cache_keys( + team_id="team-large", + member_user_ids=members, + cache_keys=tuple(member_cache_keys("team-large", members)), + user_api_key_cache=UserApiKeyCache(), ) await asyncio.gather(*pubsub_module._pending_publishes) # pyright: ignore[reportPrivateUsage] # drain module-level tasks @@ -11612,45 +11010,6 @@ async def test_create_team_member_budget_table_with_duration(): assert result["metadata"]["team_member_budget_id"] == "budget-abc" -@pytest.mark.asyncio -async def test_upsert_team_member_model_max_budget_updates_default_budget_and_evicts_cache(): - from litellm.proxy.management_endpoints.team_endpoints import TeamMemberBudgetHandler - - model_budget: Final = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}} - team_table: Final = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "member-budget-1"}, - members_with_roles=[], - ) - cache: Final = MagicMock() - cache.async_delete_cache = AsyncMock() - budget_cache: Final = MagicMock() - budget_cache.async_delete_cache = AsyncMock() - prisma: Final = MagicMock() - prisma.db.litellm_budgettable.update = AsyncMock(return_value=MagicMock(budget_id="member-budget-1")) - - with ( - patch("litellm.proxy.proxy_server.prisma_client", prisma), - patch("litellm.proxy.proxy_server.user_api_key_cache", budget_cache), - patch("litellm.proxy.proxy_server.premium_user", True), - ): - result: Final = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), - updated_kv={"team_id": "test-team", "team_member_model_max_budget": model_budget}, - team_member_model_max_budget=model_budget, - user_api_key_cache=cache, - explicitly_set_fields={"team_member_model_max_budget"}, - ) - - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - assert json.loads(budget_update["data"]["model_max_budget"]) == model_budget - assert result["metadata"]["team_member_budget_id"] == "member-budget-1" - assert "team_member_model_max_budget" not in result - cache.async_delete_cache.assert_awaited_once_with(key="team_member_default_budget:member-budget-1") - budget_cache.async_delete_cache.assert_awaited_once_with(key="team_member_default_budget:member-budget-1") @pytest.mark.asyncio @@ -11675,7 +11034,6 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts updated.metadata = {"team_member_budget_id": "member-budget-1"} updated.model_dump.return_value.update({"metadata": updated.metadata, "members_with_roles": []}) updated.litellm_model_table = None - update_budget_response: Final = MagicMock(budget_id="member-budget-1") prisma: Final = MagicMock() with ( @@ -11687,7 +11045,7 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) prisma.jsonify_team_object = lambda db_data: db_data prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) - prisma.db.litellm_budgettable.update = AsyncMock(return_value=update_budget_response) + _transaction_over(prisma) request_data: Final = UpdateTeamRequest(team_id="standalone-team-123", team_member_model_max_budget=None) await update_team( @@ -11696,16 +11054,10 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), ) - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["model_max_budget"] == "{}" - assert "team_member_model_max_budget" in request_data.model_fields_set - assert "model_max_budget" in budget_update["data"] - assert cache.async_delete_cache.await_args_list == [ - call(key="team_member_default_budget:member-budget-1"), - call(key="team_member_default_budget:member-budget-1"), - ] + budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs + assert budget_upsert["where"]["budget_id"] == "member-budget-1" + assert budget_upsert["data"]["update"]["model_max_budget"] == "{}" + assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] @pytest.mark.asyncio @@ -11731,7 +11083,6 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( updated.metadata = {"team_member_budget_id": "member-budget-1"} updated.model_dump.return_value.update({"metadata": updated.metadata, "members_with_roles": []}) updated.litellm_model_table = None - update_budget_response: Final = MagicMock(budget_id="member-budget-1") prisma: Final = MagicMock() with ( @@ -11743,7 +11094,7 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) prisma.jsonify_team_object = lambda db_data: db_data prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) - prisma.db.litellm_budgettable.update = AsyncMock(return_value=update_budget_response) + _transaction_over(prisma) await update_team( data=UpdateTeamRequest(team_id="standalone-team-123", team_member_model_max_budget=member_caps), @@ -11751,10 +11102,9 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), ) - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - stored_member_model_caps: Final = json.loads(budget_update["data"]["model_max_budget"]) + budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs + assert budget_upsert["where"]["budget_id"] == "member-budget-1" + stored_member_model_caps: Final = json.loads(budget_upsert["data"]["update"]["model_max_budget"]) assert { model: { **budget, @@ -11770,10 +11120,7 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( "rpm_limit": None, } } - assert cache.async_delete_cache.await_args_list == [ - call(key="team_member_default_budget:member-budget-1"), - call(key="team_member_default_budget:member-budget-1"), - ] + assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] # --------------------------------------------------------------------------- @@ -12795,209 +12142,12 @@ def test_set_budget_reset_at_sets_value_when_budget_duration_provided(): assert updated_kv["budget_reset_at"] is not None -@pytest.mark.asyncio -async def test_clear_team_member_budget_duration_calls_update_budget(): - """ - When team_member_budget_duration is explicitly null and a budget row - exists, clear_team_member_budget_fields should call update_budget - with budget_duration=None and budget_reset_at=None. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-123"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget_duration": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget_duration"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-123" - assert "budget_duration" in budget_request.model_fields_set - assert budget_request.budget_duration is None - assert "budget_reset_at" in budget_request.model_fields_set - assert budget_request.budget_reset_at is None - assert "team_member_budget_duration" not in result -@pytest.mark.asyncio -async def test_clear_team_member_budget_clears_max_budget(): - """ - When team_member_budget is explicitly null, clear_team_member_budget_fields - should call update_budget with max_budget=None. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-456"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-456" - assert "max_budget" in budget_request.model_fields_set - assert budget_request.max_budget is None - assert "team_member_budget" not in result -@pytest.mark.asyncio -async def test_clear_team_member_rpm_tpm_limits(): - """ - When team_member_rpm_limit and team_member_tpm_limit are explicitly null, - clear_team_member_budget_fields should clear both on the budget row. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-789"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_rpm_limit": None, - "team_member_tpm_limit": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_rpm_limit", "team_member_tpm_limit"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-789" - assert "rpm_limit" in budget_request.model_fields_set - assert budget_request.rpm_limit is None - assert "tpm_limit" in budget_request.model_fields_set - assert budget_request.tpm_limit is None - assert "team_member_rpm_limit" not in result - assert "team_member_tpm_limit" not in result -@pytest.mark.asyncio -async def test_clear_all_team_member_fields_at_once(): - """ - When all team_member fields are explicitly null, all corresponding - budget row fields should be cleared in a single update. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-all"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - "team_member_budget_duration": None, - "team_member_rpm_limit": None, - "team_member_tpm_limit": None, - } - - all_fields = { - "team_member_budget", - "team_member_budget_duration", - "team_member_rpm_limit", - "team_member_tpm_limit", - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields=all_fields, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-all" - assert budget_request.max_budget is None - assert budget_request.budget_duration is None - assert budget_request.budget_reset_at is None - assert budget_request.rpm_limit is None - assert budget_request.tpm_limit is None - for field in all_fields: - assert field not in result @pytest.mark.asyncio @@ -13031,44 +12181,6 @@ async def test_team_member_budget_duration_not_sent_does_not_update(): assert "team_member_budget" not in updated_kv -@pytest.mark.asyncio -async def test_clear_team_member_budget_fields_no_budget_row_skips_update(): - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata=None, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - "team_member_rpm_limit": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget", "team_member_rpm_limit"}, - ) - - mock_update_budget.assert_not_awaited() - assert "team_member_budget" not in result - assert "team_member_rpm_limit" not in result @pytest.mark.asyncio @@ -13435,6 +12547,7 @@ async def _drive_team_write( return_value=LiteLLM_TeamTable(team_id=_PATCH_TEAM_ID, team_alias="t") ) pc.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) + _transaction_over(pc) if mock_sink is not None: mock_sink["update"] = pc.db.litellm_teamtable.update @@ -13567,14 +12680,8 @@ _STORED_METADATA_WITH_BUDGET: Final = { async def _written_metadata_with_budget(kind, body): """Like ``_written_metadata`` but the team already owns a member budget row.""" - from litellm.proxy._types import LiteLLM_BudgetTable - - with ( - patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( # test-quality-ok: update_team imports update_budget at call time; the module attribute is its only seam - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - AsyncMock(return_value=LiteLLM_BudgetTable(budget_id="budget-existing-123")), - ), + with patch( # test-quality-ok: proxy_server module global is the endpoint's only injection point + "litellm.proxy.proxy_server.premium_user", True ): return await _written_metadata(kind, dict(_STORED_METADATA_WITH_BUDGET), body) @@ -16743,25 +15850,6 @@ async def test_evict_created_membership_caches_drops_the_negative_sentinel(): assert await cache.async_get_cache(key=kept_key) == NO_TEAM_MEMBERSHIP_SENTINEL -def test_member_user_ids_keeps_only_string_user_ids(): - """ - The /team/update backfill feeds Prisma-deserialized member dicts here; a row can be missing - user_id or carry a non-string value. Only real string ids may reach invalidate_team_member_spend_state, - so those get eviction and the malformed rows are dropped rather than crashing the update. - """ - from litellm.proxy.management_endpoints.team_endpoints import _member_user_ids - - members = [ - {"user_id": "alice", "role": "admin"}, - {"role": "user"}, - {"user_id": None, "role": "user"}, - {"user_id": 123, "role": "user"}, - {"user_id": "bob", "role": "user"}, - ] - - assert _member_user_ids(members) == ("alice", "bob") - - def _team_spend_by_user_team(team_id: str, team_alias: str, member: Member, permissions: list[str]) -> MagicMock: team = MagicMock(spec=LiteLLM_TeamTable) team.team_id = team_id @@ -17292,6 +16380,23 @@ async def test_new_team_rejects_unenforceable_model_max_budget(mock_db_client, m mock_db_client.db.litellm_teamtable.create.assert_not_awaited() +def _transaction_over(prisma: MagicMock) -> MagicMock: + """A transaction that writes through ``prisma.db``'s own table mocks, as the real one writes the same rows.""" + tx: Final = MagicMock() + tx.litellm_teamtable = prisma.db.litellm_teamtable + tx.litellm_budgettable = prisma.db.litellm_budgettable + tx.query_raw = AsyncMock(return_value=[{"members_with_roles": []}]) + tx.execute_raw = AsyncMock(return_value=0) + prisma.db.litellm_budgettable.upsert = AsyncMock() + + @contextlib.asynccontextmanager + async def transaction(**_options: object): + yield tx + + prisma.tx = transaction + return tx + + def _existing_team_with_model_caps(caps): existing = MagicMock() existing.team_id = "standalone-team-123" diff --git a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py index 644f0656c7a..d16ec9921a2 100644 --- a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py +++ b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py @@ -44,9 +44,7 @@ async def test_management_otel_span_redacts_mcp_global_env_var_secrets(monkeypat captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook( - self, logging_payload, parent_otel_span - ): + async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -119,9 +117,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook( - self, logging_payload, parent_otel_span - ): + async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -141,9 +137,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( created_at=datetime.datetime.now(), updated_at=datetime.datetime.now(), ) - result = MCPSubmissionsSummary( - total=1, pending_review=1, active=0, rejected=0, items=[server] - ) + result = MCPSubmissionsSummary(total=1, pending_review=1, active=0, rejected=0, items=[server]) await mgmt_utils._emit_management_endpoint_otel_span( func=lambda: None, @@ -158,11 +152,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( assert secret not in str(captured["response"]) redacted_item = captured["response"]["items"][0] - redacted_env_vars = ( - redacted_item["env_vars"] - if isinstance(redacted_item, dict) - else redacted_item.env_vars - ) + redacted_env_vars = redacted_item["env_vars"] if isinstance(redacted_item, dict) else redacted_item.env_vars assert [entry["value"] for entry in redacted_env_vars] == [""] assert redacted_env_vars[0]["name"] == "DB_PASSWORD" # The endpoint's own return value is untouched for the admin UI. @@ -180,9 +170,7 @@ async def test_add_new_member_links_default_team_budget_id(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -195,15 +183,11 @@ async def test_add_new_member_links_default_team_budget_id(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() # Mock the team membership creation @@ -214,9 +198,7 @@ async def test_add_new_member_links_default_team_budget_id(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -242,9 +224,7 @@ async def test_add_new_member_links_default_team_budget_id(): ) mock_prisma_client.db.litellm_budgettable.create.assert_not_called() - team_membership_call_args = ( - mock_prisma_client.db.litellm_teammembership.upsert.call_args - ) + team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_default_budget_id @@ -314,9 +294,7 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="missing-default-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -327,9 +305,7 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_membership = MagicMock() @@ -367,9 +343,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="dur-clone-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -380,9 +354,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_default_budget_row = MagicMock() mock_default_budget_row.model_dump.return_value = { "budget_id": "default-dc", @@ -395,14 +367,10 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_duration": "1d", "allowed_models": [], } - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_cloned_budget_row = MagicMock() mock_cloned_budget_row.budget_id = "cloned-dc" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_cloned_budget_row - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_cloned_budget_row) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dc", @@ -410,9 +378,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_id": "cloned-dc", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) await add_new_member( new_member=new_member, @@ -426,9 +392,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - cloned_create_data = ( - mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] - ) + cloned_create_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert cloned_create_data["max_budget"] == 100.0 # kept from the team default assert cloned_create_data["budget_duration"] == "7d" # overridden by the caller assert cloned_create_data["budget_reset_at"] > datetime.now(timezone.utc) @@ -451,9 +415,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -465,9 +427,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) # Even though we mock these, they must NOT be called on the no-budget path. mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock() @@ -482,9 +442,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "total_spend": 0.0, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -508,9 +466,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): assert result_team_membership.budget_id is None mock_prisma_client.db.litellm_teammembership.upsert.assert_awaited_once() upsert_kwargs = mock_prisma_client.db.litellm_teammembership.upsert.call_args.kwargs - assert upsert_kwargs["where"] == { - "user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id} - } + assert upsert_kwargs["where"] == {"user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id}} assert upsert_kwargs["data"]["create"] == {"user_id": test_user_id, "team_id": test_team_id} assert "budget_id" not in upsert_kwargs["data"]["update"] @@ -540,9 +496,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): new_member = Member(user_id=test_user_id, role="user") # Create UserAPIKeyAuth object - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) # Mock the prisma client mock_prisma_client = AsyncMock() @@ -556,16 +510,12 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) # Mock the budget table creation mock_budget_response = MagicMock() mock_budget_response.budget_id = test_new_budget_id - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) # Mock the team membership creation mock_team_membership_response = MagicMock() @@ -575,9 +525,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "budget_id": test_new_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) # Call the function with max_budget_in_team provided result_user, result_team_membership = await add_new_member( @@ -603,9 +551,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): assert result_team_membership.budget_id == test_new_budget_id # Verify the team membership was created with the correct budget_id - team_membership_call_args = ( - mock_prisma_client.db.litellm_teammembership.upsert.call_args - ) + team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args assert team_membership_call_args is not None create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_new_budget_id @@ -621,9 +567,7 @@ async def test_add_new_member_persists_budget_duration(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -634,14 +578,10 @@ async def test_add_new_member_persists_budget_duration(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur", @@ -649,9 +589,7 @@ async def test_add_new_member_persists_budget_duration(): "budget_id": "budget-dur", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) await add_new_member( new_member=new_member, @@ -666,9 +604,7 @@ async def test_add_new_member_persists_budget_duration(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ - "data" - ] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert budget_data["max_budget"] == 10.0 assert budget_data["allowed_models"] == ["gpt-4o-mini"] assert budget_data["budget_duration"] == "30d" @@ -685,9 +621,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur2", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -698,14 +632,10 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur2" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur2", @@ -713,9 +643,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "budget_id": "budget-dur2", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) _, result_team_membership = await add_new_member( new_member=new_member, @@ -729,9 +657,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ - "data" - ] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert budget_data["budget_duration"] == "7d" assert budget_data["budget_reset_at"] > datetime.now(timezone.utc) assert result_team_membership is not None @@ -749,9 +675,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): new_member = Member(user_email=test_user_email, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -768,9 +692,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_team_membership_response = MagicMock() @@ -780,9 +702,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -905,7 +825,6 @@ async def test_team_update_reaches_inherited_members_but_not_overridden_ones(): from litellm.proxy._types import LitellmUserRoles from litellm.proxy.auth.auth_checks import _check_team_member_budget from litellm.proxy.management_endpoints.common_utils import upsert_budget_and_membership - from litellm.proxy.management_endpoints.team_endpoints import TeamMemberBudgetHandler from litellm.proxy.utils import ProxyLogging db: Final = _FakeDb() @@ -940,15 +859,7 @@ async def test_team_update_reaches_inherited_members_but_not_overridden_ones(): assert db.litellm_teammembership.membership(team_id, "overridden").budget_id != default_budget.budget_id assert db.litellm_budgettable.rows[default_budget.budget_id]["max_budget"] == 100.0 - with patch( # test-quality-ok: update_budget reads this module global; no dependency injection seam exists - "litellm.proxy.proxy_server.prisma_client", prisma_client - ): - await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team, - user_api_key_dict=admin, - updated_kv={}, - team_member_budget=1.0, - ) + await db.litellm_budgettable.update(where={"budget_id": default_budget.budget_id}, data={"max_budget": 1.0}) async def spend_from_membership(counter_key: str, fallback_spend: float, max_budget: float | None = None) -> float: return fallback_spend @@ -1011,14 +922,10 @@ async def test_attach_object_permission_to_dict_with_object_permission_id(): mock_object_permission.model_dump.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=mock_object_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result assert result is not None @@ -1050,9 +957,7 @@ async def test_attach_object_permission_to_dict_without_object_permission_id(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1084,14 +989,10 @@ async def test_attach_object_permission_to_dict_object_permission_not_found(): mock_prisma_client = AsyncMock() # Mock the database query to return None (not found) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=None - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1132,20 +1033,14 @@ async def test_attach_object_permission_to_dict_with_dict_method(): # Mock the object permission response that uses .dict() method mock_object_permission = MagicMock() - mock_object_permission.model_dump.side_effect = AttributeError( - "No model_dump method" - ) + mock_object_permission.model_dump.side_effect = AttributeError("No model_dump method") mock_object_permission.dict.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=mock_object_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result assert result is not None @@ -1174,7 +1069,8 @@ async def test_attach_object_permission_to_dict_with_none_prisma_client(): # Call the function with None prisma_client with pytest.raises(ValueError, match="Prisma client not found"): await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=None # type: ignore + data_dict=test_data_dict, + prisma_client=None, # type: ignore ) @@ -1194,9 +1090,7 @@ async def test_attach_object_permission_to_dict_with_empty_dict(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == {} @@ -1226,9 +1120,7 @@ async def test_attach_object_permission_to_dict_with_none_object_permission_id() mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1254,9 +1146,7 @@ async def test_add_new_member_appends_team_only_if_absent_for_existing_user(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="existing-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -1327,9 +1217,7 @@ async def test_add_new_member_creates_missing_user_atomically_via_upsert(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="brand-new-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -1433,9 +1321,7 @@ async def test_add_new_member_runs_every_write_on_the_caller_transaction(new_mem max_budget_in_team=50.0, prisma_client=prisma_client, team_id="team-pool", - user_api_key_dict=UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN), litellm_proxy_admin_name="admin", tx=tx, ) diff --git a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py new file mode 100644 index 00000000000..a3a7fa5dcce --- /dev/null +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -0,0 +1,88 @@ +import json +from datetime import datetime, timezone + +import pytest +from pydantic import ValidationError + +from litellm.proxy._types import UpdateTeamRequest +from litellm.proxy.management_helpers.team_member_default_budget import plan_team_member_default_budget_write + + +def _plan(existing_budget_id: str | None = None, team_budget_duration: str | None = None, **fields: object): + return plan_team_member_default_budget_write( + data=UpdateTeamRequest(team_id="team-1", **fields), + existing_budget_id=existing_budget_id, + team_alias="My Team", + team_budget_duration=team_budget_duration, + ) + + +def test_a_request_without_member_defaults_writes_nothing(): + assert _plan(existing_budget_id="default-1", max_budget=10.0) is None + + +def test_clearing_a_default_the_team_never_had_writes_nothing(): + assert _plan(team_member_budget=None) is None + + +def test_clearing_an_existing_default_updates_it_without_relinking_members(): + write = _plan(existing_budget_id="default-1", team_member_budget=None, team_member_model_max_budget=None) + + assert write is not None + assert write.budget_id == "default-1" + assert dict(write.update) == {"max_budget": None, "model_max_budget": {}} + assert write.links_members is False + + +def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period(): + before = datetime.now(timezone.utc) + + write = _plan(team_budget_duration="30d", team_member_budget=25.0) + + assert write is not None + assert write.budget_id.startswith("team-My-Team-budget-") + assert write.create["max_budget"] == 25.0 + assert write.create["budget_duration"] == "30d" + assert write.create["budget_reset_at"] > before + assert write.links_members is True + + +def test_an_explicit_null_reset_period_is_not_replaced_by_the_team_period(): + write = _plan(team_budget_duration="30d", team_member_budget=25.0, team_member_budget_duration=None) + + assert write is not None + assert "budget_duration" not in write.create + assert write.update["budget_duration"] is None + assert write.update["budget_reset_at"] is None + + +def test_changing_the_reset_period_restarts_the_window(): + before = datetime.now(timezone.utc) + + write = _plan(existing_budget_id="default-1", team_member_budget_duration="7d") + + assert write is not None + assert write.update["budget_duration"] == "7d" + assert write.update["budget_reset_at"] > before + + +@pytest.mark.parametrize("team_member_budget", [None, 0.0]) +def test_backfill_without_a_positive_default_in_the_same_request_is_rejected(team_member_budget): + with pytest.raises(ValidationError, match="team_member_budget_backfill needs a positive team_member_budget"): + UpdateTeamRequest( + team_id="team-1", team_member_budget=team_member_budget, team_member_budget_backfill="raise_to_default" + ) + + +@pytest.mark.parametrize("backfill", [None, "none"]) +def test_keeping_custom_budgets_needs_no_default(backfill): + assert UpdateTeamRequest(team_id="team-1", team_member_budget_backfill=backfill).team_member_budget is None + + +def test_per_model_member_budgets_are_stored_as_plain_json(): + caps = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}} + + write = _plan(existing_budget_id="default-1", team_member_model_max_budget=caps) + + assert write is not None + assert json.loads(json.dumps(write.update["model_max_budget"]))["gpt-4o"]["max_budget"] == 5.0 diff --git a/ui/litellm-dashboard/src/components/networking.tsx b/ui/litellm-dashboard/src/components/networking.tsx index 4df34275923..4f8b785e3b3 100644 --- a/ui/litellm-dashboard/src/components/networking.tsx +++ b/ui/litellm-dashboard/src/components/networking.tsx @@ -97,6 +97,7 @@ import type { ListPluginsResponse, SkillRegisterRequest } from "./claude_code_pl import type { ModelBudgetUsage, ModelMaxBudget } from "./key_team_helpers/ModelMaxBudgetEditor"; import type { StoredModelMaxBudget } from "./key_team_helpers/modelMaxBudgetPayload"; import type { ObjectPermission } from "./object_permission_types"; +import type { MemberBudgetBackfillResult } from "./team/memberBudgetReset"; import type { components } from "@/lib/http/schema"; import type { DecisionTestBody } from "@/app/(dashboard)/guardrails/_components/decision_model/decisionModelQuestion"; import { fetchClient } from "@/lib/http/api"; @@ -2828,7 +2829,11 @@ export const teamUpdateCall = async ( toast.fromError("Failed to update team settings: " + unwrapProxyErrorMessage(errorData)); throw new Error(errorData); } - const data = (await response.json()) as { data: Team; team_id: string }; + const data = (await response.json()) as { + data: Team; + team_id: string; + team_member_budget_backfill_result?: MemberBudgetBackfillResult; + }; return data; // Handle success - you might want to update some state or UI based on the updated team } catch (error) { diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx index 7132ec13fbb..439c383255c 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx @@ -1,103 +1,91 @@ import { render, screen } from "@testing-library/react"; import userEvent from "@testing-library/user-event"; import { describe, expect, it, vi } from "vitest"; -import ResetMemberBudgetsDialog from "./ResetMemberBudgetsDialog"; +import type { MemberBudgetBackfillPreview } from "./memberBudgetReset"; +import ResetMemberBudgetsDialog, { backfillOptions } from "./ResetMemberBudgetsDialog"; import type { MemberBudgetResetState } from "./useMemberBudgetReset"; -const pendingFor = (memberCount: number, newBudget = 10) => ({ - teamId: "team-123", - updateData: {}, - userIds: Array.from({ length: memberCount }, (_, i) => `u-${i}`), - newBudget, +const preview = (below: number, above: number, otherResetPeriod = 0): MemberBudgetBackfillPreview => ({ + below, + above, + otherResetPeriod, }); -const promptingWith = (memberCount: number, newBudget = 10): MemberBudgetResetState => ({ - phase: "prompting", - pending: pendingFor(memberCount, newBudget), +const state = (phase: "prompting" | "saving", shown: MemberBudgetBackfillPreview): MemberBudgetResetState => ({ + phase, + pending: { updateData: { team_id: "team-123" }, newBudget: 1250, preview: shown }, }); -const defaultHandlers = () => ({ - onReset: vi.fn(), - onRetry: vi.fn(), - onKeep: vi.fn(), - onDismiss: vi.fn(), +const renderDialog = (dialogState: MemberBudgetResetState) => { + const handlers = { onSave: vi.fn(), onDismiss: vi.fn() }; + render(); + return handlers; +}; + +describe("backfillOptions", () => { + it("offers every direction when members sit on both sides of the default", () => { + expect(backfillOptions(preview(2, 1), 20)).toEqual([ + { value: "none", label: "Keep all custom budgets" }, + { value: "raise_to_default", label: "Raise 2 members below $20.00" }, + { value: "lower_to_default", label: "Lower 1 member above $20.00" }, + { value: "all_to_default", label: "Raise and lower all 3 members" }, + ]); + }); + + it.each([ + [preview(1, 0), ["none", "raise_to_default"]], + [preview(0, 4), ["none", "lower_to_default"]], + ])("hides directions that would move nobody", (shown, values) => { + expect(backfillOptions(shown, 20).map((option) => option.value)).toEqual(values); + }); }); describe("ResetMemberBudgetsDialog", () => { - it("names the members and the new default so the prompt is self-explanatory", () => { - render(); - - expect( - screen.getByText( - "3 members have a custom budget, so the new team default of $10.00 will not apply to them. " + - "Reset them to the default, or keep the custom budgets?", - ), - ).toBeInTheDocument(); - }); - - it("switches to singular for one member", () => { - render(); - - expect( - screen.getByText( - "1 member has a custom budget, so the new team default of $10.00 will not apply to that member. " + - "Reset it to the default, or keep the custom budget?", - ), - ).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Reset to $10.00" })).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Keep custom budget" })).toBeInTheDocument(); - }); - - it("formats large budgets like the rest of the team page", () => { - render(); - - expect(screen.getByRole("button", { name: "Reset all to $1,000.00" })).toBeInTheDocument(); - expect(screen.getByText(/new team default of \$1,000\.00/)).toBeInTheDocument(); - }); - - it("routes each choice to the matching action", async () => { - const handlers = defaultHandlers(); + it("keeps custom budgets unless another direction is picked", async () => { const user = userEvent.setup(); - render(); + const { onSave } = renderDialog(state("prompting", preview(2, 1))); - await user.click(screen.getByRole("button", { name: "Reset all to $10.00" })); - expect(handlers.onReset).toHaveBeenCalledTimes(1); + expect(screen.getByText("Apply the new $1,250.00 default to members with a custom budget?")).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Keep all custom budgets" })).toBeChecked(); + await user.click(screen.getByRole("button", { name: "Save" })); - await user.click(screen.getByRole("button", { name: "Keep custom budgets" })); - expect(handlers.onKeep).toHaveBeenCalledTimes(1); + expect(onSave).toHaveBeenCalledWith("none"); + }); + + it("saves the picked direction", async () => { + const user = userEvent.setup(); + const { onSave } = renderDialog(state("prompting", preview(2, 1))); + + await user.click(screen.getByRole("radio", { name: "Raise and lower all 3 members" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + expect(onSave).toHaveBeenCalledWith("all_to_default"); + }); + + it("says how many members reset on another schedule", () => { + renderDialog(state("prompting", preview(1, 0, 2))); + + expect(screen.getByText("2 members reset on a different schedule and won't change")).toBeInTheDocument(); + }); + + it("cancels without saving", async () => { + const user = userEvent.setup(); + const { onSave, onDismiss } = renderDialog(state("prompting", preview(1, 0))); await user.click(screen.getByRole("button", { name: "Cancel" })); - expect(handlers.onDismiss).toHaveBeenCalledTimes(1); + + expect(onDismiss).toHaveBeenCalledTimes(1); + expect(onSave).not.toHaveBeenCalled(); }); - it("locks every button while the reset is in flight", () => { - const state: MemberBudgetResetState = { phase: "resetting", pending: pendingFor(2), attempted: 0 }; - render(); + it("locks every control while the save is in flight", () => { + renderDialog(state("saving", preview(1, 0))); - expect(screen.getByRole("button", { name: "Reset all to $10.00" })).toBeDisabled(); - expect(screen.getByRole("button", { name: "Keep custom budgets" })).toBeDisabled(); + expect(screen.getByRole("button", { name: "Save" })).toBeDisabled(); expect(screen.getByRole("button", { name: "Cancel" })).toBeDisabled(); - }); - - it("offers retry or cancel after a failed reset", async () => { - const handlers = defaultHandlers(); - const user = userEvent.setup(); - const state: MemberBudgetResetState = { phase: "resetFailed", pending: pendingFor(2), attempted: 0 }; - render(); - - await user.click(screen.getByRole("button", { name: "Retry reset" })); - expect(handlers.onRetry).toHaveBeenCalledTimes(1); - - await user.click(screen.getByRole("button", { name: "Cancel" })); - expect(handlers.onDismiss).toHaveBeenCalledTimes(1); - - expect(screen.queryByRole("button", { name: "Keep custom budgets" })).not.toBeInTheDocument(); - expect(screen.queryByRole("button", { name: "Reset all to $10.00" })).not.toBeInTheDocument(); - }); - - it("renders nothing while idle", () => { - render(); - - expect(screen.queryByRole("dialog")).not.toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise 1 member below $1,250.00" })).toHaveAttribute( + "aria-disabled", + "true", + ); }); }); diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx index 95714e3df33..045bb18e780 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx @@ -1,70 +1,101 @@ -import React from "react"; +import React, { useState } from "react"; import { Button } from "@/components/ui/button"; import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"; +import { FieldLabel } from "@/components/ui/field"; +import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"; import { formatNumberWithCommas } from "@/utils/dataUtils"; -import { pluralize } from "./memberBudgetReset"; +import { + pluralize, + type MemberBudgetBackfill, + type MemberBudgetBackfillPreview, + type MemberBudgetResetPending, +} from "./memberBudgetReset"; import type { MemberBudgetResetState } from "./useMemberBudgetReset"; interface ResetMemberBudgetsDialogProps { state: MemberBudgetResetState; - onReset: () => void; - onRetry: () => void; - onKeep: () => void; + onSave: (backfill: MemberBudgetBackfill) => void; onDismiss: () => void; } -export default function ResetMemberBudgetsDialog({ - state, - onReset, - onRetry, - onKeep, - onDismiss, -}: ResetMemberBudgetsDialogProps) { - const open = state.phase !== "idle"; - const busy = state.phase === "resetting"; - const failed = state.phase === "resetFailed"; - const memberCount = state.phase === "idle" ? 0 : state.pending.userIds.length; - const newBudget = state.phase === "idle" ? 0 : state.pending.newBudget; +interface BackfillOption { + value: MemberBudgetBackfill; + label: string; +} + +const members = (count: number) => `${count} ${pluralize(count, "member", "members")}`; + +export const backfillOptions = (preview: MemberBudgetBackfillPreview, newBudget: number): BackfillOption[] => { + const amount = `$${formatNumberWithCommas(newBudget, 2)}`; + const options: (BackfillOption | null)[] = [ + { value: "none", label: "Keep all custom budgets" }, + preview.below > 0 ? { value: "raise_to_default", label: `Raise ${members(preview.below)} below ${amount}` } : null, + preview.above > 0 ? { value: "lower_to_default", label: `Lower ${members(preview.above)} above ${amount}` } : null, + preview.below > 0 && preview.above > 0 + ? { value: "all_to_default", label: `Raise and lower all ${members(preview.below + preview.above)}` } + : null, + ]; + return options.filter((option): option is BackfillOption => option !== null); +}; + +interface BackfillChoiceProps { + pending: MemberBudgetResetPending; + busy: boolean; + onSave: (backfill: MemberBudgetBackfill) => void; + onDismiss: () => void; +} + +function BackfillChoice({ pending, busy, onSave, onDismiss }: BackfillChoiceProps) { + const [choice, setChoice] = useState("none"); + const otherResetPeriod = pending.preview.otherResetPeriod; + + return ( + <> + + + Apply the new ${formatNumberWithCommas(pending.newBudget, 2)} default to members with a custom budget? + + + setChoice(value as MemberBudgetBackfill)}> + {backfillOptions(pending.preview, pending.newBudget).map((option) => ( + + + {option.label} + + ))} + + {otherResetPeriod > 0 && ( +

+ {members(otherResetPeriod)} {pluralize(otherResetPeriod, "resets", "reset")} on a different schedule and + won't change +

+ )} + + + + + + ); +} + +export default function ResetMemberBudgetsDialog({ state, onSave, onDismiss }: ResetMemberBudgetsDialogProps) { + const busy = state.phase === "saving"; return ( { if (!nextOpen && !busy) onDismiss(); }} > - - Reset member budgets? - -

- {memberCount} {pluralize(memberCount, "member has", "members have")} a custom budget, so the new team default - of ${formatNumberWithCommas(newBudget, 2)} will not apply to {pluralize(memberCount, "that member", "them")}. - Reset {pluralize(memberCount, "it", "them")} to the default, or keep the custom{" "} - {pluralize(memberCount, "budget", "budgets")}? -

- - {failed ? ( - <> - - - - ) : ( - <> - - - - - )} - + {state.phase !== "idle" && ( + + )}
); diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx index fc054e51e5b..016b60338ee 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx @@ -6,7 +6,6 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; import { renderWithProviders } from "../../../tests/test-utils"; import { toast } from "@/lib/toast"; import type { Team } from "../key_team_helpers/key_list"; -import { MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES } from "./memberBudgetReset"; import TeamInfoView, { type TeamData } from "./TeamInfo"; const authState = vi.hoisted(() => ({ userRole: "Admin" })); @@ -49,12 +48,6 @@ vi.mock("@/components/networking", () => ({ getClaudeCodePluginsList: vi.fn().mockResolvedValue({ plugins: [], count: 0 }), })); -const { bulkUpdatePOST } = vi.hoisted(() => ({ bulkUpdatePOST: vi.fn() })); -vi.mock("@/lib/http/api", async (importOriginal) => { - const actual = await importOriginal(); - return { ...actual, fetchClient: { ...actual.fetchClient, POST: bulkUpdatePOST } }; -}); - const can = vi.fn(); vi.mock("@/app/(dashboard)/hooks/useCan", () => ({ default: (...args: unknown[]) => can(...args), @@ -358,6 +351,7 @@ describe("TeamInfoView - member budget reset prompt", () => { const customBudgetMembership = ( userId: string, maxBudget: number | null = 50, + budgetDuration: string | null = null, ): TeamData["team_memberships"][number] => ({ user_id: userId, team_id: "123", @@ -373,7 +367,7 @@ describe("TeamInfoView - member budget reset prompt", () => { tpm_limit: null, rpm_limit: null, model_max_budget: null, - budget_duration: null, + budget_duration: budgetDuration, budget_reset_at: null, }, }); @@ -393,333 +387,147 @@ describe("TeamInfoView - member budget reset prompt", () => { spend: 0, }; - const openEditorWithCustomMembers = async ( - user: ReturnType, - userIds: string[] = ["user-custom"], - maxBudget: number | null = 50, - ) => { - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: userIds.map((id) => customBudgetMembership(id, maxBudget)), - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - - renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - return await screen.findByLabelText("Default Budget (USD)"); - }; - const submitNewDefault = async (user: ReturnType, input: HTMLElement, value: string) => { fireEvent.change(input, { target: { value } }); await user.click(screen.getByRole("button", { name: /save changes/i })); }; + const memberships = (...rows: TeamData["team_memberships"]) => rows; + + const openEditor = async (user: ReturnType, rows: TeamData["team_memberships"]) => { + const data = { + ...createMockTeamData({ + team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, + }), + team_memberships: rows, + } as TeamData; + vi.mocked(networking.teamInfoCall).mockResolvedValue(data); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); + + const view = renderWithProviders(); + await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); + await user.click(screen.getByRole("tab", { name: "Settings" })); + await user.click(await screen.findByRole("button", { name: /edit settings/i })); + await user.click(screen.getByText("Team Member Settings")); + return { input: await screen.findByLabelText("Default Budget (USD)"), view }; + }; + + const savedBody = () => vi.mocked(networking.teamUpdateCall).mock.calls[0][1]; + const promptTitle = "Apply the new $20.00 default to members with a custom budget?"; + beforeEach(() => { seedDefaultMocks(); - bulkUpdatePOST.mockResolvedValue({ data: { data: [] } }); }); afterEach(() => { vi.clearAllMocks(); }); - it("holds the save behind the prompt when the default changes while a member has a custom budget", async () => { + it("holds the save behind a prompt that counts members on each side of the new default", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - - await submitNewDefault(user, input, "20"); - - expect(await screen.findByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.getByText(/1 member has a custom budget/)).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Reset to $20.00" })).toBeInTheDocument(); - expect(networking.teamUpdateCall).not.toHaveBeenCalled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("saves the new default and leaves custom budgets alone on keep", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Keep custom budget" })); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - }); - - it("saves the new default then clears each custom budget through the bulk endpoint on reset all", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-a", "user-b"]); - bulkUpdatePOST.mockResolvedValue({ - data: { - data: [ - { success: true, user_id: "user-a" }, - { success: true, user_id: "user-b" }, - ], - }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(1)); - expect(networking.teamUpdateCall).toHaveBeenCalled(); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(bulkUpdatePOST).toHaveBeenCalledWith("/management/v1/teams/{team_id}/members/bulk_update", { - params: { path: { team_id: "123" } }, - body: { - members: [ - { user_id: "user-a", max_budget_in_team: null }, - { user_id: "user-b", max_budget_in_team: null }, - ], - }, - }); - await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Reset 2 member budgets to the team default")); - }); - - it("keeps the prompt mounted while the member-budget reset is in flight", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - const bulk = Promise.withResolvers<{ data: { data: { success: boolean; user_id: string }[] } }>(); - vi.mocked(networking.teamInfoCall).mockImplementationOnce(() => new Promise(() => {})); - bulkUpdatePOST.mockImplementationOnce(() => bulk.promise); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalled()); - expect(screen.getByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - - bulk.resolve({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - }); - - it("offers a retry after a failed reset and never re-saves the team", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - bulkUpdatePOST - .mockRejectedValueOnce(new Error("bulk update down")) - .mockResolvedValueOnce({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - - await waitFor(() => - expect(toast.fromError).toHaveBeenCalledWith("Team updated, but member budgets could not be reset"), + const { input } = await openEditor( + user, + memberships( + customBudgetMembership("user-low", 5), + customBudgetMembership("user-high", 50), + customBudgetMembership("user-weekly", 5, "7d"), + ), ); - expect(screen.getByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - await waitFor(() => expect(vi.mocked(networking.teamInfoCall).mock.calls.length).toBeGreaterThan(1)); - await user.click(screen.getByRole("button", { name: "Retry reset" })); + await submitNewDefault(user, input, "20"); - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(2)); - expect(vi.mocked(networking.teamUpdateCall).mock.calls).toHaveLength(1); - await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Reset 1 member budget to the team default")); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); + expect(await screen.findByText(promptTitle)).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise 1 member below $20.00" })).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Lower 1 member above $20.00" })).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise and lower all 2 members" })).toBeInTheDocument(); + expect(screen.getByText("1 member resets on a different schedule and won't change")).toBeInTheDocument(); + expect(networking.teamUpdateCall).not.toHaveBeenCalled(); }); - it("returns to the prompt without its own toast when the team save fails", async () => { + it("keeps every custom budget when saved with the default choice", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); + + await submitNewDefault(user, input, "20"); + await user.click(await screen.findByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody()).toMatchObject({ team_member_budget: 20, team_member_budget_backfill: "none" }); + await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Team settings updated successfully")); + expect(screen.queryByText(promptTitle)).not.toBeInTheDocument(); + }); + + it("sends the chosen direction in the same save and reports what the server moved", async () => { + const user = userEvent.setup({ delay: null }); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ + data: savedTeam, + team_id: "123", + team_member_budget_backfill_result: { moved_to_default: 1, skipped_other_reset_period: 0 }, + }); + + await submitNewDefault(user, input, "20"); + await user.click(await screen.findByRole("radio", { name: "Lower 1 member above $20.00" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody()).toMatchObject({ team_member_budget: 20, team_member_budget_backfill: "lower_to_default" }); + await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Moved 1 member to the $20.00 default")); + }); + + it("returns to the prompt without its own toast when the save fails", async () => { + const user = userEvent.setup({ delay: null }); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); vi.mocked(networking.teamUpdateCall).mockRejectedValueOnce(new Error("save failed")); await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); + await user.click(await screen.findByRole("button", { name: "Save" })); - expect(await screen.findByRole("button", { name: "Reset to $20.00" })).toBeEnabled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - }); - - it("reports how many budgets were already reset when a later batch fails", async () => { - const user = userEvent.setup({ delay: null }); - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `user-${i}`); - const input = await openEditorWithCustomMembers(user, userIds); - bulkUpdatePOST - .mockResolvedValueOnce({ - data: { - data: userIds.slice(0, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES).map((user_id) => ({ success: true, user_id })), - }, - }) - .mockRejectedValueOnce(new Error("second batch down")) - .mockResolvedValueOnce({ - data: { data: [{ success: true, user_id: `user-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}` }] }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => - expect(toast.error).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES} of ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets; the rest could not be reset`, - ), - ); - expect(bulkUpdatePOST).toHaveBeenCalledTimes(2); - - await user.click(screen.getByRole("button", { name: "Retry reset" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(3)); - expect(vi.mocked(bulkUpdatePOST).mock.calls[2][1]).toEqual({ - params: { path: { team_id: "123" } }, - body: { - members: [{ user_id: `user-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`, max_budget_in_team: null }], - }, - }); - expect(vi.mocked(networking.teamUpdateCall).mock.calls).toHaveLength(1); - await waitFor(() => - expect(toast.success).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets to the team default`, - ), - ); - }); - - it("surfaces a failure toast when some members cannot be reset", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-a", "user-b"]); - bulkUpdatePOST.mockResolvedValue({ - data: { - data: [ - { success: true, user_id: "user-a" }, - { success: false, user_id: "user-b", error: "no such member" }, - ], - }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => - expect(toast.error).toHaveBeenCalledWith("Team updated, but 1 member budget could not be reset"), - ); + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(await screen.findByRole("button", { name: "Save" })).toBeEnabled(); + expect(toast.success).not.toHaveBeenCalled(); }); it("aborts the save entirely on cancel", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); await submitNewDefault(user, input, "20"); await user.click(await screen.findByRole("button", { name: "Cancel" })); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); + await waitFor(() => expect(screen.queryByText(promptTitle)).not.toBeInTheDocument()); expect(networking.teamUpdateCall).not.toHaveBeenCalled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); }); - it("saves directly when no member carries a custom budget", async () => { + it.each([ + ["no member has a custom budget", memberships(), "20"], + ["a custom member's cap is null", memberships(customBudgetMembership("user-limits-only", null)), "20"], + ["the only custom member resets on another schedule", memberships(customBudgetMembership("u", 5, "7d")), "20"], + ["the only custom member already matches", memberships(customBudgetMembership("user-equal", 20)), "20"], + ["the default is resubmitted unchanged", memberships(customBudgetMembership("user-high")), "10"], + ])("saves directly when %s", async (_case, rows, value) => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, []); + const { input } = await openEditor(user, rows); - await submitNewDefault(user, input, "20"); + await submitNewDefault(user, input, value); - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("saves directly when the default is resubmitted unchanged", async () => { - const user = userEvent.setup({ delay: null }); - await openEditorWithCustomMembers(user); - - await user.click(screen.getByRole("button", { name: /save changes/i })); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(10); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody().team_member_budget).toBe(Number(value)); + expect(savedBody()).not.toHaveProperty("team_member_budget_backfill"); + expect(screen.queryByText(/default to members with a custom budget/)).not.toBeInTheDocument(); }); it("dismisses a pending prompt when the selected team changes", async () => { const user = userEvent.setup({ delay: null }); - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: [customBudgetMembership("user-custom")], - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - - const { rerender } = renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - const input = await screen.findByLabelText("Default Budget (USD)"); + const { input, view } = await openEditor(user, memberships(customBudgetMembership("user-high"))); await submitNewDefault(user, input, "20"); - expect(await screen.findByText("Reset member budgets?")).toBeInTheDocument(); + expect(await screen.findByText(promptTitle)).toBeInTheDocument(); - rerender(); + view.rerender(); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("does not reopen the dialog or refetch the old team when the team changes mid-reset", async () => { - const user = userEvent.setup({ delay: null }); - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: [customBudgetMembership("user-custom")], - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - const bulkDone = Promise.withResolvers<{ data: { data: { success: boolean; user_id: string }[] } }>(); - bulkUpdatePOST.mockReturnValue(bulkDone.promise); - - const { rerender } = renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - const input = await screen.findByLabelText("Default Budget (USD)"); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalled()); - - const infoCallsBeforeSwitch = vi.mocked(networking.teamInfoCall).mock.calls.length; - rerender(); - bulkDone.resolve({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - await waitFor(() => - expect( - vi - .mocked(networking.teamInfoCall) - .mock.calls.slice(infoCallsBeforeSwitch) - .some((call) => call[1] === "456"), - ).toBe(true), - ); - const infoCallsAfterSwitch = vi.mocked(networking.teamInfoCall).mock.calls.slice(infoCallsBeforeSwitch); - expect(infoCallsAfterSwitch.every((call) => call[1] === "456")).toBe(true); - expect(screen.queryByRole("button", { name: "Retry reset" })).not.toBeInTheDocument(); - }); - - it("saves directly when a custom member's cap is null and already inherits the default", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-limits-only"], null); - - await submitNewDefault(user, input, "20"); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); + await waitFor(() => expect(screen.queryByText(promptTitle)).not.toBeInTheDocument()); + expect(networking.teamUpdateCall).not.toHaveBeenCalled(); }); it("omits the default member model budget when it has not changed", async () => { diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx index e4bf67ab72f..d5ac82faa2f 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx @@ -8,6 +8,7 @@ import { toast } from "@/lib/toast"; import type { Member } from "@/components/networking"; import type { EffectiveMcpServer } from "../mcp_server_management/effectiveMcpServers"; import type { MCPServer } from "../mcp_tools/types"; +import type { Team } from "../key_team_helpers/key_list"; import TeamInfoView, { grantedMcpServerIds, type McpGrantInput, @@ -2152,6 +2153,54 @@ describe("TeamInfoView", () => { expect(screen.getByRole("button", { name: /save changes/i })).toBeDisabled(); }); + it("asks a team admin which custom member budgets follow a new member default and sends the choice", async () => { + const user = userEvent.setup({ delay: null }); + vi.mocked(networking.teamInfoCall).mockResolvedValue({ + ...createMockTeamData({ + team_member_budget_table: { max_budget: 10, budget_duration: "30d", tpm_limit: null, rpm_limit: null }, + caller_edit_access: { kind: "team_admin", editable_fields: ["team_member_budget"] }, + }), + team_memberships: [ + { + user_id: "user-high", + team_id: "123", + budget_id: "budget-user-high", + budget_source: "custom", + spend: 0, + total_spend: 0, + litellm_budget_table: { + budget_id: "budget-user-high", + soft_budget: null, + max_budget: 50, + max_parallel_requests: null, + tpm_limit: null, + rpm_limit: null, + model_max_budget: null, + budget_duration: "30d", + budget_reset_at: null, + }, + }, + ], + }); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: {} as Team, team_id: "123" }); + + renderWithProviders(); + + await user.click(await screen.findByRole("tab", { name: "Settings" })); + await user.click(await screen.findByRole("button", { name: /edit settings/i })); + fireEvent.change(await screen.findByLabelText("Member Default Budget (USD)"), { target: { value: "20" } }); + await user.click(screen.getByRole("button", { name: /save changes/i })); + await user.click(await screen.findByRole("radio", { name: "Lower 1 member above $20.00" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1]).toStrictEqual({ + team_id: "123", + team_member_budget: 20, + team_member_budget_backfill: "lower_to_default", + }); + }); + it("opens the form when the proxy reports unrestricted access although the props only mark a team admin", async () => { const user = userEvent.setup({ delay: null }); vi.mocked(networking.teamInfoCall).mockResolvedValue( diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx index 0d63f5d0833..8d4aedc6626 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx @@ -132,9 +132,12 @@ import { } from "./teamMemberBudgetAlertEmails"; import { TeamVirtualKeysTable } from "./TeamVirtualKeysTable"; import ResetMemberBudgetsDialog from "./ResetMemberBudgetsDialog"; -import { customBudgetMemberUserIds, shouldPromptMemberBudgetReset } from "./memberBudgetReset"; +import { + previewMemberBudgetBackfill, + shouldPromptMemberBudgetReset, + type TeamUpdatePayload, +} from "./memberBudgetReset"; import { useMemberBudgetReset } from "./useMemberBudgetReset"; -import { fetchClient } from "@/lib/http/api"; const UI_MANAGED_METADATA_KEYS: ReadonlySet = new Set([ "logging", @@ -941,32 +944,38 @@ const TeamInfoView: React.FC = ({ }; const persistTeamUpdate = async (token: string, updateData: Record) => { - await teamUpdateCall(token, updateData); + const response = await teamUpdateCall(token, updateData); void queryClient.invalidateQueries({ queryKey: organizationKeys.all }); void invalidateTeamQueries(queryClient); setIsEditing(false); + return response.team_member_budget_backfill_result; }; const memberBudgetReset = useMemberBudgetReset({ saveTeam: async (updateData) => { - if (!accessToken) return; + if (!accessToken) return undefined; setIsTeamSaving(true); try { - await persistTeamUpdate(accessToken, updateData); + return await persistTeamUpdate(accessToken, updateData); } finally { setIsTeamSaving(false); } }, - resetMemberBudgets: async (bulkTeamId, userIds) => { - const { data } = await fetchClient.POST("/management/v1/teams/{team_id}/members/bulk_update", { - params: { path: { team_id: bulkTeamId } }, - body: { members: userIds.map((user_id) => ({ user_id, max_budget_in_team: null })) }, - }); - return data?.data ?? []; - }, refreshTeamData, }); + const promptsMemberBudgetBackfill = ( + updateData: TeamUpdatePayload, + newBudget: number | null | undefined, + newBudgetDuration: string | null | undefined, + ): boolean => { + if (typeof newBudget !== "number") return false; + const preview = previewMemberBudgetBackfill(teamData?.team_memberships ?? [], newBudget, newBudgetDuration); + if (!shouldPromptMemberBudgetReset(newBudget, info.team_member_budget_table?.max_budget, preview)) return false; + memberBudgetReset.prompt({ updateData, newBudget, preview }); + return true; + }; + const { dismiss: dismissMemberBudgetReset } = memberBudgetReset; useEffect(() => { dismissMemberBudgetReset(); @@ -974,9 +983,15 @@ const TeamInfoView: React.FC = ({ const saveTeamAdminSettings = async (changes: TeamAdminSettingsChanges) => { if (!accessToken) return; + const updateData = { team_id: teamId, ...changes }; + const newBudgetDuration = + "team_member_budget_duration" in changes + ? changes.team_member_budget_duration + : info.team_member_budget_table?.budget_duration; + if (promptsMemberBudgetBackfill(updateData, changes.team_member_budget, newBudgetDuration)) return; setIsTeamSaving(true); try { - await persistTeamUpdate(accessToken, { team_id: teamId, ...changes }); + await persistTeamUpdate(accessToken, updateData); toast.success("Team settings updated successfully"); await fetchTeamInfo(); } catch (error) { @@ -1257,24 +1272,7 @@ const TeamInfoView: React.FC = ({ } } - const customBudgetUserIds = customBudgetMemberUserIds(teamData?.team_memberships ?? []); - if ( - typeof newTeamMemberBudget === "number" && - shouldPromptMemberBudgetReset( - newTeamMemberBudget, - info.team_member_budget_table?.max_budget, - customBudgetUserIds, - ) - ) { - const pendingReset = { - teamId, - updateData, - userIds: customBudgetUserIds, - newBudget: newTeamMemberBudget, - }; - memberBudgetReset.prompt(pendingReset); - return; - } + if (promptsMemberBudgetBackfill(updateData, newTeamMemberBudget, values.team_member_budget_duration)) return; await persistTeamUpdate(accessToken, updateData); toast.success("Team settings updated successfully"); @@ -2711,9 +2709,7 @@ const TeamInfoView: React.FC = ({ diff --git a/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts b/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts index e673840203f..71c1621fd17 100644 --- a/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts +++ b/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts @@ -1,101 +1,90 @@ import { describe, expect, it } from "vitest"; import { - chunk, - customBudgetMemberUserIds, - MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES, - pluralize, + budgetResetPeriodKey, + previewMemberBudgetBackfill, shouldPromptMemberBudgetReset, + type MemberBudgetBackfillPreview, } from "./memberBudgetReset"; -describe("customBudgetMemberUserIds", () => { - const customRow = (user_id: string, max_budget: number | null = 50) => ({ - user_id, - budget_source: "custom" as const, - litellm_budget_table: { max_budget }, +const custom = (max_budget: number | null, budget_duration: string | null = "30d") => ({ + budget_source: "custom" as const, + litellm_budget_table: { max_budget, budget_duration }, +}); + +describe("budgetResetPeriodKey", () => { + it.each([ + ["7d", "1w", true], + ["24h", "1d", true], + ["daily", "1d", true], + ["60s", "1m", true], + ["monthly", "30d", true], + [" 30d ", "30d", true], + ["1mo", "1mo", true], + [null, undefined, true], + ["1mo", "30d", false], + ["2mo", "1mo", false], + ["7d", "1d", false], + ["30d", null, false], + ["garbage", "garbage", true], + ["garbage", "30d", false], + ])("treats %s and %s as the same schedule: %s", (first, second, same) => { + expect(budgetResetPeriodKey(first) === budgetResetPeriodKey(second)).toBe(same); + }); +}); + +describe("previewMemberBudgetBackfill", () => { + it("counts custom budgets on each side of the new default that reset on its schedule", () => { + const preview = previewMemberBudgetBackfill( + [custom(5), custom(10, "1mo"), custom(80, "30d"), custom(90, "monthly"), custom(3, "7d"), custom(70, null)], + 20, + "30d", + ); + + expect(preview).toEqual({ below: 1, above: 2, otherResetPeriod: 3 }); }); - it("returns only members whose budget_source is custom with a private cap", () => { - const memberships = [ - customRow("u-custom"), - { user_id: "u-default", budget_source: "team_default" as const }, - { user_id: "u-none", budget_source: "none" as const }, - ]; + it("ignores members on the default, members without a cap of their own and caps already at the new default", () => { + const preview = previewMemberBudgetBackfill( + [ + { budget_source: "team_default" as const, litellm_budget_table: { max_budget: 5, budget_duration: "30d" } }, + { budget_source: "none" as const }, + custom(null), + { budget_source: "custom" as const, litellm_budget_table: null }, + custom(20), + custom(20, "7d"), + ], + 20, + "30d", + ); - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); + expect(preview).toEqual({ below: 0, above: 0, otherResetPeriod: 0 }); }); - it("skips a custom row whose cap is null since it already inherits the default", () => { - const memberships = [customRow("u-rate-limits-only", null), customRow("u-custom")]; - - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); - }); - - it("skips a custom row that has no budget table at all", () => { - const memberships = [ - { user_id: "u-no-table", budget_source: "custom" as const, litellm_budget_table: null }, - customRow("u-custom"), - ]; - - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); + it("matches a default that never resets only to caps that never reset", () => { + expect(previewMemberBudgetBackfill([custom(5, null), custom(5, "30d")], 20, null)).toEqual({ + below: 1, + above: 0, + otherResetPeriod: 1, + }); }); }); describe("shouldPromptMemberBudgetReset", () => { - it("prompts when the default changes and custom-budget members exist", () => { - expect(shouldPromptMemberBudgetReset(10, 5, ["u-1"])).toBe(true); + const movable: MemberBudgetBackfillPreview = { below: 1, above: 0, otherResetPeriod: 0 }; + const nothingMovable: MemberBudgetBackfillPreview = { below: 0, above: 0, otherResetPeriod: 4 }; + + it("prompts when the default changes and some member could move onto it", () => { + expect(shouldPromptMemberBudgetReset(10, 5, movable)).toBe(true); + expect(shouldPromptMemberBudgetReset(10, null, { below: 0, above: 1, otherResetPeriod: 0 })).toBe(true); }); - it("prompts when a default is set for the first time", () => { - expect(shouldPromptMemberBudgetReset(10, null, ["u-1"])).toBe(true); - expect(shouldPromptMemberBudgetReset(10, undefined, ["u-1"])).toBe(true); + it("does not prompt when the default is unchanged, cleared or zero", () => { + expect(shouldPromptMemberBudgetReset(10, 10, movable)).toBe(false); + expect(shouldPromptMemberBudgetReset(undefined, 10, movable)).toBe(false); + expect(shouldPromptMemberBudgetReset(0, 10, movable)).toBe(false); }); - it("does not prompt when the submitted budget is unchanged", () => { - expect(shouldPromptMemberBudgetReset(10, 10, ["u-1"])).toBe(false); - }); - - it("does not prompt when the budget is cleared or zero", () => { - expect(shouldPromptMemberBudgetReset(undefined, 10, ["u-1"])).toBe(false); - expect(shouldPromptMemberBudgetReset(0, 10, ["u-1"])).toBe(false); - }); - - it("does not prompt when no member has a custom budget", () => { - expect(shouldPromptMemberBudgetReset(10, 5, [])).toBe(false); - }); -}); - -describe("chunk", () => { - it("splits selections larger than the bulk endpoint limit", () => { - const ids = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - - const chunks = chunk(ids, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - - expect(chunks).toHaveLength(2); - expect(chunks[0]).toHaveLength(MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - expect(chunks[1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - }); - - it("keeps a selection under the limit in a single chunk", () => { - expect(chunk(["u-1", "u-2"], MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES)).toEqual([["u-1", "u-2"]]); - }); - - it("returns no chunks for an empty selection", () => { - expect(chunk([], MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES)).toEqual([]); - }); - - it("returns no chunks for a non-positive size", () => { - expect(chunk(["u-1"], 0)).toEqual([]); - expect(chunk(["u-1"], -3)).toEqual([]); - }); -}); - -describe("pluralize", () => { - it("uses the singular form for exactly one", () => { - expect(pluralize(1, "budget", "budgets")).toBe("budget"); - }); - - it("uses the plural form for zero and for more than one", () => { - expect(pluralize(0, "budget", "budgets")).toBe("budgets"); - expect(pluralize(3, "budget", "budgets")).toBe("budgets"); + it("does not prompt when only members on another schedule differ", () => { + expect(shouldPromptMemberBudgetReset(10, 5, nothingMovable)).toBe(false); }); }); diff --git a/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts b/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts index 2b24a5ebbb0..40cec94f184 100644 --- a/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts +++ b/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts @@ -1,38 +1,75 @@ import type { components } from "@/lib/http/schema"; import type { TeamMembership } from "./TeamInfo"; -export const MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES = 500; - export type TeamUpdatePayload = components["schemas"]["UpdateTeamRequest"]; -export interface MemberBudgetResetPending { - readonly teamId: string; - readonly updateData: TeamUpdatePayload; - readonly userIds: readonly string[]; - readonly newBudget: number; +export type MemberBudgetBackfill = NonNullable; + +export interface MemberBudgetBackfillResult { + readonly moved_to_default: number; + readonly skipped_other_reset_period: number; } -type MembershipBudgetRow = Pick & { - litellm_budget_table?: Pick | null; +export interface MemberBudgetBackfillPreview { + readonly below: number; + readonly above: number; + readonly otherResetPeriod: number; +} + +export interface MemberBudgetResetPending { + readonly updateData: TeamUpdatePayload; + readonly newBudget: number; + readonly preview: MemberBudgetBackfillPreview; +} + +type MembershipBudgetRow = Pick & { + litellm_budget_table?: Pick | null; }; -export const customBudgetMemberUserIds = (memberships: readonly MembershipBudgetRow[]): string[] => - memberships - .filter((m) => m.budget_source === "custom" && m.litellm_budget_table?.max_budget != null) - .map((m) => m.user_id); +const FIXED_UNIT_SECONDS: Readonly> = { s: 1, m: 60, h: 3600, d: 86400, w: 604800 }; +const DURATION_WORD_ALIASES: Readonly> = { + hourly: "1h", + daily: "24h", + weekly: "7d", + monthly: "30d", +}; + +export const budgetResetPeriodKey = (duration: string | null | undefined): string | null => { + if (duration == null) return null; + const normalized = (DURATION_WORD_ALIASES[duration.trim().toLowerCase()] ?? duration).trim(); + const parsed = /^(\d+)(mo|[smhdw])$/.exec(normalized); + if (parsed === null) return normalized; + const value = Number(parsed[1]); + const unit = parsed[2]; + return unit === "mo" ? `${value}mo` : `${value * FIXED_UNIT_SECONDS[unit]}s`; +}; + +export const previewMemberBudgetBackfill = ( + memberships: readonly MembershipBudgetRow[], + newBudget: number, + newBudgetDuration: string | null | undefined, +): MemberBudgetBackfillPreview => { + const schedule = budgetResetPeriodKey(newBudgetDuration); + const differing = memberships.flatMap((m) => { + const budget = m.litellm_budget_table; + if (m.budget_source !== "custom" || budget?.max_budget == null || budget.max_budget === newBudget) return []; + return [{ amount: budget.max_budget, sameSchedule: budgetResetPeriodKey(budget.budget_duration) === schedule }]; + }); + const comparable = differing.filter((m) => m.sameSchedule); + return { + below: comparable.filter((m) => m.amount < newBudget).length, + above: comparable.filter((m) => m.amount > newBudget).length, + otherResetPeriod: differing.length - comparable.length, + }; +}; export const shouldPromptMemberBudgetReset = ( nextBudget: number | undefined, previousBudget: number | null | undefined, - customBudgetUserIds: string[], + preview: MemberBudgetBackfillPreview, ): boolean => { const budgetChanged = typeof nextBudget === "number" && nextBudget > 0 && nextBudget !== previousBudget; - return budgetChanged && customBudgetUserIds.length > 0; -}; - -export const chunk = (items: readonly T[], size: number): T[][] => { - if (size <= 0) return []; - return Array.from({ length: Math.ceil(items.length / size) }, (_, i) => items.slice(i * size, i * size + size)); + return budgetChanged && preview.below + preview.above > 0; }; export const pluralize = (count: number, singular: string, plural: string): string => (count === 1 ? singular : plural); diff --git a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx index 71318b635a3..61b65d9a4b0 100644 --- a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx +++ b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx @@ -1,345 +1,126 @@ import { act, renderHook } from "@testing-library/react"; import { afterEach, describe, expect, it, vi } from "vitest"; import { toast } from "@/lib/toast"; -import { MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES } from "./memberBudgetReset"; -import { useMemberBudgetReset, type MemberBudgetResetGateway } from "./useMemberBudgetReset"; +import type { MemberBudgetBackfillResult, MemberBudgetResetPending } from "./memberBudgetReset"; +import { backfillToastMessage, useMemberBudgetReset, type MemberBudgetResetGateway } from "./useMemberBudgetReset"; -const buildGateway = () => ({ - saveTeam: vi.fn(async (_updateData: Record) => {}), - resetMemberBudgets: vi.fn(async (_teamId: string, userIds: readonly string[]) => - userIds.map((user_id) => ({ success: true, user_id })), - ), +const pending: MemberBudgetResetPending = { + updateData: { team_id: "team-123", team_member_budget: 20 }, + newBudget: 20, + preview: { below: 2, above: 1, otherResetPeriod: 0 }, +}; + +const buildGateway = (result?: MemberBudgetBackfillResult) => ({ + saveTeam: vi.fn(async (_updateData: Record) => result), refreshTeamData: vi.fn(async () => {}), }); -const pendingFor = (userIds: string[]) => ({ - teamId: "team-123", - updateData: { team_id: "team-123", team_member_budget: 20 }, - userIds, - newBudget: 20, -}); - const renderReset = (gateway: MemberBudgetResetGateway) => renderHook(() => useMemberBudgetReset(gateway)); +const promptedReset = async (gateway: MemberBudgetResetGateway) => { + const rendered = renderReset(gateway); + await act(async () => { + rendered.result.current.prompt(pending); + }); + return rendered; +}; + +describe("backfillToastMessage", () => { + it.each([ + [undefined, "Team settings updated successfully"], + [{ moved_to_default: 1, skipped_other_reset_period: 0 }, "Moved 1 member to the $20.00 default"], + [ + { moved_to_default: 3, skipped_other_reset_period: 1 }, + "Moved 3 members to the $20.00 default. 1 member resets on a different schedule and was not changed", + ], + [ + { moved_to_default: 0, skipped_other_reset_period: 2 }, + "Moved 0 members to the $20.00 default. 2 members reset on a different schedule and were not changed", + ], + ])("reports %j as %s", (result, message) => { + expect(backfillToastMessage(result, 20)).toBe(message); + }); +}); + describe("useMemberBudgetReset", () => { afterEach(() => { vi.clearAllMocks(); }); - it("starts idle and prompts with the pending update", async () => { + it("holds the update until a choice is saved", async () => { const gateway = buildGateway(); - const { result } = renderReset(gateway); + const { result } = await promptedReset(gateway); - expect(result.current.state.phase).toBe("idle"); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - - expect(result.current.state).toEqual({ - phase: "prompting", - pending: pendingFor(["u-1"]), - }); + expect(result.current.state).toEqual({ phase: "prompting", pending }); expect(gateway.saveTeam).not.toHaveBeenCalled(); }); - it("saves the team once, resets every member, and refreshes on success", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); + it("saves the update and the chosen direction in one request and reports the server's counts", async () => { + const gateway = buildGateway({ moved_to_default: 2, skipped_other_reset_period: 0 }); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); + await result.current.save("raise_to_default"); }); expect(gateway.saveTeam).toHaveBeenCalledTimes(1); - expect(gateway.saveTeam).toHaveBeenCalledWith({ team_id: "team-123", team_member_budget: 20 }); - expect(gateway.resetMemberBudgets).toHaveBeenCalledWith("team-123", ["u-1", "u-2"]); - expect(toast.success).toHaveBeenCalledWith("Reset 2 member budgets to the team default"); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - expect(result.current.state.phase).toBe("idle"); - }); - - it("resets members in batches no larger than the bulk endpoint limit", async () => { - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - const gateway = buildGateway(); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(userIds)); + expect(gateway.saveTeam).toHaveBeenCalledWith({ + team_id: "team-123", + team_member_budget: 20, + team_member_budget_backfill: "raise_to_default", }); - await act(async () => { - await result.current.reset(); - }); - - expect(gateway.resetMemberBudgets).toHaveBeenCalledTimes(2); - expect(gateway.resetMemberBudgets.mock.calls[0][0]).toBe("team-123"); - expect(gateway.resetMemberBudgets.mock.calls[0][1]).toHaveLength(MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - expect(gateway.resetMemberBudgets.mock.calls[1][1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - expect(result.current.state.phase).toBe("idle"); - }); - - it("resets against the team carried by the pending update", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); - - const pending = { - teamId: "team-999", - updateData: { team_id: "team-999", team_member_budget: 20 }, - userIds: ["u-1"], - newBudget: 20, - }; - await act(async () => { - result.current.prompt(pending); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(gateway.resetMemberBudgets).toHaveBeenCalledWith("team-999", ["u-1"]); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalledWith("team-123", expect.anything()); - }); - - it("returns to prompting without its own toast when the team save fails", async () => { - const gateway = buildGateway(); - gateway.saveTeam.mockRejectedValueOnce(new Error("team update failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("prompting"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - expect(toast.success).not.toHaveBeenCalled(); - }); - - it("retries only the unsent members when a later batch fails, without re-saving the team", async () => { - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - const gateway = buildGateway(); - gateway.resetMemberBudgets - .mockResolvedValueOnce( - userIds.slice(0, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES).map((user_id) => ({ success: true, user_id })), - ) - .mockRejectedValueOnce(new Error("second batch failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(userIds)); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("resetFailed"); - expect(toast.error).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES} of ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets; the rest could not be reset`, - ); - - gateway.resetMemberBudgets.mockResolvedValueOnce([ - { success: true, user_id: `u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}` }, - ]); - await act(async () => { - await result.current.retry(); - }); - - expect(gateway.saveTeam).toHaveBeenCalledTimes(1); - expect(gateway.resetMemberBudgets).toHaveBeenCalledTimes(3); - expect(gateway.resetMemberBudgets.mock.calls[2][0]).toBe("team-123"); - expect(gateway.resetMemberBudgets.mock.calls[2][1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - expect(toast.success).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets to the team default`, - ); - expect(result.current.state.phase).toBe("idle"); - }); - - it("reports partial progress when the first batch fails", async () => { - const gateway = buildGateway(); - gateway.resetMemberBudgets.mockRejectedValueOnce(new Error("batch failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("resetFailed"); - expect(toast.fromError).toHaveBeenCalledWith("Team updated, but member budgets could not be reset"); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - }); - - it("reports members the backend could not reset and closes", async () => { - const gateway = buildGateway(); - gateway.resetMemberBudgets.mockResolvedValueOnce([ - { success: true, user_id: "u-1" }, - { success: false, user_id: "u-2" }, - ]); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(toast.error).toHaveBeenCalledWith("Team updated, but 1 member budget could not be reset"); - expect(toast.success).not.toHaveBeenCalled(); + expect(toast.success).toHaveBeenCalledWith("Moved 2 members to the $20.00 default"); expect(result.current.state.phase).toBe("idle"); expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); }); - it("saves the team once and closes on keep custom", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); + it("confirms a plain save when custom budgets are kept", async () => { + const gateway = buildGateway({ moved_to_default: 0, skipped_other_reset_period: 0 }); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - await result.current.keepCustom(); + await result.current.save("none"); }); - expect(gateway.saveTeam).toHaveBeenCalledTimes(1); + expect(gateway.saveTeam).toHaveBeenCalledWith({ ...pending.updateData, team_member_budget_backfill: "none" }); expect(toast.success).toHaveBeenCalledWith("Team settings updated successfully"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - expect(result.current.state.phase).toBe("idle"); }); - it("abandons the pending update on dismiss", async () => { + it("returns to the prompt when the save fails", async () => { const gateway = buildGateway(); - const { result } = renderReset(gateway); + gateway.saveTeam.mockRejectedValueOnce(new Error("save failed")); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - result.current.dismiss(); + await result.current.save("lower_to_default"); }); - expect(result.current.state.phase).toBe("idle"); - expect(gateway.saveTeam).not.toHaveBeenCalled(); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - }); - - it("skips the refresh and stays idle when dismissed while a reset is in flight", async () => { - const gateway = buildGateway(); - const bulkDone = Promise.withResolvers<{ success: boolean; user_id: string }[]>(); - gateway.resetMemberBudgets.mockReturnValueOnce(bulkDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - expect(result.current.state.phase).toBe("resetting"); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - bulkDone.resolve([{ success: true, user_id: "u-1" }]); - await resetPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); + expect(result.current.state).toEqual({ phase: "prompting", pending }); expect(toast.success).not.toHaveBeenCalled(); + expect(gateway.refreshTeamData).not.toHaveBeenCalled(); }); - it("does not return to prompting when the team save fails after a dismiss", async () => { + it("drops the outcome of a save that was dismissed while in flight", async () => { + const save = Promise.withResolvers(); const gateway = buildGateway(); - const saveDone = Promise.withResolvers(); - gateway.saveTeam.mockReturnValueOnce(saveDone.promise); - const { result } = renderReset(gateway); + gateway.saveTeam.mockReturnValueOnce(save.promise); + const { result } = await promptedReset(gateway); - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); + let saving: Promise = Promise.resolve(); + act(() => { + saving = result.current.save("all_to_default"); }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - + expect(result.current.state.phase).toBe("saving"); act(() => { result.current.dismiss(); }); await act(async () => { - saveDone.reject(new Error("team update failed")); - await resetPromise; + save.resolve({ moved_to_default: 3, skipped_other_reset_period: 0 }); + await saving; }); expect(result.current.state.phase).toBe("idle"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - }); - - it("stays idle without a refresh when the reset fails after a dismiss", async () => { - const gateway = buildGateway(); - const bulkDone = Promise.withResolvers<{ success: boolean; user_id: string }[]>(); - gateway.resetMemberBudgets.mockReturnValueOnce(bulkDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - bulkDone.reject(new Error("bulk failed")); - await resetPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - }); - - it("skips the refresh when dismissed while keep-custom is saving", async () => { - const gateway = buildGateway(); - const saveDone = Promise.withResolvers(); - gateway.saveTeam.mockReturnValueOnce(saveDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let keepPromise = Promise.resolve(); - await act(async () => { - keepPromise = result.current.keepCustom(); - }); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - saveDone.resolve(); - await keepPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); expect(toast.success).not.toHaveBeenCalled(); + expect(gateway.refreshTeamData).not.toHaveBeenCalled(); }); }); diff --git a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts index f0ff832b34a..78e8b1a0474 100644 --- a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts +++ b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts @@ -1,128 +1,54 @@ import { useCallback, useRef, useState } from "react"; -import type { components } from "@/lib/http/schema"; import { toast } from "@/lib/toast"; +import { formatNumberWithCommas } from "@/utils/dataUtils"; import { - chunk, - MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES, pluralize, + type MemberBudgetBackfill, + type MemberBudgetBackfillResult, type MemberBudgetResetPending, type TeamUpdatePayload, } from "./memberBudgetReset"; -export type MemberBudgetBulkResult = components["schemas"]["TeamMemberBudgetUpdateResult"]; - export type MemberBudgetResetState = | { phase: "idle" } | { phase: "prompting"; pending: MemberBudgetResetPending } - | { phase: "resetting"; pending: MemberBudgetResetPending; attempted: number } - | { phase: "resetFailed"; pending: MemberBudgetResetPending; attempted: number }; + | { phase: "saving"; pending: MemberBudgetResetPending }; export interface MemberBudgetResetGateway { - saveTeam: (updateData: TeamUpdatePayload) => Promise; - resetMemberBudgets: (teamId: string, userIds: readonly string[]) => Promise; + saveTeam: (updateData: TeamUpdatePayload) => Promise; refreshTeamData: () => Promise; } -type ResetRun = - | { ok: true; attempted: number; results: readonly MemberBudgetBulkResult[] } - | { ok: false; attempted: number; error: unknown }; +export const backfillToastMessage = (result: MemberBudgetBackfillResult | undefined, newBudget: number): string => { + if (result === undefined) return "Team settings updated successfully"; + const moved = `Moved ${result.moved_to_default} ${pluralize(result.moved_to_default, "member", "members")} to the $${formatNumberWithCommas(newBudget, 2)} default`; + const skipped = result.skipped_other_reset_period; + if (skipped === 0) return moved; + return `${moved}. ${skipped} ${pluralize(skipped, "member resets", "members reset")} on a different schedule and ${pluralize(skipped, "was", "were")} not changed`; +}; export const useMemberBudgetReset = (gateway: MemberBudgetResetGateway) => { const [state, setState] = useState({ phase: "idle" }); const activeRun = useRef(null); - const isCurrent = (run: object) => activeRun.current === run; - - const runReset = async (pending: MemberBudgetResetPending, attempted: number, run: object) => { - const { resetMemberBudgets, refreshTeamData } = gateway; - - const runChunks = ( - chunks: readonly (readonly string[])[], - attemptedSoFar: number, - results: readonly MemberBudgetBulkResult[], - ): Promise => { - const [ids, ...rest] = chunks; - if (ids === undefined) return Promise.resolve({ ok: true, attempted: attemptedSoFar, results }); - return resetMemberBudgets(pending.teamId, ids).then( - (batch) => runChunks(rest, attemptedSoFar + ids.length, [...results, ...batch]), - (error: unknown) => ({ ok: false as const, attempted: attemptedSoFar, error }), - ); - }; - - const outcome = await runChunks( - chunk(pending.userIds.slice(attempted), MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES), - attempted, - [], - ); - - if (!isCurrent(run)) return; - if (!outcome.ok) { - console.error("Error resetting member budgets:", outcome.error); - const total = pending.userIds.length; - if (outcome.attempted > 0) { - toast.error( - `Reset ${outcome.attempted} of ${total} member ${pluralize(total, "budget", "budgets")}; the rest could not be reset`, - ); - } else { - toast.fromError("Team updated, but member budgets could not be reset"); - } - setState({ phase: "resetFailed", pending, attempted: outcome.attempted }); - await refreshTeamData(); - return; - } - const failed = outcome.results.filter((r) => !r.success); - if (failed.length > 0) { - toast.error( - `Team updated, but ${failed.length} member ${pluralize(failed.length, "budget", "budgets")} could not be reset`, - ); - } else { - toast.success( - `Reset ${outcome.attempted} member ${pluralize(outcome.attempted, "budget", "budgets")} to the team default`, - ); - } - setState({ phase: "idle" }); - await refreshTeamData(); - }; const prompt = (pending: MemberBudgetResetPending) => setState({ phase: "prompting", pending }); - const reset = async () => { + const save = async (backfill: MemberBudgetBackfill) => { if (state.phase !== "prompting") return; const { pending } = state; const run = {}; activeRun.current = run; - setState({ phase: "resetting", pending, attempted: 0 }); + setState({ phase: "saving", pending }); try { - await gateway.saveTeam(pending.updateData); + const result = await gateway.saveTeam({ ...pending.updateData, team_member_budget_backfill: backfill }); + if (activeRun.current !== run) return; + toast.success(backfillToastMessage(backfill === "none" ? undefined : result, pending.newBudget)); + setState({ phase: "idle" }); + await gateway.refreshTeamData(); } catch (error) { console.error("Error updating team:", error); - if (isCurrent(run)) setState({ phase: "prompting", pending }); - return; + if (activeRun.current === run) setState({ phase: "prompting", pending }); } - await runReset(pending, 0, run); - }; - - const retry = async () => { - if (state.phase !== "resetFailed") return; - const { pending, attempted } = state; - const run = {}; - activeRun.current = run; - setState({ phase: "resetting", pending, attempted }); - await runReset(pending, attempted, run); - }; - - const keepCustom = async () => { - if (state.phase !== "prompting") return; - const { pending } = state; - const run = {}; - activeRun.current = run; - setState({ phase: "idle" }); - try { - await gateway.saveTeam(pending.updateData); - if (isCurrent(run)) toast.success("Team settings updated successfully"); - } catch (error) { - console.error("Error updating team:", error); - } - if (isCurrent(run)) await gateway.refreshTeamData(); }; const dismiss = useCallback(() => { @@ -130,5 +56,5 @@ export const useMemberBudgetReset = (gateway: MemberBudgetResetGateway) => { setState({ phase: "idle" }); }, []); - return { state, prompt, reset, retry, keepCustom, dismiss }; + return { state, prompt, save, dismiss }; }; diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index f3821a2bb46..4d7d0219d0f 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -40584,6 +40584,11 @@ export interface components { team_id?: string | null; /** Team Member Budget */ team_member_budget?: number | null; + /** + * Team Member Budget Backfill + * @description Which members with their own budget move onto the team_member_budget sent in the same request: 'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. Members whose budget resets on a different schedule than the default are left alone + */ + team_member_budget_backfill?: ("none" | "raise_to_default" | "lower_to_default" | "all_to_default") | null; /** Team Member Budget Duration */ team_member_budget_duration?: string | null; /** Team Member Key Duration */ @@ -48770,6 +48775,11 @@ export interface components { team_id: string; /** Team Member Budget */ team_member_budget?: number | null; + /** + * Team Member Budget Backfill + * @description Which members with their own budget move onto the team_member_budget sent in the same request: 'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. Members whose budget resets on a different schedule than the default are left alone + */ + team_member_budget_backfill?: ("none" | "raise_to_default" | "lower_to_default" | "all_to_default") | null; /** Team Member Budget Duration */ team_member_budget_duration?: string | null; /** Team Member Key Duration */