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.rsindex 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.rsindex 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.rsindex 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_discovekeys: 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.rsindex 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_contOk(())}++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.rsindex 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.snapnew file mode 100644index 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 availablediff --git a/codex-rs/ext/extension-api/src/contributors.rs b/codex-rs/ext/extension-api/src/contributors.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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() -> aOk(())}+#[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.rsindex 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.rsindex 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 = testdiff --git a/codex-rs/ext/skills/src/catalog_state.rs b/codex-rs/ext/skills/src/catalog_state.rsindex 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.rsindex 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_scooriginal_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.rsindex 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.rsindex 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(())}