Skip to content

The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]

27.6 KB
Raw Blame
from collections.abc import Mapping
from typing import Final
from unittest.mock import AsyncMock, MagicMock

import pytest
from fastapi import HTTPException

from litellm.proxy._types import LiteLLMRoutes, UserAPIKeyAuth
from litellm.proxy.agent_endpoints.auth.managed_authorization import (
    actor_admission_failure,
    admit_managed_actor,
    invocation_target,
)
from litellm.proxy.agent_endpoints.identity_store import AgentIdentityStore
from litellm.types.agents import AgentResponse
from litellm.types.proxy.agent_identity import AgentIdentityBinding, AgentIdentityFailure, ManagedAgentContext

BINDING: Final = AgentIdentityBinding(
    agent_id="agent",
    provider="microsoft_entra",
    tenant_id="tenant",
    client_id="client",
    service_principal_id="principal",
    issuer="issuer",
    revision="current",
)


def agent(**overrides: object) -> AgentResponse:
    return AgentResponse.model_validate(
        {
            "agent_id": "agent",
            "agent_name": "Agent",
            "agent_card_params": {},
            "identity": BINDING,
            "identity_managed": True,
            "execution_mode": "both",
            **overrides,
        }
    )


@pytest.mark.parametrize(
    "state",
    [
        {"enabled": False},
        {"identity": None},
        {"identity": BINDING.model_copy(update={"active": False})},
        {"execution_mode": "delegated"},
    ],
)
def test_keys_cannot_bypass_lifecycle_or_delegated_only_mode(state: dict[str, object]) -> None:
    assert isinstance(actor_admission_failure(agent(**state), None), AgentIdentityFailure)


@pytest.mark.parametrize("mode", ["autonomous", "both", "delegated"])
def test_keys_cannot_impersonate_an_entra_bound_agent(mode: str) -> None:
    assert isinstance(actor_admission_failure(agent(execution_mode=mode), None), AgentIdentityFailure)


@pytest.mark.parametrize(
    "context",
    [
        ManagedAgentContext(agent_id="agent", binding_revision="previous", mode="autonomous"),
        ManagedAgentContext(agent_id="another", binding_revision="current", mode="autonomous"),
        ManagedAgentContext(agent_id="agent", binding_revision="current", mode="delegated"),
    ],
)
def test_stale_binding_and_unverified_delegation_cannot_pass_admission(context: ManagedAgentContext) -> None:
    assert isinstance(actor_admission_failure(agent(), context), AgentIdentityFailure)


def test_caller_cannot_construct_trusted_subject_or_policy() -> None:
    context: Final = ManagedAgentContext(
        agent_id="agent", binding_revision="current", mode="delegated", user_id="human"
    )
    auth: Final = UserAPIKeyAuth.model_validate(
        {
            "managed_agent_context": context,
            "requires_fresh_policy": True,
            "authenticated_by_custom_auth": True,
            "mcp_explicit_grants_only": True,
            "managed_agent_policy": agent(),
            "billing_agent_policy": agent(),
            "invoked_agent_id": "forged-target",
            "agent_invocation_cost": 0.0,
        }
    )
    assert auth.requires_fresh_policy is False
    assert auth.authenticated_by_custom_auth is False
    assert "authenticated_by_custom_auth" not in auth.model_dump()
    assert auth.mcp_explicit_grants_only is False
    assert "mcp_explicit_grants_only" not in auth.model_dump()
    assert auth.managed_agent_context is None
    assert auth.managed_agent_policy is None
    assert auth.billing_agent_policy is None
    assert auth.invoked_agent_id is None
    assert auth.agent_invocation_cost is None


@pytest.mark.asyncio
@pytest.mark.parametrize("autonomous", (True, False))
async def test_invocation_prepares_target_fee_for_the_correct_agent(
    monkeypatch: pytest.MonkeyPatch,
    autonomous: bool,
) -> None:
    from unittest.mock import AsyncMock, MagicMock

    from litellm.proxy import proxy_server
    from litellm.proxy._types import LiteLLM_ObjectPermissionTable
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.auth.managed_authorization import prepare_agent_invocation
    from litellm.proxy.agent_endpoints.identity_store import AgentIdentityStore

    target: Final = agent(litellm_params={"cost_per_query": 0.25})
    registry: Final = agent_registry.AgentRegistry()
    registry.register_agent(target)
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=target)
    monkeypatch.setattr(proxy_server, "prisma_client", database)
    permission: Final = LiteLLM_ObjectPermissionTable(object_permission_id="invoke-grant", agents=["agent"])
    auth: Final = UserAPIKeyAuth(
        agent_id="caller" if autonomous else None,
        user_id=None if autonomous else "human",
        object_permission=permission,
    )
    if autonomous:
        caller: Final = agent(agent_id="caller", object_permission=permission.model_dump())
        auth.managed_agent_policy = caller
        auth.billing_agent_policy = caller
    await prepare_agent_invocation(auth, "agent", AgentIdentityStore.from_client(database))
    assert auth.agent_invocation_cost == pytest.approx(0.25)
    assert auth.invoked_agent_id == "agent"
    assert auth.billing_agent_policy is not None
    assert auth.billing_agent_policy.agent_id == ("caller" if autonomous else "agent")


@pytest.mark.asyncio
async def test_deleted_agent_key_cannot_fall_back_to_unmanaged_authentication() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=None)
    database.writer_db.litellm_retiredagent.find_unique = AsyncMock(return_value={"original_agent_id": "deleted"})
    with pytest.raises(HTTPException, match="Agent no longer exists"):
        await admit_managed_actor(UserAPIKeyAuth(agent_id="deleted"), AgentIdentityStore.from_client(database))
    database.writer_db.litellm_retiredagent.find_unique.return_value = None
    auth: Final = UserAPIKeyAuth(agent_id="legacy-attribution-label")
    await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    assert auth.managed_agent_policy is None
    database.db.litellm_agentstable.find_unique.assert_not_called()


@pytest.mark.asyncio
async def test_agent_history_outage_does_not_permit_legacy_fallback() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=None)
    database.writer_db.litellm_retiredagent.find_unique = AsyncMock(side_effect=RuntimeError("unavailable"))
    with pytest.raises(HTTPException) as failure:
        await admit_managed_actor(UserAPIKeyAuth(agent_id="deleted"), AgentIdentityStore.from_client(database))
    assert failure.value.status_code == 503


@pytest.mark.parametrize(
    "route,body,expected",
    [
        ("/a2a/agent", {}, "agent"),
        ("/a2a/expensive", {"model": "a2a/cheap"}, "expensive"),
        ("/a2a/expensive/message/send", {"model": "a2a/cheap"}, "expensive"),
        ("/v1/a2a/expensive/message/send", {"model": "a2a/cheap"}, "expensive"),
        ("/v1/a2a/agent/", {}, "agent"),
        ("/v1/chat/completions", {"model": "a2a/Readable name"}, "Readable name"),
        ("/v1/chat/completions", {"model": "a2a/"}, None),
        ("/v1/chat/completions", {"model": "ordinary-model"}, None),
        ("/a2a", {}, None),
    ],
)
def test_invocation_routes_resolve_the_same_target(route: str, body: dict[str, object], expected: str | None) -> None:
    assert invocation_target(route, body) == expected


@pytest.mark.asyncio
async def test_agent_admission_database_outage_fails_closed() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(side_effect=RuntimeError("DB unavailable"))
    with pytest.raises(HTTPException) as failure:
        await admit_managed_actor(UserAPIKeyAuth(agent_id="agent"), AgentIdentityStore.from_client(database))
    assert failure.value.status_code == 503


@pytest.mark.asyncio
async def test_human_authentication_does_not_load_an_agent() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock()
    await admit_managed_actor(UserAPIKeyAuth(user_id="human"), AgentIdentityStore.from_client(database))
    database.writer_db.litellm_agentstable.find_unique.assert_not_awaited()


@pytest.mark.asyncio
async def test_disabled_agent_key_is_rejected_at_admission() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=agent(enabled=False))
    with pytest.raises(HTTPException) as failure:
        await admit_managed_actor(UserAPIKeyAuth(agent_id="agent"), AgentIdentityStore.from_client(database))
    assert failure.value.status_code == 403


@pytest.mark.asyncio
@pytest.mark.parametrize("permitted", [True, False])
async def test_verified_human_still_needs_an_explicit_agent_invocation_grant(
    monkeypatch: pytest.MonkeyPatch,
    permitted: bool,
) -> None:
    from litellm.proxy import proxy_server
    from litellm.proxy._types import LiteLLM_ObjectPermissionTable, LiteLLM_UserTable
    from litellm.proxy.auth import auth_checks

    policy: Final = agent()
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=policy)
    monkeypatch.setattr(proxy_server, "prisma_client", database)
    permission: Final = LiteLLM_ObjectPermissionTable(
        object_permission_id="human-grants",
        agents=["agent"] if permitted else [],
    )
    human: Final = LiteLLM_UserTable(user_id="human", teams=[], object_permission=permission)
    monkeypatch.setattr(auth_checks, "get_user_object", AsyncMock(return_value=human))
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    auth.managed_agent_context = ManagedAgentContext(
        agent_id="agent",
        binding_revision="current",
        mode="delegated",
        user_id="human",
    )
    if permitted:
        await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
        assert auth.managed_agent_policy == policy
        assert auth.billing_agent_policy == policy
    else:
        with pytest.raises(HTTPException) as failure:
            await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
        assert failure.value.status_code == 403


def test_execution_mode_must_match_verified_token_mode() -> None:
    context: Final = ManagedAgentContext(agent_id="agent", binding_revision="current", mode="autonomous")
    failure: Final = actor_admission_failure(agent(execution_mode="delegated"), context)
    assert isinstance(failure, AgentIdentityFailure)
    assert "execution mode" in failure.message


@pytest.mark.asyncio
@pytest.mark.parametrize("state,status", [("missing", 403), ("outage", 503), ("denied", 403), ("invalid-fee", 503)])
async def test_invocation_cannot_bypass_missing_policy_permission_or_invalid_price(
    monkeypatch: pytest.MonkeyPatch, state: str, status: int
) -> None:
    from litellm.proxy import proxy_server
    from litellm.proxy._types import LiteLLM_ObjectPermissionTable
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.auth.managed_authorization import prepare_agent_invocation

    registered: Final = agent(litellm_params={"cost_per_query": -1 if state == "invalid-fee" else 0.25})
    registry: Final = agent_registry.AgentRegistry()
    registry.register_agent(registered)
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(
        return_value=None if state == "missing" else registered,
        side_effect=RuntimeError("unavailable") if state == "outage" else None,
    )
    monkeypatch.setattr(proxy_server, "prisma_client", database)
    permission: Final = LiteLLM_ObjectPermissionTable(
        object_permission_id="grant", agents=[] if state == "denied" else ["agent"]
    )
    auth: Final = UserAPIKeyAuth(user_id="human", object_permission=permission)
    with pytest.raises(HTTPException) as failure:
        await prepare_agent_invocation(auth, "agent", AgentIdentityStore.from_client(database))
    assert failure.value.status_code == status
    assert auth.agent_invocation_cost is None


@pytest.mark.asyncio
async def test_legacy_jwt_cannot_adopt_an_agent_bound_on_another_worker() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=agent(execution_mode="autonomous"))
    auth: Final = UserAPIKeyAuth(agent_id="agent", jwt_claims={"agent": "agent", "sub": "unrelated-subject"})
    with pytest.raises(HTTPException) as denied:
        await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    assert denied.value.status_code == 403
    assert auth.managed_agent_policy is None


@pytest.mark.asyncio
@pytest.mark.parametrize("bound", [False, True])
async def test_managed_context_or_binding_requires_database(monkeypatch: pytest.MonkeyPatch, bound: bool) -> None:
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.agent_registry import AgentRegistry

    registry: Final = AgentRegistry()
    registry.register_agent(agent(identity_managed=bound, identity=BINDING if bound else None))
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    if not bound:
        auth.managed_agent_context = ManagedAgentContext(
            agent_id="agent", binding_revision="current", mode="autonomous"
        )
    with pytest.raises(HTTPException) as denied:
        await admit_managed_actor(auth, None)
    assert denied.value.status_code == 503


@pytest.mark.asyncio
@pytest.mark.parametrize("managed_flag", [False, True])
async def test_managed_invocation_requires_database(monkeypatch: pytest.MonkeyPatch, managed_flag: bool) -> None:
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.agent_registry import AgentRegistry
    from litellm.proxy.agent_endpoints.auth.managed_authorization import prepare_agent_invocation

    registry: Final = AgentRegistry()
    registry.register_agent(agent(identity_managed=managed_flag))
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    with pytest.raises(HTTPException) as denied:
        await prepare_agent_invocation(UserAPIKeyAuth(user_id="human"), "agent", None)
    assert denied.value.status_code == 503


@pytest.mark.asyncio
async def test_autonomous_app_rejects_persisted_virtual_key_impersonation() -> None:
    policy: Final = agent(execution_mode="autonomous")
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=policy)
    auth: Final = UserAPIKeyAuth(agent_id="agent", api_key="persisted-key")
    with pytest.raises(HTTPException, match="bound identity provider token") as denied:
        await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    assert denied.value.status_code == 403
    assert auth.managed_agent_policy is None
    assert auth.billing_agent_policy is None


@pytest.mark.asyncio
async def test_unknown_invocation_target_leaves_billing_unset(monkeypatch: pytest.MonkeyPatch) -> None:
    from litellm.proxy import proxy_server
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.auth.managed_authorization import prepare_agent_invocation

    monkeypatch.setattr(agent_registry, "global_agent_registry", agent_registry.AgentRegistry())
    monkeypatch.setattr(proxy_server, "prisma_client", None)
    auth: Final = UserAPIKeyAuth(user_id="human")
    await prepare_agent_invocation(auth, "missing", None)
    assert auth.invoked_agent_id is None
    assert auth.billing_agent_policy is None


@pytest.mark.parametrize(
    "route,method,allowed",
    [
        ("/v1/agents", "GET", True),
        ("/v1/agents", "POST", False),
        ("/v1/chat/completions", "POST", True),
        ("/v1/chat/completions", "DELETE", False),
        ("/openai/deployments/model/chat/completions", "POST", True),
        ("/engines/openai/model/chat/completions", "POST", True),
        ("/openai/deployments/openai/model/images/generations", "POST", True),
        ("/openai/deployments/openai/model/images/edits", "POST", True),
        ("/v1beta/models/gemini-model:generateContent", "POST", True),
        ("/v1/realtime", "GET", True),
        ("/v1/realtime", "POST", False),
        ("/v1/realtime/client_secrets", "POST", False),
        ("/mcp/tools/call", "POST", True),
        ("/a2a/target/message/send", "POST", True),
        ("/v1/a2a/target/message/send", "POST", True),
        ("/v1/videos", "POST", False),
        ("/v1/videos/other-video", "GET", False),
        ("/v1/search", "POST", False),
        ("/search", "POST", False),
        ("/v1/agents/target", "PATCH", False),
        ("/v1/responses/other-response", "GET", False),
        ("/v1/files", "GET", False),
        ("/v1/files", "POST", False),
        ("/openai/v1/files", "GET", False),
        ("/anthropic/v1/files", "GET", False),
    ],
)
def test_managed_route_scope_excludes_provider_resources(route: str, method: str, allowed: bool) -> None:
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_agent_route_allowed

    assert managed_agent_route_allowed(route, method) is allowed


@pytest.mark.parametrize(
    "route,body,settings,cli_model,path_model,expected",
    [
        ("/v1/chat/completions", {"model": "body"}, {"completion_model": "default"}, "cli", "path", "default"),
        ("/v1/moderations", {"model": "body"}, {"moderation_model": "default"}, "cli", None, "cli"),
        ("/v1/audio/speech", {"model": "body"}, {"completion_model": "ignored"}, None, None, "body"),
        ("/openai/deployments/path/embeddings", {"model": "body"}, {}, None, "path", "path"),
        ("/v1/messages/count_tokens", {"model": "body"}, {"completion_model": "ignored"}, "cli", None, "body"),
        ("/mcp/tools/call", {}, {"completion_model": "ignored"}, "cli", None, None),
        ("/v1/images/generations", {"model": "image"}, {"completion_model": "text"}, None, None, "image"),
        ("/v1/images/generations", {}, {"image_generation_model": "image"}, None, None, "image"),
        ("/v1/images/edits", {}, {"image_generation_model": "image"}, None, None, "image"),
        ("/v1/rerank", {"model": "reranker"}, {"completion_model": "text"}, "cli", None, "reranker"),
        ("/v1beta/models/path:countTokens", {"model": "body"}, {"completion_model": "text"}, "cli", "path", "path"),
    ],
)
def test_managed_inference_resolves_dispatch_precedence(
    route: str,
    body: Mapping[str, object],
    settings: Mapping[str, object],
    cli_model: str | None,
    path_model: str | None,
    expected: str | None,
) -> None:
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_inference_request

    assert managed_inference_request(route, body, settings, cli_model, path_model).get("model") == expected


def test_managed_inference_without_any_model_cannot_skip_model_grants():
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_inference_request

    with pytest.raises(HTTPException, match="explicit or configured model"):
        managed_inference_request("/v1/moderations", {}, {}, None)


@pytest.mark.parametrize("route", ["/v1/chat/completions", "/v1/images/generations", "/v1/images/edits"])
def test_managed_inference_query_model_takes_precedence_over_body(route: str):
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_inference_request

    assert managed_inference_request(route, {"model": "body"}, {}, None, query_model="query")["model"] == "query"


def test_managed_inference_ignores_unsupported_query_model():
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_inference_request

    assert (
        managed_inference_request("/v1/messages", {"model": "body"}, {}, None, query_model="query")["model"] == "body"
    )


@pytest.mark.parametrize("route", ["/realtime", "/v1/realtime", "/openai/v1/realtime"])
def test_managed_realtime_requires_a_model_and_ignores_completion_defaults(route: str) -> None:
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_inference_request

    with pytest.raises(HTTPException, match="explicit or configured model"):
        managed_inference_request(route, {}, {"completion_model": "allowed-default"}, "cli")
    assert (
        managed_inference_request(route, {"model": "requested"}, {"completion_model": "allowed-default"}, "cli")[
            "model"
        ]
        == "requested"
    )


@pytest.mark.parametrize("route", ["/live/sessions", "/v1/live/sessions", "/openai/v1/live/sessions"])
def test_managed_live_upgrade_defers_the_model_to_the_session_start_frame(route: str) -> None:
    from litellm.proxy.agent_endpoints.auth.managed_authorization import (
        managed_agent_route_allowed,
        managed_inference_request,
    )

    assert managed_agent_route_allowed(route, "GET")
    assert managed_inference_request(route, {}, {"completion_model": "allowed-default"}, "cli") == {}
    assert managed_inference_request(
        route, {"model": "frame-model"}, {"completion_model": "allowed-default"}, "cli"
    ) == {"model": "frame-model"}


@pytest.mark.parametrize("mode,user", [("autonomous", None), ("delegated", "verified-human")])
def test_matching_identity_revision_and_execution_mode_pass_admission(mode: str, user: str | None) -> None:
    context: Final = ManagedAgentContext.model_validate(
        {"agent_id": "agent", "binding_revision": "current", "mode": mode, "user_id": user}
    )
    assert actor_admission_failure(agent(), context) is None


@pytest.mark.asyncio
async def test_unmanaged_agent_invocation_retains_legacy_behavior(monkeypatch: pytest.MonkeyPatch) -> None:
    from litellm.proxy import proxy_server
    from litellm.proxy.agent_endpoints import agent_registry
    from litellm.proxy.agent_endpoints.auth.managed_authorization import prepare_agent_invocation

    legacy: Final = agent(identity=None, identity_managed=False)
    registry: Final = agent_registry.AgentRegistry()
    registry.register_agent(legacy)
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    monkeypatch.setattr(proxy_server, "prisma_client", None)
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    await admit_managed_actor(auth, None)
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=legacy)
    await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    await prepare_agent_invocation(auth, "agent", AgentIdentityStore.from_client(database))
    assert auth.managed_agent_policy is None
    assert auth.billing_agent_policy is None
    assert auth.invoked_agent_id is None


@pytest.mark.asyncio
async def test_bound_autonomous_actor_is_admitted_without_a_human() -> None:
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=agent())
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    auth.managed_agent_context = ManagedAgentContext(agent_id="agent", binding_revision="current", mode="autonomous")
    await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    assert auth.managed_agent_policy == agent()
    assert auth.billing_agent_policy == agent()
    assert auth.user_id is None


@pytest.mark.asyncio
async def test_admitted_managed_actor_requires_fresh_policy_so_revocations_bind_next_request() -> None:
    """Managed MCP grants (toolsets, access groups) are read through the shared resolvers, which only
    bypass the warm cache and the replica when the subject carries requires_fresh_policy"""
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=agent())
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    auth.managed_agent_context = ManagedAgentContext(agent_id="agent", binding_revision="current", mode="autonomous")
    assert auth.requires_fresh_policy is False
    assert auth.authenticated_by_custom_auth is False
    assert "authenticated_by_custom_auth" not in auth.model_dump()
    await admit_managed_actor(auth, AgentIdentityStore.from_client(database))
    assert auth.requires_fresh_policy is True


async def test_jwt_delegation_verification_is_consumed_once_and_cannot_be_supplied_by_a_caller(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from litellm.proxy.agent_endpoints.auth import agent_permission_handler

    policy: Final = agent()
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=policy)
    store: Final = AgentIdentityStore.from_client(database)
    grants: Final = AsyncMock(return_value=frozenset())
    monkeypatch.setattr(agent_permission_handler, "verified_human_agent_grants", grants)
    auth: Final = UserAPIKeyAuth.model_validate({"agent_id": "agent", "_managed_delegation_verified": True})
    assert auth._managed_delegation_verified is False
    auth.managed_agent_context = ManagedAgentContext(
        agent_id="agent", binding_revision="current", mode="delegated", user_id="human"
    )
    auth._managed_delegation_verified = True
    assert "_managed_delegation_verified" not in auth.model_dump()
    await admit_managed_actor(auth, store)
    grants.assert_not_awaited()
    assert auth._managed_delegation_verified is False
    with pytest.raises(HTTPException) as failure:
        await admit_managed_actor(auth, store)
    assert failure.value.status_code == 403
    grants.assert_awaited_once_with("human", None)


@pytest.mark.asyncio
@pytest.mark.parametrize("database_available", (False, True))
async def test_ordinary_agent_admission_preserves_legacy_authentication(
    monkeypatch: pytest.MonkeyPatch, database_available: bool
) -> None:
    from litellm.proxy.agent_endpoints import agent_registry

    registry: Final = agent_registry.AgentRegistry()
    ordinary: Final = agent(identity_managed=False, identity=None)
    registry.register_agent(ordinary)
    monkeypatch.setattr(agent_registry, "global_agent_registry", registry)
    database: Final = MagicMock()
    database.writer_db.litellm_agentstable.find_unique = AsyncMock(return_value=ordinary)
    auth: Final = UserAPIKeyAuth(agent_id="agent")
    await admit_managed_actor(auth, AgentIdentityStore.from_client(database) if database_available else None)
    assert auth.agent_id == "agent"
    assert auth.managed_agent_policy is None
    assert auth.requires_fresh_policy is False
    assert auth.authenticated_by_custom_auth is False
    assert "authenticated_by_custom_auth" not in auth.model_dump()


@pytest.mark.parametrize(
    "route",
    tuple(dict.fromkeys(
        LiteLLMRoutes.openai_routes.value
        + LiteLLMRoutes.anthropic_routes.value
        + LiteLLMRoutes.google_routes.value
    )),
)
def test_registered_inference_routes_have_an_explicit_managed_access_decision(route: str) -> None:
    from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_agent_route_allowed

    normalized: Final = route.removeprefix("/openai").removeprefix("/v1beta").removeprefix("/v1")
    unsupported: Final = normalized.startswith((
        "/videos", "/batches", "/files", "/fine_tuning", "/assistants", "/threads", "/utils/",
        "/vector_stores", "/vector_store/", "/search", "/containers", "/skills", "/claude-code/",
        "/interactions", "/agents", "/responses/{", "/responses/input_tokens",
        "/realtime/client_secrets", "/realtime/calls", "/realtime/transcription_sessions",
    )) or normalized in ("/models", "/cursor/models", "/cursor/v1/models")
    concrete: Final = route.split("?")[0].replace("{model}", "model").replace("{model_name:path}", "model")
    assert managed_agent_route_allowed(concrete, None) is not unsupported, route