Lightweight coding agent that runs in your terminal
Rust
Reuse cloud skill catalogs across turns until invalidated (#47350)
Henry Levy8edfca892d46
diff --git a/codex-rs/core/tests/suite/skills_extension/cloud_lifecycle_tests.rs b/codex-rs/core/tests/suite/skills_extension/cloud_lifecycle_tests.rsindex dc5d925fe5..2f86e1cafb 100644--- a/codex-rs/core/tests/suite/skills_extension/cloud_lifecycle_tests.rs+++ b/codex-rs/core/tests/suite/skills_extension/cloud_lifecycle_tests.rs@@ -1,4 +1,4 @@-//! Cloud catalog refresh and auth-scoped retention through real Core turns.+//! Cloud catalog reuse, refresh, and auth-scoped retention through real Core turns.use super::*;use codex_extension_api::ThreadLifecycleContributor;@@ -89,7 +89,7 @@ impl ThreadLifecycleContributor<Config> for SessionResources {}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn cloud_skills_refresh_per_turn_and_invalidate_on_auth_change() -> Result<()> {+async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change() -> Result<()> {let server = responses::start_mock_server().await;let apps = AppsTestServer::mount(&server).await?;let calendar = ("calendar", 1);@@ -129,51 +129,82 @@ async fn cloud_skills_refresh_per_turn_and_invalidate_on_auth_change() -> Result});let test = builder.build_with_auto_env(&server).await?;let mut last_available_skill = calendar;- for (turn, next_reply, expected_skill, new_account, expected_reads) in [- ("discovered", Ok(Some(calendar)), Some(calendar), None, 1),+ for (turn, next_reply, expected_skill, new_account, expected_lists, expected_reads) in [+ ("discovered", Ok(Some(calendar)), Some(calendar), None, 1, 1),+ (+ "cached",+ Ok(Some(updated_calendar)),+ Some(calendar),+ None,+ 0,+ 0,+ ),("refreshed",Ok(Some(updated_calendar)),Some(updated_calendar),None,1,+ 1,),("same-account-failure",Err(()),Some(updated_calendar),None,+ 1,0,),- ("removed", Ok(None), None, None, 0),+ ("removed", Ok(None), None, None, 1, 0),+ ("empty-cached", Ok(Some(updated_calendar)), None, None, 0, 0),("restored",Ok(Some(updated_calendar)),Some(updated_calendar),None,1,+ 1,+ ),+ (+ "auth-changed-failure",+ Err(()),+ None,+ Some("account-b"),+ 1,+ 0,),- ("auth-changed-failure", Err(()), None, Some("account-b"), 0),("new-account-discovered",Ok(Some(gmail)),Some(gmail),None,1,+ 1,+ ),+ (+ "connection-replaced-failure",+ Err(()),+ Some(gmail),+ None,+ 1,+ 0,),- ("connection-replaced-failure", Err(()), Some(gmail), None, 0),("replacement-connection-discovered",Ok(Some(gmail)),Some(gmail),None,1,+ 1,),] {let previous_lists = provider.lists.load(Ordering::SeqCst);let previous_reads = provider.reads.load(Ordering::SeqCst);*provider.reply.lock().expect("cloud reply lock") = next_reply;- let previous_connection_scope = if turn == "connection-replaced-failure" {+ let previous_connection_scope = if matches!(+ turn,+ "refreshed" | "same-account-failure" | "restored" | "connection-replaced-failure"+ ) {let client = resources.0.lock()@@ -265,7 +296,7 @@ async fn cloud_skills_refresh_per_turn_and_invalidate_on_auth_change() -> Resultassert_eq!(requests.len(), 2, "turn {turn}");assert_eq!(provider.lists.load(Ordering::SeqCst),- previous_lists + 1,+ previous_lists + expected_lists,"turn {turn}");assert_eq!(diff --git a/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs b/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rsindex 86b29f1d7e..08d78329f1 100644--- a/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs+++ b/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs@@ -704,9 +704,9 @@ async fn cloud_skill_can_read_referenced_resource_without_an_executor() -> Resulresponses::ev_completed("resp-orchestrator-skill"),]),responses::sse(vec![- responses::ev_response_created("resp-orchestrator-skill-after-refresh"),- responses::ev_assistant_message("msg-orchestrator-skill-after-refresh", "Done"),- responses::ev_completed("resp-orchestrator-skill-after-refresh"),+ responses::ev_response_created("resp-orchestrator-skill-next-turn"),+ responses::ev_assistant_message("msg-orchestrator-skill-next-turn", "Done"),+ responses::ev_completed("resp-orchestrator-skill-next-turn"),]),],)@@ -812,8 +812,7 @@ async fn cloud_skill_can_read_referenced_resource_without_an_executor() -> Resulvec![SKILL_MAIN_PROMPT_URI, SKILL_REFERENCE_URI]);- test.codex.submit(Op::RefreshMcpServers).await?;- test.submit_turn(&format!("Use ${SKILL_NAME} after refreshing MCP"))+ test.submit_turn(&format!("Use ${SKILL_NAME} on the next turn")).await?;let requests = response_mock.requests();assert_eq!(requests.len(), 6);@@ -826,6 +825,7 @@ async fn cloud_skill_can_read_referenced_resource_without_an_executor() -> Resulassert!(skill_fragments[0].contains(&format!("<name>{SKILL_NAME}</name>")));assert!(skill_fragments[0].contains(SKILL_MARKER));assert!(skill_fragments[0].contains(SKILL_REFERENCE_URI));+ // Partial discovery retries on the next turn without an MCP or auth invalidation.assert_eq!(*provider.reads.lock().await,vec![diff --git a/codex-rs/ext/skills/src/cloud_skill.rs b/codex-rs/ext/skills/src/cloud_skill.rsindex 74e5bc61ad..6adbefbae2 100644--- a/codex-rs/ext/skills/src/cloud_skill.rs+++ b/codex-rs/ext/skills/src/cloud_skill.rs@@ -1,4 +1,5 @@-//! Attempts cloud discovery once during cancellable regular-turn startup.+//! Reuses warning-free cloud catalogs until their Apps resource generation changes.+//! Partial catalogs are retried during the next cancellable regular-turn startup.//! Snapshot readers never discover or retry. Failures may retain a same-auth-scope//! catalog; missing or invalidated catalogs remain empty until the next turn.diff --git a/codex-rs/ext/skills/src/skills_extension_state.rs b/codex-rs/ext/skills/src/skills_extension_state.rsindex c4d6831f1f..dac4388899 100644--- a/codex-rs/ext/skills/src/skills_extension_state.rs+++ b/codex-rs/ext/skills/src/skills_extension_state.rs@@ -7,6 +7,7 @@ use std::sync::Mutex;use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;use codex_mcp::McpResourceClient;use codex_mcp::McpResourceClientAuthKey;+use codex_mcp::McpResourceServerCacheKey;use codex_protocol::capabilities::SelectedCapabilityRoot;use crate::catalog::SkillAuthority;@@ -37,15 +38,23 @@ pub(crate) enum ExecutorCatalogSelection {}/// Keeps cloud metadata and contents within one published auth scope and Apps availability state.-/// A successful turn refresh replaces the Arc so late reads cannot populate its successor.+/// Warning-free discovery is reused until the Apps resource generation changes.+/// A successful refresh replaces the Arc so late reads cannot populate its successor.pub(crate) struct CloudSkillGeneration {pub(crate) auth_cache_key: Option<McpResourceClientAuthKey>,+ pub(crate) resource_cache_key: Option<McpResourceServerCacheKey>,pub(crate) mcp_resources: Option<McpResourceClient>,pub(crate) catalog: Option<SkillCatalog>,pub(crate) resources: Mutex<CloudResourceCache>,}impl CloudSkillGeneration {+ pub(crate) fn current_resource_cache_key(&self) -> Option<McpResourceServerCacheKey> {+ self.mcp_resources+ .as_ref()+ .and_then(|client| client.server_cache_key(codex_mcp::CODEX_APPS_MCP_SERVER_NAME))+ }+pub(crate) fn is_current(&self) -> bool {self.auth_cache_key== self.mcp_resources.as_ref().map(|client| {diff --git a/codex-rs/ext/skills/src/state.rs b/codex-rs/ext/skills/src/state.rsindex 32dc1a9447..e1997da589 100644--- a/codex-rs/ext/skills/src/state.rs+++ b/codex-rs/ext/skills/src/state.rs@@ -301,6 +301,7 @@ impl SkillsThreadState {let next_cache = Arc::new(CloudSkillGeneration {auth_cache_key: cache_key,+ resource_cache_key: None,mcp_resources: mcp_resources.cloned(),catalog: None,resources: Mutex::new(CloudResourceCache::default()),@@ -310,7 +311,7 @@ impl SkillsThreadState {}/// The serialized turn-start lifecycle is the only discovery writer.- /// Attempt once per turn; readers never retry, including after a failed refresh.+ /// Reuse warning-free discovery until invalidated; retry failures and partial catalogs next turn.#[tracing::instrument(name = "skills.cloud.refresh_cloud_catalog", level = "info", skip_all)]pub(crate) async fn refresh_cloud_catalog(&self,@@ -323,6 +324,16 @@ impl SkillsThreadState {// Switch generations before the fallible lookup; only same-auth-scope failures// may retain previously authorized metadata and contents.let cache = self.cloud_cache(query.mcp_resources.as_deref());+ let resource_cache_key = cache.current_resource_cache_key();+ if cache.is_current()+ && cache+ .catalog+ .as_ref()+ .is_some_and(|catalog| catalog.warnings.is_empty())+ && cache.resource_cache_key == resource_cache_key+ {+ return Ok(());+ }let mut catalog = providers.list_cloud_for_turn(query).await?;catalog.entries.sort_by(|a, b| a.id.0.cmp(&b.id.0));let mut catalogs = self@@ -330,6 +341,7 @@ impl SkillsThreadState {.lock().unwrap_or_else(std::sync::PoisonError::into_inner);if !cache.is_current()+ || cache.current_resource_cache_key() != resource_cache_key|| !catalogs.cloud_cache.as_ref()@@ -341,6 +353,7 @@ impl SkillsThreadState {}catalogs.cloud_cache = Some(Arc::new(CloudSkillGeneration {auth_cache_key: cache.auth_cache_key.clone(),+ resource_cache_key,mcp_resources: cache.mcp_resources.clone(),catalog: Some(catalog),resources: Mutex::new(CloudResourceCache::default()),