Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Refresh persisted capability roots from owner-provided configuration (#52676)

teddywyly-oaiaab4f9614877
diff --git a/codex-rs/core/src/environment_selection.rs b/codex-rs/core/src/environment_selection.rs
index 29005bc6bf..f85efc1e79 100644
--- a/codex-rs/core/src/environment_selection.rs
+++ b/codex-rs/core/src/environment_selection.rs
@@ -84,17 +84,13 @@ impl EnvironmentConfigOrigin {
/// 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.
+/// A matching root from the current attachment refreshes its persisted location. Root IDs from
+/// other environments and persisted roots absent from the attachment keep their existing location.
pub(crate) fn combine_selected_capability_roots(
thread_roots: &[SelectedCapabilityRoot],
- sources: impl IntoIterator<Item = (EnvironmentConfigOrigin, Vec<SelectedCapabilityRoot>)>,
+ sources: impl IntoIterator<Item = 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 attachment_roots = sources.into_iter().flatten().collect::<Vec<_>>();
let mut combined_roots = thread_roots
.iter()
.map(|thread_root| {
@@ -104,23 +100,21 @@ pub(crate) fn combine_selected_capability_roots(
} = &thread_root.location;
attachment_roots
.iter()
- .find_map(|(origin, attachment_root)| {
- if *origin != EnvironmentConfigOrigin::Thread
- || attachment_root.id != thread_root.id
- {
- return None;
+ .find(|attachment_root| {
+ if attachment_root.id != thread_root.id {
+ return false;
}
let CapabilityRootLocation::Environment {
environment_id: attachment_environment_id,
..
} = &attachment_root.location;
- (attachment_environment_id == thread_environment_id).then_some(attachment_root)
+ attachment_environment_id == thread_environment_id
})
.unwrap_or(thread_root)
.clone()
})
.collect::<Vec<_>>();
- combined_roots.extend(attachment_roots.into_iter().map(|(_, root)| root));
+ combined_roots.extend(attachment_roots);
combined_roots
}
@@ -715,12 +709,11 @@ impl ThreadEnvironments {
let EnvironmentConfigState::Ready(config) = &environment.selection.config else {
return None;
};
- Some((
- environment.config_origin,
+ Some(
environment
.config_origin
.selected_capability_roots(&environment.environment, config),
- ))
+ )
}),
);
let mut seen_root_ids = HashSet::with_capacity(selected_capability_roots.len());
diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rs
index 67e99d1c65..d2599a4d5c 100644
--- a/codex-rs/core/src/session/mcp.rs
+++ b/codex-rs/core/src/session/mcp.rs
@@ -512,12 +512,9 @@ impl Session {
let combined_roots = combine_selected_capability_roots(
&thread_roots,
environments.turn_environments().map(|environment| {
- (
- environment.config_origin,
- environment
- .config_origin
- .selected_capability_roots(&environment.environment, environment.config()),
- )
+ environment
+ .config_origin
+ .selected_capability_roots(&environment.environment, environment.config())
}),
);
for (index, root) in combined_roots.into_iter().enumerate() {
diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rs
index c658fd8faa..23acf8c18d 100644
--- a/codex-rs/core/tests/suite/remote_env.rs
+++ b/codex-rs/core/tests/suite/remote_env.rs
@@ -2622,11 +2622,14 @@ async fn active_environment_update_wakes_the_old_wait_with_the_new_selection() -
Ok(())
}
-#[test_case(true; "uses refreshed executor root")]
-#[test_case(false; "preserves persisted root when executor reports none")]
+#[test_case(true, false; "uses refreshed executor root")]
+#[test_case(false, false; "preserves persisted root when executor reports none")]
+#[test_case(true, true; "uses refreshed owner root")]
+#[test_case(false, true; "preserves persisted root when owner reports none")]
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wait(
- executor_reports_refreshed_root: bool,
+ reports_refreshed_root: bool,
+ owner_provided: bool,
) -> Result<()> {
const WAIT_CALL_ID: &str = "wait-ready-before-selection";
@@ -2738,11 +2741,17 @@ async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wa
path: PathUri::parse("file:///stale-ready-first-root")?,
},
};
- let expected_root = if executor_reports_refreshed_root {
+ let expected_root = if reports_refreshed_root {
refreshed_root.clone()
} else {
stale_root.clone()
};
+ let mut executor_root = refreshed_root.clone();
+ if owner_provided {
+ // Owner configuration must not inherit the executor's shared root location.
+ let CapabilityRootLocation::Environment { path, .. } = &mut executor_root.location;
+ *path = PathUri::parse("file:///shared-root-not-selected-by-owner")?;
+ }
let provider = Arc::new(OfflineThenReadyNoiseConnectProvider {
websocket_url: format!("{rendezvous_url}/relay?role=harness"),
executor_public_key,
@@ -2754,8 +2763,8 @@ async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wa
.report_environment_provisioning_status(
REMOTE_ENVIRONMENT_ID.to_string(),
Ok(EnvironmentReadyInfo {
- selected_capability_roots: if executor_reports_refreshed_root {
- vec![refreshed_root.clone()]
+ selected_capability_roots: if reports_refreshed_root || owner_provided {
+ vec![executor_root]
} else {
Vec::new()
},
@@ -2793,7 +2802,7 @@ async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wa
anyhow::Ok(())
});
- let selection = TurnEnvironmentSelection::new(
+ let mut selection = TurnEnvironmentSelection::new(
TurnEnvironmentRequest {
environment_id: REMOTE_ENVIRONMENT_ID.to_string(),
cwd: PathUri::from_abs_path(&test.config.cwd),
@@ -2802,6 +2811,13 @@ async fn ready_before_selection_resolves_resumed_thread_capability_root_after_wa
},
std::slice::from_ref(&stale_root),
);
+ if owner_provided {
+ let mut config = environment_config_for_selection(&test.config, &selection);
+ if reports_refreshed_root {
+ config.selected_capability_roots = vec![refreshed_root];
+ }
+ selection.config = EnvironmentConfigState::Ready(config);
+ }
let mut thread_extension_init = ExtensionDataInit::new();
thread_extension_init.insert(vec![stale_root]);
let resumed = test