From 15c5444e87e334d40262d07adb8e383c1e5172fc Mon Sep 17 00:00:00 2001 From: Anthony Tafoya Date: Fri, 20 Nov 2026 05:02:54 +0000 Subject: [PATCH] Force executor capability rescans after V2 cache invalidation (#62675) ## Why Invalidating Codex's discovery cache could still return stale inventory if the executor reused its cached snapshot before its file watcher reported a change. ## What changed Add an optional `forceReload` flag to `capabilities/discoverV2` that makes the executor rescan its files. Codex sends it on the next lookup of each invalidated context. Explicit reloads also replace the matching cache entry so subsequent ordinary requests can reuse the fresh result. ## Testing Add coverage for discovering a newly added skill before the watcher runs, forwarding the reload flag after invalidation, and reusing refreshed results. GitOrigin-RevId: c98f2b8d4772e10b74ff09dd382ad8386857158f --- .../core/src/session/executor_discovery.rs | 2 + .../core/tests/suite/executor_discovery_v2.rs | 79 +++++++++++++++++- .../exec-server-protocol/src/capabilities.rs | 3 + .../src/capabilities_tests.rs | 12 +++ .../src/capability_discovery_v2_cache.rs | 80 +++++++++++++------ .../exec-server/src/client_refresh_tests.rs | 1 + .../src/discoverV2/capability_manager.rs | 23 +++--- .../tests/capability_discoveries_tests.rs | 3 + .../tests/capability_manager_tests.rs | 43 ++++++++++ .../tests/capability_watchers_tests.rs | 2 + .../src/environment/discovery_v2_tests.rs | 1 + codex-rs/exec-server/src/server/handler.rs | 2 +- codex-rs/exec-server/tests/capabilities_v2.rs | 3 + codex-rs/exec-server/tests/initialize.rs | 1 + 14 files changed, 221 insertions(+), 34 deletions(-) diff --git a/codex-rs/core/src/session/executor_discovery.rs b/codex-rs/core/src/session/executor_discovery.rs index 12f16e4c26..e0c98d11ed 100644 --- a/codex-rs/core/src/session/executor_discovery.rs +++ b/codex-rs/core/src/session/executor_discovery.rs @@ -53,6 +53,7 @@ impl ExecutorDiscovery { &selected.selection.environment_id, selected.environment(), DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: selected.cwd().clone(), sandbox: Some(selected.sandbox_context(/*additional_permissions*/ None)), }, @@ -129,6 +130,7 @@ impl Session { continue; } let request = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: selected.cwd().clone(), sandbox: Some(self.discovery_sandbox(selected, skill_turn)), }; diff --git a/codex-rs/core/tests/suite/executor_discovery_v2.rs b/codex-rs/core/tests/suite/executor_discovery_v2.rs index 43b53f4704..5c2ce9b1ce 100644 --- a/codex-rs/core/tests/suite/executor_discovery_v2.rs +++ b/codex-rs/core/tests/suite/executor_discovery_v2.rs @@ -1123,6 +1123,7 @@ async fn v2_discovery_failures_retry_or_remain_cached_by_error_kind() -> Result< .context("remote environment")?; let cache = codex_exec_server::ExecutorCapabilityDiscoveryV2Cache::default(); let request = codex_exec_server::DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: codex_utils_path_uri::PathUri::parse("file:///repo")?, sandbox: None, }; @@ -1276,6 +1277,16 @@ pub(super) async fn check_acquisition(enabled: bool, version: &'static str) -> R assert_eq!(calls().await, before, "invalidation is lazy"); let _ = test.codex.current_mcp_config_and_runtime_context().await; assert_eq!(calls().await, before + 1); + assert_eq!( + executor + .requests + .lock() + .await + .iter() + .rfind(|request| request["method"] == "capabilities/discoverV2") + .context("refreshed discovery request")?["params"]["forceReload"], + true, + ); let observed = observed.lock().await; let inventory = observed .last() @@ -1591,6 +1602,7 @@ async fn v2_discovery_cache_reuses_matching_requests_and_isolates_execution_cont .context("remote environment")?; let cache = codex_exec_server::ExecutorCapabilityDiscoveryV2Cache::default(); let request = codex_exec_server::DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: codex_utils_path_uri::PathUri::from_host_native_path(root.path())?, sandbox: None, }; @@ -1718,13 +1730,78 @@ async fn v2_discovery_cache_reuses_matching_requests_and_isolates_execution_cont .map_err(anyhow::Error::msg)?; // Reading the oldest entry did not promote it: eviction is FIFO, not LRU. let reloaded = cache - .discover("other-executor", &environment, request) + .discover("other-executor", &environment, request.clone()) .await .map_err(anyhow::Error::msg)?; assert_eq!(calls().await, 19); assert!(!Arc::ptr_eq(&other, &reloaded)); assert_eq!(other.as_ref(), reloaded.as_ref()); + // Explicit requests and dirty entries reload once; ordinary reads reuse the result. + let mut previous = reloaded; + for (expected_calls, force_reload) in [(20, true), (21, false)] { + if !force_reload { + cache.invalidate(); + assert_eq!(calls().await, expected_calls - 1); + } + let refreshed = cache + .discover( + "executor", + &environment, + codex_exec_server::DiscoverV2CapabilitiesRequest { + force_reload, + ..request.clone() + }, + ) + .await + .map_err(anyhow::Error::msg)?; + assert!(!Arc::ptr_eq(&previous, &refreshed)); + let ordinary = cache + .discover("executor", &environment, request.clone()) + .await + .map_err(anyhow::Error::msg)?; + assert!(Arc::ptr_eq(&refreshed, &ordinary)); + assert_eq!(calls().await, expected_calls); + assert_eq!( + executor + .requests + .lock() + .await + .iter() + .rfind(|request| request["method"] == "capabilities/discoverV2") + .context("forced discovery request")?["params"]["forceReload"], + true, + ); + previous = refreshed; + } + + // Reloading one dirty entry leaves the others dirty; new contexts load normally. + for (cwd, force_reload) in [("overflow", true), ("new-context", false)] { + cache + .discover( + "executor", + &environment, + codex_exec_server::DiscoverV2CapabilitiesRequest { + cwd: request.cwd.join(cwd)?, + ..request.clone() + }, + ) + .await + .map_err(anyhow::Error::msg)?; + assert_eq!( + executor + .requests + .lock() + .await + .iter() + .rfind(|request| request["method"] == "capabilities/discoverV2") + .context("discovery request")?["params"]["forceReload"] + .as_bool() + .unwrap_or(false), + force_reload, + ); + } + Ok(()) } diff --git a/codex-rs/exec-server-protocol/src/capabilities.rs b/codex-rs/exec-server-protocol/src/capabilities.rs index 29b638796a..732a4d5217 100644 --- a/codex-rs/exec-server-protocol/src/capabilities.rs +++ b/codex-rs/exec-server-protocol/src/capabilities.rs @@ -39,6 +39,9 @@ pub struct DiscoverV2CapabilitiesRequest { pub cwd: PathUri, #[serde(default)] pub sandbox: Option, + /// Rescan the executor's files even if its watcher has not reported a change. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub force_reload: bool, } /// Discovered metadata before caller policy is applied. diff --git a/codex-rs/exec-server-protocol/src/capabilities_tests.rs b/codex-rs/exec-server-protocol/src/capabilities_tests.rs index 7951dea723..8d9940d3f7 100644 --- a/codex-rs/exec-server-protocol/src/capabilities_tests.rs +++ b/codex-rs/exec-server-protocol/src/capabilities_tests.rs @@ -7,14 +7,26 @@ use pretty_assertions::assert_eq; #[test] fn discovery_contract_round_trips_json() -> Result<(), Box> { let request = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::parse("file:///workspace")?, sandbox: None, }; let wire = serde_json::to_value(&request)?; + assert!(wire.get("forceReload").is_none()); assert_eq!( serde_json::from_value::(wire)?, request ); + let refreshed = DiscoverV2CapabilitiesRequest { + force_reload: true, + ..request + }; + let wire = serde_json::to_value(&refreshed)?; + assert_eq!(wire["forceReload"], true); + assert_eq!( + serde_json::from_value::(wire)?, + refreshed + ); let text_file = CapabilityTextFile { path: PathUri::parse("file:///plugin/config.json")?, contents: "{}".to_string(), diff --git a/codex-rs/exec-server/src/capability_discovery_v2_cache.rs b/codex-rs/exec-server/src/capability_discovery_v2_cache.rs index f1d4e62638..d8e575c8c2 100644 --- a/codex-rs/exec-server/src/capability_discovery_v2_cache.rs +++ b/codex-rs/exec-server/src/capability_discovery_v2_cache.rs @@ -1,5 +1,5 @@ //! Lazy V2 responses, cached per environment, executor session, cwd, and sandbox. -//! Dirty entries are replaced on the next lookup; in-flight readers may finish with older results. +//! Reloads replace the matching entry; in-flight readers may finish with older results. //! Reports recovery from retryable failures so Core can refresh dependent MCP projections. use std::sync::Arc; @@ -9,12 +9,14 @@ use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; +use codex_utils_path_uri::PathUri; use tokio::sync::OnceCell; use crate::DiscoverV2CapabilitiesRequest; use crate::DiscoverV2CapabilitiesResponse; use crate::Environment; use crate::ExecServerError; +use crate::FileSystemSandboxContext; const MIN_CACHED_DISCOVERY_CONTEXTS: usize = 16; @@ -26,12 +28,28 @@ pub struct ExecutorCapabilityDiscoveryV2Cache { recovered_discovery: AtomicBool, } -struct CachedEnvironmentDiscovery { - request: DiscoverV2CapabilitiesRequest, +// Reload controls how this entry is populated, not which inventory it identifies. +struct DiscoveryCacheKey { environment: Weak, session_id: Option, + cwd: PathUri, + sandbox: Option, +} + +impl PartialEq for DiscoveryCacheKey { + fn eq(&self, other: &Self) -> bool { + self.environment.ptr_eq(&other.environment) + && self.session_id == other.session_id + && self.cwd == other.cwd + && self.sandbox == other.sandbox + } +} + +struct CachedEnvironmentDiscovery { + key: DiscoveryCacheKey, response: Arc, Arc>>>, retryable: Arc, + force_reload: bool, dirty: bool, } @@ -46,7 +64,7 @@ impl ExecutorCapabilityDiscoveryV2Cache { self.recovered_discovery.swap(false, Ordering::AcqRel) } - /// Makes future lookups reload every context without interrupting existing loads. + /// Dirties cached entries so their next lookup reloads without interrupting existing loads. pub fn invalidate(&self) { let mut entries = self .entries @@ -66,56 +84,68 @@ impl ExecutorCapabilityDiscoveryV2Cache { let environment = Arc::downgrade(environment); for entry in entries .iter_mut() - .filter(|entry| entry.environment.ptr_eq(&environment)) + .filter(|entry| entry.key.environment.ptr_eq(&environment)) { entry.dirty = true; } } - /// Reuses successes and non-retryable failures using V1's error classification. + /// Reuses successes and non-retryable failures unless the request forces a reload. /// Retryable failures and cancelled loads leave the cell available for retry. /// Invalidation during a load applies to the next lookup, not its current readers. pub async fn discover( &self, environment_id: &str, environment: &Arc, - request: DiscoverV2CapabilitiesRequest, + mut request: DiscoverV2CapabilitiesRequest, ) -> Result, Arc> { // Resolve startup/replacement before lookup; a resumed session keeps its cache entries. let session_id = environment.executor_session_id().await.map_err(|error| { tracing::warn!(environment_id, "executor discovery V2 session unavailable"); Arc::new(error) })?; - let (response, retryable) = { + let key = DiscoveryCacheKey { + environment: Arc::downgrade(environment), + session_id, + cwd: request.cwd.clone(), + sandbox: request.sandbox.clone(), + }; + let (response, retryable, force_reload) = { let mut entries = self .entries .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); - let environment = Arc::downgrade(environment); - if let Some(entry) = entries.iter().find(|entry| { - !entry.dirty - && entry.environment.ptr_eq(&environment) - && entry.session_id == session_id - && entry.request == request - }) { - (Arc::clone(&entry.response), Arc::clone(&entry.retryable)) + let matching = entries.iter().position(|entry| entry.key == key); + if let Some(entry) = matching + .map(|index| &entries[index]) + .filter(|entry| !entry.dirty && !request.force_reload) + { + ( + Arc::clone(&entry.response), + Arc::clone(&entry.retryable), + entry.force_reload, + ) } else { + let force_reload = request.force_reload || matching.is_some(); + if let Some(index) = matching { + entries.remove(index); + } // Recovery belongs to the environment/request, not one executor session. let retryable = entries .iter() .find(|entry| { !entry.dirty - && entry.environment.ptr_eq(&environment) - && entry.request == request + && entry.key.environment.ptr_eq(&key.environment) + && entry.key.cwd == key.cwd + && entry.key.sandbox == key.sandbox }) .map(|entry| Arc::clone(&entry.retryable)) .unwrap_or_default(); let entry = CachedEnvironmentDiscovery { - request: request.clone(), - environment, - session_id, + key, response: Arc::new(OnceCell::new()), retryable, + force_reload, dirty: false, }; let capacity = self @@ -123,17 +153,21 @@ impl ExecutorCapabilityDiscoveryV2Cache { .load(Ordering::Relaxed) .max(MIN_CACHED_DISCOVERY_CONTEXTS); // Existing readers retain their response cells after replacement or eviction. - entries.retain(|entry| !entry.dirty); if entries.len() >= capacity { entries.remove(0); } - let load = (Arc::clone(&entry.response), Arc::clone(&entry.retryable)); + let load = ( + Arc::clone(&entry.response), + Arc::clone(&entry.retryable), + force_reload, + ); entries.push(entry); load } }; let response = response .get_or_try_init(|| async { + request.force_reload = force_reload; match environment.discover_capabilities_v2(request).await { Ok(response) => Ok(Ok(Arc::new(response))), Err(error) => { diff --git a/codex-rs/exec-server/src/client_refresh_tests.rs b/codex-rs/exec-server/src/client_refresh_tests.rs index 93b479bafa..344009ee94 100644 --- a/codex-rs/exec-server/src/client_refresh_tests.rs +++ b/codex-rs/exec-server/src/client_refresh_tests.rs @@ -349,6 +349,7 @@ async fn refresh_retires_a_still_connected_old_executor() -> Result<()> { )); let cache = crate::ExecutorCapabilityDiscoveryV2Cache::default(); let request = crate::DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: codex_utils_path_uri::PathUri::from_host_native_path(&root)?, sandbox: None, }; diff --git a/codex-rs/exec-server/src/discoverV2/capability_manager.rs b/codex-rs/exec-server/src/discoverV2/capability_manager.rs index 58851f7b53..a327af7f4c 100644 --- a/codex-rs/exec-server/src/discoverV2/capability_manager.rs +++ b/codex-rs/exec-server/src/discoverV2/capability_manager.rs @@ -1,7 +1,6 @@ //! Retains watched global locations and sandbox-scoped response snapshots. //! Replacement snapshots isolate in-flight loads; failed watch registration forces request-time reloads. -use crate::DiscoverV2CapabilitiesRequest; use crate::DiscoverV2CapabilitiesResponse; use crate::FileSystemSandboxContext; use crate::LocalFileSystem; @@ -80,22 +79,25 @@ impl CapabilityManager { } /// Reuses startup locations, retrying prewarming if the background scan failed. - pub(crate) async fn get_or_refresh_discovery( + pub(crate) async fn discover( self: &Arc, - params: DiscoverV2CapabilitiesRequest, + sandbox: Option, + force_reload: bool, ) -> io::Result> { let (location_request, _) = self.prewarm_locations().await?; - let location_state = self.get_or_refresh_locations(location_request).await?; + let location_state = self + .get_or_refresh_locations(location_request, force_reload) + .await?; let discovery = { let mut discoveries = location_state.sandbox_discoveries.lock().await; if let Some(discovery) = discoveries .iter() - .find(|discovery| discovery.sandbox == params.sandbox) + .find(|discovery| discovery.sandbox == sandbox) { Arc::clone(discovery) } else { let discovery = Arc::new(CachedSandboxDiscovery { - sandbox: params.sandbox, + sandbox, response: OnceCell::new(), }); if discoveries.len() == MAX_CACHED_SANDBOX_CONTEXTS { @@ -130,8 +132,10 @@ impl CapabilityManager { async fn get_or_refresh_locations( &self, request: &CapabilityLocationRequest, + force_reload: bool, ) -> io::Result> { - if let Some(location_state) = self.location_snapshot().await + if !force_reload + && let Some(location_state) = self.location_snapshot().await && location_state.registration.registration_succeeded() && !location_state.dirty.load(Ordering::Relaxed) { @@ -142,7 +146,8 @@ impl CapabilityManager { .acquire() .await .map_err(io::Error::other)?; - if let Some(location_state) = self.location_snapshot().await + if !force_reload + && let Some(location_state) = self.location_snapshot().await && location_state.registration.registration_succeeded() && !location_state.dirty.load(Ordering::Relaxed) { @@ -152,7 +157,7 @@ impl CapabilityManager { let locations = match prewarm_locations(&self.file_system, request).await { Ok(locations) => locations, Err(error) => { - if let Some(location_state) = self.location_snapshot().await { + if !force_reload && let Some(location_state) = self.location_snapshot().await { tracing::warn!(error_kind = ?error.kind(), "capability refresh failed; retrying on the next request"); return Ok(location_state); } diff --git a/codex-rs/exec-server/src/discoverV2/tests/capability_discoveries_tests.rs b/codex-rs/exec-server/src/discoverV2/tests/capability_discoveries_tests.rs index 2975953969..f14eabd8f5 100644 --- a/codex-rs/exec-server/src/discoverV2/tests/capability_discoveries_tests.rs +++ b/codex-rs/exec-server/src/discoverV2/tests/capability_discoveries_tests.rs @@ -120,6 +120,7 @@ async fn discovery_preserves_inventory_and_v1_metadata() -> anyhow::Result<()> { manager.seed_prewarmed_locations(request.clone()).await?; let response = manager .get_or_refresh_discovery(DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(temp.path().join("project"))?, sandbox: None, }) @@ -344,6 +345,7 @@ policy: manager.seed_prewarmed_locations(request.clone()).await?; let response = manager .get_or_refresh_discovery(DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(temp.path().join("project"))?, sandbox: None, }) @@ -396,6 +398,7 @@ async fn standalone_skills_retain_their_search_roots() -> anyhow::Result<()> { let manager = CapabilityManager::new(LocalFileSystem::unsandboxed()); manager.seed_prewarmed_locations(request.clone()).await?; let query = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(temp.path().join("project"))?, sandbox: None, }; diff --git a/codex-rs/exec-server/src/discoverV2/tests/capability_manager_tests.rs b/codex-rs/exec-server/src/discoverV2/tests/capability_manager_tests.rs index 8e639d01fd..7fefdac87b 100644 --- a/codex-rs/exec-server/src/discoverV2/tests/capability_manager_tests.rs +++ b/codex-rs/exec-server/src/discoverV2/tests/capability_manager_tests.rs @@ -1,6 +1,7 @@ //! Covers bounded context caching, shared initialization, cancellation retry, and cached warnings. use super::*; +use crate::DiscoverV2CapabilitiesRequest; use crate::discover_v2::capability_locations::tests::request; use crate::discover_v2::capability_locations::tests::write; use codex_protocol::models::PermissionProfile; @@ -8,6 +9,13 @@ use codex_utils_path_uri::PathUri; use pretty_assertions::assert_eq; impl CapabilityManager { + pub(in crate::discover_v2) async fn get_or_refresh_discovery( + self: &Arc, + request: DiscoverV2CapabilitiesRequest, + ) -> io::Result> { + self.discover(request.sandbox, request.force_reload).await + } + // Supply fixture paths through the existing cell, without production override state. pub(crate) async fn seed_prewarmed_locations( self: &Arc, @@ -47,6 +55,7 @@ async fn discovery_responses_are_cached_by_sandbox_context() -> anyhow::Result<( let cwd = PathUri::from_host_native_path(directory.path().join("project"))?; let other_cwd = PathUri::from_host_native_path(directory.path().join("other"))?; let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: cwd.clone(), sandbox: None, }; @@ -99,6 +108,39 @@ async fn discovery_responses_are_cached_by_sandbox_context() -> anyhow::Result<( Ok(()) } +#[tokio::test] +async fn forced_discovery_reads_new_skills_before_the_watcher_runs() -> anyhow::Result<()> { + let (directory, manager) = setup().await?; + let params = DiscoverV2CapabilitiesRequest { + force_reload: false, + cwd: PathUri::from_host_native_path(directory.path())?, + sandbox: None, + }; + let original = manager.get_or_refresh_discovery(params.clone()).await?; + write( + directory.path(), + "codex/skills/added/SKILL.md", + "---\nname: added\ndescription: new skill\n---\n", + )?; + assert!(Arc::ptr_eq( + &original, + &manager.get_or_refresh_discovery(params.clone()).await?, + )); + + let refreshed = manager + .get_or_refresh_discovery(DiscoverV2CapabilitiesRequest { + force_reload: true, + ..params.clone() + }) + .await?; + assert!(refreshed.skills.iter().any(|skill| skill.name == "added")); + assert!(Arc::ptr_eq( + &refreshed, + &manager.get_or_refresh_discovery(params).await?, + )); + Ok(()) +} + #[test] fn cancelled_initialization_retries_and_warning_responses_are_cached() -> anyhow::Result<()> { tokio::runtime::Builder::new_current_thread() @@ -108,6 +150,7 @@ fn cancelled_initialization_retries_and_warning_responses_are_cached() -> anyhow .block_on(async { let (directory, manager) = setup().await?; let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(directory.path().join("project"))?, sandbox: None, }; diff --git a/codex-rs/exec-server/src/discoverV2/tests/capability_watchers_tests.rs b/codex-rs/exec-server/src/discoverV2/tests/capability_watchers_tests.rs index c9cc807c6d..a9237b3b16 100644 --- a/codex-rs/exec-server/src/discoverV2/tests/capability_watchers_tests.rs +++ b/codex-rs/exec-server/src/discoverV2/tests/capability_watchers_tests.rs @@ -40,6 +40,7 @@ async fn watch_events_invalidate_discovery_and_no_subscription_disables_caching( let manager = CapabilityManager::new(LocalFileSystem::unsandboxed()); manager.seed_prewarmed_locations(request.clone()).await?; let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(&root)?, sandbox: None, }; @@ -279,6 +280,7 @@ async fn failed_watch_registration_reloads_locations_and_contents() -> anyhow::R )?; let request = request(&root)?; let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::from_host_native_path(&root)?, sandbox: None, }; diff --git a/codex-rs/exec-server/src/environment/discovery_v2_tests.rs b/codex-rs/exec-server/src/environment/discovery_v2_tests.rs index 986f302e7d..2dfbf9643f 100644 --- a/codex-rs/exec-server/src/environment/discovery_v2_tests.rs +++ b/codex-rs/exec-server/src/environment/discovery_v2_tests.rs @@ -93,6 +93,7 @@ async fn discovery_checks_version_and_retries_disconnect( ScopedSkillsConfig::default(), ); let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: PathUri::parse("file:///caller/project-b")?, sandbox: None, }; diff --git a/codex-rs/exec-server/src/server/handler.rs b/codex-rs/exec-server/src/server/handler.rs index 5a54b9bfbc..37737d782c 100644 --- a/codex-rs/exec-server/src/server/handler.rs +++ b/codex-rs/exec-server/src/server/handler.rs @@ -348,7 +348,7 @@ impl ExecServerHandler { ) -> Result, JSONRPCErrorError> { self.require_initialized_for("capability discovery")?; self.capability_manager - .get_or_refresh_discovery(params) + .discover(params.sandbox, params.force_reload) .await .map_err(|error| internal_error(error.to_string())) } diff --git a/codex-rs/exec-server/tests/capabilities_v2.rs b/codex-rs/exec-server/tests/capabilities_v2.rs index 57ebe74a80..f96a3b6002 100644 --- a/codex-rs/exec-server/tests/capabilities_v2.rs +++ b/codex-rs/exec-server/tests/capabilities_v2.rs @@ -63,6 +63,7 @@ async fn v2_rpc_refreshes_metadata_and_enforces_sandbox() -> anyhow::Result<()> let project = tempfile::tempdir()?; let cwd = PathUri::from_host_native_path(project.path())?; let params = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: cwd.clone(), sandbox: None, }; @@ -138,6 +139,7 @@ async fn v2_rpc_refreshes_metadata_and_enforces_sandbox() -> anyhow::Result<()> ..sandbox }; let restricted = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: cwd.clone(), sandbox: Some(sandbox), }; @@ -176,6 +178,7 @@ async fn v2_rpc_refreshes_metadata_and_enforces_sandbox() -> anyhow::Result<()> sandbox.windows_sandbox_selection = codex_exec_server::WindowsSandboxSelection::RestrictedToken; let permitted = DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: cwd.clone(), sandbox: Some(sandbox), }; diff --git a/codex-rs/exec-server/tests/initialize.rs b/codex-rs/exec-server/tests/initialize.rs index c9510011ac..fe722a749a 100644 --- a/codex-rs/exec-server/tests/initialize.rs +++ b/codex-rs/exec-server/tests/initialize.rs @@ -196,6 +196,7 @@ async fn discovery_prewarms_before_initialize_and_recovers_without_client_opt_in .send_request( CAPABILITIES_DISCOVER_V2_METHOD, serde_json::to_value(DiscoverV2CapabilitiesRequest { + force_reload: false, cwd: info.cwd.context("startup cwd")?, sandbox: None, })?,