From 44d2376f0665cd27b0fcd363efc5fc62b60c6bd3 Mon Sep 17 00:00:00 2001 From: Casey Chow Date: Thu, 9 Jul 2026 23:05:24 +0000 Subject: [PATCH] fix(plugins): close host capability gating gaps --- codex-rs/app-server/README.md | 5 +- codex-rs/app-server/src/message_processor.rs | 9 +- .../src/request_processors/apps_processor.rs | 9 +- .../request_processors/thread_processor.rs | 15 ++- .../src/request_processors/turn_processor.rs | 11 +- .../suite/v2/connection_handling_websocket.rs | 70 +++++++++++- .../core-plugins/src/discoverable_tests.rs | 95 ++++++++++++++++ .../core-plugins/src/tool_suggest_metadata.rs | 12 +- codex-rs/core/tests/suite/plugins.rs | 104 ++++++++++++++++++ 9 files changed, 320 insertions(+), 10 deletions(-) diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.md index 0abe5a5de1..7b49347f6c 100644 --- a/codex-rs/app-server/README.md +++ b/codex-rs/app-server/README.md @@ -98,7 +98,8 @@ Clients declare host features available to runtime plugins with compatibility signals, not authorization grants; omitted or `null` capabilities are treated as an empty set. The capability set is fixed for the lifetime of a loaded thread, so clients must use the same set when resuming or -starting turns on that thread. +performing model-visible runtime operations on that thread. Capability-independent +settings updates remain available; the next `turn/start` enforces compatibility. Plugin manifests declare all-of host requirements with `{"requires":{"hostCapabilities":["codex.inline_visualization"]}}`. A plugin @@ -1835,7 +1836,7 @@ Use `app/list` to fetch available apps (connectors). Each entry includes metadat } } ``` -When `threadId` is provided, app feature gating (`Feature::Apps`) is evaluated using that thread's config snapshot. When omitted, the latest global config is used. +When `threadId` is provided, app feature gating (`Feature::Apps`) is evaluated using that thread's config snapshot, and the requesting connection must have the same host capability set as the loaded thread. When omitted, the latest global config is used. `app/list` returns after both accessible apps and directory apps are loaded. Set `forceRefetch: true` to bypass app caches and fetch fresh data from sources. Cache entries are only replaced when those refetches succeed. diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rs index 0fd882d1be..bd4a6d5c56 100644 --- a/codex-rs/app-server/src/message_processor.rs +++ b/codex-rs/app-server/src/message_processor.rs @@ -1136,7 +1136,12 @@ impl MessageProcessor { } ClientRequest::ThreadRollback { params, .. } => { self.thread_processor - .thread_rollback(&request_id, params, app_server_client_info.name.as_deref()) + .thread_rollback( + &request_id, + params, + app_server_client_info.name.as_deref(), + host_capabilities.clone(), + ) .await } ClientRequest::ThreadList { params, .. } => { @@ -1280,7 +1285,7 @@ impl MessageProcessor { } ClientRequest::TurnInterrupt { params, .. } => { self.turn_processor - .turn_interrupt(&request_id, params) + .turn_interrupt(&request_id, params, host_capabilities.clone()) .await } ClientRequest::ThreadRealtimeStart { params, .. } => { diff --git a/codex-rs/app-server/src/request_processors/apps_processor.rs b/codex-rs/app-server/src/request_processors/apps_processor.rs index 58cf1cd55b..190d68f0bd 100644 --- a/codex-rs/app-server/src/request_processors/apps_processor.rs +++ b/codex-rs/app-server/src/request_processors/apps_processor.rs @@ -52,7 +52,14 @@ impl AppsRequestProcessor { let installed_start = Instant::now(); let reload = params.force_refetch; let thread = if let Some(thread_id) = params.thread_id.as_deref() { - let (_, loaded_thread) = self.load_thread(thread_id).await?; + let (thread_id, loaded_thread) = self.load_thread(thread_id).await?; + ensure_thread_host_capabilities( + thread_id, + loaded_thread.as_ref(), + &host_capabilities, + "list apps", + ) + .await?; Some(loaded_thread) } else { None diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rs index 46a9cecd5e..8fdd26ada9 100644 --- a/codex-rs/app-server/src/request_processors/thread_processor.rs +++ b/codex-rs/app-server/src/request_processors/thread_processor.rs @@ -669,12 +669,13 @@ impl ThreadRequestProcessor { request_id: &ConnectionRequestId, params: ThreadRollbackParams, app_server_client_name: Option<&str>, + host_capabilities: HostCapabilities, ) -> Result, JSONRPCErrorError> { if app_server_client_name != Some(CODEX_TUI_CLIENT_NAME) { self.send_thread_rollback_deprecation_notice(request_id.connection_id) .await; } - self.thread_rollback_inner(request_id, params) + self.thread_rollback_inner(request_id, params, host_capabilities) .await .map(|()| None) } @@ -1750,14 +1751,17 @@ impl ThreadRequestProcessor { &self, request_id: &ConnectionRequestId, params: ThreadRollbackParams, + host_capabilities: HostCapabilities, ) -> Result<(), JSONRPCErrorError> { - self.thread_rollback_start(request_id, params).await + self.thread_rollback_start(request_id, params, host_capabilities) + .await } async fn thread_rollback_start( &self, request_id: &ConnectionRequestId, params: ThreadRollbackParams, + host_capabilities: HostCapabilities, ) -> Result<(), JSONRPCErrorError> { let ThreadRollbackParams { thread_id, @@ -1769,6 +1773,13 @@ impl ThreadRequestProcessor { } let (thread_id, thread) = self.load_thread(&thread_id).await?; + ensure_thread_host_capabilities( + thread_id, + thread.as_ref(), + &host_capabilities, + "roll back", + ) + .await?; let request = request_id.clone(); diff --git a/codex-rs/app-server/src/request_processors/turn_processor.rs b/codex-rs/app-server/src/request_processors/turn_processor.rs index 69335c34e1..16d0e04773 100644 --- a/codex-rs/app-server/src/request_processors/turn_processor.rs +++ b/codex-rs/app-server/src/request_processors/turn_processor.rs @@ -208,8 +208,9 @@ impl TurnRequestProcessor { &self, request_id: &ConnectionRequestId, params: TurnInterruptParams, + host_capabilities: HostCapabilities, ) -> Result, JSONRPCErrorError> { - self.turn_interrupt_inner(request_id, params) + self.turn_interrupt_inner(request_id, params, host_capabilities) .await .map(|response| response.map(Into::into)) } @@ -1389,11 +1390,19 @@ impl TurnRequestProcessor { &self, request_id: &ConnectionRequestId, params: TurnInterruptParams, + host_capabilities: HostCapabilities, ) -> Result, JSONRPCErrorError> { let TurnInterruptParams { thread_id, turn_id } = params; let is_startup_interrupt = turn_id.is_empty(); let (thread_uuid, thread) = self.load_thread(&thread_id).await?; + ensure_thread_host_capabilities( + thread_uuid, + thread.as_ref(), + &host_capabilities, + "interrupt a turn", + ) + .await?; // Record turn interrupts so we can reply when TurnAborted arrives. Startup // interrupts do not have a turn and are acknowledged after submission. diff --git a/codex-rs/app-server/tests/suite/v2/connection_handling_websocket.rs b/codex-rs/app-server/tests/suite/v2/connection_handling_websocket.rs index 2ac7447e47..e7a159ba25 100644 --- a/codex-rs/app-server/tests/suite/v2/connection_handling_websocket.rs +++ b/codex-rs/app-server/tests/suite/v2/connection_handling_websocket.rs @@ -356,6 +356,68 @@ async fn host_capabilities_are_normalized_and_sticky_for_loaded_threads() -> Res inject_error.error.message ); + send_request( + &mut mismatched_client, + "app/list", + /*id*/ 11, + Some(json!({ + "threadId": thread_id, + })), + ) + .await?; + let apps_error = read_error_for_id(&mut mismatched_client, /*id*/ 11) + .await + .context("mismatched-client app/list error")?; + assert!(apps_error.error.message.contains("cannot list apps")); + + send_request( + &mut mismatched_client, + "thread/rollback", + /*id*/ 12, + Some(json!({ + "threadId": thread_id, + "numTurns": 1, + })), + ) + .await?; + let rollback_error = read_error_for_id(&mut mismatched_client, /*id*/ 12) + .await + .context("mismatched-client thread/rollback error")?; + assert!(rollback_error.error.message.contains("cannot roll back")); + + send_request( + &mut mismatched_client, + "turn/interrupt", + /*id*/ 13, + Some(json!({ + "threadId": thread_id, + "turnId": "turn-under-test", + })), + ) + .await?; + let interrupt_error = read_error_for_id(&mut mismatched_client, /*id*/ 13) + .await + .context("mismatched-client turn/interrupt error")?; + assert!( + interrupt_error + .error + .message + .contains("cannot interrupt a turn") + ); + + send_request( + &mut mismatched_client, + "thread/settings/update", + /*id*/ 14, + Some(json!({ + "threadId": thread_id, + })), + ) + .await?; + read_response_for_id(&mut mismatched_client, /*id*/ 14) + .await + .context("mismatched-client thread/settings/update response")?; + process .kill() .await @@ -951,7 +1013,13 @@ pub(super) async fn send_initialize_request( id: i64, client_name: &str, ) -> Result<()> { - send_initialize_request_with_host_capabilities(stream, id, client_name, None).await + send_initialize_request_with_host_capabilities( + stream, + id, + client_name, + /*host_capabilities*/ None, + ) + .await } async fn send_initialize_request_with_host_capabilities( diff --git a/codex-rs/core-plugins/src/discoverable_tests.rs b/codex-rs/core-plugins/src/discoverable_tests.rs index d1dbb945e4..2ebe9b7075 100644 --- a/codex-rs/core-plugins/src/discoverable_tests.rs +++ b/codex-rs/core-plugins/src/discoverable_tests.rs @@ -350,6 +350,101 @@ async fn reprojects_cached_configured_and_fallback_plugins_for_host_capabilities ); } +#[tokio::test] +async fn filters_unmaterialized_remote_plugins_by_fallback_host_capabilities() { + let codex_home = tempdir().expect("tempdir should succeed"); + let marketplace_name = "remote-marketplace"; + let plugin_name = "remote-plugin"; + let plugin_id = format!("{plugin_name}@{marketplace_name}"); + let malformed_plugin_name = "malformed-remote-plugin"; + let malformed_plugin_id = format!("{malformed_plugin_name}@{marketplace_name}"); + let marketplace_root = codex_home + .path() + .join(format!(".tmp/marketplaces/{marketplace_name}")); + write_file( + &marketplace_root.join(".agents/plugins/marketplace.json"), + &format!( + r#"{{ + "name": "{marketplace_name}", + "plugins": [ + {{ + "name": "{plugin_name}", + "source": {{ + "source": "git-subdir", + "url": "openai/remote-plugin", + "path": "plugins/remote-plugin" + }}, + "requires": {{ + "hostCapabilities": ["{HOST_CAPABILITY_INLINE_VISUALIZATION}"] + }} + }}, + {{ + "name": "{malformed_plugin_name}", + "source": {{ + "source": "git-subdir", + "url": "openai/malformed-remote-plugin", + "path": "plugins/malformed-remote-plugin" + }}, + "requires": {{ + "hostCapabilities": "{HOST_CAPABILITY_INLINE_VISUALIZATION}" + }} + }} + ] +}} +"# + ), + ); + write_file( + &codex_home.path().join(CONFIG_TOML_FILE), + &format!( + r#"[features] +plugins = true + +[marketplaces.{marketplace_name}] +source_type = "git" +source = "/tmp/{marketplace_name}" +"# + ), + ); + + let mut plugins = load_plugins_config(codex_home.path(), codex_home.path()).await; + let plugins_manager = PluginsManager::new(codex_home.path().to_path_buf()); + let unsupported = list_discoverable_plugins( + &plugins_manager, + discovery_input( + plugins.clone(), + &[plugin_id.as_str(), malformed_plugin_id.as_str()], + &[], + &[], + ), + /*auth*/ None, + ) + .await; + assert_eq!(unsupported, Vec::new()); + + plugins + .host_capabilities + .insert(HOST_CAPABILITY_INLINE_VISUALIZATION.to_string()); + let supported = list_discoverable_plugins( + &plugins_manager, + discovery_input( + plugins, + &[plugin_id.as_str(), malformed_plugin_id.as_str()], + &[], + &[], + ), + /*auth*/ None, + ) + .await; + assert_eq!( + supported + .into_iter() + .map(|plugin| plugin.id) + .collect::>(), + vec![plugin_id] + ); +} + #[tokio::test] async fn reprojects_cached_skill_availability_for_current_config() { let codex_home = tempdir().expect("tempdir should succeed"); diff --git a/codex-rs/core-plugins/src/tool_suggest_metadata.rs b/codex-rs/core-plugins/src/tool_suggest_metadata.rs index b232adde41..d2943afadf 100644 --- a/codex-rs/core-plugins/src/tool_suggest_metadata.rs +++ b/codex-rs/core-plugins/src/tool_suggest_metadata.rs @@ -206,13 +206,23 @@ async fn load_plugin_metadata( )?; let MarketplacePluginSource::Local { path: plugin_root } = &plugin.source else { + let required_host_capabilities = match plugin.manifest_fallback.as_ref() { + Some(fallback) => { + fallback + .parse_for_listing() + .ok_or_else(|| "invalid marketplace plugin manifest fallback".to_string())? + .requires + .host_capabilities + } + None => Vec::new(), + }; return Ok(Arc::new(ToolSuggestMetadataFragment { config_name: plugin.id.clone(), display_name: plugin.name.clone(), description: prompt_safe_plugin_description(Some( &remote_plugin_install_required_description(&plugin.source), )), - required_host_capabilities: Vec::new(), + required_host_capabilities, mcp_server_names: Vec::new(), app_declarations: Vec::new(), skill_inventory: None, diff --git a/codex-rs/core/tests/suite/plugins.rs b/codex-rs/core/tests/suite/plugins.rs index aaf65baad0..5b34f4f9d8 100644 --- a/codex-rs/core/tests/suite/plugins.rs +++ b/codex-rs/core/tests/suite/plugins.rs @@ -29,6 +29,7 @@ use core_test_support::test_codex::TestCodex; use core_test_support::test_codex::test_codex; use core_test_support::wait_for_event; use core_test_support::wait_for_mcp_server; +use pretty_assertions::assert_eq; use tempfile::TempDir; use wiremock::MockServer; @@ -274,6 +275,109 @@ async fn capability_sections_render_in_developer_message_in_order() -> Result<() Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn host_capabilities_gate_plugin_guidance_and_tools_all_of() -> Result<()> { + skip_if_no_network!(Ok(())); + let rmcp_test_server_bin = match stdio_server_bin() { + Ok(bin) => bin, + Err(err) => { + eprintln!("test_stdio_server binary not available, skipping test: {err}"); + return Ok(()); + } + }; + + for (host_capabilities, expected_supported) in [ + (Vec::new(), false), + (vec!["capability-a"], false), + (vec!["capability-b"], false), + (vec!["capability-a", "capability-b"], true), + ( + vec!["capability-a", "capability-b", "capability-extra"], + true, + ), + ] { + let server = start_mock_server().await; + let mock = mount_plugin_tool_search_turn(&server).await; + let codex_home = Arc::new(TempDir::new()?); + write_plugin_skill_plugin(codex_home.as_ref()); + write_plugin_mcp_plugin(codex_home.as_ref(), &rmcp_test_server_bin); + std::fs::write( + sample_plugin_root(codex_home.as_ref()).join(".codex-plugin/plugin.json"), + format!( + r#"{{ + "name": "{SAMPLE_PLUGIN_DISPLAY_NAME}", + "description": "{SAMPLE_PLUGIN_DESCRIPTION}", + "requires": {{ + "hostCapabilities": ["capability-a", "capability-b"] + }} +}}"# + ), + )?; + + let mut builder = test_codex() + .with_home(codex_home) + .with_auth(CodexAuth::from_api_key("Test API Key")) + .with_config(move |config| { + config.host_capabilities = host_capabilities + .iter() + .map(std::string::ToString::to_string) + .collect(); + }); + let test_codex = builder + .build(&server) + .await + .expect("create new conversation"); + let codex = Arc::clone(&test_codex.codex); + let startup = loop { + let event = codex + .next_event() + .await + .expect("stream ended unexpectedly while waiting for MCP startup"); + if let EventMsg::McpStartupComplete(startup) = event.msg { + break startup; + } + }; + let sample_ready = startup.ready.iter().any(|server| server == "sample"); + let sample_reported = sample_ready + || startup + .failed + .iter() + .any(|failure| failure.server == "sample") + || startup.cancelled.iter().any(|server| server == "sample"); + assert_eq!(sample_reported, expected_supported); + assert_eq!(sample_ready, expected_supported); + + codex + .submit(Op::UserInput { + items: vec![codex_protocol::user_input::UserInput::Text { + text: "hello".into(), + text_elements: Vec::new(), + }], + final_output_json_schema: None, + responsesapi_client_metadata: None, + additional_context: Default::default(), + thread_settings: Default::default(), + }) + .await?; + wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; + + let requests = mock.requests(); + let developer_text = requests[0].message_input_texts("developer").join("\n\n"); + assert_eq!( + developer_text.contains("sample:sample-search: inspect sample data"), + expected_supported + ); + assert_eq!( + developer_text.contains(SAMPLE_PLUGIN_DESCRIPTION), + expected_supported + ); + let (_, echo_tool) = searched_plugin_tools(&requests[1]); + assert_eq!(echo_tool.is_some(), expected_supported); + } + + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn explicit_plugin_mentions_use_apps_for_chatgpt_dual_surface_plugins() -> Result<()> { skip_if_no_network!(Ok(()));