use crate::{Error, Result};
use http::header::{HeaderName, HeaderValue, AUTHORIZATION};
use std::fmt;
use std::sync::Arc;
use timvw_rust_runtime::{ExposeSecret, SecretString};
pub use timvw_rust_runtime::provider::ProviderLayer;
pub const OPENAI_BASE_URL: &str = "https://api.openai.com/v1";
pub const OPENROUTER_BASE_URL: &str = "https://openrouter.ai/api/v1";
pub const GROQ_BASE_URL: &str = "https://api.groq.com/openai/v1";
pub const OLLAMA_BASE_URL: &str = "http://localhost:11434/v1";
pub const AZURE_DEFAULT_API_VERSION: &str = "2024-02-01";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ProviderKind {
OpenAi,
Azure,
OpenRouter,
Groq,
Ollama,
Custom,
}
#[derive(Clone)]
enum Credential {
None,
Bearer(SecretString),
Header(String, SecretString),
}
type MapPath = Arc<dyn Fn(&str) -> String + Send + Sync>;
#[derive(Clone)]
pub struct Provider {
kind: ProviderKind,
base_url: String,
credential: Credential,
headers: Vec<(String, String, bool)>,
query: Vec<(String, String)>,
map_path: Option<MapPath>,
azure_deployment: Option<String>,
}
impl Provider {
fn new(kind: ProviderKind, base_url: impl Into<String>, credential: Credential) -> Self {
Self {
kind,
base_url: trim_base(&base_url.into()),
credential,
headers: Vec::new(),
query: Vec::new(),
map_path: None,
azure_deployment: None,
}
}
pub fn openai(api_key: impl Into<String>) -> Self {
Self::new(
ProviderKind::OpenAi,
OPENAI_BASE_URL,
bearer(api_key.into()),
)
}
pub fn azure(
endpoint: impl Into<String>,
api_key: impl Into<String>,
deployment: impl Into<String>,
) -> Self {
Self::azure_with(
&endpoint.into(),
Credential::Header("api-key".to_string(), SecretString::from(api_key.into())),
deployment.into(),
)
}
pub fn azure_entra(endpoint: impl Into<String>, deployment: impl Into<String>) -> Self {
Self::azure_with(&endpoint.into(), Credential::None, deployment.into())
}
fn azure_with(endpoint: &str, credential: Credential, deployment: String) -> Self {
let endpoint = trim_base(endpoint);
let endpoint = match endpoint.find("/openai") {
Some(index) if endpoint[..index].contains("://") => endpoint[..index].to_string(),
_ => endpoint,
};
let mut provider = Self::new(
ProviderKind::Azure,
format!("{endpoint}/openai"),
credential,
);
let prefix = format!("/deployments/{deployment}");
provider.map_path = Some(Arc::new(move |path: &str| {
if path.starts_with("/deployments/") {
path.to_string()
} else {
format!("{prefix}{path}")
}
}));
provider.azure_deployment = Some(deployment);
provider.query = vec![(
"api-version".to_string(),
AZURE_DEFAULT_API_VERSION.to_string(),
)];
provider
}
pub fn openrouter(api_key: impl Into<String>) -> Self {
Self::new(
ProviderKind::OpenRouter,
OPENROUTER_BASE_URL,
bearer(api_key.into()),
)
}
pub fn groq(api_key: impl Into<String>) -> Self {
Self::new(ProviderKind::Groq, GROQ_BASE_URL, bearer(api_key.into()))
}
pub fn ollama() -> Self {
Self::new(ProviderKind::Ollama, OLLAMA_BASE_URL, Credential::None)
}
pub fn custom(base_url: impl Into<String>) -> Self {
Self::new(ProviderKind::Custom, base_url, Credential::None)
}
#[must_use]
pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
let base_url = trim_base(&base_url.into());
self.base_url = if self.kind == ProviderKind::Azure && !base_url.ends_with("/openai") {
format!("{base_url}/openai")
} else {
base_url
};
self
}
#[must_use]
pub fn bearer(mut self, token: impl Into<String>) -> Self {
self.credential = bearer(token.into());
self
}
#[must_use]
pub fn api_key_header(mut self, name: impl Into<String>, key: impl Into<String>) -> Self {
self.credential = Credential::Header(name.into(), SecretString::from(key.into()));
self
}
#[must_use]
pub fn without_credential(mut self) -> Self {
self.credential = Credential::None;
self
}
#[must_use]
pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.set_header(name.into(), value.into(), false);
self
}
#[must_use]
pub fn sensitive_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.set_header(name.into(), value.into(), true);
self
}
fn set_header(&mut self, name: String, value: String, sensitive: bool) {
self.headers
.retain(|(existing, _, _)| !existing.eq_ignore_ascii_case(&name));
self.headers.push((name, value, sensitive));
}
#[must_use]
pub fn query(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
let name = name.into();
self.query.retain(|(existing, _)| *existing != name);
self.query.push((name, value.into()));
self
}
#[must_use]
pub fn map_path<F>(mut self, f: F) -> Self
where
F: Fn(&str) -> String + Send + Sync + 'static,
{
self.map_path = Some(Arc::new(f));
self
}
#[must_use]
pub fn api_version(self, version: impl Into<String>) -> Self {
self.query("api-version", version)
}
#[must_use]
pub fn http_referer(self, url: impl Into<String>) -> Self {
self.header("HTTP-Referer", url)
}
#[must_use]
pub fn title(self, title: impl Into<String>) -> Self {
self.header("X-Title", title)
}
pub fn kind(&self) -> ProviderKind {
self.kind
}
pub fn api_base(&self) -> &str {
&self.base_url
}
pub fn api_key(&self) -> Option<&str> {
match &self.credential {
Credential::None => None,
Credential::Bearer(token) | Credential::Header(_, token) => Some(token.expose_secret()),
}
}
pub fn azure_deployment(&self) -> Option<&str> {
self.azure_deployment.as_deref()
}
pub fn query_param(&self, name: &str) -> Option<&str> {
self.query
.iter()
.find(|(existing, _)| existing == name)
.map(|(_, value)| value.as_str())
}
pub fn layer(&self) -> Result<ProviderLayer> {
self.layer_with(Vec::new())
}
pub(crate) fn layer_with(
&self,
extra_headers: Vec<(HeaderName, HeaderValue)>,
) -> Result<ProviderLayer> {
let config_error = |error: timvw_rust_runtime::Error| {
Error::Config(format!(
"invalid {:?} provider configuration: {error}{}",
self.kind,
std::error::Error::source(&error)
.map(|source| format!(": {source}"))
.unwrap_or_default()
))
};
let mut layer = ProviderLayer::new(&self.base_url).map_err(config_error)?;
match &self.credential {
Credential::None => {}
Credential::Bearer(token) => {
if !token.expose_secret().is_empty() {
layer = layer
.sensitive_header(
AUTHORIZATION,
format!("Bearer {}", token.expose_secret()),
)
.map_err(config_error)?;
}
}
Credential::Header(name, key) => {
layer = layer
.sensitive_header(name.as_str(), key.expose_secret())
.map_err(config_error)?;
}
}
for (name, value, sensitive) in &self.headers {
layer = if *sensitive {
layer.sensitive_header(name.as_str(), value.as_str())
} else {
layer.header(name.as_str(), value.as_str())
}
.map_err(config_error)?;
}
for (name, value) in extra_headers {
layer = layer.header(name, value).map_err(config_error)?;
}
if !self.query.is_empty() {
layer = layer.query(&self.query).map_err(config_error)?;
}
if let Some(map_path) = self.map_path.clone() {
layer = layer.map_path(move |path| map_path(path));
}
Ok(layer)
}
}
impl Default for Provider {
fn default() -> Self {
Self::openai(String::new())
}
}
impl fmt::Debug for Provider {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let credential = match &self.credential {
Credential::None => "none".to_string(),
Credential::Bearer(_) => "bearer ***".to_string(),
Credential::Header(name, _) => format!("{name}: ***"),
};
let headers: Vec<(&str, &str)> = self
.headers
.iter()
.map(|(name, value, sensitive)| {
(
name.as_str(),
if *sensitive { "***" } else { value.as_str() },
)
})
.collect();
f.debug_struct("Provider")
.field("kind", &self.kind)
.field("base_url", &self.base_url)
.field("credential", &credential)
.field("headers", &headers)
.field("query", &self.query)
.field("map_path", &self.map_path.is_some())
.field("azure_deployment", &self.azure_deployment)
.finish()
}
}
fn bearer(token: String) -> Credential {
Credential::Bearer(SecretString::from(token))
}
fn trim_base(base_url: &str) -> String {
base_url.trim_end_matches('/').to_string()
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used)]
use super::*;
fn rewrite(provider: &Provider, uri: &str) -> String {
provider
.layer()
.unwrap()
.rewrite_uri(&uri.parse().unwrap())
.unwrap()
.to_string()
}
#[test]
fn azure_paths_and_api_version() {
let provider = Provider::azure("https://res.openai.azure.com/", "key", "my-dep");
assert_eq!(provider.api_base(), "https://res.openai.azure.com/openai");
assert_eq!(
rewrite(
&provider,
"https://res.openai.azure.com/openai/chat/completions"
),
"https://res.openai.azure.com/openai/deployments/my-dep/chat/completions?api-version=2024-02-01"
);
let provider = Provider::azure(
"https://res.openai.azure.com/openai/deployments/x",
"key",
"dep",
)
.api_version("2024-10-21");
assert_eq!(provider.api_base(), "https://res.openai.azure.com/openai");
assert_eq!(provider.query_param("api-version"), Some("2024-10-21"));
assert_eq!(
rewrite(
&provider,
"https://res.openai.azure.com/openai/deployments/dep/embeddings?api-version=old"
),
"https://res.openai.azure.com/openai/deployments/dep/embeddings?api-version=2024-10-21"
);
assert_eq!(
provider.layer().unwrap().header_map()["api-key"]
.to_str()
.unwrap(),
"key"
);
}
#[test]
fn presets() {
assert_eq!(Provider::openai("k").api_base(), OPENAI_BASE_URL);
assert_eq!(Provider::groq("k").api_base(), GROQ_BASE_URL);
assert_eq!(Provider::openrouter("k").api_base(), OPENROUTER_BASE_URL);
assert_eq!(Provider::ollama().api_base(), OLLAMA_BASE_URL);
assert_eq!(Provider::ollama().api_key(), None);
assert!(Provider::ollama().layer().unwrap().header_map().is_empty());
let layer = Provider::openrouter("sk-or")
.http_referer("https://app.example")
.title("App")
.layer()
.unwrap();
let headers = layer.header_map();
assert_eq!(headers["authorization"], "Bearer sk-or");
assert!(headers["authorization"].is_sensitive());
assert_eq!(headers["http-referer"], "https://app.example");
assert_eq!(headers["x-title"], "App");
}
#[test]
fn invalid_configuration_is_a_config_error() {
assert!(matches!(
Provider::custom("not a url").layer(),
Err(Error::Config(_))
));
assert!(matches!(
Provider::custom("https://p.example")
.header("bad name", "v")
.layer(),
Err(Error::Config(_))
));
}
#[test]
fn debug_hides_secrets() {
let provider = Provider::custom("https://p.example")
.bearer("secret-token")
.sensitive_header("x-secret", "hidden-value")
.header("x-visible", "shown");
let debug = format!("{provider:?}");
assert!(!debug.contains("secret-token"));
assert!(!debug.contains("hidden-value"));
assert!(debug.contains("shown"));
}
}