Lightweight coding agent that runs in your terminal
Rust
Add workspace routing support for Responses requests (#45812)
acrognale-oai58e2e8cf3c2a
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 3a4550fd90..cdb51f237f 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -4036,6 +4036,7 @@ dependencies = ["tempfile","tokio","tracing",+ "url","wiremock",]diff --git a/codex-rs/app-server/src/config_manager.rs b/codex-rs/app-server/src/config_manager.rsindex 3dca9dd143..c54c844516 100644--- a/codex-rs/app-server/src/config_manager.rs+++ b/codex-rs/app-server/src/config_manager.rs@@ -163,16 +163,18 @@ impl ConfigManager {manager.load_latest_config(/*fallback_cwd*/ None).await}- pub(crate) async fn load_latest_config_for_thread(+ pub(crate) async fn load_latest_config_with_session_layers(&self,- thread_config: &Config,+ session_layers: &ConfigLayerStack,+ cwd: &Path,) -> std::io::Result<Config> {- let refreshed_config = self- .load_latest_config(Some(thread_config.cwd.to_path_buf()))- .await?;- let mut config = thread_config- .rebuild_preserving_session_layers(&refreshed_config)- .await?;+ let refreshed_config = self.load_latest_config(Some(cwd.to_path_buf())).await?;+ let mut config = Config::rebuild_with_session_layers(+ session_layers,+ cwd.to_path_buf(),+ &refreshed_config,+ )+ .await?;self.apply_runtime_feature_enablement(&mut config);self.apply_arg0_paths(&mut config);Ok(config)diff --git a/codex-rs/app-server/src/config_manager_service_tests.rs b/codex-rs/app-server/src/config_manager_service_tests.rsindex a418909299..dae2c0c28e 100644--- a/codex-rs/app-server/src/config_manager_service_tests.rs+++ b/codex-rs/app-server/src/config_manager_service_tests.rs@@ -1344,7 +1344,9 @@ async fn managed_auth_policy_survives_unusable_requirements_file_changes() -> Re)?;for refreshed in [service.load_latest_config(/*fallback_cwd*/ None).await?,- service.load_latest_config_for_thread(&startup).await?,+ service+ .load_latest_config_with_session_layers(&startup.config_layer_stack, &startup.cwd)+ .await?,] {assert_eq!(refreshed.forced_login_method, None);assert_eq!(refreshed.forced_chatgpt_workspace_id, None);diff --git a/codex-rs/app-server/src/mcp_refresh.rs b/codex-rs/app-server/src/mcp_refresh.rsindex 2953580378..b654ad6a28 100644--- a/codex-rs/app-server/src/mcp_refresh.rs+++ b/codex-rs/app-server/src/mcp_refresh.rs@@ -57,7 +57,10 @@ async fn load_refresh_config() -> io::Result<Config> {let thread_config = thread.config().await;config_manager- .load_latest_config_for_thread(thread_config.as_ref())+ .load_latest_config_with_session_layers(+ &thread_config.config_layer_stack,+ &thread_config.cwd,+ ).await}diff --git a/codex-rs/app-server/src/request_processors/apps_processor.rs b/codex-rs/app-server/src/request_processors/apps_processor.rsindex 28add513f4..be74a8fb61 100644--- a/codex-rs/app-server/src/request_processors/apps_processor.rs+++ b/codex-rs/app-server/src/request_processors/apps_processor.rs@@ -361,7 +361,10 @@ impl AppsRequestProcessor {let (_, thread) = self.load_thread(thread_id).await?;let thread_config = thread.config().await;self.config_manager- .load_latest_config_for_thread(thread_config.as_ref())+ .load_latest_config_with_session_layers(+ &thread_config.config_layer_stack,+ &thread_config.cwd,+ ).await.map_err(|err| internal_error(format!("failed to reload config: {err}")))}diff --git a/codex-rs/app-server/src/request_processors/catalog_processor.rs b/codex-rs/app-server/src/request_processors/catalog_processor.rsindex ac2ed55997..45b8f132ff 100644--- a/codex-rs/app-server/src/request_processors/catalog_processor.rs+++ b/codex-rs/app-server/src/request_processors/catalog_processor.rs@@ -331,7 +331,10 @@ impl CatalogRequestProcessor {.map_err(|_| invalid_request(format!("thread not found: {thread_id}")))?;let thread_config = thread.config().await;self.config_manager- .load_latest_config_for_thread(thread_config.as_ref())+ .load_latest_config_with_session_layers(+ &thread_config.config_layer_stack,+ &thread_config.cwd,+ ).await.map_err(|err| internal_error(format!("failed to reload config: {err}")))?}diff --git a/codex-rs/app-server/src/request_processors/config_processor.rs b/codex-rs/app-server/src/request_processors/config_processor.rsindex b6b5348ede..adee7e1f65 100644--- a/codex-rs/app-server/src/request_processors/config_processor.rs+++ b/codex-rs/app-server/src/request_processors/config_processor.rs@@ -371,7 +371,10 @@ pub(super) async fn reload_user_config(};let current_config = thread.config().await;let next_config = match config_manager- .load_latest_config_for_thread(current_config.as_ref())+ .load_latest_config_with_session_layers(+ ¤t_config.config_layer_stack,+ ¤t_config.cwd,+ ).await{Ok(config) => config,diff --git a/codex-rs/app-server/src/request_processors/mcp_processor.rs b/codex-rs/app-server/src/request_processors/mcp_processor.rsindex f6e910392e..9c22739de9 100644--- a/codex-rs/app-server/src/request_processors/mcp_processor.rs+++ b/codex-rs/app-server/src/request_processors/mcp_processor.rs@@ -279,7 +279,10 @@ impl McpRequestProcessor {let thread_config = thread.config().await;let config = self.config_manager- .load_latest_config_for_thread(thread_config.as_ref())+ .load_latest_config_with_session_layers(+ &thread_config.config_layer_stack,+ &thread_config.cwd,+ ).await.map_err(|err| internal_error(format!("failed to reload config: {err}")))?;(config, Some(thread))diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex b60f810b99..5957c192bb 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -71,6 +71,7 @@ use codex_login::AuthManager;use codex_login::CodexAuth;use codex_login::RefreshTokenError;use codex_login::UnauthorizedRecovery;+use codex_login::default_client::ClientRedirectPolicy;use codex_login::default_client::add_originator_header;use codex_login::default_client::create_client_for_route;use codex_otel::SessionTelemetry;@@ -135,7 +136,9 @@ use codex_login::auth_env_telemetry::collect_auth_env_telemetry;use codex_model_provider::AgentIdentitySessionFallback;use codex_model_provider::ProviderAuthScope;use codex_model_provider::ProviderUnauthorizedRecovery;+use codex_model_provider::ResponsesConnectionKey;use codex_model_provider::SharedModelProvider;+use codex_model_provider::WorkspaceRoutingContext;use codex_model_provider::create_model_provider;#[cfg(test)]use codex_model_provider_info::DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS;@@ -193,6 +196,7 @@ fn session_telemetry_for_request(struct ModelClientState {thread_id: ThreadId,provider: SharedModelProvider,+ workspace_routing: WorkspaceRoutingContext,auth_env_telemetry: AuthEnvTelemetry,session_source: SessionSource,originator: String,@@ -209,6 +213,11 @@ struct ModelClientState {cached_websocket_session: StdMutex<WebsocketSession>,}+enum ClientRouting {+ Workspace,+ ConfiguredProvider,+}+/// Resolved API client setup for a single request attempt.////// Keeping this as a single bundle ensures prewarm and normal request paths@@ -216,7 +225,9 @@ struct ModelClientState {struct CurrentClientSetup {auth: Option<CodexAuth>,auth_owner_generation: Option<u64>,+ auth_revision: Option<u64>,api_provider: ApiProvider,+ redirect_policy: ClientRedirectPolicy,api_auth: SharedAuthProvider,agent_identity_telemetry: Option<AgentIdentityTelemetry>,}@@ -295,6 +306,7 @@ struct WebsocketSession {responses_headers: ApiHeaderMap,/// Owner of the cached state, including before a connection is opened.auth_owner_generation: Option<u64>,+ connection_key: Option<ResponsesConnectionKey>,last_request: Option<ResponsesApiRequest>,last_response_rx: Option<oneshot::Receiver<LastResponse>>,last_response_from_untraced_warmup: bool,@@ -443,6 +455,7 @@ impl ModelClient {concurrent_reasoning_summaries_enabled: bool,attestation_provider: Option<Arc<dyn AttestationProvider>>,http_client_factory: HttpClientFactory,+ workspace_routing: WorkspaceRoutingContext,) -> Self {let model_provider = create_model_provider(provider_info, auth_manager);let codex_api_key_env_enabled = model_provider@@ -456,6 +469,7 @@ impl ModelClient {state: Arc::new(ModelClientState {thread_id,provider: model_provider,+ workspace_routing,auth_env_telemetry,session_source,originator,@@ -596,7 +610,9 @@ impl ModelClient {) -> Result<RealtimeWebrtcCallStart> {// Create the media call over HTTP first, then retain matching auth so realtime can attach// the server-side control WebSocket to the call id from that HTTP response.- let client_setup = self.current_client_setup().await?;+ let client_setup = self+ .current_client_setup(ClientRouting::ConfiguredProvider)+ .await?;if let Some(header_value) = self.generate_attestation_header_for().await {extra_headers.insert(X_OAI_ATTESTATION_HEADER, header_value);}@@ -605,7 +621,11 @@ impl ModelClient {client_setup.api_auth.as_ref(),));let api_provider = api_provider_override.unwrap_or(client_setup.api_provider);- let transport = self.build_api_transport(&api_provider, REALTIME_CALLS_ENDPOINT)?;+ let transport = self.build_api_transport(+ &api_provider,+ REALTIME_CALLS_ENDPOINT,+ client_setup.redirect_policy,+ )?;let response = ApiRealtimeCallClient::new(transport, api_provider, client_setup.api_auth).create_with_session_and_headers(sdp, session_config, extra_headers).await@@ -621,7 +641,9 @@ impl ModelClient {&self,mut extra_headers: ApiHeaderMap,) -> Result<ApiHeaderMap> {- let client_setup = self.current_client_setup().await?;+ let client_setup = self+ .current_client_setup(ClientRouting::ConfiguredProvider)+ .await?;if let Some(header_value) = self.generate_attestation_header_for().await {extra_headers.insert(X_OAI_ATTESTATION_HEADER, header_value);}@@ -648,9 +670,14 @@ impl ModelClient {return Ok(Vec::new());}- let client_setup = self.current_client_setup().await?;- let transport =- self.build_api_transport(&client_setup.api_provider, MEMORIES_SUMMARIZE_ENDPOINT)?;+ let client_setup = self+ .current_client_setup(ClientRouting::ConfiguredProvider)+ .await?;+ let transport = self.build_api_transport(+ &client_setup.api_provider,+ MEMORIES_SUMMARIZE_ENDPOINT,+ client_setup.redirect_policy,+ )?;let request_telemetry = Self::build_request_telemetry(session_telemetry,AuthRequestTelemetryContext::new(@@ -944,28 +971,68 @@ impl ModelClient {////// This centralizes setup used by both prewarm and normal request paths so they stay in/// lockstep when auth/provider resolution changes.- async fn current_client_setup(&self) -> Result<CurrentClientSetup> {+ async fn current_client_setup(&self, routing: ClientRouting) -> Result<CurrentClientSetup> {// Capture before resolving credentials so an account switch during setup cannot label// an old connection with the new owner's revision.let auth_owner_generation = self.auth_owner_generation();- let auth = self.state.provider.auth().await;- let api_provider = self.state.provider.api_provider().await?;- let resolved_auth = self+ let auth_changes = self.state.provider- .api_auth_for_scope(ProviderAuthScope {- agent_identity_policy: self.agent_identity_policy,- session_source: self.state.session_source.clone(),- agent_identity_session_fallback: self.state.agent_identity_session_fallback.clone(),- })- .await?;- Ok(CurrentClientSetup {- auth,- auth_owner_generation,- api_provider,- api_auth: resolved_auth.auth,- agent_identity_telemetry: resolved_auth.agent_identity_telemetry,- })+ .auth_manager()+ .map(|manager| manager.auth_change_receiver());+ loop {+ let revision = auth_changes.as_ref().map(|changes| *changes.borrow());+ let auth = self.state.provider.auth().await;+ let (api_provider, redirect_policy) = match routing {+ ClientRouting::Workspace => {+ let resolved = self+ .state+ .provider+ .responses_api_provider(&self.state.workspace_routing)+ .await?;+ (resolved.provider, resolved.redirect_policy)+ }+ ClientRouting::ConfiguredProvider => (+ self.state.provider.api_provider().await?,+ ClientRedirectPolicy::Default,+ ),+ };+ let resolved_auth = self+ .state+ .provider+ .api_auth_for_scope(ProviderAuthScope {+ agent_identity_policy: self.agent_identity_policy,+ session_source: self.state.session_source.clone(),+ agent_identity_session_fallback: self+ .state+ .agent_identity_session_fallback+ .clone(),+ })+ .await?;+ // Command-backed bearer refreshes cannot change workspace routing. Keep the captured+ // revisions so a refresh during setup still invalidates cached WebSocket state.+ if self.state.provider.info().auth.is_none() {+ if self.auth_owner_generation() != auth_owner_generation {+ return Err(std::io::Error::other(+ "account changed while preparing model request",+ )+ .into());+ }+ // Rebuild the entire bundle after a credential-only refresh, including routing.+ if auth_changes.as_ref().map(|changes| *changes.borrow()) != revision {+ continue;+ }+ }+ return Ok(CurrentClientSetup {+ auth,+ auth_owner_generation,+ auth_revision: revision,+ api_provider,+ redirect_policy,+ api_auth: resolved_auth.auth,+ agent_identity_telemetry: resolved_auth.agent_identity_telemetry,+ });+ }}fn responses_headers(&self, auth: Option<&CodexAuth>, model: &str) -> ApiHeaderMap {@@ -1047,19 +1114,30 @@ impl ModelClient {&self,api_provider: &ApiProvider,endpoint: &str,+ redirect_policy: ClientRedirectPolicy,) -> Result<ReqwestTransport> {- let request_url = api_provider.url_for_path(endpoint);+ let redirect_policy = if api_provider+ .headers+ .contains_key(codex_model_provider::ACCOUNT_ROUTING_HEADER)+ {+ ClientRedirectPolicy::Reject+ } else {+ redirect_policy+ };let client = create_client_for_route(&self.http_client_factory,- &request_url,+ &api_provider.url_for_path(endpoint),ClientRouteClass::Api,+ redirect_policy,).map_err(std::io::Error::from)?;Ok(ReqwestTransport::from_http_client(client))}pub(crate) async fn prewarm_auth(&self) -> Result<()> {- self.current_client_setup().await.map(|_| ())+ self.current_client_setup(ClientRouting::Workspace)+ .await+ .map(|_| ())}/// Opens a websocket connection using the same header and telemetry wiring as normal turns.@@ -1203,6 +1281,7 @@ impl ModelClientSession {fn reset_websocket_session(&mut self) {self.websocket_session.connection = None;self.websocket_session.responses_headers.clear();+ self.websocket_session.connection_key = None;self.websocket_session.last_request = None;self.websocket_session.last_response_rx = None;self.websocket_session.last_response_from_untraced_warmup = false;@@ -1340,15 +1419,23 @@ impl ModelClientSession {if !self.client.responses_websocket_enabled() {return Ok(());}- if self.websocket_session.connection.is_some() {+ let client_setup = self+ .client+ .current_client_setup(ClientRouting::Workspace)+ .await+ .map_err(|err| {+ ApiError::Stream(format!(+ "failed to build websocket prewarm client setup: {err}"+ ))+ })?;+ let connection_key =+ ResponsesConnectionKey::new(&client_setup.api_provider, client_setup.auth_revision);+ if self.websocket_session.connection.is_some()+ && self.websocket_session.connection_key.as_ref() == Some(&connection_key)+ {return Ok(());}-- let client_setup = self.client.current_client_setup().await.map_err(|err| {- ApiError::Stream(format!(- "failed to build websocket prewarm client setup: {err}"- ))- })?;+ self.reset_websocket_session();let auth_context = AuthRequestTelemetryContext::new(client_setup.auth.as_ref().map(CodexAuth::auth_mode),client_setup.api_auth.as_ref(),@@ -1361,6 +1448,7 @@ impl ModelClientSession {self.websocket_connection(WebsocketConnectParams {session_telemetry,api_provider: client_setup.api_provider,+ auth_revision: client_setup.auth_revision,api_auth: client_setup.api_auth,auth_owner_generation: client_setup.auth_owner_generation,responses_metadata,@@ -1391,6 +1479,7 @@ impl ModelClientSession {let WebsocketConnectParams {session_telemetry,api_provider,+ auth_revision,api_auth,auth_owner_generation,responses_metadata,@@ -1398,9 +1487,11 @@ impl ModelClientSession {request_route_telemetry,responses_headers,} = params;+ let connection_key = ResponsesConnectionKey::new(&api_provider, auth_revision);let needs_new = match self.websocket_session.connection.as_ref() {Some(conn) => {self.websocket_session.responses_headers != *responses_headers+ || self.websocket_session.connection_key.as_ref() != Some(&connection_key)|| conn.is_closed().await}None => true,@@ -1438,6 +1529,7 @@ impl ModelClientSession {self.websocket_session.connection = Some(new_conn);self.websocket_session.responses_headers = responses_headers.clone();self.websocket_session.auth_owner_generation = auth_owner_generation;+ self.websocket_session.connection_key = Some(connection_key);self.websocket_session.set_connection_reused(/*connection_reused*/ false);} else {@@ -1499,14 +1591,19 @@ impl ModelClientSession {let mut provider_auth_recovery_attempted = false;let mut pending_retry = PendingUnauthorizedRetry::default();loop {- let client_setup = self.client.current_client_setup().await?;+ let client_setup = self+ .client+ .current_client_setup(ClientRouting::Workspace)+ .await?;let responses_headers = self.client.responses_headers(client_setup.auth.as_ref(), &model_info.slug);tracing::Span::current().record("api.path", "/responses");- let transport = self- .client- .build_api_transport(&client_setup.api_provider, "/responses")?;+ let transport = self.client.build_api_transport(+ &client_setup.api_provider,+ "/responses",+ client_setup.redirect_policy,+ )?;let request_auth_context = AuthRequestTelemetryContext::new(client_setup.auth.as_ref().map(CodexAuth::auth_mode),client_setup.api_auth.as_ref(),@@ -1676,7 +1773,10 @@ impl ModelClientSession {let mut provider_auth_recovery_attempted = false;let mut pending_retry = PendingUnauthorizedRetry::default();loop {- let client_setup = self.client.current_client_setup().await?;+ let client_setup = self+ .client+ .current_client_setup(ClientRouting::Workspace)+ .await?;let responses_headers = self.client.responses_headers(client_setup.auth.as_ref(), &model_info.slug);@@ -1729,6 +1829,7 @@ impl ModelClientSession {.websocket_connection(WebsocketConnectParams {session_telemetry,api_provider: client_setup.api_provider,+ auth_revision: client_setup.auth_revision,api_auth: client_setup.api_auth,auth_owner_generation: client_setup.auth_owner_generation,responses_metadata: &websocket_metadata,@@ -2342,6 +2443,7 @@ impl AuthRequestTelemetryContext {struct WebsocketConnectParams<'a> {session_telemetry: &'a SessionTelemetry,api_provider: codex_api::Provider,+ auth_revision: Option<u64>,api_auth: SharedAuthProvider,auth_owner_generation: Option<u64>,responses_metadata: &'a CodexResponsesMetadata,diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rsindex 36d54c9cc4..b129556af1 100644--- a/codex-rs/core/src/client_tests.rs+++ b/codex-rs/core/src/client_tests.rs@@ -14,6 +14,7 @@ use crate::GenerateAttestationFuture;use crate::responses_metadata::CodexResponsesMetadata;use crate::test_support::TestCodexResponsesRequestKind;use crate::test_support::responses_metadata as test_responses_metadata;+use base64::Engine;use codex_api::AgentIdentityTelemetry;use codex_api::ApiError;use codex_api::ResponseEvent;@@ -120,6 +121,9 @@ fn test_model_client_with_thread_id(/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ codex_model_provider::WorkspaceRoutingContext::new(+ "https://chatgpt.com/backend-api".into(),+ ),)}@@ -127,6 +131,289 @@ fn test_model_provider() -> SharedModelProvider {test_model_client(SessionSource::Cli).state.provider.clone()}+#[tokio::test]+async fn workspace_routed_http_rejects_redirects_without_a_routing_header() {+ use codex_client::HttpTransport;+ use codex_login::WorkspaceRouting;+ use codex_login::WorkspaceRoutingRequest;+ use codex_login::WorkspaceRoutingResolver;++ struct Routing(Option<&'static str>);+ impl WorkspaceRoutingResolver for Routing {+ fn resolve(+ &self,+ _request: WorkspaceRoutingRequest,+ ) -> Pin<+ Box<+ dyn std::future::Future<Output = std::io::Result<Option<WorkspaceRouting>>>+ + Send+ + '_,+ >,+ > {+ Box::pin(async move {+ Ok(self.0.map(|override_value| WorkspaceRouting {+ chatgpt_account_id: "account_id".into(),+ backend_origin: "https://gov.chatgpt.com".into(),+ account_routing_override: override_value.into(),+ }))+ })+ }+ }++ for routing_override in [Some("NO_CONSTRAINT"), Some("us_cr"), None] {+ let origin = MockServer::start().await;+ let destination = MockServer::start().await;+ Mock::given(method("POST"))+ .respond_with(+ ResponseTemplate::new(/*status*/ 307)+ .insert_header("location", format!("{}/responses", destination.uri())),+ )+ .mount(&origin)+ .await;+ Mock::given(method("POST"))+ .respond_with(ResponseTemplate::new(/*status*/ 200))+ .mount(&destination)+ .await;+ let manager =+ AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());+ let resolver: Arc<dyn WorkspaceRoutingResolver> = Arc::new(Routing(routing_override));+ manager.set_workspace_routing_resolver(Arc::downgrade(&resolver));+ let mut client = test_model_client(SessionSource::Exec);+ Arc::get_mut(&mut client.state).unwrap().provider = create_model_provider(+ ModelProviderInfo::create_openai_provider(/*base_url*/ None),+ Some(manager),+ );+ let mut setup = client+ .current_client_setup(super::ClientRouting::Workspace)+ .await+ .unwrap();+ if routing_override.is_some() {+ assert_eq!(+ setup.api_provider.base_url,+ "https://gov.chatgpt.com/backend-api/codex"+ );+ }+ // Exercise the resolved route's redirect policy against loopback HTTP servers.+ setup.api_provider.base_url = origin.uri();+ let transport = client+ .build_api_transport(&setup.api_provider, "/responses", setup.redirect_policy)+ .unwrap();+ let request = setup+ .api_provider+ .build_request(http::Method::POST, "/responses")+ .with_json(&json!({"input": "workspace content"}));+ let result = transport.execute(request).await;+ if routing_override.is_some() {+ assert!(+ matches!(+ result,+ Err(TransportError::Http {+ status: http::StatusCode::TEMPORARY_REDIRECT,+ ..+ })+ ),+ "workspace redirect must be rejected: {routing_override:?}"+ );+ } else {+ assert_eq!(result.unwrap().status, http::StatusCode::OK);+ }+ assert_eq!(+ destination.received_requests().await.unwrap().len(),+ usize::from(routing_override.is_none())+ );+ }+}++#[derive(Debug)]+enum SetupRefresh {+ Command(PathBuf),+ ChatGpt {+ home: PathBuf,+ token: String,+ workspace: String,+ },+}++#[derive(Debug)]+struct SetupRefreshProvider {+ inner: SharedModelProvider,+ refresh: SetupRefresh,+ setup_calls: AtomicUsize,+}++impl ModelProvider for SetupRefreshProvider {+ fn info(&self) -> &ModelProviderInfo {+ self.inner.info()+ }++ fn auth_manager(&self) -> Option<Arc<AuthManager>> {+ self.inner.auth_manager()+ }++ fn auth(&self) -> ModelProviderFuture<'_, Option<CodexAuth>> {+ self.inner.auth()+ }++ fn account_state(&self) -> ProviderAccountResult {+ self.inner.account_state()+ }++ fn api_provider(+ &self,+ ) -> ModelProviderFuture<'_, codex_protocol::error::Result<codex_api::Provider>> {+ Box::pin(async move {+ self.setup_calls.fetch_add(1, Ordering::SeqCst);+ let manager = self.inner.auth_manager().expect("auth manager");+ match &self.refresh {+ SetupRefresh::Command(token_path) => {+ std::fs::write(token_path, "refreshed-token")?;+ manager+ .refresh_token_from_authority()+ .await+ .expect("refresh command token");+ }+ SetupRefresh::ChatGpt {+ home,+ token,+ workspace,+ } => {+ codex_login::auth::login_with_chatgpt_auth_tokens(+ home, token, workspace, /*chatgpt_plan_type*/ None,+ )?;+ manager.reload().await;+ }+ }+ self.inner.api_provider().await+ })+ }++ fn models_manager(+ &self,+ codex_home: PathBuf,+ config_model_catalog: Option<ModelsResponse>,+ ) -> SharedModelsManager {+ self.inner.models_manager(codex_home, config_model_catalog)+ }+}++#[tokio::test]+async fn client_setup_accepts_command_credential_refresh() {+ for routing in [+ super::ClientRouting::Workspace,+ super::ClientRouting::ConfiguredProvider,+ ] {+ let tempdir = TempDir::new().unwrap();+ let token_path = tempdir.path().join("token.txt");+ std::fs::write(&token_path, "initial-token").unwrap();+ let mut info = test_model_provider().info().clone();+ info.auth = Some(codex_protocol::config_types::ModelProviderAuthInfo {+ command: if cfg!(windows) { "cmd.exe" } else { "cat" }.into(),+ args: if cfg!(windows) {+ vec!["/D", "/C", "type", "token.txt"]+ } else {+ vec!["token.txt"]+ }+ .into_iter()+ .map(Into::into)+ .collect(),+ timeout_ms: std::num::NonZeroU64::new(/*n*/ 5_000).unwrap(),+ refresh_interval_ms: 60_000,+ cwd: tempdir.path().try_into().unwrap(),+ });+ let provider = Arc::new(SetupRefreshProvider {+ inner: create_model_provider(info, /*auth_manager*/ None),+ refresh: SetupRefresh::Command(token_path),+ setup_calls: AtomicUsize::new(/*v*/ 0),+ });+ let manager = provider.auth_manager().unwrap();+ let mut client = test_model_client(SessionSource::Exec);+ Arc::get_mut(&mut client.state).unwrap().provider = provider;++ let setup = client.current_client_setup(routing).await.unwrap();+ let mut headers = http::HeaderMap::new();+ setup.api_auth.add_auth_headers(&mut headers);+ assert_eq!(+ headers.get(http::header::AUTHORIZATION).unwrap(),+ "Bearer refreshed-token"+ );+ let refreshed_revision = Some(*manager.auth_change_receiver().borrow());+ assert_ne!(+ codex_model_provider::ResponsesConnectionKey::new(+ &setup.api_provider,+ setup.auth_revision+ ),+ codex_model_provider::ResponsesConnectionKey::new(+ &setup.api_provider,+ refreshed_revision+ ),+ );+ assert_ne!(setup.auth_owner_generation, client.auth_owner_generation());+ }+}++#[tokio::test]+async fn client_setup_rebuilds_chatgpt_refresh_but_rejects_account_switches() {+ for (user, workspace, expected_calls) in [+ ("user-a", "workspace-a", 2),+ ("user-b", "workspace-a", 1),+ ("user-a", "workspace-b", 1),+ ] {+ let token = |user: &str, revision: &str| {+ let claims =+ json!({"jti": revision, "https://api.openai.com/auth": {"chatgpt_user_id": user}});+ let payload =+ base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(claims.to_string());+ format!("header.{payload}.signature")+ };+ let home = TempDir::new().unwrap();+ let initial = CodexAuth::from_external_chatgpt_tokens(+ &token("user-a", "initial"),+ "workspace-a",+ /*chatgpt_plan_type*/ None,+ )+ .unwrap();+ let manager =+ AuthManager::from_auth_for_testing_with_home(initial, home.path().to_path_buf());+ let refreshed_token = token(user, "refreshed");+ let mut info = test_model_provider().info().clone();+ info.requires_openai_auth = true;+ let provider = Arc::new(SetupRefreshProvider {+ inner: create_model_provider(info, Some(manager.clone())),+ refresh: SetupRefresh::ChatGpt {+ home: home.path().to_path_buf(),+ token: refreshed_token.clone(),+ workspace: workspace.into(),+ },+ setup_calls: AtomicUsize::new(/*v*/ 0),+ });+ let mut client = test_model_client(SessionSource::Exec);+ Arc::get_mut(&mut client.state).unwrap().provider = provider.clone();+ let result = client+ .current_client_setup(super::ClientRouting::ConfiguredProvider)+ .await;+ if expected_calls == 2 {+ let setup = result.unwrap();+ let mut headers = http::HeaderMap::new();+ setup.api_auth.add_auth_headers(&mut headers);+ assert_eq!(+ headers.get(http::header::AUTHORIZATION).unwrap(),+ &format!("Bearer {refreshed_token}")+ );+ assert_eq!(setup.auth.unwrap().get_token().unwrap(), refreshed_token);+ assert_eq!(+ (setup.auth_revision, setup.auth_owner_generation),+ (Some(*manager.auth_change_receiver().borrow()), Some(0))+ );+ } else {+ assert_eq!(+ result.err().expect("account switch must fail").to_string(),+ "account changed while preparing model request"+ );+ }+ assert_eq!(provider.setup_calls.load(Ordering::SeqCst), expected_calls);+ }+}+fn test_responses_metadata_for_client(client: &ModelClient,turn_id: Option<&str>,@@ -1197,6 +1484,9 @@ fn model_client_with_counting_attestation(calls: attestation_calls.clone(),})),HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ codex_model_provider::WorkspaceRoutingContext::new(+ "https://chatgpt.com/backend-api".into(),+ ),);(model_client, attestation_calls)}diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex 748ecc8410..d4e1adf178 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -5307,7 +5307,7 @@ fn filter_plugin_mcp_servers_by_matchers_enforces_name_and_invocation() {}#[tokio::test]-async fn rebuild_preserving_session_layers_refreshes_requirements() -> std::io::Result<()> {+async fn rebuild_with_session_layers_refreshes_requirements() -> std::io::Result<()> {let codex_home = TempDir::new()?;let user_file = AbsolutePathBuf::resolve_path_against_base(CONFIG_TOML_FILE, codex_home.path());let project_dot_codex =@@ -5476,9 +5476,12 @@ async fn rebuild_preserving_session_layers_refreshes_requirements() -> std::io::thread_layer_stack,).await?;- let config = thread_config- .rebuild_preserving_session_layers(&refreshed_config)- .await?;+ let config = Config::rebuild_with_session_layers(+ &thread_config.config_layer_stack,+ thread_config.cwd.to_path_buf(),+ &refreshed_config,+ )+ .await?;assert_eq!(config.mcp_servers.get(),@@ -5516,8 +5519,7 @@ async fn rebuild_preserving_session_layers_refreshes_requirements() -> std::io::}#[tokio::test]-async fn rebuild_preserving_session_layers_refreshes_plugin_derived_mcp_config()--> anyhow::Result<()> {+async fn rebuild_with_session_layers_refreshes_plugin_derived_mcp_config() -> anyhow::Result<()> {let codex_home = TempDir::new()?;let plugin_root = codex_home.path()@@ -5599,9 +5601,12 @@ async fn rebuild_preserving_session_layers_refreshes_plugin_derived_mcp_config()thread_layer_stack,).await?;- let config = thread_config- .rebuild_preserving_session_layers(&refreshed_config)- .await?;+ let config = Config::rebuild_with_session_layers(+ &thread_config.config_layer_stack,+ thread_config.cwd.to_path_buf(),+ &refreshed_config,+ )+ .await?;let plugins_manager =plugins_manager_for_config(&config, auth_manager_from_optional_auth(/*auth*/ None));let mcp_config = config.to_mcp_config(&plugins_manager).await;diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex ef972143cf..789b207da3 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -1826,12 +1826,23 @@ impl Config {}}- pub async fn rebuild_preserving_session_layers(- &self,+ pub fn workspace_routing_context(&self) -> codex_model_provider::WorkspaceRoutingContext {+ codex_model_provider::WorkspaceRoutingContext::new(self.chatgpt_base_url.clone())+ .with_session(codex_login::WorkspaceRoutingSession {+ cwd: self.cwd.to_path_buf(),+ config_layer_stack: self.config_layer_stack.clone(),+ })+ }++ pub async fn rebuild_with_session_layers(+ session_layers: &ConfigLayerStack,+ cwd: PathBuf,refreshed_config: &Config,) -> std::io::Result<Self> {- let config_layer_stack =- self.layer_stack_preserving_session(&refreshed_config.config_layer_stack)?;+ let config_layer_stack = Self::layer_stack_preserving_session(+ session_layers,+ &refreshed_config.config_layer_stack,+ )?;let cfg: ConfigToml = config_layer_stack.effective_config().try_into()@@ -1846,7 +1857,7 @@ impl Config {LOCAL_FS.as_ref(),cfg,ConfigOverrides {- cwd: Some(self.cwd.to_path_buf()),+ cwd: Some(cwd),default_zsh_path,..Default::default()},@@ -1857,7 +1868,7 @@ impl Config {}fn layer_stack_preserving_session(- &self,+ session_layers: &ConfigLayerStack,refreshed_layers: &ConfigLayerStack,) -> std::io::Result<ConfigLayerStack> {let mut layers = refreshed_layers@@ -1866,7 +1877,7 @@ impl Config {.cloned().collect::<Vec<_>>();layers.extend(- self.config_layer_stack+ session_layers.all_layers_low_to_high().filter(|layer| is_session_layer(&layer.name)).cloned(),diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 83e6024ce6..97e067c759 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1673,6 +1673,7 @@ impl Session {.enabled(Feature::ConcurrentReasoningSummaries),attestation_provider,config.http_client_factory(),+ config.workspace_routing_context(),).with_session_context(crate::guardian::prompt_cache_key_override_for_review_session(diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 00e7e935ca..745756d48a 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -743,6 +743,9 @@ fn test_model_client_session() -> crate::client::ModelClientSession {/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ codex_model_provider::WorkspaceRoutingContext::new(+ "https://chatgpt.com/backend-api".into(),+ ),).new_session()}@@ -6119,6 +6122,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {.enabled(Feature::ConcurrentReasoningSummaries),/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),),executed_tool_calls: executed_tool_calls.clone(),code_mode_service: crate::tools::code_mode::CodeModeService::new(@@ -8304,6 +8308,7 @@ where.enabled(Feature::ConcurrentReasoningSummaries),/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),),executed_tool_calls: executed_tool_calls.clone(),code_mode_service: crate::tools::code_mode::CodeModeService::new(diff --git a/codex-rs/core/tests/responses_headers.rs b/codex-rs/core/tests/responses_headers.rsindex be184753e7..b3b1e86e91 100644--- a/codex-rs/core/tests/responses_headers.rs+++ b/codex-rs/core/tests/responses_headers.rs@@ -136,6 +136,7 @@ async fn responses_stream_includes_subagent_header_on_review() {/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let responses_metadata = test_turn_responses_metadata(&client, thread_id, &session_source);let mut client_session = client.new_session();@@ -273,6 +274,7 @@ async fn responses_stream_includes_subagent_header_on_other() {/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let responses_metadata = test_turn_responses_metadata(&client, thread_id, &session_source);let mut client_session = client.new_session();@@ -395,6 +397,7 @@ async fn responses_respects_model_info_overrides_from_config() {/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let responses_metadata = test_turn_responses_metadata(&client, thread_id, &session_source);let mut client_session = client.new_session();diff --git a/codex-rs/core/tests/suite/client.rs b/codex-rs/core/tests/suite/client.rsindex 79d0eb4f6d..502f3ccf38 100644--- a/codex-rs/core/tests/suite/client.rs+++ b/codex-rs/core/tests/suite/client.rs@@ -1579,6 +1579,7 @@ async fn send_request_with_provider(provider: ModelProviderInfo) {.enabled(Feature::ConcurrentReasoningSummaries),/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let responses_metadata = test_turn_responses_metadata(&client, thread_id);let mut client_session = client.new_session();@@ -3070,6 +3071,7 @@ async fn azure_responses_request_does_not_store_and_preserves_prefixed_item_ids(/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let responses_metadata = test_turn_responses_metadata(&client, thread_id);let mut client_session = client.new_session();diff --git a/codex-rs/core/tests/suite/client_websockets.rs b/codex-rs/core/tests/suite/client_websockets.rsindex 4d2ba3c926..6a72bffb3b 100755--- a/codex-rs/core/tests/suite/client_websockets.rs+++ b/codex-rs/core/tests/suite/client_websockets.rs@@ -2836,6 +2836,7 @@ async fn websocket_harness_with_provider_options_and_auth(.enabled(Feature::ConcurrentReasoningSummaries),/*attestation_provider*/ None,http_client_factory,+ config.workspace_routing_context(),);WebsocketTestHarness {diff --git a/codex-rs/core/tests/suite/model_provider_requirements_tests.rs b/codex-rs/core/tests/suite/model_provider_requirements_tests.rsindex c096bf8fb1..a6090f1de5 100644--- a/codex-rs/core/tests/suite/model_provider_requirements_tests.rs+++ b/codex-rs/core/tests/suite/model_provider_requirements_tests.rs@@ -4,6 +4,7 @@ use anyhow::Result;use codex_config::LoaderOverrides;use codex_config::config_toml::ConfigToml;use codex_config::test_support::CloudConfigBundleFixture;+use codex_core::config::Config;use codex_core::config::ConfigBuilder;use codex_core::config::ConfigOverrides;use codex_login::CodexAuth;@@ -177,9 +178,12 @@ X-Managed = "required"insta::assert_debug_snapshot!("provider_selection_override_warning", warnings);}assert_eq!(&overridden.model_provider, &test.config.model_provider);- let rebuilt = overridden- .rebuild_preserving_session_layers(&overridden)- .await?;+ let rebuilt = Config::rebuild_with_session_layers(+ &overridden.config_layer_stack,+ overridden.cwd.to_path_buf(),+ &overridden,+ )+ .await?;assert_eq!(rebuilt.model_provider, test.config.model_provider);}}diff --git a/codex-rs/login/src/auth/default_client.rs b/codex-rs/login/src/auth/default_client.rsindex cd4cbd5431..0d6a0fcc99 100644--- a/codex-rs/login/src/auth/default_client.rs+++ b/codex-rs/login/src/auth/default_client.rs@@ -253,24 +253,32 @@ pub fn create_client_for_route(http_client_factory: &HttpClientFactory,request_url: &str,route_class: ClientRouteClass,+ redirect_policy: ClientRedirectPolicy,) -> Result<HttpClient, BuildRouteAwareHttpClientError> {+ let builder = match redirect_policy {+ ClientRedirectPolicy::Default => default_http_client_builder(),+ ClientRedirectPolicy::Reject => default_http_client_builder().without_redirects(),+ };if matches!(http_client_factory.outbound_proxy_policy(),OutboundProxyPolicy::ReqwestDefault) {- return Ok(create_client());+ return Ok(build_default_client(builder));}if is_sandboxed() {// Preserve the sandbox's existing no-proxy policy; sandboxed command egress is routed// separately through network-proxy.- return Ok(create_client());+ return Ok(build_default_client(builder));}- default_http_client_builder().build_respecting_outbound_proxy_policy(- http_client_factory,- request_url,- route_class,- )+ builder.build_respecting_outbound_proxy_policy(http_client_factory, request_url, route_class)+}++/// Redirect handling for the shared HTTP client builders.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum ClientRedirectPolicy {+ Default,+ Reject,}/// Builds the default Codex HTTP client for a concrete outbound route without blocking the@@ -286,8 +294,13 @@ pub async fn create_client_for_route_async(.map_err(std::io::Error::other)?;tokio::task::spawn_blocking(move || {let _permit = permit;- create_client_for_route(&http_client_factory, &request_url, route_class)- .map_err(std::io::Error::from)+ create_client_for_route(+ &http_client_factory,+ &request_url,+ route_class,+ ClientRedirectPolicy::Default,+ )+ .map_err(std::io::Error::from)}).await.map_err(std::io::Error::other)?@@ -329,6 +342,7 @@ pub(crate) fn create_default_auth_client(auth_route_config.http_client_factory(),endpoint,ClientRouteClass::Auth,+ ClientRedirectPolicy::Default,)}diff --git a/codex-rs/login/src/auth/manager.rs b/codex-rs/login/src/auth/manager.rsindex baf243faf6..db0f2e2057 100644--- a/codex-rs/login/src/auth/manager.rs+++ b/codex-rs/login/src/auth/manager.rs@@ -1,3 +1,5 @@+mod workspace_routing;+use chrono::Utc;use http::StatusCode;use serde::Deserialize;@@ -12,7 +14,9 @@ use std::path::PathBuf;use std::pin::Pin;use std::sync::Arc;use std::sync::Mutex;+use std::sync::OnceLock;use std::sync::RwLock;+use std::sync::Weak;use std::sync::atomic::AtomicU64;use std::sync::atomic::Ordering;use std::time::Duration;@@ -74,6 +78,10 @@ use codex_protocol::auth::RefreshTokenFailedReason;use codex_protocol::protocol::SessionSource;use serde_json::Value;use thiserror::Error;+pub use workspace_routing::WorkspaceRouting;+pub use workspace_routing::WorkspaceRoutingRequest;+pub use workspace_routing::WorkspaceRoutingResolver;+pub use workspace_routing::WorkspaceRoutingSession;/// Authentication mechanism used by the current user.#[derive(Debug, Clone)]@@ -2051,6 +2059,7 @@ pub struct AuthManager {inner: RwLock<CachedAuth>,auth_change_tx: watch::Sender<u64>,auth_change_state_tx: watch::Sender<AuthChangeState>,+ workspace_routing_resolver: OnceLock<Weak<dyn WorkspaceRoutingResolver>>,enable_codex_api_key_env: bool,auth_credentials_store_mode: AuthCredentialsStoreMode,keyring_backend_kind: AuthKeyringBackendKind,@@ -2188,6 +2197,7 @@ impl AuthManager {}),auth_change_tx,auth_change_state_tx: watch::channel(AuthChangeState::default()).0,+ workspace_routing_resolver: OnceLock::new(),enable_codex_api_key_env,auth_credentials_store_mode,keyring_backend_kind,@@ -2223,6 +2233,7 @@ impl AuthManager {inner: RwLock::new(cached),auth_change_tx,auth_change_state_tx: watch::channel(AuthChangeState::default()).0,+ workspace_routing_resolver: OnceLock::new(),enable_codex_api_key_env: false,auth_credentials_store_mode: AuthCredentialsStoreMode::File,keyring_backend_kind: AuthKeyringBackendKind::default(),@@ -2252,6 +2263,7 @@ impl AuthManager {inner: RwLock::new(cached),auth_change_tx,auth_change_state_tx: watch::channel(AuthChangeState::default()).0,+ workspace_routing_resolver: OnceLock::new(),enable_codex_api_key_env: false,auth_credentials_store_mode: AuthCredentialsStoreMode::File,keyring_backend_kind: AuthKeyringBackendKind::default(),@@ -2285,6 +2297,7 @@ impl AuthManager {inner: RwLock::new(cached),auth_change_tx,auth_change_state_tx: watch::channel(AuthChangeState::default()).0,+ workspace_routing_resolver: OnceLock::new(),enable_codex_api_key_env: false,auth_credentials_store_mode: AuthCredentialsStoreMode::File,keyring_backend_kind: AuthKeyringBackendKind::default(),@@ -2316,6 +2329,7 @@ impl AuthManager {}),auth_change_tx,auth_change_state_tx: watch::channel(AuthChangeState::default()).0,+ workspace_routing_resolver: OnceLock::new(),enable_codex_api_key_env: false,auth_credentials_store_mode: AuthCredentialsStoreMode::File,keyring_backend_kind: AuthKeyringBackendKind::default(),diff --git a/codex-rs/login/src/auth/manager/workspace_routing.rs b/codex-rs/login/src/auth/manager/workspace_routing.rsnew file mode 100644index 0000000000..0ceb56a35d--- /dev/null+++ b/codex-rs/login/src/auth/manager/workspace_routing.rs@@ -0,0 +1,88 @@+//! Connects account-owned routing discovery to ChatGPT request builders.+//! The resolver is weakly held so it cannot keep its app-server owner alive.++use codex_config::ConfigLayerStack;+use std::future::Future;+use std::io;+use std::path::PathBuf;+use std::pin::Pin;+use std::sync::Arc;+use std::sync::Weak;++use crate::AuthManager;+use crate::CodexAuth;++/// A successful discovery for one selected workspace.+#[derive(Clone, Debug)]+pub struct WorkspaceRouting {+ pub chatgpt_account_id: String,+ pub backend_origin: String,+ pub account_routing_override: String,+}++/// Retained configuration layers and project location for one model session.+/// The account owner refreshes global settings without discarding session overrides.+pub struct WorkspaceRoutingSession {+ pub cwd: PathBuf,+ pub config_layer_stack: ConfigLayerStack,+}++impl std::fmt::Debug for WorkspaceRoutingSession {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.debug_struct("WorkspaceRoutingSession")+ .finish_non_exhaustive()+ }+}++/// The provider and bootstrap selected for one model session.+pub struct WorkspaceRoutingRequest {+ pub provider_base_url: String,+ pub chatgpt_base_url: String,+ pub previously_routed: bool,+ pub session: Option<Arc<WorkspaceRoutingSession>>,+}++/// Resolves routing through the account owner's cache and requirements loader.+/// Returns no routing for independent destinations or no selected workspace.+/// Destination scope is decided here, before making a discovery request.+/// Implementations must reject failed discovery and changes to the selected account.+pub trait WorkspaceRoutingResolver: Send + Sync {+ fn resolve(+ &self,+ request: WorkspaceRoutingRequest,+ ) -> Pin<Box<dyn Future<Output = io::Result<Option<WorkspaceRouting>>> + Send + '_>>;+}++impl AuthManager {+ /// Installs the app-server's routing owner before accepting model requests.+ pub fn set_workspace_routing_resolver(&self, resolver: Weak<dyn WorkspaceRoutingResolver>) {+ assert!(self.workspace_routing_resolver.set(resolver).is_ok());+ }++ /// CLI callers without a discovery owner retain their existing routing behavior.+ pub async fn workspace_routing(+ &self,+ auth: &CodexAuth,+ request: WorkspaceRoutingRequest,+ ) -> io::Result<Option<WorkspaceRouting>> {+ let Some(resolver) = self.workspace_routing_resolver.get() else {+ return Ok(None);+ };+ let auth_changes = self.auth_change_receiver();+ let revision = *auth_changes.borrow();+ let resolver = resolver+ .upgrade()+ .ok_or_else(|| io::Error::other("workspace routing owner is unavailable"))?;+ let routing = resolver.resolve(request).await?;+ if *auth_changes.borrow() != revision+ || routing.as_ref().is_some_and(|routing| {+ auth.get_account_id().as_deref() != Some(routing.chatgpt_account_id.as_str())+ })+ {+ return Err(io::Error::other(+ "account changed during workspace routing discovery",+ ));+ }+ Ok(routing)+ }+}diff --git a/codex-rs/login/src/lib.rs b/codex-rs/login/src/lib.rsindex e33e587121..6661a78d8e 100644--- a/codex-rs/login/src/lib.rs+++ b/codex-rs/login/src/lib.rs@@ -2,6 +2,10 @@ pub mod auth;pub mod auth_env_telemetry;pub mod test_support;pub mod token_data;+pub use auth::WorkspaceRouting;+pub use auth::WorkspaceRoutingRequest;+pub use auth::WorkspaceRoutingResolver;+pub use auth::WorkspaceRoutingSession;mod callback_params;mod device_code_auth;diff --git a/codex-rs/memories/write/src/runtime.rs b/codex-rs/memories/write/src/runtime.rsindex d9079c48bb..3efdfb21c5 100644--- a/codex-rs/memories/write/src/runtime.rs+++ b/codex-rs/memories/write/src/runtime.rs@@ -304,6 +304,7 @@ impl MemoryStartupContext {/*concurrent_reasoning_summaries_enabled*/ false,/*attestation_provider*/ None,config.http_client_factory(),+ config.workspace_routing_context(),);let mut client_session = model_client.new_session();diff --git a/codex-rs/model-provider/Cargo.toml b/codex-rs/model-provider/Cargo.tomlindex 9ba32d881a..c9ad5683da 100644--- a/codex-rs/model-provider/Cargo.toml+++ b/codex-rs/model-provider/Cargo.toml@@ -31,6 +31,7 @@ serde_json = { workspace = true }sha2 = { workspace = true }tokio = { workspace = true, features = ["io-util", "process", "sync", "time"] }tracing = { workspace = true, features = ["log"] }+url = { workspace = true }[dev-dependencies]base64 = { workspace = true }diff --git a/codex-rs/model-provider/src/lib.rs b/codex-rs/model-provider/src/lib.rsindex b3ca480d8c..0abe111a40 100644--- a/codex-rs/model-provider/src/lib.rs+++ b/codex-rs/model-provider/src/lib.rs@@ -6,6 +6,11 @@ mod models_identity;mod provider;mod shared_state;pub mod test_support;+mod workspace_routing;+pub use workspace_routing::ACCOUNT_ROUTING_HEADER;+pub use workspace_routing::ResolvedResponsesProvider;+pub use workspace_routing::ResponsesConnectionKey;+pub use workspace_routing::WorkspaceRoutingContext;pub use amazon_bedrock::is_supported_amazon_bedrock_region;pub use auth::AgentIdentitySessionFallback;@@ -31,3 +36,7 @@ pub use provider::ProviderUnauthorizedRecovery;pub use provider::RemoteCompactionSupport;pub use provider::SharedModelProvider;pub use provider::create_model_provider;++#[cfg(test)]+#[path = "workspace_routing_tests.rs"]+mod workspace_routing_tests;diff --git a/codex-rs/model-provider/src/provider.rs b/codex-rs/model-provider/src/provider.rsindex 6239bf0cb5..58b51d1bb3 100644--- a/codex-rs/model-provider/src/provider.rs+++ b/codex-rs/model-provider/src/provider.rs@@ -11,6 +11,8 @@ use codex_api::TransportError;use codex_api::is_azure_responses_provider;use codex_login::AuthManager;use codex_login::CodexAuth;+use codex_login::WorkspaceRoutingRequest;+use codex_login::default_client::ClientRedirectPolicy;use codex_login::default_client::RESIDENCY_HEADER_NAME;use codex_login::default_client::ResidencyRequirement;use codex_login::default_client::read_default_client_residency_requirement;@@ -24,6 +26,7 @@ use codex_protocol::error::CodexErr;use codex_protocol::openai_models::ModelsResponse;use http::HeaderValue;+use crate::ResolvedResponsesProvider;use crate::amazon_bedrock::AmazonBedrockModelProvider;use crate::auth::ProviderAuthScope;use crate::auth::ResolvedProviderAuth;@@ -31,6 +34,7 @@ use crate::auth::auth_manager_for_provider;use crate::auth::resolve_provider_auth;use crate::auth::resolve_provider_auth_for_scope;use crate::models_endpoint::OpenAiModelsEndpoint;+use crate::workspace_routing::WorkspaceRoutingContext;pub(crate) fn enforce_managed_residency(provider: &mut Provider) {if let Some(requirement) = read_default_client_residency_requirement() {@@ -234,6 +238,48 @@ pub trait ModelProvider: fmt::Debug + Send + Sync {})}+ /// Resolves routing for Responses HTTP, compaction, and WebSocket handshakes.+ #[expect(+ clippy::await_holding_invalid_type,+ reason = "serialize discovery and the session's first successful routing transition"+ )]+ fn responses_api_provider<'a>(+ &'a self,+ routing_context: &'a WorkspaceRoutingContext,+ ) -> ModelProviderFuture<'a, codex_protocol::error::Result<ResolvedResponsesProvider>> {+ Box::pin(async move {+ let mut provider = self.api_provider().await?;+ let mut redirect_policy = ClientRedirectPolicy::Default;+ if provider_uses_first_party_auth_path(self.info())+ && self.info().supports_codex_backend_routes()+ && let Some(auth) = self.auth().await.filter(CodexAuth::is_chatgpt_auth)+ && let Some(auth_manager) = self.auth_manager()+ {+ let mut previously_routed = routing_context.previously_routed.lock().await;+ if let Some(routing) = auth_manager+ .workspace_routing(+ &auth,+ WorkspaceRoutingRequest {+ provider_base_url: provider.base_url.clone(),+ chatgpt_base_url: routing_context.chatgpt_base_url.clone(),+ previously_routed: *previously_routed,+ session: routing_context.session.clone(),+ },+ )+ .await?+ {+ crate::workspace_routing::apply_workspace_routing(&mut provider, routing)?;+ redirect_policy = ClientRedirectPolicy::Reject;+ *previously_routed = true;+ }+ }+ Ok(ResolvedResponsesProvider {+ provider,+ redirect_policy,+ })+ })+ }+/// Returns the provider base URL that will be used at request time.fn runtime_base_url(&self,diff --git a/codex-rs/model-provider/src/workspace_routing.rs b/codex-rs/model-provider/src/workspace_routing.rsnew file mode 100644index 0000000000..d057a665b4--- /dev/null+++ b/codex-rs/model-provider/src/workspace_routing.rs@@ -0,0 +1,103 @@+//! Applies discovered routing and keeps requests within the selected ChatGPT backend.++use codex_login::WorkspaceRouting;+use codex_login::WorkspaceRoutingSession;+use codex_login::default_client::ClientRedirectPolicy;+use http::HeaderValue;+use std::io;+use std::sync::Arc;+use tokio::sync::Mutex;+use url::Url;++pub const ACCOUNT_ROUTING_HEADER: &str = "x-openai-account-routing-override";++/// Routing scope for one session's provider. Once routed, it cannot become+/// independent merely because the account owner's bootstrap configuration changes.+/// Lookups and the first successful routing transition are serialized per session.+#[derive(Debug)]+pub struct WorkspaceRoutingContext {+ pub(crate) chatgpt_base_url: String,+ pub(crate) previously_routed: Mutex<bool>,+ pub(crate) session: Option<Arc<WorkspaceRoutingSession>>,+}++impl WorkspaceRoutingContext {+ pub fn new(chatgpt_base_url: String) -> Self {+ Self {+ chatgpt_base_url,+ previously_routed: Mutex::new(/*t*/ false),+ session: None,+ }+ }++ pub fn with_session(mut self, session: WorkspaceRoutingSession) -> Self {+ self.session = Some(Arc::new(session));+ self+ }+}++/// Changes only the origin of requests to the selected ChatGPT backend.+pub(crate) fn apply_workspace_routing(+ provider: &mut codex_api::Provider,+ routing: WorkspaceRouting,+) -> io::Result<()> {+ let base_url = &mut provider.base_url;+ let headers = &mut provider.headers;+ let parse = |value: &str| Url::parse(value).map_err(io::Error::other);+ let mut url = parse(base_url)?;+ let backend = parse(&routing.backend_origin)?;+ if backend.scheme() != "https"+ || backend.host_str().is_none()+ || !backend.username().is_empty()+ || backend.password().is_some()+ || backend.path() != "/"+ || backend.query().is_some()+ || backend.fragment().is_some()+ {+ return Err(io::Error::other("invalid workspace backend origin"));+ }+ let header = match routing.account_routing_override.as_str() {+ "NO_CONSTRAINT" => None,+ "us" | "us_cr" => Some(+ HeaderValue::from_str(&routing.account_routing_override).map_err(io::Error::other)?,+ ),+ _ => return Err(io::Error::other("invalid workspace routing override")),+ };+ url.set_scheme(backend.scheme())+ .map_err(|()| io::Error::other("invalid backend scheme"))?;+ url.set_host(backend.host_str()).map_err(io::Error::other)?;+ url.set_port(backend.port())+ .map_err(|()| io::Error::other("invalid backend port"))?;+ *base_url = url.into();+ headers.remove(ACCOUNT_ROUTING_HEADER);+ if let Some(header) = header {+ headers.insert(ACCOUNT_ROUTING_HEADER, header);+ }+ Ok(())+}++/// API deployment and redirect policy resolved for one Responses request.+/// Workspace routes reject redirects even when their routing override supplies no header.+#[derive(Debug)]+pub struct ResolvedResponsesProvider {+ pub provider: codex_api::Provider,+ pub redirect_policy: ClientRedirectPolicy,+}++/// Effective destination and credentials that permit reusing a Responses socket.+#[derive(Debug, PartialEq, Eq)]+pub struct ResponsesConnectionKey {+ base_url: String,+ routing_header: Option<HeaderValue>,+ auth_revision: Option<u64>,+}++impl ResponsesConnectionKey {+ pub fn new(provider: &codex_api::Provider, auth_revision: Option<u64>) -> Self {+ Self {+ base_url: provider.base_url.clone(),+ routing_header: provider.headers.get(ACCOUNT_ROUTING_HEADER).cloned(),+ auth_revision,+ }+ }+}diff --git a/codex-rs/model-provider/src/workspace_routing_tests.rs b/codex-rs/model-provider/src/workspace_routing_tests.rsnew file mode 100644index 0000000000..95f20eea52--- /dev/null+++ b/codex-rs/model-provider/src/workspace_routing_tests.rs@@ -0,0 +1,199 @@+//! Routing is limited to the selected ChatGPT backend and successful discovery.++use std::future::Future;+use std::io;+use std::pin::Pin;+use std::sync::Arc;++use crate::ACCOUNT_ROUTING_HEADER;+use crate::WorkspaceRoutingContext;+use codex_login::AuthManager;+use codex_login::CodexAuth;+use codex_login::WorkspaceRouting;+use codex_login::WorkspaceRoutingRequest;+use codex_login::WorkspaceRoutingResolver;+use codex_login::default_client::ClientRedirectPolicy;+use codex_model_provider_info::ModelProviderInfo;+use pretty_assertions::assert_eq;++use crate::create_model_provider;++struct Routing(WorkspaceRouting);++struct ChangedBootstrap {+ first_lookup: std::sync::atomic::AtomicBool,+ release_first: tokio::sync::Notify,+}++impl WorkspaceRoutingResolver for ChangedBootstrap {+ fn resolve(+ &self,+ request: WorkspaceRoutingRequest,+ ) -> Pin<Box<dyn Future<Output = io::Result<Option<WorkspaceRouting>>> + Send + '_>> {+ Box::pin(async move {+ if self+ .first_lookup+ .swap(false, std::sync::atomic::Ordering::Relaxed)+ {+ self.release_first.notified().await;+ Ok(Some(WorkspaceRouting {+ chatgpt_account_id: "account_id".into(),+ backend_origin: "https://gov.chatgpt.com".into(),+ account_routing_override: "us_cr".into(),+ }))+ } else if request.previously_routed {+ Err(io::Error::other("bootstrap changed"))+ } else {+ Ok(None)+ }+ })+ }+}++#[tokio::test]+async fn concurrent_discovery_cannot_forget_established_routing() {+ let context = WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into());+ let auth =+ AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());+ let resolver = Arc::new(ChangedBootstrap {+ first_lookup: std::sync::atomic::AtomicBool::new(true),+ release_first: tokio::sync::Notify::new(),+ });+ auth.set_workspace_routing_resolver(Arc::downgrade(+ &(resolver.clone() as Arc<dyn WorkspaceRoutingResolver>),+ ));+ let provider = create_model_provider(+ ModelProviderInfo::create_openai_provider(/*base_url*/ None),+ Some(auth),+ );+ let mut first = provider.responses_api_provider(&context);+ let mut second = provider.responses_api_provider(&context);+ let early_second = std::future::poll_fn(|cx| {+ assert!(first.as_mut().poll(cx).is_pending());+ std::task::Poll::Ready(second.as_mut().poll(cx))+ })+ .await;+ resolver.release_first.notify_one();+ assert_eq!(+ first.await.unwrap().provider.base_url,+ "https://gov.chatgpt.com/backend-api/codex"+ );+ let second = match early_second {+ std::task::Poll::Ready(result) => result,+ std::task::Poll::Pending => second.await,+ };+ assert!(+ second.is_err(),+ "a concurrent lookup must retain the first lookup's routing scope"+ );+}++impl WorkspaceRoutingResolver for Routing {+ fn resolve(+ &self,+ request: WorkspaceRoutingRequest,+ ) -> Pin<Box<dyn Future<Output = io::Result<Option<WorkspaceRouting>>> + Send + '_>> {+ Box::pin(async move {+ let origin = url::Url::parse(&request.provider_base_url)+ .unwrap()+ .origin();+ let bootstrap = url::Url::parse(&request.chatgpt_base_url).unwrap().origin();+ Ok((origin == bootstrap).then(|| self.0.clone()))+ })+ }+}++#[tokio::test]+async fn workspace_routing_preserves_paths_and_excludes_other_providers() {+ let routing_context = WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into());+ let auth =+ AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());+ let resolver: Arc<dyn WorkspaceRoutingResolver> = Arc::new(Routing(WorkspaceRouting {+ chatgpt_account_id: "account_id".into(),+ backend_origin: "https://gov.chatgpt.com:8443".into(),+ account_routing_override: "us_cr".into(),+ }));+ auth.set_workspace_routing_resolver(Arc::downgrade(&resolver));+ let info = ModelProviderInfo::create_openai_provider(/*base_url*/ None);+ let provider = create_model_provider(info.clone(), Some(auth.clone()));+ let routed = provider+ .responses_api_provider(&routing_context)+ .await+ .unwrap();+ assert_eq!(+ (+ routed.provider.base_url.as_str(),+ routed.provider.headers[ACCOUNT_ROUTING_HEADER]+ .to_str()+ .unwrap(),+ routed.redirect_policy,+ ),+ (+ "https://gov.chatgpt.com:8443/backend-api/codex",+ "us_cr",+ ClientRedirectPolicy::Reject+ )+ );+ let mut custom_auth = info.clone();+ custom_auth.experimental_bearer_token = Some("custom-token".into());+ let mut unrelated_path = info.clone();+ unrelated_path.base_url = Some("https://chatgpt.com/v1".into());+ for info in [custom_auth, unrelated_path] {+ let provider = create_model_provider(info, Some(auth.clone()));+ let ordinary = provider.api_provider().await.unwrap();+ let responses = provider+ .responses_api_provider(&routing_context)+ .await+ .unwrap();+ assert_eq!(+ (+ responses.provider.base_url,+ responses.provider.headers,+ responses.redirect_policy+ ),+ (+ ordinary.base_url,+ ordinary.headers,+ ClientRedirectPolicy::Default+ )+ );+ }+ let api_auth = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("api-key"));+ api_auth.set_workspace_routing_resolver(Arc::downgrade(&resolver));+ let api = create_model_provider(info, Some(api_auth))+ .responses_api_provider(&routing_context)+ .await+ .unwrap();+ assert_eq!(api.provider.base_url, "https://api.openai.com/v1");+ assert!(!api.provider.headers.contains_key(ACCOUNT_ROUTING_HEADER));+}++#[tokio::test]+async fn missing_routing_owner_and_wrong_workspace_fail_closed() {+ let routing_context = WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into());+ let auth =+ AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());+ let resolver: Arc<dyn WorkspaceRoutingResolver> = Arc::new(Routing(WorkspaceRouting {+ chatgpt_account_id: "other-account".into(),+ backend_origin: "https://chatgpt.com".into(),+ account_routing_override: "NO_CONSTRAINT".into(),+ }));+ auth.set_workspace_routing_resolver(Arc::downgrade(&resolver));+ let provider = create_model_provider(+ ModelProviderInfo::create_openai_provider(/*base_url*/ None),+ Some(auth),+ );+ assert!(+ provider+ .responses_api_provider(&routing_context)+ .await+ .is_err()+ );+ drop(resolver);+ assert!(+ provider+ .responses_api_provider(&routing_context)+ .await+ .is_err()+ );+}