This commit is contained in:
sahil00yada 2026-09-21 13:36:01 +00:00 • committed by GitHub
commit 7bd7e12d73
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 279 additions and 16 deletions

View file

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

View file

@ -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,17 @@ 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,
)
access_group_models: Final = (
await _get_access_group_models(
user_api_key_dict=user_api_key_dict,
team_object=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,
),
team_object=team_object,
prisma_client=prisma_client,
user_api_key_cache=user_api_key_cache,
proxy_logging_obj=proxy_logging_obj,
@ -8282,6 +8304,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 +8330,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:

View file

@ -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,181 @@ 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, 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=list(team_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"]
@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"]