The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]
Python ai-gatewayanthropicazure-openaibedrockgatewaylangchainlitellmllmllm-gatewayllmopsmcp-gatewayopenaiopenai-proxyrustrust-aivertex-ai
use axum::{
extract::{FromRequestParts, MatchedPath, Request, State},
http::{header::AUTHORIZATION, request::Parts},
middleware::Next,
response::Response,
};
use litellm_auth_types::SecretValue;
use crate::{AccessRequest, Auth, AuthenticatedRequest, Credential, Error};
pub trait CredentialExtractor: Send + Sync {
fn extract(&self, parts: &Parts) -> Result<Credential, Error>;
}
pub struct Bearer;
impl CredentialExtractor for Bearer {
fn extract(&self, parts: &Parts) -> Result<Credential, Error> {
bearer(parts).map(Credential::Token)
}
}
fn bearer(parts: &Parts) -> Result<SecretValue, Error> {
let mut values = parts.headers.get_all(AUTHORIZATION).iter();
let value = values.next().ok_or(Error::InvalidToken)?;
if values.next().is_some() {
return Err(Error::InvalidToken);
}
let token = value
.to_str()
.ok()
.and_then(|value| value.strip_prefix("Bearer "))
.map(str::trim)
.filter(|value| !value.is_empty() && !value.bytes().any(|byte| byte.is_ascii_whitespace()))
.ok_or(Error::InvalidToken)?;
Ok(SecretValue::new(token))
}
pub async fn authenticate(
State(auth): State<Auth>,
request: Request,
next: Next,
) -> Result<Response, Error> {
let (mut parts, body) = request.into_parts();
let identity = auth.authenticate_parts(&parts).await?;
let route = AccessRequest::Route {
method: parts.method.to_string(),
path: parts
.extensions
.get::<MatchedPath>()
.map_or(parts.uri.path(), MatchedPath::as_str)
.into(),
};
identity
.authorize(route.clone())
.await?
.consume(identity.caller(), &route)?;
parts.extensions.insert(identity);
Ok(next.run(Request::from_parts(parts, body)).await)
}
impl<S: Send + Sync> FromRequestParts<S> for AuthenticatedRequest {
type Rejection = Error;
async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Error> {
parts
.extensions
.get::<Self>()
.cloned()
.ok_or(Error::MissingIdentity)
}
}
pub struct RequireMasterKey;
impl FromRequestParts<Auth> for RequireMasterKey {
type Rejection = Error;
async fn from_request_parts(parts: &mut Parts, state: &Auth) -> Result<Self, Error> {
state.validate().await?;
let identity = state
.authenticate_request(&Credential::Token(bearer(parts)?), parts)
.await?;
if identity.caller().authentication().method != crate::AuthenticationMethod::MasterKey {
return Err(Error::InvalidToken);
}
parts.extensions.insert(identity);
Ok(Self)
}
}