fix(proxy): scope /health to the model group an allowed name routes to

A key alias, team alias, or router model_group_alias lets auth admit a
requested name by checking its target, so /health also kept the deployment
under the requested name, one the key's requests never reach. Keep only the
served model group each admitted name dispatches to, through the same alias
layers /v1/models mirrors, and let alias_map read its own read-only output.
This commit is contained in:
mateo-berri 2026-10-28 14:57:28 -07:00
parent f2604b1371
commit 4f15b376b6
3 changed files with 124 additions and 10 deletions

View file

@ -216,7 +216,7 @@ def caller_alias_maps(
def alias_map(aliases: object) -> Mapping[str, str]:
try:
entries: Final = _ALIAS_ENTRIES.validate_python(aliases, strict=True)
entries: Final = _ALIAS_ENTRIES.validate_python(aliases)
except ValidationError:
return _NO_ALIASES
return MappingProxyType(
@ -284,6 +284,11 @@ def _dispatch(model_id: str, layers: Sequence[_AliasLayer]) -> tuple[str, bool]:
return reduce(_through_layer, layers, (model_id, False))
def dispatched_model(model_id: str, aliases: CallerAliases) -> str:
target, _ = _dispatch(model_id, _alias_layers(aliases))
return target
def _lookup_id(name: str, lookup_by_response: Mapping[str, str], lookup_ids: Container[str]) -> str | None:
if name in lookup_by_response:
return lookup_by_response[name]

View file

@ -41,12 +41,15 @@ from litellm.proxy._types import (
from litellm.proxy.auth.auth_checks import (
_resolve_key_models_for_auth_check, # pyright: ignore[reportPrivateUsage] # the auth layer's sentinel resolution, reused so /health scopes exactly like a request
can_key_call_resolved_model,
key_model_aliases_for_auth_check,
team_model_aliases_for_auth_check,
)
from litellm.proxy.auth.auth_utils import (
_BANNED_REQUEST_BODY_PARAMS, # pyright: ignore[reportPrivateUsage] # one canonical list, shared with the request-body check
)
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.common_utils import http_parsing_utils
from litellm.proxy.common_utils.model_listing_utils import CallerAliases, dispatched_model
from litellm.proxy.db.db_lookup_gate import db_lookup_stall_tracker
from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
from litellm.proxy.db.health_check_latest import (
@ -1085,24 +1088,47 @@ async def _key_may_call_model(model_name: str, user_api_key_dict: UserAPIKeyAuth
return True
async def _model_names_key_may_call(
async def _caller_aliases(user_api_key_dict: UserAPIKeyAuth) -> CallerAliases:
from litellm.proxy.proxy_server import prisma_client, proxy_config, proxy_logging_obj
router_settings: Final = await proxy_config.get_hierarchical_router_settings(
user_api_key_dict, prisma_client, proxy_logging_obj
)
return CallerAliases(
team_model_aliases_for_auth_check(user_api_key_dict),
key_model_aliases_for_auth_check(user_api_key_dict),
router_settings.get("model_group_alias") if router_settings is not None else None,
)
def _served_model_group(model_name: str, aliases: CallerAliases, llm_router: Router | None) -> str:
dispatched: Final = dispatched_model(model_name, aliases)
return llm_router.routable_model_group(dispatched) if llm_router is not None else dispatched
async def _model_groups_key_may_reach(
llm_model_list: Sequence[object], user_api_key_dict: UserAPIKeyAuth, llm_router: Router | None
) -> frozenset[str]:
requested_names: Final = frozenset[str]().union(
*(_names_caller_may_request(deployment, user_api_key_dict.team_id) for deployment in llm_model_list)
)
aliases: Final = await _caller_aliases(user_api_key_dict)
return frozenset(
[name for name in requested_names if await _key_may_call_model(name, user_api_key_dict, llm_router)]
[
_served_model_group(name, aliases, llm_router)
for name in requested_names
if await _key_may_call_model(name, user_api_key_dict, llm_router)
]
)
def _caller_may_probe_deployment(
deployment: Mapping[str, object], callable_names: frozenset[str], team_id: str | None, caller_is_admin: bool
deployment: Mapping[str, object], reachable_groups: frozenset[str], team_id: str | None, caller_is_admin: bool
) -> bool:
"""Same deployment visibility rule as routing: another team's deployment is never in scope, team-less callers included."""
if not caller_is_admin and not Router.deployment_usable_by_team(deployment, team_id):
return False
return not callable_names.isdisjoint(_names_caller_may_request(deployment, team_id))
return not reachable_groups.isdisjoint(_names_caller_may_request(deployment, team_id))
def _resolve_targeted_model_ids(
@ -1327,8 +1353,8 @@ async def health_endpoint(
detail={"error": "Model list not initialized"},
)
restrict_to_allowed_models: Final = not is_admin or not _key_models_unrestricted(user_api_key_dict)
callable_names: Final = (
await _model_names_key_may_call(
reachable_groups: Final = (
await _model_groups_key_may_reach(
_DEPLOYMENT_LIST.validate_python(llm_model_list), user_api_key_dict, llm_router
)
if restrict_to_allowed_models
@ -1338,7 +1364,7 @@ async def health_endpoint(
m
for m in copy.deepcopy(llm_model_list)
if not restrict_to_allowed_models
or _caller_may_probe_deployment(m, callable_names, user_api_key_dict.team_id, is_admin)
or _caller_may_probe_deployment(m, reachable_groups, user_api_key_dict.team_id, is_admin)
]
targeted_ids: Final = _resolve_targeted_model_ids(_llm_model_list, model, model_id, user_api_key_dict.team_id)
if restrict_to_allowed_models and targeted_ids is not None and not targeted_ids:

View file

@ -3771,7 +3771,10 @@ def test_clean_endpoint_data_never_displays_credential_fields(credential_field,
async def _live_probed_model_ids(
model_list: Sequence[Mapping[str, object]], user_api_key_dict: UserAPIKeyAuth, model: str | None = None
model_list: Sequence[Mapping[str, object]],
user_api_key_dict: UserAPIKeyAuth,
model: str | None = None,
llm_router: Router | None = None,
) -> set[str]:
from fastapi import Response
@ -3784,7 +3787,7 @@ async def _live_probed_model_ids(
return {"healthy_endpoints": [], "unhealthy_endpoints": [], "healthy_count": 0, "unhealthy_count": 0}
with (
_proxy_health_globals(model_list, _router_for(model_list)),
_proxy_health_globals(model_list, llm_router or _router_for(model_list)),
patch( # test-quality-ok: the model list handed to the probe is the assertion; no injection seam
"litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save",
side_effect=fake_perform,
@ -4342,6 +4345,86 @@ async def test_health_endpoint_refuses_a_deployment_the_team_allowlist_forbids(u
probe.assert_not_awaited()
_KEY_ALIASED_AWAY_FROM_HAIKU = UserAPIKeyAuth(
api_key="hashed-test-key", models=["gpt-5.4-mini"], aliases={"claude-haiku-5-5": "gpt-5.4-mini"}
)
_TEAM_ALIASED_AWAY_FROM_HAIKU = UserAPIKeyAuth(
api_key="hashed-test-key",
models=["claude-haiku-5-5"],
team_id="team-a",
team_model_aliases={"claude-haiku-5-5": "gpt-5.4-mini"},
)
_MINI_ONLY_KEY = UserAPIKeyAuth(api_key="hashed-test-key", models=["gpt-5.4-mini"])
_ALIAS_SHADOW_CASES = [
pytest.param(_KEY_ALIASED_AWAY_FROM_HAIKU, {}, id="key-alias"),
pytest.param(_TEAM_ALIASED_AWAY_FROM_HAIKU, {}, id="team-alias"),
pytest.param(_MINI_ONLY_KEY, {"claude-haiku-5-5": "gpt-5.4-mini"}, id="router-alias"),
]
def _router_with_aliases(model_group_alias: Mapping[str, str]) -> Router:
return Router(model_list=copy.deepcopy(_PROVIDER_PREFIXED_MODEL_LIST), model_group_alias=dict(model_group_alias))
@pytest.mark.asyncio
@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
async def test_health_endpoint_probes_the_deployment_an_alias_sends_the_key_to_not_the_one_it_shadows(
caller, model_group_alias
):
probed = await _live_probed_model_ids(
_PROVIDER_PREFIXED_MODEL_LIST, caller, llm_router=_router_with_aliases(model_group_alias)
)
assert probed == {"id-mini"}
@pytest.mark.asyncio
@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
async def test_health_endpoint_returns_the_deployment_an_alias_sends_the_key_to_on_background_cache_path(
caller, model_group_alias
):
from fastapi import Response
from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
with _proxy_health_globals(
_PROVIDER_PREFIXED_MODEL_LIST,
_router_with_aliases(model_group_alias),
use_background_health_checks=True,
health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
):
result = await health_endpoint(response=Response(), user_api_key_dict=caller, model=None, model_id=None)
assert [ep["model_id"] for ep in result["healthy_endpoints"]] == ["id-mini"]
@pytest.mark.asyncio
@pytest.mark.parametrize("use_background_health_checks", [False, True])
async def test_health_endpoint_refuses_the_deployment_a_key_alias_shadows(use_background_health_checks):
from fastapi import HTTPException, Response
from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
with (
_proxy_health_globals(
_PROVIDER_PREFIXED_MODEL_LIST,
_router_for(_PROVIDER_PREFIXED_MODEL_LIST),
use_background_health_checks=use_background_health_checks,
health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
),
patch( # test-quality-ok: the probe must never run; the endpoint has no injection seam for it
"litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save", new_callable=AsyncMock
) as probe,
pytest.raises(HTTPException) as refused,
):
await health_endpoint(
response=Response(), user_api_key_dict=_KEY_ALIASED_AWAY_FROM_HAIKU, model=None, model_id="id-haiku"
)
assert refused.value.status_code == 403
probe.assert_not_awaited()
def test_resolve_targeted_model_ids_lets_model_id_win_over_model():
resolve = _health_endpoints_module._resolve_targeted_model_ids