[plugins] Support plugin installation elicitation.

codex-rs/core/src/codex.rs

@@ -292,7 +292,6 @@ use crate::tasks::SessionTask;
 use crate::tasks::SessionTaskContext;
 use crate::tools::ToolRouter;
 use crate::tools::context::SharedTurnDiffTracker;
-use crate::tools::discoverable::DiscoverableTool;
 use crate::tools::js_repl::JsReplHandle;
 use crate::tools::js_repl::resolve_compatible_node;
 use crate::tools::network_approval::NetworkApprovalService;
@@ -6468,11 +6467,14 @@ pub(crate) async fn built_tools(
                 accessible_connectors.as_slice(),
             )
             .await
-            {
-                Ok(connectors) if connectors.is_empty() => None,
-                Ok(connectors) => {
-                    Some(connectors.into_iter().map(DiscoverableTool::from).collect())
-                }
+            .map(|discoverable_tools| {
+                crate::tools::discoverable::filter_tool_suggest_discoverable_tools_for_client(
+                    discoverable_tools,
+                    turn_context.app_server_client_name.as_deref(),
+                )
+            }) {
+                Ok(discoverable_tools) if discoverable_tools.is_empty() => None,
+                Ok(discoverable_tools) => Some(discoverable_tools),
                 Err(err) => {
                     warn!("failed to load discoverable tool suggestions: {err:#}");
                     None

codex-rs/core/src/connectors.rs

@@ -42,24 +42,14 @@ use crate::mcp_connection_manager::McpConnectionManager;
 use crate::mcp_connection_manager::codex_apps_tools_cache_key;
 use crate::plugins::AppConnectorId;
 use crate::plugins::PluginsManager;
+use crate::plugins::list_tool_suggest_discoverable_plugins;
 use crate::token_data::TokenData;
+use crate::tools::discoverable::DiscoverablePluginInfo;
+use crate::tools::discoverable::DiscoverableTool;
 
 pub use codex_connectors::CONNECTORS_CACHE_TTL;
 const CONNECTORS_READY_TIMEOUT_ON_EMPTY_TOOLS: Duration = Duration::from_secs(30);
 const DIRECTORY_CONNECTORS_TIMEOUT: Duration = Duration::from_secs(60);
-const TOOL_SUGGEST_DISCOVERABLE_CONNECTOR_IDS: &[&str] = &[
-    "connector_2128aebfecb84f64a069897515042a44",
-    "connector_68df038e0ba48191908c8434991bbac2",
-    "asdk_app_69a1d78e929881919bba0dbda1f6436d",
-    "connector_4964e3b22e3e427e9b4ae1acf2c1fa34",
-    "connector_9d7cfa34e6654a5f98d3387af34b2e1c",
-    "connector_6f1ec045b8fa4ced8738e32c7f74514b",
-    "connector_947e0d954944416db111db556030eea6",
-    "connector_5f3c8c41a1e54ad7a76272c89e2554fa",
-    "connector_686fad9b54914a35b75be6d06a0f6f31",
-    "connector_76869538009648d5b282a4bb21c3d157",
-    "connector_37316be7febe4224b3d31465bae4dbd7",
-];
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct AppToolPolicy {
@@ -116,13 +106,24 @@ pub(crate) async fn list_tool_suggest_discoverable_tools_with_auth(
     config: &Config,
     auth: Option<&CodexAuth>,
     accessible_connectors: &[AppInfo],
-) -> anyhow::Result<Vec<AppInfo>> {
+) -> anyhow::Result<Vec<DiscoverableTool>> {
     let directory_connectors =
         list_directory_connectors_for_tool_suggest_with_auth(config, auth).await?;
-    Ok(filter_tool_suggest_discoverable_tools(
+    let connector_ids = tool_suggest_connector_ids(config);
+    let discoverable_connectors = filter_tool_suggest_discoverable_connectors(
         directory_connectors,
         accessible_connectors,
-    ))
+        &connector_ids,
+    )
+    .into_iter()
+    .map(DiscoverableTool::from);
+    let discoverable_plugins = list_tool_suggest_discoverable_plugins(config)?
+        .into_iter()
+        .map(DiscoverablePluginInfo::from)
+        .map(DiscoverableTool::from);
+    Ok(discoverable_connectors
+        .chain(discoverable_plugins)
+        .collect())
 }
 
 pub async fn list_cached_accessible_connectors_from_mcp_tools(
@@ -350,24 +351,21 @@ fn write_cached_accessible_connectors(
     });
 }
 
-fn filter_tool_suggest_discoverable_tools(
+fn filter_tool_suggest_discoverable_connectors(
     directory_connectors: Vec<AppInfo>,
     accessible_connectors: &[AppInfo],
+    discoverable_connector_ids: &HashSet<String>,
 ) -> Vec<AppInfo> {
     let accessible_connector_ids: HashSet<&str> = accessible_connectors
         .iter()
-        .filter(|connector| connector.is_accessible && connector.is_enabled)
+        .filter(|connector| connector.is_accessible)
         .map(|connector| connector.id.as_str())
         .collect();
-    let allowed_connector_ids: HashSet<&str> = TOOL_SUGGEST_DISCOVERABLE_CONNECTOR_IDS
-        .iter()
-        .copied()
-        .collect();
 
     let mut connectors = filter_disallowed_connectors(directory_connectors)
         .into_iter()
         .filter(|connector| !accessible_connector_ids.contains(connector.id.as_str()))
-        .filter(|connector| allowed_connector_ids.contains(connector.id.as_str()))
+        .filter(|connector| discoverable_connector_ids.contains(connector.id.as_str()))
         .collect::<Vec<_>>();
     connectors.sort_by(|left, right| {
         left.name
@@ -377,6 +375,16 @@ fn filter_tool_suggest_discoverable_tools(
     connectors
 }
 
+fn tool_suggest_connector_ids(config: &Config) -> HashSet<String> {
+    PluginsManager::new(config.codex_home.clone())
+        .plugins_for_config(config)
+        .capability_summaries()
+        .iter()
+        .flat_map(|plugin| plugin.app_connector_ids.iter())
+        .map(|connector_id| connector_id.0.clone())
+        .collect()
+}
+
 async fn list_directory_connectors_for_tool_suggest_with_auth(
     config: &Config,
     auth: Option<&CodexAuth>,
@@ -675,6 +683,7 @@ pub(crate) fn codex_app_tool_is_enabled(
 const DISALLOWED_CONNECTOR_IDS: &[&str] = &[
     "asdk_app_6938a94a61d881918ef32cb999ff937c",
     "connector_2b0a9009c9c64bf9933a3dae3f2b1254",
+    "connector_3f8d1a79f27c4c7ba1a897ab13bf37dc",
     "connector_68de829bf7648191acd70a907364c67c",
     "connector_68e004f14af881919eb50893d3d9f523",
     "connector_69272cb413a081919685ec3c88d1744e",

codex-rs/core/src/connectors_tests.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::config::CONFIG_TOML_FILE;
 use crate::config::ConfigBuilder;
 use crate::config::types::AppConfig;
 use crate::config::types::AppToolConfig;
@@ -13,13 +14,13 @@ use crate::config_loader::ConfigRequirementsToml;
 use crate::features::Feature;
 use crate::mcp::CODEX_APPS_MCP_SERVER_NAME;
 use crate::mcp_connection_manager::ToolInfo;
-use codex_config::CONFIG_TOML_FILE;
 use codex_utils_absolute_path::AbsolutePathBuf;
 use pretty_assertions::assert_eq;
 use rmcp::model::JsonObject;
 use rmcp::model::Tool;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::sync::Arc;
 use tempfile::tempdir;
 
@@ -957,6 +958,7 @@ fn filter_disallowed_connectors_filters_openai_prefix() {
 fn filter_disallowed_connectors_filters_disallowed_connector_ids() {
     let filtered = filter_disallowed_connectors(vec![
         app("asdk_app_6938a94a61d881918ef32cb999ff937c"),
+        app("connector_3f8d1a79f27c4c7ba1a897ab13bf37dc"),
         app("delta"),
     ]);
     assert_eq!(filtered, vec![app("delta")]);
@@ -979,8 +981,8 @@ fn first_party_chat_originator_filters_target_and_openai_prefixed_connectors() {
 }
 
 #[test]
-fn filter_tool_suggest_discoverable_tools_keeps_only_allowlisted_uninstalled_apps() {
-    let filtered = filter_tool_suggest_discoverable_tools(
+fn filter_tool_suggest_discoverable_connectors_keeps_only_plugin_backed_uninstalled_apps() {
+    let filtered = filter_tool_suggest_discoverable_connectors(
         vec![
             named_app(
                 "connector_2128aebfecb84f64a069897515042a44",
@@ -996,6 +998,10 @@ fn filter_tool_suggest_discoverable_tools_keeps_only_allowlisted_uninstalled_app
                 "Google Calendar",
             )
         }],
+        &HashSet::from([
+            "connector_2128aebfecb84f64a069897515042a44".to_string(),
+            "connector_68df038e0ba48191908c8434991bbac2".to_string(),
+        ]),
     );
 
     assert_eq!(
@@ -1008,8 +1014,8 @@ fn filter_tool_suggest_discoverable_tools_keeps_only_allowlisted_uninstalled_app
 }
 
 #[test]
-fn filter_tool_suggest_discoverable_tools_keeps_disabled_accessible_apps() {
-    let filtered = filter_tool_suggest_discoverable_tools(
+fn filter_tool_suggest_discoverable_connectors_excludes_accessible_apps_even_when_disabled() {
+    let filtered = filter_tool_suggest_discoverable_connectors(
         vec![
             named_app(
                 "connector_2128aebfecb84f64a069897515042a44",
@@ -1031,13 +1037,11 @@ fn filter_tool_suggest_discoverable_tools_keeps_disabled_accessible_apps() {
                 ..named_app("connector_68df038e0ba48191908c8434991bbac2", "Gmail")
             },
         ],
+        &HashSet::from([
+            "connector_2128aebfecb84f64a069897515042a44".to_string(),
+            "connector_68df038e0ba48191908c8434991bbac2".to_string(),
+        ]),
     );
 
-    assert_eq!(
-        filtered,
-        vec![named_app(
-            "connector_68df038e0ba48191908c8434991bbac2",
-            "Gmail"
-        )]
-    );
+    assert_eq!(filtered, Vec::<AppInfo>::new());
 }

codex-rs/core/src/plugins/discoverable.rs

@@ -0,0 +1,72 @@
+use anyhow::Context;
+use tracing::warn;
+
+use super::OPENAI_CURATED_MARKETPLACE_NAME;
+use super::PluginCapabilitySummary;
+use super::PluginReadRequest;
+use super::PluginsManager;
+use crate::config::Config;
+use crate::features::Feature;
+
+const TOOL_SUGGEST_DISCOVERABLE_PLUGIN_ALLOWLIST: &[&str] = &[
+    "github@openai-curated",
+    "notion@openai-curated",
+    "slack@openai-curated",
+    "gmail@openai-curated",
+    "google-calendar@openai-curated",
+    "google-docs@openai-curated",
+    "google-drive@openai-curated",
+    "google-sheets@openai-curated",
+    "google-slides@openai-curated",
+];
+
+pub(crate) fn list_tool_suggest_discoverable_plugins(
+    config: &Config,
+) -> anyhow::Result<Vec<PluginCapabilitySummary>> {
+    if !config.features.enabled(Feature::Plugins) {
+        return Ok(Vec::new());
+    }
+
+    let plugins_manager = PluginsManager::new(config.codex_home.clone());
+    let marketplaces = plugins_manager
+        .list_marketplaces_for_config(config, &[])
+        .context("failed to list plugin marketplaces for tool suggestions")?;
+    let Some(curated_marketplace) = marketplaces
+        .into_iter()
+        .find(|marketplace| marketplace.name == OPENAI_CURATED_MARKETPLACE_NAME)
+    else {
+        return Ok(Vec::new());
+    };
+
+    let mut discoverable_plugins = Vec::<PluginCapabilitySummary>::new();
+    for plugin in curated_marketplace.plugins {
+        if plugin.installed
+            || !TOOL_SUGGEST_DISCOVERABLE_PLUGIN_ALLOWLIST.contains(&plugin.id.as_str())
+        {
+            continue;
+        }
+        let plugin_id = plugin.id.clone();
+        let plugin_name = plugin.name.clone();
+
+        match plugins_manager.read_plugin_for_config(
+            config,
+            &PluginReadRequest {
+                plugin_name,
+                marketplace_path: curated_marketplace.path.clone(),
+            },
+        ) {
+            Ok(plugin) => discoverable_plugins.push(plugin.plugin.into()),
+            Err(err) => warn!("failed to load curated plugin suggestion {plugin_id}: {err:#}"),
+        }
+    }
+    discoverable_plugins.sort_by(|left, right| {
+        left.display_name
+            .cmp(&right.display_name)
+            .then_with(|| left.config_name.cmp(&right.config_name))
+    });
+    Ok(discoverable_plugins)
+}
+
+#[cfg(test)]
+#[path = "discoverable_tests.rs"]
+mod tests;