Files
luxe/crates/luxe-providers/src/auth/source.rs
Evan Whittaker 09a7de2520 Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
2026-10-17 12:08:30 -05:00

462 lines
18 KiB
Rust

//! Per-request auth — what an adapter puts on the wire for *this* call.
//!
//! An adapter cannot hold a key handed to it at construction: an OAuth access token outlives that
//! assumption by about an hour, so auth is resolved per request: [`AuthSource::request_auth`]
//! returns the headers (and, for GitHub Copilot, the base URL) for one call, refreshing an expiring
//! token on the way if it has to.
//!
//! Two implementations. [`StaticAuth`] is a fixed key in a provider-appropriate header.
//! [`StoreAuth`] reads the credential store, under a key named for the run and over the provider's
//! variables and configured key, so a `/login` mid-session takes effect on the next turn and a
//! rotating token stays fresh without rebuilding the engine.
use std::sync::Arc;
use luxe_core::auth::ApiKind;
use luxe_core::provider::ProviderError;
use tokio::sync::Mutex;
use super::catalog::{provider_descriptor, OauthFlow, ProviderDescriptor};
use super::credential::{now_ms, Credential, OAuthCredential};
use super::store::AuthStore;
use crate::config::{resolve_value_async, ApiKey};
mod key_style;
pub use key_style::KeyStyle;
/// Refresh a token this far ahead of its expiry.
///
/// Long enough that a turn started at the boundary can't have its token die mid-stream; short
/// enough that we aren't refreshing constantly.
const REFRESH_MARGIN_MS: u64 = 5 * 60 * 1000;
/// `key`, once it is remembered for redaction: every credential a request carries passes one of
/// [`RequestAuth`]'s key constructors, so this is where a shapeless one becomes known.
fn remembered(key: &ApiKey) -> &ApiKey {
luxe_core::redact::process_secrets().add(key.expose());
key
}
/// The auth a single request should carry.
///
/// Header values are [`ApiKey`]-wrapped whether or not they're secret, so a `Debug` of this struct
/// can never print a token — the cost is that a boring value reads as `[REDACTED]` too.
#[derive(Debug, Clone, Default)]
pub struct RequestAuth {
/// Headers to set, in order.
pub headers: Vec<(String, ApiKey)>,
/// Base URL this credential must be used against, when the provider hands out a
/// per-account endpoint (Copilot's `proxy-ep`). Overrides the adapter's configured base URL.
pub base_url: Option<String>,
}
impl RequestAuth {
/// No auth at all — a local server that doesn't check.
pub fn none() -> Self {
Self::default()
}
/// `Authorization: Bearer <key>`.
pub fn bearer(key: &ApiKey) -> Self {
let key = remembered(key);
Self {
headers: vec![(
"Authorization".to_string(),
ApiKey::new(format!("Bearer {}", key.expose())),
)],
base_url: None,
}
}
/// Anthropic's `x-api-key` (it rejects `Authorization: Bearer`).
pub fn anthropic_key(key: &ApiKey) -> Self {
let key = remembered(key);
Self { headers: vec![("x-api-key".to_string(), key.clone())], base_url: None }
}
/// Azure's `api-key`, which every Microsoft Foundry surface accepts.
pub fn azure_key(key: &ApiKey) -> Self {
let key = remembered(key);
Self { headers: vec![("api-key".to_string(), key.clone())], base_url: None }
}
/// Both `x-api-key` and `api-key`, for Foundry's Anthropic passthrough.
///
/// The endpoint authenticates on `x-api-key` and its own portal samples show `api-key`, so
/// Anthropic's `AnthropicFoundry` client sends the pair and so does Luxe. One header would
/// work today against a 401 that costs a user an evening.
pub fn foundry_key(key: &ApiKey) -> Self {
let key = remembered(key);
Self {
headers: vec![
("x-api-key".to_string(), key.clone()),
("api-key".to_string(), key.clone()),
],
base_url: None,
}
}
/// Add a non-secret header.
pub fn with_header(mut self, name: &str, value: impl Into<String>) -> Self {
self.headers.push((name.to_string(), ApiKey::new(value.into())));
self
}
/// Pin the base URL for this call.
pub fn with_base_url(mut self, base_url: impl Into<String>) -> Self {
self.base_url = Some(base_url.into());
self
}
/// Apply every header to a request builder.
pub fn apply(&self, mut request: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
for (name, value) in &self.headers {
request = request.header(name.as_str(), value.expose());
}
request
}
/// Whether anything was resolved (a keyless local server resolves to nothing).
pub fn is_empty(&self) -> bool {
self.headers.is_empty() && self.base_url.is_none()
}
}
/// Resolves the auth for one provider's requests.
#[async_trait::async_trait]
pub trait AuthSource: Send + Sync + std::fmt::Debug {
/// Auth for one request. Fails with [`ProviderError::Auth`] when there is no usable credential,
/// carrying a message that says how to fix it.
async fn request_auth(&self) -> Result<RequestAuth, ProviderError>;
/// The stored sign-in behind this source, for a provider that reads account details with it
/// (GitHub Copilot's plan usage). `None` for a key, or with nothing stored.
async fn oauth_credential(&self) -> Option<OAuthCredential> {
None
}
}
/// A fixed credential, resolved once at construction.
#[derive(Debug, Clone)]
pub struct StaticAuth {
auth: RequestAuth,
}
impl StaticAuth {
/// Bearer-token auth (OpenAI-compatible endpoints).
pub fn bearer(key: Option<ApiKey>) -> Self {
Self { auth: key.map(|key| RequestAuth::bearer(&key)).unwrap_or_default() }
}
/// Anthropic `x-api-key` auth.
pub fn anthropic(key: Option<ApiKey>) -> Self {
Self { auth: key.map(|key| RequestAuth::anthropic_key(&key)).unwrap_or_default() }
}
/// Auth appropriate to an API kind.
pub fn for_api(api: ApiKind, key: Option<ApiKey>) -> Self {
Self::for_style(KeyStyle::for_api(api), key)
}
/// Auth in an explicit style, for a provider whose header isn't implied by its API.
pub fn for_style(style: KeyStyle, key: Option<ApiKey>) -> Self {
Self { auth: key.map(|key| style.headers(&key)).unwrap_or_default() }
}
/// Whatever headers were resolved (used by adapters that also accept a `StoreAuth`).
pub fn into_arc(self) -> Arc<dyn AuthSource> {
Arc::new(self)
}
}
#[async_trait::async_trait]
impl AuthSource for StaticAuth {
async fn request_auth(&self) -> Result<RequestAuth, ProviderError> {
Ok(self.auth.clone())
}
}
/// Credential-store-backed auth for one provider.
///
/// Resolution order per request: the stored credential, then an ambient environment variable, then
/// the fallback supplied by the CLI/config. A stored credential wins so that logging out of a
/// provider doesn't silently fall back to a stale env var the user forgot about — except that an
/// explicit fallback (a `--api-key` flag) is *above* everything, since it was typed for this run.
#[derive(Debug)]
pub struct StoreAuth {
store: AuthStore,
provider_id: String,
/// How a resolved key goes on the wire.
key_style: KeyStyle,
/// OAuth flow to use when the stored credential needs refreshing.
flow: Option<OauthFlow>,
/// Env var names to consult when nothing is stored.
env: Vec<String>,
/// A key from the CLI/config, used when nothing is stored and no env var is set.
fallback: Option<ApiKey>,
/// A `--api-key`-style override that beats even a stored credential.
override_key: Option<ApiKey>,
/// How long a `!command` key may take to print.
command_deadline: std::time::Duration,
/// Whether this provider needs no credential.
keyless: bool,
/// Serializes refreshes inside this process; the store's file lock covers other processes.
refresh_lock: Mutex<()>,
}
impl StoreAuth {
/// Build a source for `provider_id`, taking defaults from the catalog when it knows the
/// provider.
pub fn new(store: AuthStore, provider_id: impl Into<String>, api: ApiKind) -> Self {
let provider_id = provider_id.into();
let descriptor = provider_descriptor(&provider_id);
Self {
store,
key_style: descriptor
.map(ProviderDescriptor::key_style)
.unwrap_or_else(|| KeyStyle::for_api(api)),
flow: descriptor.and_then(|descriptor| descriptor.oauth_flow()),
env: descriptor
.map(|descriptor| descriptor.env.iter().map(|name| name.to_string()).collect())
.unwrap_or_default(),
keyless: descriptor.is_some_and(|descriptor| descriptor.keyless),
provider_id,
fallback: None,
override_key: None,
command_deadline: luxe_core::secret_command::SECRET_COMMAND_TIMEOUT,
refresh_lock: Mutex::new(()),
}
}
/// A key from config, used only when nothing is stored and no env var is set.
pub fn with_fallback(mut self, key: Option<ApiKey>) -> Self {
self.fallback = key;
self
}
/// A key from the command line, which beats everything.
pub fn with_override(mut self, key: Option<ApiKey>) -> Self {
self.override_key = key;
self
}
/// Additional environment variables to consult (a user-declared provider).
pub fn with_env(mut self, env: Vec<String>) -> Self {
self.env.extend(env);
self
}
/// Override the header style, for a provider block that names one.
pub fn with_key_style(mut self, style: Option<KeyStyle>) -> Self {
if let Some(style) = style {
self.key_style = style;
}
self
}
/// Bound a `!command` key by `deadline` instead of the default.
pub fn with_command_deadline(mut self, deadline: std::time::Duration) -> Self {
self.command_deadline = deadline;
self
}
/// Treat a missing credential as fine (a local server).
pub fn keyless(mut self, keyless: bool) -> Self {
self.keyless = keyless;
self
}
/// Wrap in an `Arc` for an adapter.
pub fn into_arc(self) -> Arc<dyn AuthSource> {
Arc::new(self)
}
fn env_key(&self) -> Option<ApiKey> {
self.env
.iter()
.filter_map(|name| std::env::var(name).ok())
.map(|value| value.trim().to_string())
.find(|value| !value.is_empty())
.map(ApiKey::new)
}
/// Turn a resolved credential into request headers.
async fn derive(&self, credential: &Credential) -> Result<RequestAuth, ProviderError> {
match credential {
Credential::ApiKey(api) => {
// `$ENV` / `!command` specs are expanded here, at the moment of use — never while
// listing credentials.
let resolved = self.resolve(&api.key).await?;
if resolved.trim().is_empty() {
return Err(self.missing("its stored key resolved to nothing"));
}
Ok(self.api_key_auth(&ApiKey::new(resolved)))
}
Credential::OAuth(oauth) => self.oauth_auth(oauth),
}
}
/// A key spec as its value; a `!command` runs bounded, off the runtime thread.
async fn resolve(&self, key: &ApiKey) -> Result<String, ProviderError> {
resolve_value_async(key.expose(), self.command_deadline)
.await
.map_err(|reason| self.missing(&reason))
}
/// An override or fallback spec as a key, `None` when absent or when it expands to nothing.
///
/// Resolved on every call with nothing cached, so a short-lived token from a `!command` is
/// fresh for each request. A local server needs no key, so a spec that will not resolve is no
/// reason to stop there.
async fn resolve_spec(&self, spec: Option<&ApiKey>) -> Result<Option<ApiKey>, String> {
let Some(spec) = spec else { return Ok(None) };
match resolve_value_async(spec.expose(), self.command_deadline).await {
Ok(value) if !value.trim().is_empty() => Ok(Some(ApiKey::new(value))),
Err(reason) if !self.keyless => Err(reason),
_ => Ok(None),
}
}
/// The override, resolved. Signing in would not help when it fails, since it outranks the
/// store, so its error says which key it was rather than pointing at `luxe auth login`.
async fn resolved_override(&self) -> Result<Option<ApiKey>, ProviderError> {
self.resolve_spec(self.override_key.as_ref()).await.map_err(|reason| {
ProviderError::Auth(format!(
"the key given for '{}' on this run could not be read — {reason}",
self.provider_id
))
})
}
fn api_key_auth(&self, key: &ApiKey) -> RequestAuth {
self.key_style.headers(key)
}
/// OAuth headers, which are provider-specific beyond the bearer token.
fn oauth_auth(&self, oauth: &OAuthCredential) -> Result<RequestAuth, ProviderError> {
let mut auth = RequestAuth::bearer(&oauth.access);
match self.flow {
Some(OauthFlow::OpenaiCodex) => {
let account = oauth
.account
.clone()
.or_else(|| super::oauth::openai_codex::account_id(oauth.access.expose()))
.ok_or_else(|| {
self.missing("its ChatGPT credential carries no account id; sign in again")
})?;
auth = auth
.with_header("chatgpt-account-id", account)
.with_header("OpenAI-Beta", "responses=experimental")
.with_header("originator", super::oauth::openai_codex::originator());
}
Some(OauthFlow::GithubCopilot) => {
for (name, value) in super::oauth::github_copilot::EDITOR_HEADERS {
auth = auth.with_header(name, *value);
}
let base = oauth.endpoint.clone().unwrap_or_else(|| {
super::oauth::github_copilot::api_base_url(
oauth.access.expose(),
oauth.enterprise_domain.as_deref(),
)
});
auth = auth.with_base_url(base);
}
// OpenRouter's flow mints a plain API key, so it never lands here.
Some(OauthFlow::OpenRouter) | None => {}
}
Ok(auth)
}
/// Refresh the stored OAuth credential if it's within the margin of expiry.
///
/// Double-checked: the cheap check happens outside the lock, the authoritative one inside, so
/// concurrent turns produce exactly one refresh and the rotated token is persisted before any of
/// them reads it.
async fn refreshed(&self, current: OAuthCredential) -> Result<OAuthCredential, ProviderError> {
if current.expires_at_ms == 0 || now_ms() + REFRESH_MARGIN_MS < current.expires_at_ms {
return Ok(current);
}
let Some(flow) = self.flow else { return Ok(current) };
let _guard = self.refresh_lock.lock().await;
// Re-read under the lock: another task may have refreshed while we waited.
let latest = self
.store
.credential(&self.provider_id)
.and_then(|credential| credential.as_oauth().cloned())
.unwrap_or(current);
if latest.expires_at_ms != 0 && now_ms() + REFRESH_MARGIN_MS < latest.expires_at_ms {
return Ok(latest);
}
tracing::debug!(provider = %self.provider_id, "refreshing an expiring OAuth token");
let refreshed = super::oauth::refresh(flow, &latest).await.map_err(|error| {
ProviderError::Auth(format!(
"{}: could not refresh the stored credential ({error}) — run `luxe auth login {}`",
self.provider_id, self.provider_id
))
})?;
if let Err(error) = self.store.put(&self.provider_id, &Credential::OAuth(refreshed.clone()))
{
// A token we can't persist still works for this request; the next process pays again.
tracing::warn!(provider = %self.provider_id, %error, "could not persist refreshed token");
}
Ok(refreshed)
}
fn missing(&self, reason: &str) -> ProviderError {
ProviderError::Auth(format!(
"no credential for '{provider}' — {reason}. Run `luxe auth login {provider}` (or \
`/login {provider}` in the TUI).",
provider = self.provider_id
))
}
}
#[async_trait::async_trait]
impl AuthSource for StoreAuth {
async fn oauth_credential(&self) -> Option<OAuthCredential> {
// a key typed for this run outranks the store, so the store's sign-in is not this run's,
// unless that key expands to nothing and `request_auth` falls through to the store too
if !matches!(self.resolved_override().await, Ok(None)) {
return None;
}
self.store
.credential(&self.provider_id)
.and_then(|credential| credential.as_oauth().cloned())
}
async fn request_auth(&self) -> Result<RequestAuth, ProviderError> {
// An explicit command-line key is the user speaking about this run specifically.
if let Some(key) = self.resolved_override().await? {
return Ok(self.api_key_auth(&key));
}
if let Some(credential) = self.store.credential(&self.provider_id) {
return match credential {
Credential::OAuth(oauth) => {
let fresh = self.refreshed(oauth).await?;
self.derive(&Credential::OAuth(fresh)).await
}
api_key => self.derive(&api_key).await,
};
}
if let Some(key) = self.env_key() {
return Ok(self.api_key_auth(&key));
}
if let Some(key) = self
.resolve_spec(self.fallback.as_ref())
.await
.map_err(|reason| self.missing(&reason))?
{
return Ok(self.api_key_auth(&key));
}
if self.keyless {
return Ok(RequestAuth::none());
}
Err(self.missing("nothing is stored and no environment variable is set"))
}
}
#[cfg(test)]
mod tests;