From a13ef695ec29be7943c0fd5adbdb49d2cdb02d23 Mon Sep 17 00:00:00 2001 From: Yujong Lee Date: Fri, 4 Sep 2026 11:49:03 -0700 Subject: [PATCH] refactor(ocr): integrate shared authentication primitives --- litellm-rust/crates/core/Cargo.toml | 5 +- litellm-rust/crates/core/src/auth.rs | 135 ++++++++++++++++-- .../core/src/providers/azure_ai/auth.rs | 9 +- .../core/src/providers/vertex_ai/auth.rs | 9 +- .../src/python_token_provider.rs | 15 +- 5 files changed, 146 insertions(+), 27 deletions(-) diff --git a/litellm-rust/crates/core/Cargo.toml b/litellm-rust/crates/core/Cargo.toml index 465e15ea16b..0aaf66a26ce 100644 --- a/litellm-rust/crates/core/Cargo.toml +++ b/litellm-rust/crates/core/Cargo.toml @@ -7,6 +7,8 @@ repository.workspace = true [dependencies] async-trait = "0.1" +azure_core = "1.0.0" +azure_identity = { version = "1.0.0", features = ["tokio"] } base64.workspace = true google-cloud-auth = { version = "=1.15.0", default-features = false, features = ["default-rustls-provider"] } rand.workspace = true @@ -14,9 +16,8 @@ reqwest.workspace = true serde.workspace = true serde_json.workspace = true thiserror.workspace = true -tokio = { workspace = true, features = ["net", "sync", "time"] } +tokio = { workspace = true, features = ["net", "rt", "sync", "time"] } tracing.workspace = true -tokio = { workspace = true, features = ["sync", "rt"] } tracing-subscriber = { workspace = true, optional = true } sha2.workspace = true aws-config = { version = "1.9.0", default-features = false, features = ["rustls", "rt-tokio"], optional = true } diff --git a/litellm-rust/crates/core/src/auth.rs b/litellm-rust/crates/core/src/auth.rs index b65285c3991..8b9d5470797 100644 --- a/litellm-rust/crates/core/src/auth.rs +++ b/litellm-rust/crates/core/src/auth.rs @@ -57,6 +57,96 @@ impl fmt::Debug for SecretString { } } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum AuthHeaderKind { + Bearer, + Header(&'static str), +} + +impl AuthHeaderKind { + pub fn header_name(self) -> &'static str { + match self { + Self::Bearer => "authorization", + Self::Header(name) => name, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum ResolvedAuth { + Bearer(SecretString), + Header { + name: &'static str, + value: SecretString, + }, +} + +impl ResolvedAuth { + pub fn from_credential(kind: AuthHeaderKind, credential: impl Into) -> Self { + let credential = SecretString::new(credential); + match kind { + AuthHeaderKind::Bearer => Self::Bearer(credential), + AuthHeaderKind::Header(name) => Self::Header { + name, + value: credential, + }, + } + } + + pub fn header_name(&self) -> &'static str { + match self { + Self::Bearer(_) => "authorization", + Self::Header { name, .. } => name, + } + } + + pub fn credential_header(&self) -> (String, String) { + match self { + Self::Bearer(token) => ( + "Authorization".to_string(), + format!("Bearer {}", token.expose()), + ), + Self::Header { name, value } => ((*name).to_string(), value.expose().to_string()), + } + } + + pub fn from_header(kind: AuthHeaderKind, value: &str) -> Option { + match kind { + AuthHeaderKind::Bearer => value + .trim() + .split_once(char::is_whitespace) + .filter(|(scheme, token)| { + scheme.eq_ignore_ascii_case("bearer") && !token.trim().is_empty() + }) + .map(|(_, token)| Self::Bearer(SecretString::new(token.trim()))), + AuthHeaderKind::Header(name) if !value.trim().is_empty() => Some(Self::Header { + name, + value: SecretString::new(value), + }), + AuthHeaderKind::Header(_) => None, + } + } + + pub fn apply_preserving_existing( + &self, + mut headers: Vec<(String, String)>, + ) -> Vec<(String, String)> { + if !crate::http_utils::has_header(&headers, self.header_name()) { + headers.push(self.credential_header()); + } + headers + } + + pub fn apply_replacing_existing( + &self, + mut headers: Vec<(String, String)>, + ) -> Vec<(String, String)> { + headers.retain(|(name, _)| !name.eq_ignore_ascii_case(self.header_name())); + headers.push(self.credential_header()); + headers + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum AuthErrorKind { MissingCredential, @@ -103,9 +193,11 @@ pub struct TokenLease { pub expires_at: Instant, } +pub type ExpiringToken = TokenLease; + #[async_trait] pub trait TokenProvider: Send + Sync { - async fn token(&self) -> Result; + async fn token(&self) -> Result; } #[derive(Clone, PartialEq, Eq, Hash)] @@ -174,11 +266,11 @@ impl TokenCache { .clone() } - pub async fn token( + pub async fn token_cached( self: &Arc, key: TokenCacheKey, provider: Arc, - ) -> Result { + ) -> Result { let entry = self.entry(key).await; let now = self.clock.now(); let cached = entry.lease.read().await.clone(); @@ -213,7 +305,7 @@ impl TokenCache { &self, entry: Arc, provider: Arc, - ) -> Result { + ) -> Result { let _guard = entry.refresh.lock().await; let now = self.clock.now(); if let Some(lease) = entry.lease.read().await.as_ref() @@ -223,10 +315,8 @@ impl TokenCache { } let lease = provider.token().await?; if lease.expires_at <= self.clock.now() { - return Err(AuthError::new( - AuthErrorKind::CredentialUnavailable, - "expired_token", - "credential provider returned an expired token", + return Err(Error::Auth( + "credential provider returned an expired token".to_string(), )); } let token = lease.token.clone(); @@ -239,6 +329,31 @@ impl TokenCache { *entry.lease.write().await = None; } } + + pub async fn token( + &self, + key: String, + provider: &dyn TokenProvider, + ) -> Result { + let key = TokenCacheKey::fingerprint([key.as_bytes()]); + let entry = self.entry(key).await; + let _guard = entry.refresh.lock().await; + let now = self.clock.now(); + if let Some(lease) = entry.lease.read().await.as_ref() + && lease.expires_at.saturating_duration_since(now) > self.refresh_before + { + return Ok(lease.token.clone()); + } + let lease = provider.token().await?; + if lease.expires_at <= self.clock.now() { + return Err(Error::Auth( + "credential provider returned an expired token".to_string(), + )); + } + let token = lease.token.clone(); + *entry.lease.write().await = Some(lease); + Ok(token) + } } #[derive(Clone)] @@ -393,7 +508,7 @@ mod tests { #[async_trait] impl TokenProvider for CountingProvider { - async fn token(&self) -> Result { + async fn token(&self) -> Result { let call = self.calls.fetch_add(1, Ordering::SeqCst) + 1; Ok(TokenLease { token: SecretString::new(format!("token-{call}")), @@ -415,7 +530,7 @@ mod tests { let cache = cache.clone(); let provider = provider.clone(); let key = key.clone(); - tokio::spawn(async move { cache.token(key, provider).await.unwrap() }) + tokio::spawn(async move { cache.token_cached(key, provider).await.unwrap() }) }); for request in requests { assert_eq!(request.await.unwrap().expose(), "token-1"); diff --git a/litellm-rust/crates/core/src/providers/azure_ai/auth.rs b/litellm-rust/crates/core/src/providers/azure_ai/auth.rs index d8e037bf556..695fe43d065 100644 --- a/litellm-rust/crates/core/src/providers/azure_ai/auth.rs +++ b/litellm-rust/crates/core/src/providers/azure_ai/auth.rs @@ -15,8 +15,8 @@ use sha2::{Digest, Sha256}; use crate::Error; use crate::auth::{ - AuthHeaderKind, Environment, ExpiringToken, ResolvedAuth, SecretString, TokenCache, - TokenProvider, + AuthHeaderKind, Environment, ExpiringToken, ResolvedAuth, SecretString, SystemClock, + TokenCache, TokenProvider, }; use crate::constants::{AZURE_AUTH_DEFAULT_SCOPE, AZURE_AUTH_TOKEN_REFRESH_WINDOW_SECS}; @@ -417,7 +417,10 @@ pub async fn resolve_azure_auth(input: AzureAuthInput<'_>) -> Result) -> PyResult> #[async_trait] impl TokenProvider for PythonTokenProvider { - async fn token(&self) -> Result { - self.resolve().await.map_err(|_| { - AuthError::new( - AuthErrorKind::ExternalProviderFailed, - "python_token_provider_failed", - "Python token provider failed", - ) - }) + async fn token(&self) -> Result { + self.resolve() + .await + .map_err(|_| Error::Auth("Python token provider failed".to_string())) } }