Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Prevent invalidated wakeups from starting a turn (#51427)

jif0ef50c9f663f
diff --git a/codex-rs/app-server-transport/src/transport/remote_control/tests.rs b/codex-rs/app-server-transport/src/transport/remote_control/tests.rs
index 611d540583..490ac1e37b 100644
--- a/codex-rs/app-server-transport/src/transport/remote_control/tests.rs
+++ b/codex-rs/app-server-transport/src/transport/remote_control/tests.rs
@@ -2617,7 +2617,10 @@ async fn remote_control_http_mode_reenrolls_after_explicit_missing_server_404()
)
.await;
- let (handshake_request, _websocket) = accept_remote_control_backend_connection(&listener).await;
+ // Re-enrollment is followed by reconnect backoff, so allow time for that delay.
+ let (handshake_request, _websocket) =
+ accept_remote_control_backend_connection_with_timeout(&listener, Duration::from_secs(45))
+ .await;
expect_remote_control_status(
&mut status_rx,
/*expected_status*/ None,
diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs
index 0d183a1793..bfc9c13415 100644
--- a/codex-rs/core/src/tasks/mod.rs
+++ b/codex-rs/core/src/tasks/mod.rs
@@ -531,6 +531,17 @@ impl Session {
self.input_queue
.extend_pending_input_for_turn_state(turn_state.as_ref(), input)
.await;
+ // Context construction can outlive an interrupt or replacement. Do not let
+ // start_task recreate a turn whose reservation is no longer ours.
+ if self
+ .active_turn
+ .lock()
+ .await
+ .as_ref()
+ .is_none_or(|turn| !Arc::ptr_eq(&turn.turn_state, &turn_state))
+ {
+ return;
+ }
self.start_task(turn_context, Vec::new(), RegularTask::new())
.await;
}
diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rs
index 8142ec5c11..a65fbf2d88 100644
--- a/codex-rs/core/tests/suite/mod.rs
+++ b/codex-rs/core/tests/suite/mod.rs
@@ -241,6 +241,7 @@ mod unstable_features_warning;
mod user_notification;
mod user_shell_cmd;
mod view_image;
+mod wake_reservation;
mod web_search;
#[path = "web_search_system_proxy_tests.rs"]
mod web_search_system_proxy;
diff --git a/codex-rs/core/tests/suite/wake_reservation.rs b/codex-rs/core/tests/suite/wake_reservation.rs
new file mode 100644
index 0000000000..e6a44d0395
--- /dev/null
+++ b/codex-rs/core/tests/suite/wake_reservation.rs
@@ -0,0 +1,209 @@
+//! A wake invalidated during context construction must not enter task startup.
+
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+use codex_core::TurnInputRequest;
+use codex_core::config::Config;
+use codex_extension_api::ExtensionFuture;
+use codex_extension_api::ExtensionRegistryBuilder;
+use codex_extension_api::TurnLifecycleContributor;
+use codex_extension_api::TurnStartInput;
+use codex_extension_api::TurnStopInput;
+use codex_extension_items::sleep::SleepItem;
+use codex_http_client::HttpClientFactory;
+use codex_login::AuthManager;
+use codex_models_manager::ModelsManagerConfig;
+use codex_models_manager::bundled_models_response;
+use codex_models_manager::manager::ModelsManager;
+use codex_models_manager::manager::ModelsManagerFuture;
+use codex_models_manager::manager::RefreshStrategy;
+use codex_models_manager::manager::StaticModelsManager;
+use codex_protocol::AgentPath;
+use codex_protocol::config_types::CollaborationModeMask;
+use codex_protocol::openai_models::ModelInfo;
+use codex_protocol::openai_models::ModelsResponse;
+use codex_protocol::protocol::EventMsg;
+use codex_protocol::protocol::InterAgentCommunication;
+use codex_protocol::protocol::Op;
+use codex_protocol::user_input::UserInput;
+use core_test_support::responses;
+use core_test_support::test_codex::test_codex;
+use core_test_support::wait_for_event;
+use pretty_assertions::assert_eq;
+use tokio::sync::Notify;
+use tokio::sync::TryLockError;
+
+#[derive(Debug, Default)]
+struct Gate {
+ entered: Notify,
+ release: Notify,
+}
+
+#[derive(Debug)]
+struct GatedModelsManager {
+ inner: StaticModelsManager,
+ gate_next_lookup: AtomicBool,
+ context_build: Gate,
+}
+
+impl ModelsManager for GatedModelsManager {
+ fn raw_model_catalog(
+ &self,
+ strategy: RefreshStrategy,
+ factory: HttpClientFactory,
+ ) -> ModelsManagerFuture<'_, ModelsResponse> {
+ self.inner.raw_model_catalog(strategy, factory)
+ }
+
+ fn get_remote_models(&self) -> ModelsManagerFuture<'_, Vec<ModelInfo>> {
+ self.inner.get_remote_models()
+ }
+
+ fn try_get_remote_models(&self) -> Result<Vec<ModelInfo>, TryLockError> {
+ self.inner.try_get_remote_models()
+ }
+
+ fn auth_manager(&self) -> Option<&AuthManager> {
+ self.inner.auth_manager()
+ }
+
+ fn list_collaboration_modes(&self) -> Vec<CollaborationModeMask> {
+ self.inner.list_collaboration_modes()
+ }
+
+ fn refresh_if_new_etag(
+ &self,
+ etag: String,
+ factory: HttpClientFactory,
+ ) -> ModelsManagerFuture<'_, ()> {
+ self.inner.refresh_if_new_etag(etag, factory)
+ }
+
+ fn get_model_info<'a>(
+ &'a self,
+ model: &'a str,
+ config: &'a ModelsManagerConfig,
+ ) -> ModelsManagerFuture<'a, ModelInfo> {
+ Box::pin(async move {
+ if self.gate_next_lookup.swap(/*val*/ false, Ordering::SeqCst) {
+ self.context_build.entered.notify_one();
+ self.context_build.release.notified().await;
+ }
+ self.inner.get_model_info(model, config).await
+ })
+ }
+}
+
+struct CompletionSignal(Arc<Notify>);
+
+impl Drop for CompletionSignal {
+ fn drop(&mut self) {
+ self.0.notify_one();
+ }
+}
+
+#[derive(Default)]
+struct SleepingTurn {
+ started: AtomicUsize,
+ has_stopped: AtomicBool,
+ stop: Gate,
+ finished: Arc<Notify>,
+}
+
+impl TurnLifecycleContributor for SleepingTurn {
+ fn on_turn_start<'a>(&'a self, _input: TurnStartInput<'a>) -> ExtensionFuture<'a, ()> {
+ Box::pin(async move {
+ self.started.fetch_add(/*val*/ 1, Ordering::SeqCst);
+ })
+ }
+
+ fn on_turn_stop<'a>(&'a self, input: TurnStopInput<'a>) -> ExtensionFuture<'a, ()> {
+ Box::pin(async move {
+ if self.has_stopped.swap(/*val*/ true, Ordering::SeqCst) {
+ return;
+ }
+ input.thread_store.insert(SleepItem {
+ id: "sleep-before-mail".to_string(),
+ duration_ms: 60_000,
+ });
+ // This turn's context survives through the completion-triggered wake.
+ // Its drop is a barrier after the entire wake attempt has returned.
+ input
+ .turn_store
+ .insert(CompletionSignal(Arc::clone(&self.finished)));
+ self.stop.entered.notify_one();
+ self.stop.release.notified().await;
+ })
+ }
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn interrupt_during_wake_context_construction_does_not_start_turn() -> anyhow::Result<()> {
+ let server = responses::start_mock_server().await;
+ let requests = responses::mount_sse_once(&server, responses::sse_completed("initial")).await;
+ let models = Arc::new(GatedModelsManager {
+ inner: StaticModelsManager::new(/*auth_manager*/ None, bundled_models_response()?),
+ gate_next_lookup: AtomicBool::new(/*v*/ false),
+ context_build: Gate::default(),
+ });
+ let sleeping_turn = Arc::new(SleepingTurn::default());
+ let mut extensions = ExtensionRegistryBuilder::<Config>::new();
+ extensions.turn_lifecycle_contributor(sleeping_turn.clone());
+ let test = test_codex()
+ .with_models_manager(models.clone())
+ .with_extensions(Arc::new(extensions.build()))
+ .build_with_auto_env(&server)
+ .await?;
+ let codex = &test.codex;
+ codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "wait for the worker".to_string(),
+ text_elements: Vec::new(),
+ }]))
+ .await?;
+ sleeping_turn.stop.entered.notified().await;
+
+ // Queue mail while the completed turn still owns the reservation, so its
+ // completion starts the wake independently of the submission loop.
+ codex
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new(
+ AgentPath::try_from("/root/worker").expect("valid worker path"),
+ AgentPath::root(),
+ Vec::new(),
+ "worker completed".to_string(),
+ /*trigger_turn*/ false,
+ ),
+ start_options: Default::default(),
+ })
+ .await?;
+ codex.submit(Op::RealtimeConversationListVoices).await?;
+ wait_for_event(codex, |event| {
+ matches!(event, EventMsg::RealtimeConversationListVoicesResponse(_))
+ })
+ .await;
+ models
+ .gate_next_lookup
+ .store(/*val*/ true, Ordering::SeqCst);
+ sleeping_turn.stop.release.notify_one();
+
+ // Context construction happens after the discovery-time reservation check.
+ // Process the interrupt before allowing that context construction to finish.
+ models.context_build.entered.notified().await;
+ codex.submit(Op::Interrupt).await?;
+ codex.submit(Op::RealtimeConversationListVoices).await?;
+ wait_for_event(codex, |event| {
+ matches!(event, EventMsg::RealtimeConversationListVoicesResponse(_))
+ })
+ .await;
+ models.context_build.release.notify_one();
+ sleeping_turn.finished.notified().await;
+
+ assert_eq!(sleeping_turn.started.load(Ordering::SeqCst), 1);
+ requests.single_request();
+ codex.shutdown_and_wait().await?;
+ Ok(())
+}