This commit is contained in:
devin-ai-integration[bot] 2026-10-24 19:17:00 +00:00 • committed by GitHub
commit b1dcc9119c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 1358 additions and 6 deletions

View file

@ -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),

View file

@ -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))

View file

@ -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]:

View file

@ -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"]

View file

@ -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"}))

View file

@ -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"]}