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 */