Lightweight coding agent that runs in your terminal
Rust
Preserve managed network policy in route-aware transports (#47663)
jackz8e17909b2787
diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rsindex a70da0f93f..f06e0c2246 100644--- a/codex-rs/core/tests/suite/code_mode.rs+++ b/codex-rs/core/tests/suite/code_mode.rs@@ -26,6 +26,8 @@ use codex_extension_api::ToolLifecycleFuture;use codex_extension_api::ToolStartInput;use codex_features::CurrentTimeSource;use codex_features::Feature;+use codex_http_client::DestinationPolicy;+use codex_http_client::NetworkPolicyController;use codex_login::CodexAuth;use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;use codex_mcp::codex_apps_mcp_server_config;@@ -108,6 +110,7 @@ use image::codecs::png::PngEncoder;use image::metadata::Orientation;use pretty_assertions::assert_eq;use serde_json::Value;+use std::collections::BTreeSet;use std::collections::HashMap;use std::fs;use std::io::Cursor;@@ -486,28 +489,68 @@ async fn disabled_process_host_with_fallback_disabled_attempts_the_host() -> Res#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn code_mode_can_call_standalone_web_search() -> Result<()> {- assert_code_mode_standalone_web_search(WebSearchMode::Live, serde_json::json!(true)).await+ assert_code_mode_standalone_web_search(+ WebSearchMode::Live,+ serde_json::json!(true),+ SearchPolicy::Unmanaged,+ )+ .await}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn code_mode_can_call_indexed_standalone_web_search() -> Result<()> {- assert_code_mode_standalone_web_search(WebSearchMode::Indexed, serde_json::json!("indexed"))+ assert_code_mode_standalone_web_search(+ WebSearchMode::Indexed,+ serde_json::json!("indexed"),+ SearchPolicy::Unmanaged,+ )+ .await+}++#[test_case(SearchPolicy::DenySearch; "initial_request")]+#[test_case(SearchPolicy::DenyRedirect; "redirect")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn code_mode_web_search_preserves_managed_policy(policy: SearchPolicy) -> Result<()> {+ assert_code_mode_standalone_web_search(WebSearchMode::Live, serde_json::json!(true), policy).await}+enum SearchPolicy {+ Unmanaged,+ DenySearch,+ DenyRedirect,+}+async fn assert_code_mode_standalone_web_search(web_search_mode: WebSearchMode,expected_external_web_access: Value,+ policy: SearchPolicy,) -> Result<()> {skip_if_no_network!(Ok(()));let server = responses::start_mock_server().await;+ let denied = responses::start_mock_server().await;+ let managed = !matches!(policy, SearchPolicy::Unmanaged);+ let deny_search = matches!(policy, SearchPolicy::DenySearch);+ let search_response = match policy {+ SearchPolicy::DenyRedirect => {+ ResponseTemplate::new(/*s*/ 307).insert_header("location", denied.uri())+ }+ SearchPolicy::Unmanaged | SearchPolicy::DenySearch => {+ ResponseTemplate::new(200).set_body_json(serde_json::json!({"output": "Search result"}))+ }+ };+ let controller = NetworkPolicyController::default();+ let mut allowed_endpoints = BTreeSet::from([format!("{}/v1/responses", server.uri()).parse()?]);+ if !deny_search {+ allowed_endpoints.insert(format!("{}/v1/alpha/search", server.uri()).parse()?);+ }+ let policy = controller.policy().restrict_to_endpoints(allowed_endpoints);+ assert!(controller.publish(policy.revision(), DestinationPolicy::Unrestricted));Mock::given(method("POST")).and(path("/v1/alpha/search"))- .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({- "output": "Search result",- })))- .expect(1)+ .respond_with(search_response)+ .expect(if deny_search { 0 } else { 1 }).mount(&server).await;@@ -547,6 +590,10 @@ text(result);.with_extensions(Arc::new(extension_builder.build())).with_model("test-gpt-5.1-codex").with_config(move |config| {+ if managed {+ config.application_network_policy = policy;+ config.respect_system_proxy = false;+ }config.features.enable(Feature::CodeMode)@@ -560,10 +607,21 @@ text(result);.set(web_search_mode).expect("web search mode should be accepted");});- let test = builder.build(&server).await?;+ let test = builder.build_with_auto_env(&server).await?;test.submit_turn("Search the web from code mode").await?;+ if managed {+ let output =+ custom_tool_output_body_and_success(&follow_up_mock.single_request(), "call-1").0;+ assert!(+ output.contains("destination denied by application network policy"),+ "{output}"+ );+ assert!(denied.received_requests().await.unwrap().is_empty());+ return Ok(());+ }+let search_request = server.received_requests().awaitdiff --git a/codex-rs/login/src/auth/default_client.rs b/codex-rs/login/src/auth/default_client.rsindex ae509a4a73..a8c6c1c18c 100644--- a/codex-rs/login/src/auth/default_client.rs+++ b/codex-rs/login/src/auth/default_client.rs@@ -359,7 +359,8 @@ async fn create_client_for_route_async_with_builder(/// Builds the default Codex transport without blocking the async runtime worker.////// Route-aware proxy handling resolves each request and redirect destination. When it is disabled,-/// or the client is running inside the Codex sandbox, this preserves the default client's behavior.+/// or the client is running inside the Codex sandbox, this preserves the default client's proxy+/// behavior while retaining managed application network policy enforcement.pub async fn create_transport_for_routes_async(http_client_factory: HttpClientFactory,route_class: ClientRouteClass,@@ -370,21 +371,28 @@ pub async fn create_transport_for_routes_async(.map_err(std::io::Error::other)?;tokio::task::spawn_blocking(move || {let _permit = permit;- if matches!(+ let sandboxed = is_sandboxed();+ let transport_default_proxy = matches!(http_client_factory.outbound_proxy_policy(),OutboundProxyPolicy::ReqwestDefault- ) || is_sandboxed()+ );+ if !http_client_factory.network_policy().is_managed()+ && (transport_default_proxy || sandboxed){return ReqwestTransport::from_http_client(create_client());}- ReqwestTransport::from_route_aware_client_pool(- RouteAwareClientPool::with_chatgpt_cloudflare_cookies_and_default_headers(- http_client_factory,- route_class,- default_headers(),- ),- )+ let mut pool = RouteAwareClientPool::with_builder(+ http_client_factory,+ route_class,+ default_http_client_builder(),+ );+ if sandboxed {+ pool = pool.with_legacy_direct_proxy_and_custom_ca_fallback();+ } else if transport_default_proxy {+ pool = pool.with_legacy_custom_ca_fallback();+ }+ ReqwestTransport::from_route_aware_client_pool(pool)}).await.map_err(std::io::Error::other)