Lightweight coding agent that runs in your terminal
Rust
Refresh environment dates from the configured clock (#36187)
rka-oai9eeac78b3f0c
diff --git a/codex-rs/app-server/tests/suite/v2/current_time.rs b/codex-rs/app-server/tests/suite/v2/current_time.rsindex d3a012f0ea..9f8ae49d46 100644--- a/codex-rs/app-server/tests/suite/v2/current_time.rs+++ b/codex-rs/app-server/tests/suite/v2/current_time.rs@@ -2,8 +2,12 @@ use anyhow::Result;use app_test_support::MockResponsesConfig;use app_test_support::TestAppServer;use app_test_support::create_final_assistant_message_sse_response;+use chrono::DateTime;+use chrono::Local;+use chrono::Utc;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::CurrentTimeReadResponse;+use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::ServerRequest;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;@@ -68,35 +72,54 @@ clock_source = "external"}).await?;- let server_request = timeout(- DEFAULT_READ_TIMEOUT,- app_server.read_stream_until_request_message(),- )- .await??;- let ServerRequest::CurrentTimeRead { request_id, params } = server_request else {- panic!("expected CurrentTimeRead request, got: {server_request:?}");- };- assert_eq!(params.thread_id, thread.id);- app_server- .send_response(- request_id,- serde_json::to_value(CurrentTimeReadResponse {- current_time_at: CURRENT_TIME_AT,- })?,- )- .await?;- timeout(- DEFAULT_READ_TIMEOUT,- app_server.read_stream_until_notification_message("turn/completed"),- )+ let mut current_time_reads = 0;+ timeout(DEFAULT_READ_TIMEOUT, async {+ loop {+ match app_server.read_next_message().await? {+ JSONRPCMessage::Request(request) => {+ let server_request = ServerRequest::try_from(request)?;+ let ServerRequest::CurrentTimeRead { request_id, params } = server_request+ else {+ panic!("expected CurrentTimeRead request, got: {server_request:?}");+ };+ assert_eq!(params.thread_id, thread.id);+ current_time_reads += 1;+ app_server+ .send_response(+ request_id,+ serde_json::to_value(CurrentTimeReadResponse {+ current_time_at: CURRENT_TIME_AT,+ })?,+ )+ .await?;+ }+ JSONRPCMessage::Notification(notification)+ if notification.method == "turn/completed" =>+ {+ break Ok::<_, anyhow::Error>(());+ }+ _ => {}+ }+ }+ }).await??;+ assert!(current_time_reads >= 2);+ let request = response_mock.single_request();assert!(- response_mock- .single_request()+ request.message_input_texts("developer").iter().any(|text| text == CURRENT_TIME_REMINDER));+ let current_date = DateTime::<Utc>::from_timestamp(CURRENT_TIME_AT, 0)+ .expect("test timestamp should be valid")+ .with_timezone(&Local)+ .format("%Y-%m-%d")+ .to_string();+ assert!(request.message_input_texts("user").iter().any(|text| {+ text.contains("<environment_context>")+ && text.contains(&format!("<current_date>{current_date}</current_date>"))+ }));Ok(())}diff --git a/codex-rs/app-server/tests/suite/v2/sleep.rs b/codex-rs/app-server/tests/suite/v2/sleep.rsindex a886125645..b0b4a939f2 100644--- a/codex-rs/app-server/tests/suite/v2/sleep.rs+++ b/codex-rs/app-server/tests/suite/v2/sleep.rs@@ -54,6 +54,7 @@ async fn external_sleep_polls_current_time_and_emits_items() -> Result<()> {let codex_home = TempDir::new()?;MockResponsesConfig::new(&server.uri())+ .with_root_config("include_environment_context = false").with_extra_config(r#"[features.current_time_reminder]enabled = truediff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex 63f2c69aff..074719114d 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -496,7 +496,7 @@ impl CodexThread {.await?;self.session.record_context_updates_and_set_reference_context_item(step_context.as_ref())- .await;+ .await?;}self.session.inject_no_new_turn(items, Some(turn_context.as_ref()))diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rsindex 6fcec9bb27..ac7cc87bee 100644--- a/codex-rs/core/src/compact_tests.rs+++ b/codex-rs/core/src/compact_tests.rs@@ -18,7 +18,12 @@ async fn process_compacted_history_with_test_session(.await;let step_context =crate::session::step_context::StepContext::for_test(Arc::clone(&turn_context));- let world_state = Arc::new(session.build_world_state_for_step(&step_context).await);+ let world_state = Arc::new(+ session+ .build_world_state_for_step(&step_context)+ .await+ .expect("world state should build"),+ );let initial_context = session.build_initial_context_with_world_state(&turn_context, world_state.as_ref()).await;diff --git a/codex-rs/core/src/compact_token_budget.rs b/codex-rs/core/src/compact_token_budget.rsindex 1e47496638..2abb6b0b24 100644--- a/codex-rs/core/src/compact_token_budget.rs+++ b/codex-rs/core/src/compact_token_budget.rs@@ -40,7 +40,7 @@ pub(crate) async fn run_manual_compact_task(let step_context = sess.capture_step_context(Arc::clone(&turn_context), &CancellationToken::new()).await?;- let world_state = Arc::new(sess.build_world_state_for_step(&step_context).await);+ let world_state = Arc::new(sess.build_world_state_for_step(&step_context).await?);run_compact_task_inner(&sess, &step_context, world_state, CompactionTrigger::Manual).await}@@ -57,7 +57,7 @@ pub(crate) async fn run_inline_auto_compact_task(let world_state = match initial_context_injection {InitialContextInjection::BeforeLastUserMessage { world_state, .. } => world_state,InitialContextInjection::DoNotInject => {- Arc::new(sess.build_world_state_for_step(&step_context).await)+ Arc::new(sess.build_world_state_for_step(&step_context).await?)}};run_compact_task_inner(&sess, &step_context, world_state, CompactionTrigger::Auto).awaitdiff --git a/codex-rs/core/src/context/world_state/environment.rs b/codex-rs/core/src/context/world_state/environment.rsindex 735f864a6c..c039544ca0 100644--- a/codex-rs/core/src/context/world_state/environment.rs+++ b/codex-rs/core/src/context/world_state/environment.rs@@ -27,6 +27,7 @@ impl EnvironmentsState {pub(crate) fn from_turn_context_with_environments(turn_context: &TurnContext,environments: &TurnEnvironmentSnapshot,+ current_date: Option<String>,) -> Self {let workspace_roots = environments.primary()@@ -34,7 +35,7 @@ impl EnvironmentsState {.unwrap_or_default();Self {environments: environment_states(environments),- current_date: turn_context.current_date.clone(),+ current_date,timezone: turn_context.timezone.clone(),network: network_from_turn_context(turn_context),filesystem: Some(FileSystemContext::from_permission_profile(diff --git a/codex-rs/core/src/prompt_debug.rs b/codex-rs/core/src/prompt_debug.rsindex 3fbaf1d683..b97a5a2c7c 100644--- a/codex-rs/core/src/prompt_debug.rs+++ b/codex-rs/core/src/prompt_debug.rs@@ -88,7 +88,7 @@ pub(crate) async fn build_prompt_input_from_session(.capture_step_context(Arc::clone(&turn_context), &CancellationToken::new()).await?;sess.record_context_updates_and_set_reference_context_item(step_context.as_ref())- .await;+ .await?;if !input.is_empty() {let response_item = sess.response_item_from_user_input(input);diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 1e81eecdbd..0c7b438464 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -2992,10 +2992,10 @@ impl Session {&self,previous_world_state: &Arc<WorldState>,step_context: &step_context::StepContext,- ) -> Arc<WorldState> {+ ) -> CodexResult<Arc<WorldState>> {let turn_context = step_context.turn.as_ref();// Render model-visible state from the same step used to build and run tools.- let world_state = Arc::new(self.build_world_state_for_step(step_context).await);+ let world_state = Arc::new(self.build_world_state_for_step(step_context).await?);// Derive the model update and persisted patch from the same two snapshots.let previous_snapshot = previous_world_state.snapshot();let world_state_snapshot = world_state.snapshot();@@ -3020,7 +3020,7 @@ impl Session {self.persist_rollout_items(&[RolloutItem::WorldState(world_state_item)]).await;}- world_state+ Ok(world_state)}/// Captures one request-scoped view of dynamic state.@@ -3711,7 +3711,7 @@ impl Session {pub(crate) async fn record_context_updates_and_set_reference_context_item(&self,step_context: &StepContext,- ) -> Arc<WorldState> {+ ) -> CodexResult<Arc<WorldState>> {let turn_context = step_context.turn.as_ref();let reference_context_item = {let state = self.state.lock().await;@@ -3720,7 +3720,7 @@ impl Session {let turn_context_item = turn_context.to_turn_context_item();let turn_context_changed = reference_context_item.as_ref() != Some(&turn_context_item);let should_inject_full_context = reference_context_item.is_none();- let world_state = Arc::new(self.build_world_state_for_step(step_context).await);+ let world_state = Arc::new(self.build_world_state_for_step(step_context).await?);// Full initial context resets the baseline; later turns persist only its changes.let (mut context_items, world_state_item) = if should_inject_full_context {let context_items = self@@ -3757,7 +3757,7 @@ impl Session {// A snapshot can change without producing model-visible or TurnContext updates.let only_world_state_changed = !turn_context_changed && context_items.is_empty();if only_world_state_changed && world_state_item.is_none() {- return world_state;+ return Ok(world_state);}if !context_items.is_empty() {self.record_conversation_items(turn_context, &context_items)@@ -3770,7 +3770,7 @@ impl Session {}// A snapshot-only change does not require a duplicate TurnContext record.if only_world_state_changed {- return world_state;+ return Ok(world_state);}// Persist one `TurnContextItem` per real user turn so resume/lazy replay can recover the// latest durable baseline even when this turn emitted no model-visible context diffs.@@ -3781,7 +3781,7 @@ impl Session {// context items.let mut state = self.state.lock().await;state.set_reference_context_item(Some(turn_context_item));- world_state+ Ok(world_state)}pub(crate) async fn update_token_usage_info(diff --git a/codex-rs/core/src/session/rollout_reconstruction_tests.rs b/codex-rs/core/src/session/rollout_reconstruction_tests.rsindex f5bf358d5a..952d4714e6 100644--- a/codex-rs/core/src/session/rollout_reconstruction_tests.rs+++ b/codex-rs/core/src/session/rollout_reconstruction_tests.rs@@ -165,7 +165,8 @@ async fn record_initial_history_restores_world_state_baseline() {let step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");assert_eq!(session.clone_history().await.raw_items(),diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex d0378c4bf1..a71c37fa2f 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -2575,7 +2575,8 @@ async fn resumed_history_injects_initial_context_on_first_context_update_only()let step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");let initial_context = build_initial_context(&session, &turn_context).await;expected.extend(initial_context);let history_after_seed = session.clone_history().await;@@ -2586,7 +2587,8 @@ async fn resumed_history_injects_initial_context_on_first_context_update_only()session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");let history_after_second_seed = session.clone_history().await;assert_eq!(history_after_seed.raw_items(),@@ -3208,7 +3210,12 @@ async fn start_new_context_window_assigns_and_persists_item_ids() {.capture_step_context(Arc::clone(&turn_context), &CancellationToken::new()).await.expect("a fresh cancellation token cannot be cancelled");- let world_state = Arc::new(session.build_world_state_for_step(&step_context).await);+ let world_state = Arc::new(+ session+ .build_world_state_for_step(&step_context)+ .await+ .expect("world state should build"),+ );session.start_new_context_window(&step_context, world_state)@@ -5616,7 +5623,10 @@ pub(crate) async fn build_world_state_from_turn_context(turn_context: &Arc<TurnContext>,) -> WorldState {let step_context = StepContext::for_test(Arc::clone(turn_context));- session.build_world_state_for_step(&step_context).await+ session+ .build_world_state_for_step(&step_context)+ .await+ .expect("world state should build")}// todo: use online model info@@ -8716,7 +8726,6 @@ async fn record_context_updates_emits_environment_item_for_time_changes() {&session.services.models_manager,).await;- current_context.current_date = Some("2026-02-27".to_string());current_context.timezone = Some("Europe/Berlin".to_string());let update_items =@@ -8726,7 +8735,8 @@ async fn record_context_updates_emits_environment_item_for_time_changes() {.into_iter().find(|text| text.contains("<environment_context>")).expect("environment update item should be emitted");- assert!(environment_update.contains("<current_date>2026-02-27</current_date>"));+ let current_date = chrono::Local::now().format("%Y-%m-%d").to_string();+ assert!(environment_update.contains(&format!("<current_date>{current_date}</current_date>")));assert!(environment_update.contains("<timezone>Europe/Berlin</timezone>"));}@@ -8777,13 +8787,15 @@ async fn record_context_update_items(let previous_step = StepContext::for_test(previous_context);session.record_context_updates_and_set_reference_context_item(&previous_step)- .await;+ .await+ .expect("world state should build");let previous_len = session.clone_history().await.raw_items().len();let current_step = StepContext::for_test(Arc::new(current_context));session.record_context_updates_and_set_reference_context_item(¤t_step)- .await;+ .await+ .expect("world state should build");let history = session.clone_history().await;history.raw_items()[previous_len..].to_vec()}@@ -9009,7 +9021,8 @@ async fn record_context_updates_includes_turn_context_fragments_on_steady_state_let step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");let history = session.clone_history().await;let developer_messages = developer_message_texts(history.raw_items());@@ -9467,7 +9480,8 @@ async fn record_context_updates_and_set_reference_context_item_injects_full_contlet step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");let history = session.clone_history().await;let initial_context = build_initial_context(&session, &turn_context).await;assert_eq!(@@ -9503,7 +9517,8 @@ async fn record_context_updates_and_set_reference_context_item_reinjects_full_co.await;session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");{let mut state = session.state.lock().await;state.set_reference_context_item(/*item*/ None);@@ -9517,7 +9532,8 @@ async fn record_context_updates_and_set_reference_context_item_reinjects_full_cosession.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");let history = session.clone_history().await;let mut expected_history = vec![compacted_summary];@@ -9562,7 +9578,8 @@ async fn record_context_updates_and_set_reference_context_item_persists_baselinelet step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");assert_eq!(session.clone_history().await.raw_items().to_vec(),@@ -9611,7 +9628,8 @@ async fn record_context_updates_and_set_reference_context_item_persists_split_filet step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");session.ensure_rollout_materialized().await;session.flush_rollout().await.expect("rollout should flush");@@ -9698,7 +9716,8 @@ async fn record_context_updates_and_set_reference_context_item_persists_full_reilet step_context = StepContext::for_test(Arc::clone(&turn_context));session.record_context_updates_and_set_reference_context_item(&step_context)- .await;+ .await+ .expect("world state should build");session.ensure_rollout_materialized().await;session.flush_rollout().await.expect("rollout should flush");diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rsindex 15ac87b7d1..5e84027b43 100644--- a/codex-rs/core/src/session/tests/guardian_tests.rs+++ b/codex-rs/core/src/session/tests/guardian_tests.rs@@ -540,7 +540,12 @@ async fn process_compacted_history_preserves_separate_guardian_developer_messageturn_context.developer_instructions = Some(guardian_policy.clone());let turn_context = Arc::new(turn_context);let step_context = StepContext::for_test(Arc::clone(&turn_context));- let world_state = Arc::new(session.build_world_state_for_step(&step_context).await);+ let world_state = Arc::new(+ session+ .build_world_state_for_step(&step_context)+ .await+ .expect("world state should build"),+ );let initial_context_injection = InitialContextInjection::BeforeLastUserMessage {world_state,step_context,diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 2a51f892e3..09358b82a8 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -210,10 +210,11 @@ pub(crate) async fn run_turn(Err(err) => return Err(err),};// Keep the exact model-visible state used by this turn and its inline compactions.- let (mut world_state, display_roots) = tokio::join!(+ let (world_state, display_roots) = tokio::join!(sess.record_context_updates_and_set_reference_context_item(first_step_context.as_ref()),turn_diff_display_roots(first_step_context.as_ref()),);+ let mut world_state = world_state?;let Some((injection_items, explicitly_enabled_connectors)) = build_skills_and_plugins(&sess,@@ -325,7 +326,7 @@ pub(crate) async fn run_turn(world_state = sess.record_step_world_state_if_changed(&world_state, step_context.as_ref())- .await;+ .await?;// Construct the input that we will send to the model.let sampling_request_input: Vec<ResponseItem> = async {diff --git a/codex-rs/core/src/session/world_state.rs b/codex-rs/core/src/session/world_state.rsindex 7663beb7c9..f60ef8398e 100644--- a/codex-rs/core/src/session/world_state.rs+++ b/codex-rs/core/src/session/world_state.rs@@ -20,13 +20,15 @@ use crate::context::world_state::ToolsState;use crate::context::world_state::WorldState;use codex_extension_api::WorldStateContributionInput;use codex_features::Feature;+use codex_protocol::error::CodexErr;+use codex_protocol::error::Result as CodexResult;impl Session {#[tracing::instrument(name = "world_state.build", level = "info", skip_all)]pub(crate) async fn build_world_state_for_step(&self,step_context: &StepContext,- ) -> WorldState {+ ) -> CodexResult<WorldState> {let turn_context = step_context.turn.as_ref();tracing::trace!(selected_capability_root_count = step_context.selected_capability_roots.len(),@@ -134,10 +136,20 @@ impl Session {world_state.add_section(collaboration_mode);}if turn_context.config.include_environment_context {+ let current_date = self+ .services+ .time_provider+ .current_time(self.thread_id())+ .await+ .map_err(|err| CodexErr::Fatal(format!("failed to read current time: {err:#}")))?+ .with_timezone(&chrono::Local)+ .format("%Y-%m-%d")+ .to_string();world_state.add_section(EnvironmentsState::from_turn_context_with_environments(turn_context,&step_context.environments,+ Some(current_date),).with_subagents(environment_subagents),);@@ -205,6 +217,6 @@ impl Session {world_state.add_section(MultiAgentModeState::new(super::multi_agents::effective_multi_agent_mode(turn_context),));- world_state+ Ok(world_state)}}diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rsindex e12e2bfbe1..83ca4512a4 100644--- a/codex-rs/core/src/tasks/mod.rs+++ b/codex-rs/core/src/tasks/mod.rs@@ -607,6 +607,17 @@ impl Session {}Err(err) => {warn!(%err, "session task returned an unexpected error");+ self.emit_turn_error_lifecycle(+ turn_context.as_ref(),+ err.to_codex_protocol_error(),+ )+ .await;+ self.track_turn_codex_error(turn_context.as_ref(), &err);+ self.send_event(+ turn_context.as_ref(),+ EventMsg::Error(err.to_error_event(/*message_prefix*/ None)),+ )+ .await;(None, None)}};diff --git a/codex-rs/core/tests/suite/current_time_reminder.rs b/codex-rs/core/tests/suite/current_time_reminder.rsindex 9a9440fb33..4e1da82e5f 100644--- a/codex-rs/core/tests/suite/current_time_reminder.rs+++ b/codex-rs/core/tests/suite/current_time_reminder.rs@@ -7,6 +7,7 @@ use std::time::Duration;use anyhow::Result;use anyhow::anyhow;use chrono::DateTime;+use chrono::Local;use chrono::Utc;use codex_core::SleepFuture;use codex_core::TimeFuture;@@ -100,6 +101,7 @@ fn enable_current_time_reminder(interval: u64,clock_source: CurrentTimeSource,) {+ config.include_environment_context = false;config.features.enable(Feature::CurrentTimeReminder)@@ -111,6 +113,56 @@ fn enable_current_time_reminder(});}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn environment_context_uses_external_current_time_on_each_turn() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = start_mock_server().await;+ let responses = mount_sse_sequence(+ &server,+ vec![+ sse(vec![ev_response_created("resp-1"), ev_completed("resp-1")]),+ sse(vec![ev_response_created("resp-2"), ev_completed("resp-2")]),+ ],+ )+ .await;+ let time_provider = Arc::new(TestTimeProvider::default());+ let test = test_codex()+ .with_config(|config| {+ enable_current_time_reminder(config, /*interval*/ 0, CurrentTimeSource::External);+ config.include_environment_context = true;+ })+ .with_external_time_provider(time_provider.clone())+ .build_with_auto_env(&server)+ .await?;++ test.submit_turn("first simulated day").await?;+ time_provider+ .current_time+ .store(FIRST_TIME_UNIX_SECONDS + 86_400, Ordering::Relaxed);+ test.submit_turn("second simulated day").await?;++ let requests = responses.requests();+ assert_eq!(requests.len(), 2);+ for (request, timestamp) in requests+ .iter()+ .zip([FIRST_TIME_UNIX_SECONDS, FIRST_TIME_UNIX_SECONDS + 86_400])+ {+ let current_date = DateTime::<Utc>::from_timestamp(timestamp, 0)+ .expect("test timestamp should be valid")+ .with_timezone(&Local)+ .format("%Y-%m-%d")+ .to_string();+ assert!(request.message_input_texts("user").iter().any(|text| {+ text.contains("<environment_context>")+ && text.contains(&format!("<current_date>{current_date}</current_date>"))+ }));+ }+ assert_eq!(current_time_reminders(&requests[0]), vec![SECOND_REMINDER]);++ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn current_time_reminders_follow_time_interval_and_persist_in_history() -> Result<()> {skip_if_no_network!(Ok(()));@@ -368,10 +420,11 @@ async fn time_provider_failure_stops_before_inference() -> Result<()> {.await;let test = test_codex().with_config(|config| {- enable_current_time_reminder(config, /*interval*/ 1, CurrentTimeSource::External)+ enable_current_time_reminder(config, /*interval*/ 1, CurrentTimeSource::External);+ config.include_environment_context = true;}).with_external_time_provider(Arc::new(FailingTimeProvider))- .build(&server)+ .build_with_auto_env(&server).await?;test.codexdiff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rsindex de64275c45..aaf736ab8e 100644--- a/codex-rs/core/tests/suite/guardian_review.rs+++ b/codex-rs/core/tests/suite/guardian_review.rs@@ -1,8 +1,18 @@#![cfg(not(target_os = "windows"))]use anyhow::Result;+use chrono::DateTime;+use chrono::Local;+use chrono::Utc;+use codex_core::SleepFuture;+use codex_core::TimeFuture;+use codex_core::TimeProvider;use codex_core::config::Constrained;+use codex_core::config::CurrentTimeReminderConfig;use codex_core::sandboxing::SandboxPermissions;+use codex_features::CurrentTimeSource;+use codex_features::Feature;+use codex_protocol::ThreadId;use codex_protocol::config_types::ApprovalsReviewer;use codex_protocol::openai_models::AutoReviewMessages;use codex_protocol::openai_models::ModelsResponse;@@ -33,9 +43,34 @@ use serde_json::Value;use serde_json::json;use std::fs;use std::os::unix::fs::PermissionsExt;+use std::sync::Arc;+use std::sync::Mutex;use std::time::Duration;use tempfile::TempDir;+const CURRENT_TIME_AT: i64 = 1_781_717_655;++struct RecordingTimeProvider {+ thread_ids: Mutex<Vec<ThreadId>>,+}++impl TimeProvider for RecordingTimeProvider {+ fn current_time(&self, thread_id: ThreadId) -> TimeFuture<'_> {+ self.thread_ids+ .lock()+ .expect("time-provider thread ids lock should not be poisoned")+ .push(thread_id);+ Box::pin(async {+ Ok(DateTime::<Utc>::from_timestamp(CURRENT_TIME_AT, 0)+ .expect("test timestamp should be valid"))+ })+ }++ fn sleep(&self, _thread_id: ThreadId, _duration: Duration) -> SleepFuture<'_> {+ Box::pin(async { Ok(()) })+ }+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_session_prewarms_and_is_reused_for_first_review() -> Result<()> {skip_if_no_network!(Ok(()));@@ -85,17 +120,31 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review() -> Result<()]],]).await;- let mut builder = test_codex().with_config(move |config| {- config.model_catalog = Some(ModelsResponse {- models: vec![review_model],- });- config.model_context_window = Some(900_000);- config.model_auto_compact_token_limit = Some(600_000);- config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);- config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ let time_provider = Arc::new(RecordingTimeProvider {+ thread_ids: Mutex::new(Vec::new()),});+ let mut builder = test_codex()+ .with_config(move |config| {+ config.model_catalog = Some(ModelsResponse {+ models: vec![review_model],+ });+ config.model_context_window = Some(900_000);+ config.model_auto_compact_token_limit = Some(600_000);+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ config+ .features+ .enable(Feature::CurrentTimeReminder)+ .expect("test config should allow current-time reminders");+ config.current_time_reminder = Some(CurrentTimeReminderConfig {+ clock_source: CurrentTimeSource::External,+ ..CurrentTimeReminderConfig::default()+ });+ })+ .with_external_time_provider(time_provider.clone());let test = builder.build_with_websocket_server(&server).await?;+ let root_thread_id = test.session_configured.thread_id;let (first, second) = tokio::time::timeout(Duration::from_secs(5), async {tokio::join!(server.wait_for_request(/*connection_index*/ 0, /*request_index*/ 0),@@ -103,6 +152,14 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review() -> Result<())}).await?;+ assert!(+ time_provider+ .thread_ids+ .lock()+ .expect("time-provider thread ids lock should not be poisoned")+ .is_empty(),+ "startup prewarm must not request the external clock"+ );let prewarm_requests = [first.body_json(), second.body_json()];let guardian_prewarm = prewarm_requests.iter()@@ -145,6 +202,32 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review() -> Result<()guardian_review["client_metadata"]["thread_id"].as_str(),Some(guardian_thread_id));+ let current_date = DateTime::<Utc>::from_timestamp(CURRENT_TIME_AT, 0)+ .expect("test timestamp should be valid")+ .with_timezone(&Local)+ .format("%Y-%m-%d")+ .to_string();+ assert!(+ guardian_review+ .to_string()+ .contains(&format!("<current_date>{current_date}</current_date>")),+ "guardian's environment context should use the simulated current date"+ );+ let guardian_thread_id = ThreadId::from_string(guardian_thread_id)?;+ {+ let thread_ids = time_provider+ .thread_ids+ .lock()+ .expect("time-provider thread ids lock should not be poisoned");+ assert!(thread_ids.contains(&root_thread_id));+ assert!(thread_ids.contains(&guardian_thread_id));+ assert!(+ thread_ids+ .iter()+ .all(|thread_id| thread_id == &root_thread_id || thread_id == &guardian_thread_id),+ "clock requests should use the corresponding agent's own thread id: {thread_ids:?}"+ );+ }assert_eq!(guardian_review.get("generate"), None);let guardian_rollout_path = test