Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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() -> Result
assert_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.rs
index 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() -> Resul
responses::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() -> Resul
vec![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() -> Resul
assert!(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.rs
index 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.rs
index 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.rs
index 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()),