diff --git a/litellm/proxy/management_endpoints/internal_user_endpoints.py b/litellm/proxy/management_endpoints/internal_user_endpoints.py index d6bf9220551..f29a7285b40 100644 --- a/litellm/proxy/management_endpoints/internal_user_endpoints.py +++ b/litellm/proxy/management_endpoints/internal_user_endpoints.py @@ -32,6 +32,7 @@ from litellm._uuid import uuid from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.proxy._types import * from litellm.proxy.auth.auth_checks import ( + TeamNotFoundError, delete_cache_key_objects, forget_missing_user, get_jwt_key_mapping_cache_keys_for_tokens, @@ -80,9 +81,11 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa: _set_object_permission, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export handle_update_object_permission_common, set_object_permission, + validate_user_mcp_grants_against_teams, ) from litellm.proxy.management_helpers.utils import management_endpoint_wrapper from litellm.proxy.utils import handle_exception_on_proxy, hash_password +from litellm.repositories.object_permission_repository import ObjectPermissionRepository from litellm.repositories.organization_repository import OrganizationRepository from litellm.repositories.prisma_protocols import TableActions from litellm.repositories.table_repositories import ( @@ -459,6 +462,73 @@ async def _fetch_user_team_ids(user_id: str, prisma_client: "PrismaClient") -> t return tuple(user_row.teams) if user_row is not None else () +async def _load_user_mcp_grant_teams( + team_ids: Sequence[str], + prisma_client: "PrismaClient", + user_api_key_cache: "UserApiKeyCache", +) -> tuple["LiteLLM_TeamTableCachedObj", ...]: + async def _load_team(team_id: str) -> "LiteLLM_TeamTableCachedObj | None": + try: + return await get_team_object( + team_id=team_id, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + check_db_only=True, + ) + except TeamNotFoundError: + return None + + return tuple( + team_obj + for team_obj in await asyncio.gather(*(_load_team(team_id) for team_id in team_ids)) + if team_obj is not None + ) + + +async def _validate_user_mcp_grants( + object_permission: object, + team_ids: Sequence[str], + existing_object_permission_id: str | None, + prisma_client: "PrismaClient", + user_api_key_cache: "UserApiKeyCache", + *, + is_proxy_admin: bool, +) -> None: + validated_object_permission: Final[ObjectPermissionDict | None] = TypeAdapter[ObjectPermissionDict | None]( + ObjectPermissionDict | None + ).validate_python(object_permission) + if validated_object_permission is None or (not team_ids and is_proxy_admin): + return + + team_objs: Final = ( + await _load_user_mcp_grant_teams( + team_ids=team_ids, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + ) + if team_ids + else () + ) + existing_object_permission_row: Final = ( + await ObjectPermissionRepository(prisma_client).table.find_unique( + where={"object_permission_id": existing_object_permission_id}, + ) + if existing_object_permission_id is not None + else None + ) + existing_object_permission: Final[LiteLLM_ObjectPermissionTable | None] = ( + LiteLLM_ObjectPermissionTable.model_validate(existing_object_permission_row.model_dump()) + if existing_object_permission_row is not None + else None + ) + await validate_user_mcp_grants_against_teams( + object_permission=validated_object_permission, + team_objs=team_objs, + prisma_client=prisma_client, + existing_user_object_permission=existing_object_permission, + ) + + @router.post( "/user/new", tags=["Internal User management"], @@ -535,7 +605,7 @@ async def new_user( ``` """ try: - from litellm.proxy.proxy_server import _license_check, prisma_client + from litellm.proxy.proxy_server import _license_check, prisma_client, user_api_key_cache if prisma_client is None: raise HTTPException(status_code=400, detail=CommonProxyErrors.db_not_connected_error.value) @@ -582,6 +652,22 @@ async def new_user( data_json = data.json() data_json = _update_internal_new_user_params(data_json, data) + teams: Final = data.teams if data.teams is not None else check_if_default_team_set() + team_ids: Final = ( + (data.team_id,) + if data.team_id is not None + else tuple(team if isinstance(team, str) else team.team_id for team in teams or ()) + ) + await _validate_user_mcp_grants( + object_permission=TypeAdapter[dict[str, object]](dict[str, object]) + .validate_python(data_json) + .get("object_permission"), + team_ids=team_ids, + existing_object_permission_id=None, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + is_proxy_admin=user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value, + ) # Persist the requested grants as their own row and link it, mirroring key/team creation. # generate_key_helper_fn only forwards object_permission_id, so without this the entitlement # the caller sent would be dropped on the floor. @@ -589,9 +675,6 @@ async def new_user( data_json=data_json, prisma_client=prisma_client ) data_json.pop("password", None) - teams = data.teams - if teams is None: - teams = check_if_default_team_set() organization_ids: Final = cast(list[str] | None, data_json.pop("organizations", None)) response: Final = await generate_key_helper_fn(request_type="user", **data_json, llm_router=None) @@ -1539,6 +1622,20 @@ async def _update_single_user_helper( # Upsert the grants into their own row and link it, mirroring /key/update and /team/update. # This also removes object_permission from the payload, which is not a column on the user table. if "object_permission" in non_default_values: + await _validate_user_mcp_grants( + object_permission=TypeAdapter[dict[str, object]](dict[str, object]).validate_python(non_default_values)[ + "object_permission" + ], + team_ids=TypeAdapter[tuple[str, ...]](tuple[str, ...]).validate_python( + getattr(existing_user_row, "teams", ()) or () + ), + existing_object_permission_id=TypeAdapter[str | None](str | None).validate_python( + getattr(existing_user_row, "object_permission_id", None) + ), + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + is_proxy_admin=user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value, + ) object_permission_id: Final = await handle_update_object_permission_common( data_json=non_default_values, existing_object_permission_id=getattr(existing_user_row, "object_permission_id", None), diff --git a/litellm/proxy/management_helpers/bulk_user_creation.py b/litellm/proxy/management_helpers/bulk_user_creation.py index cca37ebd7ed..79ece32ad2a 100644 --- a/litellm/proxy/management_helpers/bulk_user_creation.py +++ b/litellm/proxy/management_helpers/bulk_user_creation.py @@ -40,6 +40,7 @@ from litellm.proxy.management.teams.dependencies import get_team_access from litellm.proxy.management_endpoints.common_utils import validate_budget_duration from litellm.proxy.management_endpoints.internal_user_endpoints import ( _update_internal_new_user_params, # pyright: ignore[reportPrivateUsage, reportUnknownVariableType] # /user/new defaults; result validated below + _validate_user_mcp_grants, # pyright: ignore[reportPrivateUsage] # shared user-grant validator check_if_default_team_set, ) from litellm.proxy.management_endpoints.key_management_endpoints import ( # noqa: F401 # legacy module exports @@ -340,11 +341,24 @@ def _db_failure( return None -async def _prepare_user(user: _PendingUser, prisma_client: PrismaClient) -> _PreparedUser | _RowFailure: +async def _prepare_user( + user: _PendingUser, + prisma_client: PrismaClient, + user_api_key_cache: "UserApiKeyCache", + is_proxy_admin: bool, +) -> _PreparedUser | _RowFailure: try: dumped: Final = user.request.model_dump(exclude={"user_id"}) data: Final = {**dumped, "user_id": user.user_id} data_json: Final = _JSON_OBJECT.validate_python(_update_internal_new_user_params(data, user.request)) + await _validate_user_mcp_grants( + object_permission=data_json.get("object_permission"), + team_ids=tuple(team.team_id for team in user.teams), + existing_object_permission_id=None, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + is_proxy_admin=is_proxy_admin, + ) with_permission: Final = _JSON_OBJECT.validate_python( await set_object_permission(data_json=data_json, prisma_client=prisma_client) ) @@ -783,6 +797,7 @@ async def bulk_create_users( pending, request_failures = _partition_rows(users, user_api_key_dict) existing_ids, existing_emails = await _existing_user_conflicts(prisma_client, pending) teams, team_errors = await _unusable_teams(prisma_client, pending, user_api_key_dict) + is_proxy_admin: Final = user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value db_failures: Final = tuple( failure for user in pending @@ -802,7 +817,17 @@ async def bulk_create_users( ) ) - prepared_outcomes: Final = tuple([await _prepare_user(user, prisma_client) for user in creatable]) + prepared_outcomes: Final = tuple( + [ + await _prepare_user( + user, + prisma_client, + user_api_key_cache, + is_proxy_admin=is_proxy_admin, + ) + for user in creatable + ] + ) prepare_failures: Final = tuple(o for o in prepared_outcomes if isinstance(o, _RowFailure)) created, insert_failures = await _insert_users( prisma_client, tuple(o for o in prepared_outcomes if isinstance(o, _PreparedUser)) diff --git a/litellm/proxy/management_helpers/object_permission_utils.py b/litellm/proxy/management_helpers/object_permission_utils.py index 920970427ba..b0376f1db2c 100644 --- a/litellm/proxy/management_helpers/object_permission_utils.py +++ b/litellm/proxy/management_helpers/object_permission_utils.py @@ -3,6 +3,7 @@ Common utility functions for handling object permission updates across organizations, teams, and keys. """ +import asyncio import json from collections.abc import Iterable, Mapping, Sequence from collections.abc import Set as AbstractSet @@ -855,6 +856,128 @@ def _validate_requested_toolsets( ) +async def validate_user_mcp_grants_against_teams( + object_permission: ObjectPermissionDict | None, + team_objs: Sequence["LiteLLM_TeamTableCachedObj"], + prisma_client: PrismaClient | None = None, + existing_user_object_permission: "LiteLLM_ObjectPermissionTable | None" = None, +) -> None: + """Validate user MCP grants against the combined grants of the user's teams.""" + requested_servers: Final = _extract_requested_mcp_server_ids(object_permission) + requested_access_groups: Final = _extract_requested_mcp_access_groups(object_permission) + requested_toolsets: Final = _extract_requested_mcp_toolsets(object_permission) + if not requested_servers and not requested_access_groups and not requested_toolsets: + return + + allow_all_keys_servers: Final = get_allow_all_keys_server_ids() + team_server_results: Final = await asyncio.gather( + *(get_team_allowed_mcp_servers(team_obj=team_obj, prisma_client=prisma_client) for team_obj in team_objs) + ) + team_allowed_servers: Final = frozenset[str]().union(*team_server_results) + all_allowed_servers: Final = team_allowed_servers | allow_all_keys_servers + grandfathered_servers: Final = ( + await _get_grandfathered_key_mcp_server_ids( + existing_object_permission=existing_user_object_permission, + prisma_client=prisma_client, + ) + if requested_servers or requested_toolsets + else frozenset[str]() + ) + allowed_mcp_servers: Final = all_allowed_servers | grandfathered_servers + + if requested_servers: + identifier_to_server_ids: Final = await _resolve_mcp_server_identifiers_to_ids( + identifiers=requested_servers, + prisma_client=prisma_client, + ) + active_requested_servers: Final = _flatten_resolved_mcp_server_ids(identifier_to_server_ids) + disallowed_servers: Final = active_requested_servers - allowed_mcp_servers + if disallowed_servers: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail={ + "error": ( + "User requests MCP servers not allowed by any of the user's teams: " + f"{sorted(disallowed_servers)}." + ) + }, + ) + + if requested_access_groups: + team_access_groups: Final = frozenset[str]().union( + *( + team_obj.object_permission.mcp_access_groups or [] + for team_obj in team_objs + if team_obj.object_permission is not None + ) + ) + existing_access_groups: Final = ( + frozenset(existing_user_object_permission.mcp_access_groups or []) + if existing_user_object_permission is not None + else frozenset[str]() + ) + allowed_access_groups: Final = team_access_groups | existing_access_groups + disallowed_groups: Final = requested_access_groups - allowed_access_groups + if disallowed_groups: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail={ + "error": ( + "User requests MCP access groups not allowed by any of the user's teams: " + f"{sorted(disallowed_groups)}." + ) + }, + ) + + if requested_toolsets: + team_toolsets: Final = frozenset[str]().union( + *( + team_obj.object_permission.mcp_toolsets or [] + for team_obj in team_objs + if team_obj.object_permission is not None + ) + ) + existing_toolsets: Final = ( + frozenset(existing_user_object_permission.mcp_toolsets or []) + if existing_user_object_permission is not None + else frozenset[str]() + ) + remaining_toolsets: Final = tuple(sorted(requested_toolsets - team_toolsets - existing_toolsets)) + if remaining_toolsets: + from litellm.proxy._experimental.mcp_server.mcp_server_manager import ( + global_mcp_server_manager, + ) + + resolved_toolset_permissions: Final = await asyncio.gather( + *( + global_mcp_server_manager.resolve_toolset_tool_permissions( + toolset_ids=[toolset_id], + requires_fresh_policy=True, + ) + for toolset_id in remaining_toolsets + ) + ) + disallowed_toolsets: Final = frozenset( + toolset_id + for toolset_id, tool_permissions in zip( + remaining_toolsets, + resolved_toolset_permissions, + strict=True, + ) + if not tool_permissions or not set(tool_permissions).issubset(allowed_mcp_servers) + ) + if disallowed_toolsets: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail={ + "error": ( + "User requests MCP toolsets not allowed by any of the user's teams: " + f"{sorted(disallowed_toolsets)}." + ) + }, + ) + + def _extract_requested_vector_stores( object_permission: ObjectPermissionDict | None, ) -> set[str]: diff --git a/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py b/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py index cb8a73d581b..a07f1f93d1b 100644 --- a/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py @@ -13,6 +13,7 @@ import httpx import pytest from fastapi import HTTPException from fastapi.testclient import TestClient +from prisma.models import LiteLLM_ObjectPermissionTable as PrismaLiteLLM_ObjectPermissionTable from pytest_mock import MockerFixture from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler @@ -5211,3 +5212,534 @@ async def test_user_update_without_password_revokes_nothing(_admin_prisma, mocke await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller) revoke_mock.assert_not_awaited() + + +def _user_mcp_grant_prisma_mocks(mocker: MockerFixture, teams: Sequence[str] = ()) -> MagicMock: + mock_prisma_client: Final = mocker.MagicMock() + existing_user: Final = mocker.MagicMock() + existing_user.model_dump.return_value = { + "user_id": "target-user", + "object_permission_id": None, + "teams": list(teams), + } + existing_user.user_id = "target-user" + existing_user.object_permission_id = None + mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock(return_value=None) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = mocker.AsyncMock( + return_value=SimpleNamespace(object_permission_id="perm-new") + ) + mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[]) + mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"}) + mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda value: value) + mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) + mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin") + mocker.patch( + "litellm.proxy.proxy_server.invalidate_spend_counter", + new=mocker.AsyncMock(), + ) + return mock_prisma_client + + +def _patch_user_mcp_grant_env( + mocker: MockerFixture, + server_ids: Sequence[str], + allow_all_server_ids: Sequence[str] = (), +) -> None: + server_objects: Final = { + server_id: SimpleNamespace(server_id=server_id, alias=None, server_name=None, name=server_id) + for server_id in server_ids + } + manager: Final = mocker.MagicMock() + manager.get_registry.return_value = server_objects + manager.get_mcp_server_by_id.side_effect = lambda server_id: server_objects.get(server_id) + manager.get_allow_all_keys_server_ids.return_value = list(allow_all_server_ids) + mocker.patch( + "litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager", + manager, + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=[]), + ) + + +def _user_mcp_team(team_id: str, access_group_ids: Sequence[str] = ()) -> SimpleNamespace: + return SimpleNamespace( + team_id=team_id, + access_group_ids=list(access_group_ids), + object_permission=None, + ) + + +@pytest.mark.asyncio +async def test_user_update_rejects_server_outside_every_team_before_upserting(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",)) + _patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside")) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=["server-in-team"]), + ) + handle_update: Final = mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.handle_update_object_permission_common", + new=mocker.AsyncMock(), + ) + + with pytest.raises(HTTPException) as exc_info: + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["server-outside"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + assert exc_info.value.status_code == 403 + handle_update.assert_not_called() + mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called() + mock_prisma_client.update_data.assert_not_called() + + +@pytest.mark.asyncio +async def test_user_update_persists_server_allowed_by_a_team(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",)) + _patch_user_mcp_grant_env(mocker, ("server-in-team",)) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=["server-in-team"]), + ) + + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["server-in-team"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + upsert_kwargs: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs + assert upsert_kwargs["data"]["create"]["mcp_servers"] == ["server-in-team"] + assert mock_prisma_client.update_data.call_args.kwargs["data"]["object_permission_id"] == "perm-new" + + +@pytest.mark.asyncio +async def test_user_update_rejects_server_when_all_teams_are_missing(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks( + mocker, + teams=("missing-team-a", "missing-team-b"), + ) + _patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside")) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + + async def get_team(team_id: str, **kwargs: object) -> SimpleNamespace: + raise auth_checks.TeamNotFoundError(team_id) + + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + side_effect=get_team, + ) + + with pytest.raises(HTTPException) as exc_info: + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["server-outside"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + assert exc_info.value.status_code == 403 + mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called() + + +@pytest.mark.asyncio +async def test_user_update_allows_global_server_when_all_teams_are_missing(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("missing-team",)) + _patch_user_mcp_grant_env( + mocker, + ("global-server",), + allow_all_server_ids=("global-server",), + ) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(side_effect=auth_checks.TeamNotFoundError("missing-team")), + ) + + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["global-server"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + upsert_data: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs["data"] + assert upsert_data["create"]["mcp_servers"] == ["global-server"] + + +@pytest.mark.asyncio +async def test_user_update_propagates_non_missing_team_lookup_errors(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",)) + _patch_user_mcp_grant_env(mocker, ("server-a",)) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(side_effect=RuntimeError("team lookup failed")), + ) + + with pytest.raises(RuntimeError, match="team lookup failed"): + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["server-a"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called() + mock_prisma_client.update_data.assert_not_called() + + +@pytest.mark.asyncio +async def test_user_mcp_grant_validation_for_teamless_users(mocker: MockerFixture): + from litellm.proxy.management_endpoints.internal_user_endpoints import _validate_user_mcp_grants + + prisma_client: Final = mocker.MagicMock() + prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock( + return_value=PrismaLiteLLM_ObjectPermissionTable( + object_permission_id="permission-id", + mcp_servers=["stored-server"], + mcp_access_groups=["stored-group"], + vector_stores=[], + agents=[], + agent_access_groups=[], + models=[], + blocked_tools=[], + mcp_toolsets=["stored-toolset"], + search_tools=[], + skills=[], + ) + ) + prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[]) + get_team: Final = mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run")) + cache: Final = mocker.MagicMock() + _patch_user_mcp_grant_env( + mocker, + ("server-outside", "allow-all-server", "stored-server"), + allow_all_server_ids=("allow-all-server",), + ) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=get_team, + ) + + no_permission_result: Final = await _validate_user_mcp_grants( + object_permission=None, + team_ids=("team-a",), + existing_object_permission_id="permission-id", + prisma_client=prisma_client, + user_api_key_cache=cache, + is_proxy_admin=False, + ) + no_teams_result: Final = await _validate_user_mcp_grants( + object_permission={"mcp_servers": ["server-outside"]}, + team_ids=(), + existing_object_permission_id="permission-id", + prisma_client=prisma_client, + user_api_key_cache=cache, + is_proxy_admin=True, + ) + + assert no_permission_result is None + assert no_teams_result is None + + with pytest.raises(HTTPException) as exc_info: + await _validate_user_mcp_grants( + object_permission={"mcp_servers": ["server-outside"]}, + team_ids=(), + existing_object_permission_id=None, + prisma_client=prisma_client, + user_api_key_cache=cache, + is_proxy_admin=False, + ) + + assert exc_info.value.status_code == 403 + assert exc_info.value.detail == { + "error": "User requests MCP servers not allowed by any of the user's teams: ['server-outside']." + } + + allow_all_result: Final = await _validate_user_mcp_grants( + object_permission={"mcp_servers": ["allow-all-server"]}, + team_ids=(), + existing_object_permission_id=None, + prisma_client=prisma_client, + user_api_key_cache=cache, + is_proxy_admin=False, + ) + stored_grant_result: Final = await _validate_user_mcp_grants( + object_permission={ + "mcp_servers": ["stored-server"], + "mcp_access_groups": ["stored-group"], + "mcp_toolsets": ["stored-toolset"], + }, + team_ids=(), + existing_object_permission_id="permission-id", + prisma_client=prisma_client, + user_api_key_cache=cache, + is_proxy_admin=False, + ) + + assert allow_all_result is None + assert stored_grant_result is None + get_team.assert_not_awaited() + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "team_args", + ({"teams": ["team-a"]}, {"team_id": "team-a"}), +) +async def test_new_user_rejects_server_outside_requested_teams_before_persisting( + mocker: MockerFixture, + team_args: dict[str, object], +): + mock_prisma_client: Final = mocker.MagicMock() + mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock() + mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[]) + mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None) + mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock( + return_value=SimpleNamespace(teams=["team-a"]) + ) + mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0) + mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock()) + _patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside")) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=["server-in-team"]), + ) + mocker.patch( + "litellm.proxy.hooks.user_management_event_hooks.UserManagementEventHooks.async_user_created_hook", + new=mocker.AsyncMock(), + ) + mocker.patch( + "litellm.proxy.management_endpoints.team_endpoints.team_member_add", + new=mocker.AsyncMock(), + ) + generate_key: Final = mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn", + new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}), + ) + + with pytest.raises(ProxyException) as exc_info: + await new_user( + data=NewUserRequest( + user_id="new-human", + object_permission={"mcp_servers": ["server-outside"]}, + **team_args, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + assert exc_info.value.code == "403" + assert "server-outside" in exc_info.value.message + mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_called() + generate_key.assert_not_called() + + +@pytest.mark.asyncio +async def test_new_user_rejects_outside_server_for_teamless_non_admin_before_persisting( + mocker: MockerFixture, +) -> None: + mock_prisma_client: Final = mocker.MagicMock() + mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock() + mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[]) + mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None) + mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=None) + mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0) + mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock()) + mocker.patch("litellm.proxy.proxy_server._license_check.is_over_limit", return_value=False) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.check_if_default_team_set", + return_value=None, + ) + _patch_user_mcp_grant_env(mocker, ("server-outside",)) + get_team: Final = mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run")), + ) + generate_key: Final = mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn", + new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}), + ) + + with pytest.raises(ProxyException) as exc_info: + await new_user( + data=NewUserRequest( + user_id="new-human", + user_role=LitellmUserRoles.INTERNAL_USER, + object_permission={"mcp_servers": ["server-outside"]}, + ), + user_api_key_dict=UserAPIKeyAuth( + user_id="internal-caller", + user_role=LitellmUserRoles.INTERNAL_USER, + ), + ) + + assert exc_info.value.code == "403" + assert "server-outside" in exc_info.value.message + mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_awaited() + generate_key.assert_not_awaited() + get_team.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_new_user_uses_team_id_instead_of_teams_for_mcp_grants(mocker: MockerFixture): + mock_prisma_client: Final = mocker.MagicMock() + mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock( + return_value=SimpleNamespace(object_permission_id="perm-created") + ) + mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[]) + mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None) + mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock( + return_value=SimpleNamespace(teams=["team-b"]) + ) + mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0) + mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock()) + _patch_user_mcp_grant_env(mocker, ("server-in-team-a",)) + + teams: Final = { + "team-a": _user_mcp_team("team-a", ("group-a",)), + "team-b": _user_mcp_team("team-b"), + } + + async def get_team(team_id: str, **kwargs: object) -> SimpleNamespace: + return teams[team_id] + + async def get_access_group_servers(access_group_ids: Sequence[str], **kwargs: object) -> list[str]: + return ["server-in-team-a"] if "group-a" in access_group_ids else [] + + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(side_effect=get_team), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(side_effect=get_access_group_servers), + ) + mocker.patch( + "litellm.proxy.hooks.user_management_event_hooks.UserManagementEventHooks.async_user_created_hook", + new=mocker.AsyncMock(), + ) + mocker.patch( + "litellm.proxy.management_endpoints.team_endpoints.team_member_add", + new=mocker.AsyncMock(), + ) + generate_key: Final = mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn", + new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}), + ) + + with pytest.raises(ProxyException) as exc_info: + await new_user( + data=NewUserRequest( + user_id="new-human", + team_id="team-b", + teams=["team-a"], + object_permission={"mcp_servers": ["server-in-team-a"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + assert exc_info.value.code == "403" + assert "server-in-team-a" in exc_info.value.message + mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_called() + generate_key.assert_not_called() + + +@pytest.mark.asyncio +async def test_user_update_grandfathers_prisma_object_permission_model(mocker: MockerFixture) -> None: + from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper + + mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",)) + mock_prisma_client.db.litellm_usertable.find_first.return_value.object_permission_id = "perm-existing" + mock_prisma_client.db.litellm_usertable.find_first.return_value.model_dump.return_value = { + "user_id": "target-user", + "object_permission_id": "perm-existing", + "teams": ["team-a"], + } + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock( + return_value=PrismaLiteLLM_ObjectPermissionTable( + object_permission_id="perm-existing", + mcp_servers=["srv_b"], + mcp_access_groups=[], + vector_stores=[], + agents=[], + agent_access_groups=[], + models=[], + blocked_tools=[], + mcp_toolsets=[], + search_tools=[], + skills=[], + ) + ) + _patch_user_mcp_grant_env(mocker, ("srv_a", "srv_b")) + cache: Final = mocker.MagicMock() + cache.async_delete_cache = mocker.AsyncMock() + mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=["srv_a"]), + ) + + await _update_single_user_helper( + user_request=UpdateUserRequest( + user_id="target-user", + object_permission={"mcp_servers": ["srv_b"]}, + ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN), + ) + + upsert_data: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs["data"] + assert upsert_data["update"]["mcp_servers"] == ["srv_b"] diff --git a/tests/unit/proxy/management_helpers/test_bulk_user_creation.py b/tests/unit/proxy/management_helpers/test_bulk_user_creation.py index cf1ac61c93a..bb1af4e37d0 100644 --- a/tests/unit/proxy/management_helpers/test_bulk_user_creation.py +++ b/tests/unit/proxy/management_helpers/test_bulk_user_creation.py @@ -1,13 +1,18 @@ import json from contextlib import asynccontextmanager +from dataclasses import dataclass +from types import SimpleNamespace from typing import Final import httpx import pytest +from pytest_mock import MockerFixture from prisma.errors import UniqueViolationError from pydantic import BaseModel, ConfigDict, ValidationError from litellm.caching.caching import DualCache +from litellm.models.object_permission import LiteLLM_ObjectPermissionTable +from litellm.models.team import LiteLLM_TeamTableCachedObj from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, Member, UserAPIKeyAuth from litellm.proxy.list_api.common import ManagementProblem from litellm.proxy.management_helpers.bulk_user_creation import bulk_create_users @@ -28,6 +33,7 @@ class _UserRow(BaseModel): user_role: str | None = None teams: list[str] = [] max_budget: float | None = None + object_permission_id: str | None = None class _UserTable: @@ -109,6 +115,26 @@ class _MembershipTable: return len(data) +@dataclass(frozen=True, slots=True) +class _CreatedPermission: + object_permission_id: str + + +class _ObjectPermissionTable: + def __init__(self) -> None: + self.rows: dict[str, dict[str, object]] = {} + + async def create(self, data: dict[str, object]) -> _CreatedPermission: + object_permission_id: Final = f"permission-{len(self.rows) + 1}" + self.rows[object_permission_id] = data + return _CreatedPermission(object_permission_id=object_permission_id) + + +class _MCPServerTable: + async def find_many(self, where: dict[str, object]) -> list[object]: + return [] + + class _Tx: def __init__(self, db: "_Db") -> None: self.litellm_teamtable = db.litellm_teamtable @@ -136,6 +162,8 @@ class _Db: self.litellm_usertable = _UserTable(fail_ids, commit_then_drop, raced_ids) self.litellm_teamtable = _TeamTable(teams) self.litellm_teammembership = _MembershipTable() + self.litellm_objectpermissiontable = _ObjectPermissionTable() + self.litellm_mcpservertable = _MCPServerTable() class _FakePrisma: @@ -281,6 +309,101 @@ async def test_bad_rows_fail_alone_and_good_rows_still_land(): assert [m.user_id for m in prisma.db.litellm_teamtable.rows["t1"].members_with_roles] == ["u1", "u7"] +@pytest.mark.asyncio +async def test_bulk_user_mcp_grants_are_checked_before_permission_rows_are_created( + mocker: MockerFixture, +) -> None: + prisma: Final = _FakePrisma(teams=[_team("team_9193")]) + team_obj: Final = LiteLLM_TeamTableCachedObj( + team_id="team_9193", + object_permission=LiteLLM_ObjectPermissionTable( + object_permission_id="team-permission", + mcp_servers=["srv_a"], + ), + ) + server_objects: Final = { + server_id: SimpleNamespace(server_id=server_id, alias=None, server_name=None, name=server_id) + for server_id in ("srv_a", "srv_b") + } + manager: Final = mocker.MagicMock() + manager.get_registry.return_value = server_objects + manager.get_allow_all_keys_server_ids.return_value = [] + mocker.patch( + "litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager", + manager, + ) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(return_value=team_obj), + ) + mocker.patch( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + new=mocker.AsyncMock(return_value=[]), + ) + + response = await _run( + prisma, + [ + { + "user_id": "u1", + "teams": ["team_9193"], + "object_permission": {"mcp_servers": ["srv_b"]}, + }, + { + "user_id": "u2", + "teams": ["team_9193"], + "object_permission": {"mcp_servers": ["srv_a"]}, + }, + ], + ) + + rejected: Final = response.data[0] + accepted: Final = response.data[1] + assert (rejected.user_id, rejected.success) == ("u1", False) + assert rejected.error is not None and "srv_b" in rejected.error + assert (accepted.user_id, accepted.success, accepted.error) == ("u2", True, None) + assert set(prisma.db.litellm_usertable.rows) == {"u2"} + permission_rows: Final = prisma.db.litellm_objectpermissiontable.rows + assert len(permission_rows) == 1 + accepted_permission_id: Final = prisma.db.litellm_usertable.rows["u2"].object_permission_id + assert accepted_permission_id is not None + assert set(permission_rows) == {accepted_permission_id} + assert permission_rows[accepted_permission_id]["mcp_servers"] == ["srv_a"] + + +@pytest.mark.asyncio +async def test_bulk_user_mcp_grants_reject_outside_server_for_teamless_non_admin( + mocker: MockerFixture, +) -> None: + prisma: Final = _FakePrisma() + server_objects: Final = { + "srv_outside": SimpleNamespace(server_id="srv_outside", alias=None, server_name=None, name="srv_outside") + } + manager: Final = mocker.MagicMock() + manager.get_registry.return_value = server_objects + manager.get_allow_all_keys_server_ids.return_value = [] + mocker.patch( + "litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager", + manager, + ) + mocker.patch( + "litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object", + new=mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run")), + ) + + response: Final = await _run( + prisma, + [{"user_id": "u1", "object_permission": {"mcp_servers": ["srv_outside"]}}], + caller=INTERNAL, + ) + + rejected: Final = response.data[0] + assert (rejected.user_id, rejected.success) == ("u1", False) + assert rejected.error is not None and "srv_outside" in rejected.error + assert prisma.db.litellm_usertable.rows == {} + assert prisma.db.litellm_objectpermissiontable.rows == {} + + @pytest.mark.asyncio async def test_insert_failure_falls_back_to_per_row_and_reports_only_that_row(): prisma = _FakePrisma(teams=[_team("t1")], fail_ids=frozenset({"u2"})) diff --git a/tests/unit/proxy/management_helpers/test_object_permission_utils.py b/tests/unit/proxy/management_helpers/test_object_permission_utils.py index 33557713162..3c7dba00a7b 100644 --- a/tests/unit/proxy/management_helpers/test_object_permission_utils.py +++ b/tests/unit/proxy/management_helpers/test_object_permission_utils.py @@ -25,6 +25,7 @@ from litellm.proxy.management_helpers.object_permission_utils import ( validate_key_mcp_servers_against_team, validate_key_search_tools_against_team, validate_key_vector_stores_against_team, + validate_user_mcp_grants_against_teams, ) @@ -1636,3 +1637,454 @@ def test_object_permission_dict_mirrors_pydantic_model(): f"Only in Pydantic model: {sorted(pydantic_fields - typeddict_fields)}\n" f"Only in TypedDict: {sorted(typeddict_fields - pydantic_fields)}" ) + + +def _make_user_mcp_team( + team_id: str, + mcp_servers: list[str] | None = None, + mcp_access_groups: list[str] | None = None, + access_group_ids: list[str] | None = None, + mcp_toolsets: list[str] | None = None, +) -> MagicMock: + team: Final = MagicMock() + team.team_id = team_id + team.access_group_ids = access_group_ids or [] + if any( + value is not None + for value in (mcp_servers, mcp_access_groups, mcp_toolsets) + ): + team.object_permission = MagicMock(spec=LiteLLM_ObjectPermissionTable) + team.object_permission.mcp_servers = mcp_servers or [] + team.object_permission.mcp_access_groups = mcp_access_groups or [] + team.object_permission.mcp_tool_permissions = {} + team.object_permission.mcp_toolsets = mcp_toolsets + else: + team.object_permission = None + return team + + +def _patch_user_mcp_grant_env( + monkeypatch: pytest.MonkeyPatch, + *server_ids: str, + allow_all_server_ids: tuple[str, ...] = (), + access_group_server_ids: tuple[str, ...] = (), +) -> MagicMock: + manager: Final = _make_mock_mcp_manager(*server_ids) + manager.resolve_toolset_tool_permissions = AsyncMock(return_value={}) + mock_prisma: Final = MagicMock() + mock_prisma.db.litellm_mcpservertable.find_many = AsyncMock(return_value=[]) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager", + manager, + ) + monkeypatch.setattr( + "litellm.proxy.management_helpers.object_permission_utils.get_allow_all_keys_server_ids", + lambda: set(allow_all_server_ids), + ) + monkeypatch.setattr( + "litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups", + AsyncMock(return_value=list(access_group_server_ids)), + ) + return mock_prisma + + +def _patch_user_mcp_toolset_resolution( + monkeypatch: pytest.MonkeyPatch, + server_tool_permissions: dict[str, list[str]], +) -> AsyncMock: + resolver: Final = AsyncMock(return_value=server_tool_permissions) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager.resolve_toolset_tool_permissions", + resolver, + ) + return resolver + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_rejects_servers_outside_every_team(monkeypatch: pytest.MonkeyPatch): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a", "server-b") + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"]) + + with pytest.raises(HTTPException) as exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["server-b"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert exc_info.value.status_code == 403 + assert exc_info.value.detail == { + "error": ( + "User requests MCP servers not allowed by any of the user's teams: ['server-b']." + ) + } + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_the_union_of_teams_and_global_servers( + monkeypatch: pytest.MonkeyPatch, +): + mock_prisma: Final = _patch_user_mcp_grant_env( + monkeypatch, + "server-a", + "server-b", + "global-server", + allow_all_server_ids=("global-server",), + ) + teams: Final = ( + _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"]), + _make_user_mcp_team(team_id="team-b", mcp_servers=["server-b"]), + ) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["server-a", "server-b", "global-server"]}, + team_objs=teams, + prisma_client=mock_prisma, + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_servers_from_team_unified_access_groups( + monkeypatch: pytest.MonkeyPatch, +): + mock_prisma: Final = _patch_user_mcp_grant_env( + monkeypatch, + "group-server", + access_group_server_ids=("group-server",), + ) + team: Final = _make_user_mcp_team(team_id="team-a", access_group_ids=["group-a"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["group-server"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert result is None + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "object_permission", + ( + {"mcp_servers": ["server-a"]}, + {"mcp_access_groups": ["group-a"]}, + {"mcp_toolsets": ["toolset-a"]}, + ), + ids=("server", "access-group", "toolset"), +) +async def test_validate_user_mcp_grants_without_teams_rejects_non_global_grants( + monkeypatch: pytest.MonkeyPatch, + object_permission: ObjectPermissionDict, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a") + if object_permission.get("mcp_toolsets"): + _patch_user_mcp_toolset_resolution(monkeypatch, {"server-a": ["tool-a"]}) + + with pytest.raises(HTTPException) as exc_info: + await validate_user_mcp_grants_against_teams( + object_permission=object_permission, + team_objs=[], + prisma_client=mock_prisma, + ) + + assert exc_info.value.status_code == 403 + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_without_teams_allows_global_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env( + monkeypatch, + "global-server", + allow_all_server_ids=("global-server",), + ) + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["global-server"]}, + team_objs=[], + prisma_client=mock_prisma, + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_without_requested_grants_returns_without_error(): + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": []}, + team_objs=[team], + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_grandfathers_existing_server(monkeypatch: pytest.MonkeyPatch): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "legacy-server") + existing_permission: Final = MagicMock() + existing_permission.mcp_servers = ["legacy-server"] + existing_permission.mcp_tool_permissions = {} + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=[]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["legacy-server"]}, + team_objs=[team], + prisma_client=mock_prisma, + existing_user_object_permission=existing_permission, + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_rejects_disallowed_access_group(monkeypatch: pytest.MonkeyPatch): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch) + team: Final = _make_user_mcp_team(team_id="team-a", mcp_access_groups=["group-a"]) + + with pytest.raises(HTTPException) as exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_access_groups": ["group-b"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert exc_info.value.status_code == 403 + assert exc_info.value.detail == { + "error": ( + "User requests MCP access groups not allowed by any of the user's teams: ['group-b']." + ) + } + + +@pytest.mark.asyncio +async def test_user_grant_errors_do_not_disclose_team_allowlists(monkeypatch: pytest.MonkeyPatch) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env( + monkeypatch, + "srv_a", + "srv_b", + "srv_g", + allow_all_server_ids=("srv_g",), + ) + team: Final = _make_user_mcp_team( + team_id="team-a", + mcp_servers=["srv_a"], + mcp_access_groups=["grp_a"], + ) + + with pytest.raises(HTTPException) as server_exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_servers": ["srv_b"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert server_exc_info.value.status_code == 403 + assert server_exc_info.value.detail == { + "error": "User requests MCP servers not allowed by any of the user's teams: ['srv_b']." + } + + with pytest.raises(HTTPException) as access_group_exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_access_groups": ["grp_b"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert access_group_exc_info.value.status_code == 403 + assert access_group_exc_info.value.detail == { + "error": "User requests MCP access groups not allowed by any of the user's teams: ['grp_b']." + } + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_grandfathers_existing_access_groups(monkeypatch: pytest.MonkeyPatch): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch) + existing_permission: Final = MagicMock() + existing_permission.mcp_access_groups = ["existing-group"] + team: Final = _make_user_mcp_team(team_id="team-a", mcp_access_groups=["team-group"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_access_groups": ["team-group", "existing-group"]}, + team_objs=[team], + prisma_client=mock_prisma, + existing_user_object_permission=existing_permission, + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_unions_toolsets_and_grandfathers_existing_toolsets( + monkeypatch: pytest.MonkeyPatch, +): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch) + team_a: Final = _make_user_mcp_team(team_id="team-a", mcp_toolsets=["toolset-a"]) + team_b: Final = _make_user_mcp_team(team_id="team-b", mcp_toolsets=["toolset-b"]) + existing_permission: Final = MagicMock() + existing_permission.mcp_access_groups = [] + existing_permission.mcp_toolsets = ["toolset-existing"] + existing_permission.mcp_servers = [] + existing_permission.mcp_tool_permissions = {} + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["toolset-a", "toolset-b", "toolset-existing"]}, + team_objs=(team_a, team_b), + prisma_client=mock_prisma, + existing_user_object_permission=existing_permission, + ) + + assert result is None + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_rejects_toolsets_resolving_outside_team_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a", "srv_b") + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]}) + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"]) + + with pytest.raises(HTTPException) as exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_b"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert exc_info.value.status_code == 403 + assert exc_info.value.detail == { + "error": "User requests MCP toolsets not allowed by any of the user's teams: ['ts_b']." + } + resolver.assert_awaited_once_with(toolset_ids=["ts_b"], requires_fresh_policy=True) + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_rejects_toolsets_with_no_resolved_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a") + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {}) + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"]) + + with pytest.raises(HTTPException) as exc_info: + await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_missing"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert exc_info.value.status_code == 403 + assert exc_info.value.detail == { + "error": "User requests MCP toolsets not allowed by any of the user's teams: ['ts_missing']." + } + resolver.assert_awaited_once_with(toolset_ids=["ts_missing"], requires_fresh_policy=True) + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_toolsets_resolving_to_team_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a") + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_a": ["tool_a"]}) + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_a"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert result is None + resolver.assert_awaited_once_with(toolset_ids=["ts_a"], requires_fresh_policy=True) + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_toolsets_resolving_to_allow_all_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env( + monkeypatch, + "srv_a", + "srv_g", + allow_all_server_ids=("srv_g",), + ) + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_g": ["tool_g"]}) + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_g"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert result is None + resolver.assert_awaited_once_with(toolset_ids=["ts_g"], requires_fresh_policy=True) + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_team_toolset_resolving_outside_team_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a", "srv_b") + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]}) + team: Final = _make_user_mcp_team( + team_id="team-a", + mcp_servers=["srv_a"], + mcp_toolsets=["ts_team"], + ) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_team"]}, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert result is None + resolver.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_allows_existing_user_toolset_resolving_outside_team_servers( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_b") + resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]}) + existing_permission: Final = MagicMock() + existing_permission.mcp_servers = [] + existing_permission.mcp_access_groups = [] + existing_permission.mcp_tool_permissions = {} + existing_permission.mcp_toolsets = ["ts_existing"] + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=[]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission={"mcp_toolsets": ["ts_existing"]}, + team_objs=[team], + prisma_client=mock_prisma, + existing_user_object_permission=existing_permission, + ) + + assert result is None + resolver.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_validate_user_mcp_grants_ignores_stale_server_identifiers_without_mutating_input( + monkeypatch: pytest.MonkeyPatch, +): + mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a") + requested: Final[ObjectPermissionDict] = {"mcp_servers": ["stale-server"]} + team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"]) + + result: Final = await validate_user_mcp_grants_against_teams( + object_permission=requested, + team_objs=[team], + prisma_client=mock_prisma, + ) + + assert result is None + assert requested == {"mcp_servers": ["stale-server"]}