This commit is contained in:
Mateo Wang 2026-10-29 09:47:41 -07:00 • committed by GitHub
commit 5f261484bf
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 542 additions and 64 deletions

View file

@ -3332,6 +3332,180 @@ def _make_team_scoped_router(team_id: str = "team-a"):
return Router(model_list=model_list)
def _make_router_with_global_and_team_b_deployment():
from litellm import Router
return Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
]
)
_OTHER_TEAMS_DEPLOYMENT_403: Final = (
"key not allowed to access model. Tried to access model_name_team-b_1111, which is only deployed for other teams"
)
_OUTSIDE_TEAM_A_GRANT_403: Final = (
"key not allowed to access model. This key can only access models=['bedrock-group']. "
"Tried to access model_name_team-b_1111"
)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("valid_token", "denial"),
[
(UserAPIKeyAuth(api_key="sk-teamless", models=["bedrock-group"], team_id=None), _OTHER_TEAMS_DEPLOYMENT_403),
(UserAPIKeyAuth(api_key="sk-team-a", models=["bedrock-group"], team_id="team-a"), _OUTSIDE_TEAM_A_GRANT_403),
(UserAPIKeyAuth(api_key="sk-unrestricted", models=[], team_id=None), _OTHER_TEAMS_DEPLOYMENT_403),
],
ids=["teamless-key", "other-team-key", "unrestricted-key"],
)
@pytest.mark.parametrize(
"model",
["model_name_team-b_1111", ["bedrock-nova", "model_name_team-b_1111"]],
)
async def test_can_key_call_model_denies_other_teams_deployment(valid_token, denial, model):
from litellm.proxy._types import ModelAccessDeniedProxyException, ProxyErrorTypes
from litellm.proxy.auth.auth_checks import can_key_call_model
router = _make_router_with_global_and_team_b_deployment()
with pytest.raises(ModelAccessDeniedProxyException) as exc:
await can_key_call_model(
model=model,
llm_model_list=router.model_list,
valid_token=valid_token,
llm_router=router,
)
assert exc.value.type == ProxyErrorTypes.key_model_access_denied
assert exc.value.code == "403"
assert exc.value.internal_message == denial
def _keys_that_skip_the_key_model_check() -> list[UserAPIKeyAuth]:
return [
UserAPIKeyAuth(api_key="sk-all-team", models=["all-team-models"], team_id=None, team_models=[]),
UserAPIKeyAuth(api_key="sk-config", models=[], team_id=None, config={"model_list": []}),
]
@pytest.mark.asyncio
@pytest.mark.parametrize("valid_token", _keys_that_skip_the_key_model_check(), ids=["all-team-models-key", "config-key"])
@pytest.mark.parametrize(
("model", "fallbacks", "denied"),
[
("model_name_team-b_1111", (), True),
("bedrock-nova", (), False),
("bedrock-nova", ("model_name_team-b_1111",), True),
("bedrock-nova", ({"model": "model_name_team-b_1111"},), True),
("bedrock-nova", ("bedrock-nova",), False),
],
ids=[
"other-teams-deployment",
"global-deployment",
"other-teams-deployment-as-fallback",
"other-teams-deployment-as-fallback-dict",
"global-deployment-as-fallback",
],
)
async def test_enforce_key_access_keys_skipping_the_model_check_still_stop_at_other_teams_deployments(
valid_token, model, fallbacks, denied
):
from litellm.proxy._types import ModelAccessDeniedProxyException
from litellm.proxy.auth.user_api_key_auth import _enforce_key_and_fallback_model_access
router = _make_router_with_global_and_team_b_deployment()
async def enforce() -> None:
await _enforce_key_and_fallback_model_access(
valid_token=valid_token,
request_data={"model": model, **({"fallbacks": list(fallbacks)} if fallbacks else {})},
route="/chat/completions",
request=None,
llm_model_list=router.model_list,
llm_router=router,
)
if not denied:
await enforce()
return
with pytest.raises(ModelAccessDeniedProxyException) as exc:
await enforce()
assert exc.value.code == "403"
assert exc.value.internal_message == _OTHER_TEAMS_DEPLOYMENT_403
@pytest.mark.asyncio
async def test_can_key_call_resolved_model_all_team_models_key_denied_other_teams_deployment():
from litellm.proxy._types import ModelAccessDeniedProxyException
from litellm.proxy.auth.auth_checks import can_key_call_resolved_model
router = _make_router_with_global_and_team_b_deployment()
valid_token = UserAPIKeyAuth(api_key="sk-orphan", models=["all-team-models"], team_models=[])
with pytest.raises(ModelAccessDeniedProxyException) as exc:
await can_key_call_resolved_model(
model="model_name_team-b_1111",
llm_model_list=router.model_list,
valid_token=valid_token,
llm_router=router,
)
assert exc.value.code == "403"
assert exc.value.internal_message == _OTHER_TEAMS_DEPLOYMENT_403
@pytest.mark.asyncio
@pytest.mark.parametrize(
("valid_token", "model"),
[
(UserAPIKeyAuth(api_key="sk-teamless", models=["bedrock-group"], team_id=None), "bedrock-nova"),
(
UserAPIKeyAuth(api_key="sk-team-b", models=["bedrock-group"], team_id="team-b"),
"model_name_team-b_1111",
),
(
UserAPIKeyAuth(
api_key="sk-admin",
models=["bedrock-group"],
team_id=None,
user_role=LitellmUserRoles.PROXY_ADMIN,
),
"model_name_team-b_1111",
),
],
ids=["teamless-key-global-deployment", "owning-team-key", "proxy-admin-key"],
)
async def test_can_key_call_model_access_group_allows_usable_deployments(valid_token, model):
from litellm.proxy.auth.auth_checks import can_key_call_model
router = _make_router_with_global_and_team_b_deployment()
assert (
await can_key_call_model(
model=model,
llm_model_list=router.model_list,
valid_token=valid_token,
llm_router=router,
)
is True
)
def test_can_object_call_model_access_group_with_team_id():
"""
When team_id is passed, _can_object_call_model should resolve

View file

@ -7,6 +7,7 @@ VERIA-39 regression tests:
models the caller is not authorized to use.
"""
from typing import Final
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@ -15,6 +16,12 @@ from fastapi import HTTPException
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
def _router_without_other_teams_deployments() -> MagicMock:
router: Final = MagicMock()
router.model_owned_by_other_teams.return_value = False
return router
def _models(file_content_as_dict):
"""Distinct body.model values, mirroring how the rate limiter collects the
models from a streamed batch file before the access check."""
@ -627,7 +634,7 @@ async def test_pre_call_does_not_skip_for_spoofed_provider():
)
user = UserAPIKeyAuth(api_key="sk-ok", user_id="alice", models=["*"])
mock_router = MagicMock()
mock_router = _router_without_other_teams_deployments()
mock_router.model_list = []
mock_router.resolve_model_name_from_model_id.return_value = "my-openai-model"
@ -699,7 +706,7 @@ async def test_count_input_file_usage_decodes_model_embedded_file_id():
) as mock_afile_content,
patch(
"litellm.proxy.proxy_server.llm_router",
MagicMock(),
_router_without_other_teams_deployments(),
),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
@ -1424,7 +1431,7 @@ async def test_pre_call_enforces_project_otpm_limit_for_batch():
with (
patch("litellm.proxy.proxy_server.general_settings", {}),
patch("litellm.proxy.proxy_server.llm_router", MagicMock()),
patch("litellm.proxy.proxy_server.llm_router", _router_without_other_teams_deployments()),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
return_value={"custom_llm_provider": "openai"},
@ -1478,7 +1485,7 @@ async def test_pre_call_enforces_project_itpm_limit_for_batch():
with (
patch("litellm.proxy.proxy_server.general_settings", {}),
patch("litellm.proxy.proxy_server.llm_router", MagicMock()),
patch("litellm.proxy.proxy_server.llm_router", _router_without_other_teams_deployments()),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
return_value={"custom_llm_provider": "openai"},
@ -1538,7 +1545,7 @@ async def test_pre_call_enforces_project_otpm_limit_for_non_routing_row_model():
with (
patch("litellm.proxy.proxy_server.general_settings", {}),
patch("litellm.proxy.proxy_server.llm_router", MagicMock()),
patch("litellm.proxy.proxy_server.llm_router", _router_without_other_teams_deployments()),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
return_value={"custom_llm_provider": "openai"},
@ -1605,7 +1612,7 @@ async def test_pre_call_charges_each_row_model_against_its_own_project_quota():
with (
patch("litellm.proxy.proxy_server.general_settings", {}),
patch("litellm.proxy.proxy_server.llm_router", MagicMock()),
patch("litellm.proxy.proxy_server.llm_router", _router_without_other_teams_deployments()),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
return_value={"custom_llm_provider": "openai"},
@ -2132,7 +2139,7 @@ def _enqueued_batch_patches():
afile_content_mock = AsyncMock(return_value=mock_content)
return afile_content_mock, (
patch("litellm.proxy.proxy_server.general_settings", {}),
patch("litellm.proxy.proxy_server.llm_router", MagicMock()),
patch("litellm.proxy.proxy_server.llm_router", _router_without_other_teams_deployments()),
patch(
"litellm.proxy.openai_files_endpoints.common_utils.get_credentials_for_model",
return_value={"custom_llm_provider": "openai"},

View file

@ -578,6 +578,45 @@ async def test_v1_model_info_star_wildcard_filter_keeps_provider_expansion(monke
assert [model["model_name"] for model in result] == ["openai/gpt-4o"]
async def test_v1_model_info_allowed_names_expand_access_group_only_to_callers_deployments():
from litellm import Router
from litellm.proxy._types import UserAPIKeyAuth
router: Final = Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
]
)
teamless_key: Final = UserAPIKeyAuth(api_key="sk-teamless", models=["bedrock-group"], team_id=None, team_models=[])
team_b_key: Final = UserAPIKeyAuth(api_key="sk-team-b", models=["bedrock-group"], team_id="team-b", team_models=[])
async def allowed_names(key: UserAPIKeyAuth) -> frozenset[str] | None:
return await proxy_server._get_v1_model_info_allowed_model_names_with_access_groups(
user_api_key_dict=key,
llm_router=router,
prisma_client=None,
user_api_key_cache=None,
proxy_logging_obj=None,
)
assert await allowed_names(teamless_key) == {"bedrock-nova"}
assert await allowed_names(team_b_key) == {"bedrock-nova", "model_name_team-b_1111"}
# ---------------------------------------------------------------------------
# GET /model/info — team BYOK scoping (issue #30983)
# ---------------------------------------------------------------------------

View file

@ -15,6 +15,7 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
import litellm.proxy.proxy_server as ps
from litellm import Router
from litellm.proxy._types import (
LiteLLM_UserTable,
LitellmUserRoles,
@ -696,6 +697,46 @@ async def test_populate_team_access_grants_config_access_group_model():
assert by_id["model-a-id"]["model_info"]["access_via_team_ids"] == [team_id]
@pytest.mark.asyncio
async def test_populate_team_access_direct_grant_expands_group_only_to_non_team_deployments(monkeypatch):
router = Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
]
)
monkeypatch.setattr(ps, "get_all_team_models", AsyncMock(return_value={}))
prisma_client = MagicMock()
prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=LiteLLM_UserTable(user_id="teamless-user", teams=[], models=["bedrock-group"])
)
result = await ps._populate_team_access_on_models(
user_api_key_dict=UserAPIKeyAuth(user_id="teamless-user", models=[], team_models=[]),
prisma_client=prisma_client,
llm_router=router,
all_models=[{**row, "model_info": dict(row["model_info"])} for row in router.model_list],
)
by_id = {m["model_info"]["id"]: m for m in result}
assert by_id["global-nova"]["model_info"]["direct_access"] is True
assert by_id["team-b-nova"]["model_info"]["direct_access"] is False
assert ps._filter_models_to_user_accessible(result) == [by_id["global-nova"]]
@pytest.mark.asyncio
async def test_model_info_v1_team_id_without_db_fails_fast(monkeypatch):
"""`teamId` without a connected DB raises 500 before any enrichment work runs."""
@ -882,6 +923,7 @@ async def test_v1_models_translates_team_model_for_access_group_key(monkeypatch)
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_uuid9"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = None
router.model_list = [team_dep]
@ -892,10 +934,7 @@ async def test_v1_models_translates_team_model_for_access_group_key(monkeypatch)
# Default behavior: listing surfaces public names.
monkeypatch.setattr(ps, "general_settings", {})
# virtual key granted access via the access group (no team membership)
key = UserAPIKeyAuth(
user_id="u", api_key="sk-test", models=["grp-a"], team_models=[]
)
key = UserAPIKeyAuth(user_id="u", api_key="sk-test", models=["grp-a"], team_id="teamX", team_models=[])
resp = await ps.model_list(user_api_key_dict=key)
ids = [d["id"] for d in resp["data"]]
@ -924,6 +963,7 @@ async def test_v1_models_keeps_internal_names_when_public_name_flag_disabled(
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_uuid9"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = None
router.model_list = [team_dep]
@ -933,9 +973,7 @@ async def test_v1_models_keeps_internal_names_when_public_name_flag_disabled(
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {"use_team_public_model_name": False})
key = UserAPIKeyAuth(
user_id="u", api_key="sk-test", models=["grp-a"], team_models=[]
)
key = UserAPIKeyAuth(user_id="u", api_key="sk-test", models=["grp-a"], team_id="teamX", team_models=[])
resp = await ps.model_list(user_api_key_dict=key)
ids = [d["id"] for d in resp["data"]]
@ -959,6 +997,7 @@ async def test_v1_models_translates_team_model_with_metadata(monkeypatch):
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_uuid9"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = None
router.model_list = [team_dep]
@ -969,9 +1008,7 @@ async def test_v1_models_translates_team_model_with_metadata(monkeypatch):
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {})
key = UserAPIKeyAuth(
user_id="u", api_key="sk-test", models=["grp-a"], team_models=[]
)
key = UserAPIKeyAuth(user_id="u", api_key="sk-test", models=["grp-a"], team_id="teamX", team_models=[])
resp = await ps.model_list(user_api_key_dict=key, include_metadata=True)
assert resp["data"] == [
@ -1005,6 +1042,7 @@ async def test_v1_models_metadata_fallbacks_use_internal_routing_key(monkeypatch
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_uuid9"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = None
router.model_list = [team_dep]
@ -1017,9 +1055,7 @@ async def test_v1_models_metadata_fallbacks_use_internal_routing_key(monkeypatch
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {})
key = UserAPIKeyAuth(
user_id="u", api_key="sk-test", models=["grp-a"], team_models=[]
)
key = UserAPIKeyAuth(user_id="u", api_key="sk-test", models=["grp-a"], team_id="teamX", team_models=[])
resp = await ps.model_list(user_api_key_dict=key, include_metadata=True)
assert resp["data"] == [
@ -1062,6 +1098,7 @@ async def test_v1_models_metadata_does_not_leak_other_team_fallbacks(monkeypatch
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_uuid9"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_uuid9"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = None
router.model_list = [team_x, team_y]
@ -1076,9 +1113,7 @@ async def test_v1_models_metadata_does_not_leak_other_team_fallbacks(monkeypatch
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {})
key = UserAPIKeyAuth(
user_id="u", api_key="sk-test", models=["grp-a"], team_models=[]
)
key = UserAPIKeyAuth(user_id="u", api_key="sk-test", models=["grp-a"], team_id="teamX", team_models=[])
resp = await ps.model_list(user_api_key_dict=key, include_metadata=True)
assert resp["data"] == [
@ -1110,6 +1145,7 @@ async def test_v1_models_team_alias_inherits_token_limits_and_chat_mode(monkeypa
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_terra_uuid"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_terra_uuid"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_terra_uuid"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = DeploymentModelListingInfo(
cost_map_keys=("azure/gpt-4.1",),
@ -1125,7 +1161,7 @@ async def test_v1_models_team_alias_inherits_token_limits_and_chat_mode(monkeypa
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {"use_team_public_model_name": True})
key = UserAPIKeyAuth(user_id="user", api_key="***", models=["grp-a"], team_models=[])
key = UserAPIKeyAuth(user_id="user", api_key="***", models=["grp-a"], team_id="teamX", team_models=[])
response = await ps.model_list(user_api_key_dict=key, include_metadata=True)
assert response["data"] == [
@ -1158,6 +1194,7 @@ async def test_v1_models_team_image_alias_inherits_image_generation_mode(monkeyp
router = MagicMock()
router.get_model_names.return_value = ["model_name_teamX_image_uuid"]
router.get_model_access_groups.return_value = {"grp-a": ["model_name_teamX_image_uuid"]}
router.get_model_access_groups_usable_by_team.return_value = {"grp-a": ["model_name_teamX_image_uuid"]}
router.get_fully_blocked_model_names.return_value = set()
router.get_model_listing_info.return_value = DeploymentModelListingInfo(
cost_map_keys=("openai/gpt-image-1",),
@ -1173,7 +1210,7 @@ async def test_v1_models_team_image_alias_inherits_image_generation_mode(monkeyp
monkeypatch.setattr(ps, "user_model", None)
monkeypatch.setattr(ps, "general_settings", {"use_team_public_model_name": True})
key = UserAPIKeyAuth(user_id="user", api_key="***", models=["grp-a"], team_models=[])
key = UserAPIKeyAuth(user_id="user", api_key="***", models=["grp-a"], team_id="teamX", team_models=[])
response = await ps.model_list(user_api_key_dict=key)
assert response["data"] == [
@ -1655,6 +1692,14 @@ async def test_retrieve_model_by_inaccessible_public_name_404s(monkeypatch):
router.get_deployment_by_model_group_name.assert_not_called()
def _deployment_row(model_name: str, model_id: str, access_groups: tuple[str, ...] = ()) -> dict:
return {
"model_name": model_name,
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": model_id, "access_groups": list(access_groups)},
}
def test_get_direct_access_models_expands_all_proxy_models_sentinel():
"""A user provisioned with 'all-proxy-models' has direct access to every non-team
deployment. The sentinel must resolve via get_model_ids, not be looked up as a
@ -1679,16 +1724,13 @@ def test_get_direct_access_models_expands_all_proxy_models_sentinel():
def test_get_direct_access_models_resolves_explicit_model_names():
"""Without the sentinel, only the user's explicitly listed models resolve to ids;
the all-proxy-models shortcut must not fire."""
router = MagicMock()
router.get_model_list.return_value = [{"model_info": {"id": "gpt4o-id"}}]
router = Router(model_list=[_deployment_row("gpt-4o", "gpt4o-id"), _deployment_row("sonnet", "sonnet-id")])
user = LiteLLM_UserTable(user_id="u", models=["gpt-4o"], teams=[])
result = ps.get_direct_access_models(user_db_object=user, llm_router=router)
assert result == ("gpt4o-id",)
router.get_model_ids.assert_not_called()
router.get_model_list.assert_called_once_with(model_name="gpt-4o")
def test_get_direct_access_models_empty_models_grants_all_non_team_models():
@ -1749,12 +1791,7 @@ async def test_populate_team_access_grants_empty_models_user_direct_access(monke
def test_get_direct_access_models_restricted_key_narrows_unrestricted_user():
"""A key scoped to one model cannot call the rest, so the listing must not show
every non-team model just because the user record is unrestricted."""
router = MagicMock()
router.get_model_ids.return_value = ["gpt4o-id", "sonnet-id"]
router.get_model_access_groups.return_value = {}
router.get_model_list.side_effect = lambda model_name: (
[{"model_info": {"id": "gpt4o-id"}}] if model_name == "gpt-4o" else []
)
router = Router(model_list=[_deployment_row("gpt-4o", "gpt4o-id"), _deployment_row("sonnet", "sonnet-id")])
user = LiteLLM_UserTable(user_id="u", models=[], teams=[])
@ -1763,17 +1800,12 @@ def test_get_direct_access_models_restricted_key_narrows_unrestricted_user():
assert result == ("gpt4o-id",)
def test_get_direct_access_models_all_proxy_models_key_keeps_team_scoped_user_grant():
def test_get_direct_access_models_all_proxy_models_key_keeps_user_grant():
"""'all-proxy-models' on the key means unrestricted, so it must leave the user's
grant alone rather than clipping it to the non-team deployment set."""
router = MagicMock()
router.get_model_ids.return_value = ["global-id"]
router.get_model_access_groups.return_value = {}
router.get_model_list.side_effect = lambda model_name: (
[{"model_info": {"id": "byok-id"}}] if model_name == "byok-model" else []
)
grant alone rather than widening it to every non-team deployment."""
router = Router(model_list=[_deployment_row("gpt-4o", "gpt4o-id"), _deployment_row("sonnet", "sonnet-id")])
user = LiteLLM_UserTable(user_id="u", models=["byok-model"], teams=[])
user = LiteLLM_UserTable(user_id="u", models=["gpt-4o"], teams=[])
result = ps.get_direct_access_models(
user_db_object=user,
@ -1781,18 +1813,19 @@ def test_get_direct_access_models_all_proxy_models_key_keeps_team_scoped_user_gr
key_models=(ps.SpecialModelNames.all_proxy_models.value,),
)
assert result == ("byok-id",)
assert result == ("gpt4o-id",)
def test_get_direct_access_models_expands_access_group_grant():
"""A grant naming an access group can call the group's members at call time, so the
listing must resolve the members instead of looking up the group name as a model."""
router = MagicMock()
router.get_model_access_groups.return_value = {"beta-models": ["gpt-4o", "sonnet"]}
router.get_model_list.side_effect = lambda model_name: {
"gpt-4o": [{"model_info": {"id": "gpt4o-id"}}],
"sonnet": [{"model_info": {"id": "sonnet-id"}}],
}.get(model_name, [])
router = Router(
model_list=[
_deployment_row("gpt-4o", "gpt4o-id", access_groups=("beta-models",)),
_deployment_row("sonnet", "sonnet-id", access_groups=("beta-models",)),
_deployment_row("haiku", "haiku-id"),
]
)
user = LiteLLM_UserTable(user_id="u", models=["beta-models"], teams=[])
@ -1816,12 +1849,7 @@ async def test_populate_team_access_hides_models_the_calling_key_cannot_call(mon
"model_info": {"id": "sonnet-id", "db_model": False},
}
router = MagicMock()
router.get_model_ids.return_value = ["gpt4o-id", "sonnet-id"]
router.get_model_access_groups.return_value = {}
router.get_model_list.side_effect = lambda model_name: (
[{"model_info": {"id": "gpt4o-id"}}] if model_name == "gpt-4o" else []
)
router = Router(model_list=[_deployment_row("gpt-4o", "gpt4o-id"), _deployment_row("sonnet", "sonnet-id")])
user_row = LiteLLM_UserTable(
user_id="u",

View file

@ -11,7 +11,7 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
from litellm import Router
from litellm.proxy.proxy_server import _filter_models_by_team_id
@ -59,7 +59,7 @@ async def test_filter_resolves_access_group_names():
# Router mock
mock_router = MagicMock()
# get_model_access_groups returns {group_name: [model_names]}
mock_router.get_model_access_groups.return_value = {
mock_router.get_model_access_groups_usable_by_team.return_value = {
"Group-A": ["gpt-4o", "gpt-5"],
"Group-B": ["claude-3"],
}
@ -114,7 +114,7 @@ async def test_filter_resolves_mix_of_access_groups_and_literal_names():
all_models = [gpt4o, gpt5, claude, mistral]
mock_router = MagicMock()
mock_router.get_model_access_groups.return_value = {
mock_router.get_model_access_groups_usable_by_team.return_value = {
"Group-A": ["gpt-4o", "gpt-5"],
"Group-B": ["claude-3"],
}
@ -159,7 +159,7 @@ async def test_filter_excludes_models_from_other_access_group():
all_models = [gpt4o, claude, llama]
mock_router = MagicMock()
mock_router.get_model_access_groups.return_value = {
mock_router.get_model_access_groups_usable_by_team.return_value = {
"Group-A": ["gpt-4o"],
"Group-B": ["claude-3", "llama-4"],
}
@ -198,7 +198,7 @@ async def test_filter_db_fallback_receives_resolved_model_names():
all_models = [gpt4o]
mock_router = MagicMock()
mock_router.get_model_access_groups.return_value = {
mock_router.get_model_access_groups_usable_by_team.return_value = {
"Group-A": ["gpt-4o", "gpt-5"],
}
# get_model_list returns nothing — forces reliance on the DB fallback
@ -231,3 +231,49 @@ async def test_filter_db_fallback_receives_resolved_model_names():
"gpt-5",
}, f"DB query should receive resolved model names, got {queried_names}"
assert "Group-A" not in queried_names, "Raw access group name should not be in DB query"
@pytest.mark.asyncio
async def test_filter_by_team_id_keeps_other_teams_deployments_out_of_a_shared_access_group():
router = Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0", "api_base": "https://team-b.example"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
]
)
db_rows = {
"bedrock-nova": MagicMock(model_id="global-nova", model_name="bedrock-nova"),
"model_name_team-b_1111": MagicMock(model_id="team-b-nova", model_name="model_name_team-b_1111"),
}
async def find_many(where):
return [row for name, row in db_rows.items() if name in where["model_name"]["in"]]
mock_prisma = MagicMock()
mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=_make_team(models=["bedrock-group"], team_id="team-a"))
mock_prisma.db.litellm_proxymodeltable.find_many = AsyncMock(side_effect=find_many)
all_models = [{**row, "model_info": {**row["model_info"], "access_via_team_ids": []}} for row in router.model_list]
result = await _filter_models_by_team_id(
all_models=all_models,
team_id="team-a",
prisma_client=mock_prisma,
llm_router=router,
)
assert [m["model_info"]["id"] for m in result] == ["global-nova"]
queried_names = mock_prisma.db.litellm_proxymodeltable.find_many.call_args[1]["where"]["model_name"]["in"]
assert set(queried_names) == {"bedrock-nova"}

View file

@ -5915,6 +5915,7 @@ async def test_model_info_v1_oci_secrets_not_leaked():
mock_router.model_list = [mock_model_data]
mock_router.get_model_names.return_value = ["oci-grok-test"]
mock_router.get_model_access_groups.return_value = {}
mock_router.get_model_access_groups_usable_by_team.return_value = {}
# Mock global variables
with (

View file

@ -4,8 +4,8 @@ import pytest
from fastapi import HTTPException
import litellm
from litellm import ModelResponse
from litellm.proxy._types import UserAPIKeyAuth
from litellm import ModelResponse, Router
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.utils import (
create_model_info_response,
get_available_models_for_user,
@ -287,6 +287,112 @@ def test_model_dump_with_preserved_fields_error_path_invalid_obj_raises():
model_dump_with_preserved_fields(None)
def _router_with_global_and_team_b_deployments() -> Router:
return Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
{
"model_name": "model_name_team-b_2222",
"litellm_params": {"model": "bedrock/us.amazon.nova-lite-v1:0"},
"model_info": {
"id": "team-b-lite",
"team_id": "team-b",
"team_public_model_name": "team-b-lite",
"access_groups": ["team-b-only"],
},
},
]
)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("user_api_key_dict", "expected"),
[
(
UserAPIKeyAuth(api_key="sk-teamless", models=["bedrock-group"], team_id=None, team_models=[]),
["bedrock-nova"],
),
(
UserAPIKeyAuth(api_key="sk-team-b", models=["bedrock-group"], team_id="team-b", team_models=[]),
["bedrock-nova", "model_name_team-b_1111"],
),
(
UserAPIKeyAuth(api_key="sk-team-a", models=["bedrock-group"], team_id="team-a", team_models=[]),
["bedrock-nova"],
),
(
UserAPIKeyAuth(
api_key="sk-admin",
models=["bedrock-group"],
team_id=None,
team_models=[],
user_role=LitellmUserRoles.PROXY_ADMIN,
),
["bedrock-nova", "model_name_team-b_1111"],
),
],
ids=["teamless-key", "owning-team-key", "other-team-key", "proxy-admin-key"],
)
async def test_get_available_models_for_user_access_group_expands_only_to_usable_deployments(
user_api_key_dict, expected
):
result = await get_available_models_for_user(
user_api_key_dict=user_api_key_dict,
llm_router=_router_with_global_and_team_b_deployments(),
general_settings={},
user_model=None,
)
assert sorted(result) == expected
@pytest.mark.asyncio
async def test_get_available_models_for_user_admin_listing_for_a_team_scopes_groups_to_that_team(monkeypatch):
from litellm.models.team import LiteLLM_TeamTableCachedObj
async def _get_team_object(**_kwargs):
return LiteLLM_TeamTableCachedObj(team_id="team-a", models=["bedrock-group"])
monkeypatch.setattr("litellm.proxy.auth.auth_checks.get_team_object", _get_team_object)
result = await get_available_models_for_user(
user_api_key_dict=UserAPIKeyAuth(api_key="sk-admin", user_role=LitellmUserRoles.PROXY_ADMIN, team_models=[]),
llm_router=_router_with_global_and_team_b_deployments(),
general_settings={},
user_model=None,
team_id="team-a",
prisma_client=MagicMock(),
proxy_logging_obj=MagicMock(),
user_api_key_cache=MagicMock(),
)
assert sorted(result) == ["bedrock-nova"]
@pytest.mark.asyncio
async def test_get_available_models_for_user_group_owned_by_another_team_lists_no_deployments():
result = await get_available_models_for_user(
user_api_key_dict=UserAPIKeyAuth(api_key="sk-teamless", models=["team-b-only"], team_id=None, team_models=[]),
llm_router=_router_with_global_and_team_b_deployments(),
general_settings={},
user_model=None,
)
assert not {"bedrock-nova", "model_name_team-b_1111", "model_name_team-b_2222"} & set(result)
@pytest.mark.asyncio
async def test_get_available_models_for_user_happy_path_returns_complete_list(
monkeypatch,

View file

@ -348,6 +348,7 @@ async def test_vector_store_file_list_resolves_single_openai_team_deployment():
request.headers = {}
llm_router = MagicMock()
llm_router.model_owned_by_other_teams.return_value = False
llm_router.get_deployment_credentials_with_provider.return_value = {
"api_key": "sk-team-openai",
"api_base": "https://api.openai.com/v1",
@ -381,6 +382,7 @@ async def test_vector_store_file_list_wildcard_model_hint_falls_back_to_team_dep
request.headers = {}
llm_router = MagicMock()
llm_router.model_owned_by_other_teams.return_value = False
llm_router.model_group_alias = {}
llm_router.get_deployment_credentials_with_provider.side_effect = [
None,
@ -444,6 +446,7 @@ async def test_vector_store_file_list_uses_single_team_model_for_router_routing(
request.headers = {}
llm_router = MagicMock()
llm_router.model_owned_by_other_teams.return_value = False
llm_router.get_model_access_groups.return_value = {}
llm_router.get_deployment_credentials_with_provider.return_value = None
@ -504,6 +507,7 @@ async def test_vector_store_file_list_does_not_guess_ambiguous_team_deployment()
request.headers = {}
llm_router = MagicMock()
llm_router.model_owned_by_other_teams.return_value = False
llm_router.get_deployment_credentials_with_provider.side_effect = [
{
"api_key": "sk-team-openai-1",
@ -563,6 +567,7 @@ async def test_vector_store_file_list_requires_explicit_openai_provider_for_team
request.headers = {}
llm_router = MagicMock()
llm_router.model_owned_by_other_teams.return_value = False
llm_router.get_deployment_credentials_with_provider.return_value = {
"api_key": "sk-unknown-provider",
"api_base": "https://example.com/v1",

View file

@ -9955,6 +9955,78 @@ def test_deployment_usable_by_team_uses_dynamic_model_info_get():
assert litellm.Router.deployment_usable_by_team({"model_info": ModelInfo()}, "team-a") is False
def _make_router_with_global_and_team_b_deployments() -> litellm.Router:
return litellm.Router(
model_list=[
{
"model_name": "bedrock-nova",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {"id": "global-nova", "access_groups": ["bedrock-group"]},
},
{
"model_name": "model_name_team-b_1111",
"litellm_params": {"model": "bedrock/us.amazon.nova-micro-v1:0"},
"model_info": {
"id": "team-b-nova",
"team_id": "team-b",
"team_public_model_name": "team-b-nova",
"access_groups": ["bedrock-group"],
},
},
{
"model_name": "model_name_team-b_2222",
"litellm_params": {"model": "bedrock/us.amazon.nova-lite-v1:0"},
"model_info": {
"id": "team-b-lite",
"team_id": "team-b",
"team_public_model_name": "team-b-lite",
"access_groups": ["team-b-only"],
},
},
],
)
def test_get_model_access_groups_usable_by_team_drops_other_teams_deployments():
router = _make_router_with_global_and_team_b_deployments()
assert router.get_model_access_groups_usable_by_team(None) == {"bedrock-group": ("bedrock-nova",)}
assert router.get_model_access_groups_usable_by_team("team-a") == {"bedrock-group": ("bedrock-nova",)}
assert router.get_model_access_groups_usable_by_team("team-b") == {
"bedrock-group": ("bedrock-nova", "model_name_team-b_1111"),
"team-b-only": ("model_name_team-b_2222",),
}
def test_get_deployments_usable_by_team_drops_other_teams_deployments():
router = _make_router_with_global_and_team_b_deployments()
def ids(model_name: str, team_id: str | None) -> list[str]:
return [d["model_info"]["id"] for d in router.get_deployments_usable_by_team(model_name, team_id)]
assert ids("bedrock-nova", None) == ["global-nova"]
assert ids("bedrock-nova", "team-a") == ["global-nova"]
assert ids("model_name_team-b_1111", None) == []
assert ids("model_name_team-b_1111", "team-a") == []
assert ids("model_name_team-b_1111", "team-b") == ["team-b-nova"]
assert ids("team-b-nova", "team-b") == ["team-b-nova"]
def test_model_owned_by_other_teams():
router = _make_router_with_global_and_team_b_deployments()
assert router.model_owned_by_other_teams("model_name_team-b_1111", None) is True
assert router.model_owned_by_other_teams("model_name_team-b_1111", "team-a") is True
assert router.model_owned_by_other_teams("model_name_team-b_1111", "team-b") is False
assert router.model_owned_by_other_teams("bedrock-nova", "team-a") is False
assert router.model_owned_by_other_teams("bedrock-nova", None) is False
assert router.model_owned_by_other_teams("bedrock-nova", "team-b") is False
assert router.model_owned_by_other_teams("team-b-nova", None) is False
assert router.model_owned_by_other_teams("unknown-model", None) is False
def test_get_deployment_credentials_with_provider_skips_other_team_wildcard():
"""
Global wildcard resolution must skip a team-scoped wildcard deployment for