From f38dc51d2bc21c7a06dfbad9f53254af4967eb82 Mon Sep 17 00:00:00 2001 From: Sahil Date: Sun, 20 Sep 2026 23:39:59 +0530 Subject: [PATCH 1/2] fix(proxy): apply team member allowed_models to model discovery GET /v1/models, /models and /model_group/info returned the whole team model list to a virtual key whose user has a per-member allowed_models scope on that team, while inference correctly rejected every model outside that scope with 403. OpenAI-compatible clients fill their model picker from /v1/models, so they offered models the key could never call get_available_models_for_user now reads the member scope through the same helper request-time authorization uses and keeps only the models that check passes, so access groups, wildcards and sentinels resolve the same way in both paths. Keys with no user, members with no scope, and teams without a membership row are unchanged Closes #41595 --- litellm/proxy/auth/auth_checks.py | 37 ++++ litellm/proxy/utils.py | 60 +++++- .../proxy/utils/helpers/test_model_access.py | 182 +++++++++++++++++- 3 files changed, 265 insertions(+), 14 deletions(-) diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 2ae285d6eef..6ec3e5070ae 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -4394,6 +4394,43 @@ async def _team_member_granted_models( return () if team_membership is None else _member_allowed_models(team_membership) +async def team_member_allowed_models( + valid_token: UserAPIKeyAuth, + team_object: LiteLLM_TeamTable | None, + prisma_client: PrismaClient, + user_api_key_cache: UserApiKeyCache, + proxy_logging_obj: ProxyLogging, +) -> Sequence[str]: + """The member's own ``allowed_models`` scope for callers outside this module; empty when not narrowed.""" + return await _team_member_granted_models( + valid_token=valid_token, + team_object=team_object, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + proxy_logging_obj=proxy_logging_obj, + ) + + +def team_member_can_call_model( + model: str, + llm_router: Router | None, + member_allowed_models: Sequence[str], + team_id: str | None, +) -> bool: + """Non-raising form of the per-member model check that request-time authorization enforces.""" + try: + _can_object_call_model( + model=model, + llm_router=llm_router, + models=list(member_allowed_models), # mutable-ok: _can_object_call_model takes list[str] + object_type="team", + team_id=team_id, + ) + except ProxyException: + return False + return True + + async def _org_granted_models( valid_token: UserAPIKeyAuth, team_object: LiteLLM_TeamTable | None, diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py index 9de2b5fd282..ebd07e31b54 100644 --- a/litellm/proxy/utils.py +++ b/litellm/proxy/utils.py @@ -8185,6 +8185,26 @@ async def _get_access_group_models( return tuple(dict.fromkeys((*team_group_models, *key_group_models))) +async def _get_team_member_allowed_models( + user_api_key_dict: "UserAPIKeyAuth", + team_object: Optional["LiteLLM_TeamTableCachedObj"], + prisma_client: Optional["PrismaClient"], + user_api_key_cache: Optional["UserApiKeyCache"], + proxy_logging_obj: Optional["ProxyLogging"], +) -> Sequence[str]: + from litellm.proxy.auth.auth_checks import team_member_allowed_models + + if team_object is None or prisma_client is None or user_api_key_cache is None or proxy_logging_obj is None: + return () + return await team_member_allowed_models( + valid_token=user_api_key_dict, + team_object=team_object, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + proxy_logging_obj=proxy_logging_obj, + ) + + async def get_available_models_for_user( user_api_key_dict: "UserAPIKeyAuth", llm_router: Optional["Router"], @@ -8216,6 +8236,7 @@ async def get_available_models_for_user( Returns: List of model names available to the user """ + from litellm.proxy.auth.auth_checks import team_member_can_call_model from litellm.proxy.auth.model_checks import ( get_complete_model_list, get_key_models, @@ -8264,16 +8285,24 @@ async def get_available_models_for_user( effective_team_id: Final = team_id or user_api_key_dict.team_id - access_group_models: Final = ( - await _get_access_group_models( - user_api_key_dict=user_api_key_dict, - team_object=requested_team_object + team_object: Final = ( + ( + requested_team_object or await _get_team_object_for_access_groups( team_id=effective_team_id, prisma_client=prisma_client, user_api_key_cache=user_api_key_cache, proxy_logging_obj=proxy_logging_obj, - ), + ) + ) + if key_models or team_models + else None + ) + + access_group_models: Final = ( + await _get_access_group_models( + user_api_key_dict=user_api_key_dict, + team_object=team_object, prisma_client=prisma_client, user_api_key_cache=user_api_key_cache, proxy_logging_obj=proxy_logging_obj, @@ -8282,6 +8311,14 @@ async def get_available_models_for_user( else () ) + member_allowed_models: Final = await _get_team_member_allowed_models( + user_api_key_dict=user_api_key_dict, + team_object=team_object, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + proxy_logging_obj=proxy_logging_obj, + ) + granted_key_models: Final = (*key_models, *access_group_models) if key_models else key_models granted_team_models: Final = (*team_models, *access_group_models) if team_models else team_models @@ -8300,7 +8337,18 @@ async def get_available_models_for_user( team_id=effective_team_id, ) - return all_models + if not member_allowed_models: + return all_models + return [ # mutable-ok: callers consume the public list[str] return contract + model + for model in all_models + if team_member_can_call_model( + model=model, + llm_router=llm_router, + member_allowed_models=member_allowed_models, + team_id=effective_team_id, + ) + ] def _safe_get_model_info(model: str, get_model_info: Callable[[str], ModelInfo]) -> ModelInfo | None: diff --git a/tests/test_litellm/proxy/utils/helpers/test_model_access.py b/tests/test_litellm/proxy/utils/helpers/test_model_access.py index 5fb4392eec6..94def3cc5d6 100644 --- a/tests/test_litellm/proxy/utils/helpers/test_model_access.py +++ b/tests/test_litellm/proxy/utils/helpers/test_model_access.py @@ -28,6 +28,14 @@ def _router_with_models(model_names): return router +@pytest.fixture +def no_team_member_scope(monkeypatch): + async def _no_membership(**_kwargs): + return None + + monkeypatch.setattr("litellm.proxy.auth.auth_checks.get_team_membership", _no_membership) + + def test_is_known_model_happy_path_returns_true_when_in_router(): router = _router_with_models(["gpt-4o", "claude-haiku"]) summary = { @@ -110,8 +118,7 @@ def test_create_model_info_response_happy_path_no_metadata(): "owned_by": result["owned_by"], "created_is_int": isinstance(result["created"], int), "metadata_absent": "metadata" not in result, - "max_input_tokens_positive_int": isinstance(result["max_input_tokens"], int) - and result["max_input_tokens"] > 0, + "max_input_tokens_positive_int": isinstance(result["max_input_tokens"], int) and result["max_input_tokens"] > 0, "max_output_tokens_positive_int": isinstance(result["max_output_tokens"], int) and result["max_output_tokens"] > 0, } @@ -205,9 +212,7 @@ def test_validate_model_access_happy_path_single_model_in_list(): def test_validate_model_access_happy_path_batch_all_accessible(): summary = { - "result": validate_model_access( - "gpt-4o,claude-haiku", ["gpt-4o", "claude-haiku", "gemini"] - ), + "result": validate_model_access("gpt-4o,claude-haiku", ["gpt-4o", "claude-haiku", "gemini"]), "input": "gpt-4o,claude-haiku", "available": ["gpt-4o", "claude-haiku", "gemini"], } @@ -389,9 +394,7 @@ async def test_get_available_models_for_user_error_path_complete_list_raises( def _boom(**_kwargs): raise RuntimeError("downstream failure") - monkeypatch.setattr( - "litellm.proxy.auth.model_checks.get_complete_model_list", _boom - ) + monkeypatch.setattr("litellm.proxy.auth.model_checks.get_complete_model_list", _boom) user_api_key_dict = UserAPIKeyAuth( api_key="sk-test-key", user_id="user-1", @@ -408,6 +411,7 @@ async def test_get_available_models_for_user_error_path_complete_list_raises( @pytest.mark.asyncio +@pytest.mark.usefixtures("no_team_member_scope") async def test_get_available_models_for_user_resolves_team_access_group_models( monkeypatch, ): @@ -454,6 +458,7 @@ async def test_get_available_models_for_user_resolves_team_access_group_models( @pytest.mark.asyncio +@pytest.mark.usefixtures("no_team_member_scope") async def test_get_available_models_for_user_without_access_groups_grants_nothing( monkeypatch, ): @@ -481,7 +486,9 @@ async def test_get_available_models_for_user_without_access_groups_grants_nothin ) assert result == [] + @pytest.mark.asyncio +@pytest.mark.usefixtures("no_team_member_scope") async def test_get_available_models_for_user_resolves_key_access_group_models( monkeypatch, ): @@ -521,3 +528,162 @@ async def test_get_available_models_for_user_resolves_key_access_group_models( user_api_key_cache=MagicMock(), ) assert result == ["model-b"] + + +def _team_member_world(monkeypatch, *, allowed_models, access_groups=None): + from litellm.models.budget import LiteLLM_BudgetTable + from litellm.models.team import LiteLLM_TeamTableCachedObj + from litellm.models.team_membership import LiteLLM_TeamMembership + + team = LiteLLM_TeamTableCachedObj(team_id="team-1", models=["all-proxy-models"]) + membership = LiteLLM_TeamMembership( + user_id="member-1", + team_id="team-1", + litellm_budget_table=LiteLLM_BudgetTable(budget_id="b-1", allowed_models=allowed_models), + ) + + async def _get_team_object(**_kwargs): + return team + + async def _get_team_membership(**_kwargs): + return membership + + monkeypatch.setattr("litellm.proxy.auth.auth_checks.get_team_object", _get_team_object) + monkeypatch.setattr("litellm.proxy.auth.auth_checks.get_team_membership", _get_team_membership) + + groups = access_groups or {} + router = _router_with_models(["model-a", "model-b", "model-c"]) + router.get_model_access_groups.side_effect = lambda model_name=None, team_id=None: ( + {g: ms for g, ms in groups.items() if model_name in ms} if model_name and team_id == "team-1" else groups + ) + router.model_group_alias = {} + return router + + +def _team_with_access_group_ids(access_group_ids, models=("all-proxy-models",)): + from litellm.models.team import LiteLLM_TeamTableCachedObj + + team = LiteLLM_TeamTableCachedObj(team_id="team-1", models=list(models), access_group_ids=access_group_ids) + + async def _get_team_object(**_kwargs): + return team + + return _get_team_object + + +def _member_key(user_id): + return UserAPIKeyAuth( + api_key="sk-member", + user_id=user_id, + team_id="team-1", + models=[], + team_models=["all-proxy-models"], + ) + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_narrows_team_models_to_member_allowed_models(monkeypatch): + router = _team_member_world(monkeypatch, allowed_models=["model-b"]) + + result = await get_available_models_for_user( + user_api_key_dict=_member_key("member-1"), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + ) + + assert result == ["model-b"] + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_member_allowed_models_expands_access_groups(monkeypatch): + router = _team_member_world( + monkeypatch, + allowed_models=["standard"], + access_groups={"standard": ["model-a", "model-c"], "power": ["model-b"]}, + ) + + result = await get_available_models_for_user( + user_api_key_dict=_member_key("member-1"), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + include_model_access_groups=True, + ) + + assert sorted(result) == ["model-a", "model-c", "standard"] + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_member_without_allowed_models_keeps_team_models(monkeypatch): + router = _team_member_world(monkeypatch, allowed_models=[]) + + result = await get_available_models_for_user( + user_api_key_dict=_member_key("member-1"), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + ) + + assert sorted(result) == ["all-proxy-models", "model-a", "model-b", "model-c"] + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_team_key_without_user_ignores_member_scope(monkeypatch): + router = _team_member_world(monkeypatch, allowed_models=["model-b"]) + + result = await get_available_models_for_user( + user_api_key_dict=_member_key(None), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + ) + + assert sorted(result) == ["all-proxy-models", "model-a", "model-b", "model-c"] + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_member_scope_applies_to_team_access_group_grants(monkeypatch): + from litellm.models.access_group import LiteLLM_AccessGroupTable + + router = _team_member_world(monkeypatch, allowed_models=["model-c"]) + monkeypatch.setattr( + "litellm.proxy.auth.auth_checks.get_team_object", + _team_with_access_group_ids(["ag-1"], models=["model-a"]), + ) + + async def _get_access_object(**_kwargs): + return LiteLLM_AccessGroupTable( + access_group_id="ag-1", + access_group_name="extra", + access_model_names=["model-c"], + assigned_team_ids=["team-1"], + ) + + monkeypatch.setattr("litellm.proxy.auth.auth_checks.get_access_object", _get_access_object) + + result = await get_available_models_for_user( + user_api_key_dict=UserAPIKeyAuth( + api_key="sk-member", user_id="member-1", team_id="team-1", models=[], team_models=["model-a"] + ), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + ) + + assert result == ["model-c"] From 53f4f85310dac027e202b4f01438f6a58258448c Mon Sep 17 00:00:00 2001 From: Sahil Date: Mon, 21 Sep 2026 19:05:54 +0530 Subject: [PATCH 2/2] fix(proxy): apply member scope when the team has no model list A team with models=[] grants every proxy model, and the team object was only loaded when the key or team carried a model list, so members of such teams were listed every model while inference still rejected the ones outside their allowed_models. Load the team whenever the key has one so the member scope is read in that configuration too --- litellm/proxy/utils.py | 17 ++++---------- .../proxy/utils/helpers/test_model_access.py | 23 +++++++++++++++++-- 2 files changed, 26 insertions(+), 14 deletions(-) diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py index ebd07e31b54..1d3bc7df155 100644 --- a/litellm/proxy/utils.py +++ b/litellm/proxy/utils.py @@ -8285,18 +8285,11 @@ async def get_available_models_for_user( effective_team_id: Final = team_id or user_api_key_dict.team_id - team_object: Final = ( - ( - requested_team_object - or await _get_team_object_for_access_groups( - team_id=effective_team_id, - prisma_client=prisma_client, - user_api_key_cache=user_api_key_cache, - proxy_logging_obj=proxy_logging_obj, - ) - ) - if key_models or team_models - else None + team_object: Final = requested_team_object or await _get_team_object_for_access_groups( + team_id=effective_team_id, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + proxy_logging_obj=proxy_logging_obj, ) access_group_models: Final = ( diff --git a/tests/test_litellm/proxy/utils/helpers/test_model_access.py b/tests/test_litellm/proxy/utils/helpers/test_model_access.py index 94def3cc5d6..bdf46ff7f06 100644 --- a/tests/test_litellm/proxy/utils/helpers/test_model_access.py +++ b/tests/test_litellm/proxy/utils/helpers/test_model_access.py @@ -530,12 +530,12 @@ async def test_get_available_models_for_user_resolves_key_access_group_models( assert result == ["model-b"] -def _team_member_world(monkeypatch, *, allowed_models, access_groups=None): +def _team_member_world(monkeypatch, *, allowed_models, access_groups=None, team_models=("all-proxy-models",)): from litellm.models.budget import LiteLLM_BudgetTable from litellm.models.team import LiteLLM_TeamTableCachedObj from litellm.models.team_membership import LiteLLM_TeamMembership - team = LiteLLM_TeamTableCachedObj(team_id="team-1", models=["all-proxy-models"]) + team = LiteLLM_TeamTableCachedObj(team_id="team-1", models=list(team_models)) membership = LiteLLM_TeamMembership( user_id="member-1", team_id="team-1", @@ -687,3 +687,22 @@ async def test_get_available_models_for_user_member_scope_applies_to_team_access ) assert result == ["model-c"] + + +@pytest.mark.asyncio +async def test_get_available_models_for_user_member_scope_applies_when_team_has_no_model_list(monkeypatch): + router = _team_member_world(monkeypatch, allowed_models=["model-b"], team_models=()) + + result = await get_available_models_for_user( + user_api_key_dict=UserAPIKeyAuth( + api_key="sk-member", user_id="member-1", team_id="team-1", models=[], team_models=[] + ), + llm_router=router, + general_settings={}, + user_model=None, + prisma_client=MagicMock(), + proxy_logging_obj=MagicMock(), + user_api_key_cache=MagicMock(), + ) + + assert result == ["model-b"]