refactor(auth): port model and route policy to native decisions

This commit is contained in:
Devin AI 2026-11-08 22:36:29 +00:00
parent 7341581452
commit cad362a398
30 changed files with 4780 additions and 661 deletions

View file

@ -4409,6 +4409,7 @@ dependencies = [
name = "litellm-request-auth-core"
version = "0.1.0"
dependencies = [
"fancy-regex 0.19.2",
"litellm-secret-value",
"rstest",
"serde",

View file

@ -39,13 +39,32 @@ mod _native {
use crate::model_registry::bundled_model_cost_map;
#[pymodule_export]
use crate::request_auth::{
NativeAuthContinuation, request_auth_access, request_auth_admission,
request_auth_budget_alert, request_auth_budget_price, request_auth_budget_route,
request_auth_budget_window_start, request_auth_budgets, request_auth_common_budget,
request_auth_litellm_header_token, request_auth_managed, request_auth_member_limit,
request_auth_model_budget_check, request_auth_model_budget_query,
request_auth_model_budget_resolve, request_auth_scheme_credential,
request_auth_select_api_key, request_auth_select_websocket_api_key, request_auth_start,
NativeAuthContinuation,
request_auth_access,
request_auth_admission,
request_auth_budget_alert,
request_auth_budget_price,
request_auth_budget_route,
request_auth_budget_window_start,
request_auth_budgets,
request_auth_common_budget,
request_auth_fallback_access,
request_auth_litellm_header_token,
request_auth_managed,
request_auth_member_limit,
request_auth_model_access,
request_auth_model_budget_check,
request_auth_model_budget_query,
request_auth_model_budget_resolve,
request_auth_model_groups,
request_auth_org_admin,
request_auth_org_route,
request_auth_route_access,
request_auth_scheme_credential,
request_auth_select_api_key,
request_auth_select_websocket_api_key,
request_auth_start,
||||||| parent of da364c75e2 (refactor(auth): port model and route policy to native decisions) NativeAuthContinuation,
};
#[pymodule_export]
use crate::router::{RouterCall, RouterCoreHandle};

View file

@ -129,6 +129,7 @@ fn map_error(error: core::Error) -> PyErr {
match error {
core::Error::IncompatibleDateTimes => PyTypeError::new_err(message),
core::Error::InvalidAnswer => PyRuntimeError::new_err(message),
core::Error::Pattern(_) => PyRuntimeError::new_err(message),
}
}
@ -237,3 +238,42 @@ pub(crate) fn request_auth_scheme_credential(value: &str) -> Option<String> {
pub(crate) fn request_auth_litellm_header_token(value: &str) -> String {
credential::litellm_header_token(value)
}
#[pyfunction]
pub(crate) fn request_auth_route_access(py: Python<'_>, request: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
let request: core::route_access::Request = from_py(request)?;
let decision = py.detach(move || core::route_access::decide(request)).map_err(map_error)?;
to_py(py, &decision)
}
#[pyfunction]
pub(crate) fn request_auth_org_route(py: Python<'_>, facts: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
let facts: core::org_routes::Facts = from_py(facts)?;
to_py(py, &py.detach(move || core::org_routes::decide(facts)))
}
#[pyfunction]
pub(crate) fn request_auth_org_admin(py: Python<'_>, memberships: &Bound<'_, PyAny>, organizations: Vec<String>) -> PyResult<bool> {
let memberships: Vec<core::org_routes::Membership> = from_py(memberships)?;
Ok(py.detach(move || core::org_routes::user_is_admin(&memberships, &organizations)))
}
#[pyfunction]
pub(crate) fn request_auth_model_access(py: Python<'_>, request: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
let request: core::model_access::Request = from_py(request)?;
let decision = py.detach(move || core::model_access::decide(request)).map_err(map_error)?;
to_py(py, &decision)
}
#[pyfunction]
pub(crate) fn request_auth_model_groups(py: Python<'_>, facts: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
let facts: core::model_groups::Facts = from_py(facts)?;
to_py(py, &py.detach(move || core::model_groups::decide(facts)))
}
#[pyfunction]
pub(crate) fn request_auth_fallback_access(py: Python<'_>, facts: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
let facts: core::fallback_access::Facts = from_py(facts)?;
let decision = py.detach(move || core::fallback_access::decide(facts)).map_err(map_error)?;
to_py(py, &decision)
}

View file

@ -5,6 +5,7 @@ edition.workspace = true
license.workspace = true
[dependencies]
fancy-regex.workspace = true
litellm-secret-value.workspace = true
serde.workspace = true
sha2.workspace = true

View file

@ -1,5 +1,7 @@
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("invalid auth pattern")]
Pattern(#[source] fancy_regex::Error),
#[error("invalid auth effect answer")]
InvalidAnswer,
#[error("can't compare offset-naive and offset-aware datetimes")]

View file

@ -0,0 +1,105 @@
use serde::{Deserialize, Serialize};
use crate::{
Error,
model_access::{self, Decision as ModelDecision, Facts as ModelFacts, Request, Response},
};
#[derive(Deserialize)]
pub struct GroupedScope {
pub facts: ModelFacts,
pub group_ids: Vec<String>,
pub group_models: Option<Vec<String>>,
}
#[derive(Deserialize)]
pub struct Facts {
pub refuse_agent_keys: bool,
pub agent_id: Option<String>,
pub key: GroupedScope,
pub team: Option<GroupedScope>,
pub embedded_team: Option<ModelFacts>,
pub assigned_models: Option<Vec<String>>,
pub member: Option<ModelFacts>,
pub project: Option<ModelFacts>,
}
#[derive(Serialize)]
#[serde(tag = "kind")]
pub enum Decision {
Allow,
Deny { denial: Option<ModelDecision> },
ReadKeyGroups,
ReadTeamGroups,
ReadAssignedGroups,
}
fn grouped(scope: GroupedScope, merge: bool) -> Result<ModelDecision, Error> {
let Response::Decision(decision) = model_access::decide(Request::Grouped {
facts: scope.facts,
group_ids: scope.group_ids,
group_models: scope.group_models,
merge,
})?
else {
return Err(Error::InvalidAnswer);
};
Ok(decision)
}
pub fn decide(facts: Facts) -> Result<Decision, Error> {
if facts.refuse_agent_keys && facts.agent_id.is_some() {
return Ok(Decision::Deny { denial: None });
}
let key = grouped(facts.key, false)?;
if matches!(key, ModelDecision::ReadGroups) {
return Ok(Decision::ReadKeyGroups);
}
if !key.allowed() {
return Ok(Decision::Deny { denial: Some(key) });
}
if let Some(team) = facts.team {
let model_facts = team.facts.clone();
let decision = grouped(team, true)?;
if matches!(decision, ModelDecision::ReadGroups) {
return Ok(Decision::ReadTeamGroups);
}
if !decision.allowed() {
if !matches!(decision, ModelDecision::Deny { .. }) {
return Ok(Decision::Deny {
denial: Some(decision),
});
}
let Some(grants) = facts.assigned_models else {
return Ok(Decision::ReadAssignedGroups);
};
if grants.is_empty()
|| !model_access::check(&ModelFacts {
grants,
..model_facts
})?
.allowed()
{
return Ok(Decision::Deny {
denial: Some(decision),
});
}
}
} else if let Some(team) = facts.embedded_team {
let decision = model_access::check(&team)?;
if !decision.allowed() {
return Ok(Decision::Deny {
denial: Some(decision),
});
}
}
for scope in [facts.member, facts.project].into_iter().flatten() {
let decision = model_access::check(&scope)?;
if !decision.allowed() {
return Ok(Decision::Deny {
denial: Some(decision),
});
}
}
Ok(Decision::Allow)
}

View file

@ -10,6 +10,12 @@ mod key;
pub mod managed;
pub mod model_budget_data;
mod model_budgets;
pub mod patterns;
pub mod route_access;
pub mod org_routes;
pub mod model_access;
pub mod model_groups;
pub mod fallback_access;
pub mod protocol;
pub use error::Error;

View file

@ -0,0 +1,600 @@
use std::collections::{BTreeMap, BTreeSet};
use serde::{Deserialize, Serialize};
use crate::{Error, patterns};
#[derive(Clone, Default, Deserialize)]
pub struct Provider {
pub stripped_model: String,
pub provider: String,
}
#[derive(Clone, Default, Deserialize)]
pub struct ModelRecord {
pub access_groups: Vec<String>,
pub provider: Option<Provider>,
pub deployment_team: Option<String>,
pub deployment_public_name: Option<String>,
}
#[derive(Clone, Default, Deserialize)]
pub struct Registry {
pub present: bool,
pub names: Vec<String>,
pub aliases: BTreeMap<String, String>,
pub records: BTreeMap<String, ModelRecord>,
pub compaction_parents: BTreeMap<String, String>,
}
#[derive(Clone, Default, Deserialize)]
pub struct Aliases {
pub team: BTreeMap<String, String>,
pub key: BTreeMap<String, String>,
#[serde(rename = "global_")]
pub global: BTreeMap<String, String>,
}
#[derive(Clone, Deserialize)]
pub struct Facts {
pub requested: Vec<String>,
pub grants: Vec<String>,
pub team_id: Option<String>,
pub aliases: Aliases,
pub registry: Registry,
pub object_type: ObjectType,
pub fallback_depth: usize,
pub max_depth: usize,
pub is_list: bool,
}
#[derive(Clone, Copy, Deserialize, Serialize, Debug, PartialEq, Eq, strum::VariantArray)]
#[serde(rename_all = "snake_case")]
pub enum ObjectType {
User,
Customer,
Team,
Key,
Org,
Project,
Agent,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(tag = "kind")]
pub enum Decision {
Allow,
Deny {
model: String,
grants: Vec<String>,
object_type: ObjectType,
},
Depth {
model: Option<String>,
},
NoDefaultModels,
NoAgentModels,
EmptyAgentCeiling,
PersonalTeam {
model: String,
},
ReadGroups,
}
impl Decision {
pub fn allowed(&self) -> bool {
matches!(self, Self::Allow)
}
}
fn unique(values: impl Iterator<Item = String>) -> Vec<String> {
let mut seen = BTreeSet::new();
values.filter(|value| seen.insert(value.clone())).collect()
}
pub fn resolve_key_grants(
grants: &[String],
team_id: Option<&str>,
team_grants: &[String],
) -> Vec<String> {
if grants.iter().any(|grant| grant == "all-team-models") {
return if team_id.is_none() {
Vec::new()
} else {
team_grants.to_vec()
};
}
grants.to_vec()
}
fn expanded_grants(facts: &Facts) -> Vec<String> {
if !facts.grants.iter().any(|grant| grant == "all-team-models")
|| facts.team_id.is_none()
|| !facts.registry.present
{
return facts.grants.clone();
}
let others = facts
.grants
.iter()
.filter(|grant| grant.as_str() != "all-team-models")
.cloned();
if facts.registry.names.is_empty() {
let values: Vec<_> = others.collect();
return if values.is_empty() {
facts.grants.clone()
} else {
values
};
}
unique(others.chain(facts.registry.names.iter().cloned()))
}
fn helper(model: &str, facts: &Facts, aliases: bool) -> Result<bool, Error> {
let grants = expanded_grants(facts);
let record = facts.registry.records.get(model);
let groups = record.map_or(&[][..], |record| record.access_groups.as_slice());
if grants.iter().any(|grant| groups.contains(grant)) {
return Ok(true);
}
let filtered: Vec<_> = grants
.iter()
.filter(|grant| !groups.contains(grant))
.collect();
if aliases && facts.aliases.team.contains_key(model) {
return Ok(true);
}
for grant in &filtered {
if patterns::model_pattern(model, grant)? {
return Ok(true);
}
}
if let Some(provider) = record.and_then(|record| record.provider.as_ref())
&& (provider.stripped_model != model || !model.contains('/'))
{
for grant in &filtered {
if patterns::model_pattern(
&format!("{}/{}", provider.provider, provider.stripped_model),
grant,
)? {
return Ok(true);
}
}
}
Ok((filtered.is_empty() && grants.is_empty())
|| filtered.iter().any(|grant| {
matches!(grant.as_str(), "*" | "all-proxy-models") || grant.as_str() == model
}))
}
pub fn candidate_names(
model: &str,
aliases: &Aliases,
registry: &Registry,
team_id: Option<&str>,
) -> (Vec<String>, Vec<String>) {
let after_team = aliases.team.get(model).map_or(model, String::as_str);
let after_key = aliases
.key
.get(after_team)
.map_or(after_team, String::as_str);
let after_global = aliases
.global
.get(after_key)
.map_or(after_key, String::as_str);
let dispatched = aliases
.key
.get(after_global)
.map_or(after_global, String::as_str);
if after_key != after_team || dispatched != after_global {
return (vec![dispatched.to_owned()], vec![]);
}
let candidates = std::iter::once(model.to_owned())
.chain(registry.compaction_parents.get(model).cloned())
.chain(
aliases
.global
.get(model)
.or_else(|| registry.aliases.get(model))
.filter(|target| !target.is_empty())
.cloned(),
)
.collect();
let Some(team) = team_id else {
return (candidates, vec![]);
};
if !registry.present || !model.starts_with(&format!("model_name_{team}_")) {
return (candidates, vec![]);
}
let record = registry.records.get(model);
let public = record
.filter(|record| record.deployment_team.as_deref() == Some(team))
.and_then(|record| record.deployment_public_name.clone())
.filter(|name| !name.is_empty());
let legacy = aliases
.team
.iter()
.filter(|(_, target)| target.as_str() == model)
.map(|(alias, _)| alias.clone());
(candidates, public.into_iter().chain(legacy).collect())
}
pub fn live_team_target(model: &str, facts: &Facts) -> String {
let Some(target) = facts.aliases.team.get(model) else {
return model.to_owned();
};
let team = facts.team_id.as_deref().unwrap_or("None");
if facts.registry.present
&& target.starts_with(&format!("model_name_{team}_"))
&& !facts.registry.names.contains(target)
{
return model.to_owned();
}
target.clone()
}
pub fn check(facts: &Facts) -> Result<Decision, Error> {
if facts.fallback_depth >= facts.max_depth {
return Ok(Decision::Depth { model: None });
}
for model in &facts.requested {
if facts.is_list && facts.fallback_depth + 1 >= facts.max_depth {
return Ok(Decision::Depth {
model: Some(model.clone()),
});
}
let (candidates, owning_names) = candidate_names(
model,
&facts.aliases,
&facts.registry,
facts.team_id.as_deref(),
);
let mut allowed = false;
for candidate in candidates {
if helper(&candidate, facts, true)? {
allowed = true;
break;
}
}
if !allowed {
for candidate in owning_names {
if helper(&candidate, facts, false)? {
allowed = true;
break;
}
}
}
if !allowed {
return Ok(Decision::Deny {
model: model.clone(),
grants: facts.grants.clone(),
object_type: facts.object_type,
});
}
}
Ok(Decision::Allow)
}
#[derive(Deserialize)]
pub enum Request {
Object(Facts),
Grouped {
facts: Facts,
group_ids: Vec<String>,
group_models: Option<Vec<String>>,
merge: bool,
},
Helper {
model: String,
facts: Facts,
},
User {
facts: Facts,
present: bool,
},
Customer(Facts),
Agent {
facts: Facts,
managed_grants: Option<Vec<String>>,
ceilings: Vec<Vec<String>>,
},
Personal {
requested: Vec<String>,
teams: Vec<PersonalTeam>,
},
KeyGrants {
grants: Vec<String>,
team_id: Option<String>,
team_grants: Vec<String>,
},
Candidates(Facts),
PersonalApplies {
enabled: bool,
token_present: bool,
team_id: Option<String>,
user_id: Option<String>,
master: bool,
role: Option<String>,
api_key_present: bool,
inheritance: bool,
},
AssignedGroups {
groups: Vec<AssignedGroup>,
team_id: Option<String>,
key_id: Option<String>,
},
}
#[derive(Deserialize)]
pub struct AssignedGroup {
pub assigned_team_ids: Vec<String>,
pub assigned_key_ids: Vec<String>,
pub models: Vec<String>,
}
#[derive(Deserialize)]
pub struct PersonalTeam {
pub blocked: bool,
pub available: bool,
pub team: Facts,
pub member: Option<Facts>,
}
#[derive(Serialize)]
#[serde(untagged)]
pub enum Response {
Decision(Decision),
Models(Vec<String>),
Predicate(bool),
}
pub fn decide(request: Request) -> Result<Response, Error> {
let decision = match request {
Request::Object(facts) => check(&facts)?,
Request::Grouped {
facts,
group_ids,
group_models,
merge,
} => {
let primary = check(&facts)?;
if primary.allowed()
|| !matches!(primary, Decision::Deny { .. })
|| group_ids.is_empty()
{
primary
} else if let Some(models) = group_models {
if models.is_empty() {
primary
} else {
check(&Facts {
grants: if merge {
unique(facts.grants.iter().cloned().chain(models))
} else {
models
},
..facts
})?
}
} else {
Decision::ReadGroups
}
}
Request::Helper { model, facts } => {
return Ok(Response::Predicate(helper(&model, &facts, true)?));
}
Request::User { facts, present } => {
if !present {
Decision::Allow
} else if facts
.grants
.iter()
.any(|grant| grant == "no-default-models")
{
Decision::NoDefaultModels
} else {
check(&facts)?
}
}
Request::Customer(facts) => {
for name in &facts.requested {
let target = live_team_target(name, &facts);
if target != *name && facts.grants.contains(name) {
continue;
}
let customer = Facts {
requested: vec![target],
is_list: false,
team_id: None,
aliases: Aliases {
key: facts.aliases.key.clone(),
global: facts.aliases.global.clone(),
..Default::default()
},
..facts.clone()
};
let result = check(&customer)?;
if !result.allowed() {
return Ok(Response::Decision(result));
}
}
Decision::Allow
}
Request::Agent {
facts,
managed_grants,
ceilings,
} => {
if facts.requested.is_empty()
|| (facts.requested.len() == 1 && !facts.is_list && facts.requested[0].is_empty())
{
return Ok(Response::Decision(Decision::Allow));
}
let dispatched = facts
.requested
.iter()
.map(|name| live_team_target(name, &facts))
.collect();
let scope = Facts {
requested: dispatched,
aliases: Aliases {
key: facts.aliases.key.clone(),
global: facts.aliases.global.clone(),
..Default::default()
},
object_type: ObjectType::Agent,
..facts
};
if let Some(grants) = managed_grants {
if grants.is_empty() {
return Ok(Response::Decision(Decision::NoAgentModels));
}
let result = check(&Facts {
grants,
..scope.clone()
})?;
if !result.allowed() {
return Ok(Response::Decision(result));
}
}
for grants in ceilings {
if grants.is_empty() {
return Ok(Response::Decision(Decision::EmptyAgentCeiling));
}
let result = check(&Facts {
grants,
..scope.clone()
})?;
if !result.allowed() {
return Ok(Response::Decision(result));
}
}
Decision::Allow
}
Request::Personal { requested, teams } => {
for name in requested {
let mut allowed = false;
for team in &teams {
if team.blocked || !team.available {
continue;
}
if !check(&Facts {
requested: vec![name.clone()],
is_list: false,
..team.team.clone()
})?
.allowed()
{
continue;
}
if let Some(member) = &team.member
&& !check(&Facts {
requested: vec![name.clone()],
is_list: false,
..member.clone()
})?
.allowed()
{
continue;
}
allowed = true;
break;
}
if !allowed {
return Ok(Response::Decision(Decision::PersonalTeam { model: name }));
}
}
Decision::Allow
}
Request::KeyGrants {
grants,
team_id,
team_grants,
} => {
return Ok(Response::Models(resolve_key_grants(
&grants,
team_id.as_deref(),
&team_grants,
)));
}
Request::Candidates(facts) => {
return Ok(Response::Models(unique(facts.requested.iter().flat_map(
|model| {
let (candidates, owned) = candidate_names(
model,
&facts.aliases,
&facts.registry,
facts.team_id.as_deref(),
);
candidates.into_iter().chain(owned)
},
))));
}
Request::PersonalApplies {
enabled,
token_present,
team_id,
user_id,
master,
role,
api_key_present,
inheritance,
} => {
return Ok(Response::Predicate(
enabled
&& token_present
&& team_id.is_none()
&& user_id.is_some()
&& !master
&& role.as_deref() != Some("proxy_admin")
&& (!inheritance || api_key_present),
));
}
Request::AssignedGroups {
groups,
team_id,
key_id,
} => {
return Ok(Response::Models(unique(
groups
.into_iter()
.filter(|group| {
team_id.as_ref().is_some_and(|id| {
!id.is_empty() && group.assigned_team_ids.contains(id)
}) || key_id
.as_ref()
.is_some_and(|id| !id.is_empty() && group.assigned_key_ids.contains(id))
})
.flat_map(|group| group.models),
)));
}
};
Ok(Response::Decision(decision))
}
#[cfg(test)]
mod tests {
use super::*;
use rstest::rstest;
#[rstest]
#[case::empty(vec![], true)]
#[case::wildcard(vec!["*"], true)]
#[case::proxy(vec!["all-proxy-models"], true)]
#[case::other(vec!["other"], false)]
#[case::exact(vec!["model"], true)]
fn model_grants(#[case] grants: Vec<&str>, #[case] expected: bool) {
let facts = Facts {
requested: vec!["model".into()],
grants: grants.into_iter().map(str::to_owned).collect(),
team_id: None,
aliases: Aliases::default(),
registry: Registry::default(),
object_type: ObjectType::Key,
fallback_depth: 0,
max_depth: 10,
is_list: false,
};
assert_eq!(check(&facts).unwrap().allowed(), expected);
}
}

View file

@ -0,0 +1,73 @@
use std::collections::BTreeSet;
use serde::{Deserialize, Serialize};
#[derive(Deserialize)]
pub struct Group {
pub assigned_team_ids: Vec<String>,
pub assigned_key_ids: Vec<String>,
pub resources: Vec<String>,
}
#[derive(Deserialize)]
#[serde(tag = "kind", content = "group")]
pub enum Lookup {
Found(Group),
Missing,
Failed,
}
#[derive(Deserialize)]
pub struct Facts {
pub subject_present: bool,
pub database_present: bool,
pub cache_present: bool,
pub group_ids: Vec<String>,
pub team_id: Option<String>,
pub key_id: Option<String>,
pub check_db_only: bool,
pub strict_errors: bool,
pub loaded: Vec<Lookup>,
}
#[derive(Serialize)]
#[serde(tag = "kind")]
pub enum Decision {
Read { index: usize },
Raise { index: usize },
Complete { resources: Vec<String> },
}
pub fn decide(facts: Facts) -> Decision {
if !facts.subject_present || !facts.database_present || !facts.cache_present {
return Decision::Complete { resources: vec![] };
}
let mut resources = BTreeSet::new();
for index in 0..facts.group_ids.len() {
let Some(loaded) = facts.loaded.get(index) else {
return Decision::Read { index };
};
match loaded {
Lookup::Missing | Lookup::Failed if facts.check_db_only || facts.strict_errors => {
return Decision::Raise { index };
}
Lookup::Missing | Lookup::Failed => {}
Lookup::Found(group) => {
if facts
.team_id
.as_ref()
.is_some_and(|id| !id.is_empty() && group.assigned_team_ids.contains(id))
|| facts
.key_id
.as_ref()
.is_some_and(|id| !id.is_empty() && group.assigned_key_ids.contains(id))
{
resources.extend(group.resources.iter().cloned());
}
}
}
}
Decision::Complete {
resources: resources.into_iter().collect(),
}
}

View file

@ -0,0 +1,119 @@
use serde::{Deserialize, Serialize};
#[derive(Clone, Deserialize)]
pub struct Membership {
pub organization_id: Option<String>,
pub role: Option<String>,
}
#[derive(Deserialize)]
pub struct Facts {
pub route: String,
pub user_present: bool,
pub user_role: Option<String>,
pub memberships: Option<Vec<Membership>>,
pub organization_id: Option<String>,
pub org_admin_routes: Vec<String>,
}
#[derive(Debug, PartialEq, Eq, Serialize, strum::VariantArray)]
pub enum Denial {
CreateOrganization,
NoMemberships,
MissingOrganization,
MissingRole,
WrongRole,
TeamMissingOrganization,
TeamWrongRole,
}
#[derive(Debug, PartialEq, Eq, Serialize)]
pub struct Decision {
pub denial: Option<Denial>,
pub organization_role: Option<String>,
pub organization_ids: Vec<String>,
}
pub fn decide(facts: Facts) -> Decision {
let memberships = facts.memberships.as_deref().unwrap_or(&[]);
let ids = memberships
.iter()
.filter_map(|item| item.organization_id.clone())
.collect();
let role = memberships
.iter()
.rev()
.find(|item| {
item.organization_id.is_some() && item.organization_id == facts.organization_id
})
.and_then(|item| item.role.clone());
let denial = if !facts.user_present || facts.user_role.as_deref() == Some("proxy_admin") {
None
} else if facts.route == "/organization/new" {
Some(Denial::CreateOrganization)
} else if facts.org_admin_routes.contains(&facts.route) {
if facts.memberships.is_none() {
Some(Denial::NoMemberships)
} else if facts.organization_id.is_none() {
Some(Denial::MissingOrganization)
} else if role.is_none() {
Some(Denial::MissingRole)
} else if role.as_deref() != Some("org_admin") {
Some(Denial::WrongRole)
} else {
None
}
} else if facts.route == "/team/new" && !memberships.is_empty() {
if facts.organization_id.is_none() {
Some(Denial::TeamMissingOrganization)
} else if role.as_deref() != Some("org_admin") {
Some(Denial::TeamWrongRole)
} else {
None
}
} else {
None
};
Decision {
denial,
organization_role: role,
organization_ids: ids,
}
}
pub fn user_is_admin(memberships: &[Membership], organizations: &[String]) -> bool {
!organizations.is_empty()
&& organizations.iter().all(|id| {
memberships.iter().any(|item| {
item.organization_id.as_ref() == Some(id)
&& item.role.as_deref() == Some("org_admin")
})
})
}
#[cfg(test)]
mod tests {
use super::*;
use rstest::rstest;
#[rstest]
#[case::none(None, Some(Denial::NoMemberships))]
#[case::empty(Some(vec![]), Some(Denial::MissingOrganization))]
fn membership_presence(
#[case] memberships: Option<Vec<Membership>>,
#[case] expected: Option<Denial>,
) {
assert_eq!(
decide(Facts {
route: "/organization/update".into(),
user_present: true,
user_role: None,
memberships,
organization_id: None,
org_admin_routes: vec!["/organization/update".into()]
})
.denial,
expected
);
}
}

View file

@ -0,0 +1,134 @@
use fancy_regex::Regex;
use std::{
collections::BTreeMap,
sync::{Arc, LazyLock, Mutex},
};
use crate::Error;
static EXPRESSIONS: LazyLock<Mutex<BTreeMap<String, Arc<Regex>>>> =
LazyLock::new(|| Mutex::new(BTreeMap::new()));
fn expression(pattern: &str) -> Result<Arc<Regex>, Error> {
if let Some(compiled) = EXPRESSIONS
.lock()
.unwrap_or_else(|error| error.into_inner())
.get(pattern)
{
return Ok(Arc::clone(compiled));
}
let compiled = Arc::new(Regex::new(pattern).map_err(Error::Pattern)?);
let mut expressions = EXPRESSIONS
.lock()
.unwrap_or_else(|error| error.into_inner());
if expressions.len() >= 1024 {
expressions.clear();
}
expressions.insert(pattern.to_owned(), Arc::clone(&compiled));
Ok(compiled)
}
pub fn regex_match(pattern: &str, value: &str) -> Result<bool, Error> {
let expression = expression(pattern)?;
Ok(expression
.find(value)
.map_err(Error::Pattern)?
.is_some_and(|found| found.start() == 0))
}
pub fn model_pattern(model: &str, pattern: &str) -> Result<bool, Error> {
if !pattern.contains('*') {
return Ok(false);
}
regex_match(
&format!("^{}(?=\\n?\\z)", pattern.replace('*', ".*")),
model,
)
}
pub fn route_pattern(route: &str, pattern: &str) -> Result<bool, Error> {
let mut expression = String::from("^");
let mut rest = pattern;
while let Some(start) = rest.find('{') {
expression.push_str(&rest[..start]);
let Some(end) = rest[start + 1..].find('}').map(|index| index + start + 1) else {
expression.push_str(&rest[start..]);
rest = "";
break;
};
let name = &rest[start + 1..end];
if name.is_empty() {
expression.push_str("{}");
} else if name.ends_with(":path") {
expression.push_str(if rest[end + 1..].contains(':') {
"[^:]+"
} else {
"[\\s\\S]+"
});
} else {
expression.push_str("[^/]+");
}
rest = &rest[end + 1..];
}
expression.push_str(rest);
expression.push_str("(?=\\n?\\z)");
regex_match(&expression, route)
}
pub fn wildcard(route: &str, pattern: &str) -> bool {
pattern
.strip_suffix('*')
.map_or(route == pattern, |prefix| route.starts_with(prefix))
}
pub fn prefix(route: &str, pattern: &str) -> bool {
route == pattern
|| route
.strip_prefix(pattern)
.is_some_and(|suffix| suffix.starts_with('/'))
}
pub fn route_access(route: &str, patterns: &[String]) -> Result<bool, Error> {
if patterns
.iter()
.any(|pattern| pattern == route || (pattern.ends_with('*') && wildcard(route, pattern)))
{
return Ok(true);
}
for pattern in patterns {
if route_pattern(route, pattern)? {
return Ok(true);
}
}
Ok(false)
}
#[cfg(test)]
mod tests {
use rstest::rstest;
#[rstest]
#[case::segment("/key/k/reset", "/key/{id}/reset", true)]
#[case::segment_slash("/key/a/b/reset", "/key/{id}/reset", false)]
#[case::path_slash("/credentials/a/b/start", "/credentials/{id:path}/start", true)]
#[case::path_newline("/credentials/a\nb/start", "/credentials/{id:path}/start", true)]
#[case::google_suffix(
"/models/a:b:generateContent",
"/models/{id:path}:generateContent",
false
)]
#[case::final_newline("/models/a\n", "/models/{id}", true)]
fn route_templates(#[case] route: &str, #[case] pattern: &str, #[case] expected: bool) {
assert_eq!(super::route_pattern(route, pattern).unwrap(), expected);
}
#[rstest]
#[case::provider("openai/a", "openai/*", true)]
#[case::exact_not_pattern("a", "a", false)]
#[case::regex_dot("aa-1", "a.-*", true)]
#[case::newline("a\nb", "*", false)]
#[case::final_newline("a\n", "a*", true)]
fn model_patterns(#[case] model: &str, #[case] pattern: &str, #[case] expected: bool) {
assert_eq!(super::model_pattern(model, pattern).unwrap(), expected);
}
}

View file

@ -0,0 +1,567 @@
use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::{Error, patterns};
#[derive(Clone, Default, Deserialize)]
pub struct RouteCatalog {
pub groups: BTreeMap<String, Vec<String>>,
pub viewer_blocked: Vec<String>,
pub viewer_write_blocked: Vec<String>,
pub self_credentials: Vec<(String, String)>,
pub managed_models: Vec<String>,
pub managed_paths: Vec<String>,
pub managed_realtime: Vec<String>,
pub managed_live: Vec<String>,
pub managed_mcp: Vec<String>,
pub unbilled: Vec<String>,
}
impl RouteCatalog {
fn group(&self, name: &str) -> &[String] {
self.groups.get(name).map_or(&[], Vec::as_slice)
}
fn access(&self, route: &str, name: &str) -> Result<bool, Error> {
patterns::route_access(route, self.group(name))
}
fn contains(&self, route: &str, name: &str) -> bool {
self.group(name).iter().any(|entry| entry == route)
}
}
#[derive(Clone, Default, Deserialize)]
pub struct RouteContext {
pub route: String,
pub method: Option<String>,
pub catalog: RouteCatalog,
pub registered: bool,
pub registered_auth: Option<bool>,
pub configured_eu_jev: bool,
}
#[derive(Clone, Default, Deserialize)]
pub struct PassThroughFacts {
pub key_allowed: Vec<String>,
pub team_allowed: Vec<String>,
pub denied: Vec<String>,
pub forwarded: Vec<String>,
pub jwt_team_routes: Vec<String>,
}
#[derive(Deserialize)]
pub struct VirtualRouteFacts {
pub context: RouteContext,
pub allowed_routes: Option<Vec<String>>,
pub passthrough: PassThroughFacts,
pub password_reset_required: bool,
}
#[derive(Deserialize)]
pub struct ViewerFacts {
pub context: RouteContext,
pub request_keys: Vec<String>,
}
#[derive(Deserialize)]
pub struct NonAdminFacts {
pub viewer: ViewerFacts,
pub role: Option<String>,
pub custom_admin_routes: Vec<String>,
pub premium: bool,
pub query_user_id: Option<String>,
pub token_user_id: Option<String>,
pub permissions: Vec<String>,
pub organization_ids: Vec<String>,
pub admin_organization_ids: Vec<String>,
pub team_service_account: bool,
pub allowed_routes: Option<Vec<String>>,
pub passthrough: PassThroughFacts,
}
#[derive(Deserialize)]
pub struct MatchFacts {
pub route: String,
pub patterns: Vec<String>,
pub mode: MatchMode,
}
#[derive(Deserialize, strum::VariantArray)]
pub enum MatchMode {
Access,
Template,
Prefix,
Wildcard,
Denied,
Jwt,
}
#[derive(Deserialize, strum::VariantArray)]
pub enum Classification {
Llm,
Unbilled,
Discovery,
SelfCredential,
Azure,
Managed,
}
#[derive(Deserialize)]
pub enum Request {
Match(MatchFacts),
Classify {
context: RouteContext,
kind: Classification,
},
Virtual(VirtualRouteFacts),
Viewer(ViewerFacts),
NonAdmin(NonAdminFacts),
PassThrough {
context: RouteContext,
facts: PassThroughFacts,
required: bool,
},
DeniedPassThrough {
route: String,
facts: PassThroughFacts,
},
}
#[derive(Debug, PartialEq, Eq, Serialize)]
pub struct Decision {
pub allowed: bool,
pub denial: Option<Denial>,
pub detail: Option<String>,
}
#[derive(Debug, PartialEq, Eq, Serialize, strum::VariantArray)]
pub enum Denial {
VirtualRoute,
PasswordReset,
PassThrough,
DeniedPassThrough,
CustomAdmin,
UserInfo,
AdminOnly,
ViewerInference,
ViewerWrite,
ViewerParameter,
}
impl Decision {
fn allow() -> Self {
Self {
allowed: true,
denial: None,
detail: None,
}
}
fn predicate(value: bool) -> Self {
Self {
allowed: value,
denial: None,
detail: None,
}
}
fn deny(denial: Denial) -> Self {
Self {
allowed: false,
denial: Some(denial),
detail: None,
}
}
fn detail(denial: Denial, detail: String) -> Self {
Self {
allowed: false,
denial: Some(denial),
detail: Some(detail),
}
}
}
fn denied_pattern(route: &str, pattern: &str) -> bool {
let normalized = pattern.trim_end_matches('/');
normalized.is_empty()
|| patterns::prefix(route, normalized)
|| patterns::wildcard(route, pattern)
}
fn jwt_grant(route: &str, entries: &[String]) -> bool {
entries.iter().any(|entry| {
!entry.trim_end_matches('*').trim_matches('/').is_empty()
&& patterns::wildcard(route, entry)
})
}
fn passthrough_grant(route: &str, facts: &PassThroughFacts) -> bool {
let entries = if facts.key_allowed.is_empty() {
&facts.team_allowed
} else {
&facts.key_allowed
};
entries.iter().any(|entry| patterns::prefix(route, entry))
}
fn denied_passthrough(facts: &PassThroughFacts) -> Option<&str> {
facts
.denied
.iter()
.find(|denied| {
facts
.forwarded
.iter()
.any(|route| denied_pattern(route, denied))
})
.map(String::as_str)
}
fn require_passthrough(route: &str, facts: &PassThroughFacts) -> Decision {
if let Some(denied) = denied_passthrough(facts) {
return Decision::detail(Denial::DeniedPassThrough, denied.to_owned());
}
if passthrough_grant(route, facts) || jwt_grant(route, &facts.jwt_team_routes) {
return Decision::allow();
}
Decision::deny(Denial::PassThrough)
}
fn azure(route: &str) -> Result<bool, Error> {
Ok(patterns::regex_match(
"^/openai/deployments/[^/]+/[^/]+/chat/completions(?=\\n?\\z)",
route,
)? || patterns::regex_match("^/engines/[^/]+/chat/completions(?=\\n?\\z)", route)?)
}
fn llm(context: &RouteContext) -> Result<bool, Error> {
let route = &context.route;
let catalog = &context.catalog;
for group in ["openai_routes", "anthropic_routes", "google_routes"] {
if catalog.contains(route, group) {
return Ok(true);
}
}
for group in [
"mcp_inference_routes",
"agent_inference_routes",
"litellm_native_routes",
] {
if catalog.access(route, group)? {
return Ok(true);
}
}
for group in ["openai_routes", "google_routes", "anthropic_routes"] {
for pattern in catalog.group(group) {
if pattern.contains('{') && patterns::route_pattern(route, pattern)? {
return Ok(true);
}
if group == "openai_routes"
&& pattern.ends_with('*')
&& patterns::wildcard(route, pattern)
{
return Ok(true);
}
}
}
Ok(azure(route)?
|| catalog
.group("mapped_pass_through_routes")
.iter()
.any(|pattern| patterns::prefix(route, pattern))
|| (route.trim_end_matches('/') == "/eu_jev/v1/systemone" && !context.configured_eu_jev))
}
fn discovery(context: &RouteContext) -> bool {
context.method.as_deref() == Some("GET")
&& (context.route == "/v1/mcp/server"
|| context
.route
.strip_prefix("/v1/mcp/server/")
.is_some_and(|tail| !tail.is_empty() && !tail.contains('/')))
}
fn self_credential(context: &RouteContext) -> Result<bool, Error> {
for (method, pattern) in &context.catalog.self_credentials {
if context.method.as_ref() == Some(method)
&& patterns::route_access(&context.route, std::slice::from_ref(pattern))?
{
return Ok(true);
}
}
Ok(false)
}
fn managed(context: &RouteContext) -> Result<bool, Error> {
let route = &context.route;
let method = context.method.as_deref();
let catalog = &context.catalog;
if route == "/agents" || route == "/v1/agents" {
return Ok(matches!(method, None | Some("GET" | "HEAD")));
}
if catalog.managed_realtime.contains(route) || catalog.managed_live.contains(route) {
return Ok(matches!(method, None | Some("GET")));
}
if catalog.managed_models.contains(route)
|| patterns::route_access(route, &catalog.managed_paths)?
{
return Ok(matches!(method, None | Some("POST")));
}
Ok(patterns::route_access(route, &catalog.managed_mcp)?
|| catalog.access(route, "agent_inference_routes")?)
}
fn virtual_route(facts: &VirtualRouteFacts) -> Result<Decision, Error> {
let Some(allowed) = &facts.allowed_routes else {
return Ok(Decision::allow());
};
if allowed.is_empty() {
return Ok(Decision::allow());
}
let context = &facts.context;
let route = &context.route;
if allowed
.iter()
.any(|pattern| patterns::prefix(route, pattern))
{
return Ok(Decision::allow());
}
let mut denied_passthrough = false;
for group in allowed {
if !context.catalog.groups.contains_key(group) {
continue;
}
let is_llm = matches!(
group.as_str(),
"llm_api_routes" | "llm_api_routes_without_mcp"
);
if context.catalog.access(route, group)? {
if (is_llm || group == "openai_routes") && context.registered_auth == Some(true) {
if passthrough_grant(route, &facts.passthrough) {
return Ok(Decision::allow());
}
denied_passthrough = true;
} else {
return Ok(Decision::allow());
}
}
if !is_llm {
continue;
}
if route == "/auto_router/session" && context.method.as_deref() == Some("GET") {
return Ok(Decision::allow());
}
if context.registered {
if context.registered_auth == Some(true) {
if passthrough_grant(route, &facts.passthrough) {
return Ok(Decision::allow());
}
denied_passthrough = true;
} else {
return Ok(Decision::allow());
}
}
if group == "llm_api_routes"
&& (discovery(context) || context.catalog.access(route, "agent_management_routes")?)
{
return Ok(Decision::allow());
}
}
if allowed
.iter()
.any(|pattern| patterns::wildcard(route, pattern))
{
return Ok(Decision::allow());
}
Ok(Decision::deny(if denied_passthrough {
Denial::PassThrough
} else if facts.password_reset_required {
Denial::PasswordReset
} else {
Denial::VirtualRoute
}))
}
fn viewer(facts: &ViewerFacts) -> Result<Decision, Error> {
let context = &facts.context;
let route = &context.route;
let catalog = &context.catalog;
if llm(context)? {
return Ok(Decision::deny(Denial::ViewerInference));
}
let invalid = facts
.request_keys
.iter()
.find(|key| key.as_str() != "user_email");
if catalog.access(route, "management_routes")? {
if route == "/user/update" {
if let Some(key) = invalid {
return Ok(Decision::detail(Denial::ViewerParameter, key.clone()));
}
} else if patterns::route_access(route, &catalog.viewer_blocked)?
|| (route.starts_with("/key/")
&& (route.ends_with("/regenerate") || route.ends_with("/reset_spend")))
{
return Ok(Decision::deny(Denial::ViewerWrite));
}
}
if matches!(
context.method.as_deref().unwrap_or("GET"),
"GET" | "HEAD" | "OPTIONS"
) {
return Ok(Decision::allow());
}
if route == "/user/update" {
return Ok(invalid.map_or_else(Decision::allow, |key| {
Decision::detail(Denial::ViewerParameter, key.clone())
}));
}
if route == "/user/password/change" || route == "/session/logout" || self_credential(context)? {
return Ok(Decision::allow());
}
if patterns::route_access(route, &catalog.viewer_write_blocked)?
|| (route.starts_with("/key/") && route.ends_with("/regenerate"))
{
return Ok(Decision::deny(Denial::ViewerWrite));
}
if catalog.access(route, "admin_viewer_routes")?
|| catalog.access(route, "global_spend_tracking_routes")?
{
return Ok(Decision::allow());
}
Ok(Decision::deny(Denial::ViewerWrite))
}
fn non_admin(facts: &NonAdminFacts) -> Result<Decision, Error> {
let context = &facts.viewer.context;
let route = &context.route;
let catalog = &context.catalog;
let role = facts.role.as_deref();
if facts.premium && facts.custom_admin_routes.contains(route) {
return Ok(Decision::deny(Denial::CustomAdmin));
}
if context.registered_auth == Some(true) {
return Ok(require_passthrough(route, &facts.passthrough));
}
if llm(context)? {
return Ok(Decision::allow());
}
if catalog.contains(route, "info_routes") {
if route == "/user/info"
&& facts
.query_user_id
.as_ref()
.is_some_and(|id| !id.is_empty())
&& facts.query_user_id != facts.token_user_id
&& role != Some("proxy_admin_viewer")
{
return Ok(Decision::deny(Denial::UserInfo));
}
return Ok(Decision::allow());
}
if catalog.contains(route, "global_spend_tracking_routes")
&& facts
.permissions
.iter()
.any(|entry| entry == "get_spend_routes")
{
return Ok(Decision::allow());
}
if patterns::prefix(route, "/lens") {
return Ok(Decision::allow());
}
if role == Some("proxy_admin_viewer") {
return viewer(&facts.viewer);
}
let org_admin = !facts.organization_ids.is_empty()
&& facts
.organization_ids
.iter()
.all(|id| facts.admin_organization_ids.contains(id));
if (role == Some("internal_user")
&& (catalog.access(route, "internal_user_routes")? || self_credential(context)?))
|| (org_admin && catalog.access(route, "org_admin_allowed_routes")?)
|| (role == Some("internal_user_viewer")
&& catalog.access(route, "internal_user_view_only_routes")?)
|| catalog.access(route, "self_managed_routes")?
|| route.starts_with("/v1/mcp/")
|| route.starts_with("/mcp-rest/")
|| passthrough_grant(route, &facts.passthrough)
|| (facts.team_service_account
&& catalog.access(route, "team_service_account_key_routes")?)
{
return Ok(Decision::allow());
}
if facts.allowed_routes.as_ref().is_some_and(|entries| {
entries
.iter()
.any(|entry| patterns::prefix(route, entry) || patterns::wildcard(route, entry))
}) {
return Ok(Decision::allow());
}
Ok(Decision::deny(Denial::AdminOnly))
}
pub fn decide(request: Request) -> Result<Decision, Error> {
match request {
Request::Virtual(facts) => virtual_route(&facts),
Request::Viewer(facts) => viewer(&facts),
Request::NonAdmin(facts) => non_admin(&facts),
Request::PassThrough {
context,
facts,
required,
} => Ok(if required {
require_passthrough(&context.route, &facts)
} else {
Decision::predicate(passthrough_grant(&context.route, &facts))
}),
Request::DeniedPassThrough { route: _, facts } => Ok(denied_passthrough(&facts)
.map_or_else(Decision::allow, |entry| {
Decision::detail(Denial::DeniedPassThrough, entry.to_owned())
})),
Request::Match(facts) => {
let matched = match facts.mode {
MatchMode::Access => patterns::route_access(&facts.route, &facts.patterns)?,
MatchMode::Jwt => jwt_grant(&facts.route, &facts.patterns),
MatchMode::Template => {
let mut found = false;
for pattern in &facts.patterns {
if patterns::route_pattern(&facts.route, pattern)? {
found = true;
break;
}
}
found
}
MatchMode::Prefix => facts
.patterns
.iter()
.any(|pattern| patterns::prefix(&facts.route, pattern)),
MatchMode::Wildcard => facts
.patterns
.iter()
.any(|pattern| patterns::wildcard(&facts.route, pattern)),
MatchMode::Denied => facts
.patterns
.iter()
.any(|pattern| denied_pattern(&facts.route, pattern)),
};
Ok(Decision::predicate(matched))
}
Request::Classify { context, kind } => Ok(Decision::predicate(match kind {
Classification::Llm => llm(&context)?,
Classification::Azure => azure(&context.route)?,
Classification::Discovery => discovery(&context),
Classification::SelfCredential => self_credential(&context)?,
Classification::Managed => managed(&context)?,
Classification::Unbilled => {
let tail = context.route.rsplit('/').next().unwrap_or("");
let (resource, action) = tail.split_once(':').unwrap_or((tail, ""));
context.catalog.unbilled.contains(&context.route)
|| matches!(resource, "count_tokens" | "count-tokens")
|| action == "countTokens"
}
})),
}
}

View file

@ -0,0 +1,39 @@
from dataclasses import asdict, dataclass
from typing import Final, Literal
from pydantic import TypeAdapter
from litellm._auth.model_access import ModelAccessDecision, ModelAccessFacts
from litellm.rust_bridge import _native
@dataclass(frozen=True, slots=True)
class GroupedModelScope:
facts: ModelAccessFacts
group_ids: tuple[str, ...] = ()
group_models: tuple[str, ...] | None = None
@dataclass(frozen=True, slots=True)
class FallbackAuthorizationFacts:
key: GroupedModelScope
refuse_agent_keys: bool = False
agent_id: str | None = None
team: GroupedModelScope | None = None
embedded_team: ModelAccessFacts | None = None
assigned_models: tuple[str, ...] | None = None
member: ModelAccessFacts | None = None
project: ModelAccessFacts | None = None
@dataclass(frozen=True, slots=True)
class FallbackAuthorizationDecision:
kind: Literal["Allow", "Deny", "ReadKeyGroups", "ReadTeamGroups", "ReadAssignedGroups"]
denial: ModelAccessDecision | None = None
_DECISION: Final = TypeAdapter(FallbackAuthorizationDecision)
def fallback_authorization(facts: FallbackAuthorizationFacts) -> FallbackAuthorizationDecision:
return _DECISION.validate_python(_native.request_auth_fallback_access(asdict(facts)))

View file

@ -0,0 +1,211 @@
from collections.abc import Mapping
from dataclasses import asdict, dataclass, field
from typing import Final, Literal, TypeAlias
from pydantic import TypeAdapter
from litellm.rust_bridge import _native
ModelObject: TypeAlias = Literal["user", "customer", "team", "key", "org", "project", "agent"]
@dataclass(frozen=True, slots=True)
class ModelProvider:
stripped_model: str
provider: str
@dataclass(frozen=True, slots=True)
class ModelRecord:
access_groups: tuple[str, ...] = ()
provider: ModelProvider | None = None
deployment_team: str | None = None
deployment_public_name: str | None = None
@dataclass(frozen=True, slots=True)
class ModelRegistry:
present: bool = False
names: tuple[str, ...] = ()
aliases: Mapping[str, str] = field(default_factory=dict[str, str])
records: Mapping[str, ModelRecord] = field(default_factory=dict[str, ModelRecord])
compaction_parents: Mapping[str, str] = field(default_factory=dict[str, str])
@dataclass(frozen=True, slots=True)
class ModelAliases:
team: Mapping[str, str] = field(default_factory=dict[str, str])
key: Mapping[str, str] = field(default_factory=dict[str, str])
global_: Mapping[str, str] = field(default_factory=dict[str, str])
@dataclass(frozen=True, slots=True)
class ModelAccessFacts:
requested: tuple[str, ...]
grants: tuple[str, ...] = ()
team_id: str | None = None
aliases: ModelAliases = field(default_factory=ModelAliases)
registry: ModelRegistry = field(default_factory=ModelRegistry)
object_type: ModelObject = "user"
fallback_depth: int = 0
max_depth: int = 5
is_list: bool = False
@dataclass(frozen=True, slots=True)
class ModelAccessDecision:
kind: Literal[
"Allow", "Deny", "Depth", "NoDefaultModels", "NoAgentModels", "EmptyAgentCeiling", "PersonalTeam", "ReadGroups"
]
model: str | None = None
grants: tuple[str, ...] = ()
object_type: ModelObject = "user"
@dataclass(frozen=True, slots=True)
class AssignedModelGroup:
assigned_team_ids: tuple[str, ...]
assigned_key_ids: tuple[str, ...]
models: tuple[str, ...]
@dataclass(frozen=True, slots=True)
class PersonalModelTeam:
blocked: bool
available: bool
team: ModelAccessFacts
member: ModelAccessFacts | None = None
_DECISION: Final = TypeAdapter(ModelAccessDecision)
_MODELS: Final = TypeAdapter(tuple[str, ...])
_BOOL: Final = TypeAdapter(bool)
def model_access(facts: ModelAccessFacts, *, kind: Literal["Object", "Customer"] = "Object") -> ModelAccessDecision:
return _DECISION.validate_python(_native.request_auth_model_access({kind: asdict(facts)}))
def grouped_model_access(
facts: ModelAccessFacts,
group_ids: tuple[str, ...],
group_models: tuple[str, ...] | None = None,
*,
merge: bool = False,
) -> ModelAccessDecision:
return _DECISION.validate_python(
_native.request_auth_model_access(
{
"Grouped": {
"facts": asdict(facts),
"group_ids": group_ids,
"group_models": group_models,
"merge": merge,
}
}
)
)
def user_model_access(facts: ModelAccessFacts, *, present: bool) -> ModelAccessDecision:
return _DECISION.validate_python(
_native.request_auth_model_access({"User": {"facts": asdict(facts), "present": present}})
)
def agent_model_access(
facts: ModelAccessFacts, managed_grants: tuple[str, ...] | None, ceilings: tuple[tuple[str, ...], ...]
) -> ModelAccessDecision:
return _DECISION.validate_python(
_native.request_auth_model_access(
{
"Agent": {
"facts": asdict(facts),
"managed_grants": managed_grants,
"ceilings": ceilings,
}
}
)
)
def personal_model_access(requested: tuple[str, ...], teams: tuple[PersonalModelTeam, ...]) -> ModelAccessDecision:
return _DECISION.validate_python(
_native.request_auth_model_access(
{
"Personal": {
"requested": requested,
"teams": tuple(asdict(team) for team in teams),
}
}
)
)
def model_candidates(facts: ModelAccessFacts) -> tuple[str, ...]:
return _MODELS.validate_python(_native.request_auth_model_access({"Candidates": asdict(facts)}))
def model_access_helper(model: str, facts: ModelAccessFacts) -> bool:
return _BOOL.validate_python(
_native.request_auth_model_access({"Helper": {"model": model, "facts": asdict(facts)}})
)
def key_model_grants(grants: tuple[str, ...], team_id: str | None, team_grants: tuple[str, ...]) -> tuple[str, ...]:
return _MODELS.validate_python(
_native.request_auth_model_access(
{
"KeyGrants": {
"grants": grants,
"team_id": team_id,
"team_grants": team_grants,
}
}
)
)
def assigned_model_grants(
groups: tuple[AssignedModelGroup, ...], team_id: str | None, key_id: str | None
) -> tuple[str, ...]:
return _MODELS.validate_python(
_native.request_auth_model_access(
{
"AssignedGroups": {
"groups": tuple(asdict(group) for group in groups),
"team_id": team_id,
"key_id": key_id,
}
}
)
)
def personal_model_access_applies(
*,
enabled: bool,
token_present: bool,
team_id: str | None,
user_id: str | None,
master: bool,
role: str | None,
api_key_present: bool,
inheritance: bool = False,
) -> bool:
return _BOOL.validate_python(
_native.request_auth_model_access(
{
"PersonalApplies": {
"enabled": enabled,
"token_present": token_present,
"team_id": team_id,
"user_id": user_id,
"master": master,
"role": role,
"api_key_present": api_key_present,
"inheritance": inheritance,
}
}
)
)

View file

@ -0,0 +1,46 @@
from dataclasses import asdict, dataclass
from typing import Final, Literal
from pydantic import TypeAdapter
from litellm.rust_bridge import _native
@dataclass(frozen=True, slots=True)
class GroupResources:
assigned_team_ids: tuple[str, ...]
assigned_key_ids: tuple[str, ...]
resources: tuple[str, ...]
@dataclass(frozen=True, slots=True)
class GroupLookup:
kind: Literal["Found", "Missing", "Failed"]
group: GroupResources | None = None
@dataclass(frozen=True, slots=True)
class ResourceGroupFacts:
subject_present: bool
database_present: bool
cache_present: bool
group_ids: tuple[str, ...]
team_id: str | None
key_id: str | None
check_db_only: bool = False
strict_errors: bool = False
loaded: tuple[GroupLookup, ...] = ()
@dataclass(frozen=True, slots=True)
class ResourceGroupDecision:
kind: Literal["Read", "Raise", "Complete"]
index: int = 0
resources: tuple[str, ...] = ()
_DECISION: Final = TypeAdapter(ResourceGroupDecision)
def resource_group_decision(facts: ResourceGroupFacts) -> ResourceGroupDecision:
return _DECISION.validate_python(_native.request_auth_model_groups(asdict(facts)))

View file

@ -0,0 +1,51 @@
from dataclasses import asdict, dataclass
from typing import Final, Literal, TypeAlias
from pydantic import TypeAdapter
from litellm.rust_bridge import _native
@dataclass(frozen=True, slots=True)
class OrganizationMembership:
organization_id: str | None
role: str | None
@dataclass(frozen=True, slots=True)
class OrganizationRouteFacts:
route: str
user_present: bool
user_role: str | None
memberships: tuple[OrganizationMembership, ...] | None
organization_id: str | None
org_admin_routes: tuple[str, ...]
OrgRouteDenial: TypeAlias = Literal[
"CreateOrganization",
"NoMemberships",
"MissingOrganization",
"MissingRole",
"WrongRole",
"TeamMissingOrganization",
"TeamWrongRole",
]
@dataclass(frozen=True, slots=True)
class OrganizationRouteDecision:
denial: OrgRouteDenial | None
organization_role: str | None
organization_ids: tuple[str, ...]
_DECISION: Final = TypeAdapter(OrganizationRouteDecision)
def organization_route(facts: OrganizationRouteFacts) -> OrganizationRouteDecision:
return _DECISION.validate_python(_native.request_auth_org_route(asdict(facts)))
def user_is_org_admin(memberships: tuple[OrganizationMembership, ...], organizations: tuple[str, ...]) -> bool:
return _native.request_auth_org_admin(tuple(asdict(item) for item in memberships), organizations)

138
litellm/_auth/routes.py Normal file
View file

@ -0,0 +1,138 @@
from collections.abc import Mapping
from dataclasses import asdict, dataclass, field
from typing import Final, Literal, TypeAlias
from pydantic import TypeAdapter
from litellm.rust_bridge import _native
@dataclass(frozen=True, slots=True)
class RouteCatalog:
groups: Mapping[str, tuple[str, ...]] = field(default_factory=dict[str, tuple[str, ...]])
viewer_blocked: tuple[str, ...] = ()
viewer_write_blocked: tuple[str, ...] = ()
self_credentials: tuple[tuple[str, str], ...] = ()
managed_models: tuple[str, ...] = ()
managed_paths: tuple[str, ...] = ()
managed_realtime: tuple[str, ...] = ()
managed_live: tuple[str, ...] = ()
managed_mcp: tuple[str, ...] = ()
unbilled: tuple[str, ...] = ()
@dataclass(frozen=True, slots=True)
class RouteContext:
route: str
method: str | None = None
catalog: RouteCatalog = field(default_factory=RouteCatalog)
registered: bool = False
registered_auth: bool | None = None
configured_eu_jev: bool = False
@dataclass(frozen=True, slots=True)
class PassThroughFacts:
key_allowed: tuple[str, ...] = ()
team_allowed: tuple[str, ...] = ()
denied: tuple[str, ...] = ()
forwarded: tuple[str, ...] = ()
jwt_team_routes: tuple[str, ...] = ()
@dataclass(frozen=True, slots=True)
class VirtualRouteFacts:
context: RouteContext
allowed_routes: tuple[str, ...] | None
passthrough: PassThroughFacts = field(default_factory=PassThroughFacts)
password_reset_required: bool = False
@dataclass(frozen=True, slots=True)
class ViewerFacts:
context: RouteContext
request_keys: tuple[str, ...] = ()
@dataclass(frozen=True, slots=True)
class NonAdminFacts:
viewer: ViewerFacts
role: str | None = None
custom_admin_routes: tuple[str, ...] = ()
premium: bool = False
query_user_id: str | None = None
token_user_id: str | None = None
permissions: tuple[str, ...] = ()
organization_ids: tuple[str, ...] = ()
admin_organization_ids: tuple[str, ...] = ()
team_service_account: bool = False
allowed_routes: tuple[str, ...] | None = None
passthrough: PassThroughFacts = field(default_factory=PassThroughFacts)
RouteDenial: TypeAlias = Literal[
"VirtualRoute",
"PasswordReset",
"PassThrough",
"DeniedPassThrough",
"CustomAdmin",
"UserInfo",
"AdminOnly",
"ViewerInference",
"ViewerWrite",
"ViewerParameter",
]
@dataclass(frozen=True, slots=True)
class RouteDecision:
allowed: bool
denial: RouteDenial | None = None
detail: str | None = None
_DECISION: Final = TypeAdapter(RouteDecision)
def match_route(
route: str,
patterns: tuple[str, ...],
mode: Literal["Access", "Template", "Prefix", "Wildcard", "Denied", "Jwt"] = "Access",
) -> bool:
return _DECISION.validate_python(
_native.request_auth_route_access({"Match": {"route": route, "patterns": patterns, "mode": mode}})
).allowed
def classify_route(
context: RouteContext, kind: Literal["Llm", "Unbilled", "Discovery", "SelfCredential", "Azure", "Managed"]
) -> bool:
return _DECISION.validate_python(
_native.request_auth_route_access({"Classify": {"context": asdict(context), "kind": kind}})
).allowed
def virtual_route(facts: VirtualRouteFacts) -> RouteDecision:
return _DECISION.validate_python(_native.request_auth_route_access({"Virtual": asdict(facts)}))
def non_admin_route(facts: NonAdminFacts) -> RouteDecision:
return _DECISION.validate_python(_native.request_auth_route_access({"NonAdmin": asdict(facts)}))
def viewer_route(facts: ViewerFacts) -> RouteDecision:
return _DECISION.validate_python(_native.request_auth_route_access({"Viewer": asdict(facts)}))
def passthrough_route(context: RouteContext, facts: PassThroughFacts, *, required: bool = False) -> RouteDecision:
return _DECISION.validate_python(
_native.request_auth_route_access(
{"PassThrough": {"context": asdict(context), "facts": asdict(facts), "required": required}}
)
)
def denied_passthrough_route(route: str, facts: PassThroughFacts) -> RouteDecision:
return _DECISION.validate_python(
_native.request_auth_route_access({"DeniedPassThrough": {"route": route, "facts": asdict(facts)}})
)

View file

@ -0,0 +1,111 @@
from dataclasses import replace
from typing import Final
from litellm._auth.fallback_access import FallbackAuthorizationFacts, GroupedModelScope, fallback_authorization
from litellm._auth.model_access import key_model_grants
from litellm.proxy._types import LiteLLM_ProjectTable, LiteLLM_TeamMembership, LiteLLM_TeamTable, UserAPIKeyAuth
from litellm.proxy.auth.model_access_adapter import object_model_grants, project_model_facts
from litellm.proxy.auth.model_group_adapter import get_authorized_resources_from_key_access_groups
from litellm.repositories.prisma_protocols import DatabaseClient
from litellm.router_api import RegistryReader
async def load_fallback_authorization_facts(
model: str,
valid_token: UserAPIKeyAuth,
llm_router: RegistryReader | None,
prisma_client: DatabaseClient | None = None,
team_membership: LiteLLM_TeamMembership | None = None,
project_object: LiteLLM_ProjectTable | None = None,
refuse_agent_keys: bool = False,
team_object: LiteLLM_TeamTable | None = None,
) -> FallbackAuthorizationFacts:
from litellm.proxy.auth.auth_checks import key_model_aliases_for_auth_check
aliases: Final = key_model_aliases_for_auth_check(valid_token)
key_grants: Final = key_model_grants(
object_model_grants(valid_token), valid_token.team_id, tuple(valid_token.team_models or ())
)
member_grants: Final = (
tuple(team_membership.litellm_budget_table.allowed_models or ())
if team_membership is not None and team_membership.litellm_budget_table is not None
else ()
)
facts: Final = FallbackAuthorizationFacts(
key=GroupedModelScope(
project_model_facts(
model, llm_router, key_grants, valid_token.team_model_aliases, valid_token.team_id, aliases, "key"
),
tuple(valid_token.access_group_ids or ()),
),
refuse_agent_keys=refuse_agent_keys,
agent_id=valid_token.agent_id,
team=GroupedModelScope(
project_model_facts(
model,
llm_router,
team_object.models,
valid_token.team_model_aliases,
team_object.team_id,
aliases,
"team",
),
tuple(team_object.access_group_ids or ()),
)
if team_object is not None
else None,
embedded_team=project_model_facts(
model,
llm_router,
valid_token.team_models or (),
valid_token.team_model_aliases,
valid_token.team_id,
aliases,
"team",
)
if team_object is None
else None,
member=project_model_facts(
model, llm_router, member_grants, team_id=valid_token.team_id, key_model_aliases=aliases, object_type="team"
),
project=project_model_facts(
model,
llm_router,
project_object.models,
team_id=project_object.team_id,
key_model_aliases=aliases,
object_type="project",
)
if project_object is not None
else None,
)
return await _load_groups(facts, valid_token, team_object, prisma_client)
async def _load_groups(
facts: FallbackAuthorizationFacts,
token: UserAPIKeyAuth,
team: LiteLLM_TeamTable | None,
prisma: DatabaseClient | None,
) -> FallbackAuthorizationFacts:
from litellm.proxy.auth.auth_checks import get_models_from_access_groups
decision: Final = fallback_authorization(facts)
match decision.kind:
case "Allow" | "Deny":
return facts
case "ReadKeyGroups":
models: Final = await get_models_from_access_groups(facts.key.group_ids, prisma_client=prisma)
return await _load_groups(
replace(facts, key=replace(facts.key, group_models=tuple(models))), token, team, prisma
)
case "ReadTeamGroups":
if facts.team is None:
raise RuntimeError("fallback requested missing team")
team_models: Final = await get_models_from_access_groups(facts.team.group_ids, prisma_client=prisma)
return await _load_groups(
replace(facts, team=replace(facts.team, group_models=tuple(team_models))), token, team, prisma
)
case "ReadAssignedGroups":
assigned: Final = await get_authorized_resources_from_key_access_groups(token, team, "access_model_names")
return await _load_groups(replace(facts, assigned_models=tuple(assigned)), token, team, prisma)

View file

@ -0,0 +1,329 @@
from collections.abc import Mapping, Sequence
from dataclasses import replace
from typing import Final, Literal
from fastapi import HTTPException
from pydantic import BaseModel
import litellm
from litellm._auth.model_access import (
ModelAccessDecision,
ModelAccessFacts,
ModelAliases,
ModelObject,
ModelProvider,
ModelRecord,
ModelRegistry,
grouped_model_access,
key_model_grants,
model_access,
model_candidates,
user_model_access,
)
from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH
from litellm.proxy._types import (
LiteLLM_EndUserTable,
LiteLLM_OrganizationTable,
LiteLLM_ProjectTable,
LiteLLM_TeamTable,
LiteLLM_UserTable,
ModelAccessDeniedProxyException,
ProxyErrorTypes,
UserAPIKeyAuth,
)
from litellm.proxy.auth.model_access_denied import (
customer_model_access_denied_client_message,
model_access_denied_client_message,
)
from litellm.repositories.prisma_protocols import DatabaseClient
from litellm.router_api import RegistryReader
from litellm.router_strategy.complexity_router.context_compaction import native_compaction_parent
class ModelLists(BaseModel, frozen=True):
models: tuple[str, ...] = ()
def object_model_grants(source: object) -> tuple[str, ...]:
return ModelLists.model_validate(source, from_attributes=True).models
def _provider(model: str) -> ModelProvider | None:
try:
stripped, provider, _, _ = litellm.get_llm_provider(model=model)
return ModelProvider(stripped, provider)
except Exception:
return None
def _record(model: str, router: RegistryReader | None, team_id: str | None) -> ModelRecord:
deployment: Final = router.registry().deployments(model, source="first_in_group") if router is not None else None
return ModelRecord(
access_groups=tuple(router.registry().access_groups(model_name=model, team_id=team_id))
if router is not None
else (),
provider=_provider(model),
deployment_team=deployment.model_info.team_id if deployment is not None else None,
deployment_public_name=deployment.model_info.team_public_model_name if deployment is not None else None,
)
def project_model_facts(
model: str | Sequence[str],
llm_router: RegistryReader | None,
models: Sequence[str],
team_model_aliases: Mapping[str, str] | None = None,
team_id: str | None = None,
key_model_aliases: Mapping[str, str] | None = None,
object_type: ModelObject = "user",
fallback_depth: int = 0,
) -> ModelAccessFacts:
requested: Final = (model,) if isinstance(model, str) else tuple(model)
aliases: Final = ModelAliases(
team=dict(team_model_aliases or {}), key=dict(key_model_aliases or {}), global_=dict(litellm.model_alias_map)
)
names: Final = tuple(dict.fromkeys((*requested, *aliases.team.values())))
registry: Final = ModelRegistry(
present=llm_router is not None,
names=tuple(llm_router.registry().names()) if llm_router is not None else (),
aliases={
name: target
for name in names
if name in llm_router.registry().aliases()
and (target := llm_router.registry().resolve(name, kind="alias")) is not None
}
if llm_router is not None
else {},
records={name: _record(name, llm_router, team_id) for name in names},
compaction_parents={name: parent for name in names if (parent := native_compaction_parent(name)) is not None},
)
initial: Final = ModelAccessFacts(
requested=requested,
grants=tuple(models),
team_id=team_id,
aliases=aliases,
registry=registry,
object_type=object_type,
fallback_depth=fallback_depth,
max_depth=DEFAULT_MAX_RECURSE_DEPTH,
is_list=not isinstance(model, str),
)
candidates: Final = model_candidates(replace(initial, requested=names))
return replace(
initial,
registry=replace(
registry,
records={
**registry.records,
**{name: _record(name, llm_router, team_id) for name in candidates if name not in registry.records},
},
),
)
def raise_model_denial(
decision: ModelAccessDecision,
requested: str | Sequence[str],
*,
user_id: str | None = None,
team_id: str | None = None,
teams: Sequence[str] | None = None,
member_models: Sequence[str] | None = None,
) -> Literal[True]:
model: Final = requested if isinstance(requested, str) else list(requested)
match decision.kind:
case "Allow":
return True
case "Depth":
raise Exception(
f"Unable to parse model, max fallback depth exceeded - received model: {decision.model if decision.model is not None else model}"
)
case "NoAgentModels":
raise HTTPException(403, "This agent has no model grants")
case "ReadGroups":
raise RuntimeError("model grant lookup was not answered")
case "Deny" | "NoDefaultModels" | "EmptyAgentCeiling" | "PersonalTeam":
error_model: Final = decision.model if decision.model is not None else model
object_type: Final = decision.object_type
message: Final = (
customer_model_access_denied_client_message(error_model)
if object_type == "customer"
else model_access_denied_client_message(error_model)
)
internal: Final = (
f"Team member not allowed to access model. User={user_id}, Team={team_id}, Model={model}. Allowed member models = {list(member_models)}"
if member_models is not None
else (
f"User not allowed to access model. No default model access, only team models allowed. Tried to access {model}"
if decision.kind == "NoDefaultModels"
else (
f"agent {user_id} access groups grant no models"
if decision.kind == "EmptyAgentCeiling"
else (
f"Personal key model access is derived from the owner's teams. User={user_id}, teams={list(teams) if teams is not None else None}, model={error_model}"
if decision.kind == "PersonalTeam"
else (
f"{object_type} not allowed to access model. This {object_type} can only access models={list(decision.grants)}. Tried to access {error_model}"
)
)
)
)
)
error_type: Final = (
ProxyErrorTypes.team_model_access_denied
if member_models is not None
else (
ProxyErrorTypes.key_model_access_denied
if decision.kind in ("NoDefaultModels", "PersonalTeam")
else (
ProxyErrorTypes.agent_model_access_denied
if decision.kind == "EmptyAgentCeiling"
else ProxyErrorTypes.get_model_access_error_type_for_object(object_type)
)
)
)
raise ModelAccessDeniedProxyException(
message=message, internal_message=internal, type=error_type, param="model", code=403
)
def can_object_call_model(
model: str | Sequence[str],
llm_router: RegistryReader | None,
models: Sequence[str],
team_model_aliases: Mapping[str, str] | None = None,
team_id: str | None = None,
key_model_aliases: Mapping[str, str] | None = None,
object_type: ModelObject = "user",
fallback_depth: int = 0,
) -> Literal[True]:
facts: Final = project_model_facts(
model, llm_router, models, team_model_aliases, team_id, key_model_aliases, object_type, fallback_depth
)
return raise_model_denial(model_access(facts), model)
async def _grouped_model_access(
facts: ModelAccessFacts,
group_ids: Sequence[str],
prisma_client: DatabaseClient | None,
*,
merge: bool,
) -> ModelAccessDecision:
from litellm.proxy.auth.auth_checks import get_models_from_access_groups
decision: Final = grouped_model_access(facts, tuple(group_ids), merge=merge)
if decision.kind != "ReadGroups":
return decision
models: Final = await get_models_from_access_groups(list(group_ids), prisma_client=prisma_client)
return grouped_model_access(facts, tuple(group_ids), tuple(models), merge=merge)
async def can_key_call_model(
model: str | Sequence[str],
llm_model_list: Sequence[object] | None,
valid_token: UserAPIKeyAuth,
llm_router: RegistryReader | None,
prisma_client: DatabaseClient | None = None,
) -> Literal[True]:
from litellm.proxy.auth.auth_checks import key_model_aliases_for_auth_check
grants: Final = key_model_grants(
object_model_grants(valid_token), valid_token.team_id, tuple(valid_token.team_models or ())
)
facts: Final = project_model_facts(
model,
llm_router,
grants,
valid_token.team_model_aliases,
valid_token.team_id,
key_model_aliases_for_auth_check(valid_token),
"key",
)
decision: Final = await _grouped_model_access(facts, valid_token.access_group_ids or (), prisma_client, merge=False)
return raise_model_denial(decision, model)
async def can_team_access_model(
model: str | Sequence[str],
team_object: LiteLLM_TeamTable | None,
llm_router: RegistryReader | None,
team_model_aliases: Mapping[str, str] | None = None,
key_model_aliases: Mapping[str, str] | None = None,
prisma_client: DatabaseClient | None = None,
) -> Literal[True]:
facts: Final = project_model_facts(
model,
llm_router,
team_object.models if team_object is not None else (),
team_model_aliases,
team_object.team_id if team_object is not None else None,
key_model_aliases,
"team",
)
decision: Final = await _grouped_model_access(
facts, (team_object.access_group_ids or ()) if team_object is not None else (), prisma_client, merge=True
)
return raise_model_denial(decision, model)
def can_org_access_model(
model: str,
org_object: LiteLLM_OrganizationTable | None,
llm_router: RegistryReader | None,
team_model_aliases: Mapping[str, str] | None = None,
) -> Literal[True]:
return can_object_call_model(
model, llm_router, org_object.models if org_object is not None else (), team_model_aliases, object_type="org"
)
def can_project_access_model(
model: str | Sequence[str],
project_object: LiteLLM_ProjectTable,
llm_router: RegistryReader | None,
key_model_aliases: Mapping[str, str] | None = None,
) -> Literal[True]:
return can_object_call_model(
model,
llm_router,
project_object.models,
team_id=project_object.team_id,
key_model_aliases=key_model_aliases,
object_type="project",
)
def can_customer_access_model(
model: str | Sequence[str],
end_user_object: LiteLLM_EndUserTable,
llm_router: RegistryReader | None,
valid_token: UserAPIKeyAuth | None,
) -> Literal[True]:
from litellm.proxy.auth.auth_checks import key_model_aliases_for_auth_check, team_model_aliases_for_auth_check
facts: Final = project_model_facts(
model,
llm_router,
end_user_object.models or (),
team_model_aliases_for_auth_check(valid_token) if valid_token is not None else None,
valid_token.team_id if valid_token is not None else None,
key_model_aliases_for_auth_check(valid_token),
"customer",
)
return raise_model_denial(model_access(facts, kind="Customer"), model)
async def can_user_call_model(
model: str | Sequence[str],
llm_router: RegistryReader | None,
user_object: LiteLLM_UserTable | None,
key_model_aliases: Mapping[str, str] | None = None,
) -> Literal[True]:
facts: Final = project_model_facts(
model,
llm_router,
object_model_grants(user_object) if user_object is not None else (),
key_model_aliases=key_model_aliases,
)
return raise_model_denial(user_model_access(facts, present=user_object is not None), model)

View file

@ -0,0 +1,91 @@
from dataclasses import dataclass, replace
from typing import Final, Literal, TypeAlias
from litellm._auth.model_groups import GroupLookup, GroupResources, ResourceGroupFacts, resource_group_decision
from litellm.proxy._types import LiteLLM_TeamTable, UserAPIKeyAuth
ResourceField: TypeAlias = Literal[
"access_model_names", "access_mcp_server_ids", "access_agent_ids", "access_skill_names"
]
@dataclass(frozen=True, slots=True)
class GroupRead:
lookup: GroupLookup
error: Exception | None = None
async def get_authorized_resources_from_key_access_groups(
valid_token: UserAPIKeyAuth | None,
team_object: LiteLLM_TeamTable | None,
resource_field: ResourceField,
check_db_only: bool = False,
strict_errors: bool = False,
) -> list[str]: # mutable-ok: retain the legacy public return contract
from litellm.proxy.proxy_server import prisma_client, user_api_key_cache
facts: Final = ResourceGroupFacts(
subject_present=valid_token is not None,
database_present=prisma_client is not None,
cache_present=_present(user_api_key_cache),
group_ids=tuple(valid_token.access_group_ids or ()) if valid_token is not None else (),
team_id=(valid_token.team_id if valid_token is not None else None)
or (team_object.team_id if team_object is not None else None),
key_id=valid_token.token if valid_token is not None else None,
check_db_only=check_db_only,
strict_errors=strict_errors,
)
return list(set(await _drive(facts, resource_field, ())))
async def _read(group_id: str, resource_field: ResourceField, check_db_only: bool) -> GroupRead:
from litellm.proxy.auth.auth_checks import AccessGroupNotFoundError, get_access_object
from litellm.proxy.proxy_server import prisma_client, proxy_logging_obj, user_api_key_cache
try:
group: Final = await get_access_object(
access_group_id=group_id,
prisma_client=prisma_client,
user_api_key_cache=user_api_key_cache,
proxy_logging_obj=proxy_logging_obj,
check_db_only=check_db_only,
)
resources: Final = {
"access_model_names": group.access_model_names,
"access_mcp_server_ids": group.access_mcp_server_ids,
"access_agent_ids": group.access_agent_ids,
"access_skill_names": group.access_skill_names,
}[resource_field]
return GroupRead(
GroupLookup(
"Found",
GroupResources(
tuple(group.assigned_team_ids or ()), tuple(group.assigned_key_ids or ()), tuple(resources or ())
),
)
)
except AccessGroupNotFoundError as error:
return GroupRead(GroupLookup("Missing"), error)
except Exception as error:
return GroupRead(GroupLookup("Failed"), error)
async def _drive(
facts: ResourceGroupFacts, resource_field: ResourceField, reads: tuple[GroupRead, ...]
) -> tuple[str, ...]:
decision: Final = resource_group_decision(facts)
match decision.kind:
case "Complete":
return decision.resources
case "Raise":
error: Final = reads[decision.index].error
if error is None:
raise RuntimeError("missing access group lookup failure")
raise error
case "Read":
result: Final = await _read(facts.group_ids[decision.index], resource_field, facts.check_db_only)
return await _drive(replace(facts, loaded=(*facts.loaded, result.lookup)), resource_field, (*reads, result))
def _present(value: object) -> bool:
return value is not None

View file

@ -0,0 +1,84 @@
from collections.abc import Mapping
from typing import Final
from pydantic import TypeAdapter
from litellm._auth.org_routes import (
OrganizationMembership,
OrganizationRouteFacts,
organization_route,
)
from litellm._auth.org_routes import (
user_is_org_admin as native_org_admin,
)
from litellm.proxy._types import LiteLLM_UserTable, LiteLLMRoutes, ProxyErrorTypes, ProxyException
_STRINGS: Final = TypeAdapter(tuple[str, ...])
def memberships(user: LiteLLM_UserTable | None) -> tuple[OrganizationMembership, ...] | None:
return (
tuple(OrganizationMembership(item.organization_id, item.user_role) for item in user.organization_memberships)
if user is not None and user.organization_memberships is not None
else None
)
def user_is_org_admin(request_data: Mapping[str, object], user_object: LiteLLM_UserTable | None = None) -> bool:
singular: Final = request_data.get("organization_id")
plural: Final = request_data.get("organizations")
return native_org_admin(
memberships(user_object) or (),
(
*((singular,) if isinstance(singular, str) else ()),
*(_STRINGS.validate_python(plural) if isinstance(plural, list) else ()),
),
)
def organization_role_based_access_check(
request_body: Mapping[str, object], user_object: LiteLLM_UserTable | None, route: str
) -> None:
passed: Final = request_body.get("organization_id")
organization_id: Final = passed if isinstance(passed, str) else None
role: Final = user_object.user_role if user_object is not None else None
decision: Final = organization_route(
OrganizationRouteFacts(
route,
user_object is not None,
role,
memberships(user_object),
organization_id,
tuple(LiteLLMRoutes.org_admin_only_routes.value),
)
)
messages: Final = {
"CreateOrganization": (f"Only proxy admins can create new organizations. You are {role}", "user_role"),
"NoMemberships": (
f"Tried to access route={route} but you are not a member of any organization. Please contact the proxy admin to request access.",
"organization_id",
),
"MissingOrganization": (
"Passed organization_id is None, please pass an organization_id in your request",
"organization_id",
),
"MissingRole": (
f"You do not have a role within the selected organization. Passed organization_id: {organization_id}. Please contact the organization admin to request access.",
"organization_id",
),
"WrongRole": (
f"You do not have the required role to perform {route} in Organization {organization_id}. Your role is {decision.organization_role} in Organization {organization_id}",
"user_role",
),
"TeamMissingOrganization": (
f"Passed organization_id is None, please specify the organization_id in your request. You are part of multiple organizations: {list(decision.organization_ids)}",
"organization_id",
),
"TeamWrongRole": (
f"You do not have the required role to call {route}. Your role is {decision.organization_role} in Organization {organization_id}",
"user_role",
),
}
if decision.denial is not None:
message, param = messages[decision.denial]
raise ProxyException(message=message, type=ProxyErrorTypes.auth_error.value, param=param, code=401)

View file

@ -1,11 +1,11 @@
import itertools
import re
from collections.abc import Collection, Iterable, Mapping
from typing import Final, cast
from fastapi import HTTPException, Request, status
from litellm._logging import verbose_proxy_logger
from litellm._auth import routes
from litellm.proxy.auth import route_policy_adapter
from litellm.proxy._types import (
MODEL_LIST_ROUTES,
UI_TEAM_ID,
@ -141,120 +141,7 @@ class RouteChecks:
valid_token: UserAPIKeyAuth,
request: Request | None = None,
) -> bool:
"""
Raises Exception if Virtual Key is not allowed to call the route
"""
# Only check if valid_token.allowed_routes is set and is a list with at least one item
if valid_token.allowed_routes is None:
return True
if not isinstance(valid_token.allowed_routes, list):
return True
if len(valid_token.allowed_routes) == 0:
return True
denied_auth_enforced_pass_through_route = False
# explicit check for allowed routes (exact match or prefix match)
for allowed_route in valid_token.allowed_routes:
if RouteChecks._route_matches_allowed_route(route=route, allowed_route=allowed_route):
return True
## check if 'allowed_route' is a field name in LiteLLMRoutes
if any(allowed_route in LiteLLMRoutes._member_names_ for allowed_route in valid_token.allowed_routes):
for allowed_route in valid_token.allowed_routes:
if allowed_route in LiteLLMRoutes._member_names_:
if RouteChecks.check_route_access(
route=route,
allowed_routes=LiteLLMRoutes[allowed_route].value,
):
if (
allowed_route in _AUTH_ENFORCED_PASS_THROUGH_ROUTE_GROUPS
and RouteChecks.is_auth_enforced_pass_through_route(
route=route,
method=RouteChecks.get_request_method(request=request),
)
):
if RouteChecks.check_passthrough_route_access(route=route, user_api_key_dict=valid_token):
return True
denied_auth_enforced_pass_through_route = True
else:
return True
################################################
# For llm_api_routes, also check registered pass-through endpoints
################################################
if allowed_route in _LLM_API_ROUTE_GROUPS:
if route == "/auto_router/session" and RouteChecks.get_request_method(request) == "GET":
return True
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import (
InitPassThroughEndpointHelpers,
)
if InitPassThroughEndpointHelpers.is_registered_pass_through_route(route=route):
if RouteChecks.is_auth_enforced_pass_through_route(
route=route,
method=RouteChecks.get_request_method(request=request),
):
if RouteChecks.check_passthrough_route_access(
route=route, user_api_key_dict=valid_token
):
return True
denied_auth_enforced_pass_through_route = True
else:
return True
# Method-aware carve-out: allow GET on the two
# read-only MCP-server discovery endpoints
# (`/v1/mcp/server` and `/v1/mcp/server/{server_id}`)
# so virtual keys with allowed_routes=["llm_api_routes"]
# can list/inspect MCP servers. The GET handlers in
# mcp_management_endpoints.py sanitize the response
# for restricted virtual keys (stripping url,
# headers, env, credentials). POST/PUT/DELETE on
# these paths are admin-only management writes and
# are intentionally not covered.
if allowed_route == "llm_api_routes" and RouteChecks._is_get_mcp_server_discovery_route(
route=route, request=request
):
return True
# Agent registry CRUD moved from llm_api_routes into
# management_routes so DISABLE_LLM_API_ENDPOINTS stops
# blocking it. Keys configured with
# allowed_routes=["llm_api_routes"] before that split
# could reach these paths, so keep them reachable here;
# the handlers in agent_endpoints/endpoints.py still
# enforce proxy-admin on writes and scope reads by role.
if allowed_route == "llm_api_routes" and RouteChecks.check_route_access(
route=route,
allowed_routes=LiteLLMRoutes.agent_management_routes.value,
):
return True
# check if wildcard pattern is allowed
for allowed_route in valid_token.allowed_routes:
if RouteChecks.route_matches_wildcard_pattern(route=route, pattern=allowed_route):
return True
if denied_auth_enforced_pass_through_route:
raise RouteChecks._auth_pass_through_denied_exception(route=route)
if valid_token.metadata.get("password_reset_required") is True:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=(
"This account's password must be changed before the session can be used: "
"it was either found in a known data breach or set by an admin. "
"Change it via POST /user/password/change (UI: /ui/change-password), then log in again."
),
)
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Virtual key is not allowed to call this route. Only allowed to call routes: {valid_token.allowed_routes}. Tried to call route: {route}",
)
return route_policy_adapter.check_virtual_route(route, valid_token, request)
@staticmethod
def _mask_user_id(user_id: str) -> str:
@ -318,109 +205,7 @@ class RouteChecks:
valid_token: UserAPIKeyAuth,
request_data: dict,
):
"""
Checks if Non Proxy Admin User is allowed to access the route
"""
# Check user has defined custom admin routes
RouteChecks.custom_admin_only_route_check(
route=route,
)
if RouteChecks.is_auth_enforced_pass_through_route(
route=route,
method=RouteChecks.get_request_method(request=request),
):
RouteChecks._require_auth_pass_through_access(
route=route,
valid_token=valid_token,
jwt_team_allowed_routes=RouteChecks._jwt_team_allowed_routes(valid_token=valid_token),
)
elif RouteChecks.is_llm_api_route(route=route):
pass
elif RouteChecks.is_info_route(route=route):
# check if user allowed to call an info route
if route == "/key/info":
# handled by function itself
pass
elif route == "/user/info":
# check if user can access this route
query_params: Final = request.query_params
user_id: Final = query_params.get("user_id")
verbose_proxy_logger.debug("user_id: %s & valid_token.user_id: %s", user_id, valid_token.user_id)
if (
user_id
and user_id != valid_token.user_id
and _user_role != LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value
):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"key not allowed to access this user's info. user_id={user_id}, key's user_id={valid_token.user_id}",
)
elif route == "/v2/user/info":
# handled by the endpoint itself (full RBAC in handler)
pass
elif route == "/model/info":
# /model/info just shows models user has access to
pass
elif route == "/team/info":
pass # handled by function itself
elif (
route in LiteLLMRoutes.global_spend_tracking_routes.value
and getattr(valid_token, "permissions", None) is not None
and "get_spend_routes" in getattr(valid_token, "permissions", [])
):
pass
elif route == "/lens" or route.startswith("/lens/"):
pass # Lens authorizes the delegated role, including its POST-based read endpoints.
elif _user_role == LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value:
RouteChecks._check_proxy_admin_viewer_access(
route=route,
_user_role=_user_role,
request_data=request_data,
request=request,
)
elif (
_user_role == LitellmUserRoles.INTERNAL_USER.value
and (
RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.internal_user_routes.value)
or RouteChecks.is_self_scoped_credential_route(route=route, request=request)
)
or user_is_org_admin(request_data=request_data, user_object=user_obj)
and RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.org_admin_allowed_routes.value)
or _user_role == LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value
and RouteChecks.check_route_access(
route=route,
allowed_routes=LiteLLMRoutes.internal_user_view_only_routes.value,
)
or RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.self_managed_routes.value)
):
pass
elif route.startswith("/v1/mcp/") or route.startswith("/mcp-rest/"):
pass # authN/authZ handled by api itself
elif RouteChecks.check_passthrough_route_access(route=route, user_api_key_dict=valid_token) or (
valid_token.is_team_service_account
and RouteChecks.check_route_access(
route=route, allowed_routes=LiteLLMRoutes.team_service_account_key_routes.value
)
):
pass
elif valid_token.allowed_routes is not None:
# check if route is in allowed_routes (exact match or prefix match)
route_allowed = False
for allowed_route in valid_token.allowed_routes:
if RouteChecks._route_matches_allowed_route(route=route, allowed_route=allowed_route):
route_allowed = True
break
if RouteChecks.route_matches_wildcard_pattern(route=route, pattern=allowed_route):
route_allowed = True
break
if not route_allowed:
RouteChecks._raise_admin_only_route_exception(user_obj=user_obj, route=route)
else:
RouteChecks._raise_admin_only_route_exception(user_obj=user_obj, route=route)
return route_policy_adapter.check_non_admin_route(user_obj, _user_role, route, request, valid_token, request_data)
@staticmethod
def custom_admin_only_route_check(route: str):
@ -441,73 +226,11 @@ class RouteChecks:
@staticmethod
def is_unbilled_route(route: str) -> bool:
resource, _, action = route.rsplit("/", 1)[-1].partition(":")
return route in _UNBILLED_ROUTES or resource in _TOKEN_COUNTING_SEGMENTS or action == _TOKEN_COUNTING_ACTION
return route_policy_adapter.classify(route, "Unbilled")
@staticmethod
def is_llm_api_route(route: str) -> bool:
"""
Helper to checks if provided route is an OpenAI route
Returns:
- True: if route is an OpenAI route
- False: if route is not an OpenAI route
"""
# Ensure route is a string before performing checks
if not isinstance(route, str):
return False
if route in LiteLLMRoutes.openai_routes.value:
return True
if route in LiteLLMRoutes.anthropic_routes.value:
return True
if route in LiteLLMRoutes.google_routes.value:
return True
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.mcp_inference_routes.value):
return True
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.agent_inference_routes.value):
return True
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.litellm_native_routes.value):
return True
# fuzzy match routes like "/v1/threads/thread_49EIN5QF32s4mH20M7GFKdlZ"
# Check for routes with placeholders or wildcard patterns
for openai_route in LiteLLMRoutes.openai_routes.value:
# Replace placeholders with regex pattern
# placeholders are written as "/threads/{thread_id}"
if "{" in openai_route:
if RouteChecks._route_matches_pattern(route=route, pattern=openai_route):
return True
# Check for wildcard patterns like "/containers/*"
if RouteChecks.is_wildcard_pattern(pattern=openai_route):
if RouteChecks.route_matches_wildcard_pattern(route=route, pattern=openai_route):
return True
# Check for Google routes with placeholders like "/v1beta/models/{model_name}:generateContent"
for google_route in LiteLLMRoutes.google_routes.value:
if "{" in google_route:
if RouteChecks._route_matches_pattern(route=route, pattern=google_route):
return True
# Check for Anthropic routes with placeholders
for anthropic_route in LiteLLMRoutes.anthropic_routes.value:
if "{" in anthropic_route:
if RouteChecks._route_matches_pattern(route=route, pattern=anthropic_route):
return True
if RouteChecks._is_azure_openai_route(route=route):
return True
for _llm_passthrough_route in LiteLLMRoutes.mapped_pass_through_routes.value:
if route == _llm_passthrough_route or route.startswith(_llm_passthrough_route + "/"):
return True
return RouteChecks.is_builtin_eu_jev_decision_route(route=route)
return isinstance(route, str) and route_policy_adapter.classify(route, "Llm")
@staticmethod
def is_builtin_eu_jev_decision_route(route: str) -> bool:
@ -523,26 +246,7 @@ class RouteChecks:
@staticmethod
def _is_get_mcp_server_discovery_route(route: str, request: Request | None) -> bool:
"""
Returns True if `request` is a GET against one of the two read-only
MCP-server discovery paths:
- GET `/v1/mcp/server` (list)
- GET `/v1/mcp/server/{server_id}` (single server, single segment)
Multi-segment paths (`/v1/mcp/server/{id}/approve`, etc.) and any
non-GET method return False, so admin-only management writes on the
same path prefix are not reachable through this carve-out.
"""
if request is None or request.method.upper() != "GET":
return False
if route == "/v1/mcp/server":
return True
prefix: Final = "/v1/mcp/server/"
if not route.startswith(prefix):
return False
remainder: Final = route[len(prefix) :]
return bool(remainder) and "/" not in remainder
return route_policy_adapter.classify(route, "Discovery", RouteChecks.get_request_method(request))
@staticmethod
def is_management_route(route: str) -> bool:
@ -567,67 +271,11 @@ class RouteChecks:
@staticmethod
def _is_azure_openai_route(route: str) -> bool:
"""
Check if route is a route from AzureOpenAI SDK client
eg.
route='/openai/deployments/vertex_ai/gemini-1.5-flash/chat/completions'
"""
# Ensure route is a string before attempting regex matching
if not isinstance(route, str):
return False
# Add support for deployment and engine model paths
deployment_pattern: Final = r"^/openai/deployments/[^/]+/[^/]+/chat/completions$"
engine_pattern: Final = r"^/engines/[^/]+/chat/completions$"
if re.match(deployment_pattern, route) or re.match(engine_pattern, route):
return True
return False
return isinstance(route, str) and route_policy_adapter.classify(route, "Azure")
@staticmethod
def _route_matches_pattern(route: str, pattern: str) -> bool:
"""
Check if route matches the pattern placed in proxy/_types.py
Example:
- pattern: "/threads/{thread_id}"
- route: "/threads/thread_49EIN5QF32s4mH20M7GFKdlZ"
- returns: True
- pattern: "/key/{token_id}/regenerate"
- route: "/key/regenerate/82akk800000000jjsk"
- returns: False, pattern is "/key/{token_id}/regenerate"
"""
# Ensure route is a string before attempting regex matching
if not isinstance(route, str):
return False
def _placeholder_to_regex(match: re.Match) -> str:
placeholder: Final = match.group(0).strip("{}")
if not placeholder.endswith(":path"):
return r"[^/]+"
# A ":path" placeholder takes whatever the router's own path
# converter takes, slashes and colons alike, so an id spelled with
# either (or both) still matches the template it was mounted under.
#
# Unless the template puts a ":" literal of its own after the
# placeholder: the Google routes end in ":generateContent" and
# friends, and there the value has to stop before that suffix
# rather than swallow it and match a different verb.
#
# "[\s\S]" rather than ".", because "." stops at a newline and the
# path converter does not: a %0A anywhere in the value would leave
# the route unmatched here while still reaching the handler, which
# turns this gate into a bypass for the lists built on it.
return r"[^:]+" if ":" in match.string[match.end() :] else r"[\s\S]+"
pattern = re.sub(r"\{[^}]+\}", _placeholder_to_regex, pattern)
# Anchor the pattern to match the entire string
pattern = f"^{pattern}$"
if re.match(pattern, route):
return True
return False
return isinstance(route, str) and routes.match_route(route, (pattern,), "Template")
@staticmethod
def is_wildcard_pattern(pattern: str) -> bool:
@ -640,100 +288,15 @@ class RouteChecks:
@staticmethod
def route_matches_wildcard_pattern(route: str, pattern: str) -> bool:
"""
Check if route matches the wildcard pattern
eg.
pattern: "/scim/v2/*"
route: "/scim/v2/Users"
- returns: True
pattern: "/scim/v2/*"
route: "/chat/completions"
- returns: False
pattern: "/scim/v2/*"
route: "/scim/v2/Users/123"
- returns: True
"""
if pattern.endswith("*"):
# Get the prefix (everything before the wildcard)
prefix: Final = pattern[:-1]
return route.startswith(prefix)
else:
# If there's no wildcard, the pattern and route should match exactly
return route == pattern
return routes.match_route(route, (pattern,), "Wildcard")
@staticmethod
def _route_matches_allowed_route(route: str, allowed_route: str) -> bool:
"""
Check if route matches the allowed_route pattern.
Supports both exact match and prefix match.
Examples:
- allowed_route="/fake-openai-proxy-6", route="/fake-openai-proxy-6" -> True (exact match)
- allowed_route="/fake-openai-proxy-6", route="/fake-openai-proxy-6/v1/chat/completions" -> True (prefix match)
- allowed_route="/fake-openai-proxy-6", route="/fake-openai-proxy-600" -> False (not a valid prefix)
Args:
route: The actual route being accessed
allowed_route: The allowed route pattern
Returns:
bool: True if route matches (exact or prefix), False otherwise
"""
# Exact match
if route == allowed_route:
return True
# Prefix match - ensure we add "/" to prevent false matches like /fake-openai-proxy-600
if route.startswith(allowed_route + "/"):
return True
return False
return routes.match_route(route, (allowed_route,), "Prefix")
@staticmethod
def check_route_access(route: str, allowed_routes: Collection[str]) -> bool:
"""
Check if a route has access by checking both exact matches and patterns
Args:
route (str): The route to check
allowed_routes (Sequence): Allowed routes/patterns
Returns:
bool: True if route is allowed, False otherwise
"""
#########################################################
# exact match route is in allowed_routes
#########################################################
if route in allowed_routes:
return True
#########################################################
# wildcard match route is in allowed_routes
# e.g calling /anthropic/v1/messages is allowed if allowed_routes has /anthropic/*
#########################################################
if any(
RouteChecks.route_matches_wildcard_pattern(route=route, pattern=allowed_route)
for allowed_route in allowed_routes
if RouteChecks.is_wildcard_pattern(pattern=allowed_route)
):
return True
#########################################################
# pattern match route is in allowed_routes
# pattern: "/threads/{thread_id}"
# route: "/threads/thread_49EIN5QF32s4mH20M7GFKdlZ"
# returns: True
#########################################################
if any( # Check pattern match
RouteChecks._route_matches_pattern(route=route, pattern=allowed_route) for allowed_route in allowed_routes
):
return True
return False
return routes.match_route(route, tuple(allowed_routes))
@staticmethod
def get_request_method(request: Request | None) -> str | None:
@ -755,13 +318,7 @@ class RouteChecks:
@staticmethod
def is_self_scoped_credential_route(route: str, request: Request | None) -> bool:
method: Final = RouteChecks.get_request_method(request)
if method is None:
return False
return any(
method == expected_method and RouteChecks.check_route_access(route=route, allowed_routes=(pattern,))
for expected_method, pattern in _SELF_SCOPED_CREDENTIAL_ROUTES
)
return route_policy_adapter.classify(route, "SelfCredential", RouteChecks.get_request_method(request))
@staticmethod
def is_auth_enforced_pass_through_route(route: str, method: str | None = None) -> bool:
@ -793,48 +350,13 @@ class RouteChecks:
@staticmethod
def _route_matches_denied_route(route: str, denied_route: str) -> bool:
"""A `/` entry denies every route, since every route sits under the root."""
normalized_denied_route: Final = denied_route.rstrip("/") or "/"
return (
normalized_denied_route == "/"
or RouteChecks._route_matches_allowed_route(route=route, allowed_route=normalized_denied_route)
or RouteChecks.route_matches_wildcard_pattern(route=route, pattern=denied_route)
)
return routes.match_route(route, (denied_route,), "Denied")
@staticmethod
def matching_denied_passthrough_route(
route: str, metadata_sources: Iterable[Mapping[str, object] | None]
) -> str | None:
"""
First ``denied_passthrough_routes`` entry across ``metadata_sources`` that matches ``route``.
Unlike the allowlist (key list, else team list), every source's deny list applies.
"""
denied_routes: Final = tuple(
itertools.chain.from_iterable(
cast( # cast-ok: management endpoints validate this metadata key as a list of route strings on write
"list[str]", (metadata or {}).get("denied_passthrough_routes") or []
)
for metadata in metadata_sources
)
)
if not denied_routes:
return None
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import (
InitPassThroughEndpointHelpers,
)
forwarded_routes: Final = InitPassThroughEndpointHelpers.forwarded_routes(route)
return next(
(
denied_route
for denied_route in denied_routes
if any(
RouteChecks._route_matches_denied_route(route=candidate, denied_route=denied_route)
for candidate in forwarded_routes
)
),
None,
)
return route_policy_adapter.denied_passthrough(route, metadata_sources)
@staticmethod
def passthrough_route_denied_exception(route: str, denied_route: str) -> HTTPException:
@ -857,16 +379,7 @@ class RouteChecks:
@staticmethod
def jwt_team_routes_grant_pass_through(route: str, team_allowed_routes: Collection[str]) -> bool:
"""
Explicit paths and trailing-wildcard prefixes grant auth=true pass-through. Blanket grants never do:
a named route group like ``openai_routes`` is only ever compared as a path, and an entry that names
no path segment (``*``, ``/*``) is skipped.
"""
return any(
RouteChecks.route_matches_wildcard_pattern(route=route, pattern=allowed_route)
for allowed_route in team_allowed_routes
if allowed_route.rstrip("*").strip("/")
)
return routes.match_route(route, tuple(team_allowed_routes), "Jwt")
@staticmethod
def _jwt_team_allowed_routes(valid_token: UserAPIKeyAuth) -> Collection[str]:
@ -884,46 +397,16 @@ class RouteChecks:
valid_token: UserAPIKeyAuth,
jwt_team_allowed_routes: Collection[str] = (),
) -> None:
"""
Require an explicit grant for auth=true pass-through: ``allowed_passthrough_routes`` on the
key or team, or an explicit JWT ``team_allowed_routes`` entry. A key or team
``denied_passthrough_routes`` match blocks the route even when one of those grants it.
"""
RouteChecks._raise_if_passthrough_route_denied(route=route, valid_token=valid_token)
if RouteChecks.check_passthrough_route_access(route=route, user_api_key_dict=valid_token):
return
if RouteChecks.jwt_team_routes_grant_pass_through(route=route, team_allowed_routes=jwt_team_allowed_routes):
return
raise RouteChecks._auth_pass_through_denied_exception(route=route)
decision: Final = routes.passthrough_route(
routes.RouteContext(route),
route_policy_adapter.passthrough_facts(route, valid_token, jwt_team_allowed_routes, include_denied=True),
required=True,
)
route_policy_adapter.raise_route_denial(decision, route, token=valid_token)
@staticmethod
def check_passthrough_route_access(route: str, user_api_key_dict: UserAPIKeyAuth) -> bool:
"""
Check if route is a passthrough route.
Supports both exact match and prefix match.
"""
metadata: Final = user_api_key_dict.metadata
team_metadata: Final = user_api_key_dict.team_metadata or {}
if metadata is None and team_metadata is None:
return False
if "allowed_passthrough_routes" not in metadata and "allowed_passthrough_routes" not in team_metadata:
return False
if (
metadata.get("allowed_passthrough_routes") is None
and team_metadata.get("allowed_passthrough_routes") is None
):
return False
allowed_passthrough_routes: Final = (
metadata.get("allowed_passthrough_routes") or team_metadata.get("allowed_passthrough_routes") or []
)
# Check if route matches any allowed passthrough route (exact or prefix match)
for allowed_route in allowed_passthrough_routes:
if RouteChecks._route_matches_allowed_route(route=route, allowed_route=allowed_route):
return True
return False
return routes.passthrough_route(routes.RouteContext(route), route_policy_adapter.passthrough_facts(route, user_api_key_dict)).allowed
@staticmethod
def is_assistants_api_request(request: Request) -> bool:
@ -1004,117 +487,4 @@ class RouteChecks:
request_data: dict,
request: Request | None = None,
) -> None:
"""
Check access for PROXY_ADMIN_VIEW_ONLY role.
Admin Viewer follows a read-parity-with-Proxy-Admin rule: anything Proxy
Admin can read/list/get, Admin Viewer can read/list/get. The only
exclusions are cost-incurring inference routes (Playground, /chat/
completions, etc.) and any state-mutating request.
Implementation:
1. LLM/inference routes → 403 (cost-incurring).
2. Safe HTTP method (GET/HEAD/OPTIONS) → allow by default. This is
the read-parity guarantee — every new GET endpoint added anywhere
in the codebase is automatically readable by Admin Viewer
without needing to remember to add it to an allowlist.
3. Unsafe HTTP method (POST/PUT/PATCH/DELETE):
- Allow `/user/update` only when restricted to user_email.
- Allow `/user/password/change` (endpoint only writes the caller's own row).
- Block all explicit writes in `_ADMIN_VIEWER_BLOCKED_WRITE_ROUTES`.
- Otherwise allow only if the route is in admin_viewer_routes /
global_spend_tracking_routes (legacy explicit-allow set).
- Else 403.
"""
if RouteChecks.is_llm_api_route(route=route):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"user not allowed to access this OpenAI routes, role= {_user_role}",
)
# Check if this is a write operation on management routes
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.management_routes.value):
# For management routes, only allow read operations or specific allowed updates
if route == "/user/update":
# Check the Request params are valid for PROXY_ADMIN_VIEW_ONLY
if request_data is not None and isinstance(request_data, dict):
_params_updated: Final = request_data.keys()
for param in _params_updated:
if param != "user_email":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"user not allowed to access this route, role= {_user_role}. Trying to access: {route} and updating invalid param: {param}. only user_email can be updated",
)
elif RouteChecks.check_route_access(route=route, allowed_routes=_PROXY_ADMIN_VIEW_ONLY_BLOCKED_ROUTES) or (
route.startswith("/key/") and route.endswith(_PROXY_ADMIN_VIEW_ONLY_BLOCKED_KEY_SUFFIXES)
):
# Block write operations for PROXY_ADMIN_VIEW_ONLY
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"user not allowed to access this route, role= {_user_role}. Trying to access: {route}",
)
# Allow read operations on management routes (like /user/info, /team/info, /model/info)
method: Final = request.method.upper() if request is not None else "GET"
is_safe_method: Final = method in RouteChecks._SAFE_HTTP_METHODS
# ── Safe HTTP method: default-allow ──────────────────────────────
if is_safe_method:
return
# ── Unsafe HTTP method: explicit checks ──────────────────────────
# Allow `/user/update` for self-service email change.
if route == "/user/update":
if request_data is not None and isinstance(request_data, dict):
for param in request_data:
if param != "user_email":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=(
f"user not allowed to access this route, role= {_user_role}. "
f"Trying to access: {route} and updating invalid param: {param}. "
"only user_email can be updated"
),
)
return
# Self-service password change; the endpoint only writes the caller's own row.
if route == "/user/password/change":
return
# Self-service logout; the endpoint only revokes the caller's own session key.
if route == "/session/logout":
return
if RouteChecks.is_self_scoped_credential_route(route=route, request=request):
return
# Hard-block known write routes regardless of HTTP method (defensive
# — these are POSTs in practice, but pinning them here protects
# against future GET-shaped writes).
if RouteChecks.check_route_access(
route=route, allowed_routes=RouteChecks._ADMIN_VIEWER_BLOCKED_WRITE_ROUTES
) or (route.startswith("/key/") and route.endswith("/regenerate")):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"user not allowed to access this route, role= {_user_role}. Trying to access: {route}",
)
# Legacy explicit-allow sets (kept for routes that are POST but
# semantically read-only, e.g. /spend/calculate). Both admin_viewer_routes
# and global_spend_tracking_routes are reads/listings.
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.admin_viewer_routes.value):
return
if RouteChecks.check_route_access(route=route, allowed_routes=LiteLLMRoutes.global_spend_tracking_routes.value):
return
# NOTE: We intentionally do NOT fall back to allowing all
# `management_routes`. That set is a mix of reads (info/list — handled
# via the safe-method branch above) and writes (`/team/block`,
# `/team/permissions_update`, `/jwt/key/mapping/{new,update,delete}`,
# `/key/bulk_update`, `/key/{id}/reset_spend`). A blanket allow would
# let Admin Viewer POST these write endpoints — violating the
# "no writes, ever" rule. Default-deny instead.
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"user not allowed to access this route, role= {_user_role}. Trying to access: {route}",
)
return route_policy_adapter.check_viewer_route(route, _user_role, request_data, request)

View file

@ -0,0 +1,239 @@
from collections.abc import Collection, Iterable, Mapping
from dataclasses import replace
from typing import Final, Literal
from fastapi import HTTPException, Request
from pydantic import BaseModel, Field, TypeAdapter
from litellm._auth import routes
from litellm.proxy._types import LiteLLM_UserTable, LiteLLMRoutes, UserAPIKeyAuth
_STRINGS: Final = TypeAdapter(tuple[str, ...])
class _TokenFields(BaseModel, frozen=True):
allowed_routes: object = None
metadata: Mapping[str, object] | None = Field(default_factory=dict[str, object])
permissions: Mapping[str, object] | None = None
class _ProxyFields(BaseModel, frozen=True):
general_settings: Mapping[str, object]
premium_user: bool
def _allowed_routes(value: object) -> tuple[str, ...] | None:
return _STRINGS.validate_python(value) if isinstance(value, list) else None
def route_catalog() -> routes.RouteCatalog:
from litellm.proxy.agent_endpoints.auth.managed_authorization import (
_MANAGED_LIVE_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_MANAGED_MCP_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_MANAGED_MODEL_PATHS, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_MANAGED_MODEL_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_MANAGED_REALTIME_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
)
from litellm.proxy.auth.route_checks import (
_PROXY_ADMIN_VIEW_ONLY_BLOCKED_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_SELF_SCOPED_CREDENTIAL_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
_UNBILLED_ROUTES, # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
RouteChecks,
)
return routes.RouteCatalog(
groups={name: tuple(member.value) for name, member in LiteLLMRoutes.__members__.items()},
viewer_blocked=tuple(_PROXY_ADMIN_VIEW_ONLY_BLOCKED_ROUTES),
viewer_write_blocked=tuple(RouteChecks._ADMIN_VIEWER_BLOCKED_WRITE_ROUTES), # pyright: ignore[reportPrivateUsage] # read-only legacy catalog projection
self_credentials=_SELF_SCOPED_CREDENTIAL_ROUTES,
managed_models=tuple(_MANAGED_MODEL_ROUTES),
managed_paths=_MANAGED_MODEL_PATHS,
managed_realtime=tuple(_MANAGED_REALTIME_ROUTES),
managed_live=tuple(_MANAGED_LIVE_ROUTES),
managed_mcp=_MANAGED_MCP_ROUTES,
unbilled=tuple(_UNBILLED_ROUTES),
)
def route_context(route: str, method: str | None = None, *, registration: bool = False) -> routes.RouteContext:
if not registration:
return routes.RouteContext(route=route, method=method, catalog=route_catalog())
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import InitPassThroughEndpointHelpers
registered: Final = InitPassThroughEndpointHelpers.get_registered_pass_through_route(route=route, method=method)
return routes.RouteContext(
route=route,
method=method,
catalog=route_catalog(),
registered=InitPassThroughEndpointHelpers.is_registered_pass_through_route(route),
registered_auth=registered.get("auth") is True if registered is not None else None,
configured_eu_jev=InitPassThroughEndpointHelpers.has_configured_route_ignoring_trailing_slash(
"/eu_jev/v1/systemone"
),
)
def passthrough_facts(
route: str, token: UserAPIKeyAuth, jwt_team_routes: Collection[str] = (), *, include_denied: bool = False
) -> routes.PassThroughFacts:
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import InitPassThroughEndpointHelpers
metadata: Final = _TokenFields.model_validate(token, from_attributes=True).metadata or {}
return routes.PassThroughFacts(
key_allowed=_STRINGS.validate_python(metadata.get("allowed_passthrough_routes") or ()),
team_allowed=_STRINGS.validate_python((token.team_metadata or {}).get("allowed_passthrough_routes") or ()),
denied=(
*_STRINGS.validate_python(metadata.get("denied_passthrough_routes") or ()),
*_STRINGS.validate_python((token.team_metadata or {}).get("denied_passthrough_routes") or ()),
)
if include_denied
else (),
forwarded=InitPassThroughEndpointHelpers.forwarded_routes(route) if include_denied else (),
jwt_team_routes=tuple(jwt_team_routes),
)
def raise_route_denial(
decision: routes.RouteDecision,
route: str,
*,
token: UserAPIKeyAuth | None = None,
role: str | None = None,
user: LiteLLM_UserTable | None = None,
query_user_id: str | None = None,
) -> None:
from litellm.proxy.auth.route_checks import RouteChecks
match decision.denial:
case None:
return
case "AdminOnly":
RouteChecks._raise_admin_only_route_exception(user_obj=user, route=route) # pyright: ignore[reportPrivateUsage] # preserve the public exception envelope
case "PassThrough":
raise RouteChecks._auth_pass_through_denied_exception(route) # pyright: ignore[reportPrivateUsage] # preserve the public exception envelope
case "DeniedPassThrough":
raise RouteChecks.passthrough_route_denied_exception(route, decision.detail or "")
case "VirtualRoute":
raise HTTPException(
403,
f"Virtual key is not allowed to call this route. Only allowed to call routes: {_TokenFields.model_validate(token, from_attributes=True).allowed_routes if token is not None else None}. Tried to call route: {route}",
)
case "PasswordReset":
raise HTTPException(
403,
"This account's password must be changed before the session can be used: "
"it was either found in a known data breach or set by an admin. "
"Change it via POST /user/password/change (UI: /ui/change-password), then log in again.",
)
case "CustomAdmin":
raise HTTPException(403, f"user not allowed to access this route. Route={route} is an admin only route")
case "UserInfo":
raise HTTPException(
403,
f"key not allowed to access this user's info. user_id={query_user_id}, key's user_id={token.user_id if token is not None else None}",
)
case "ViewerInference":
raise HTTPException(403, f"user not allowed to access this OpenAI routes, role= {role}")
case "ViewerWrite":
raise HTTPException(403, f"user not allowed to access this route, role= {role}. Trying to access: {route}")
case "ViewerParameter":
raise HTTPException(
403,
f"user not allowed to access this route, role= {role}. Trying to access: {route} and updating invalid param: {decision.detail}. only user_email can be updated",
)
def check_virtual_route(route: str, token: UserAPIKeyAuth, request: Request | None) -> bool:
from litellm.proxy.auth.route_checks import RouteChecks
fields: Final = _TokenFields.model_validate(token, from_attributes=True)
facts: Final = routes.VirtualRouteFacts(
context=route_context(route, RouteChecks.get_request_method(request), registration=True),
allowed_routes=_allowed_routes(fields.allowed_routes),
passthrough=passthrough_facts(route, token),
password_reset_required=(fields.metadata or {}).get("password_reset_required") is True,
)
raise_route_denial(routes.virtual_route(facts), route, token=token)
return True
def check_viewer_route(route: str, role: str, request_data: Mapping[str, object], request: Request | None) -> None:
from litellm.proxy.auth.route_checks import RouteChecks
context: Final = route_context(route, RouteChecks.get_request_method(request), registration=True)
facts: Final = routes.ViewerFacts(
replace(context, method="") if request is not None and context.method is None else context, tuple(request_data)
)
raise_route_denial(routes.viewer_route(facts), route, role=role)
def check_non_admin_route(
user: LiteLLM_UserTable | None,
role: str | None,
route: str,
request: Request,
token: UserAPIKeyAuth,
request_data: Mapping[str, object],
) -> None:
from litellm.proxy import proxy_server
from litellm.proxy.auth.route_checks import RouteChecks
proxy: Final = _ProxyFields.model_validate(vars(proxy_server))
fields: Final = _TokenFields.model_validate(token, from_attributes=True)
singular: Final = request_data.get("organization_id")
plural: Final = request_data.get("organizations")
organization_ids: Final = (
*((singular,) if isinstance(singular, str) else ()),
*(_STRINGS.validate_python(plural) if isinstance(plural, list) else ()),
)
context: Final = route_context(route, RouteChecks.get_request_method(request), registration=True)
facts: Final = routes.NonAdminFacts(
viewer=routes.ViewerFacts(
replace(context, method="") if context.method is None else context, tuple(request_data)
),
role=role,
custom_admin_routes=_STRINGS.validate_python(proxy.general_settings.get("admin_only_routes") or ()),
premium=proxy.premium_user is True,
query_user_id=request.query_params.get("user_id") if route == "/user/info" else None,
token_user_id=token.user_id,
permissions=tuple(fields.permissions or ()),
organization_ids=organization_ids,
admin_organization_ids=tuple(
membership.organization_id
for membership in (user.organization_memberships or ())
if membership.user_role == "org_admin"
)
if user is not None
else (),
team_service_account=bool(token.is_team_service_account),
allowed_routes=_allowed_routes(fields.allowed_routes),
passthrough=passthrough_facts(route, token, RouteChecks._jwt_team_allowed_routes(token), include_denied=True), # pyright: ignore[reportPrivateUsage] # project legacy JWT team route metadata
)
raise_route_denial(
routes.non_admin_route(facts), route, token=token, role=role, user=user, query_user_id=facts.query_user_id
)
def classify(
route: str,
kind: Literal["Llm", "Unbilled", "Discovery", "SelfCredential", "Azure", "Managed"],
method: str | None = None,
) -> bool:
return routes.classify_route(route_context(route, method, registration=kind == "Llm"), kind)
def denied_passthrough(route: str, metadata_sources: Iterable[Mapping[str, object] | None]) -> str | None:
from itertools import chain
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import InitPassThroughEndpointHelpers
facts: Final = routes.PassThroughFacts(
denied=tuple(
chain.from_iterable(
_STRINGS.validate_python((source or {}).get("denied_passthrough_routes") or ())
for source in metadata_sources
)
),
forwarded=InitPassThroughEndpointHelpers.forwarded_routes(route),
)
return routes.denied_passthrough_route(route, facts).detail

View file

@ -38,6 +38,12 @@ def request_auth_select_api_key(keys: object) -> dict[str, str] | None: ...
def request_auth_select_websocket_api_key(keys: object) -> dict[str, str]: ...
def request_auth_scheme_credential(value: str) -> str | None: ...
def request_auth_litellm_header_token(value: str) -> str: ...
def request_auth_route_access(request: object) -> object: ...
def request_auth_org_route(facts: object) -> object: ...
def request_auth_org_admin(memberships: object, organizations: tuple[str, ...]) -> bool: ...
def request_auth_model_access(request: object) -> object: ...
def request_auth_model_groups(facts: object) -> object: ...
def request_auth_fallback_access(facts: object) -> object: ...
@final
class NativeClickHouseSpendConfig:

View file

@ -0,0 +1,85 @@
import re
from dataclasses import replace
from typing import Final
from litellm._auth.model_access import ModelAccessDecision, ModelAccessFacts
def _pattern(model: str, pattern: str) -> bool:
return "*" in pattern and re.match("^" + re.escape(pattern).replace(r"\*", ".*") + "$", model) is not None
def helper(model: str, facts: ModelAccessFacts, *, team_aliases: bool = True) -> bool:
ordinary: Final = tuple(grant for grant in facts.grants if grant != "all-team-models")
expanded: Final = tuple(dict.fromkeys((*ordinary, *facts.registry.names)))
grants: Final = (
(expanded or facts.grants)
if "all-team-models" in facts.grants and facts.team_id is not None and facts.registry.present
else facts.grants
)
record: Final = facts.registry.records.get(model)
groups: Final = record.access_groups if record is not None else ()
if facts.registry.present and any(grant in groups for grant in grants):
return True
filtered: Final = tuple(grant for grant in grants if grant not in groups)
if team_aliases and model in facts.aliases.team:
return True
if any(_pattern(model, grant) for grant in filtered):
return True
provider: Final = record.provider if record is not None else None
if (
provider is not None
and (provider.stripped_model != model or "/" not in model)
and any(_pattern(f"{provider.provider}/{provider.stripped_model}", grant) for grant in filtered)
):
return True
return not grants or "*" in filtered or "all-proxy-models" in filtered or model in filtered
def model_access(facts: ModelAccessFacts) -> ModelAccessDecision:
if facts.fallback_depth >= facts.max_depth:
return ModelAccessDecision("Depth")
if facts.is_list:
for model in facts.requested:
decision: Final = model_access(
replace(facts, requested=(model,), fallback_depth=facts.fallback_depth + 1, is_list=False)
)
if decision.kind != "Allow":
return replace(decision, model=model) if decision.kind == "Depth" else decision
return ModelAccessDecision("Allow")
for model in facts.requested:
after_team: Final = facts.aliases.team.get(model, model)
after_key: Final = facts.aliases.key.get(after_team, after_team)
after_global: Final = facts.aliases.global_.get(after_key, after_key)
dispatched: Final = facts.aliases.key.get(after_global, after_global)
key_applied: Final = after_key != after_team or dispatched != after_global
alias: Final = (
facts.aliases.global_.get(model) if model in facts.aliases.global_ else facts.registry.aliases.get(model)
)
parent: Final = facts.registry.compaction_parents.get(model)
potential: Final = (
(dispatched,)
if key_applied
else (model, *((parent,) if parent is not None else ()), *((alias,) if alias else ()))
)
if any(helper(candidate, facts) for candidate in potential):
continue
record: Final = facts.registry.records.get(model)
public: Final = (
record.deployment_public_name if record is not None and record.deployment_team == facts.team_id else None
)
owning: Final = (
(
*((public,) if public else ()),
*(alias for alias, target in facts.aliases.team.items() if target == model),
)
if not key_applied
and facts.registry.present
and facts.team_id is not None
and model.startswith(f"model_name_{facts.team_id}_")
else ()
)
if any(helper(candidate, facts, team_aliases=False) for candidate in owning):
continue
return ModelAccessDecision("Deny", model, facts.grants, facts.object_type)
return ModelAccessDecision("Allow")

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,62 @@
from dataclasses import replace
from typing import Final
import pytest
from litellm._auth.fallback_access import FallbackAuthorizationFacts, GroupedModelScope, fallback_authorization
from litellm._auth.model_access import ModelAccessFacts
_ALLOW: Final = ModelAccessFacts(("model",), ("model",), object_type="key")
_DENY: Final = replace(_ALLOW, grants=("other",))
_BASE: Final = FallbackAuthorizationFacts(GroupedModelScope(_ALLOW))
@pytest.mark.parametrize(
("facts", "kind"),
(
pytest.param(_BASE, "Allow", id="no-extra-ceilings"),
pytest.param(replace(_BASE, refuse_agent_keys=True, agent_id=""), "Deny", id="agent-presence-not-truthiness"),
pytest.param(
replace(_BASE, key=GroupedModelScope(_DENY, ("group",))), "ReadKeyGroups", id="key-groups-before-team"
),
pytest.param(
replace(_BASE, key=GroupedModelScope(_DENY, ("group",), ())), "Deny", id="empty-key-group-retains-denial"
),
pytest.param(
replace(_BASE, key=GroupedModelScope(_DENY, ("group",), ("model",))), "Allow", id="key-group-fallback"
),
pytest.param(
replace(_BASE, team=GroupedModelScope(_DENY, ("group",))), "ReadTeamGroups", id="team-group-fallback"
),
pytest.param(
replace(_BASE, team=GroupedModelScope(_DENY)), "ReadAssignedGroups", id="team-denial-asks-owned-key-grants"
),
pytest.param(
replace(_BASE, team=GroupedModelScope(_DENY), assigned_models=()),
"Deny",
id="empty-assigned-does-not-widen",
),
pytest.param(
replace(_BASE, team=GroupedModelScope(_DENY), assigned_models=("model",)),
"Allow",
id="assigned-overrides-team",
),
pytest.param(
replace(_BASE, embedded_team=_DENY, assigned_models=("model",)),
"Deny",
id="embedded-team-no-assigned-override",
),
pytest.param(replace(_BASE, member=_DENY), "Deny", id="member-ceiling"),
pytest.param(replace(_BASE, project=_DENY), "Deny", id="project-ceiling"),
),
)
def test_fallback_authorization_stage_order(facts: FallbackAuthorizationFacts, kind: str) -> None:
assert fallback_authorization(facts).kind == kind
def test_key_denial_wins_before_later_scopes() -> None:
decision: Final = fallback_authorization(
replace(_BASE, key=GroupedModelScope(_DENY), project=replace(_DENY, object_type="project"))
)
assert decision.denial is not None
assert decision.denial.object_type == "key"

View file

@ -0,0 +1,229 @@
from dataclasses import replace
from typing import Final
import pytest
from litellm._auth import model_access as native
from litellm._auth.model_access import (
ModelAccessFacts as Facts,
)
from litellm._auth.model_access import (
ModelAliases as Aliases,
)
from litellm._auth.model_access import (
ModelProvider as Provider,
)
from litellm._auth.model_access import (
ModelRecord as Record,
)
from litellm._auth.model_access import (
ModelRegistry as Registry,
)
from tests.unit._auth.support import model_reference as reference
_BASE: Final = Facts(("model",), object_type="key")
_CASES: Final = (
pytest.param(_BASE, "Allow", id="empty-is-unrestricted"),
pytest.param(replace(_BASE, grants=("model",)), "Allow", id="exact-grant"),
pytest.param(replace(_BASE, grants=("other",)), "Deny", id="denied-model"),
pytest.param(replace(_BASE, grants=("*",)), "Allow", id="global-wildcard"),
pytest.param(replace(_BASE, grants=("all-proxy-models",)), "Allow", id="proxy-sentinel"),
pytest.param(replace(_BASE, grants=("mo*",)), "Allow", id="prefix-wildcard"),
pytest.param(replace(_BASE, requested=("model\n",), grants=("mo*",)), "Allow", id="python-final-newline"),
pytest.param(replace(_BASE, requested=("mod\nel",), grants=("mo*l",)), "Deny", id="embedded-newline"),
pytest.param(
replace(_BASE, grants=("p/*",), registry=Registry(records={"model": Record(provider=Provider("model", "p"))})),
"Allow",
id="inferred-provider",
),
pytest.param(
replace(
_BASE,
requested=("p/model",),
grants=("q/*",),
registry=Registry(records={"p/model": Record(provider=Provider("model", "p"))}),
),
"Deny",
id="different-provider",
),
pytest.param(
replace(_BASE, grants=("other",), aliases=Aliases(team={"model": "target"})), "Allow", id="team-alias-exists"
),
pytest.param(
replace(_BASE, grants=("model",), aliases=Aliases(key={"model": "target"})),
"Deny",
id="key-alias-replaces-source",
),
pytest.param(
replace(_BASE, grants=("target",), aliases=Aliases(key={"model": "target"})), "Allow", id="key-target"
),
pytest.param(
replace(_BASE, grants=("target",), aliases=Aliases(global_={"model": "target"})), "Allow", id="global-target"
),
pytest.param(
replace(
_BASE,
grants=("target",),
aliases=Aliases(
team={"model": "middle"}, key={"middle": "third", "global": "target"}, global_={"third": "global"}
),
),
"Allow",
id="alias-order",
),
pytest.param(
replace(_BASE, grants=("target",), registry=Registry(present=True, aliases={"model": "target"})),
"Allow",
id="router-alias",
),
pytest.param(
replace(
_BASE,
grants=("target",),
registry=Registry(present=True, aliases={"model": "target"}),
aliases=Aliases(global_={"model": "wrong"}),
),
"Deny",
id="global-over-router",
),
pytest.param(
replace(_BASE, grants=("parent",), registry=Registry(compaction_parents={"model": "parent"})),
"Allow",
id="compaction-parent",
),
pytest.param(
replace(
_BASE,
grants=("group",),
registry=Registry(present=True, records={"model": Record(access_groups=("group",))}),
),
"Allow",
id="registry-group",
),
pytest.param(
replace(
_BASE,
grants=("other-group",),
registry=Registry(present=True, records={"model": Record(access_groups=("group",))}),
),
"Deny",
id="different-group",
),
pytest.param(
replace(_BASE, grants=("all-team-models",), team_id="team", registry=Registry(present=True, names=("model",))),
"Allow",
id="team-sentinel-expands",
),
pytest.param(
replace(_BASE, grants=("all-team-models",), team_id="team", registry=Registry(present=True)),
"Deny",
id="empty-registry-sentinel",
),
pytest.param(
replace(_BASE, grants=("all-team-models",), registry=Registry(present=True, names=("model",))),
"Deny",
id="team-sentinel-no-team",
),
pytest.param(
replace(
_BASE,
requested=("model_name_team_id",),
grants=("public",),
team_id="team",
registry=Registry(
present=True,
records={"model_name_team_id": Record(deployment_team="team", deployment_public_name="public")},
),
),
"Allow",
id="owning-team-public-name",
),
pytest.param(
replace(
_BASE,
requested=("model_name_team_id",),
grants=("public",),
team_id="team",
registry=Registry(
present=True,
records={"model_name_team_id": Record(deployment_team="other", deployment_public_name="public")},
),
),
"Deny",
id="public-name-wrong-team",
),
pytest.param(
replace(
_BASE,
requested=("model_name_team_id",),
grants=("other",),
team_id="team",
aliases=Aliases(team={"public": "model_name_team_id"}),
registry=Registry(present=True),
),
"Deny",
id="owning-alias-not-unconditional",
),
pytest.param(
replace(_BASE, requested=("model", "other"), grants=("model",), is_list=True),
"Deny",
id="all-list-items-required",
),
pytest.param(replace(_BASE, requested=(), grants=("other",), is_list=True), "Allow", id="empty-list"),
pytest.param(replace(_BASE, fallback_depth=5), "Depth", id="depth"),
pytest.param(replace(_BASE, fallback_depth=4, is_list=True), "Depth", id="list-depth"),
)
@pytest.mark.parametrize("policy", (reference.model_access, native.model_access), ids=("reference", "native"))
@pytest.mark.parametrize(("facts", "kind"), _CASES)
def test_model_policy_case_table(policy, facts: Facts, kind: str) -> None:
decision: Final = policy(facts)
assert decision.kind == kind
assert decision == reference.model_access(facts)
@pytest.mark.parametrize(
("groups", "models", "merge", "kind"),
(
((), None, False, "Deny"),
(("g",), None, False, "ReadGroups"),
(("g",), (), False, "Deny"),
(("g",), ("model",), False, "Allow"),
(("g",), ("model",), True, "Allow"),
(("g",), ("other",), False, "Deny"),
),
)
def test_group_fallback_waits_for_data(
groups: tuple[str, ...], models: tuple[str, ...] | None, merge: bool, kind: str
) -> None:
assert native.grouped_model_access(replace(_BASE, grants=("no",)), groups, models, merge=merge).kind == kind
@pytest.mark.parametrize(
("present", "grants", "kind"),
(
(False, ("no-default-models",), "Allow"),
(True, ("no-default-models", "model"), "NoDefaultModels"),
(True, (), "Allow"),
(True, ("other",), "Deny"),
),
)
def test_user_default_scope(present: bool, grants: tuple[str, ...], kind: str) -> None:
assert native.user_model_access(replace(_BASE, grants=grants), present=present).kind == kind
@pytest.mark.parametrize(
("managed", "ceilings", "kind"),
(
(None, (), "Allow"),
((), (), "NoAgentModels"),
(("model",), ((),), "EmptyAgentCeiling"),
(("model",), (("model",), ("other",)), "Deny"),
(("model",), (("model",),), "Allow"),
),
)
def test_agent_grants_are_intersected(
managed: tuple[str, ...] | None, ceilings: tuple[tuple[str, ...], ...], kind: str
) -> None:
assert native.agent_model_access(_BASE, managed, ceilings).kind == kind

View file

@ -0,0 +1,49 @@
from dataclasses import replace
from typing import Final
import pytest
from litellm._auth.model_groups import GroupLookup, GroupResources, ResourceGroupFacts, resource_group_decision
_BASE: Final = ResourceGroupFacts(True, True, True, ("group",), "team", "key")
@pytest.mark.parametrize(
("team_ids", "key_ids", "expected"),
(
(("team",), (), ("model",)),
((), ("key",), ("model",)),
(("other",), (), ()),
((), ("other",), ()),
((), (), ()),
),
)
def test_group_ownership_boundary(
team_ids: tuple[str, ...], key_ids: tuple[str, ...], expected: tuple[str, ...]
) -> None:
decision: Final = resource_group_decision(
replace(_BASE, loaded=(GroupLookup("Found", GroupResources(team_ids, key_ids, ("model", "model"))),))
)
assert (decision.kind, decision.resources) == ("Complete", expected)
@pytest.mark.parametrize("kind", ("Missing", "Failed"))
@pytest.mark.parametrize("check_db_only", (False, True))
@pytest.mark.parametrize("strict_errors", (False, True))
def test_strict_lookup_errors_stop_before_next_group(kind, check_db_only: bool, strict_errors: bool) -> None:
decision: Final = resource_group_decision(
replace(
_BASE,
group_ids=("first", "second"),
check_db_only=check_db_only,
strict_errors=strict_errors,
loaded=(GroupLookup(kind),),
)
)
assert (decision.kind, decision.index) == (("Raise", 0) if check_db_only or strict_errors else ("Read", 1))
@pytest.mark.parametrize("field", ("subject_present", "database_present", "cache_present"))
def test_unavailable_dependency_grants_nothing(field: str) -> None:
decision: Final = resource_group_decision(replace(_BASE, **{field: False}))
assert (decision.kind, decision.resources) == ("Complete", ())

View file

@ -0,0 +1,192 @@
from collections.abc import Callable
from dataclasses import dataclass
from typing import Final
import pytest
from fastapi import HTTPException, Request
from litellm._auth import routes
from litellm.proxy._types import LiteLLMRoutes, UserAPIKeyAuth
from litellm.proxy.auth.route_checks import RouteChecks
from litellm.proxy.auth.route_policy_adapter import route_context
from tests.unit._auth.support.route_reference import RouteChecks as ReferenceRoutes
@dataclass(frozen=True, slots=True)
class RouteResult:
allowed: bool
status: int | None = None
detail: object = None
def outcome(call: Callable[[], object]) -> RouteResult:
try:
result: Final = call()
return RouteResult(result is not False)
except HTTPException as error:
return RouteResult(False, error.status_code, error.detail)
_ROUTES: Final = tuple(
dict.fromkeys(
(
"/unknown",
"/chat/completions",
"/v1/mcp/server",
"/v1/mcp/server/id",
"/v1/mcp/server/id/more",
"/auto_router/session",
"/models",
"/v1/responses/id",
"/agents",
"/v1/agents/id",
"/key/id/regenerate",
"/user/update",
"/user/password/change",
"/session/logout",
"/user/info",
"/organization/new",
"/team/new",
"/openai/deployments/model/versions/chat/completions",
"/engines/model/chat/completions",
"/foo/count_tokens",
"/v1beta/models/model:countTokens",
"/unknown\n",
"/key/generate",
"/key/list",
"/session/list",
)
)
)
@pytest.mark.parametrize("route", _ROUTES)
@pytest.mark.parametrize("method", (None, "GET", "POST", "DELETE", "HEAD", "OPTIONS"))
def test_route_classifications_match_reference(route: str, method: str | None) -> None:
request: Final = Request({"type": "http", "method": method or "GET", "path": route, "headers": []})
assert RouteChecks.is_llm_api_route(route) == ReferenceRoutes.is_llm_api_route(route)
assert RouteChecks.is_unbilled_route(route) == ReferenceRoutes.is_unbilled_route(route)
assert RouteChecks.is_self_scoped_credential_route(
route, request
) == ReferenceRoutes.is_self_scoped_credential_route(route, request)
assert RouteChecks._is_get_mcp_server_discovery_route(
route, request
) == ReferenceRoutes._is_get_mcp_server_discovery_route(route, request)
@pytest.mark.parametrize("route", _ROUTES)
@pytest.mark.parametrize(
"allowed",
(
None,
(),
("llm_api_routes",),
("llm_api_routes_without_mcp",),
("management_routes",),
("/v1/*",),
("/user",),
("*",),
("/no",),
),
)
@pytest.mark.parametrize("method", ("GET", "POST"))
def test_virtual_route_allow_and_denial_envelope(route: str, allowed: tuple[str, ...] | None, method: str) -> None:
request: Final = Request({"type": "http", "method": method, "path": route, "headers": []})
token: Final = UserAPIKeyAuth(allowed_routes=list(allowed) if allowed is not None else None)
assert outcome(lambda: RouteChecks.is_virtual_key_allowed_to_call_route(route, token, request)) == outcome(
lambda: ReferenceRoutes.is_virtual_key_allowed_to_call_route(route, token, request)
)
@pytest.mark.parametrize("route", _ROUTES)
@pytest.mark.parametrize("method", ("GET", "POST", "PATCH", "HEAD"))
@pytest.mark.parametrize("keys", ((), ("user_email",), ("user_id", "user_email")))
def test_viewer_role_denial_order_and_envelope(route: str, method: str, keys: tuple[str, ...]) -> None:
request: Final = Request({"type": "http", "method": method, "path": route, "headers": []})
data: Final = {key: "value" for key in keys}
assert outcome(
lambda: RouteChecks._check_proxy_admin_viewer_access(
route=route, _user_role="proxy_admin_viewer", request_data=data, request=request
)
) == outcome(
lambda: ReferenceRoutes._check_proxy_admin_viewer_access(
route=route, _user_role="proxy_admin_viewer", request_data=data, request=request
)
)
@pytest.mark.parametrize("group", tuple(LiteLLMRoutes))
def test_full_catalog_classification(group: LiteLLMRoutes) -> None:
assert tuple(RouteChecks.is_llm_api_route(route) for route in group.value) == tuple(
ReferenceRoutes.is_llm_api_route(route) for route in group.value
)
@pytest.mark.parametrize(
("route", "pattern"),
(
("/a/id", "/a/{id}"),
("/a/x/y", "/a/{id:path}"),
("/a/x/y:action", "/a/{id:path}:action"),
("/a/x\ny", "/a/{id:path}"),
("/a/id\n", "/a/{id}"),
("/a/b", "/a/*"),
("/ab", "/a"),
("/a", ""),
("/a", "/"),
("/a/id:action", "/a/{id}:action"),
("/a/id", "/a/{id:path}"),
),
)
def test_route_pattern_modes(route: str, pattern: str) -> None:
assert RouteChecks._route_matches_pattern(route, pattern) == ReferenceRoutes._route_matches_pattern(route, pattern)
assert RouteChecks._route_matches_allowed_route(route, pattern) == ReferenceRoutes._route_matches_allowed_route(
route, pattern
)
assert RouteChecks.route_matches_wildcard_pattern(route, pattern) == ReferenceRoutes.route_matches_wildcard_pattern(
route, pattern
)
assert RouteChecks._route_matches_denied_route(route, pattern) == ReferenceRoutes._route_matches_denied_route(
route, pattern
)
@pytest.mark.parametrize(
"route",
(
"/agents",
"/v1/agents",
"/chat/completions",
"/v1/chat/completions",
"/v1/responses/id",
"/realtime",
"/v1/realtime",
"/v1/mcp/server/id",
"/mcp/foo",
"/user/info",
"/v1beta/models/x:generateContent",
),
)
@pytest.mark.parametrize("method", (None, "GET", "HEAD", "POST", "DELETE", "get"))
def test_managed_actor_route_methods(route: str, method: str | None) -> None:
from litellm.proxy.agent_endpoints.auth.managed_authorization import managed_agent_route_allowed
assert routes.classify_route(route_context(route, method), "Managed") == managed_agent_route_allowed(route, method)
@pytest.mark.parametrize(
("key", "team", "jwt", "denied", "expected"),
(
(("/p",), (), (), (), True),
((), ("/p",), (), (), True),
(("/q",), ("/p",), (), (), False),
((), (), ("/p/*",), (), True),
((), (), ("*",), (), False),
(("/p",), (), (), ("/p",), False),
),
)
def test_passthrough_precedence(
key: tuple[str, ...], team: tuple[str, ...], jwt: tuple[str, ...], denied: tuple[str, ...], expected: bool
) -> None:
facts: Final = routes.PassThroughFacts(key, team, denied, ("/p/resource",), jwt)
assert routes.passthrough_route(routes.RouteContext("/p/resource"), facts, required=True).allowed == expected