Lightweight coding agent that runs in your terminal
Rust
Refresh resumed thread capability roots from executors (#39746)
sayan-oai2e1f18e0dbb8
diff --git a/codex-rs/core/src/environment_selection.rs b/codex-rs/core/src/environment_selection.rsindex 39a598bff9..0e7718bade 100644--- a/codex-rs/core/src/environment_selection.rs+++ b/codex-rs/core/src/environment_selection.rs@@ -54,6 +54,59 @@ impl EnvironmentConfigOrigin {}selection}++ pub(crate) fn selected_capability_roots(+ self,+ environment: &Environment,+ config: &EnvironmentConfig,+ ) -> Vec<SelectedCapabilityRoot> {+ match self {+ Self::Thread => environment.selected_capability_roots(),+ Self::Owner => config.selected_capability_roots.clone(),+ }+ }+}++/// Combines persisted thread roots with attachment roots in selection order.+///+/// Thread-owned attachments still rely on roots reported by legacy executors. A matching live root+/// refreshes the persisted location while explicit owner configuration retains the existing+/// thread-first collision behavior.+pub(crate) fn combine_selected_capability_roots(+ thread_roots: &[SelectedCapabilityRoot],+ sources: impl IntoIterator<Item = (EnvironmentConfigOrigin, Vec<SelectedCapabilityRoot>)>,+) -> Vec<SelectedCapabilityRoot> {+ let attachment_roots = sources+ .into_iter()+ .flat_map(|(config_origin, roots)| roots.into_iter().map(move |root| (config_origin, root)))+ .collect::<Vec<_>>();+ let mut combined_roots = thread_roots+ .iter()+ .map(|thread_root| {+ let CapabilityRootLocation::Environment {+ environment_id: thread_environment_id,+ ..+ } = &thread_root.location;+ attachment_roots+ .iter()+ .find_map(|(origin, attachment_root)| {+ if *origin != EnvironmentConfigOrigin::Thread+ || attachment_root.id != thread_root.id+ {+ return None;+ }+ let CapabilityRootLocation::Environment {+ environment_id: attachment_environment_id,+ ..+ } = &attachment_root.location;+ (attachment_environment_id == thread_environment_id).then_some(attachment_root)+ })+ .unwrap_or(thread_root)+ .clone()+ })+ .collect::<Vec<_>>();+ combined_roots.extend(attachment_roots.into_iter().map(|(_, root)| root));+ combined_roots}pub(crate) fn default_thread_environment_selections(@@ -410,13 +463,20 @@ impl ThreadEnvironments {thread_selected_capability_roots: &[SelectedCapabilityRoot],) -> SelectedCapabilityRootsStatus {let environments = self.environments.load();- let mut selected_capability_roots = thread_selected_capability_roots.to_vec();- for environment in environments.iter() {- let EnvironmentConfigState::Ready(config) = &environment.selection.config else {- continue;- };- selected_capability_roots.extend(config.selected_capability_roots.iter().cloned());- }+ let mut selected_capability_roots = combine_selected_capability_roots(+ thread_selected_capability_roots,+ environments.iter().filter_map(|environment| {+ let EnvironmentConfigState::Ready(config) = &environment.selection.config else {+ return None;+ };+ Some((+ environment.config_origin,+ environment+ .config_origin+ .selected_capability_roots(&environment.environment, config),+ ))+ }),+ );let mut seen_root_ids = HashSet::with_capacity(selected_capability_roots.len());selected_capability_roots.retain(|root| seen_root_ids.insert(root.id.clone()));diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rsindex 6b25214762..a46655e0d3 100644--- a/codex-rs/core/src/session/mcp.rs+++ b/codex-rs/core/src/session/mcp.rs@@ -1,5 +1,6 @@use super::mcp_refresh::McpRefreshInvalidationGuard;use super::*;+use crate::environment_selection::combine_selected_capability_roots;use crate::tools::sandboxing::executor_windows_sandbox_level;use codex_exec_server::ExecutorCapabilityDiscoveryCache;use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;@@ -438,18 +439,18 @@ impl Session {let mut root_locations_by_id = HashMap::new();let mut selected_capability_roots = Vec::new();let mut ready_environment_root_count = 0;- for (index, root) in self- .services- .selected_capability_roots- .iter()- .cloned()- .chain(- environments- .turn_environments()- .flat_map(|environment| environment.config().selected_capability_roots.clone()),- )- .enumerate()- {+ let combined_roots = combine_selected_capability_roots(+ &self.services.selected_capability_roots,+ environments.turn_environments().map(|environment| {+ (+ environment.config_origin,+ environment+ .config_origin+ .selected_capability_roots(&environment.environment, environment.config()),+ )+ }),+ );+ for (index, root) in combined_roots.into_iter().enumerate() {if let Some(kept_location) = root_locations_by_id.get(&root.id) {if kept_location != &root.location {tracing::warn!(diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 43819b1e00..582de2f9d4 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -118,6 +118,7 @@ use std::fs;use std::path::PathBuf;use std::process::Command;use std::sync::Arc;+use std::sync::Mutex;use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use std::time::Duration;@@ -158,13 +159,22 @@ impl ThreadLifecycleContributor<Config> for WaitForEnvironmentTestExtension {}}-struct ReadyCapabilityRootsTestExtension;+#[derive(Default)]+struct ReadyCapabilityRootsTestExtension {+ observed_roots: Option<Arc<Mutex<Vec<Vec<SelectedCapabilityRoot>>>>>,+}impl ContextContributor for ReadyCapabilityRootsTestExtension {fn contribute_world_state<'a>(&'a self,input: WorldStateContributionInput<'a>,) -> ExtensionFuture<'a, Vec<WorldStateSectionContribution>> {+ if let Some(observed_roots) = &self.observed_roots {+ observed_roots+ .lock()+ .expect("observed capability roots should not be poisoned")+ .push(input.ready_selected_capability_roots.to_vec());+ }let root_ids = input.ready_selected_capability_roots.iter()@@ -1218,7 +1228,7 @@ async fn wait_for_response_request_count(response_mock: &ResponseMock, expected_async fn shared_executor_keeps_ready_capability_roots_scoped_to_each_attachment() -> Result<()> {let server = start_mock_server().await;let mut extensions = ExtensionRegistryBuilder::new();- extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension));+ extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension::default()));let mut builder = test_codex().with_extensions(Arc::new(extensions.build())).with_config(|config| {@@ -1484,7 +1494,7 @@ async fn pending_attachment_installs_configuration_before_waiting_turn_resumes()let server = start_mock_server().await;let mut extensions = ExtensionRegistryBuilder::new();extensions.thread_lifecycle_contributor(Arc::new(WaitForEnvironmentTestExtension));- extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension));+ extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension::default()));let mut builder = test_codex().with_extensions(Arc::new(extensions.build())).with_config(|config| {@@ -1718,9 +1728,12 @@ async fn pending_attachment_installs_configuration_before_waiting_turn_resumes()Ok(())}+#[test_case(true; "uses refreshed executor root")]+#[test_case(false; "preserves persisted root when executor reports none")]#[tokio::test(flavor = "multi_thread", worker_threads = 4)]-async fn ready_before_selection_exposes_remote_tools_and_capability_context_after_wait()--> Result<()> {+async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wait(+ executor_reports_refreshed_root: bool,+) -> Result<()> {const WAIT_CALL_ID: &str = "wait-ready-before-selection";let rendezvous = TcpListener::bind("127.0.0.1:0").await?;@@ -1804,9 +1817,12 @@ async fn ready_before_selection_exposes_remote_tools_and_capability_context_afte],).await;+ let observed_roots = Arc::new(Mutex::new(Vec::new()));let mut extensions = ExtensionRegistryBuilder::new();extensions.thread_lifecycle_contributor(Arc::new(WaitForEnvironmentTestExtension));- extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension));+ extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension {+ observed_roots: Some(Arc::clone(&observed_roots)),+ }));let mut builder = test_codex().with_extensions(Arc::new(extensions.build())).with_config(|config| {@@ -1816,20 +1832,36 @@ async fn ready_before_selection_exposes_remote_tools_and_capability_context_afteassert!(config.features.enable(Feature::UnifiedExec).is_ok());});let test = builder.build(&server).await?;- let ready_root = SelectedCapabilityRoot {+ let refreshed_root = SelectedCapabilityRoot {id: "ready-first-root".to_string(),location: CapabilityRootLocation::Environment {environment_id: REMOTE_ENVIRONMENT_ID.to_string(),path: PathUri::parse("file:///ready-first-root")?,},};+ let stale_root = SelectedCapabilityRoot {+ id: refreshed_root.id.clone(),+ location: CapabilityRootLocation::Environment {+ environment_id: REMOTE_ENVIRONMENT_ID.to_string(),+ path: PathUri::parse("file:///stale-ready-first-root")?,+ },+ };+ let expected_root = if executor_reports_refreshed_root {+ refreshed_root.clone()+ } else {+ stale_root.clone()+ };let environment = test.thread_manager.environment_manager().report_environment_provisioning_status(REMOTE_ENVIRONMENT_ID.to_string(),Ok(EnvironmentReadyInfo {- selected_capability_roots: Vec::new(),+ selected_capability_roots: if executor_reports_refreshed_root {+ vec![refreshed_root.clone()]+ } else {+ Vec::new()+ },}),Arc::new(ReadyNoiseConnectProvider {websocket_url: format!("{rendezvous_url}/relay?role=harness"),@@ -1867,26 +1899,45 @@ async fn ready_before_selection_exposes_remote_tools_and_capability_context_afteanyhow::Ok(())});- test.submit_turn_with_environments(- "use the ready environment",- Some(vec![TurnEnvironmentSelection {- environment_id: REMOTE_ENVIRONMENT_ID.to_string(),- cwd: PathUri::from_abs_path(&test.config.cwd),- workspace_roots: vec![PathUri::from_abs_path(&test.config.cwd)],- config: EnvironmentConfigState::Ready(EnvironmentConfig {- allow_login_shell: true,- permission_profile: PermissionProfileSnapshot::legacy(- test.config.permissions.permission_profile().clone(),- ),- shell_environment_policy: Default::default(),- exec_policy: None,- mcp_policy: None,- network_policy: None,- selected_capability_roots: vec![ready_root],- }),- }]),- )- .await?;+ let selection = TurnEnvironmentSelection {+ environment_id: REMOTE_ENVIRONMENT_ID.to_string(),+ cwd: PathUri::from_abs_path(&test.config.cwd),+ workspace_roots: vec![PathUri::from_abs_path(&test.config.cwd)],+ config: EnvironmentConfigState::FromThread,+ };+ let mut thread_extension_init = ExtensionDataInit::new();+ thread_extension_init.insert(vec![stale_root]);+ let resumed = test+ .thread_manager+ .start_thread(StartThreadOptions {+ environments: Some(vec![selection.clone()]),+ thread_extension_init,+ ..StartThreadOptions::new(test.config.clone())+ })+ .await?;+ resumed+ .thread+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "use the ready environment".to_string(),+ text_elements: Vec::new(),+ }]))+ .await?;+ wait_for_event(&resumed.thread, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ assert_eq!(+ resumed.thread.environment_selections().await,+ vec![selection]+ );+ assert_eq!(+ resumed+ .thread+ .inspect_selected_capability_roots()+ .ready_roots,+ vec![expected_root.clone()]+ );let requests = response_mock.requests();assert_eq!(requests.len(), 2);@@ -1930,6 +1981,14 @@ async fn ready_before_selection_exposes_remote_tools_and_capability_context_afte.iter().any(|text| text.contains("<ready_capability_roots>ready-first-root")));+ let observed_selected_roots = observed_roots+ .lock()+ .expect("observed capability roots should not be poisoned")+ .iter()+ .rfind(|roots| roots.iter().any(|root| root.id == expected_root.id))+ .cloned()+ .context("selected capability root should reach world state")?;+ assert_eq!(observed_selected_roots, vec![expected_root]);relay.abort();remote_environment.abort();