Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Refresh cloud plugin and skill catalogs after mid-turn auth changes (#55957)

Anthony Tafoya9e12b148918b
diff --git a/codex-rs/core/src/mcp.rs b/codex-rs/core/src/mcp.rs
index f2d4ea9f29..f4170cb011 100644
--- a/codex-rs/core/src/mcp.rs
+++ b/codex-rs/core/src/mcp.rs
@@ -214,18 +214,12 @@ impl McpManager {
plugins_config: &PluginsConfigToml,
disabled_plugin_ids: &[String],
) -> SelectedPluginSnapshot {
- let roots = context
- .ready_selected_capability_roots()
- .unwrap_or_default();
let mut selected = SelectedPluginSnapshot {
disabled_plugin_ids: disabled_plugin_ids.to_vec(),
..Default::default()
};
- let v2 = context.executor_capability_discovery_v2().is_some();
let available_roots = available_plugin_roots(context);
- if roots.is_empty() && !v2 {
- return selected;
- }
+ // Check hosted plugins even when no executor roots are selected.
for contributor in self.extensions.mcp_server_contributors() {
for SelectedPlugin {
selected_root_id,
diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rs
index 38a7fe82ae..95301d6bc3 100644
--- a/codex-rs/core/src/session/mcp.rs
+++ b/codex-rs/core/src/session/mcp.rs
@@ -425,6 +425,35 @@ impl Session {
self.mark_mcp_runtime_dirty();
}
self.refresh_mcp_if_dirty().await;
+ // Prewarm and other context-only captures must not start cloud discovery.
+ let is_active_regular_turn = {
+ let active_turn = self.active_turn.lock().await;
+ active_turn
+ .as_ref()
+ .and_then(|turn| turn.task.as_ref())
+ .is_some_and(|task| {
+ task.kind == TaskKind::Regular
+ && task.turn_context.sub_id == turn_context.sub_id
+ })
+ };
+ if is_active_regular_turn {
+ // Refresh cloud catalogs without holding the MCP permit or active-turn lock.
+ for contributor in self.services.extensions.turn_lifecycle_contributors() {
+ if contributor
+ .refresh_catalog_for_step(codex_extension_api::CatalogRefreshInput {
+ turn_id: &turn_context.sub_id,
+ session_store: &self.services.session_extension_data,
+ thread_store: &self.services.thread_extension_data,
+ turn_store: turn_context.extension_data.as_ref(),
+ })
+ .await
+ {
+ // Preserve MCP updates if a later refresh is cancelled.
+ self.mark_mcp_runtime_dirty();
+ }
+ }
+ self.refresh_mcp_if_dirty().await;
+ }
let required_servers = required_servers
.iter()
.chain(&recovered_oauth_servers)
diff --git a/codex-rs/core/src/session/turn_start_mcp_tests.rs b/codex-rs/core/src/session/turn_start_mcp_tests.rs
index c325d53026..46d6ec4144 100644
--- a/codex-rs/core/src/session/turn_start_mcp_tests.rs
+++ b/codex-rs/core/src/session/turn_start_mcp_tests.rs
@@ -1,4 +1,4 @@
-//! Turn-start MCP reconciliation and cooperative discovery cancellation regressions.
+//! Turn-start MCP reconciliation, discovery cancellation, and prewarm refresh boundaries.
use super::*;
use codex_mcp::McpResourceClient;
@@ -37,6 +37,13 @@ impl codex_extension_api::TurnLifecycleContributor for Recorder {
std::future::pending::<()>().await;
})
}
+
+ fn refresh_catalog_for_step<'a>(
+ &'a self,
+ _input: codex_extension_api::CatalogRefreshInput<'a>,
+ ) -> codex_extension_api::ExtensionFuture<'a, bool> {
+ panic!("prewarm must not start cloud discovery");
+ }
}
#[tokio::test]
@@ -48,12 +55,18 @@ async fn turn_start_refreshes_dirty_mcp_reuses_clean_runtime_and_cancels_discove
keys: Default::default(),
discovered: Default::default(),
});
- let initial_key = recorder.client.cache_key();
let mut builder = codex_extension_api::ExtensionRegistryBuilder::new();
builder.turn_lifecycle_contributor(recorder.clone());
session.services.extensions = Arc::new(builder.build());
let session = Arc::new(session);
let turn_context = Arc::new(turn_context);
+ let prewarm = session
+ .new_startup_prewarm_turn_with_sub_id(INITIAL_SUBMIT_ID.to_owned())
+ .await;
+ session
+ .mcp_runtime_for_step(&prewarm, &[], &[], &HashSet::new())
+ .await;
+ let initial_key = recorder.client.cache_key();
for turn in 0..4 {
recorder
@@ -97,6 +110,10 @@ async fn turn_start_refreshes_dirty_mcp_reuses_clean_runtime_and_cancels_discove
.unwrap_or_else(std::sync::PoisonError::into_inner)[turn],
"a clean refresh must reuse the published MCP runtime"
);
+ // Prewarm must also skip discovery while a regular turn is active.
+ session
+ .mcp_runtime_for_step(&prewarm, &[], &[], &HashSet::new())
+ .await;
}
let (cancellation_token, done) = {
let active_turn = session.active_turn.lock().await;
diff --git a/codex-rs/core/tests/suite/executor_discovery_v2.rs b/codex-rs/core/tests/suite/executor_discovery_v2.rs
index d3b619d46b..1791e41ba1 100644
--- a/codex-rs/core/tests/suite/executor_discovery_v2.rs
+++ b/codex-rs/core/tests/suite/executor_discovery_v2.rs
@@ -1,10 +1,17 @@
-//! Verifies V2 discovery gating, turn integration, and cache behavior.
+//! Verifies V2 discovery, plugin acceptance across auth changes, and cache behavior.
use anyhow::Context;
use anyhow::Result;
use codex_core::config::Config;
use codex_core::windows_sandbox::WindowsSandboxLevelExt;
+use codex_core_plugins::ExecutorPluginProvider;
+use codex_core_plugins::PluginCatalog;
+use codex_core_plugins::PluginCatalogEntry;
use codex_core_plugins::PluginIdentity;
+use codex_core_plugins::PluginListQuery;
+use codex_core_plugins::PluginProvider;
+use codex_core_plugins::PluginProviderFuture;
+use codex_core_plugins::PluginSourceLocation;
use codex_exec_server::DiscoverV2CapabilitiesResponse;
use codex_exec_server::ExecutorCapabilityDiscoveryV2Cache;
use codex_exec_server::ExecutorCapabilityDiscoveryV2Snapshot;
@@ -17,10 +24,33 @@ use codex_extension_api::McpServerContribution;
use codex_extension_api::McpServerContributionContext;
use codex_extension_api::McpServerContributor;
use codex_extension_api::SelectedPluginSnapshot;
+use codex_extension_api::ToolFinishInput;
+use codex_extension_api::ToolLifecycleContributor;
+use codex_extension_api::ToolLifecycleFuture;
use codex_extension_api::WorldStateContributionInput;
use codex_extension_api::WorldStateSectionContribution;
use codex_features::Feature;
+use codex_login::CodexAuth;
+use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
+use codex_mcp::McpResourceClient;
+use codex_mcp_extension::PluginProviders;
+use codex_mcp_extension::install_plugin_providers;
use codex_protocol::config_types::WindowsSandboxLevel;
+use codex_protocol::protocol::SKILLS_INSTRUCTIONS_OPEN_TAG;
+use codex_skills_extension::ExecutorSkillProvider;
+use codex_skills_extension::SkillProviders;
+use codex_skills_extension::SkillsExtensionConfig;
+use codex_skills_extension::catalog::SkillAuthority;
+use codex_skills_extension::catalog::SkillCatalog;
+use codex_skills_extension::catalog::SkillCatalogEntry;
+use codex_skills_extension::catalog::SkillPackageId;
+use codex_skills_extension::catalog::SkillResourceId;
+use codex_skills_extension::catalog::SkillSourceKind;
+use codex_skills_extension::install_with_providers;
+use core_test_support::apps_test_server::AppsTestServer;
+use core_test_support::apps_test_server::apps_enabled_builder;
+use core_test_support::context_snapshot;
+use core_test_support::context_snapshot::ContextSnapshotOptions;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
use core_test_support::test_codex::test_codex;
@@ -30,10 +60,14 @@ use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
+use std::time::Duration;
use tokio::net::TcpListener;
use tokio::sync::Mutex;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
use tokio_tungstenite::accept_async;
use tokio_tungstenite::tungstenite::Message;
use tokio_util::task::AbortOnDropHandle;
@@ -156,6 +190,7 @@ impl ContextContributor for DiscoveryRecorder {
struct Executor {
url: String,
+ inventory: Arc<Mutex<Option<Value>>>,
requests: Arc<Mutex<Vec<Value>>>,
_task: AbortOnDropHandle<Result<()>>,
}
@@ -172,6 +207,8 @@ impl Executor {
let listener = TcpListener::bind("127.0.0.1:0").await?;
let url = format!("ws://{}", listener.local_addr()?);
let requests = Arc::new(Mutex::new(Vec::new()));
+ let inventory = Arc::new(Mutex::new(None::<Value>));
+ let served_inventory = Arc::clone(&inventory);
let recorded = Arc::clone(&requests);
let discovery_attempts = Arc::new(AtomicUsize::new(0));
let http = codex_exec_server::Environment::create_for_tests(/*exec_server_url*/ None)?
@@ -180,6 +217,7 @@ impl Executor {
let mut connections = tokio::task::JoinSet::new();
while let Ok((stream, _)) = listener.accept().await {
let recorded = Arc::clone(&recorded);
+ let inventory = Arc::clone(&served_inventory);
let discovery_attempts = Arc::clone(&discovery_attempts);
let http = Arc::clone(&http);
connections.spawn(async move {
@@ -234,7 +272,7 @@ impl Executor {
"roots": request["params"]["roots"].as_array().context("V1 roots")?
.iter().map(|root| json!({"id":root["id"],"path":root["path"]})).collect::<Vec<_>>()
})),
- Some("capabilities/discoverV2") => Some(json!({
+ Some("capabilities/discoverV2") => Some(inventory.lock().await.clone().unwrap_or_else(|| json!({
"plugins":[{"id":"inert-sentinel@market","displayName":"inert-sentinel","remotePluginId":null,
"version":"1","root":"file:///inert-sentinel",
"files":{"manifest":{"path":"file:///inert-sentinel/.codex-plugin/plugin.json",
@@ -246,7 +284,7 @@ impl Executor {
"shortDescription":null,"path":"file:///inert-sentinel/SKILL.md",
"discoveryRoot":{"id":"codex-home-skills","path":"file:///"},"metadata":null}],
"warnings":[]
- })),
+ }))),
Some("fs/open") if request["params"]["path"] == "file:///inert-sentinel/SKILL.md" => Some(json!({"handleId": request["params"]["handleId"]})),
Some("fs/readBlock") => Some(json!(codex_exec_server::FsReadBlockResponse {
chunk: b"# Sentinel instructions from the captured executor".to_vec().into(),
@@ -270,6 +308,7 @@ impl Executor {
});
Ok(Self {
url,
+ inventory,
requests,
_task: AbortOnDropHandle::new(task),
})
@@ -936,3 +975,224 @@ async fn v2_discovery_cache_reuses_matching_requests_and_isolates_execution_cont
Ok(())
}
+
+struct Cloud {
+ available: AtomicBool,
+ ready: mpsc::UnboundedSender<(Arc<McpResourceClient>, oneshot::Sender<()>)>,
+}
+
+impl PluginProvider for Cloud {
+ fn list(&self, _query: PluginListQuery) -> PluginProviderFuture<'_, PluginCatalog> {
+ Box::pin(async move {
+ Ok(PluginCatalog {
+ entries: if !self.available.load(Ordering::SeqCst) {
+ Vec::new()
+ } else {
+ vec![PluginCatalogEntry {
+ id: PluginIdentity::Remote {
+ remote_plugin_id: "plugin_demo".into(),
+ },
+ enabled: true,
+ display_name: "Demo".into(),
+ version: "1".into(),
+ mcp_servers: Default::default(),
+ connector_ids: Vec::new(),
+ locations: vec![PluginSourceLocation::Cloud {
+ resource_uri: "plugin://plugin_demo".into(),
+ bundle_uri: None,
+ }],
+ }]
+ },
+ ..Default::default()
+ })
+ })
+ }
+}
+
+impl ToolLifecycleContributor for Cloud {
+ fn on_tool_finish<'a>(&'a self, input: ToolFinishInput<'a>) -> ToolLifecycleFuture<'a> {
+ Box::pin(async move {
+ let (resume, wait) = oneshot::channel();
+ let client = input
+ .session_store
+ .get::<McpResourceClient>()
+ .expect("MCP resource client should be installed");
+ self.ready.send((client, resume)).expect("step observer");
+ wait.await.expect("resume after auth rotation");
+ })
+ }
+}
+
+/// Auth refresh updates plugin acceptance before merging skills and capturing the next step.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn auth_rotation_refreshes_plugin_acceptance_before_merged_skills() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let executor = Executor::start(/*supports_v2*/ true, DiscoveryFailure::None).await?;
+ *executor.inventory.lock().await = Some(json!({
+ "plugins":[{"id":"inert-sentinel@market","displayName":"inert-sentinel","remotePluginId":"plugin_demo",
+ "version":"1","root":"file:///inert-sentinel",
+ "files":{"manifest":{"path":"file:///inert-sentinel/.codex-plugin/plugin.json",
+ "contents":"{\"name\":\"inert-sentinel\"}"},"mcpConfig":null,"appsConfig":null},
+ "skills":[{"name":"inert-sentinel","description":"Executor skill used by the acquisition test",
+ "shortDescription":null,"path":"file:///inert-sentinel/SKILL.md",
+ "discoveryRoot":{"id":"codex-home-skills","path":"file:///"},"metadata":null}]}],
+ "skills":[],"warnings":[]
+ }));
+ let server = responses::start_mock_server().await;
+ let apps = AppsTestServer::mount(&server).await?;
+ let (ready, mut steps) = mpsc::unbounded_channel();
+ let cloud = Arc::new(Cloud {
+ available: AtomicBool::new(true),
+ ready,
+ });
+ let mut extensions = ExtensionRegistryBuilder::new();
+ extensions.tool_lifecycle_contributor(cloud.clone());
+ let manager = Arc::new(codex_exec_server::EnvironmentManager::default_for_tests());
+ install_plugin_providers(
+ &mut extensions,
+ PluginProviders::new(Arc::new(ExecutorPluginProvider::new(manager.clone())))
+ .with_cloud_provider(cloud.clone()),
+ );
+ install_with_providers(
+ &mut extensions,
+ SkillProviders::new()
+ // Keep listing the skill after its owning plugin disappears.
+ .with_cloud_provider(Arc::new(super::skills_extension::CatalogSkillProvider {
+ catalog: SkillCatalog {
+ entries: vec![
+ SkillCatalogEntry::new(
+ SkillPackageId("skill://plugin_demo/demo".into()),
+ SkillAuthority::new(SkillSourceKind::Cloud, CODEX_APPS_MCP_SERVER_NAME),
+ "inert-sentinel",
+ "Accepted plugin skill",
+ SkillResourceId::new("skill://plugin_demo/demo/SKILL.md"),
+ )
+ .with_remote_plugin_id(Some("plugin_demo".into())),
+ ],
+ ..Default::default()
+ },
+ }))
+ .with_executor_provider(Arc::new(
+ ExecutorSkillProvider::new_with_restriction_product(
+ manager, /*restriction_product*/ None,
+ ),
+ )),
+ |_config: &Config| SkillsExtensionConfig {
+ include_instructions: true,
+ max_context_tokens: None,
+ bundled_skills_enabled: false,
+ cloud_skill_enabled: true,
+ shadow_selection_enabled: false,
+ },
+ );
+ // Rotate auth, revoke the owning plugin, then reuse the revoked state.
+ let cases = [
+ ("initial", true),
+ ("rotated", true),
+ ("removed", false),
+ ("removed", false),
+ ];
+ let model_responses = (0..cases.len())
+ .map(|step| {
+ let mut events = vec![responses::ev_response_created(&format!("response-{step}"))];
+ if step + 1 < cases.len() {
+ events.push(responses::ev_function_call_with_namespace(
+ &format!("read-{step}"),
+ "skills",
+ "read",
+ r#"{"package":"skill://inert-sentinel@market/inert-sentinel"}"#,
+ ));
+ }
+ events.push(responses::ev_completed(&format!("response-{step}")));
+ responses::sse(events)
+ })
+ .collect::<Vec<_>>();
+ let model = responses::mount_sse_sequence(&server, model_responses).await;
+ let test = apps_enabled_builder(apps.chatgpt_base_url)
+ .with_exec_server_url(executor.url.clone())
+ .with_auth(CodexAuth::from_external_chatgpt_tokens(
+ "header.e30.initial",
+ "account",
+ /*chatgpt_plan_type*/ None,
+ )?)
+ .with_extensions(Arc::new(extensions.build()))
+ .with_config(move |config| {
+ config.cloud_skill_enabled = true;
+ config.features.enable(Feature::Plugins).unwrap();
+ config
+ .features
+ .enable(Feature::ExecutorCapabilityDiscoveryV2)
+ .unwrap();
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ let rotate = async {
+ for (index, &(revision, available)) in cases.iter().enumerate().skip(1) {
+ let (client, resume) = tokio::time::timeout(Duration::from_secs(15), steps.recv())
+ .await?
+ .expect("tool completion");
+ cloud.available.store(available, Ordering::SeqCst);
+ let previous = client.auth_cache_key_for_server(CODEX_APPS_MCP_SERVER_NAME);
+ if revision != cases[index - 1].0 {
+ codex_login::auth::login_with_chatgpt_auth_tokens(
+ test.codex_home_path(),
+ &format!("header.e30.{revision}"),
+ "account",
+ /*chatgpt_plan_type*/ None,
+ )?;
+ test.thread_manager.auth_manager().reload().await;
+ tokio::time::timeout(Duration::from_secs(15), async {
+ while client.auth_cache_key_for_server(CODEX_APPS_MCP_SERVER_NAME) == previous {
+ tokio::task::yield_now().await;
+ }
+ })
+ .await?;
+ }
+ resume.send(()).expect("resume next model step");
+ }
+ anyhow::Ok(())
+ };
+ tokio::try_join!(
+ test.submit_turn("Inspect the accepted plugin skill."),
+ rotate
+ )?;
+ let requests = model.requests();
+ assert_eq!(requests.len(), cases.len());
+ for (request, (_, available)) in requests.iter().zip(cases) {
+ let instructions = request.message_input_texts("developer");
+ let skills = instructions
+ .iter()
+ .rfind(|text| text.starts_with(SKILLS_INSTRUCTIONS_OPEN_TAG))
+ .expect("latest skill instructions");
+ assert_eq!(skills.contains("Accepted plugin skill"), available);
+ }
+ let mut bodies = requests
+ .iter()
+ .map(responses::ResponsesRequest::body_json)
+ .collect::<Vec<_>>();
+ // Normalize JSON ordering for the request-history snapshot.
+ for body in &mut bodies {
+ for item in body["input"].as_array_mut().unwrap() {
+ if item["type"] == "function_call_output"
+ && let Ok(mut output) =
+ serde_json::from_str::<Value>(item["output"].as_str().unwrap())
+ {
+ output.sort_all_objects();
+ item["output"] = Value::String(output.to_string());
+ }
+ }
+ }
+ insta::assert_snapshot!(
+ "plugin_acceptance_auth_refresh",
+ context_snapshot::format_context_snapshot(
+ "Mid-turn auth refresh preserves skill context and executor access. Revoking the plugin removes cloud skill instructions and denies executor reads.",
+ &bodies
+ .iter()
+ .map(context_snapshot::SnapshotEntry::body)
+ .collect::<Vec<_>>(),
+ &ContextSnapshotOptions::default().rewrite_known_segments(),
+ )
+ );
+ Ok(())
+}
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 cac29b1af6..32642b6628 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 reuse, refresh, and auth-scoped retention through real Core turns.
+//! Cloud catalog reuse, refresh retries, and auth-scoped retention through real Core turns.
use super::*;
use codex_extension_api::ThreadLifecycleContributor;
@@ -91,6 +91,8 @@ impl ThreadLifecycleContributor<Config> for SessionResources {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change() -> Result<()> {
+ core_test_support::skip_if_no_network!(Ok(()));
+
let server = responses::start_mock_server().await;
let apps = AppsTestServer::mount(&server).await?;
let calendar = ("calendar", 1);
@@ -130,6 +132,7 @@ async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change()
});
let test = builder.build_with_auto_env(&server).await?;
let mut last_available_skill = calendar;
+ // Retry turn-start failures before each model step.
for (turn, next_reply, expected_skill, new_account, expected_lists, expected_reads) in [
("discovered", Ok(Some(calendar)), Some(calendar), None, 1, 1),
(
@@ -153,7 +156,7 @@ async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change()
Err(()),
Some(updated_calendar),
None,
- 1,
+ 3,
0,
),
("removed", Ok(None), None, None, 1, 0),
@@ -171,7 +174,7 @@ async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change()
Err(()),
None,
Some("account-b"),
- 1,
+ 3,
0,
),
(
@@ -187,7 +190,7 @@ async fn cloud_skills_reuse_cache_and_invalidate_on_connection_or_auth_change()
Err(()),
Some(gmail),
None,
- 1,
+ 3,
0,
),
(
diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__executor_discovery_v2__plugin_acceptance_auth_refresh.snap b/codex-rs/core/tests/suite/snapshots/all__suite__executor_discovery_v2__plugin_acceptance_auth_refresh.snap
new file mode 100644
index 0000000000..094d58a531
--- /dev/null
+++ b/codex-rs/core/tests/suite/snapshots/all__suite__executor_discovery_v2__plugin_acceptance_auth_refresh.snap
@@ -0,0 +1,30 @@
+---
+source: core/tests/suite/executor_discovery_v2.rs
+expression: "context_snapshot::format_context_snapshot(\"Mid-turn auth refresh preserves skill context and executor access. Revoking the plugin removes cloud skill instructions and denies executor reads.\",\n&bodies.iter().map(context_snapshot::SnapshotEntry::body).collect::<Vec<_>>(),\n&ContextSnapshotOptions::default().rewrite_known_segments(),)"
+---
+Scenario: Mid-turn auth refresh preserves skill context and executor access. Revoking the plugin removes cloud skill instructions and denies executor reads.
+
+## Window 1
+-- request 1 (request) --
+00:message/developer:
+ <MODEL_INSTRUCTIONS>
+01:message/developer[4]:
+ [01] <PERMISSIONS_INSTRUCTIONS>
+ [02] <APPS_INSTRUCTIONS>
+ [03] <PLUGINS_INSTRUCTIONS>
+ [04] <SKILLS_INSTRUCTIONS>
+02:message/user:
+ <ENVIRONMENT_CONTEXT>
+03:message/user:
+ Inspect the accepted plugin skill.
+-- request 2 (request) --
+04:function_call/skills.read:{"package":"skill://inert-sentinel@market/inert-sentinel"}
+05:function_call_output:{"contents":"# Sentinel instructions from the captured executor","installations":[{"environment_id":"rem...ill://inert-sentinel@market/inert-sentinel/SKILL.md"} [hash=4b2e6fc42721d90a]
+-- request 3 (request) --
+06:function_call/skills.read:{"package":"skill://inert-sentinel@market/inert-sentinel"}
+07:function_call_output:{"contents":"# Sentinel instructions from the captured executor","installations":[{"environment_id":"rem...ill://inert-sentinel@market/inert-sentinel/SKILL.md"} [hash=4b2e6fc42721d90a]
+08:message/developer:
+ <SKILLS_INSTRUCTIONS>
+-- request 4 (request) --
+09:function_call/skills.read:{"package":"skill://inert-sentinel@market/inert-sentinel"}
+10:function_call_output:skill package is not available
diff --git a/codex-rs/ext/extension-api/src/contributors.rs b/codex-rs/ext/extension-api/src/contributors.rs
index c2c3e60c34..dc95f991a4 100644
--- a/codex-rs/ext/extension-api/src/contributors.rs
+++ b/codex-rs/ext/extension-api/src/contributors.rs
@@ -61,6 +61,7 @@ pub use tool_lifecycle::ToolTimingBoundary;
pub use tool_lifecycle::ToolTimingInput;
pub use turn_input::TurnInputContext;
pub use turn_input::TurnInputEnvironment;
+pub use turn_lifecycle::CatalogRefreshInput;
pub use turn_lifecycle::TurnAbortInput;
pub use turn_lifecycle::TurnErrorInput;
pub use turn_lifecycle::TurnStartInput;
@@ -236,6 +237,14 @@ pub trait TurnLifecycleContributor: Send + Sync {
})
}
+ /// Refreshes catalogs before a step; returns true when MCP needs rebuilding.
+ fn refresh_catalog_for_step<'a>(
+ &'a self,
+ _input: CatalogRefreshInput<'a>,
+ ) -> ExtensionFuture<'a, bool> {
+ Box::pin(async { false })
+ }
+
/// Observes a completed item without changing it or delaying streamed deltas.
fn on_item_completed<'a>(
&'a self,
diff --git a/codex-rs/ext/extension-api/src/contributors/turn_lifecycle.rs b/codex-rs/ext/extension-api/src/contributors/turn_lifecycle.rs
index 7361c20c5f..c6c7571de5 100644
--- a/codex-rs/ext/extension-api/src/contributors/turn_lifecycle.rs
+++ b/codex-rs/ext/extension-api/src/contributors/turn_lifecycle.rs
@@ -33,6 +33,15 @@ pub struct TurnStartInput<'a> {
pub turn_store: &'a ExtensionData,
}
+/// Inputs for refreshing catalogs before a model step.
+#[derive(Clone, Copy)]
+pub struct CatalogRefreshInput<'a> {
+ pub turn_id: &'a str,
+ pub session_store: &'a ExtensionData,
+ pub thread_store: &'a ExtensionData,
+ pub turn_store: &'a ExtensionData,
+}
+
/// Input supplied when the host completes a turn.
pub struct TurnStopInput<'a> {
/// Store scoped to the host session runtime.
diff --git a/codex-rs/ext/extension-api/src/lib.rs b/codex-rs/ext/extension-api/src/lib.rs
index 41d85d6396..f66a2ee0db 100644
--- a/codex-rs/ext/extension-api/src/lib.rs
+++ b/codex-rs/ext/extension-api/src/lib.rs
@@ -52,6 +52,7 @@ pub use codex_tools::parse_tool_input_schema_without_compaction;
pub use contributors::ApprovalDecision;
pub use contributors::ApprovalDecisionInput;
pub use contributors::ApprovalReviewContributor;
+pub use contributors::CatalogRefreshInput;
pub use contributors::CodeModeCellTiming;
pub use contributors::CommandStartInput;
pub use contributors::ConfigContributor;
diff --git a/codex-rs/ext/mcp/src/cloud_plugin.rs b/codex-rs/ext/mcp/src/cloud_plugin.rs
index 0968ea1863..035ef367c2 100644
--- a/codex-rs/ext/mcp/src/cloud_plugin.rs
+++ b/codex-rs/ext/mcp/src/cloud_plugin.rs
@@ -1,4 +1,4 @@
-//! Refreshes the cloud catalog each regular turn and projects Apps-only plugin packages.
+//! Refreshes cloud plugins each turn and after auth changes.
use crate::PluginListQuery;
use crate::PluginsThreadState;
@@ -6,6 +6,7 @@ use crate::plugin_contributor::PluginContributor;
use codex_core::config::Config;
use codex_core_plugins::PluginCatalog;
use codex_core_plugins::PluginIdentity;
+use codex_extension_api::CatalogRefreshInput;
use codex_extension_api::ConfigContributor;
use codex_extension_api::ExtensionData;
use codex_extension_api::ExtensionFuture;
@@ -16,14 +17,102 @@ use codex_extension_api::TurnLifecycleContributor;
use codex_extension_api::TurnStartInput;
use codex_extension_api::TurnStartPhase;
use codex_features::Feature;
+use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
use codex_mcp::McpResourceClient;
+use codex_mcp::McpResourceClientAuthKey;
use std::collections::HashSet;
-use std::sync::Arc;
const MAX_PROJECTED_CLOUD_PLUGINS: usize = 100;
pub(crate) const MAX_PLUGIN_DISPLAY_NAME_CHARS: usize = 64;
pub(crate) const MAX_CONNECTOR_IDS_PER_PLUGIN: usize = 64;
+/// Auth scope of the latest catalog accepted for this turn.
+struct LatestCloudPluginAuth(Option<McpResourceClientAuthKey>);
+
+impl PluginContributor {
+ #[expect(
+ clippy::await_holding_invalid_type,
+ reason = "cloud discovery must remain serialized through fetching and catalog publication"
+ )]
+ async fn refresh_cloud_catalog(&self, input: CatalogRefreshInput<'_>) -> bool {
+ let Some(provider) = &self.providers.cloud else {
+ return false;
+ };
+ let Some(state) = input.thread_store.get::<PluginsThreadState>() else {
+ return false;
+ };
+ // Wait without holding catalog state or the MCP runtime permit, then recheck the cache.
+ let (mut refresh_succeeded, waited) = match state.cloud_refresh_lock.try_lock() {
+ Ok(guard) => (guard, false),
+ Err(_) => (state.cloud_refresh_lock.lock().await, true),
+ };
+ let query = PluginListQuery {
+ thread_id: input.thread_store.level_id().to_string(),
+ turn_id: input.turn_id.to_string(),
+ mcp_resources: input.session_store.get::<McpResourceClient>(),
+ snapshots: Vec::new(),
+ };
+ let (auth_cache_key, catalog_cleared) = {
+ let mut state = state.contributor_state();
+ if !state.plugins_enabled {
+ return false;
+ }
+ let auth = query
+ .mcp_resources
+ .as_ref()
+ .map(|client| client.auth_cache_key_for_server(CODEX_APPS_MCP_SERVER_NAME));
+ if ((waited && *refresh_succeeded)
+ || input
+ .turn_store
+ .get::<LatestCloudPluginAuth>()
+ .is_some_and(|previous| previous.0 == auth))
+ && state
+ .cloud_generation
+ .as_ref()
+ .is_some_and(|generation| generation.auth_cache_key == auth)
+ && state.cloud_catalog().is_some()
+ {
+ input.turn_store.insert(LatestCloudPluginAuth(auth));
+ return false;
+ }
+ // A failed or cancelled refresh must leave waiting callers able to retry.
+ *refresh_succeeded = false;
+ input.turn_store.remove::<LatestCloudPluginAuth>();
+ let previous_catalog_auth = state
+ .cloud_generation
+ .as_ref()
+ .filter(|generation| generation.catalog.is_some())
+ .map(|generation| generation.auth_cache_key.clone());
+ let auth_cache_key =
+ state.prepare_cloud_generation(query.mcp_resources.as_deref().cloned());
+ let catalog_cleared =
+ previous_catalog_auth.is_some_and(|previous| previous != auth_cache_key);
+ (auth_cache_key, catalog_cleared)
+ };
+ let result = provider.list(query).await;
+ let mut state = state.contributor_state();
+ let catalog_published = match result {
+ Ok(catalog) => {
+ let published = state.publish_cloud_catalog(auth_cache_key.as_ref(), catalog);
+ if published {
+ input
+ .turn_store
+ .insert(LatestCloudPluginAuth(auth_cache_key));
+ *refresh_succeeded = true;
+ } else {
+ tracing::debug!("cloud plugin discovery finished after auth changed");
+ }
+ published
+ }
+ Err(_) => {
+ tracing::warn!("cloud plugin discovery failed");
+ false
+ }
+ };
+ catalog_cleared || catalog_published
+ }
+}
+
impl ThreadLifecycleContributor<Config> for PluginContributor {
fn on_thread_start<'a>(
&'a self,
@@ -77,45 +166,23 @@ impl TurnLifecycleContributor for PluginContributor {
fn on_turn_start<'a>(&'a self, input: TurnStartInput<'a>) -> ExtensionFuture<'a, ()> {
Box::pin(async move {
- let Some(provider) = &self.providers.cloud else {
- return;
- };
- if !input
- .thread_store
- .get::<PluginsThreadState>()
- .is_some_and(|state| state.contributor_state().plugins_enabled)
- {
- return;
- }
- let resources = input
- .session_store
- .get::<McpResourceClient>()
- .map(|resources| resources.as_ref().clone());
- let state = input.thread_store.get_or_init(PluginsThreadState::default);
- // Change generations before the fallible lookup so only failures within the
- // same auth scope may retain a previously published catalog.
- let auth_cache_key = state
- .contributor_state()
- .prepare_cloud_generation(resources.clone());
- match provider
- .list(PluginListQuery {
- thread_id: input.thread_store.level_id().to_string(),
- turn_id: input.turn_id.to_string(),
- mcp_resources: resources.map(Arc::new),
- snapshots: Vec::new(),
- })
- .await
- {
- Ok(catalog) => {
- let mut state = state.contributor_state();
- if !state.publish_cloud_catalog(auth_cache_key.as_ref(), catalog) {
- tracing::warn!("cloud plugin discovery finished after auth changed");
- }
- }
- Err(_) => tracing::warn!("cloud plugin discovery failed"),
- }
+ input.turn_store.remove::<LatestCloudPluginAuth>();
+ self.refresh_cloud_catalog(CatalogRefreshInput {
+ turn_id: input.turn_id,
+ session_store: input.session_store,
+ thread_store: input.thread_store,
+ turn_store: input.turn_store,
+ })
+ .await;
})
}
+
+ fn refresh_catalog_for_step<'a>(
+ &'a self,
+ input: CatalogRefreshInput<'a>,
+ ) -> ExtensionFuture<'a, bool> {
+ Box::pin(self.refresh_cloud_catalog(input))
+ }
}
/// Cloud packages contribute Apps attribution, never executor MCP declarations.
diff --git a/codex-rs/ext/mcp/src/cloud_plugin_tests.rs b/codex-rs/ext/mcp/src/cloud_plugin_tests.rs
index 85496cf0bd..4c592b248a 100644
--- a/codex-rs/ext/mcp/src/cloud_plugin_tests.rs
+++ b/codex-rs/ext/mcp/src/cloud_plugin_tests.rs
@@ -1,4 +1,4 @@
-//! Tests cloud plugin lifecycle, tool calls, scheduling, and plugin policy.
+//! Tests per-turn cloud plugin discovery, auth recovery, tool calls, and plugin policy.
use super::*;
use crate::PluginProvider;
@@ -245,6 +245,100 @@ async fn account_change_clears_hosted_plugins_before_waiting_for_executor() -> a
Ok(())
}
+#[tokio::test]
+async fn cloud_refresh_serializes_waiters_and_retries() {
+ let new_catalog = PluginCatalog::default();
+ for (reply, cancelled) in [
+ (Ok(cloud_catalog()), false),
+ (Err("discovery failed".to_string()), false),
+ (Ok(cloud_catalog()), true),
+ ] {
+ let succeeded = reply.is_ok() && !cancelled;
+ let expected_catalog = if succeeded {
+ cloud_catalog()
+ } else {
+ new_catalog.clone()
+ };
+ let provider = Arc::new(CloudProvider::default());
+ provider.set_reply(reply);
+ let contributor = PluginContributor {
+ providers: PluginProviders::new(Arc::new(ExecutorPluginProvider::new(Arc::new(
+ EnvironmentManager::default_for_tests(),
+ ))))
+ .with_cloud_provider(provider.clone()),
+ };
+ let session = ExtensionData::new("session");
+ let thread = ExtensionData::new("thread");
+ let turn = ExtensionData::new("turn");
+ let prewarm_turn = ExtensionData::new("prewarm");
+ let input = CatalogRefreshInput {
+ turn_id: "turn",
+ session_store: &session,
+ thread_store: &thread,
+ turn_store: &turn,
+ };
+ let state = thread.get_or_init(PluginsThreadState::default);
+ state.contributor_state().plugins_enabled = true;
+
+ // A delayed prewarm waits without superseding the real turn's request.
+ provider.pause_discovery.store(true, Ordering::SeqCst);
+ let mut turn_start = contributor.refresh_catalog_for_step(input);
+ assert!(futures::poll!(&mut turn_start).is_pending());
+ let prewarm_input = CatalogRefreshInput {
+ turn_id: "prewarm",
+ turn_store: &prewarm_turn,
+ ..input
+ };
+ let mut prewarm = contributor.refresh_catalog_for_step(prewarm_input);
+ assert!(futures::poll!(&mut prewarm).is_pending());
+ let mut cancelled_waiter = contributor.refresh_catalog_for_step(prewarm_input);
+ assert!(futures::poll!(&mut cancelled_waiter).is_pending());
+ drop(cancelled_waiter);
+ assert_eq!(provider.calls.load(Ordering::SeqCst), 1);
+
+ provider.set_reply(Ok(new_catalog.clone()));
+ if cancelled {
+ drop(turn_start);
+ } else {
+ provider.resume_discovery.notify_one();
+ assert_eq!(turn_start.await, succeeded);
+ }
+ // Reuse a successful refresh; failure/cancellation releases the gate for retry.
+ assert_eq!(
+ tokio::time::timeout(Duration::from_secs(5), prewarm)
+ .await
+ .expect("waiting discovery should complete after its predecessor stops"),
+ !succeeded,
+ );
+ assert_eq!(state.cloud_catalog(), Some(expected_catalog.clone()));
+ assert!(!contributor.refresh_catalog_for_step(prewarm_input).await);
+ assert_eq!(
+ provider.calls.load(Ordering::SeqCst),
+ 1 + usize::from(!succeeded),
+ );
+
+ // Retained catalogs do not need MCP rebuilding after failed retries.
+ prewarm_turn.remove::<LatestCloudPluginAuth>();
+ provider.set_reply(Err("discovery failed".to_string()));
+ let previous_calls = provider.calls.load(Ordering::SeqCst);
+ for _ in 0..2 {
+ assert!(!contributor.refresh_catalog_for_step(prewarm_input).await);
+ assert_eq!(state.cloud_catalog(), Some(expected_catalog.clone()));
+ }
+ assert_eq!(provider.calls.load(Ordering::SeqCst), previous_calls + 2);
+
+ // Clearing an old auth scope still requires rebuilding, even on failure.
+ session.insert(McpResourceClient::new(Arc::new(
+ codex_mcp::McpRuntime::empty(/*prefix_mcp_tool_names*/ false),
+ )));
+ assert!(contributor.refresh_catalog_for_step(prewarm_input).await);
+ assert_eq!(state.cloud_catalog(), None);
+ assert!(!contributor.refresh_catalog_for_step(prewarm_input).await);
+ provider.set_reply(Ok(new_catalog.clone()));
+ assert!(contributor.refresh_catalog_for_step(prewarm_input).await);
+ }
+}
+
struct CloudProvider {
reply: Mutex<Result<PluginCatalog, String>>,
calls: AtomicUsize,
@@ -380,6 +474,8 @@ fn cloud_catalog_refreshes_per_turn_and_invalidates_on_auth_change() -> anyhow::
}
async fn run_cloud_catalog_refresh_lifecycle() -> anyhow::Result<()> {
+ core_test_support::skip_if_no_network!(Ok(()));
+
let server = responses::start_mock_server().await;
// Each account has a fixed inventory; only the auth switch changes the server's tools.
let apps_tools = Arc::new(Mutex::new(vec![app_tool("calendar", "list_events")]));
@@ -564,6 +660,7 @@ async fn run_cloud_catalog_refresh_lifecycle() -> anyhow::Result<()> {
),
] {
let previous_discoveries = provider.calls.load(Ordering::SeqCst);
+ let retry_discovery = reply.is_err() || turn == "in-flight-auth-change";
if let Some(account) = new_account {
// Do not manually refresh MCP: the auth transition must pick up this new inventory.
*apps_tools
@@ -651,19 +748,21 @@ async fn run_cloud_catalog_refresh_lifecycle() -> anyhow::Result<()> {
/*chatgpt_plan_type*/ None,
)?;
test.thread_manager.auth_manager().reload().await;
+ // Auth must be published while cloud discovery remains paused.
while resources
.auth_cache_key_for_server(codex_mcp::CODEX_APPS_MCP_SERVER_NAME)
== previous_auth
{
tokio::task::yield_now().await;
}
+ provider.set_reply(Err("new-scope discovery failed".to_string()));
provider.resume_discovery.notify_one();
anyhow::Ok(())
}
)
})
.await??;
- // The old request must not republish its catalog after credentials change.
+ // Refresh under the new auth without retaining the old catalog.
let state = test
.codex
.thread_extension_data()
@@ -740,7 +839,7 @@ async fn run_cloud_catalog_refresh_lifecycle() -> anyhow::Result<()> {
);
assert_eq!(
provider.calls.load(Ordering::SeqCst),
- previous_discoveries + 1,
+ previous_discoveries + 1 + if retry_discovery { requests.len() } else { 0 },
"turn {turn}"
);
}
diff --git a/codex-rs/ext/mcp/src/plugin_contributor_state.rs b/codex-rs/ext/mcp/src/plugin_contributor_state.rs
index f6badc308e..83d2e059c7 100644
--- a/codex-rs/ext/mcp/src/plugin_contributor_state.rs
+++ b/codex-rs/ext/mcp/src/plugin_contributor_state.rs
@@ -13,10 +13,13 @@ use codex_protocol::capabilities::SelectedCapabilityRoot;
use std::collections::HashMap;
use std::sync::Mutex;
use std::sync::MutexGuard;
+use tokio::sync::Mutex as AsyncMutex;
/// Plugin configuration and caches owned by one thread; mutable state stays extension-private.
#[derive(Default)]
pub struct PluginsThreadState {
+ /// Serializes discovery; true only when the last refresh published successfully.
+ pub(crate) cloud_refresh_lock: AsyncMutex<bool>,
state: Mutex<PluginContributorState>,
}
diff --git a/codex-rs/ext/mcp/tests/plugin_mcp.rs b/codex-rs/ext/mcp/tests/plugin_mcp.rs
index c399199717..138eca6123 100644
--- a/codex-rs/ext/mcp/tests/plugin_mcp.rs
+++ b/codex-rs/ext/mcp/tests/plugin_mcp.rs
@@ -910,7 +910,14 @@ async fn run_cloud_plugin_projection_scenarios() -> anyhow::Result<()> {
);
assert_eq!(
cloud.calls.load(Ordering::SeqCst),
- usize::from(cloud_enabled),
+ if !cloud_enabled {
+ 0
+ } else if cloud_available {
+ 1
+ } else {
+ // Failed turn-start discovery retries before each model step.
+ 1 + requests.len()
+ },
"{case}"
);
let state = test
diff --git a/codex-rs/ext/skills/src/catalog_state.rs b/codex-rs/ext/skills/src/catalog_state.rs
index b5458fe562..9f8487e40a 100644
--- a/codex-rs/ext/skills/src/catalog_state.rs
+++ b/codex-rs/ext/skills/src/catalog_state.rs
@@ -1,5 +1,6 @@
//! Reusable provider catalog caches and Cloud resource contents.
//! Provider catalogs remain unfiltered until step preparation applies policy.
+//! Cloud discovery publishes only into its current auth and resource generation.
use std::collections::HashMap;
use std::sync::Arc;
diff --git a/codex-rs/ext/skills/src/cloud_cache_tests.rs b/codex-rs/ext/skills/src/cloud_cache_tests.rs
index 780c0392c9..a85ed10aab 100644
--- a/codex-rs/ext/skills/src/cloud_cache_tests.rs
+++ b/codex-rs/ext/skills/src/cloud_cache_tests.rs
@@ -1,4 +1,4 @@
-//! Regression tests for cloud cache generation isolation and late completion.
+//! Tests cloud cache isolation, refresh retries, and late completion.
use super::*;
use crate::catalog::SkillCatalogEntry;
@@ -8,7 +8,13 @@ use crate::provider::SkillProvider;
use crate::provider::SkillProviderFuture;
use crate::provider::SkillReadContext;
use crate::provider::SkillSearchRequest;
+use codex_extension_api::CatalogRefreshInput;
+use codex_extension_api::ExtensionData;
+use codex_extension_api::ExtensionEventSink;
+use codex_extension_api::ExtensionRegistryBuilder;
+use codex_extension_api::ExtensionWarning;
use codex_mcp::McpRuntime;
+use codex_protocol::protocol::Event;
use pretty_assertions::assert_eq;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::AtomicUsize;
@@ -18,6 +24,8 @@ use tokio::sync::Notify;
#[derive(Default)]
struct Provider {
reads: AtomicUsize,
+ lists: AtomicUsize,
+ fail_list: AtomicBool,
partial_list: AtomicBool,
next_catalog: Mutex<Option<SkillCatalog>>,
pause_read: AtomicBool,
@@ -29,16 +37,21 @@ struct Provider {
impl SkillProvider for Provider {
fn list(&self, _query: SkillListQuery) -> SkillProviderFuture<'_, SkillCatalog> {
Box::pin(async move {
+ self.lists.fetch_add(1, Ordering::SeqCst);
+ let fail = self.fail_list.swap(false, Ordering::SeqCst);
+ let catalog = self
+ .next_catalog
+ .lock()
+ .expect("test provider catalog mutex should not be poisoned")
+ .take();
if self.pause_list.swap(false, Ordering::SeqCst) {
self.entered.notify_one();
self.resume.notified().await;
}
- if let Some(catalog) = self
- .next_catalog
- .lock()
- .expect("test provider catalog mutex should not be poisoned")
- .take()
- {
+ if fail {
+ return Err(SkillProviderError::new("discovery failed"));
+ }
+ if let Some(catalog) = catalog {
return Ok(catalog);
}
let is_partial = self.partial_list.swap(false, Ordering::SeqCst);
@@ -135,10 +148,18 @@ async fn frozen_cloud_catalog_and_reads_ignore_live_mcp_changes() {
)
.expect("frozen cloud skill fixture should be valid");
let providers = SkillProviders::new().with_cloud_provider(Arc::new(provider));
+ let turn_store = ExtensionData::new("turn");
state
- .refresh_cloud_catalog(&providers, query(Some(client())))
+ .refresh_cloud_catalog(&providers, query(Some(client())), &turn_store)
.await
.expect("cloud catalog refresh should succeed");
+ assert!(
+ turn_store
+ .get::<LatestCloudSkillsAuth>()
+ .expect("successful discovery should record its auth scope")
+ .0
+ .is_none()
+ );
let catalog = state
.available_cloud_catalog()
.expect("cloud catalog should be available after refresh");
@@ -166,7 +187,7 @@ async fn frozen_cloud_catalog_and_reads_ignore_live_mcp_changes() {
}
);
state
- .refresh_cloud_catalog(&providers, query(mcp_resources))
+ .refresh_cloud_catalog(&providers, query(mcp_resources), &turn_store)
.await
.expect("cloud catalog refresh should succeed");
assert_eq!(state.available_cloud_catalog(), Some(catalog.clone()));
@@ -183,6 +204,150 @@ async fn frozen_cloud_catalog_and_reads_ignore_live_mcp_changes() {
}
}
+#[tokio::test]
+async fn step_cloud_refresh_serializes_waiters_and_retries() {
+ #[derive(Default)]
+ struct WarningCounter(AtomicUsize);
+
+ impl ExtensionEventSink for WarningCounter {
+ fn emit(&self, _event: Event) {}
+
+ fn emit_warning(&self, _warning: ExtensionWarning) {
+ self.0.fetch_add(1, Ordering::SeqCst);
+ }
+ }
+
+ let cloud = Arc::new(Provider::default());
+ let providers = SkillProviders::new().with_cloud_provider(cloud.clone());
+ let session_store = ExtensionData::new("session");
+ let thread_store = ExtensionData::new("thread");
+ thread_store.insert(state());
+ let thread_state = thread_store
+ .get::<SkillsThreadState>()
+ .expect("skills thread state should be initialized");
+ let turn_store = ExtensionData::new("turn");
+ let config = thread_state.config();
+ let warnings = Arc::new(WarningCounter::default());
+ let mut builder = ExtensionRegistryBuilder::with_event_sink(warnings.clone());
+ crate::install_with_providers(&mut builder, providers, move |_: &()| config.clone());
+ let registry = builder.build();
+ let contributor = registry
+ .turn_lifecycle_contributors()
+ .iter()
+ .find(|contributor| contributor.requires_mcp_runtime(&thread_store))
+ .expect("cloud skills contributor should be registered");
+ let refresh_input = CatalogRefreshInput {
+ turn_id: "turn",
+ session_store: &session_store,
+ thread_store: &thread_store,
+ turn_store: &turn_store,
+ };
+
+ // Retry every failure, but warn only once during the turn.
+ for expected_calls in 1..=3 {
+ cloud.fail_list.store(true, Ordering::SeqCst);
+ assert!(!contributor.refresh_catalog_for_step(refresh_input).await);
+ assert_eq!(thread_state.available_cloud_catalog(), None);
+ assert_eq!(cloud.lists.load(Ordering::SeqCst), expected_calls);
+ assert_eq!(warnings.0.load(Ordering::SeqCst), 1);
+ }
+ cloud.pause_list.store(true, Ordering::SeqCst);
+ let mut cancelled = contributor.refresh_catalog_for_step(refresh_input);
+ assert!(futures::poll!(&mut cancelled).is_pending());
+ drop(cancelled);
+ *cloud
+ .next_catalog
+ .lock()
+ .expect("test provider catalog mutex should not be poisoned") =
+ Some(SkillCatalog::default());
+ assert!(!contributor.refresh_catalog_for_step(refresh_input).await);
+ assert!(!contributor.refresh_catalog_for_step(refresh_input).await);
+ assert_eq!(cloud.lists.load(Ordering::SeqCst), 5);
+
+ // Waiting callers reuse success, but retry a failed or cancelled discovery.
+ for (fails, cancelled) in [(false, false), (true, false), (false, true)] {
+ session_store.insert(SkillsSessionState {
+ mcp_resources: Some(client()),
+ extension_metrics: None,
+ });
+ let previous_calls = cloud.lists.load(Ordering::SeqCst);
+ let prewarm_store = ExtensionData::new("prewarm");
+ let first_catalog = SkillCatalog {
+ warnings: vec!["catalog warning".into()],
+ ..Default::default()
+ };
+ *cloud
+ .next_catalog
+ .lock()
+ .expect("test provider catalog mutex should not be poisoned") =
+ Some(first_catalog.clone());
+ cloud.fail_list.store(fails, Ordering::SeqCst);
+ cloud.pause_list.store(true, Ordering::SeqCst);
+ let mut turn_start = contributor.refresh_catalog_for_step(refresh_input);
+ assert!(futures::poll!(&mut turn_start).is_pending());
+ let prewarm_input = CatalogRefreshInput {
+ turn_id: "prewarm",
+ turn_store: &prewarm_store,
+ ..refresh_input
+ };
+ let mut prewarm = contributor.refresh_catalog_for_step(prewarm_input);
+ assert!(futures::poll!(&mut prewarm).is_pending());
+ let mut cancelled_waiter = contributor.refresh_catalog_for_step(prewarm_input);
+ assert!(futures::poll!(&mut cancelled_waiter).is_pending());
+ drop(cancelled_waiter);
+ assert_eq!(cloud.lists.load(Ordering::SeqCst), previous_calls + 1);
+ *cloud
+ .next_catalog
+ .lock()
+ .expect("test provider catalog mutex should not be poisoned") =
+ Some(SkillCatalog::default());
+ if cancelled {
+ drop(turn_start);
+ } else {
+ cloud.resume.notify_one();
+ assert!(!turn_start.await);
+ }
+ assert!(
+ !tokio::time::timeout(std::time::Duration::from_secs(5), prewarm)
+ .await
+ .expect("waiting discovery should complete after its predecessor stops")
+ );
+ assert_eq!(
+ thread_state.available_cloud_catalog(),
+ Some(if fails || cancelled {
+ SkillCatalog::default()
+ } else {
+ first_catalog
+ })
+ );
+ assert!(!contributor.refresh_catalog_for_step(prewarm_input).await);
+ assert!(!contributor.refresh_catalog_for_step(refresh_input).await);
+ assert_eq!(
+ cloud.lists.load(Ordering::SeqCst),
+ previous_calls + 1 + usize::from(fails || cancelled)
+ );
+ assert_eq!(warnings.0.load(Ordering::SeqCst), 1);
+ }
+
+ // A fresh turn may warn again while discovery remains unavailable.
+ session_store.insert(SkillsSessionState {
+ mcp_resources: Some(client()),
+ extension_metrics: None,
+ });
+ cloud.fail_list.store(true, Ordering::SeqCst);
+ let next_turn = ExtensionData::new("next turn");
+ assert!(
+ !contributor
+ .refresh_catalog_for_step(CatalogRefreshInput {
+ turn_id: "next turn",
+ turn_store: &next_turn,
+ ..refresh_input
+ })
+ .await
+ );
+ assert_eq!(warnings.0.load(Ordering::SeqCst), 2);
+}
+
#[tokio::test]
async fn late_read_cannot_return_or_populate_a_replaced_cache() {
for replacement in [Some(client()), None] {
@@ -196,7 +361,11 @@ async fn late_read_cannot_return_or_populate_a_replaced_cache() {
let (late, ()) = tokio::join!(state.read_skill(&providers, request(original)), async {
provider.entered.notified().await;
state
- .refresh_cloud_catalog(&providers, query(replacement.clone()))
+ .refresh_cloud_catalog(
+ &providers,
+ query(replacement.clone()),
+ &ExtensionData::new("turn"),
+ )
.await
.expect("cloud catalog refresh should succeed");
provider.resume.notify_one();
@@ -219,8 +388,9 @@ async fn late_discovery_cannot_publish_into_a_new_generation() {
let provider = Arc::new(Provider::default());
let providers = SkillProviders::new().with_cloud_provider(provider.clone());
provider.pause_list.store(true, Ordering::SeqCst);
+ let turn_store = ExtensionData::new("turn");
let (late, ()) = tokio::join!(
- state.refresh_cloud_catalog(&providers, query(Some(client()))),
+ state.refresh_cloud_catalog(&providers, query(Some(client())), &turn_store),
async {
provider.entered.notified().await;
state
@@ -231,7 +401,8 @@ async fn late_discovery_cannot_publish_into_a_new_generation() {
provider.resume.notify_one();
}
);
- assert!(late.is_err());
+ late.expect("superseded discovery should be discarded without an error");
+ assert!(turn_store.get::<LatestCloudSkillsAuth>().is_none());
assert!(
state
.catalog_state
@@ -250,12 +421,19 @@ async fn partial_cloud_catalog_without_warnings_is_refreshed_next_turn() {
let state = state();
let provider = Arc::new(Provider::default());
provider.partial_list.store(true, Ordering::SeqCst);
- let providers = SkillProviders::new().with_cloud_provider(provider);
+ let providers = SkillProviders::new().with_cloud_provider(provider.clone());
let client = Some(client());
+ let turn_store = ExtensionData::new("turn");
state
- .refresh_cloud_catalog(&providers, query(client.clone()))
+ .refresh_cloud_catalog(&providers, query(client.clone()), &turn_store)
.await
.expect("cloud catalog refresh should succeed");
+ // Reuse partial catalogs for the rest of the turn.
+ state
+ .refresh_cloud_catalog(&providers, query(client.clone()), &turn_store)
+ .await
+ .expect("cloud catalog refresh should succeed");
+ assert_eq!(provider.lists.load(Ordering::SeqCst), 1);
assert_eq!(
state
.available_cloud_catalog()
@@ -266,7 +444,11 @@ async fn partial_cloud_catalog_without_warnings_is_refreshed_next_turn() {
}
);
state
- .refresh_cloud_catalog(&providers, query(client))
+ .refresh_cloud_catalog(
+ &providers,
+ query(client.clone()),
+ &ExtensionData::new("next turn"),
+ )
.await
.expect("cloud catalog refresh should succeed");
assert_eq!(
@@ -279,6 +461,22 @@ async fn partial_cloud_catalog_without_warnings_is_refreshed_next_turn() {
..Default::default()
}
);
+ // Retry failures even when the previous catalog remains available.
+ let retry_turn = ExtensionData::new("retry turn");
+ provider.fail_list.store(true, Ordering::SeqCst);
+ assert!(
+ state
+ .refresh_cloud_catalog(&providers, query(client.clone()), &retry_turn)
+ .await
+ .is_err()
+ );
+ assert!(state.available_cloud_catalog().is_some());
+ assert!(retry_turn.get::<LatestCloudSkillsAuth>().is_none());
+ state
+ .refresh_cloud_catalog(&providers, query(client), &retry_turn)
+ .await
+ .expect("cloud catalog refresh should succeed");
+ assert_eq!(provider.lists.load(Ordering::SeqCst), 4);
}
#[tokio::test]
@@ -309,7 +507,11 @@ async fn cloud_refresh_preserves_complete_catalogs_only_within_the_same_auth_sco
.expect("test provider catalog mutex should not be poisoned") =
Some(previous.clone());
state
- .refresh_cloud_catalog(&providers, query(Some(original_client.clone())))
+ .refresh_cloud_catalog(
+ &providers,
+ query(Some(original_client.clone())),
+ &ExtensionData::new("turn"),
+ )
.await
.expect("cloud catalog refresh should succeed");
let generation = state
@@ -336,7 +538,11 @@ async fn cloud_refresh_preserves_complete_catalogs_only_within_the_same_auth_sco
original_client
};
state
- .refresh_cloud_catalog(&providers, query(Some(current_client.clone())))
+ .refresh_cloud_catalog(
+ &providers,
+ query(Some(current_client.clone())),
+ &ExtensionData::new("next turn"),
+ )
.await
.expect("cloud catalog refresh should succeed");
let retained = !changed_auth && !previous_partial && incoming_partial;
diff --git a/codex-rs/ext/skills/src/cloud_skill.rs b/codex-rs/ext/skills/src/cloud_skill.rs
index 5bdcfe74d1..06fd23db45 100644
--- a/codex-rs/ext/skills/src/cloud_skill.rs
+++ b/codex-rs/ext/skills/src/cloud_skill.rs
@@ -1,8 +1,6 @@
-//! 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.
+//! Refreshes cloud skills at turn start and after auth changes.
+use codex_extension_api::CatalogRefreshInput;
use codex_extension_api::ExtensionData;
use codex_extension_api::ExtensionFuture;
use codex_extension_api::TurnLifecycleContributor;
@@ -11,9 +9,55 @@ use codex_extension_api::TurnStartPhase;
use super::SkillsExtension;
use crate::provider::SkillListQuery;
+use crate::state::LatestCloudSkillsAuth;
use crate::state::SkillsSessionState;
use crate::state::SkillsThreadState;
+struct CloudDiscoveryWarningEmitted;
+
+impl<C: Send + Sync + 'static> SkillsExtension<C> {
+ async fn refresh_cloud_catalog(&self, input: CatalogRefreshInput<'_>) {
+ let Some(state) = input.thread_store.get::<SkillsThreadState>() else {
+ return;
+ };
+ if !state.cloud_skill_enabled() {
+ return;
+ }
+ let config = state.config();
+ let query = SkillListQuery {
+ turn_id: input.turn_id.to_string(),
+ executor_roots: Vec::new(),
+ resolved_executor_roots: Vec::new(),
+ host_snapshot: None,
+ include_host_skills: false,
+ include_bundled_skills: config.bundled_skills_enabled,
+ include_cloud_skills: true,
+ mcp_resources: input
+ .session_store
+ .get::<SkillsSessionState>()
+ .and_then(|state| state.mcp_resources.clone()),
+ executor_capability_discovery: None,
+ executor_capability_discovery_v2: None,
+ };
+ if let Err(error) = state
+ .refresh_cloud_catalog(&self.providers, query, input.turn_store)
+ .await
+ && input
+ .turn_store
+ .insert(CloudDiscoveryWarningEmitted)
+ .is_none()
+ {
+ self.emit_warning(
+ input.thread_store.level_id(),
+ Some(input.turn_id),
+ format!(
+ "Cloud skill discovery failed; retaining any catalog from the same cloud auth scope: {error}"
+ ),
+ );
+ }
+ }
+}
+
impl<C: Send + Sync + 'static> TurnLifecycleContributor for SkillsExtension<C> {
fn turn_start_phase(&self, thread_store: &ExtensionData) -> TurnStartPhase {
if thread_store
@@ -32,37 +76,24 @@ impl<C: Send + Sync + 'static> TurnLifecycleContributor for SkillsExtension<C> {
fn on_turn_start<'a>(&'a self, input: TurnStartInput<'a>) -> ExtensionFuture<'a, ()> {
Box::pin(async move {
- let Some(state) = input.thread_store.get::<SkillsThreadState>() else {
- return;
- };
- if !state.cloud_skill_enabled() {
- return;
- }
- let config = state.config();
- let query = SkillListQuery {
- turn_id: input.turn_id.to_string(),
- executor_roots: Vec::new(),
- resolved_executor_roots: Vec::new(),
- host_snapshot: None,
- include_host_skills: false,
- include_bundled_skills: config.bundled_skills_enabled,
- include_cloud_skills: true,
- mcp_resources: input
- .session_store
- .get::<SkillsSessionState>()
- .and_then(|state| state.mcp_resources.clone()),
- executor_capability_discovery: None,
- executor_capability_discovery_v2: None,
- };
- if let Err(error) = state.refresh_cloud_catalog(&self.providers, query).await {
- self.emit_warning(
- input.thread_store.level_id(),
- Some(input.turn_id),
- format!(
- "Cloud skill discovery failed; retaining any catalog from the same cloud auth scope: {error}"
- ),
- );
- }
+ input.turn_store.remove::<LatestCloudSkillsAuth>();
+ self.refresh_cloud_catalog(CatalogRefreshInput {
+ turn_id: input.turn_id,
+ session_store: input.session_store,
+ thread_store: input.thread_store,
+ turn_store: input.turn_store,
+ })
+ .await;
+ })
+ }
+
+ fn refresh_catalog_for_step<'a>(
+ &'a self,
+ input: CatalogRefreshInput<'a>,
+ ) -> ExtensionFuture<'a, bool> {
+ Box::pin(async move {
+ self.refresh_cloud_catalog(input).await;
+ false
})
}
}
diff --git a/codex-rs/ext/skills/src/state.rs b/codex-rs/ext/skills/src/state.rs
index 896fb8f290..9bed213b4f 100644
--- a/codex-rs/ext/skills/src/state.rs
+++ b/codex-rs/ext/skills/src/state.rs
@@ -4,10 +4,13 @@
use std::collections::HashSet;
use std::sync::Arc;
use std::sync::Mutex;
+use tokio::sync::Mutex as AsyncMutex;
use codex_exec_server::EnvironmentAccessKey;
+use codex_extension_api::ExtensionData;
use codex_extension_api::ExtensionMetrics;
use codex_mcp::McpResourceClient;
+use codex_mcp::McpResourceClientAuthKey;
use crate::SkillsExtensionConfig;
use crate::aliases::SkillAliasState;
@@ -44,8 +47,13 @@ pub(crate) struct SkillsSessionState {
pub(crate) extension_metrics: Option<Arc<dyn ExtensionMetrics>>,
}
+/// Auth scope of the latest catalog accepted for this turn.
+pub(crate) struct LatestCloudSkillsAuth(Option<McpResourceClientAuthKey>);
+
/// Thread-owned skill configuration and caches; consumers can only read catalog snapshots.
pub struct SkillsThreadState {
+ /// Serializes discovery; true only when the last refresh published successfully.
+ cloud_refresh_lock: AsyncMutex<bool>,
config: Mutex<SkillsExtensionConfig>,
cloud_skills_available: bool,
catalog_state: Mutex<SkillCatalogState>,
@@ -59,6 +67,7 @@ pub struct SkillsThreadState {
impl SkillsThreadState {
pub(crate) fn new(config: SkillsExtensionConfig, cloud_skills_available: bool) -> Self {
Self {
+ cloud_refresh_lock: AsyncMutex::new(false),
config: Mutex::new(config),
cloud_skills_available,
catalog_state: Mutex::new(SkillCatalogState::default()),
@@ -254,14 +263,23 @@ impl SkillsThreadState {
.and_then(|cache| cache.catalog.clone())
}
- /// The serialized turn-start lifecycle is the only discovery writer.
- /// Reuse warning-free discovery until invalidated; retry failures and partial catalogs next turn.
+ /// Reuses successful discovery within a turn; retries failures next step.
+ #[expect(
+ clippy::await_holding_invalid_type,
+ reason = "cloud discovery must remain serialized through fetching and catalog publication"
+ )]
#[tracing::instrument(name = "skills.cloud.refresh_cloud_catalog", level = "info", skip_all)]
pub(crate) async fn refresh_cloud_catalog(
&self,
providers: &SkillProviders,
query: SkillListQuery,
+ turn_store: &ExtensionData,
) -> SkillProviderResult<()> {
+ // Wait without holding config/catalog state or the MCP runtime permit.
+ let (mut refresh_succeeded, waited) = match self.cloud_refresh_lock.try_lock() {
+ Ok(guard) => (guard, false),
+ Err(_) => (self.cloud_refresh_lock.lock().await, true),
+ };
let (cache, resource_cache_key) = {
let config = self
.config
@@ -274,24 +292,38 @@ impl SkillsThreadState {
.catalog_state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
- // Switch auth scopes before discovery so failures retain only authorized contents.
+ // Check this turn's discovery using the provider's auth scope.
let cache = catalogs.prepare_cloud_generation(
providers.cloud_mcp_resources(query.mcp_resources.as_deref()),
);
+ if cache.is_auth_current()
+ && cache.catalog.is_some()
+ && turn_store
+ .get::<LatestCloudSkillsAuth>()
+ .is_some_and(|previous| previous.0 == cache.auth_cache_key)
+ {
+ return Ok(());
+ }
+ turn_store.remove::<LatestCloudSkillsAuth>();
let resource_cache_key = cache.current_resource_cache_key();
if cache.is_auth_current()
- && cache
- .catalog
- .as_ref()
- .is_some_and(|catalog| !catalog.is_partial && catalog.warnings.is_empty())
+ && cache.catalog.as_ref().is_some_and(|catalog| {
+ (waited && *refresh_succeeded)
+ || (!catalog.is_partial && catalog.warnings.is_empty())
+ })
&& cache.resource_cache_key == resource_cache_key
{
+ turn_store.insert(LatestCloudSkillsAuth(cache.auth_cache_key.clone()));
return Ok(());
}
+ // A failed or cancelled refresh must leave waiting callers able to retry.
+ *refresh_succeeded = false;
(cache, resource_cache_key)
};
- 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 result = providers.list_cloud_for_turn(query).await;
+ if let Ok(catalog) = &mut result {
+ catalog.entries.sort_by(|a, b| a.id.0.cmp(&b.id.0));
+ }
let mut catalogs = self
.catalog_state
.lock()
@@ -303,10 +335,10 @@ impl SkillsThreadState {
.as_ref()
.is_some_and(|current| Arc::ptr_eq(current, &cache))
{
- return Err(SkillProviderError::new(
- "cloud skill cache changed during discovery",
- ));
+ // Ignore superseded results, including errors.
+ return Ok(());
}
+ let mut catalog = result?;
if catalog.is_partial
&& let Some(previous) = cache
.catalog
@@ -318,12 +350,15 @@ impl SkillsThreadState {
} else {
catalogs.cloud_resources = CloudResourceCache::default();
}
- catalogs.cloud_generation = Some(Arc::new(CloudSkillGeneration {
+ let generation = Arc::new(CloudSkillGeneration {
auth_cache_key: cache.auth_cache_key.clone(),
resource_cache_key,
mcp_resources: cache.mcp_resources.clone(),
catalog: Some(catalog),
- }));
+ });
+ catalogs.cloud_generation = Some(Arc::clone(&generation));
+ turn_store.insert(LatestCloudSkillsAuth(generation.auth_cache_key.clone()));
+ *refresh_succeeded = true;
Ok(())
}