Lightweight coding agent that runs in your terminal
Rust
Handle pending network reviews after process completion (#42746)
jif8e85265c3917
diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rsindex 73cd869fe8..5ca8c44a08 100644--- a/codex-rs/core/src/session/tests/guardian_tests.rs+++ b/codex-rs/core/src/session/tests/guardian_tests.rs@@ -786,6 +786,7 @@ async fn network_approval_uses_published_task_authority_within_same_turn(exec_policy_hint: None,execution_id: None,disconnect: None,+ cancellation: None,},);tokio::pin!(decision);diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rsindex e82780c863..a3e870a92b 100644--- a/codex-rs/core/src/tools/network_approval.rs+++ b/codex-rs/core/src/tools/network_approval.rs@@ -17,6 +17,8 @@ use codex_network_proxy::NetworkPolicyDecider;use codex_network_proxy::NetworkPolicyRequest;use codex_network_proxy::NetworkProtocol;use codex_network_proxy::NetworkProxy;+use codex_network_proxy::NetworkRequestCancellation;+use codex_network_proxy::NetworkRequestCancellationReason;use codex_network_proxy::NetworkRequestDisconnect;use codex_protocol::approvals::NetworkApprovalContext;use codex_protocol::approvals::NetworkApprovalProtocol;@@ -280,6 +282,7 @@ struct PendingHostApprovalOwner<'a> {pending: Arc<PendingHostApproval>,execution_cancellation: Option<CancellationToken>,disconnect: Option<NetworkRequestDisconnect>,+ cancellation: Option<NetworkRequestCancellation>,decision_on_drop: PendingApprovalDecision,completed: bool,}@@ -297,6 +300,7 @@ impl<'a> PendingHostApprovalOwner<'a> {pending,execution_cancellation,disconnect: None,+ cancellation: None,decision_on_drop: PendingApprovalDecision::Deny,completed: false,}@@ -342,6 +346,17 @@ impl<'a> PendingHostApprovalOwner<'a> {impl Drop for PendingHostApprovalOwner<'_> {fn drop(&mut self) {if !self.completed {+ if self+ .cancellation+ .as_ref()+ .and_then(NetworkRequestCancellation::reason)+ == Some(NetworkRequestCancellationReason::ProcessFinished)+ {+ // Normal process cleanup is not a new review failure. Any earlier+ // denial is already recorded in the call outcome.+ self.publish_and_remove(self.decision_on_drop);+ return;+ }if matches!(self.decision_on_drop, PendingApprovalDecision::Deny)&& let Some(registration_id) = self.key.execution_id.as_deref()&& let Some(elapsed) = self@@ -517,20 +532,27 @@ impl NetworkApprovalService {}fn record_call_outcome(&self, registration_id: &str, outcome: String) {+ if let Some(cancellation_token) = self.store_call_outcome(registration_id, outcome) {+ cancellation_token.cancel();+ }+ }++ fn store_call_outcome(+ &self,+ registration_id: &str,+ outcome: String,+ ) -> Option<CancellationToken> {let mut calls = self.calls.lock().unwrap_or_else(std::sync::PoisonError::into_inner);- let Some(call) = calls.active_calls.get(registration_id).cloned() else {- return;- };+ let call = calls.active_calls.get(registration_id)?.clone();// Explicit network-review outcomes replace generic blocked-request fallbacks.calls.call_outcomes.insert(registration_id.to_string(), outcome);- drop(calls);- call.cancellation_token.cancel();+ Some(call.cancellation_token.clone())}fn record_call_outcome_if_absent(&self, registration_id: &str, outcome: String) {@@ -676,6 +698,7 @@ impl NetworkApprovalService {.map(|call| call.cancellation_token.clone()),);pending_owner.disconnect = request.disconnect.clone();+ pending_owner.cancellation = request.cancellation.clone();let permission_profile = owner_call.as_ref()@@ -814,6 +837,18 @@ impl NetworkApprovalService {}};+ if matches!(+ &approval_decision,+ ReviewDecision::NetworkPolicyAmendment { network_policy_amendment }+ if network_policy_amendment.action == NetworkPolicyRuleAction::Deny+ ) && let Some(owner_call) = owner_call.as_ref()+ {+ // Preserve the denial before waiting for the policy commit. Defer+ // cancellation until after saving so it cannot interrupt persistence.+ let _ = self+ .store_call_outcome(&owner_call.registration_id, "rejected by user".to_string());+ }+let _session_policy_commit_guard = if matches!(&approval_decision,ReviewDecision::Approveddiff --git a/codex-rs/core/tests/suite/network_approval_completion.rs b/codex-rs/core/tests/suite/network_approval_completion.rsnew file mode 100644index 0000000000..c1299b0677--- /dev/null+++ b/codex-rs/core/tests/suite/network_approval_completion.rs@@ -0,0 +1,294 @@+//! Exercises process cleanup while a remote network review is still pending.++use super::PushedExecScenario;+use super::accept_initialized_exec_server;+use super::read_exec_server_json;+use super::respond_environment_info;+use super::send_exec_server_json;+use anyhow::Context;+use anyhow::Result;+use base64::Engine;+use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;+use codex_core::TurnInputRequest;+use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::items::CommandExecutionStatus;+use codex_protocol::items::TurnItem;+use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::ThreadSettingsOverrides;+use codex_protocol::user_input::UserInput;+use core_test_support::managed_network_requirements_loader;+use core_test_support::responses::ev_assistant_message;+use core_test_support::responses::ev_completed;+use core_test_support::responses::ev_function_call;+use core_test_support::responses::mount_response_once_match;+use core_test_support::responses::mount_sse_once_match;+use core_test_support::responses::sse;+use core_test_support::responses::sse_response;+use core_test_support::responses::start_mock_server;+use core_test_support::startup::STARTUP_TIMEOUT;+use core_test_support::test_codex::test_codex;+use core_test_support::test_codex::turn_permission_fields;+use pretty_assertions::assert_eq;+use serde_json::Value;+use serde_json::json;+use std::fs;+use std::time::Duration;+use tokio::net::TcpListener;+use tokio::net::TcpStream;+use tokio::time::timeout;+use tokio_tungstenite::WebSocketStream;++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn completed_remote_process_withdraws_pending_network_review() -> Result<()> {+ let server = start_mock_server().await;+ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let exec_server_url = format!("ws://{}", listener.local_addr()?);+ let call_id = "pending-network-at-exit";+ let parent = mount_sse_once_match(+ &server,+ |request: &wiremock::Request| {+ let body = review_body(request);+ body.pointer("/client_metadata/x-openai-subagent") != Some(&json!("guardian"))+ && !body.to_string().contains("pending-network-at-exit")+ },+ sse(vec![+ ev_function_call(+ call_id,+ "exec_command",+ &json!({"cmd": "build-site", "yield_time_ms": 10_000}).to_string(),+ ),+ ev_completed("start"),+ ]),+ )+ .await;+ let pending_review = mount_response_once_match(+ &server,+ |request: &wiremock::Request| {+ review_body(request).pointer("/client_metadata/x-openai-subagent")+ == Some(&json!("guardian"))+ },+ sse_response(sse(vec![ev_completed("review")]))+ .set_delay(Duration::from_secs(/*secs*/ 60)),+ )+ .await;+ let final_response = mount_sse_once_match(+ &server,+ |request: &wiremock::Request| {+ let body = review_body(request);+ body.pointer("/client_metadata/x-openai-subagent") != Some(&json!("guardian"))+ && body.to_string().contains("pending-network-at-exit")+ },+ sse(vec![+ ev_assistant_message("done", "done"),+ ev_completed("done"),+ ]),+ )+ .await;+ let exec_server = tokio::spawn(async move {+ let mut websocket = accept_initialized_exec_server(listener).await;+ let start = loop {+ let request = read_exec_server_json(&mut websocket, STARTUP_TIMEOUT).await;+ if request["method"] == "process/start" {+ break request;+ }+ respond_setup_request(&mut websocket, &request).await;+ };+ assert!(+ start["params"]["networkProxy"]["policyDecisionTimeoutMs"]+ .as_u64()+ .is_some()+ );+ let process_id = &start["params"]["processId"];+ send_exec_server_json(+ &mut websocket,+ json!({"id": start["id"], "result": {"processId": process_id}}),+ )+ .await;+ send_exec_server_json(&mut websocket, json!({+ "id": 1, "method": "network/policyRequest",+ "params": {"processId": process_id, "request": {"protocol": "https_connect", "host": "review.example", "port": 443}}+ })).await;+ timeout(Duration::from_secs(/*secs*/ 10), async {+ while !pending_review.requests().iter().any(|request| {+ request+ .body_json()+ .pointer("/client_metadata/x-openai-subagent")+ == Some(&json!("guardian"))+ }) {+ tokio::select! {+ _ = tokio::time::sleep(Duration::from_millis(/*millis*/ 10)) => {},+ request = read_exec_server_json(&mut websocket, Duration::from_secs(/*secs*/ 10)) => {+ respond_setup_request(&mut websocket, &request).await;+ }+ }+ }+ })+ .await+ .expect("Guardian must start before process completion");+ for message in [+ json!({"method": "process/output", "params": {"processId": process_id, "seq": 1, "stream": "stdout", "chunk": BASE64_STANDARD.encode("build complete\n")}}),+ json!({"method": "process/exited", "params": {"processId": process_id, "seq": 2, "exitCode": 0, "sandboxDenied": false}}),+ json!({"method": "process/closed", "params": {"processId": process_id, "seq": 3}}),+ ] {+ send_exec_server_json(&mut websocket, message).await;+ }+ loop {+ let request =+ read_exec_server_json(&mut websocket, Duration::from_secs(/*secs*/ 10)).await;+ match request["method"].as_str() {+ Some("process/terminate") => {+ send_exec_server_json(+ &mut websocket,+ json!({"id": request["id"], "result": {"running": false}}),+ )+ .await;+ break;+ }+ Some("process/read") => {+ send_exec_server_json(&mut websocket, json!({"id": request["id"], "result": {"chunks": [], "nextSeq": 4, "exited": true, "exitCode": 0, "closed": true, "failure": null, "sandboxDenied": false}})).await;+ }+ None => panic!("withdrawn request must not be approved: {request}"),+ _ => respond_setup_request(&mut websocket, &request).await,+ }+ }+ });+ let test = test_codex()+ .with_exec_server_url(exec_server_url)+ .with_cloud_config_bundle(managed_network_requirements_loader())+ .with_pre_build_hook(|home| {+ fs::write(+ home.join("config.toml"),+ r#"default_permissions = "workspace"+[permissions.workspace.filesystem]+":minimal" = "read"+[permissions.workspace.network]+enabled = true+mode = "full"+allow_local_binding = true+"#,+ )+ .expect("managed network config");+ })+ .with_config(|config| {+ config.project_doc_max_bytes = 0;+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ #[cfg(windows)]+ config.set_windows_sandbox_enabled(/*value*/ true);+ })+ // This test supplies its own fake executor and must not select a CI executor.+ .build(&server)+ .await?;+ let (sandbox_policy, permission_profile) = turn_permission_fields(+ test.session_configured.permission_profile.clone(),+ test.config.cwd.as_path(),+ );+ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "build the site".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ approval_policy: Some(AskForApproval::OnRequest),+ approvals_reviewer: Some(ApprovalsReviewer::AutoReview),+ sandbox_policy: Some(sandbox_policy),+ permission_profile,+ ..Default::default()+ }),+ )+ .await?;+ let completed = timeout(Duration::from_secs(/*secs*/ 15), async {+ loop {+ match test.codex.next_event().await?.msg {+ EventMsg::ItemCompleted(event) => {+ if let TurnItem::CommandExecution(item) = event.item {+ return Ok::<_, anyhow::Error>(item);+ }+ }+ EventMsg::ExecApprovalRequest(_) => anyhow::bail!("unexpected user approval"),+ _ => {}+ }+ }+ })+ .await+ .context("command should complete")??;+ assert_eq!(+ (+ completed.status,+ completed.exit_code,+ completed.aggregated_output.as_deref()+ ),+ (+ CommandExecutionStatus::Completed,+ Some(0),+ Some("build complete\n")+ )+ );+ timeout(Duration::from_secs(/*secs*/ 10), async {+ while final_response.function_call_output_text(call_id).is_none() {+ tokio::time::sleep(Duration::from_millis(/*millis*/ 10)).await;+ }+ })+ .await?;+ let output = final_response+ .function_call_output_text(call_id)+ .context("tool output")?;+ assert!(output.contains("Process exited with code 0"), "{output}");+ assert!(output.contains("build complete"), "{output}");+ assert_eq!(parent.requests().len(), 1);+ timeout(Duration::from_secs(/*secs*/ 10), exec_server).await??;+ Ok(())+}++fn review_body(request: &wiremock::Request) -> Value {+ let bytes = if request+ .headers+ .get("content-encoding")+ .is_some_and(|value| value == "zstd")+ {+ zstd::stream::decode_all(std::io::Cursor::new(&request.body)).expect("decode request")+ } else {+ request.body.clone()+ };+ serde_json::from_slice(&bytes).expect("request JSON")+}++async fn respond_setup_request(websocket: &mut WebSocketStream<TcpStream>, request: &Value) {+ match request["method"].as_str() {+ Some("environment/info") => {+ respond_environment_info(websocket, &request["id"], PushedExecScenario::Complete).await;+ }+ Some("fs/getMetadata" | "fs/readFile" | "fs/readDirectory") => {+ send_exec_server_json(+ websocket,+ json!({+ "id": request["id"],+ "error": {"code": -32004, "message": "not found"}+ }),+ )+ .await;+ }+ Some("fs/canonicalize") => {+ send_exec_server_json(+ websocket,+ json!({+ "id": request["id"],+ "result": {"path": request["params"]["path"]}+ }),+ )+ .await;+ }+ Some("fs/walk") => {+ send_exec_server_json(+ websocket,+ json!({+ "id": request["id"],+ "result": {"entries": [], "errors": [], "truncated": false}+ }),+ )+ .await;+ }+ method => panic!("unexpected setup request: {method:?}"),+ }+}diff --git a/codex-rs/core/tests/suite/unified_exec_process_events.rs b/codex-rs/core/tests/suite/unified_exec_process_events.rsindex 75e0b16e10..4e2210e851 100644--- a/codex-rs/core/tests/suite/unified_exec_process_events.rs+++ b/codex-rs/core/tests/suite/unified_exec_process_events.rs@@ -1075,3 +1075,6 @@ timeout = 900Ok(())}++#[path = "network_approval_completion.rs"]+mod network_approval_completion;diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rsindex f832d9be13..d05a0c14b0 100644--- a/codex-rs/exec-server/src/client.rs+++ b/codex-rs/exec-server/src/client.rs@@ -13,6 +13,8 @@ use arc_swap::ArcSwapOption;use codex_exec_server_protocol::JSONRPCNotification;use codex_network_proxy::NetworkPolicyDecider;use codex_network_proxy::NetworkProxyAuditMetadata;+use codex_network_proxy::NetworkRequestCancellation;+use codex_network_proxy::NetworkRequestCancellationReason;use futures::FutureExt;use futures::future::BoxFuture;use serde_json::Value;@@ -211,6 +213,7 @@ pub(crate) struct SessionState {struct NetworkPolicyState {controller: ArcSwapOption<NetworkPolicyDecisionController>,cancelled: CancellationToken,+ cancellation: NetworkRequestCancellation,audit: Option<NetworkPolicyAuditContext>,}@@ -877,6 +880,13 @@ impl ExecServerClient {&self,process_id: &ProcessId,) -> Result<TerminateResponse, ExecServerError> {+ // A close notification may arrive before the termination response.+ if let Some(session) = self.inner.get_session(process_id) {+ session+ .network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ProcessCancelled);+ }self.call_for_cleanup(EXEC_TERMINATE_METHOD,&TerminateParams {@@ -1318,6 +1328,7 @@ impl SessionState {network_policy: NetworkPolicyState {controller: ArcSwapOption::empty(),cancelled: CancellationToken::new(),+ cancellation: NetworkRequestCancellation::default(),audit: None,},}@@ -1381,6 +1392,11 @@ impl SessionState {let is_closed = matches!(&event, ExecProcessEvent::Closed { .. });ordered_events.closed_published |= is_closed;published_closed |= is_closed;+ if is_closed && ordered_events.exit_published {+ self.network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ProcessFinished);+ }self.events.publish(event);}published_closed@@ -1581,6 +1597,10 @@ impl Session {}pub(crate) fn cancel_network_policy_decisions(&self) {+ self.state+ .network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ProcessCancelled);self.state.network_policy.cancelled.cancel();}@@ -1638,6 +1658,10 @@ impl Inner {let mut next_sessions = sessions.as_ref().clone();next_sessions.remove(process_id);self.sessions.store(Arc::new(next_sessions));+ expected+ .network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ProcessCancelled);expected.network_policy.cancelled.cancel();expected.network_policy.controller.store(None);}@@ -1678,6 +1702,10 @@ fn fail_all_sessions(inner: &Arc<Inner>, message: String) {let sessions = inner.take_all_sessions();for (_, session) in sessions {+ session+ .network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ConnectionClosed);session.network_policy.cancelled.cancel();session.network_policy.controller.store(None);// Sessions synthesize a closed read response and emit a pushed Faileddiff --git a/codex-rs/exec-server/src/client_recovery.rs b/codex-rs/exec-server/src/client_recovery.rsindex 8e9a8c77b2..6b4cf61df1 100644--- a/codex-rs/exec-server/src/client_recovery.rs+++ b/codex-rs/exec-server/src/client_recovery.rs@@ -9,6 +9,8 @@ use codex_network_proxy::NetworkDecision;use codex_network_proxy::NetworkPolicyDecision;use codex_network_proxy::NetworkPolicyRequest;use codex_network_proxy::NetworkProtocol;+use codex_network_proxy::NetworkRequestCancellation;+use codex_network_proxy::NetworkRequestCancellationReason;use serde_json::Value;use tokio::sync::mpsc;use tokio::time::Instant;@@ -526,6 +528,10 @@ impl Inner {Ok(true) => self.remove_session_if(process_id, session),Ok(false) => {}Err(error) => {+ session+ .network_policy+ .cancellation+ .record(NetworkRequestCancellationReason::ProcessCancelled);let terminated: Result<TerminateResponse, ExecServerError> = rpc_client.call_for_cleanup(EXEC_TERMINATE_METHOD,@@ -688,6 +694,10 @@ impl ExecServerClient {let process_cancelled = session.as_ref().map(|session| session.network_policy.cancelled.clone());+ let process_cancellation = session+ .as_ref()+ .map(|session| session.network_policy.cancellation.clone());+ let cancellation = NetworkRequestCancellation::default();let expected_session = session.as_ref().map(Arc::downgrade);let policy_request =(process_id_valid && host_valid).then_some(NetworkPolicyRequest {@@ -712,6 +722,7 @@ impl ExecServerClient {exec_policy_hint: None,execution_id: None,disconnect: None,+ cancellation: Some(cancellation.clone()),});let inner = Arc::downgrade(&inner);let rpc_client = Arc::downgrade(&rpc_client);@@ -721,18 +732,26 @@ impl ExecServerClient {let _request_guard = request_guard;let decision = match (controller, policy_request, process_cancelled) {(Some(controller), Some(request), Some(process_cancelled)) => {- // Core's pending-approval guard makes dropping this- // future on process removal or deadline fail closed.+ // Keep the decision future outside select/timeout so its+ // guard sees the cancellation cause before it is dropped.+ let mut decision = controller.decider.decide(request);tokio::select! {biased;- _ = connection_cancelled.cancelled() => return,+ _ = connection_cancelled.cancelled() => {+ cancellation.record(NetworkRequestCancellationReason::ConnectionClosed);+ return;+ },_ = process_cancelled.cancelled() => {+ cancellation.record(process_cancellation.as_ref()+ .and_then(NetworkRequestCancellation::reason)+ .unwrap_or(NetworkRequestCancellationReason::ProcessCancelled));NetworkDecision::deny(NETWORK_POLICY_DENIAL_REASON)}- decision = timeout(+ result = timeout(controller.timeout,- controller.decider.decide(request),- ) => decision.unwrap_or_else(|_| {+ &mut decision,+ ) => result.unwrap_or_else(|_| {+ cancellation.record(NetworkRequestCancellationReason::TimedOut);NetworkDecision::deny(NETWORK_POLICY_DENIAL_REASON)}),}diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rsindex 5ffb23046d..b2affe0b8c 100644--- a/codex-rs/network-proxy/src/lib.rs+++ b/codex-rs/network-proxy/src/lib.rs@@ -17,6 +17,7 @@ mod process_log_metadata;mod proxy;mod reasons;mod remote_config;+mod request_cancellation;mod request_disconnect;mod responses;mod runtime;@@ -89,6 +90,8 @@ pub use proxy::proxy_url_env_value;pub use proxy::strip_managed_proxy_env;pub use remote_config::RemoteNetworkProxyConfig;pub use remote_config::RemoteNetworkProxyLaunchConfig;+pub use request_cancellation::NetworkRequestCancellation;+pub use request_cancellation::NetworkRequestCancellationReason;pub use request_disconnect::NetworkRequestDisconnect;pub use runtime::BlockedRequest;pub use runtime::BlockedRequestArgs;diff --git a/codex-rs/network-proxy/src/network_policy.rs b/codex-rs/network-proxy/src/network_policy.rsindex 1839c371e4..a47e1249b9 100644--- a/codex-rs/network-proxy/src/network_policy.rs+++ b/codex-rs/network-proxy/src/network_policy.rs@@ -1,4 +1,5 @@use crate::reasons::REASON_POLICY_DENIED;+use crate::request_cancellation::NetworkRequestCancellation;use crate::request_disconnect::NetworkRequestDisconnect;use crate::runtime::HostBlockDecision;use crate::runtime::HostBlockReason;@@ -109,6 +110,8 @@ pub struct NetworkPolicyRequest {pub execution_id: Option<String>,/// Present only when the local HTTP transport can identify an abandoned request.pub disconnect: Option<NetworkRequestDisconnect>,+ /// Controller-owned cause, published before an abandoned decision future is dropped.+ pub cancellation: Option<NetworkRequestCancellation>,}pub struct NetworkPolicyRequestArgs {@@ -145,6 +148,7 @@ impl NetworkPolicyRequest {exec_policy_hint,execution_id: None,disconnect: None,+ cancellation: None,}}}diff --git a/codex-rs/network-proxy/src/request_cancellation.rs b/codex-rs/network-proxy/src/request_cancellation.rsnew file mode 100644index 0000000000..90d481acf1--- /dev/null+++ b/codex-rs/network-proxy/src/request_cancellation.rs@@ -0,0 +1,32 @@+//! Records why a policy request was withdrawn before its decision future is dropped.++use std::sync::Arc;+use std::sync::OnceLock;++/// The controller's first known reason for withdrawing a policy request.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum NetworkRequestCancellationReason {+ /// The process exited and its output streams closed normally.+ ProcessFinished,+ /// The process was explicitly terminated or its handle was abandoned.+ ProcessCancelled,+ /// The connection to the executor was lost.+ ConnectionClosed,+ /// The policy decision deadline expired.+ TimedOut,+}++/// Shared, in-process metadata; recording a reason does not authorize network access.+#[derive(Clone, Debug, Default)]+pub struct NetworkRequestCancellation(Arc<OnceLock<NetworkRequestCancellationReason>>);++impl NetworkRequestCancellation {+ pub fn reason(&self) -> Option<NetworkRequestCancellationReason> {+ self.0.get().copied()+ }++ /// Publish before dropping the decision future. Cleanup cannot replace an earlier cause.+ pub fn record(&self, reason: NetworkRequestCancellationReason) {+ let _ = self.0.set(reason);+ }+}