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]
Python ai-gatewayanthropicazure-openaibedrockgatewaylangchainlitellmllmllm-gatewayllmopsmcp-gatewayopenaiopenai-proxyrustrust-aivertex-ai
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