use std::time::Duration;
use std::{collections::BTreeMap, fmt};
use reqwest::RequestBuilder;
use reqwest::header::HeaderValue;
use serde_json::Value;
use switchyard_protocol::{Metadata, WireFormat};
use crate::error::{LlmClientError, Result, is_overflow_body};
const ANTHROPIC_VERSION: &str = "2023-06-01";
pub const DEFAULT_MAX_RETRIES: u32 = 2;
const OPENAI_OVERFLOW_PHRASES: &[&str] = &[
"maximum context length",
"context length exceeded",
"context window",
"context length is only",
"please reduce the length of the input",
"exceeds the maximum allowed input length",
"exceeds the maximum allowed length",
"is longer than the model's context length",
];
const ANTHROPIC_OVERFLOW_PHRASES: &[&str] = &[
"prompt is too long",
"maximum number of tokens",
"context window",
"context length",
];
#[derive(Clone)]
pub struct HttpBackendConfig {
pub base_url: String,
pub api_key: Option<String>,
pub forward_auth: bool,
pub extra_headers: BTreeMap<String, String>,
pub extra_body: BTreeMap<String, Value>,
pub reasoning_effort: Option<String>,
pub max_retries: u32,
pub timeout: Option<Duration>,
}
impl fmt::Debug for HttpBackendConfig {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HttpBackendConfig")
.field("base_url", &self.base_url)
.field("api_key", &self.api_key.as_ref().map(|_| "[REDACTED]"))
.field("forward_auth", &self.forward_auth)
.field("extra_header_names", &self.extra_headers.keys())
.field("extra_body_keys", &self.extra_body.keys())
.field("reasoning_effort", &self.reasoning_effort)
.field("max_retries", &self.max_retries)
.field("timeout", &self.timeout)
.finish()
}
}
#[derive(Clone, Debug)]
pub enum Backend {
OpenAiChat(HttpBackendConfig),
OpenAiResponses(HttpBackendConfig),
Anthropic(HttpBackendConfig),
}
impl Backend {
pub(crate) fn validate_extra_headers(&self, model_name: &str) -> Result<()> {
let invalid_name = self.config().extra_headers.keys().find(|name| match self {
Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => {
name.eq_ignore_ascii_case("authorization")
|| (self.is_forwarding_auth()
&& (name.eq_ignore_ascii_case("chatgpt-account-id")
|| name.eq_ignore_ascii_case("x-openai-fedramp")))
}
Backend::Anthropic(_) => {
name.eq_ignore_ascii_case("x-api-key")
|| name.eq_ignore_ascii_case("anthropic-version")
|| (self.is_forwarding_auth()
&& (name.eq_ignore_ascii_case("authorization")
|| name.eq_ignore_ascii_case("anthropic-beta")))
}
});
if let Some(name) = invalid_name {
return Err(LlmClientError::Configuration {
message: format!(
"model {model_name:?} extra_headers cannot set {name:?}; extra_headers is only for additional headers"
),
});
}
Ok(())
}
pub fn wire_format(&self) -> WireFormat {
match self {
Backend::OpenAiChat(_) => WireFormat::OpenAiChat,
Backend::OpenAiResponses(_) => WireFormat::OpenAiResponses,
Backend::Anthropic(_) => WireFormat::AnthropicMessages,
}
}
fn config(&self) -> &HttpBackendConfig {
match self {
Backend::OpenAiChat(config)
| Backend::OpenAiResponses(config)
| Backend::Anthropic(config) => config,
}
}
pub fn url(&self) -> String {
let base_url = &self.config().base_url;
let result = match self {
Backend::OpenAiChat(_) => openai_url(base_url, "/chat/completions"),
Backend::OpenAiResponses(_) => openai_url(base_url, "/responses"),
Backend::Anthropic(_) => anthropic_url(base_url, ""),
};
result.unwrap_or_else(|error| {
tracing::error!(%error, "Unable to build provider endpoint URL");
base_url.clone()
})
}
pub fn apply_auth(&self, mut builder: RequestBuilder) -> RequestBuilder {
let api_key = if self.is_forwarding_auth() {
None
} else {
self.config().api_key.as_deref()
};
match self {
Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => {
if let Some(api_key) = api_key {
builder = builder.bearer_auth(api_key);
}
}
Backend::Anthropic(_) => {
builder = builder.header("anthropic-version", ANTHROPIC_VERSION);
if let Some(api_key) = api_key {
builder = builder.header("x-api-key", api_key);
}
}
}
builder
}
pub(crate) fn is_forwarding_auth(&self) -> bool {
self.config().forward_auth
}
pub(crate) fn is_provider_owned_header(&self, name: &str) -> bool {
match self {
Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => {
["authorization", "chatgpt-account-id", "x-openai-fedramp"]
.iter()
.any(|owned| name.eq_ignore_ascii_case(owned))
}
Backend::Anthropic(_) => [
"authorization",
"x-api-key",
"anthropic-beta",
"anthropic-version",
]
.iter()
.any(|owned| name.eq_ignore_ascii_case(owned)),
}
}
pub(crate) fn apply_forwarded_auth(
&self,
mut builder: RequestBuilder,
metadata: Option<&Metadata>,
) -> RequestBuilder {
if !self.is_forwarding_auth() {
return builder;
}
let Some(headers) = metadata.and_then(|metadata| metadata.http_headers.as_ref()) else {
return builder;
};
match self {
Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => {
for name in ["authorization", "chatgpt-account-id", "x-openai-fedramp"] {
if let Some(value) = headers.get(name) {
builder = builder.header(name, sensitive_header(value));
}
}
}
Backend::Anthropic(_) => {
for name in ["authorization", "x-api-key"] {
if let Some(value) = headers.get(name) {
builder = builder.header(name, sensitive_header(value));
}
}
if let Some(value) = headers.get("anthropic-beta")
&& let Some(value) = oauth_beta_header(value)
{
builder = builder.header("anthropic-beta", value);
}
}
}
builder
}
pub fn extra_headers(&self) -> &BTreeMap<String, String> {
&self.config().extra_headers
}
pub fn extra_body(&self) -> &BTreeMap<String, Value> {
&self.config().extra_body
}
pub fn reasoning_effort(&self) -> Option<&str> {
self.config().reasoning_effort.as_deref()
}
pub fn max_retries(&self) -> u32 {
self.config().max_retries
}
pub fn timeout(&self) -> Option<Duration> {
self.config().timeout
}
pub fn is_anthropic(&self) -> bool {
matches!(self, Backend::Anthropic(_))
}
pub fn count_tokens_url(&self) -> String {
let base_url = &self.config().base_url;
anthropic_url(base_url, "/count_tokens").unwrap_or_else(|error| {
tracing::error!(%error, "Unable to build Anthropic token-counting URL");
base_url.clone()
})
}
pub(crate) fn is_context_overflow(&self, body: &str) -> bool {
match self {
Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => is_overflow_body(
body,
|value| {
value
.get("error")
.and_then(|err| err.get("code"))
.and_then(serde_json::Value::as_str)
== Some("context_length_exceeded")
},
OPENAI_OVERFLOW_PHRASES,
),
Backend::Anthropic(_) => is_overflow_body(body, |_| false, ANTHROPIC_OVERFLOW_PHRASES),
}
}
}
fn sensitive_header(value: &HeaderValue) -> HeaderValue {
let mut value = value.clone();
value.set_sensitive(true);
value
}
fn oauth_beta_header(value: &HeaderValue) -> Option<HeaderValue> {
let oauth_betas = value
.to_str()
.ok()?
.split(',')
.map(str::trim)
.filter(|beta| {
beta.get(..6)
.is_some_and(|prefix| prefix.eq_ignore_ascii_case("oauth-"))
});
let value = oauth_betas.collect::<Vec<_>>().join(",");
if value.is_empty() {
return None;
}
let mut value = HeaderValue::from_str(&value).ok()?;
value.set_sensitive(true);
Some(value)
}
pub(crate) fn openai_url(base_url: &str, suffix: &str) -> Result<String> {
let mut url = reqwest::Url::parse(base_url).map_err(|error| LlmClientError::Configuration {
message: format!("Invalid OpenAI base URL: {error}"),
})?;
let base_path = url.path().trim_end_matches('/');
let base_root = base_path
.strip_suffix("/chat/completions")
.or_else(|| base_path.strip_suffix("/responses"))
.unwrap_or(base_path);
url.set_path(&format!("{base_root}{suffix}"));
Ok(url.into())
}
fn anthropic_url(base_url: &str, suffix: &str) -> Result<String> {
let mut url = reqwest::Url::parse(base_url).map_err(|error| LlmClientError::Configuration {
message: format!("Invalid Anthropic base URL: {error}"),
})?;
let base_path = url.path().trim_end_matches('/');
let messages_path = if base_path.ends_with("/v1/messages") {
base_path.to_string()
} else if base_path.ends_with("/v1") {
format!("{base_path}/messages")
} else {
format!("{base_path}/v1/messages")
};
url.set_path(&format!("{messages_path}{suffix}"));
Ok(url.into())
}
#[cfg(test)]
mod tests {
use super::*;
fn config(base_url: &str) -> HttpBackendConfig {
HttpBackendConfig {
base_url: base_url.to_string(),
api_key: Some("secret".to_string()),
forward_auth: false,
extra_headers: BTreeMap::new(),
extra_body: BTreeMap::new(),
reasoning_effort: None,
max_retries: 0,
timeout: None,
}
}
#[test]
fn openai_chat_url_joins_bare_v1() {
let backend = Backend::OpenAiChat(config("https://api.openai.com/v1"));
assert_eq!(backend.url(), "https://api.openai.com/v1/chat/completions");
}
#[test]
fn openai_chat_url_tolerates_trailing_slash_and_existing_suffix() {
assert_eq!(
Backend::OpenAiChat(config("https://api.openai.com/v1/")).url(),
"https://api.openai.com/v1/chat/completions"
);
assert_eq!(
Backend::OpenAiChat(config("https://api.openai.com/v1/chat/completions")).url(),
"https://api.openai.com/v1/chat/completions"
);
}
#[test]
fn openai_responses_url_uses_responses_path() {
assert_eq!(
Backend::OpenAiResponses(config("https://api.openai.com/v1")).url(),
"https://api.openai.com/v1/responses"
);
}
#[test]
fn anthropic_url_join_cases() {
assert_eq!(
Backend::Anthropic(config("https://api.anthropic.com")).url(),
"https://api.anthropic.com/v1/messages"
);
assert_eq!(
Backend::Anthropic(config("https://api.anthropic.com/v1")).url(),
"https://api.anthropic.com/v1/messages"
);
assert_eq!(
Backend::Anthropic(config("https://api.anthropic.com/v1/messages")).url(),
"https://api.anthropic.com/v1/messages"
);
}
#[test]
fn wire_format_matches_variant() {
assert_eq!(
Backend::OpenAiChat(config("x")).wire_format(),
WireFormat::OpenAiChat
);
assert_eq!(
Backend::OpenAiResponses(config("x")).wire_format(),
WireFormat::OpenAiResponses
);
assert_eq!(
Backend::Anthropic(config("x")).wire_format(),
WireFormat::AnthropicMessages
);
}
#[test]
fn openai_detects_canonical_and_wrapped_overflow() {
let backend = Backend::OpenAiChat(config("x"));
assert!(
backend.is_context_overflow(
r#"{"error":{"code":"context_length_exceeded","message":"x"}}"#
)
);
assert!(backend.is_context_overflow(
r#"{"error":{"message":"the model's context length is only 131072 tokens"}}"#
));
assert!(!backend.is_context_overflow(r#"{"error":{"code":"invalid_api_key"}}"#));
assert!(backend.is_context_overflow(
r#"{"error":{"message":"Input length 877338 exceeds the maximum allowed input length of 639968 tokens","code":"400"}}"#
));
assert!(backend.is_context_overflow(
r#"{"object":"error","message":"Input length (700001 tokens) exceeds the maximum allowed length (536826 tokens). Use a shorter input or enable --allow-auto-truncate.","type":"BadRequestError","param":null,"code":400}"#
));
assert!(backend.is_context_overflow(
r#"{"object":"error","message":"The input (12345 tokens) is longer than the model's context length (8192 tokens).","type":"BadRequestError","param":null,"code":400}"#
));
}
#[test]
fn anthropic_detects_prompt_too_long() {
let backend = Backend::Anthropic(config("x"));
assert!(
backend.is_context_overflow(
r#"{"error":{"message":"prompt is too long: 200000 tokens"}}"#
)
);
assert!(!backend.is_context_overflow(r#"{"error":{"message":"overloaded"}}"#));
}
}