diff --git a/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py b/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py index 0bdc5f1910a..394a6a93178 100644 --- a/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py +++ b/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py @@ -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 diff --git a/tests/unit/proxy/hooks/test_batch_file_validation.py b/tests/unit/proxy/hooks/test_batch_file_validation.py index 8eeee2e6468..f35dfc301c0 100644 --- a/tests/unit/proxy/hooks/test_batch_file_validation.py +++ b/tests/unit/proxy/hooks/test_batch_file_validation.py @@ -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"}, diff --git a/tests/unit/proxy/proxy_server/test_routes_model_info.py b/tests/unit/proxy/proxy_server/test_routes_model_info.py index 9993361d930..e62a3cc7595 100644 --- a/tests/unit/proxy/proxy_server/test_routes_model_info.py +++ b/tests/unit/proxy/proxy_server/test_routes_model_info.py @@ -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) # --------------------------------------------------------------------------- diff --git a/tests/unit/proxy/proxy_server/test_team_model_name_translation.py b/tests/unit/proxy/proxy_server/test_team_model_name_translation.py index 679959b5728..59797d853d9 100644 --- a/tests/unit/proxy/proxy_server/test_team_model_name_translation.py +++ b/tests/unit/proxy/proxy_server/test_team_model_name_translation.py @@ -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", diff --git a/tests/unit/proxy/test_filter_models_by_team_access_group.py b/tests/unit/proxy/test_filter_models_by_team_access_group.py index 1a514ed2c57..73e919f0a4d 100644 --- a/tests/unit/proxy/test_filter_models_by_team_access_group.py +++ b/tests/unit/proxy/test_filter_models_by_team_access_group.py @@ -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"} diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 0c83d6c6c37..0ce586c7d98 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -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 ( diff --git a/tests/unit/proxy/utils/helpers/test_model_access.py b/tests/unit/proxy/utils/helpers/test_model_access.py index ecf1810f34a..8d38bd224cd 100644 --- a/tests/unit/proxy/utils/helpers/test_model_access.py +++ b/tests/unit/proxy/utils/helpers/test_model_access.py @@ -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, diff --git a/tests/unit/proxy/vector_store_endpoints/test_vector_store_endpoints.py b/tests/unit/proxy/vector_store_endpoints/test_vector_store_endpoints.py index e128b5eb1f1..82a5d340852 100644 --- a/tests/unit/proxy/vector_store_endpoints/test_vector_store_endpoints.py +++ b/tests/unit/proxy/vector_store_endpoints/test_vector_store_endpoints.py @@ -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", diff --git a/tests/unit/test_router/test_router.py b/tests/unit/test_router/test_router.py index 62510dac26d..15338d7d280 100644 --- a/tests/unit/test_router/test_router.py +++ b/tests/unit/test_router/test_router.py @@ -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