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 2b01e02bb06..f59419f12a9 100644 --- a/litellm/proxy/_types.py +++ b/litellm/proxy/_types.py @@ -1935,6 +1935,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 @@ -1977,6 +1980,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 @@ -2002,6 +2013,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/management_endpoints/common_utils.py b/litellm/proxy/management_endpoints/common_utils.py index adf89c29279..aed6386c5d3 100644 --- a/litellm/proxy/management_endpoints/common_utils.py +++ b/litellm/proxy/management_endpoints/common_utils.py @@ -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,10 +688,16 @@ 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: @@ -698,7 +705,7 @@ async def upsert_budget_and_membership( 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() + await _fall_back_to_team_default() return await tx.litellm_budgettable.update( where={"budget_id": existing_budget_id}, @@ -741,7 +748,7 @@ async def upsert_budget_and_membership( 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 1fa18e9b2b8..e67399fd7a4 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -89,6 +89,8 @@ from litellm.proxy._types import ( TeamInfoResponseObjectTeamTable, TeamListResponseObject, TeamMemberAddRequest, + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, TeamMemberBudgetSource, TeamMemberDeleteRequest, TeamMemberResetBudgetResponse, @@ -204,6 +206,14 @@ 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, + 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, ) @@ -529,6 +539,10 @@ def _team_membership_db(prisma_client: PrismaClient | None) -> "TableActions[pri return TeamMembershipRepository(prisma_client).table +def _team_membership_tx_db(tx: "Prisma") -> "TableActions[prisma_models.LiteLLM_TeamMembership]": + return tx.litellm_teammembership # pyright: ignore[reportReturnType] # TableActions widens the generated inputs to Mapping, as the repositories do + + def _user_db(prisma_client: PrismaClient | None) -> "TableActions[prisma_models.LiteLLM_UserTable]": return UserRepository(prisma_client).table @@ -678,15 +692,14 @@ class TeamMemberBudgetHandler: @staticmethod @with_service_target("team_member_budgets") - async def _evict_default_budget_cache( + async def evict_default_budget_cache( budget_id: str, 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=(f"team_member_default_budget:{budget_id}",), user_api_key_cache=user_api_key_cache + ) @staticmethod async def create_team_member_budget_table( @@ -741,7 +754,7 @@ class TeamMemberBudgetHandler: budget_obj=budget_request, user_api_key_dict=user_api_key_dict, ) - await TeamMemberBudgetHandler._evict_default_budget_cache( + await TeamMemberBudgetHandler.evict_default_budget_cache( budget_id=team_member_budget_table.budget_id, user_api_key_cache=user_api_key_cache, ) @@ -756,89 +769,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""" @@ -849,119 +779,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: """ @@ -1422,6 +1245,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, @@ -1434,26 +1259,83 @@ _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" + changed_member_user_ids: tuple[str, ...] + backfill_result: TeamMemberBudgetBackfillResult | None + + +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, + 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=changed_by, + ) + 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, + changed_member_user_ids=tuple(dict.fromkeys((*member_user_ids, *moved.user_ids))), + backfill_result=moved.result() if backfill != "none" else None, + ) def _existing_model_cap(raw_budget_config: object) -> BudgetConfig | None: @@ -2284,15 +2166,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, @@ -2361,6 +2234,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`. @@ -2702,50 +2576,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: @@ -2784,7 +2626,31 @@ 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 + ), + changed_member_user_ids=(), + backfill_result=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", + changed_by=user_api_key_dict.user_id or litellm_proxy_admin_name, + ) + ) + team_row: Final = team_write.team_row + backfill_response: Final = ( + {"team_member_budget_backfill_result": team_write.backfill_result} + if team_write.backfill_result is not None + else {} + ) if team_row is None or team_row.team_id is None: raise HTTPException( @@ -2793,6 +2659,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), @@ -2807,14 +2683,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, **{key: value.model_dump() for key, value in backfill_response.items()}}, 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, **backfill_response} except Exception as e: raise handle_exception_on_proxy(e) @@ -4115,13 +3991,6 @@ async def team_member_update( status_code=400, detail={"error": f"User id doesn't exist in team table. Data={data}"}, ) - ## find the relevant team membership - identified_budget_id: str | None = None - for tm in returned_team_info["team_memberships"]: - if tm.user_id == received_user_id: - identified_budget_id = tm.budget_id - break - # If this membership still points at the team's shared default member # budget, _upsert_budget_and_membership will clone-on-write so that the # update only touches this user (not every member sharing the default). @@ -4134,6 +4003,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, @@ -4146,11 +4016,14 @@ async def team_member_update( if data.role is not None else None ) + locked_membership: Final = await _team_membership_tx_db(tx).find_unique( + where={"user_id_team_id": {"user_id": received_user_id, "team_id": data.team_id}} + ) await upsert_budget_and_membership( tx=tx, team_id=data.team_id, user_id=received_user_id, - existing_budget_id=identified_budget_id, + existing_budget_id=locked_membership.budget_id if locked_membership is not None else None, user_api_key_dict=user_api_key_dict, budget_patch=budget_patch, team_default_budget_id=team_default_budget_id, @@ -5014,22 +4887,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) @@ -5038,6 +4912,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..bbac2b7781d --- /dev/null +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -0,0 +1,243 @@ +import uuid +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from types import MappingProxyType +from typing import TYPE_CHECKING, Final + +from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter + +from litellm.litellm_core_utils.duration_parser import budget_reset_period_key +from litellm.proxy._types import ( + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, + UpdateTeamRequest, +) +from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time + +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' +) +_ON_CHOSEN_SIDE_OF_DEFAULT: Final = """m.team_id = $1 AND m.budget_id <> $2 AND CASE $3::text + WHEN 'raise_to_default' THEN b.max_budget < $4::double precision + WHEN 'lower_to_default' THEN b.max_budget > $4::double precision + WHEN 'all_to_default' THEN b.max_budget <> $4::double precision + ELSE FALSE END""" +_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 ' + + _ON_CHOSEN_SIDE_OF_DEFAULT + + " GROUP BY b.budget_duration" +) +_MOVE_MEMBERS_SQL: Final = ( + """ +WITH candidates AS MATERIALIZED ( + SELECT m.user_id, b.*, CASE WHEN + b.soft_budget IS NOT NULL OR b.max_parallel_requests IS NOT NULL OR + b.tpm_limit IS NOT NULL OR b.rpm_limit IS NOT NULL OR b.tpd_limit IS NOT NULL OR + b.temp_budget_increase IS NOT NULL OR b.temp_budget_expiry IS NOT NULL OR + COALESCE(b.model_max_budget, '{}'::jsonb) NOT IN ('{}'::jsonb, 'null'::jsonb) OR + cardinality(b.allowed_models) > 0 + THEN gen_random_uuid()::text ELSE $2 END AS next_budget_id + FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id + WHERE """ + + _ON_CHOSEN_SIDE_OF_DEFAULT + + """ AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL)) +), copies AS ( + INSERT INTO "LiteLLM_BudgetTable" ( + budget_id, max_budget, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit, + model_max_budget, budget_duration, budget_reset_at, allowed_models, temp_budget_increase, + temp_budget_expiry, created_by, updated_by, created_at, updated_at + ) + SELECT next_budget_id, NULL, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit, + model_max_budget, budget_duration, + (SELECT budget_reset_at FROM "LiteLLM_BudgetTable" WHERE budget_id = $2), + allowed_models, temp_budget_increase, temp_budget_expiry, $7, $7, + NOW() AT TIME ZONE 'UTC', NOW() AT TIME ZONE 'UTC' + FROM candidates WHERE next_budget_id <> $2 + RETURNING budget_id +) +UPDATE "LiteLLM_TeamMembership" m SET budget_id = c.next_budget_id +FROM candidates c +WHERE m.team_id = $1 AND m.user_id = c.user_id + AND (c.next_budget_id = $2 OR c.next_budget_id IN (SELECT budget_id FROM copies)) +RETURNING m.user_id +""" +) + + +@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 _MovedMember(BaseModel): + model_config = ConfigDict(frozen=True) + + user_id: str + + +_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue]) +_SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...]) +_MOVED_MEMBERS: Final = TypeAdapter(tuple[_MovedMember, ...]) + + +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 = _JSON_OBJECT.validate_python( + data.model_dump(mode="json", include=data.model_fields_set & _DEFAULT_BUDGET_COLUMNS.keys()) + ) + 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.get("budget_duration", 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": _prisma_columns( + {**write.create, **stamps, "budget_id": write.budget_id, "created_by": changed_by} + ), + "update": _prisma_columns({**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: str, +) -> MovedMemberBudgets | TooManyMemberBudgetsToMove: + if backfill == "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, team_id, default_budget_id, backfill, 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) + moved: Final = _MOVED_MEMBERS.validate_python( + await tx.query_raw( + _MOVE_MEMBERS_SQL, + team_id, + default_budget_id, + backfill, + default.max_budget, + [count.duration for count in matching if count.duration is not None], + any(count.duration is None for count in matching), + changed_by, + ) + ) + return MovedMemberBudgets(user_ids=tuple(member.user_id for member in moved), skipped_other_reset_period=skipped) + + +def _prisma_columns(columns: Mapping[str, object]) -> Mapping[str, object]: + from prisma import Json # noqa: PLC0415 # local import: prisma may be ungenerated at module load in some tools + + return {column: Json(value) if isinstance(value, dict) else value for column, value in columns.items()} + + +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 _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/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..cea18c2e9a3 --- /dev/null +++ b/tests/integration/management/test_team_member_budget_backfill.py @@ -0,0 +1,328 @@ +from collections.abc import Mapping +from dataclasses import dataclass +from datetime import datetime, timezone +from typing import Final + +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 ManagementDatabase, ScratchResources, 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.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_a_moved_member_keeping_their_own_limits_resets_with_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"own_rpm": _Budget(20.0, rpm_limit=5)}) + default_reset = datetime(2030, 1, 1, tzinfo=timezone.utc) + await db.db.litellm_budgettable.update( + where={"budget_id": default_budget_id}, data={"budget_reset_at": default_reset} + ) + await db.db.litellm_budgettable.update( + where={"budget_id": resources.tag("own-own_rpm")}, + data={"budget_reset_at": datetime(2030, 1, 15, tzinfo=timezone.utc)}, + ) + + 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 + kept = (await _member_budget(db, resources, "own_rpm")).litellm_budget_table + assert (kept.max_budget, kept.rpm_limit, kept.budget_reset_at) == (None, 5, default_reset) + + +async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"scoped": _Budget(20.0)}) + for budget_id in (default_budget_id, resources.tag("own-scoped")): + await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data={"allowed_models": ["test-model"]}) + + 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 + scoped = await _member_budget(db, resources, "scoped") + assert (scoped.litellm_budget_table.max_budget, scoped.litellm_budget_table.allowed_models) == ( + None, + ["test-model"], + ) + + +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 + + +@pytest.mark.parametrize( + "limits", + [ + {"rpm_limit": 5}, + {"tpm_limit": 7}, + {"tpd_limit": 11}, + {"soft_budget": 0.0}, + {"max_parallel_requests": 0}, + {"model_max_budget": Json({"test-model": {"max_budget": 2.0}})}, + {"allowed_models": ["test-model"]}, + {"temp_budget_increase": 5.0, "temp_budget_expiry": datetime(2030, 1, 1, tzinfo=timezone.utc)}, + ], +) +async def test_moving_a_member_preserves_every_other_limit_even_when_it_matches_the_default( + limits: Mapping[str, object], db: ManagementDatabase, resources: ScratchResources +) -> None: + default_id: Final = await _seed_team(db, resources, {"custom": _Budget(20.0)}) + for budget_id in (default_id, resources.tag("own-custom")): + await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data=dict(limits)) + original: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table + + response: Final = _update_team( + db, resources.prefix, {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"} + ) + + assert response.status_code == 200, response.text + moved: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table + assert moved.max_budget is None + assert {field: getattr(moved, field) for field in limits} == {field: getattr(original, field) for field in limits} + untouched: Final = await db.db.litellm_budgettable.find_unique(where={"budget_id": original.budget_id}) + assert untouched == original 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..b0680133325 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,47 @@ 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"}}}, + ) + + +@pytest.mark.asyncio +async def test_emptying_a_member_on_a_limitless_team_default_keeps_them_on_it(mock_tx, fake_user): + mock_tx.litellm_budgettable.find_unique = AsyncMock(return_value=budget_row(budget_id="team-default")) + + await upsert_budget_and_membership( + mock_tx, + team_id="team-1", + user_id="user-1", + existing_budget_id="team-default", + 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"}}}, + ) + mock_tx.litellm_budgettable.create.assert_not_called() + + # 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 f727448f3ac..eff33731ec3 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 @@ -2870,174 +2871,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(): """ Test that _clean_team_member_fields removes all team member fields from a dictionary. @@ -3201,167 +3034,6 @@ 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 async def test_create_team_member_budget_table_explicit_null_duration_does_not_inherit_team_duration( mock_db_client, @@ -3446,301 +3118,6 @@ 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 async def test_bulk_team_member_add_success(): """ @@ -10361,7 +9738,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) @@ -10369,8 +9746,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 @@ -11995,47 +11375,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 async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts_cache( disable_audit_logging_for_mocked_team, @@ -12058,7 +11397,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 ( @@ -12070,7 +11408,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( @@ -12079,16 +11417,189 @@ 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"].data == {} + assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] + + +@pytest.mark.asyncio +async def test_clearing_the_member_default_evicts_every_roster_members_cached_membership( + disable_audit_logging_for_mocked_team, +): + """A member on the default caches the default row inside their membership, so clearing its cap must drop + that cached copy, or a member already at the old cap stays blocked until the cache expires.""" + from fastapi import Request + + from litellm.proxy._types import UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + cache: Final = MagicMock() + cache.async_get_cache = AsyncMock(return_value=None) + cache.async_set_cache = AsyncMock() + cache.async_delete_cache = AsyncMock() + updated: Final = _existing_team_with_model_caps({}) + updated.metadata = existing.metadata + updated.litellm_model_table = None + prisma: Final = MagicMock() + + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", cache), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + 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) + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(return_value=[{"members_with_roles": [{"user_id": "at-old-cap", "role": "user"}]}]) + + await update_team( + data=UpdateTeamRequest(team_id="standalone-team-123", team_member_budget=None), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + evicted: Final = {c.args[0] for c in cache.in_memory_cache_for.return_value.delete_cache.call_args_list} + assert "standalone-team-123_at-old-cap" in evicted + + +def _backfill_ready_prisma(answer): + from types import SimpleNamespace + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + updated: Final = _existing_team_with_model_caps({}) + updated.metadata = existing.metadata + updated.litellm_model_table = None + prisma: Final = MagicMock() + 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) + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(side_effect=answer) + default_row: Final = {"max_budget": 50.0, "budget_duration": "30d"} + prisma.db.litellm_budgettable.find_unique = AsyncMock( + return_value=SimpleNamespace(**default_row, model_dump=lambda: default_row) + ) + return prisma + + +async def _raise_to_default(prisma): + from fastapi import Request + + from litellm.proxy._types import UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + + cache: Final = MagicMock() + cache.async_get_cache = AsyncMock(return_value=None) + cache.async_set_cache = AsyncMock() + cache.async_delete_cache = AsyncMock() + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", cache), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + return await update_team( + data=UpdateTeamRequest( + team_id="standalone-team-123", team_member_budget=50.0, team_member_budget_backfill="raise_to_default" + ), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + +@pytest.mark.asyncio +async def test_a_backfill_reports_how_many_members_moved(disable_audit_logging_for_mocked_team): + from litellm.proxy._types import TeamMemberBudgetBackfillResult + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + if "GROUP BY b.budget_duration" in sql: + return [{"duration": "30d", "members": 1}, {"duration": "7d", "members": 2}] + if "b.budget_duration = ANY" in sql: + return [{"user_id": "below", "budget_id": "own-below", "budget_duration": "30d"}] + if "HAVING COUNT(*) > 1" in sql: + return [] + return [{"members_with_roles": [{"user_id": "below", "role": "user"}]}] + + response: Final = await _raise_to_default(_backfill_ready_prisma(answer)) + + assert response["team_member_budget_backfill_result"] == TeamMemberBudgetBackfillResult( + moved_to_default=1, skipped_other_reset_period=2 + ) + + +@pytest.mark.asyncio +async def test_a_team_deleted_while_its_update_waits_for_the_lock_is_not_written(disable_audit_logging_for_mocked_team): + from litellm.proxy._types import ProxyException + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + return [] + + prisma: Final = _backfill_ready_prisma(answer) + + with pytest.raises(ProxyException) as gone: + await _raise_to_default(prisma) + + assert gone.value.code == "404" + prisma.db.litellm_teamtable.update.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_a_backfill_over_the_member_limit_is_refused_without_writing_the_team( + disable_audit_logging_for_mocked_team, +): + from types import SimpleNamespace + + from fastapi import Request + + from litellm.proxy._types import ProxyException, UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + prisma: Final = MagicMock() + over_limit: Final = MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1 + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + if "GROUP BY b.budget_duration" in sql: + return [{"duration": "30d", "members": over_limit}] + return [{"members_with_roles": []}] + + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + 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() + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(side_effect=answer) + prisma.db.litellm_budgettable.find_unique = AsyncMock( + return_value=SimpleNamespace(max_budget=50.0, budget_duration="30d") + ) + + with pytest.raises(ProxyException) as refused: + await update_team( + data=UpdateTeamRequest( + team_id="standalone-team-123", + team_member_budget=50.0, + team_member_budget_backfill="raise_to_default", + ), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + assert refused.value.code == "422" + assert str(over_limit) in refused.value.message + prisma.db.litellm_teamtable.update.assert_not_awaited() @pytest.mark.asyncio @@ -12114,7 +11625,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 ( @@ -12126,7 +11636,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), @@ -12134,10 +11644,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 = budget_upsert["data"]["update"]["model_max_budget"].data assert { model: { **budget, @@ -12153,10 +11662,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")] # --------------------------------------------------------------------------- @@ -13208,211 +12714,6 @@ 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 async def test_team_member_budget_duration_not_sent_does_not_update(): """ @@ -13444,46 +12745,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 async def test_team_info_forwards_key_limit_to_get_data(): """/team/info must thread its ``key_limit`` query param into the key @@ -13841,13 +13102,12 @@ async def _drive_team_write( new=AsyncMock(), ), ): - pc.db.litellm_teamtable.find_unique = AsyncMock( - return_value=None if find_returns_none else existing - ) + pc.db.litellm_teamtable.find_unique = AsyncMock(return_value=None if find_returns_none else existing) pc.db.litellm_teamtable.update = AsyncMock( 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 @@ -13980,14 +13240,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) @@ -15314,6 +14568,7 @@ async def test_team_member_update_role_change_emits_a_roster_audit_event(monkeyp mock_prisma_client.db.litellm_auditlog.create = AsyncMock() monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) _wire_member_delete_tx(mock_prisma_client) + mock_prisma_client.db.litellm_teammembership.find_unique = AsyncMock(return_value=None) with ( patch( # test-quality-ok: no live DB here; matches this file's established convention for endpoint-logic unit tests @@ -15409,6 +14664,7 @@ async def test_team_member_update_role_change_rewrites_the_roster_it_read_under_ mock_prisma_client.db.litellm_auditlog.create = AsyncMock() monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) tx = _wire_member_delete_tx(mock_prisma_client) + mock_prisma_client.db.litellm_teammembership.find_unique = AsyncMock(return_value=None) team_info_patch, upsert_patch = _member_update_patches(stale_snapshot) with team_info_patch, upsert_patch: @@ -17217,25 +16473,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 @@ -17766,6 +17003,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" @@ -19098,7 +18352,7 @@ async def test_default_budget_cache_eviction_does_not_fail_after_redis_error() - user_api_key_cache = MagicMock() user_api_key_cache.async_delete_cache = AsyncMock(side_effect=RuntimeError("redis unavailable")) - await TeamMemberBudgetHandler._evict_default_budget_cache( + await TeamMemberBudgetHandler.evict_default_budget_cache( budget_id="budget_456", user_api_key_cache=user_api_key_cache, ) 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..3d13c73e98c 100644 --- a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py +++ b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py @@ -905,7 +905,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 +939,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 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..8220f681b1f --- /dev/null +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -0,0 +1,88 @@ +import json +from datetime import datetime + +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(): + 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" + reset_at = write.create["budget_reset_at"] + assert isinstance(reset_at, datetime) + 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(): + write = _plan(existing_budget_id="default-1", team_member_budget_duration="7d") + + assert write is not None + assert write.update["budget_duration"] == "7d" + reset_at = write.update["budget_reset_at"] + assert isinstance(reset_at, datetime) + + +@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 = {"test-model": {"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"]))["test-model"]["max_budget"] == 5.0 diff --git a/tests/unit/proxy/test_team_member_update.py b/tests/unit/proxy/test_team_member_update.py index d77904fc05d..502fa3340a4 100644 --- a/tests/unit/proxy/test_team_member_update.py +++ b/tests/unit/proxy/test_team_member_update.py @@ -69,6 +69,9 @@ def happy_path_upsert(monkeypatch): class _FakeTx: litellm_teamtable = prisma_client.db.litellm_teamtable + litellm_teammembership = types.SimpleNamespace( + find_unique=AsyncMock(return_value=types.SimpleNamespace(user_id="user-1", budget_id="bud-under-lock")) + ) async def __aenter__(self): return self @@ -123,6 +126,17 @@ async def test_team_member_update_sends_provided_fields_as_patch(happy_path_upse assert response.budget_duration == "30d" +@pytest.mark.asyncio +async def test_team_member_update_writes_the_budget_the_member_has_once_the_team_lock_is_held(happy_path_upsert): + """A team default backfill that commits while this update waits for the lock can relink the member. The + update must then write the budget the member points at now, not the one read before the lock.""" + data, request, auth = _member_update_request(max_budget_in_team=30.0) + + await team_member_update(data, request, auth) + + assert happy_path_upsert.await_args.kwargs["existing_budget_id"] == "bud-under-lock" + + @pytest.mark.asyncio async def test_team_member_update_explicit_null_clears_field(happy_path_upsert): """An explicitly-null field must be forwarded as None so the column is diff --git a/ui/litellm-dashboard/src/components/networking.tsx b/ui/litellm-dashboard/src/components/networking.tsx index fd25242ec34..b1283383780 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..b80202568a2 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 $1,250.00 default to custom budgets?")).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..5edc148c072 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx @@ -1,70 +1,99 @@ -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 ${formatNumberWithCommas(pending.newBudget, 2)} default to custom budgets? + + 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..fe028073ff3 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 $20.00 default to custom budgets?"; + 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 custom budgets/)).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 262e8b6deae..6099d7599ee 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -17315,6 +17315,7 @@ export interface paths { * - 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`. @@ -40597,6 +40598,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 */ @@ -48799,6 +48805,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 */