Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Enable executor cleanup hooks with V2 capability discovery (#56044)

Anthony Tafoya0769c6aeeb1a
diff --git a/codex-rs/core-plugins/src/executor_hooks.rs b/codex-rs/core-plugins/src/executor_hooks.rs
index abc59ab80b..dd9d2aa48c 100644
--- a/codex-rs/core-plugins/src/executor_hooks.rs
+++ b/codex-rs/core-plugins/src/executor_hooks.rs
@@ -3,7 +3,9 @@
use codex_config::DEFAULT_MCP_SERVER_ENVIRONMENT_ID;
use codex_config::HookHandlerConfig;
use codex_config::types::PluginsConfigToml;
+use codex_exec_server::DiscoveredPluginFiles;
use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;
+use codex_exec_server::ExecutorCapabilityDiscoveryV2Snapshot;
use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
use codex_mcp::MCP_TOOL_CODEX_APPS_META_KEY;
use codex_mcp::ToolInfo;
@@ -12,6 +14,7 @@ use codex_plugin::PluginId;
use codex_plugin::is_allowlisted_bundled_cleanup_hook;
use codex_plugin::manifest::PluginManifestHooks;
use codex_protocol::capabilities::CapabilityRootLocation;
+use codex_utils_path_uri::PathUri;
use serde_json::Map;
use serde_json::Value;
@@ -32,23 +35,55 @@ pub fn executor_plugin_hook_sources<'a>(
plugins_config: &PluginsConfigToml,
lookup_enabled_tool: impl Fn(&str, &str) -> Option<&'a ToolInfo>,
) -> Vec<ExecutorPluginHookSource> {
- let mut sources = Vec::new();
-
- for entry in snapshot.roots() {
- if !plugins_config.allows_plugin(&entry.selected_root.id) {
- continue;
- }
- let Ok(plugin_id) = PluginId::parse(&entry.selected_root.id) else {
- continue;
- };
+ let plugins = snapshot.roots().iter().filter_map(|entry| {
let CapabilityRootLocation::Environment {
environment_id,
path: plugin_root,
} = &entry.selected_root.location;
- let Ok(discovery) = &entry.result else {
+ let plugin = entry.result.as_ref().ok()?.plugin.as_ref()?;
+ Some((
+ entry.selected_root.id.as_str(),
+ environment_id.as_str(),
+ plugin_root,
+ plugin,
+ ))
+ });
+ admitted_hook_sources(plugins, plugins_config, lookup_enabled_tool)
+}
+
+/// Applies the same inline-hook admission and MCP routing policy to V2 inventories.
+/// Callers must additionally restrict sources to their accepted plugin installations.
+pub fn executor_plugin_hook_sources_v2<'a>(
+ snapshots: &[ExecutorCapabilityDiscoveryV2Snapshot],
+ plugins_config: &PluginsConfigToml,
+ lookup_enabled_tool: impl Fn(&str, &str) -> Option<&'a ToolInfo>,
+) -> Vec<ExecutorPluginHookSource> {
+ let plugins = snapshots.iter().flat_map(|snapshot| {
+ snapshot.result.iter().flat_map(move |inventory| {
+ inventory.plugins.iter().map(move |plugin| {
+ (
+ plugin.id.as_str(),
+ snapshot.environment_id.as_str(),
+ &plugin.root,
+ &plugin.files,
+ )
+ })
+ })
+ });
+ admitted_hook_sources(plugins, plugins_config, lookup_enabled_tool)
+}
+
+fn admitted_hook_sources<'a, 'b>(
+ plugins: impl Iterator<Item = (&'b str, &'b str, &'b PathUri, &'b DiscoveredPluginFiles)>,
+ plugins_config: &PluginsConfigToml,
+ lookup_enabled_tool: impl Fn(&str, &str) -> Option<&'a ToolInfo>,
+) -> Vec<ExecutorPluginHookSource> {
+ let mut sources = Vec::new();
+ for (plugin_id, environment_id, plugin_root, plugin) in plugins {
+ if !plugins_config.allows_plugin(plugin_id) {
continue;
- };
- let Some(plugin) = &discovery.plugin else {
+ }
+ let Ok(plugin_id) = PluginId::parse(plugin_id) else {
continue;
};
let Ok(manifest) = parse_plugin_manifest_uri(
@@ -72,7 +107,7 @@ pub fn executor_plugin_hook_sources<'a>(
sources.push(ExecutorPluginHookSource {
plugin_id: plugin_id.clone(),
- environment_id: environment_id.clone(),
+ environment_id: environment_id.to_string(),
mcp_environment_id: None,
mcp_metadata: None,
plugin_root: plugin_root.clone(),
diff --git a/codex-rs/core-plugins/src/executor_hooks_tests.rs b/codex-rs/core-plugins/src/executor_hooks_tests.rs
index fab975d655..88651ad038 100644
--- a/codex-rs/core-plugins/src/executor_hooks_tests.rs
+++ b/codex-rs/core-plugins/src/executor_hooks_tests.rs
@@ -499,3 +499,59 @@ fn ignores_file_backed_executor_plugin_hooks() {
Vec::<ExecutorPluginHookSource>::new()
);
}
+
+#[test]
+fn v2_hooks_preserve_admission_policy_and_environment_routing() {
+ let manifest = cleanup_hook_manifest();
+ let files = DiscoveredPluginFiles {
+ manifest: CapabilityTextFile {
+ path: PathUri::parse("file:///plugins/computer-use/.codex-plugin/plugin.json").unwrap(),
+ contents: manifest.to_string(),
+ },
+ mcp_config: None,
+ apps_config: None,
+ };
+ let plugin = codex_exec_server::ExecutorPlugin {
+ id: "computer-use@openai-bundled".to_string(),
+ display_name: "Computer use".to_string(),
+ remote_plugin_id: None,
+ version: "local".to_string(),
+ root: PathUri::parse("file:///plugins/computer-use").unwrap(),
+ files,
+ skills: Vec::new(),
+ };
+ let mut untrusted = plugin.clone();
+ untrusted.id = "computer-use@untrusted".to_string();
+ let inventory = Arc::new(codex_exec_server::DiscoverV2CapabilitiesResponse {
+ plugins: vec![plugin, untrusted],
+ ..Default::default()
+ });
+ let snapshots = [
+ ExecutorCapabilityDiscoveryV2Snapshot {
+ environment_id: "executor-a".to_string(),
+ result: Ok(Arc::clone(&inventory)),
+ },
+ ExecutorCapabilityDiscoveryV2Snapshot {
+ environment_id: "executor-b".to_string(),
+ result: Ok(inventory),
+ },
+ ExecutorCapabilityDiscoveryV2Snapshot {
+ environment_id: "failed".to_string(),
+ result: Err("discovery failed".to_string()),
+ },
+ ];
+ let mut second = expected_source(/*index*/ 0);
+ second.environment_id = "executor-b".to_string();
+ assert_eq!(
+ executor_plugin_hook_sources_v2(&snapshots, &PluginsConfigToml::default(), |_, _| None),
+ vec![expected_source(/*index*/ 0), second]
+ );
+ let disabled = toml::from_str(
+ "[_default]\nenabled = true\n[\"computer-use@openai-bundled\"]\nenabled = false",
+ )
+ .unwrap();
+ assert_eq!(
+ executor_plugin_hook_sources_v2(&snapshots, &disabled, |_, _| None),
+ Vec::new()
+ );
+}
diff --git a/codex-rs/core-plugins/src/lib.rs b/codex-rs/core-plugins/src/lib.rs
index 95d800d021..8b8f57f836 100644
--- a/codex-rs/core-plugins/src/lib.rs
+++ b/codex-rs/core-plugins/src/lib.rs
@@ -76,6 +76,7 @@ pub use discoverable::ToolSuggestDiscoverablePlugin;
pub use discoverable::ToolSuggestPluginDiscoveryInput;
pub use executor_catalog::catalog_from_snapshots;
pub use executor_hooks::executor_plugin_hook_sources;
+pub use executor_hooks::executor_plugin_hook_sources_v2;
pub use executor_provider::ExecutorPluginProvider;
pub use executor_provider::ExecutorPluginProviderError;
pub use executor_provider::PluginRootOwnership;
diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rs
index d8f66cb67b..34f3351372 100644
--- a/codex-rs/core/src/hook_runtime.rs
+++ b/codex-rs/core/src/hook_runtime.rs
@@ -1,3 +1,7 @@
+mod executor;
+
+pub(crate) use executor::prepare_executor_hook_sources;
+
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
@@ -5,9 +9,6 @@ use std::time::Duration;
use codex_analytics::CompactionTrigger;
use codex_analytics::HookRunFact;
use codex_analytics::build_track_events_context;
-use codex_connectors::AppToolPolicyEvaluator;
-use codex_connectors::AppToolPolicyInput;
-use codex_core_plugins::executor_plugin_hook_sources;
use codex_hooks::InterruptRequest;
use codex_hooks::PermissionRequestDecision;
use codex_hooks::PermissionRequestOutcome;
@@ -25,10 +26,8 @@ use codex_hooks::UserPromptSubmitOutcome;
use codex_hooks::UserPromptSubmitRequest;
use codex_hooks::hook_execution_mode_label;
use codex_hooks::hook_handler_type_label;
-use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
use codex_otel::HOOK_RUN_DURATION_METRIC;
use codex_otel::HOOK_RUN_METRIC;
-use codex_plugin::ExecutorPluginHookSource;
use codex_protocol::items::FunctionCallOutputItem;
use codex_protocol::items::TurnItem;
use codex_protocol::items::UserMessageItem;
@@ -327,48 +326,6 @@ pub(crate) async fn run_post_tool_use_hooks(
outcome
}
-fn executor_hook_sources_for_step(step_context: &StepContext) -> Vec<ExecutorPluginHookSource> {
- step_context
- .executor_capability_discovery
- .as_deref()
- .map(|snapshot| {
- let config = step_context.mcp.config();
- let app_tool_policy = AppToolPolicyEvaluator::new(&config.config_layer_stack);
- executor_plugin_hook_sources(snapshot, &config.plugins, |server, tool| {
- step_context
- .mcp
- .tool_info(server, tool)
- .filter(|tool_info| {
- if server != CODEX_APPS_MCP_SERVER_NAME {
- return true;
- }
- let annotations = tool_info.tool.annotations.as_ref();
- app_tool_policy
- .policy(AppToolPolicyInput {
- connector_id: tool_info.connector_id.as_deref(),
- link_id: None,
- tool_name: &tool_info.tool.name,
- tool_title: tool_info.tool.title.as_deref(),
- destructive_hint: annotations
- .and_then(|annotations| annotations.destructive_hint),
- open_world_hint: annotations
- .and_then(|annotations| annotations.open_world_hint),
- })
- .enabled
- })
- })
- .into_iter()
- .filter(|source| {
- !step_context
- .turn
- .disabled_plugin_ids
- .contains(&source.plugin_id.as_key())
- })
- .collect()
- })
- .unwrap_or_default()
-}
-
fn build_request_metadata(
step_context: Option<&StepContext>,
turn_context: &TurnContext,
@@ -458,7 +415,7 @@ pub(crate) async fn run_turn_stop_hooks(
last_assistant_message,
target,
};
- let executor_hook_sources = executor_hook_sources_for_step(step_context);
+ let executor_hook_sources = step_context.executor_hook_sources.clone();
let hooks = sess.hooks().with_executor_hooks(executor_hook_sources);
emit_hook_started_events(sess, turn_context, hooks.preview_stop(&request)).await;
@@ -512,7 +469,7 @@ pub(crate) async fn run_turn_interrupt_hooks(
let last_known_step_context = turn_state.lock().await.last_known_step_context.clone();
let executor_hook_sources = last_known_step_context
.as_deref()
- .map(executor_hook_sources_for_step)
+ .map(|step| step.executor_hook_sources.clone())
.unwrap_or_default();
let has_executor_hooks = !executor_hook_sources.is_empty();
let hooks = sess.hooks().with_executor_hooks(executor_hook_sources);
@@ -1082,7 +1039,7 @@ pub(crate) fn hooks_for_model_request(
match step.turn.session_source {
SessionSource::Internal(InternalSessionSource::MemoryConsolidation)
| SessionSource::SubAgent(SubAgentSource::MemoryConsolidation) => {
- Arc::new(hooks.for_memory_consolidation(executor_hook_sources_for_step(step)))
+ Arc::new(hooks.for_memory_consolidation(step.executor_hook_sources.clone()))
}
_ => hooks,
}
diff --git a/codex-rs/core/src/hook_runtime/executor.rs b/codex-rs/core/src/hook_runtime/executor.rs
new file mode 100644
index 0000000000..e779271aa2
--- /dev/null
+++ b/codex-rs/core/src/hook_runtime/executor.rs
@@ -0,0 +1,66 @@
+//! Captures admitted executor hooks from this step's discovery and MCP policy.
+
+use codex_connectors::AppToolPolicyEvaluator;
+use codex_connectors::AppToolPolicyInput;
+use codex_core_plugins::executor_plugin_hook_sources;
+use codex_core_plugins::executor_plugin_hook_sources_v2;
+use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;
+use codex_exec_server::ExecutorCapabilityDiscoveryV2Snapshot;
+use codex_extension_api::SelectedPluginSnapshot;
+use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
+use codex_mcp::McpBinding;
+use codex_plugin::ExecutorPluginHookSource;
+
+pub(crate) fn prepare_executor_hook_sources(
+ mcp: &McpBinding,
+ selected_plugins: &SelectedPluginSnapshot,
+ discovery: Option<&ExecutorCapabilityDiscoverySnapshot>,
+ discovery_v2: Option<&[ExecutorCapabilityDiscoveryV2Snapshot]>,
+) -> Vec<ExecutorPluginHookSource> {
+ let config = mcp.config();
+ let app_tool_policy = AppToolPolicyEvaluator::new(&config.config_layer_stack);
+ let lookup_enabled_tool = |server: &str, tool: &str| {
+ mcp.tool_info(server, tool).filter(|tool_info| {
+ if server != CODEX_APPS_MCP_SERVER_NAME {
+ return true;
+ }
+ let annotations = tool_info.tool.annotations.as_ref();
+ app_tool_policy
+ .policy(AppToolPolicyInput {
+ connector_id: tool_info.connector_id.as_deref(),
+ link_id: None,
+ tool_name: &tool_info.tool.name,
+ tool_title: tool_info.tool.title.as_deref(),
+ destructive_hint: annotations
+ .and_then(|annotations| annotations.destructive_hint),
+ open_world_hint: annotations
+ .and_then(|annotations| annotations.open_world_hint),
+ })
+ .enabled
+ })
+ };
+ let sources = if let Some(snapshots) = discovery_v2 {
+ executor_plugin_hook_sources_v2(snapshots, &config.plugins, lookup_enabled_tool)
+ .into_iter()
+ .filter(|source| {
+ let root_id = format!("{}:{}", source.environment_id, source.plugin_id.as_key());
+ selected_plugins
+ .plugins
+ .iter()
+ .any(|plugin| plugin.selected_root_id.as_deref() == Some(root_id.as_str()))
+ })
+ .collect()
+ } else if let Some(snapshot) = discovery {
+ executor_plugin_hook_sources(snapshot, &config.plugins, lookup_enabled_tool)
+ } else {
+ Vec::new()
+ };
+ sources
+ .into_iter()
+ .filter(|source| {
+ !selected_plugins
+ .disabled_plugin_ids
+ .contains(&source.plugin_id.as_key())
+ })
+ .collect()
+}
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
index 83b34a87d3..d64d42864a 100644
--- a/codex-rs/core/src/session/mod.rs
+++ b/codex-rs/core/src/session/mod.rs
@@ -3995,8 +3995,6 @@ impl Session {
.executor_capability_discovery_for_step_v2(&turn_context.config, &environments)
.await;
let v2_snapshots = executor_capability_discovery_v2.as_ref();
- // V1 discovery is still retained on StepContext for executor Stop/Interrupt hooks.
- // TODO: Prepare hook sources at capture time, including V2, instead.
let (executor_capability_discovery, discovery_recovered) = if v2_snapshots.is_some() {
(None, false)
} else {
@@ -4071,6 +4069,12 @@ impl Session {
.or_cancel(cancellation_token)
.await?;
}
+ let executor_hook_sources = crate::hook_runtime::prepare_executor_hook_sources(
+ &mcp,
+ &selected_plugins,
+ executor_capability_discovery.as_deref(),
+ executor_capability_discovery_v2.as_deref(),
+ );
extension_data.insert(selected_plugins);
let tool_router = turn::built_tools(
self.as_ref(),
@@ -4082,12 +4086,7 @@ impl Session {
prepared_recommendations,
)
.await?;
- Ok::<_, CodexErr>((
- executor_capability_discovery,
- mcp,
- tool_router,
- extension_data,
- ))
+ Ok::<_, CodexErr>((executor_hook_sources, mcp, tool_router, extension_data))
});
// Returned warnings must finish delivery even if tools fail or preparation is cancelled.
let (loaded_agents_md, prepared_tools) =
@@ -4096,7 +4095,7 @@ impl Session {
if cancellation_token.is_cancelled() {
return Err(CodexErr::TurnAborted);
}
- let (executor_capability_discovery, mcp, tool_router, extension_data) = prepared_tools??;
+ let (executor_hook_sources, mcp, tool_router, extension_data) = prepared_tools??;
Ok(Arc::new(StepContext {
preempt: turn_context
.config
@@ -4111,7 +4110,7 @@ impl Session {
extension_data,
environments,
inherited_environments,
- executor_capability_discovery,
+ executor_hook_sources,
mcp,
tool_router,
loaded_agents_md,
diff --git a/codex-rs/core/src/session/step_context.rs b/codex-rs/core/src/session/step_context.rs
index 5812579c45..ac96683d40 100644
--- a/codex-rs/core/src/session/step_context.rs
+++ b/codex-rs/core/src/session/step_context.rs
@@ -10,11 +10,11 @@ use crate::session::step_settings::ResolvedStepSettings;
use crate::session::turn_context::TurnContext;
use crate::session::turn_context::TurnEnvironment;
use crate::tools::router::ToolRouter;
-use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;
use codex_extension_api::ExtensionData;
use codex_file_system::EnvironmentAccess;
use codex_mcp::McpBinding;
use codex_otel::SessionTelemetry;
+use codex_plugin::ExecutorPluginHookSource;
use codex_protocol::items::ModelInvocationContext;
use codex_protocol::protocol::TurnContextItem;
use tokio_util::sync::CancellationToken;
@@ -35,8 +35,8 @@ pub(crate) struct StepContext {
pub(crate) environments: TurnEnvironmentSnapshot,
/// Child bindings captured with this step; configured-only when opted in.
pub(crate) inherited_environments: TurnEnvironmentSnapshot,
- /// Legacy discovery retained for executor hook materialization in this exact step.
- pub(crate) executor_capability_discovery: Option<Arc<ExecutorCapabilityDiscoverySnapshot>>,
+ /// Admitted executor hooks bound to this step's discovery, plugin policy, and MCP routing.
+ pub(crate) executor_hook_sources: Vec<ExecutorPluginHookSource>,
/// Keeps the extension inputs used to build this step's tools for its World State as well.
pub(crate) extension_data: ExtensionData,
/// The exact MCP connections, configuration, and catalog captured for this step.
diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs
index f6999ef92f..7bd3a385bc 100644
--- a/codex-rs/core/src/session/tests.rs
+++ b/codex-rs/core/src/session/tests.rs
@@ -291,7 +291,7 @@ impl StepContext {
turn: Arc::clone(&turn),
inherited_environments: environments.clone(),
environments,
- executor_capability_discovery: None,
+ executor_hook_sources: Vec::new(),
extension_data: codex_extension_api::ExtensionData::new(turn.sub_id.clone()),
mcp: Arc::new(codex_mcp::McpBinding::empty(mcp_config_for_test(
&turn.config,
diff --git a/codex-rs/core/tests/suite/executor_discovery_v2.rs b/codex-rs/core/tests/suite/executor_discovery_v2.rs
index 1791e41ba1..457677d42d 100644
--- a/codex-rs/core/tests/suite/executor_discovery_v2.rs
+++ b/codex-rs/core/tests/suite/executor_discovery_v2.rs
@@ -2,6 +2,7 @@
use anyhow::Context;
use anyhow::Result;
+use codex_core::TurnInputRequest;
use codex_core::config::Config;
use codex_core::windows_sandbox::WindowsSandboxLevelExt;
use codex_core_plugins::ExecutorPluginProvider;
@@ -36,7 +37,11 @@ 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::EventMsg;
+use codex_protocol::protocol::Op;
use codex_protocol::protocol::SKILLS_INSTRUCTIONS_OPEN_TAG;
+use codex_protocol::protocol::TurnEnvironmentSelections;
+use codex_protocol::user_input::UserInput;
use codex_skills_extension::ExecutorSkillProvider;
use codex_skills_extension::SkillProviders;
use codex_skills_extension::SkillsExtensionConfig;
@@ -1196,3 +1201,190 @@ async fn auth_rotation_refreshes_plugin_acceptance_before_merged_skills() -> Res
);
Ok(())
}
+
+#[test_case::test_case("Stop"; "stop")]
+#[test_case::test_case("Interrupt"; "interrupt")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn v2_cleanup_hooks_follow_plugin_selection_without_legacy_roots(
+ hook_event: &'static str,
+) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ let model = responses::start_mock_server().await;
+ let hook_calls = Arc::new(AtomicUsize::new(0));
+ let recorded = Arc::clone(&hook_calls);
+ wiremock::Mock::given(wiremock::matchers::path("/hooks"))
+ .respond_with(move |request: &wiremock::Request| {
+ let request: Value =
+ serde_json::from_slice(&request.body).expect("MCP request should be valid JSON");
+ let result = match request["method"].as_str() {
+ Some("initialize") => json!({
+ "protocolVersion": request["params"]["protocolVersion"],
+ "capabilities": {"tools": {}}, "serverInfo": {"name": "hooks", "version": "1"}
+ }),
+ Some("notifications/initialized") => return wiremock::ResponseTemplate::new(202),
+ Some("tools/list") => json!({"tools": [{
+ "name": "turn_ended", "inputSchema": {"type": "object"}
+ }]}),
+ Some("tools/call") => {
+ assert_eq!(request["params"]["name"], "turn_ended");
+ assert_eq!(
+ request["params"]["arguments"]["hook_event_name"],
+ hook_event
+ );
+ recorded.fetch_add(1, Ordering::SeqCst);
+ json!({"content": []})
+ }
+ other => panic!("unexpected MCP request: {other:?}"),
+ };
+ wiremock::ResponseTemplate::new(200)
+ .set_body_json(json!({"jsonrpc": "2.0", "id": request["id"], "result": result}))
+ })
+ .mount(&model)
+ .await;
+ let manifest = json!({"name": "computer-use", "hooks": {"hooks": {(hook_event): [{"hooks": [{
+ "type": "mcp_tool", "server": "node_repl", "tool": "turn_ended",
+ "input": {"hook_event_name": "${hook_event_name}", "session_id": "${session_id}", "turn_id": "${turn_id}"}
+ }]}]}}});
+ let inventory = json!({"plugins": [{
+ "id": "computer-use@openai-bundled", "displayName": "Computer use",
+ "remotePluginId": null, "version": "1", "root": "file:///plugins/computer-use",
+ "files": {"manifest": {"path": "file:///plugins/computer-use/.codex-plugin/plugin.json",
+ "contents": manifest.to_string()}, "mcpConfig": null, "appsConfig": null}, "skills": []
+ }], "skills": [], "warnings": []});
+ let executor = Executor::start(/*supports_v2*/ true, DiscoveryFailure::None).await?;
+ *executor.inventory.lock().await = Some(inventory);
+ let hook_url = format!("{}/hooks", model.uri());
+ let hook_server = serde_json::from_value(json!({
+ "url": hook_url, "environment_id": codex_exec_server::REMOTE_ENVIRONMENT_ID
+ }))?;
+ let mut extensions = ExtensionRegistryBuilder::new();
+ codex_mcp_extension::install_plugins(
+ &mut extensions,
+ Arc::new(codex_exec_server::EnvironmentManager::default_for_tests()),
+ );
+ let home = Arc::new(tempfile::TempDir::new()?);
+ std::fs::write(
+ home.path().join("config.toml"),
+ "[plugins.\"computer-use@openai-bundled\"]\nenabled = true\n",
+ )?;
+ let test = test_codex()
+ .with_home(home)
+ .with_extensions(Arc::new(extensions.build()))
+ .with_exec_server_url(executor.url.clone())
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::Plugins)
+ .expect("enable plugins");
+ config
+ .features
+ .enable(Feature::ExecutorCapabilityDiscoveryV2)
+ .expect("enable V2 discovery");
+ config
+ .features
+ .disable(Feature::ExecutorCapabilityDiscovery)
+ .expect("disable V1 discovery");
+ config
+ .mcp_servers
+ .set(
+ [(String::from("node_repl"), hook_server)]
+ .into_iter()
+ .collect(),
+ )
+ .expect("configure the executor hook server");
+ })
+ .build_with_auto_env(&model)
+ .await?;
+ core_test_support::wait_for_mcp_server(&test.codex, "node_repl").await?;
+ let mut selection = test.executor_environment().selection().clone();
+ selection.environment_id = codex_exec_server::REMOTE_ENVIRONMENT_ID.to_string();
+ selection.selected_capability_roots = Default::default();
+ for disabled in [false, true] {
+ core_test_support::submit_thread_settings(
+ &test.codex,
+ codex_protocol::protocol::ThreadSettingsOverrides {
+ environments: Some(
+ TurnEnvironmentSelections::new(
+ test.config.cwd.clone(),
+ vec![selection.clone()],
+ )
+ .into_requests(),
+ ),
+ disabled_plugin_ids: Some(if disabled {
+ vec!["computer-use@openai-bundled".to_string()]
+ } else {
+ Vec::new()
+ }),
+ ..Default::default()
+ },
+ )
+ .await?;
+ let mut response = responses::sse_response(responses::sse(vec![
+ responses::ev_response_created("response"),
+ responses::ev_assistant_message("message", "Done."),
+ responses::ev_completed("response"),
+ ]));
+ if hook_event == "Interrupt" {
+ response = response.set_delay(std::time::Duration::from_secs(60));
+ }
+ let requests = responses::mount_response_once(&model, response).await;
+ test.codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "Finish this turn.".to_string(),
+ text_elements: Vec::new(),
+ }]))
+ .await?;
+ if hook_event == "Interrupt" {
+ tokio::time::timeout(std::time::Duration::from_secs(10), async {
+ while requests.requests().is_empty() {
+ tokio::task::yield_now().await;
+ }
+ })
+ .await
+ .context("interrupted turn should reach inference with its prepared step")?;
+ test.codex.submit(Op::Interrupt).await?;
+ }
+ core_test_support::wait_for_event(&test.codex, |event| {
+ if hook_event == "Interrupt" {
+ matches!(event, EventMsg::TurnAborted(_))
+ } else {
+ matches!(event, EventMsg::TurnComplete(_))
+ }
+ })
+ .await;
+ if !disabled {
+ tokio::time::timeout(std::time::Duration::from_secs(10), async {
+ while hook_calls.load(Ordering::SeqCst) == 0 {
+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+ }
+ })
+ .await
+ .context("V2 cleanup hook should run")?;
+ } else {
+ // Cleanup is asynchronous; turn completion alone cannot prove disablement.
+ assert!(
+ tokio::time::timeout(std::time::Duration::from_secs(1), async {
+ while hook_calls.load(Ordering::SeqCst) == 1 {
+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+ }
+ })
+ .await
+ .is_err(),
+ "disabled cleanup hook must remain silent"
+ );
+ }
+ assert_eq!(hook_calls.load(Ordering::SeqCst), 1);
+ }
+ let requests = executor.requests.lock().await;
+ assert!(
+ requests
+ .iter()
+ .any(|request| request["method"] == "capabilities/discoverV2")
+ );
+ assert!(
+ !requests
+ .iter()
+ .any(|request| request["method"] == "capabilityRoots/discoverV1")
+ );
+ Ok(())
+}