refactor(auth): use typed errors and HTTP header maps

This commit is contained in:
Yujong Lee 2026-09-09 15:13:13 -07:00
parent b3b369c8ef
commit a89189eb9f
26 changed files with 497 additions and 254 deletions

View file

@ -271,7 +271,10 @@ fn core_error_kind(error: &Error) -> &'static str {
match error {
Error::Auth(_) => "AuthError",
Error::InvalidProvider(_) => "InvalidProvider",
Error::InvalidRequest(_) => "InvalidRequest",
Error::InvalidRequest(_)
| Error::InvalidHeaderType { .. }
| Error::InvalidHeaderName
| Error::InvalidHeaderValue { .. } => "InvalidRequest",
Error::InvalidType { .. } => "InvalidType",
Error::MissingField(_) => "MissingField",
Error::Http { .. } => "HttpError",

View file

@ -2,6 +2,8 @@ use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use futures_util::stream::{SplitSink, SplitStream};
use futures_util::{Sink, SinkExt, Stream, StreamExt};
use tokio::net::TcpStream;
use tokio::sync::Mutex;
use tokio_tungstenite::tungstenite::Message;
@ -9,18 +11,16 @@ use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::http::HeaderValue;
use tokio_tungstenite::tungstenite::http::header::{AUTHORIZATION, HeaderName};
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
use futures_util::stream::{SplitSink, SplitStream};
use futures_util::{Sink, SinkExt, Stream, StreamExt};
use litellm_core::providers::openai::responses::transformation::OPENAI_RESPONSES_WS_CONFIG;
use litellm_core::responses::types::ResponsesWsEvent;
use litellm_core::responses::websocket::ResponsesWebSocketProviderConfig;
use litellm_core::{AuthError, Error};
use crate::io::tls::connect_upstream;
use crate::constants::{
DEFAULT_RESPONSES_WS_CONNECT_TIMEOUT_SECS, DEFAULT_RESPONSES_WS_IDLE_TIMEOUT_SECS,
};
use crate::io::tls::connect_upstream;
const OPENAI_API_KEY_ENV: &str = "OPENAI_API_KEY";
const MISSING_KEY_MESSAGE: &str = "Missing OpenAI API Key - a Responses WebSocket call is being made but no key was passed via params or the OPENAI_API_KEY environment variable";

View file

@ -1,6 +1,8 @@
use std::net::IpAddr;
use std::time::{Duration, Instant};
use reqwest::header::HeaderMap;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use litellm_core::error::Error;
@ -24,22 +26,8 @@ pub(super) fn truncate_error_body(body: &str) -> String {
pub(super) fn string_headers(
extra_headers: Option<Map<String, Value>>,
) -> Result<Vec<(String, String)>, Error> {
extra_headers
.unwrap_or_default()
.into_iter()
.map(|(key, value)| {
value
.as_str()
.map(|value| (key.clone(), value.to_string()))
.ok_or_else(|| {
Error::InvalidRequest(format!(
"OCR extra_headers.{key} must be a string, got {}",
litellm_core::error::json_type_name(&value)
))
})
})
.collect()
) -> Result<HeaderMap, Error> {
litellm_core::http_utils::header_map("OCR", extra_headers)
}
fn document_url_field(document: &Value) -> Result<Option<(&str, &str)>, Error> {
@ -306,7 +294,7 @@ fn operation_status(response_json: &Value) -> Result<&str, Error> {
pub(super) async fn poll_document_intelligence(
operation_url: &str,
original_url: &str,
headers: &[(String, String)],
headers: &HeaderMap,
timeout: Option<Duration>,
) -> Result<Value, Error> {
if !same_origin(operation_url, original_url) {
@ -328,10 +316,8 @@ pub(super) async fn poll_document_intelligence(
}
let mut request_builder = http_client().get(operation_url);
for (key, value) in headers {
if key.eq_ignore_ascii_case("ocp-apim-subscription-key") {
request_builder = request_builder.header(key, value);
}
if let Some(value) = headers.get("ocp-apim-subscription-key") {
request_builder = request_builder.header("ocp-apim-subscription-key", value);
}
let response = request_builder
.send()
@ -446,8 +432,8 @@ mod tests {
.clone();
assert_eq!(
string_headers(Some(headers)).expect("string headers accepted"),
vec![("x-trace-id".to_string(), "trace-1".to_string())]
string_headers(Some(headers)).expect("string headers accepted")["x-trace-id"],
"trace-1"
);
}
@ -463,9 +449,11 @@ mod tests {
let err = string_headers(Some(headers)).expect_err("non-string header rejected");
assert_eq!(
err,
Error::InvalidRequest(
"OCR extra_headers.x-retry-count must be a string, got number".to_string()
)
Error::InvalidHeaderType {
context: "OCR",
name: "x-retry-count".into(),
actual: "number"
}
);
}
}

View file

@ -14,10 +14,10 @@ pub(crate) async fn execute_ocr_provider_call(
hooks: &OcrLifecycleHooks,
) -> Result<Value, Error> {
let request = hooks.prepare_provider_request(request).await?;
let mut request_builder = http_client().post(&request.url).json(&request.body);
for (key, value) in &request.upstream_headers {
request_builder = request_builder.header(key, value);
}
let mut request_builder = http_client()
.post(&request.url)
.headers(request.upstream_headers.clone())
.json(&request.body);
if let Some(duration) = request.timeout {
request_builder = request_builder.timeout(duration);
}

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use litellm_core::call_lifecycle::{CallLifecycleContext, CallLifecycleHooks, CallLifecycleTiming};
use litellm_core::error::Error;
use litellm_core::ocr::prepare::map_ocr_params;
@ -192,7 +194,7 @@ async fn upload_reducto_document(
document: &Value,
api_base: Option<&str>,
timeout: Option<std::time::Duration>,
upstream_headers: &[(String, String)],
upstream_headers: &HeaderMap,
) -> Result<Value, Error> {
let source = extract_document_source(document)?;
let Some(upload) = build_upload_request(source, api_base) else {
@ -203,14 +205,13 @@ async fn upload_reducto_document(
.mime_str(&upload.mime_type)
.map_err(|error| Error::InvalidRequest(error.to_string()))?;
let form = reqwest::multipart::Form::new().part("file", part);
let mut request_builder = http_client().post(upload.url).multipart(form);
for (name, value) in upstream_headers {
if !name.eq_ignore_ascii_case("content-type")
&& !name.eq_ignore_ascii_case("content-length")
{
request_builder = request_builder.header(name, value);
}
}
let mut headers = upstream_headers.clone();
headers.remove(reqwest::header::CONTENT_TYPE);
headers.remove(reqwest::header::CONTENT_LENGTH);
let mut request_builder = http_client()
.post(upload.url)
.headers(headers)
.multipart(form);
if let Some(timeout) = timeout {
request_builder = request_builder.timeout(timeout);
}
@ -381,7 +382,10 @@ fn core_error_kind(error: &Error) -> &'static str {
match error {
Error::Auth(_) => "AuthError",
Error::InvalidProvider(_) => "InvalidProvider",
Error::InvalidRequest(_) => "InvalidRequest",
Error::InvalidRequest(_)
| Error::InvalidHeaderType { .. }
| Error::InvalidHeaderName
| Error::InvalidHeaderValue { .. } => "InvalidRequest",
Error::InvalidType { .. } => "InvalidType",
Error::MissingField(_) => "MissingField",
Error::Http { .. } => "HttpError",

View file

@ -115,8 +115,9 @@ mod tests {
let prepared = prepare_ocr_call(request);
assert!(
matches!(prepared.request.config, Err(Error::Auth(AuthError::InvalidConfiguration(message))) if message.contains("tenant_id"))
);
assert!(matches!(
prepared.request.config,
Err(Error::Auth(AuthError::InvalidAzureConfigType { name })) if name == "tenant_id"
));
}
}

View file

@ -1,6 +1,8 @@
use std::sync::Arc;
use std::time::Duration;
use reqwest::header::HeaderMap;
use litellm_core::call_lifecycle::{CallLifecycleContext, CallLifecycleRequest};
use litellm_core::ocr::transformation::OcrProviderConfig;
use litellm_core::ocr::types::OcrAuthInputs;
@ -56,6 +58,6 @@ pub(crate) struct ProviderOcrRequest {
pub(crate) url: String,
pub(crate) body: Value,
pub(crate) optional_params: Map<String, Value>,
pub(crate) upstream_headers: Vec<(String, String)>,
pub(crate) upstream_headers: HeaderMap,
pub(crate) timeout: Option<Duration>,
}

View file

@ -113,6 +113,9 @@ impl IntoResponse for MessagesRouteError {
| Error::Network(_)
| Error::Connect(_)
| Error::InvalidResponse(_)
| Error::InvalidHeaderType { .. }
| Error::InvalidHeaderName
| Error::InvalidHeaderValue { .. }
| Error::InvalidType { .. }
| Error::MissingField(_) => (
StatusCode::BAD_GATEWAY,

View file

@ -245,7 +245,7 @@ fn build_credential(
NativeAzureRequest::DeveloperTools { .. } => DeveloperToolsCredential::new(None)
.map(|credential| credential as Arc<dyn TokenCredential>),
}
.map_err(|error| AuthError::InvalidConfiguration(error.to_string()))
.map_err(|error| AuthError::AzureCredentialConfiguration(error.to_string()))
}
fn client_options(

View file

@ -48,9 +48,7 @@ impl AzureAuthService {
AzureCredentialPlan::Caller(caller) => {
let credential = caller.acquire().await?;
if credential.secret().expose().is_empty() {
return Err(AuthError::Caller(
"Azure AD token provider returned an empty token".to_string(),
));
return Err(AuthError::EmptyAzureAdToken);
}
Ok(Some(credential))
}
@ -63,11 +61,7 @@ impl AzureAuthService {
} => {
let assertion = resolve_reference(inputs, env_lookup, &reference)
.await?
.ok_or_else(|| {
AuthError::Acquisition(
"Azure OIDC reference did not resolve to a value".to_string(),
)
})?;
.ok_or(AuthError::UnresolvedOidcReference)?;
self.native
.acquire(NativeAzureRequest::ClientAssertion {
tenant_id,
@ -115,9 +109,7 @@ pub(crate) fn select_auth_plan(
let selector = configured_string(&inputs.azure_credential, AZURE_CREDENTIAL_ENV, env_lookup)
.map(|value| value.parse::<AzureCredentialType>())
.transpose()
.map_err(|_| {
AuthError::InvalidConfiguration("invalid Azure credential selector".to_string())
})?;
.map_err(|_| AuthError::InvalidAzureCredentialSelector)?;
let federated_token_file = configured_string(
&inputs.federated_token_file,
AZURE_FEDERATED_TOKEN_FILE_ENV,
@ -199,9 +191,7 @@ fn select_native_plan(
});
match selected {
AzureCredentialType::ClientSecretCredential => Err(AuthError::InvalidConfiguration(
"ClientSecretCredential requires tenant_id, client_id, and client_secret".to_string(),
)),
AzureCredentialType::ClientSecretCredential => Err(AuthError::MissingClientSecretFields),
AzureCredentialType::WorkloadIdentityCredential => Ok(AzureCredentialPlan::Native(
workload_request(tenant_id, client_id, federated_token_file, scope, authority)?,
)),
@ -273,21 +263,9 @@ fn workload_request(
authority: Option<String>,
) -> Result<NativeAzureRequest, AuthError> {
Ok(NativeAzureRequest::WorkloadIdentity {
tenant_id: tenant_id.ok_or_else(|| {
AuthError::InvalidConfiguration(
"WorkloadIdentityCredential requires tenant_id".to_string(),
)
})?,
client_id: client_id.ok_or_else(|| {
AuthError::InvalidConfiguration(
"WorkloadIdentityCredential requires client_id".to_string(),
)
})?,
token_file_path: token_file_path.ok_or_else(|| {
AuthError::InvalidConfiguration(
"WorkloadIdentityCredential requires azure_federated_token_file".to_string(),
)
})?,
tenant_id: tenant_id.ok_or(AuthError::MissingWorkloadTenantId)?,
client_id: client_id.ok_or(AuthError::MissingWorkloadClientId)?,
token_file_path: token_file_path.ok_or(AuthError::MissingWorkloadTokenFile)?,
scope,
authority,
})
@ -334,11 +312,10 @@ async fn resolve_reference(
.map_or(CredentialLookup::Missing, CredentialLookup::Found),
CredentialRef::None => return Ok(None),
CredentialRef::File(_) | CredentialRef::Request(_) | CredentialRef::Host(_) => {
let resolver = inputs.credential_resolver.as_ref().ok_or_else(|| {
AuthError::InvalidConfiguration(
"credential reference requires a host credential resolver".to_string(),
)
})?;
let resolver = inputs
.credential_resolver
.as_ref()
.ok_or(AuthError::MissingCredentialResolver)?;
resolver.resolve(reference).await?
}
};
@ -353,34 +330,30 @@ fn oidc_reference(token: &Option<SecretValue>) -> Result<Option<CredentialRef>,
return Ok(None);
};
if let Some(name) = value.strip_prefix("oidc/env/") {
return non_empty_reference(name, "OIDC environment reference")
return non_empty_reference(name, AuthError::EmptyOidcEnvironmentReference)
.map(CredentialRef::Env)
.map(Some);
}
if let Some(name) = value.strip_prefix("oidc/env_path/") {
return non_empty_reference(name, "OIDC environment path reference")
return non_empty_reference(name, AuthError::EmptyOidcEnvironmentPathReference)
.map(|name| CredentialRef::File(CredentialFileRef::EnvironmentVariable(name)))
.map(Some);
}
if let Some(path) = value.strip_prefix("oidc/file/") {
let path = non_empty_reference(path, "OIDC file reference")?;
let path = non_empty_reference(path, AuthError::EmptyOidcFileReference)?;
return Ok(Some(CredentialRef::File(CredentialFileRef::Path(
path.into(),
))));
}
if value.starts_with("oidc/") {
return Err(AuthError::InvalidConfiguration(format!(
"unsupported OIDC reference: {value}"
)));
return Err(AuthError::UnsupportedOidcReference);
}
Ok(None)
}
fn non_empty_reference(value: &str, kind: &str) -> Result<String, AuthError> {
fn non_empty_reference(value: &str, error: AuthError) -> Result<String, AuthError> {
if value.is_empty() {
return Err(AuthError::InvalidConfiguration(format!(
"{kind} cannot be empty"
)));
return Err(error);
}
Ok(value.to_string())
}
@ -475,7 +448,7 @@ mod tests {
let error = oidc_reference(&Some(SecretValue::new("oidc/vault/assertion")))
.expect_err("unsupported backend must fail validation");
assert!(error.to_string().contains("unsupported OIDC reference"));
assert_eq!(error, crate::AuthError::UnsupportedOidcReference);
}
#[tokio::test]

View file

@ -76,9 +76,9 @@ fn string_config(
None => Ok(ConfigValue::Absent),
Some(Value::Null) => Ok(ConfigValue::ExplicitNone),
Some(Value::String(value)) => Ok(ConfigValue::Value(value.clone())),
Some(_) => Err(AuthError::InvalidConfiguration(format!(
"{name} must be a string or null"
))),
Some(_) => Err(AuthError::InvalidAzureConfigType {
name: name.to_string(),
}),
}
}

View file

@ -88,9 +88,7 @@ impl CredentialPlan {
Self::Caller(caller) => {
let credential = caller.acquire().await?;
if credential.secret().expose().is_empty() {
return Err(AuthError::Caller(
"credential caller returned an empty credential".to_string(),
));
return Err(AuthError::EmptyCallerCredential);
}
Ok(CredentialPlanResolution::Resolved(credential))
}

View file

@ -1,3 +1,5 @@
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use crate::AuthError;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@ -16,62 +18,109 @@ impl CredentialPlacement {
}
pub(crate) fn apply_credential(
headers: Vec<(String, String)>,
mut headers: HeaderMap,
credential: &str,
placement: CredentialPlacement,
) -> Result<Vec<(String, String)>, AuthError> {
) -> Result<HeaderMap, AuthError> {
if credential.trim().is_empty() {
return Err(AuthError::InvalidConfiguration(
"credential cannot be empty".to_string(),
));
return Err(AuthError::EmptyCredential);
}
if headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case(placement.header_name()))
{
return Err(AuthError::InvalidConfiguration(format!(
"credential header {} already exists",
placement.header_name()
)));
let name = HeaderName::from_bytes(placement.header_name().as_bytes()).map_err(|_| {
AuthError::InvalidCredentialHeaderName {
name: placement.header_name(),
}
})?;
if headers.contains_key(&name) {
return Err(AuthError::CredentialHeaderAlreadyExists {
name: placement.header_name(),
});
}
let value = match placement {
CredentialPlacement::Bearer => format!("Bearer {credential}"),
CredentialPlacement::Header(_) => credential.to_string(),
};
Ok(
std::iter::once((placement.header_name().to_string(), value))
.chain(headers)
.collect(),
)
let mut value = match placement {
CredentialPlacement::Bearer => HeaderValue::from_str(&format!("Bearer {credential}")),
CredentialPlacement::Header(_) => HeaderValue::from_str(credential),
}
.map_err(|_| AuthError::InvalidCredentialHeaderValue)?;
value.set_sensitive(true);
headers.insert(name, value);
Ok(headers)
}
#[cfg(test)]
mod tests {
use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderValue};
use super::{CredentialPlacement, apply_credential};
use crate::AuthError;
#[test]
fn bearer_uses_authorization_header() {
let headers = apply_credential(Vec::new(), "key", CredentialPlacement::Bearer)
.expect("credential applies");
fn credential_headers_are_sensitive_in_built_requests() {
for placement in [
CredentialPlacement::Bearer,
CredentialPlacement::Header("x-api-key"),
] {
let headers = apply_credential(HeaderMap::new(), "secret", placement).unwrap();
let request = reqwest::Client::new()
.get("https://example.com")
.headers(headers)
.build()
.unwrap();
let value = &request.headers()[placement.header_name()];
assert!(value.is_sensitive());
assert!(!format!("{request:?}").contains("secret"));
assert_eq!(
value,
match placement {
CredentialPlacement::Bearer => "Bearer secret",
_ => "secret",
}
);
}
}
#[test]
fn invalid_credentials_fail_with_typed_errors() {
for placement in [
CredentialPlacement::Bearer,
CredentialPlacement::Header("x-api-key"),
] {
for credential in ["", " "] {
assert_eq!(
apply_credential(HeaderMap::new(), credential, placement),
Err(AuthError::EmptyCredential)
);
}
for credential in ["secret\r\nx-injected: true", "secret\0"] {
assert_eq!(
apply_credential(HeaderMap::new(), credential, placement),
Err(AuthError::InvalidCredentialHeaderValue)
);
}
}
}
#[test]
fn duplicate_auth_is_rejected_case_insensitively() {
let headers =
HeaderMap::from_iter([(AUTHORIZATION, HeaderValue::from_static("Bearer caller"))]);
assert_eq!(
headers,
vec![("Authorization".to_string(), "Bearer key".to_string())]
apply_credential(headers, "configured", CredentialPlacement::Bearer),
Err(AuthError::CredentialHeaderAlreadyExists {
name: "Authorization"
})
);
}
#[test]
fn named_header_rejects_existing_value() {
let error = apply_credential(
vec![(
"ocp-apim-subscription-key".to_string(),
"caller-key".to_string(),
)],
"configured-key",
CredentialPlacement::Header("Ocp-Apim-Subscription-Key"),
)
.expect_err("provider policy must handle existing credentials");
assert!(error.to_string().contains("already exists"));
fn invalid_header_names_fail_with_a_typed_error() {
assert_eq!(
apply_credential(
HeaderMap::new(),
"secret",
CredentialPlacement::Header("invalid name")
),
Err(AuthError::InvalidCredentialHeaderName {
name: "invalid name"
})
);
}
}

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use crate::AuthError;
use super::http::apply_credential;
@ -32,37 +34,29 @@ pub struct ProviderAuthPolicy {
}
impl ProviderAuthPolicy {
pub fn has_existing_credential(&self, headers: &[(String, String)]) -> bool {
headers.iter().any(|(name, _)| {
self.accepted_existing_headers
.iter()
.any(|accepted| name.eq_ignore_ascii_case(accepted))
})
pub fn has_existing_credential(&self, headers: &HeaderMap) -> bool {
self.accepted_existing_headers
.iter()
.any(|name| headers.contains_key(*name))
}
pub fn apply(
&self,
headers: Vec<(String, String)>,
headers: HeaderMap,
kind: CredentialPlanKind,
credential: &ResolvedCredential,
) -> Result<Vec<(String, String)>, AuthError> {
) -> Result<HeaderMap, AuthError> {
if self.has_existing_credential(&headers) {
return match self.existing_header_behavior {
ExistingHeaderBehavior::Preserve => Ok(headers),
ExistingHeaderBehavior::Reject => Err(AuthError::InvalidConfiguration(
"credential header already exists".to_string(),
)),
ExistingHeaderBehavior::Reject => Err(AuthError::ExistingCredentialHeader),
};
}
let rule = self
.rules
.iter()
.find(|rule| rule.kind == kind)
.ok_or_else(|| {
AuthError::InvalidConfiguration(
"credential plan is not allowed by the provider auth policy".to_string(),
)
})?;
.ok_or(AuthError::CredentialPlanNotAllowed)?;
apply_credential(headers, credential.secret().expose(), rule.placement)
}
}
@ -71,6 +65,7 @@ impl ProviderAuthPolicy {
mod tests {
use super::{CredentialPlanKind, CredentialRule, ExistingHeaderBehavior, ProviderAuthPolicy};
use crate::auth::{CredentialPlacement, ResolvedCredential, SecretValue};
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
const RULES: &[CredentialRule] = &[CredentialRule {
kind: CredentialPlanKind::Static,
@ -84,11 +79,34 @@ mod tests {
audience: None,
};
#[test]
fn existing_credential_policy_preserves_or_rejects_caller_auth() {
let headers = HeaderMap::from_iter([(
HeaderName::from_static("x-api-key"),
HeaderValue::from_static("caller"),
)]);
let credential = ResolvedCredential::Static(SecretValue::new("configured"));
assert_eq!(
POLICY
.apply(headers.clone(), CredentialPlanKind::Static, &credential)
.unwrap()["x-api-key"],
"caller"
);
let rejecting = ProviderAuthPolicy {
existing_header_behavior: ExistingHeaderBehavior::Reject,
..POLICY
};
assert_eq!(
rejecting.apply(headers, CredentialPlanKind::Static, &credential),
Err(crate::AuthError::ExistingCredentialHeader)
);
}
#[test]
fn rules_define_allowed_plans_and_credential_placement() {
let headers = POLICY
.apply(
Vec::new(),
HeaderMap::new(),
CredentialPlanKind::Static,
&ResolvedCredential::Static(SecretValue::new("secret")),
)
@ -96,7 +114,10 @@ mod tests {
assert_eq!(
headers,
vec![("x-api-key".to_string(), "secret".to_string())]
HeaderMap::from_iter([(
HeaderName::from_static("x-api-key"),
HeaderValue::from_static("secret")
)])
);
}
@ -104,12 +125,12 @@ mod tests {
fn unsupported_plan_is_rejected() {
let error = POLICY
.apply(
Vec::new(),
HeaderMap::new(),
CredentialPlanKind::Entra,
&ResolvedCredential::Static(SecretValue::new("secret")),
)
.unwrap_err();
assert!(error.to_string().contains("not allowed"));
assert_eq!(error, crate::AuthError::CredentialPlanNotAllowed);
}
}

View file

@ -2,8 +2,75 @@ use thiserror::Error as ThisError;
#[derive(Clone, Debug, ThisError, PartialEq, Eq)]
pub enum AuthError {
#[error("invalid authentication configuration: credential cannot be empty")]
EmptyCredential,
#[error("invalid authentication configuration: credential is not a valid HTTP header value")]
InvalidCredentialHeaderValue,
#[error("invalid authentication configuration: invalid credential header name: {name}")]
InvalidCredentialHeaderName { name: &'static str },
#[error("invalid authentication configuration: credential header {name} already exists")]
CredentialHeaderAlreadyExists { name: &'static str },
#[error("invalid authentication configuration: credential header already exists")]
ExistingCredentialHeader,
#[error(
"invalid authentication configuration: credential plan is not allowed by the provider auth policy"
)]
CredentialPlanNotAllowed,
#[error(
"invalid authentication configuration: caller credential plan requires provider-specific inputs"
)]
CallerPlanRequiresProviderInputs,
#[error("credential caller failed: credential caller returned an empty credential")]
EmptyCallerCredential,
#[error("credential caller failed: Azure AD token provider returned an empty token")]
EmptyAzureAdToken,
#[error("credential acquisition failed: Azure OIDC reference did not resolve to a value")]
UnresolvedOidcReference,
#[error("invalid authentication configuration: invalid Azure credential selector")]
InvalidAzureCredentialSelector,
#[error(
"invalid authentication configuration: ClientSecretCredential requires tenant_id, client_id, and client_secret"
)]
MissingClientSecretFields,
#[error("invalid authentication configuration: WorkloadIdentityCredential requires tenant_id")]
MissingWorkloadTenantId,
#[error("invalid authentication configuration: WorkloadIdentityCredential requires client_id")]
MissingWorkloadClientId,
#[error(
"invalid authentication configuration: WorkloadIdentityCredential requires azure_federated_token_file"
)]
MissingWorkloadTokenFile,
#[error(
"invalid authentication configuration: credential reference requires a host credential resolver"
)]
MissingCredentialResolver,
#[error("invalid authentication configuration: unsupported OIDC reference")]
UnsupportedOidcReference,
#[error("invalid authentication configuration: OIDC environment reference cannot be empty")]
EmptyOidcEnvironmentReference,
#[error(
"invalid authentication configuration: OIDC environment path reference cannot be empty"
)]
EmptyOidcEnvironmentPathReference,
#[error("invalid authentication configuration: OIDC file reference cannot be empty")]
EmptyOidcFileReference,
#[error("invalid authentication configuration: {name} must be a string or null")]
InvalidAzureConfigType { name: String },
#[error(
"invalid authentication configuration: Missing Azure AI credentials - set AZURE_AI_API_KEY or configure Entra ID"
)]
MissingAzureAiCredentials,
#[error(
"invalid authentication configuration: Missing Azure Document Intelligence credentials - set AZURE_DOCUMENT_INTELLIGENCE_API_KEY or configure Entra ID"
)]
MissingAzureDocumentIntelligenceCredentials,
#[error(
"Missing REDUCTO_API_KEY - set it in the environment or pass api_key to litellm.ocr()/litellm.aocr()"
)]
MissingReductoApiKey,
#[error("invalid authentication configuration: {0}")]
InvalidConfiguration(String),
AzureCredentialConfiguration(String),
#[error("credential acquisition failed: {0}")]
Acquisition(String),
#[error("credential caller failed: {0}")]
@ -25,6 +92,16 @@ pub enum AuthError {
#[derive(Debug, ThisError, PartialEq, Eq)]
pub enum Error {
#[error("{context} extra_headers.{name} must be a string, got {actual}")]
InvalidHeaderType {
context: &'static str,
name: String,
actual: &'static str,
},
#[error("invalid HTTP header name")]
InvalidHeaderName,
#[error("invalid value for HTTP header {name}")]
InvalidHeaderValue { name: String },
#[error("expected {expected}, got {actual}")]
InvalidType {
expected: &'static str,

View file

@ -1,5 +1,6 @@
//! Header and upstream-body helpers shared by every route module.
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use serde_json::{Map, Value};
use crate::constants::UPSTREAM_ERROR_BODY_MAX_CHARS;
@ -43,6 +44,40 @@ pub fn string_headers(
.collect()
}
pub fn header_map(
context: &'static str,
extra_headers: Option<Map<String, Value>>,
) -> Result<HeaderMap, Error> {
extra_headers
.unwrap_or_default()
.into_iter()
.map(|(name, value)| {
let value = value.as_str().ok_or_else(|| Error::InvalidHeaderType {
context,
name: name.clone(),
actual: json_type_name(&value),
})?;
let name =
HeaderName::from_bytes(name.as_bytes()).map_err(|_| Error::InvalidHeaderName)?;
let mut value =
HeaderValue::from_str(value).map_err(|_| Error::InvalidHeaderValue {
name: name.to_string(),
})?;
if matches!(
name.as_str(),
"authorization"
| "proxy-authorization"
| "x-api-key"
| "api-key"
| "ocp-apim-subscription-key"
) {
value.set_sensitive(true);
}
Ok((name, value))
})
.collect()
}
pub fn has_header(headers: &[(String, String)], name: &str) -> bool {
headers
.iter()
@ -66,6 +101,48 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn header_map_validates_wire_values_without_exposing_credentials() {
for (input, expected) in [
(json!({"invalid name": "secret"}), Error::InvalidHeaderName),
(
json!({"Authorization": "secret\r\nx-injected: true"}),
Error::InvalidHeaderValue {
name: "authorization".into(),
},
),
(
json!({"x-retry": 3}),
Error::InvalidHeaderType {
context: "OCR",
name: "x-retry".into(),
actual: "number",
},
),
] {
let error = header_map("OCR", input.as_object().cloned())
.expect_err("invalid header must fail before sending");
assert_eq!(error, expected);
assert!(!error.to_string().contains("secret"));
}
let headers = header_map(
"OCR",
json!({"Authorization": "Bearer secret", "X-Api-Key": "secret", "x-trace": "trace"})
.as_object()
.cloned(),
)
.unwrap();
let request = reqwest::Client::new()
.get("https://example.com")
.headers(headers)
.build()
.unwrap();
assert_eq!(request.headers()["authorization"], "Bearer secret");
assert_eq!(request.headers()["x-api-key"], "secret");
assert_eq!(request.headers()["x-trace"], "trace");
assert!(!format!("{request:?}").contains("secret"));
}
#[test]
fn truncate_leaves_short_bodies_untouched() {
assert_eq!(truncate_error_body("short"), "short");

View file

@ -1,23 +1,24 @@
use crate::auth::CredentialPlacement;
use crate::auth::http::apply_credential;
use crate::{AuthError, Error};
use serde_json::{Map, Value};
use std::future::Future;
use std::pin::Pin;
use reqwest::header::HeaderMap;
use serde_json::{Map, Value};
use crate::auth::CredentialPlacement;
use crate::auth::http::apply_credential;
use crate::{AuthError, Error};
use super::types::{OcrAuthInputs, OcrRequestData, OcrResponseData};
pub type OcrAuthFuture<'a> =
Pin<Box<dyn Future<Output = Result<Vec<(String, String)>, Error>> + Send + 'a>>;
pub type OcrAuthFuture<'a> = Pin<Box<dyn Future<Output = Result<HeaderMap, Error>> + Send + 'a>>;
pub type OcrRequestSetupFuture<'a> =
Pin<Box<dyn Future<Output = Result<(String, Vec<(String, String)>), Error>> + Send + 'a>>;
Pin<Box<dyn Future<Output = Result<(String, HeaderMap), Error>> + Send + 'a>>;
pub struct OcrRequestSetup<'a> {
pub api_base: Option<&'a str>,
pub model: &'a str,
pub optional_params: &'a Map<String, Value>,
pub headers: Vec<(String, String)>,
pub headers: HeaderMap,
pub api_key: Option<&'a str>,
pub auth_inputs: &'a OcrAuthInputs,
pub env_lookup: &'a (dyn Fn(&str) -> Option<String> + Sync),
@ -89,12 +90,12 @@ pub trait OcrProviderConfig: Sync {
#[tracing::instrument(target = "litellm::function_trace", level = "trace", skip_all)]
fn validate_environment(
&self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
let placement = self.credential_placement();
if crate::http_utils::has_header(&headers, placement.header_name()) {
if headers.contains_key(placement.header_name()) {
return Ok(headers);
}
let api_key = self.resolve_api_key(api_key, env_lookup)?;
@ -103,7 +104,7 @@ pub trait OcrProviderConfig: Sync {
fn authenticate<'a>(
&'a self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&'a str>,
auth_inputs: &'a OcrAuthInputs,
env_lookup: &'a (dyn Fn(&str) -> Option<String> + Sync),

View file

@ -1,5 +1,7 @@
use std::sync::OnceLock;
use reqwest::header::HeaderMap;
use crate::auth::azure::{AzureAuthInputs, AzureAuthService};
use crate::auth::http::apply_credential;
use crate::auth::{
@ -121,14 +123,11 @@ pub fn resolve_document_intelligence_endpoint(
}
pub fn validate_environment(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
if headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("Authorization"))
{
) -> Result<HeaderMap, Error> {
if headers.contains_key("Authorization") {
return Ok(headers);
}
let api_key = resolve_api_key(api_key, env_lookup)?;
@ -136,11 +135,11 @@ pub fn validate_environment(
}
pub async fn authenticate(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
auth_inputs: Option<&AzureAuthInputs>,
env_lookup: &(dyn Fn(&str) -> Option<String> + Sync),
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
authenticate_with_policy(
headers,
api_key,
@ -148,17 +147,17 @@ pub async fn authenticate(
auth_inputs,
env_lookup,
&AZURE_AI_AUTH_POLICY,
"Missing Azure AI credentials - set AZURE_AI_API_KEY or configure Entra ID",
AuthError::MissingAzureAiCredentials,
)
.await
}
pub async fn authenticate_document_intelligence(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
auth_inputs: Option<&AzureAuthInputs>,
env_lookup: &(dyn Fn(&str) -> Option<String> + Sync),
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
authenticate_with_policy(
headers,
api_key,
@ -166,20 +165,20 @@ pub async fn authenticate_document_intelligence(
auth_inputs,
env_lookup,
&DOCUMENT_INTELLIGENCE_AUTH_POLICY,
"Missing Azure Document Intelligence credentials - set AZURE_DOCUMENT_INTELLIGENCE_API_KEY or configure Entra ID",
AuthError::MissingAzureDocumentIntelligenceCredentials,
)
.await
}
async fn authenticate_with_policy(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
api_key_env: &str,
auth_inputs: Option<&AzureAuthInputs>,
env_lookup: &(dyn Fn(&str) -> Option<String> + Sync),
policy: &ProviderAuthPolicy,
missing_message: &'static str,
) -> Result<Vec<(String, String)>, Error> {
missing_error: AuthError,
) -> Result<HeaderMap, Error> {
if policy.has_existing_credential(&headers) {
return Ok(headers);
}
@ -190,10 +189,7 @@ async fn authenticate_with_policy(
}
CredentialPlanKind::Entra => resolve_entra_credential(auth_inputs, env_lookup).await?,
CredentialPlanKind::Caller => {
return Err(AuthError::InvalidConfiguration(
"caller credential plan requires provider-specific inputs".to_string(),
)
.into());
return Err(AuthError::CallerPlanRequiresProviderInputs.into());
}
};
if let Some(credential) = credential {
@ -202,7 +198,7 @@ async fn authenticate_with_policy(
.map_err(Error::from);
}
}
Err(AuthError::InvalidConfiguration(missing_message.to_string()).into())
Err(missing_error.into())
}
async fn resolve_entra_credential(
@ -246,6 +242,7 @@ fn auth_service() -> &'static AzureAuthService {
mod tests {
use crate::auth::azure::AzureAuthInputs;
use crate::error::{AuthError, Error};
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use serde_json::json;
use super::{
@ -258,11 +255,8 @@ mod tests {
.expect("valid Azure auth inputs")
}
fn header_value<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
headers
.iter()
.find(|(header_name, _)| header_name.eq_ignore_ascii_case(name))
.map(|(_, value)| value.as_str())
fn header_value<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> {
headers.get(name).and_then(|value| value.to_str().ok())
}
#[test]
@ -288,22 +282,25 @@ mod tests {
#[test]
fn api_key_is_sent_as_bearer() {
let headers = validate_environment(Vec::new(), Some("key"), &|_| None)
let headers = validate_environment(HeaderMap::new(), Some("key"), &|_| None)
.expect("api key authenticates");
assert_eq!(
headers,
vec![("Authorization".to_string(), "Bearer key".to_string())]
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer key")
)])
);
}
#[test]
fn caller_bearer_token_wins_over_environment_key() {
let headers = validate_environment(
vec![(
"authorization".to_string(),
"Bearer caller-token".to_string(),
)],
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer caller-token"),
)]),
None,
&|name| (name == AZURE_AI_API_KEY_ENV).then(|| "environment-key".to_string()),
)
@ -311,17 +308,17 @@ mod tests {
assert_eq!(
headers,
vec![(
"authorization".to_string(),
"Bearer caller-token".to_string()
)]
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer caller-token")
)])
);
}
#[tokio::test]
async fn azure_ai_uses_supplied_entra_token() {
let inputs = azure_inputs(json!({"azure_ad_token": "entra-token"}));
let headers = authenticate(Vec::new(), None, Some(&inputs), &|_| None)
let headers = authenticate(HeaderMap::new(), None, Some(&inputs), &|_| None)
.await
.expect("Entra token authenticates");
@ -334,7 +331,7 @@ mod tests {
#[tokio::test]
async fn document_intelligence_api_key_uses_subscription_header() {
let headers =
authenticate_document_intelligence(Vec::new(), Some("my-key"), None, &|_| None)
authenticate_document_intelligence(HeaderMap::new(), Some("my-key"), None, &|_| None)
.await
.expect("API key authenticates");
@ -349,7 +346,7 @@ mod tests {
async fn document_intelligence_falls_back_to_entra_token() {
let inputs = azure_inputs(json!({"azure_ad_token": "entra-token"}));
let headers =
authenticate_document_intelligence(Vec::new(), None, Some(&inputs), &|_| None)
authenticate_document_intelligence(HeaderMap::new(), None, Some(&inputs), &|_| None)
.await
.expect("Entra token authenticates");
@ -363,12 +360,14 @@ mod tests {
#[tokio::test]
async fn document_intelligence_api_key_precedes_entra_token() {
let inputs = azure_inputs(json!({"azure_ad_token": "entra-token"}));
let headers =
authenticate_document_intelligence(Vec::new(), Some("api-key"), Some(&inputs), &|_| {
None
})
.await
.expect("API key authenticates");
let headers = authenticate_document_intelligence(
HeaderMap::new(),
Some("api-key"),
Some(&inputs),
&|_| None,
)
.await
.expect("API key authenticates");
assert_eq!(
header_value(&headers, "Ocp-Apim-Subscription-Key"),

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use serde_json::{Map, Value, json};
use std::collections::BTreeSet;
@ -442,7 +444,7 @@ impl OcrProviderConfig for AzureAiOcrConfig {
fn authenticate<'a>(
&'a self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&'a str>,
auth_inputs: &'a OcrAuthInputs,
env_lookup: &'a (dyn Fn(&str) -> Option<String> + Sync),
@ -560,7 +562,7 @@ impl OcrProviderConfig for AzureDocumentIntelligenceOcrConfig {
fn authenticate<'a>(
&'a self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&'a str>,
auth_inputs: &'a OcrAuthInputs,
env_lookup: &'a (dyn Fn(&str) -> Option<String> + Sync),

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use crate::auth::{
CredentialPlacement, CredentialPlanKind, CredentialRule, ExistingHeaderBehavior,
ProviderAuthPolicy, ResolvedCredential, SecretValue,
@ -33,10 +35,10 @@ pub fn resolve_api_key(
}
pub fn validate_environment(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
if AUTH_POLICY.has_existing_credential(&headers) {
return Ok(headers);
}
@ -50,6 +52,7 @@ pub fn validate_environment(
#[cfg(test)]
mod tests {
use super::*;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
#[test]
fn explicit_key_precedes_environment_key() {
@ -82,17 +85,23 @@ mod tests {
#[test]
fn static_key_is_applied_as_bearer() {
let headers = validate_environment(Vec::new(), Some("sk-param"), &|_| None).unwrap();
let headers = validate_environment(HeaderMap::new(), Some("sk-param"), &|_| None).unwrap();
assert_eq!(
headers,
vec![("Authorization".to_string(), "Bearer sk-param".to_string())]
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer sk-param")
)])
);
}
#[test]
fn existing_authorization_is_preserved_without_key_lookup() {
let headers = vec![("authorization".to_string(), "Bearer existing".to_string())];
let headers = HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer existing"),
)]);
assert_eq!(
validate_environment(headers.clone(), None, &|_| None).unwrap(),

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use crate::error::{Error, json_type_name};
use crate::ocr::transformation::OcrProviderConfig;
use crate::ocr::types::{OcrRequestData, OcrResponseData};
@ -136,10 +138,10 @@ impl OcrProviderConfig for MistralOcrConfig {
fn validate_environment(
&self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
auth::validate_environment(headers, api_key, env_lookup)
}
}

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use crate::auth::{
CredentialPlacement, CredentialPlanKind, CredentialRule, ExistingHeaderBehavior,
ProviderAuthPolicy, ResolvedCredential, SecretValue,
@ -6,7 +8,6 @@ use crate::error::{AuthError, Error};
pub const REDUCTO_API_KEY_ENV: &str = "REDUCTO_API_KEY";
const MISSING_KEY_MESSAGE: &str = "Missing REDUCTO_API_KEY - set it in the environment or pass api_key to litellm.ocr()/litellm.aocr()";
const AUTH_RULES: &[CredentialRule] = &[CredentialRule {
kind: CredentialPlanKind::Static,
placement: CredentialPlacement::Bearer,
@ -32,14 +33,14 @@ pub fn resolve_api_key(
.map(|key| key.trim().to_string())
.filter(|key| !key.is_empty())
})
.ok_or_else(|| Error::Auth(AuthError::Message(MISSING_KEY_MESSAGE.to_string())))
.ok_or(Error::Auth(AuthError::MissingReductoApiKey))
}
pub fn validate_environment(
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
if AUTH_POLICY.has_existing_credential(&headers) {
return Ok(headers);
}
@ -53,6 +54,7 @@ pub fn validate_environment(
#[cfg(test)]
mod tests {
use super::*;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
#[test]
fn explicit_key_precedes_environment_key() {
@ -72,17 +74,24 @@ mod tests {
#[test]
fn static_key_is_applied_as_bearer() {
let headers = validate_environment(Vec::new(), Some("passed-key"), &|_| None).unwrap();
let headers =
validate_environment(HeaderMap::new(), Some("passed-key"), &|_| None).unwrap();
assert_eq!(
headers,
vec![("Authorization".to_string(), "Bearer passed-key".to_string())]
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer passed-key")
)])
);
}
#[test]
fn existing_authorization_is_preserved_without_key_lookup() {
let headers = vec![("authorization".to_string(), "Bearer existing".to_string())];
let headers = HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer existing"),
)]);
assert_eq!(
validate_environment(headers.clone(), None, &|_| None).unwrap(),

View file

@ -1,3 +1,4 @@
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use rstest::{fixture, rstest};
use serde_json::{Value, json};
@ -182,12 +183,15 @@ fn test_parse_v3_uses_programmatic_api_key_over_env() {
assert_eq!(key, "passed-key");
let headers = REDUCTO_PARSE_V3_CONFIG
.validate_environment(Vec::new(), Some("passed-key"), &|_| {
.validate_environment(HeaderMap::new(), Some("passed-key"), &|_| {
Some("env-reducto-key".to_string())
})
.expect("headers should validate");
assert_eq!(
headers,
vec![("Authorization".to_string(), "Bearer passed-key".to_string())]
HeaderMap::from_iter([(
HeaderName::from_static("authorization"),
HeaderValue::from_static("Bearer passed-key")
)])
);
}

View file

@ -1,3 +1,5 @@
use reqwest::header::HeaderMap;
use std::collections::BTreeMap;
use base64::Engine;
@ -346,10 +348,10 @@ impl OcrProviderConfig for ReductoParseV3Config {
fn validate_environment(
&self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
auth::validate_environment(headers, api_key, env_lookup)
}
}
@ -397,10 +399,10 @@ impl OcrProviderConfig for ReductoParseLegacyConfig {
fn validate_environment(
&self,
headers: Vec<(String, String)>,
headers: HeaderMap,
api_key: Option<&str>,
env_lookup: &dyn Fn(&str) -> Option<String>,
) -> Result<Vec<(String, String)>, Error> {
) -> Result<HeaderMap, Error> {
auth::validate_environment(headers, api_key, env_lookup)
}
}

View file

@ -21,6 +21,9 @@ pub(crate) fn core_error_to_pyerr(err: Error) -> PyErr {
Error::Auth(message) => PyValueError::new_err(message.to_string()),
Error::InvalidProvider(_)
| Error::InvalidRequest(_)
| Error::InvalidHeaderType { .. }
| Error::InvalidHeaderName
| Error::InvalidHeaderValue { .. }
| Error::InvalidType { .. }
| Error::MissingField(_) => PyValueError::new_err(err.to_string()),
other => PyRuntimeError::new_err(other.to_string()),
@ -39,6 +42,8 @@ pub(crate) fn chat_completions_error_to_pyerr(err: Error) -> PyErr {
| Error::Auth(_)
| Error::InvalidProvider(_)
| Error::InvalidRequest(_)
| Error::InvalidHeaderType { .. } | Error::InvalidHeaderName
| Error::InvalidHeaderValue { .. }
| Error::InvalidType { .. }
| Error::MissingField(_)
| Error::Routing(_)
@ -83,6 +88,22 @@ mod ocr_error_tests {
assert!(mapped.is_instance_of::<PyValueError>(py));
assert_eq!(mapped.value(py).to_string(), "Document URL is required");
}
for error in [
Error::Auth(litellm_core::AuthError::EmptyCredential),
Error::Auth(litellm_core::AuthError::InvalidCredentialHeaderValue),
Error::InvalidHeaderName,
Error::InvalidHeaderValue {
name: "authorization".into(),
},
Error::InvalidHeaderType {
context: "OCR",
name: "authorization".into(),
actual: "number",
},
] {
let mapped = ocr_error_to_pyerr(error);
assert!(mapped.is_instance_of::<PyValueError>(py));
}
let mapped = ocr_error_to_pyerr(Error::Http {
status: 429,
body: r#"{"message":"rate limited"}"#.to_string(),

View file

@ -326,22 +326,20 @@ mod tests {
assert!(sync_ocr_error.to_string().contains("invalid OCR request"));
assert_eq!(async_ocr_error.to_string(), sync_ocr_error.to_string());
for (sync_name, async_name) in [("transcription", "atranscription")] {
let sync_error = module
.getattr(sync_name)
.and_then(|function| function.call(("model", &document), Some(&kwargs)))
.expect_err("sync route should reject non-dict extra_headers");
let async_error = module
.getattr(async_name)
.and_then(|function| function.call(("model", &document), Some(&kwargs)))
.expect_err("async route should reject non-dict extra_headers");
let sync_error = module
.getattr("transcription")
.and_then(|function| function.call(("model", &document), Some(&kwargs)))
.expect_err("sync route should reject non-dict extra_headers");
let async_error = module
.getattr("atranscription")
.and_then(|function| function.call(("model", &document), Some(&kwargs)))
.expect_err("async route should reject non-dict extra_headers");
assert_eq!(
sync_error.to_string(),
"ValueError: extra_headers must be a dict"
);
assert_eq!(async_error.to_string(), sync_error.to_string());
}
assert_eq!(
sync_error.to_string(),
"ValueError: extra_headers must be a dict"
);
assert_eq!(async_error.to_string(), sync_error.to_string());
});
}