Lightweight coding agent that runs in your terminal
Rust
Add request-scoped OAuth credentials and session lifecycle APIs (#56036)
smurching-oai09ec2451bf9a
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex d980227377..bb178d3a09 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -4144,6 +4144,7 @@ name = "codex-model-provider-info"version = "0.0.0"dependencies = ["codex-client",+ "codex-http-client","codex-protocol","codex-utils-absolute-path","codex-utils-redacted-string",@@ -4154,7 +4155,6 @@ dependencies = ["serde","tempfile","toml 0.9.11+spec-1.1.0",- "url",][[package]]diff --git a/codex-rs/http-client/Cargo.toml b/codex-rs/http-client/Cargo.tomlindex 7eb21d3358..fa144cbb70 100644--- a/codex-rs/http-client/Cargo.toml+++ b/codex-rs/http-client/Cargo.toml@@ -25,6 +25,7 @@ thiserror = { workspace = true }tokio = { workspace = true, features = ["macros", "rt", "time", "sync"] }tracing = { workspace = true }tracing-opentelemetry = { workspace = true }+url = { workspace = true }zstd = { workspace = true }[target.'cfg(target_os = "macos")'.dependencies]diff --git a/codex-rs/http-client/src/lib.rs b/codex-rs/http-client/src/lib.rsindex b199a3f676..c982757788 100644--- a/codex-rs/http-client/src/lib.rs+++ b/codex-rs/http-client/src/lib.rs@@ -1,3 +1,6 @@+use url::Host;+use url::Url;+mod chatgpt_cloudflare_cookies;mod chatgpt_hosts;mod client;@@ -83,3 +86,26 @@ pub use crate::windows_proxy_auth::WindowsProxyTls;pub use crate::windows_proxy_auth::connect_windows_proxy;#[cfg(windows)]pub use crate::windows_tls::build_windows_platform_tls_config;++/// Validates HTTPS or loopback HTTP endpoints, rejecting userinfo and fragments.+/// Errors identify the caller-supplied field without including the URL.+pub fn validate_endpoint_url(value: &str, field: &str) -> Result<Url, String> {+ let url = Url::parse(value).map_err(|_| format!("invalid {field} URL"))?;+ let loopback = match url.host() {+ Some(Host::Domain(host)) => host.eq_ignore_ascii_case("localhost"),+ Some(Host::Ipv4(host)) => host.is_loopback(),+ Some(Host::Ipv6(host)) => host.is_loopback(),+ None => false,+ };+ if url.host().is_none()+ || !url.username().is_empty()+ || url.password().is_some()+ || url.fragment().is_some()+ || !(url.scheme() == "https" || (url.scheme() == "http" && loopback))+ {+ return Err(format!(+ "{field} must use HTTPS (or loopback HTTP), without userinfo or a fragment"+ ));+ }+ Ok(url)+}diff --git a/codex-rs/login/src/lib.rs b/codex-rs/login/src/lib.rsindex b0863ee7c2..39fbb7ead1 100644--- a/codex-rs/login/src/lib.rs+++ b/codex-rs/login/src/lib.rs@@ -88,9 +88,11 @@ pub use oauth_session::OAuthSessionStatusChange as GatewayAuthStatusChange;pub use oauth_session::subscribe_oauth_session_status as subscribe_gateway_auth_status;pub use oauth_session::OAuthLoginControl;+pub use oauth_session::OAuthRequestCredentials;pub use oauth_session::OAuthSessionConfig;pub use oauth_session::OAuthSessionError;pub use oauth_session::OAuthSessionManager;+pub use oauth_session::OAuthSessionRequest;pub use oauth_session::OAuthSessionStatus;pub use oauth_session::OAuthSessionStatusChange;pub use oauth_session::subscribe_oauth_session_status;diff --git a/codex-rs/login/src/oauth_session.rs b/codex-rs/login/src/oauth_session.rsindex 4119aab553..c62fa6135b 100644--- a/codex-rs/login/src/oauth_session.rs+++ b/codex-rs/login/src/oauth_session.rs@@ -29,22 +29,26 @@ use http::StatusCode;use sha2::Digest;use sha2::Sha256;use tokio::sync::Mutex;-use url::Host;use url::Url;#[path = "oauth_session_callback.rs"]mod callback;#[path = "oauth_session_login.rs"]mod login;+#[path = "oauth_session_request.rs"]+mod request;#[path = "oauth_session_storage.rs"]mod storage;#[path = "oauth_session_token.rs"]mod token;+pub use codex_model_provider_info::OAuthSessionConfig;pub use login::OAuthLoginControl;pub use login::OAuthSessionStatus;pub use login::OAuthSessionStatusChange;pub use login::subscribe_oauth_session_status;+pub use request::OAuthRequestCredentials;+pub use request::OAuthSessionRequest;use callback::CallbackListener;use storage::OAuthSessionStorage;@@ -63,26 +67,21 @@ pub enum OAuthSessionError {LoginInProgress,}-/// Public-client OAuth settings that identify one configured authorization grant.-#[derive(Clone, PartialEq, Eq)]-pub struct OAuthSessionConfig {- pub authorization_url: String,- pub token_url: String,- pub client_id: String,- pub resource: Option<String>,- pub scopes: Vec<String>,- pub redirect_port: Option<u16>,-}-/// Resolves and persists an OAuth access token without knowing how a consumer uses it.#[derive(Clone)]pub struct OAuthSessionManager {control: Arc<OAuthLoginControl>,state: Arc<OAuthSessionState>,+ // Whether resolving missing/rejected credentials may start browser sign-in.+ // Existing credentials can still be reused or refreshed when this is false.+ allow_interactive_login: bool,}+#[derive(Clone)]enum RefreshPolicy {WhenExpired,+ // Reconcile the cached token with the persisted grant before reusing it.+ ObserveStored,AfterRejection(String),}@@ -90,7 +89,7 @@ impl RefreshPolicy {fn can_reuse(&self, token: &StoredToken) -> bool {token_is_usable(token)&& match self {- Self::WhenExpired => true,+ Self::WhenExpired | Self::ObserveStored => true,Self::AfterRejection(rejected_access_token) => {token.access_token != *rejected_access_token}@@ -99,7 +98,7 @@ impl RefreshPolicy {}enum RefreshOutcome {- AccessToken(String),+ Credentials(StoredToken),LoginRequired,}@@ -145,6 +144,7 @@ impl OAuthSessionManager {.map_err(|_| io::Error::other("failed to create provider OAuth HTTP client"))?;Ok(Self {control: OAuthLoginControl::for_host(&codex_home, http_client_factory),+ allow_interactive_login: true,state: Arc::new(OAuthSessionState {config,status_tx: login::status_sender_for_host(&codex_home, http_client_factory),@@ -158,6 +158,27 @@ impl OAuthSessionManager {})}+ /// Keeps background credential consumers from opening a browser without+ /// changing the login behavior of other managers in the same runtime.+ pub fn without_interactive_login(mut self) -> Self {+ self.allow_interactive_login = false;+ self+ }++ fn interactive_login_allowed(&self) -> bool {+ self.allow_interactive_login+ && !self+ .control+ .explicit_login+ .load(std::sync::atomic::Ordering::Relaxed)+ }++ /// Keeps the sent token paired with its sign-in identity across unauthorized+ /// recovery and retries, using the existing gateway credential lifecycle.+ pub fn begin_request(&self) -> OAuthSessionRequest {+ OAuthSessionRequest::new(self.clone())+ }+/// Returns a usable token, refreshing or starting browser login according to the host policy.pub async fn resolve_access_token(&self) -> io::Result<String> {self.resolve_with_browser(RefreshPolicy::WhenExpired, login::open_browser)@@ -181,6 +202,16 @@ impl OAuthSessionManager {policy: RefreshPolicy,open_browser: impl FnOnce(&Url),) -> io::Result<String> {+ self.resolve_credentials_with_browser(policy, open_browser)+ .await+ .map(|token| token.access_token)+ }++ async fn resolve_credentials_with_browser(+ &self,+ policy: RefreshPolicy,+ open_browser: impl FnOnce(&Url),+ ) -> io::Result<StoredToken> {validate_config(&self.state.config)?;let mut cached = self.lock_cached_token().await?;let terminal_status = self.state.status.borrow().as_ref().is_some_and(|snapshot| {@@ -199,11 +230,7 @@ impl OAuthSessionManager {&& cached.login_required.is_some()&& cached.token == cached.login_required{- if !self- .control- .explicit_login- .load(std::sync::atomic::Ordering::Relaxed)- {+ if self.interactive_login_allowed() {return self.authorize_with_browser(&mut cached, open_browser).await;}return Err(self.login_required_error(cached.token.as_ref()));@@ -222,9 +249,9 @@ impl OAuthSessionManager {if !terminal_matches {self.publish_status(OAuthSessionStatus::Succeeded, Some(token));}- let access_token = token.access_token.clone();+ let token = token.clone();cached.login_required = None;- return Ok(access_token);+ return Ok(token);}// The provider may rotate its token before the HTTP response arrives. Keep the// refresh, persistence, and cache update alive if the caller drops this future.@@ -232,10 +259,10 @@ impl OAuthSessionManager {let (mut cached, result) = tokio::spawn(async move {let result = match manager.refresh(&mut cached, &policy).await {Err(error) => Err(error),- Ok(RefreshOutcome::AccessToken(access_token)) => {+ Ok(RefreshOutcome::Credentials(token)) => {cached.login_required = None;- manager.publish_status(OAuthSessionStatus::Succeeded, cached.token.as_ref());- Ok(access_token)+ manager.publish_status(OAuthSessionStatus::Succeeded, Some(&token));+ Ok(token)}Ok(RefreshOutcome::LoginRequired) => {cached.login_required = cached.token.clone();@@ -251,10 +278,7 @@ impl OAuthSessionManager {.get_ref().and_then(|source| source.downcast_ref::<OAuthSessionError>())== Some(&OAuthSessionError::LoginRequired)- }) && !self- .control- .explicit_login- .load(std::sync::atomic::Ordering::Relaxed)+ }) && self.interactive_login_allowed(){return self.authorize_with_browser(&mut cached, open_browser).await;}@@ -265,7 +289,7 @@ impl OAuthSessionManager {&self,cached: &mut OAuthSessionCache,credential_lock: &Arc<std::fs::File>,- ) -> io::Result<String> {+ ) -> io::Result<StoredToken> {let token = cached.pending.as_ref()@@ -281,10 +305,10 @@ impl OAuthSessionManager {}).await.map_err(|_| io::Error::other("provider OAuth credential save task failed"))??;- let access_token = token.access_token.clone();+ let token = token.clone();cached.token = cached.pending.take();cached.login_required = None;- Ok(access_token)+ Ok(token)}async fn refresh(@@ -307,7 +331,7 @@ impl OAuthSessionManager {if let Some(token) = cached.token.as_ref()&& policy.can_reuse(token){- return Ok(RefreshOutcome::AccessToken(token.access_token.clone()));+ return Ok(RefreshOutcome::Credentials(token.clone()));}let Some(refresh_token) = cached.token@@ -326,11 +350,11 @@ impl OAuthSessionManager {.await{Ok(response) => {- cached.pending = Some(response.into_stored(Some(refresh_token))?);+ cached.pending = Some(response.into_stored(cached.token.as_ref())?);return self.persist_pending(cached, &credential_lock).await- .map(RefreshOutcome::AccessToken);+ .map(RefreshOutcome::Credentials);}Err(OAuthError::Rejected(rejection))if rejection.status == StatusCode::BAD_REQUEST@@ -365,13 +389,14 @@ impl OAuthSessionManager {if let Some(token) = cached.token.as_ref()&& policy.can_reuse(token){- return Ok(RefreshOutcome::AccessToken(token.access_token.clone()));+ return Ok(RefreshOutcome::Credentials(token.clone()));}}Ok(RefreshOutcome::LoginRequired)}- fn credential_id(&self) -> String {+ /// Stable, opaque identity of the issuer, client, audience, and scopes.+ pub fn credential_id(&self) -> String {let config = &self.state.config;let mut digest = Sha256::new();digest.update(self.state.codex_home.to_string_lossy().as_bytes());@@ -420,7 +445,7 @@ impl OAuthSessionManager {&self,cached: &mut OAuthSessionCache,open_browser: impl FnOnce(&Url),- ) -> io::Result<String> {+ ) -> io::Result<StoredToken> {let pkce = generate_pkce();let state = generate_state();let mut listener = CallbackListener::new(self.state.config.redirect_port, state.clone())?;@@ -468,10 +493,10 @@ impl OAuthSessionManager {Some(&redirect_uri),)})?;- cached.pending = Some(response.into_stored(/*previous_refresh_token*/ None)?);- let access_token = self.persist_pending(cached, &credential_lock).await?;- self.publish_status(OAuthSessionStatus::Succeeded, cached.token.as_ref());- Ok(access_token)+ cached.pending = Some(response.into_stored(/*previous_token*/ None)?);+ let token = self.persist_pending(cached, &credential_lock).await?;+ self.publish_status(OAuthSessionStatus::Succeeded, Some(&token));+ Ok(token)}fn oauth(&self) -> OAuthClient<'_> {@@ -488,18 +513,6 @@ impl OAuthSessionManager {}}-impl fmt::Debug for OAuthSessionConfig {- fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {- // Configured URLs may contain issuer-specific credentials in arbitrary query keys.- formatter- .debug_struct("OAuthSessionConfig")- .field("client_id", &self.client_id)- .field("scopes", &self.scopes)- .field("redirect_port", &self.redirect_port)- .finish_non_exhaustive()- }-}-impl fmt::Debug for OAuthSessionManager {fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {formatter@@ -552,24 +565,7 @@ fn validate_config(config: &OAuthSessionConfig) -> io::Result<()> {}fn validate_oauth_url(value: &str, description: &str) -> io::Result<Url> {- let url = Url::parse(value).map_err(|_| io::Error::other(format!("invalid {description}")))?;- if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {- return Err(io::Error::other(format!(- "{description} cannot include embedded credentials or fragments"- )));- }- let is_loopback = match url.host() {- Some(Host::Ipv4(address)) => address.is_loopback(),- Some(Host::Ipv6(address)) => address.is_loopback(),- Some(Host::Domain(host)) => host.eq_ignore_ascii_case("localhost"),- None => false,- };- if url.scheme() != "https" && !(url.scheme() == "http" && is_loopback) {- return Err(io::Error::other(format!(- "{description} must use HTTPS unless it is loopback"- )));- }- Ok(url)+ codex_http_client::validate_endpoint_url(value, description).map_err(io::Error::other)}#[cfg(test)]diff --git a/codex-rs/login/src/oauth_session_login.rs b/codex-rs/login/src/oauth_session_login.rsindex 443366d2d4..982ab246b7 100644--- a/codex-rs/login/src/oauth_session_login.rs+++ b/codex-rs/login/src/oauth_session_login.rs@@ -112,6 +112,42 @@ pub(super) fn status_sender_for_host(}impl OAuthSessionManager {+ /// Identifies the persisted sign-in without refreshing an expired access token.+ /// Refresh preserves this ID; explicit login creates a new one.+ pub async fn authorization_id(&self) -> io::Result<String> {+ let _lock = storage::lock_credentials(&self.state.codex_home).await?;+ self.load_token_async()+ .await?+ .and_then(|token| token.authorization_id)+ .ok_or_else(|| {+ io::Error::new(+ io::ErrorKind::PermissionDenied,+ OAuthSessionError::LoginRequired,+ )+ })+ }++ pub async fn login(&self) -> io::Result<()> {+ self.login_with_browser(std::future::pending(), open_browser)+ .await+ }++ /// Removes the persisted grant and its in-memory copy without contacting the issuer.+ pub async fn logout(&self) -> io::Result<bool> {+ let mut cached = self.lock_cached_token().await?;+ let credential_lock = storage::lock_credentials(&self.state.codex_home).await?;+ let manager = self.clone();+ tokio::task::spawn_blocking(move || {+ let _credential_lock = credential_lock;+ let removed = manager.state.storage.delete(&manager.credential_id())?;+ *cached = OAuthSessionCache::default();+ manager.publish_status(OAuthSessionStatus::NotReady, /*credential*/ None);+ Ok(removed)+ })+ .await+ .map_err(|_| io::Error::other("provider OAuth credential removal task failed"))?+ }+/// Returns the OAuth account configuration used to scope status notifications.pub fn config(&self) -> &OAuthSessionConfig {&self.state.configdiff --git a/codex-rs/login/src/oauth_session_login_tests.rs b/codex-rs/login/src/oauth_session_login_tests.rsindex 95eb6cb565..a813fd5950 100644--- a/codex-rs/login/src/oauth_session_login_tests.rs+++ b/codex-rs/login/src/oauth_session_login_tests.rs@@ -6,6 +6,37 @@ use crate::OAuthSessionStatus;use pretty_assertions::assert_eq;use tokio::sync::Notify;+#[tokio::test]+async fn logout_removes_saved_and_cached_credentials() {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ let manager = manager.without_interactive_login();+ save_token(+ &manager,+ "access",+ Some("refresh"),+ Utc::now().timestamp() + 3600,+ );+ assert_eq!(manager.resolve_access_token().await.unwrap(), "access");+ assert_eq!(+ manager.status().await.unwrap(),+ OAuthSessionStatus::Succeeded+ );++ assert!(manager.logout().await.unwrap());+ assert!(manager.load_token().unwrap().is_none());+ assert_eq!(+ manager.status().await.unwrap(),+ OAuthSessionStatus::NotReady+ );+ assert_eq!(+ manager.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::PermissionDenied,+ );+ assert!(!manager.logout().await.unwrap());+ assert!(server.received_requests().await.unwrap().is_empty());+}+#[tokio::test]async fn status_subscriptions_survive_gateway_changes_and_are_isolated_by_home() {let server = MockServer::start().await;@@ -285,6 +316,7 @@ async fn expired_readiness_stays_not_ready_while_refresh_is_blocked() {let server = MockServer::start().await;let (manager, home) = client(config(&server), Arc::new(MockKeyringStore::default()));let expired = StoredToken {+ authorization_id: None,access_token: "expired".into(),refresh_token: Some("refresh".into()),expires_at: Some(Utc::now().timestamp() - 1),@@ -526,6 +558,18 @@ async fn legacy_policy_authorizes_missing_and_rejected_credentials() {std::io::ErrorKind::PermissionDenied);manager.control.allow_automatic_login();+ assert_eq!(+ manager+ .clone()+ .without_interactive_login()+ .resolve_with_browser(super::super::RefreshPolicy::WhenExpired, |_| panic!(+ "background mode opened browser"+ ))+ .await+ .unwrap_err()+ .kind(),+ std::io::ErrorKind::PermissionDenied+ );assert_eq!(manager.resolve_with_browser(diff --git a/codex-rs/login/src/oauth_session_request.rs b/codex-rs/login/src/oauth_session_request.rsnew file mode 100644index 0000000000..61db0b291e--- /dev/null+++ b/codex-rs/login/src/oauth_session_request.rs@@ -0,0 +1,70 @@+//! Coherent request credentials and unauthorized recovery for configured OAuth consumers.+//! The session manager owns observation, refresh, locking, and persistence; a request+//! retains only its rejected token so transport retries cannot forget recovery.++use super::OAuthSessionManager;+use super::RefreshPolicy;+use super::login;+use std::fmt;+use std::io;++/// A token and the identity of the exact grant that supplied it.+pub struct OAuthRequestCredentials {+ pub access_token: String,+ pub authorization_id: Option<String>,+}++impl fmt::Debug for OAuthRequestCredentials {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.debug_struct("OAuthRequestCredentials")+ .field("access_token", &"<redacted>")+ .field("authorization_id", &self.authorization_id)+ .finish()+ }+}++/// One consumer request and its retries, using the existing session's credential state.+pub struct OAuthSessionRequest {+ manager: OAuthSessionManager,+ policy: RefreshPolicy,+ sent_token: Option<String>,+}++impl OAuthSessionRequest {+ pub(super) fn new(manager: OAuthSessionManager) -> Self {+ Self {+ manager,+ policy: RefreshPolicy::ObserveStored,+ sent_token: None,+ }+ }++ /// Observes persisted credentials using the existing session lifecycle. The returned+ /// identity is captured with the token, never read separately after resolution.+ pub async fn credentials(&mut self) -> io::Result<OAuthRequestCredentials> {+ let token = self+ .manager+ .resolve_credentials_with_browser(self.policy.clone(), login::open_browser)+ .await?;+ self.sent_token = Some(token.access_token.clone());+ Ok(OAuthRequestCredentials {+ access_token: token.access_token,+ authorization_id: token.authorization_id,+ })+ }++ /// Marks the sent credential as rejected. Callers bound unauthorized replays;+ /// transient transport failures retain this state until resolution succeeds.+ pub fn reject_credentials(&mut self) -> bool {+ let Some(token) = self.sent_token.take() else {+ return false;+ };+ self.policy = RefreshPolicy::AfterRejection(token);+ true+ }++ /// Identifies credential failures that belong to unauthorized recovery.+ pub fn is_recovering(&self) -> bool {+ matches!(self.policy, RefreshPolicy::AfterRejection(_))+ }+}diff --git a/codex-rs/login/src/oauth_session_request_tests.rs b/codex-rs/login/src/oauth_session_request_tests.rsnew file mode 100644index 0000000000..7b7141d580--- /dev/null+++ b/codex-rs/login/src/oauth_session_request_tests.rs@@ -0,0 +1,56 @@+//! Request credentials retain their grant identity through unauthorized recovery.++use super::*;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn request_refresh_retry_keeps_the_same_sign_in() {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ manager+ .save_token(&StoredToken {+ access_token: "rejected".into(),+ authorization_id: Some("grant".into()),+ refresh_token: Some("refresh".into()),+ expires_at: Some(Utc::now().timestamp() + 3_600),+ })+ .unwrap();+ let mut request = manager.begin_request();+ assert_eq!(+ request.credentials().await.unwrap().access_token,+ "rejected"+ );+ assert!(request.reject_credentials());+ Mock::given(method("POST"))+ .and(path("/token"))+ .and(body_string_contains("refresh_token=refresh"))+ .respond_with(ResponseTemplate::new(503))+ .expect(1)+ .mount(&server)+ .await;+ assert!(request.credentials().await.is_err());+ server.verify().await;+ server.reset().await;+ Mock::given(method("POST"))+ .and(path("/token"))+ .and(body_string_contains("refresh_token=refresh"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "access_token": "replacement",+ "token_type": "Bearer",+ "expires_in": 3600+ })))+ .expect(1)+ .mount(&server)+ .await;+ let credentials = request.credentials().await.unwrap();+ assert_eq!(+ (credentials.access_token, credentials.authorization_id),+ ("replacement".into(), Some("grant".into()))+ );+ assert_eq!(manager.authorization_id().await.unwrap(), "grant");+ // Ordinary transport retries reuse the refreshed token without another exchange.+ assert_eq!(+ request.credentials().await.unwrap().access_token,+ "replacement"+ );+}diff --git a/codex-rs/login/src/oauth_session_storage.rs b/codex-rs/login/src/oauth_session_storage.rsindex a82b53fff5..41b34ec4f6 100644--- a/codex-rs/login/src/oauth_session_storage.rs+++ b/codex-rs/login/src/oauth_session_storage.rs@@ -73,6 +73,12 @@ impl OAuthSessionStorage {.set(&SecretScope::Global, &secret_name(credential_id)?, value).map_err(|_| io::Error::other("failed to save provider OAuth credentials"))}++ pub(super) fn delete(&self, credential_id: &str) -> io::Result<bool> {+ self.0+ .delete(&SecretScope::Global, &secret_name(credential_id)?)+ .map_err(|_| io::Error::other("failed to remove provider OAuth credentials"))+ }}fn secret_name(credential_id: &str) -> io::Result<SecretName> {diff --git a/codex-rs/login/src/oauth_session_tests.rs b/codex-rs/login/src/oauth_session_tests.rsindex 7007c0f606..0c16ba7656 100644--- a/codex-rs/login/src/oauth_session_tests.rs+++ b/codex-rs/login/src/oauth_session_tests.rs@@ -26,6 +26,9 @@ use crate::test_support::transport_default_auth_route_config;#[path = "oauth_session_login_tests.rs"]mod login_tests;+#[path = "oauth_session_request_tests.rs"]+mod request_tests;+#[path = "oauth_session_storage_tests.rs"]mod storage_tests;@@ -48,6 +51,7 @@ fn client(fn config(server: &MockServer) -> OAuthSessionConfig {OAuthSessionConfig {authorization_url: format!("{}/authorize", server.uri()),+ device_authorization_url: None,token_url: format!("{}/token", server.uri()),client_id: "codex-test".to_string(),resource: Some("https://gateway.example.test/codex".to_string()),@@ -59,6 +63,7 @@ fn config(server: &MockServer) -> OAuthSessionConfig {fn loopback_config() -> OAuthSessionConfig {OAuthSessionConfig {authorization_url: "http://127.0.0.1:18080/authorize".to_string(),+ device_authorization_url: None,token_url: "http://127.0.0.1:18080/token".to_string(),client_id: "codex-test".to_string(),resource: None,@@ -74,6 +79,7 @@ fn save_token(expires_at: i64,) {let token = StoredToken {+ authorization_id: None,access_token: access_token.to_string(),refresh_token: refresh_token.map(str::to_string),expires_at: Some(expires_at),@@ -492,6 +498,7 @@ async fn gateway_credentials_use_a_dedicated_encrypted_file_and_reload_large_tok.expect("gateway auth manager");client.save_token(&StoredToken {+ authorization_id: None,access_token: access_token.clone(),refresh_token: None,expires_at: None,@@ -570,9 +577,18 @@ async fn browser_authorization_exchanges_and_persists_under_the_store_lock() {.await.expect("browser authorization");- assert_eq!(token, "browser-access-token");- let expected =- json!({"access_token": "browser-access-token", "refresh_token": "browser-refresh-token"});+ assert_eq!(token.access_token, "browser-access-token");+ let authorization_id = cached+ .token+ .as_ref()+ .and_then(|token| token.authorization_id.as_ref())+ .expect("new browser authorization has a grant ID");+ let expected = json!({+ "access_token": "browser-access-token",+ "refresh_token": "browser-refresh-token",+ "authorization_id": authorization_id,+ });+assert_eq!(serde_json::to_value(cached.token.as_ref()).expect("cached token"),expected@@ -632,7 +648,8 @@ async fn token_grants_reject_redirects_without_sending_credentials_to_the_targetclient.authorize_with_browser(&mut cached, complete_browser_authorization).await- .expect_err("code exchange redirect")+ .err()+ .expect("code exchange redirect")}};assert!(@@ -830,6 +847,7 @@ async fn only_explicit_refresh_grant_rejections_request_reauthorization() {(400, Some("invalid_request")),(400, None),(401, Some("unauthorized_client")),+ (429, Some("temporarily_unavailable")),(503, Some("unsupported_grant_type")),] {let server = MockServer::start().await;@@ -859,10 +877,16 @@ async fn only_explicit_refresh_grant_rejections_request_reauthorization() {assert!(matches!(result, Ok(super::RefreshOutcome::LoginRequired)));}_ => {- let message = result- .err()- .expect("surface token endpoint failure")- .to_string();+ let error = result.err().expect("surface token endpoint failure");+ assert_eq!(+ error.kind(),+ if status >= 500 || status == 429 {+ std::io::ErrorKind::Other+ } else {+ std::io::ErrorKind::PermissionDenied+ }+ );+ let message = error.to_string();assert!(message.contains(&format!("returned HTTP {status}")));if let Some(error_code) = error_code {assert!(message.contains(error_code));@@ -890,6 +914,7 @@ async fn invalid_grant_recovers_external_credentials_with_a_bounded_retry() {.respond_with(move |_: &wiremock::Request| {writer.save_token(&StoredToken {+ authorization_id: None,access_token: "external-access".to_string(),refresh_token: Some("external-refresh".to_string()),expires_at: retry_status.map(|_| Utc::now().timestamp() - 1),@@ -1085,6 +1110,7 @@ async fn failed_save_retains_rotation_without_overwriting_a_new_external_login()if recovery == Recovery::ExternalLogin {manager.save_token(&StoredToken {+ authorization_id: None,access_token: "external-access".to_string(),refresh_token: Some("external-refresh".to_string()),expires_at: None,@@ -1105,7 +1131,8 @@ async fn failed_save_retains_rotation_without_overwriting_a_new_external_login()manager.authorize_with_browser(&mut cached, complete_browser_authorization).await- .expect_err("failed login must preserve the correct recovery baseline");+ .err()+ .expect("failed login must preserve the correct recovery baseline");}if recovery == Recovery::Expired {managerdiff --git a/codex-rs/login/src/oauth_session_token.rs b/codex-rs/login/src/oauth_session_token.rsindex ecf0086bb2..fe05508626 100644--- a/codex-rs/login/src/oauth_session_token.rs+++ b/codex-rs/login/src/oauth_session_token.rs@@ -3,6 +3,7 @@use std::io;use crate::oauth::OAuthError;+use crate::oauth::generate_state;use crate::oauth::sanitize_url_for_logging;use chrono::Utc;use codex_secrets::redact_secrets;@@ -14,6 +15,9 @@ use super::OAuthSessionConfig;#[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]pub(super) struct StoredToken {pub access_token: String,+ /// Stable across refreshes, replaced by a new authorization grant.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub authorization_id: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]pub refresh_token: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]@@ -34,7 +38,7 @@ pub(super) struct TokenResponse {impl TokenResponse {pub(super) fn into_stored(self,- previous_refresh_token: Option<&str>,+ previous_token: Option<&StoredToken>,) -> io::Result<StoredToken> {if self.access_token.trim().is_empty() {return Err(io::Error::other(@@ -68,9 +72,13 @@ impl TokenResponse {.transpose()?;Ok(StoredToken {access_token: self.access_token,+ authorization_id: match previous_token {+ Some(previous) => previous.authorization_id.clone(),+ None => Some(generate_state()),+ },refresh_token: self.refresh_token- .or_else(|| previous_refresh_token.map(str::to_string)),+ .or_else(|| previous_token.and_then(|previous| previous.refresh_token.clone())),expires_at,})}@@ -125,15 +133,28 @@ pub(super) fn endpoint_error(} else {"not applicable"};- io::Error::other(format!(- "provider OAuth token endpoint {endpoint} returned HTTP {} - {detail}{request_id}. Request: grant_type={grant_type}, client_id={client_id}, client_auth=none (public client), pkce={pkce}, redirect_uri={redirect_uri}, resource={resource}, authorization_scopes={scopes}",- rejection.status.as_u16(),- ))+ let kind = if rejection.status.is_server_error()+ || matches!(rejection.status.as_u16(), 408 | 429)+ {+ io::ErrorKind::Other+ } else {+ io::ErrorKind::PermissionDenied+ };+ io::Error::new(+ kind,+ format!(+ "provider OAuth token endpoint {endpoint} returned HTTP {} - {detail}{request_id}. Request: grant_type={grant_type}, client_id={client_id}, client_auth=none (public client), pkce={pkce}, redirect_uri={redirect_uri}, resource={resource}, authorization_scopes={scopes}",+ rejection.status.as_u16(),+ ),+ )}OAuthError::Transport(_) => io::Error::other(format!("provider OAuth token exchange failed for {endpoint}")),- OAuthError::InvalidResponse => io::Error::other("provider OAuth token response is invalid"),+ OAuthError::InvalidResponse => io::Error::new(+ io::ErrorKind::InvalidData,+ "provider OAuth token response is invalid",+ ),}}diff --git a/codex-rs/model-provider-info/Cargo.toml b/codex-rs/model-provider-info/Cargo.tomlindex e6a740d25d..51d3026637 100644--- a/codex-rs/model-provider-info/Cargo.toml+++ b/codex-rs/model-provider-info/Cargo.toml@@ -14,12 +14,12 @@ workspace = true[dependencies]codex-client = { workspace = true }+codex-http-client = { workspace = true }codex-protocol = { workspace = true }codex-utils-redacted-string = { workspace = true }http = { workspace = true }schemars = { workspace = true }serde = { workspace = true, features = ["derive"] }-url = { workspace = true }[dev-dependencies]codex-utils-absolute-path = { workspace = true }diff --git a/codex-rs/model-provider-info/src/gateway_oauth.rs b/codex-rs/model-provider-info/src/gateway_oauth.rsindex 21c5901ecf..11ff6ca6da 100644--- a/codex-rs/model-provider-info/src/gateway_oauth.rs+++ b/codex-rs/model-provider-info/src/gateway_oauth.rs@@ -2,12 +2,11 @@use std::fmt;+use codex_http_client::validate_endpoint_url;use http::header::HeaderName;use schemars::JsonSchema;use serde::Deserialize;use serde::Serialize;-use url::Host;-use url::Url;use crate::ModelProviderInfo;@@ -69,13 +68,13 @@ impl GatewayOAuthConfig {if provider.aws.is_some() || provider.is_amazon_bedrock() {return Err("provider gateway_oauth cannot be combined with AWS authentication".into());}- validate_url(&self.authorization_url, "gateway_oauth.authorization_url")?;- validate_url(&self.token_url, "gateway_oauth.token_url")?;+ validate_endpoint_url(&self.authorization_url, "gateway_oauth.authorization_url")?;+ validate_endpoint_url(&self.token_url, "gateway_oauth.token_url")?;let base_url = provider.base_url.as_deref().ok_or("gateway_oauth requires base_url")?;- validate_url(base_url, "base_url")?;+ validate_endpoint_url(base_url, "base_url")?;if self.client_id.trim().is_empty() || self.redirect_port == Some(0) {return Err("gateway_oauth requires a nonempty client_id and a nonzero redirect_port".into(),@@ -131,27 +130,6 @@ fn is_token(value: &str) -> bool {.all(|byte| byte.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&byte))}-fn validate_url(value: &str, field: &str) -> Result<(), String> {- let url = Url::parse(value).map_err(|_| format!("invalid {field} URL"))?;- let loopback = match url.host() {- Some(Host::Domain(host)) => host.eq_ignore_ascii_case("localhost"),- Some(Host::Ipv4(host)) => host.is_loopback(),- Some(Host::Ipv6(host)) => host.is_loopback(),- None => false,- };- if url.host().is_none()- || !url.username().is_empty()- || url.password().is_some()- || url.fragment().is_some()- || !(url.scheme() == "https" || (url.scheme() == "http" && loopback))- {- return Err(format!(- "{field} must use HTTPS (or loopback HTTP), without userinfo or a fragment"- ));- }- Ok(())-}-#[cfg(test)]#[path = "gateway_oauth_tests.rs"]mod tests;diff --git a/codex-rs/model-provider-info/src/lib.rs b/codex-rs/model-provider-info/src/lib.rsindex f020d34c25..a70ab290ea 100644--- a/codex-rs/model-provider-info/src/lib.rs+++ b/codex-rs/model-provider-info/src/lib.rs@@ -33,10 +33,12 @@ use std::time::Duration;mod capabilities;mod gateway_oauth;+mod oauth_session;pub use capabilities::ModelProviderCapabilities;pub use capabilities::RemoteCompactionSupport;pub use gateway_oauth::GatewayOAuthConfig;pub use gateway_oauth::GatewayOAuthDelivery;+pub use oauth_session::OAuthSessionConfig;pub const RESIDENCY_HEADER_NAME: &str = "x-openai-internal-codex-residency";diff --git a/codex-rs/model-provider-info/src/oauth_session.rs b/codex-rs/model-provider-info/src/oauth_session.rsnew file mode 100644index 0000000000..cd4bfb2ee6--- /dev/null+++ b/codex-rs/model-provider-info/src/oauth_session.rs@@ -0,0 +1,27 @@+//! Public-client OAuth settings shared by managed configuration and service sign-in.++use serde::Deserialize;+use serde::Serialize;+use std::fmt;++/// Settings identifying a configured OAuth grant, independent of token delivery.+#[derive(Clone, PartialEq, Eq, Deserialize, Serialize)]+#[serde(deny_unknown_fields)]+pub struct OAuthSessionConfig {+ pub authorization_url: String,+ pub token_url: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub device_authorization_url: Option<String>,+ pub client_id: String,+ pub resource: Option<String>,+ #[serde(default)]+ pub scopes: Vec<String>,+ pub redirect_port: Option<u16>,+}++impl fmt::Debug for OAuthSessionConfig {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ // Issuer settings may contain credentials in arbitrary query parameters.+ f.debug_struct("OAuthSessionConfig").finish_non_exhaustive()+ }+}diff --git a/codex-rs/model-provider/src/shared_state.rs b/codex-rs/model-provider/src/shared_state.rsindex 02dae76d79..e6f90597a8 100644--- a/codex-rs/model-provider/src/shared_state.rs+++ b/codex-rs/model-provider/src/shared_state.rs@@ -40,6 +40,7 @@ impl ModelProviderSharedState {) -> std::io::Result<Arc<GatewayAuthManager>> {let oauth = GatewayAuthConfig {authorization_url: config.authorization_url.clone(),+ device_authorization_url: None,token_url: config.token_url.clone(),client_id: config.client_id.clone(),resource: config.resource.clone(),diff --git a/codex-rs/model-provider/src/shared_state_test_support.rs b/codex-rs/model-provider/src/shared_state_test_support.rsindex d86ab79605..d7a60e063e 100644--- a/codex-rs/model-provider/src/shared_state_test_support.rs+++ b/codex-rs/model-provider/src/shared_state_test_support.rs@@ -73,6 +73,7 @@ pub fn seed_gateway_auth(let runtime = primary.runtime_config();let oauth = GatewayAuthConfig {authorization_url: config.authorization_url,+ device_authorization_url: None,token_url: config.token_url,client_id: config.client_id,resource: config.resource,