Lightweight coding agent that runs in your terminal
Rust
Enforce Agent Plugin runtime boundaries (#37027)
jacobzhou-oai56b82e676cc5
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex b2382ed8bf..76d2af28e4 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2923,6 +2923,7 @@ dependencies = ["codex-utils-absolute-path","codex-utils-path-uri","codex-utils-plugins",+ "codex-utils-string","dunce","futures","pretty_assertions",diff --git a/codex-rs/analytics/src/analytics_client_tests.rs b/codex-rs/analytics/src/analytics_client_tests.rsindex 45d83c362c..47707225bc 100644--- a/codex-rs/analytics/src/analytics_client_tests.rs+++ b/codex-rs/analytics/src/analytics_client_tests.rs@@ -5379,6 +5379,7 @@ fn sample_plugin_metadata() -> PluginTelemetryMetadata {capability_summary: Some(PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: None,description: None,has_skills: true,mcp_server_names: vec!["mcp-1".to_string(), "mcp-2".to_string()],diff --git a/codex-rs/app-server/src/request_processors.rs b/codex-rs/app-server/src/request_processors.rsindex 5d9bec815b..57dbb04279 100644--- a/codex-rs/app-server/src/request_processors.rs+++ b/codex-rs/app-server/src/request_processors.rs@@ -458,6 +458,7 @@ use codex_protocol::protocol::W3cTraceContext;use codex_protocol::protocol::strip_user_message_prefix;use codex_protocol::user_input::MAX_USER_INPUT_TEXT_CHARS;use codex_protocol::user_input::UserInput as CoreInputItem;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::perform_oauth_login_return_url;use codex_rollout::is_persisted_rollout_item;use codex_rollout::state_db::StateDbHandle;diff --git a/codex-rs/app-server/src/request_processors/mcp_processor.rs b/codex-rs/app-server/src/request_processors/mcp_processor.rsindex 0ea24d4226..a6281e2227 100644--- a/codex-rs/app-server/src/request_processors/mcp_processor.rs+++ b/codex-rs/app-server/src/request_processors/mcp_processor.rs@@ -149,6 +149,11 @@ impl McpRequestProcessor {"No MCP server named '{name}' found.")));};+ let redirect_mode = if server.is_agent_plugin() {+ StreamableHttpRedirectMode::AgentPluginV1+ } else {+ StreamableHttpRedirectMode::Legacy+ };let server = server.config();let (url, http_headers, env_http_headers) = match &server.transport {@@ -176,6 +181,7 @@ impl McpRequestProcessor {&server.transport,Arc::clone(&http_client),codex_rmcp_client::OAuthDiscoveryTimeout::Requested,+ redirect_mode,).await} else {@@ -199,6 +205,7 @@ impl McpRequestProcessor {mcp_config.mcp_oauth_callback_port,mcp_config.mcp_oauth_callback_url.as_deref(),http_client,+ redirect_mode,).await.map_err(|err| internal_error(format!("failed to login to MCP server '{name}': {err}")))?;diff --git a/codex-rs/app-server/src/request_processors/plugins.rs b/codex-rs/app-server/src/request_processors/plugins.rsindex 20b283d066..45ff3c947a 100644--- a/codex-rs/app-server/src/request_processors/plugins.rs+++ b/codex-rs/app-server/src/request_processors/plugins.rs@@ -12,6 +12,7 @@ use codex_core_plugins::OPENAI_CURATED_MARKETPLACE_NAME;use codex_core_plugins::PluginListBackgroundTaskOptions;use codex_core_plugins::is_openai_curated_marketplace_name;use codex_core_plugins::loader::load_configured_plugin_mcp_servers;+use codex_core_plugins::manifest::is_agent_plugin_manifest;use codex_core_plugins::remote::REMOTE_CREATED_BY_ME_MARKETPLACE_NAME;use codex_core_plugins::remote::REMOTE_GLOBAL_MARKETPLACE_NAME;use codex_core_plugins::remote::REMOTE_WORKSPACE_MARKETPLACE_NAME;@@ -32,10 +33,19 @@ use codex_plugin::PluginId;use codex_plugin::PluginTelemetryMetadata;use codex_protocol::auth::AuthMode as DomainAuthMode;use codex_rmcp_client::OAuthDiscoveryTimeout;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::perform_oauth_login_silent;mod search;+fn plugin_redirect_mode(plugin_root: &Path) -> StreamableHttpRedirectMode {+ if is_agent_plugin_manifest(plugin_root) {+ StreamableHttpRedirectMode::AgentPluginV1+ } else {+ StreamableHttpRedirectMode::Legacy+ }+}+#[derive(Clone)]pub(crate) struct PluginRequestProcessor {auth_manager: Arc<AuthManager>,@@ -1540,8 +1550,14 @@ impl PluginRequestProcessor {).await;if !plugin_mcp_servers.is_empty() {- self.start_plugin_mcp_oauth_logins(&config, &result.plugin_id, plugin_mcp_servers)- .await;+ let redirect_mode = plugin_redirect_mode(result.installed_path.as_path());+ self.start_plugin_mcp_oauth_logins(+ &config,+ &result.plugin_id,+ plugin_mcp_servers,+ redirect_mode,+ )+ .await;}let plugin_app_declarations = load_plugin_apps(result.installed_path.as_path()).await;@@ -1717,8 +1733,14 @@ impl PluginRequestProcessor {).await;if !plugin_mcp_servers.is_empty() {- self.start_plugin_mcp_oauth_logins(&config, &result.plugin_id, plugin_mcp_servers)- .await;+ let redirect_mode = plugin_redirect_mode(result.installed_path.as_path());+ self.start_plugin_mcp_oauth_logins(+ &config,+ &result.plugin_id,+ plugin_mcp_servers,+ redirect_mode,+ )+ .await;}let is_chatgpt_auth = auth.as_ref().is_some_and(CodexAuth::is_chatgpt_auth);@@ -1869,6 +1891,7 @@ impl PluginRequestProcessor {config: &Config,plugin_id: &PluginId,mut plugin_mcp_servers: HashMap<String, McpServerConfig>,+ redirect_mode: StreamableHttpRedirectMode,) {let plugin_id = plugin_id.as_key();config.apply_plugin_mcp_server_requirements(&plugin_id, &mut plugin_mcp_servers);@@ -1900,6 +1923,7 @@ impl PluginRequestProcessor {&server.transport,Arc::clone(&http_client),OAuthDiscoveryTimeout::LOCAL,+ redirect_mode,).await;let oauth_config = match login_support {@@ -1944,6 +1968,7 @@ impl PluginRequestProcessor {callback_port,callback_url.as_deref(),Arc::clone(&http_client),+ redirect_mode,).await;@@ -1962,6 +1987,7 @@ impl PluginRequestProcessor {callback_port,callback_url.as_deref(),http_client,+ redirect_mode,).await}diff --git a/codex-rs/app-server/tests/suite/v2/plugin_install.rs b/codex-rs/app-server/tests/suite/v2/plugin_install.rsindex a8e76d28e4..974d7de49b 100644--- a/codex-rs/app-server/tests/suite/v2/plugin_install.rs+++ b/codex-rs/app-server/tests/suite/v2/plugin_install.rs@@ -2927,7 +2927,7 @@ fn remote_plugin_bundle_tar_gz_bytes_with_entries(app_manifest: Option<&str>,mcp_config: Option<&str>,) -> Result<Vec<u8>> {- let skill = "# Plan Work\n\nTrack work in Linear.\n";+ let skill = "---\nname: plan-work\ndescription: Track work in Linear.\n---\n\n# Plan Work\n";let encoder = GzEncoder::new(Vec::new(), Compression::default());let mut tar = tar::Builder::new(encoder);let mut entries = vec![diff --git a/codex-rs/cli/src/mcp_cmd.rs b/codex-rs/cli/src/mcp_cmd.rsindex 2ebd737cf7..ec51a8452e 100644--- a/codex-rs/cli/src/mcp_cmd.rs+++ b/codex-rs/cli/src/mcp_cmd.rs@@ -32,6 +32,7 @@ use codex_mcp::resolve_oauth_scopes;use codex_mcp::should_retry_without_scopes;use codex_protocol::protocol::McpAuthStatus;use codex_rmcp_client::OAuthDiscoveryTimeout;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::delete_oauth_tokens;use codex_rmcp_client::perform_oauth_login;use codex_utils_cli::CliConfigOverrides;@@ -406,6 +407,7 @@ async fn run_add(config_overrides: &CliConfigOverrides, add_args: AddArgs) -> Re&transport,Arc::clone(&http_client),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await;match login_support {@@ -511,6 +513,7 @@ async fn run_login(config: &Config, login_args: LoginArgs) -> Result<()> {&server.transport,Arc::clone(&http_client),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await} else {diff --git a/codex-rs/codex-mcp/src/catalog.rs b/codex-rs/codex-mcp/src/catalog.rsindex d60ea843df..274b0eb001 100644--- a/codex-rs/codex-mcp/src/catalog.rs+++ b/codex-rs/codex-mcp/src/catalog.rs@@ -10,6 +10,7 @@ use codex_config::McpServerConfig;pub struct McpPluginAttribution {plugin_id: String,display_name: String,+ agent_plugin: bool,}impl McpPluginAttribution {@@ -17,6 +18,15 @@ impl McpPluginAttribution {Self {plugin_id,display_name,+ agent_plugin: false,+ }+ }++ pub fn agent_plugin(plugin_id: String, display_name: String) -> Self {+ Self {+ plugin_id,+ display_name,+ agent_plugin: true,}}@@ -27,6 +37,10 @@ impl McpPluginAttribution {pub fn display_name(&self) -> &str {&self.display_name}++ pub fn is_agent_plugin(&self) -> bool {+ self.agent_plugin+ }}/// The component that declared an MCP server registration.@@ -46,6 +60,15 @@ pub enum McpServerSource {}impl McpServerSource {+ pub fn is_agent_plugin(&self) -> bool {+ match self {+ Self::Plugin(attribution) | Self::SelectedPlugin(attribution) => {+ attribution.is_agent_plugin()+ }+ Self::Config | Self::Compatibility { .. } | Self::Extension { .. } => false,+ }+ }+fn disabled_registration_is_name_veto(&self) -> bool {// A selected package's policy applies to its registration, not to a higher runtime source// that happens to use the same logical server name.diff --git a/codex-rs/codex-mcp/src/mcp/auth.rs b/codex-rs/codex-mcp/src/mcp/auth.rsindex 9e093e8d88..6fac47c293 100644--- a/codex-rs/codex-mcp/src/mcp/auth.rs+++ b/codex-rs/codex-mcp/src/mcp/auth.rs@@ -12,6 +12,7 @@ use codex_login::CodexAuth;use codex_rmcp_client::McpAuthState;use codex_rmcp_client::OAuthDiscoveryTimeout;use codex_rmcp_client::OAuthProviderError;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::determine_streamable_http_auth_status;use codex_rmcp_client::discover_streamable_http_oauth;use futures::FutureExt;@@ -61,6 +62,7 @@ pub async fn oauth_login_support(transport: &McpServerTransportConfig,http_client: Arc<dyn HttpClient>,discovery_timeout: OAuthDiscoveryTimeout,+ redirect_mode: StreamableHttpRedirectMode,) -> McpOAuthLoginSupport {let Some(mut config) = oauth_login_candidate(transport) else {return McpOAuthLoginSupport::Unsupported;@@ -71,6 +73,7 @@ pub async fn oauth_login_support(config.env_http_headers.clone(),http_client,discovery_timeout,+ redirect_mode,).await{@@ -108,8 +111,9 @@ pub async fn discover_supported_scopes(transport: &McpServerTransportConfig,http_client: Arc<dyn HttpClient>,discovery_timeout: OAuthDiscoveryTimeout,+ redirect_mode: StreamableHttpRedirectMode,) -> Option<Vec<String>> {- match oauth_login_support(transport, http_client, discovery_timeout).await {+ match oauth_login_support(transport, http_client, discovery_timeout, redirect_mode).await {McpOAuthLoginSupport::Supported(config) => config.discovered_scopes,McpOAuthLoginSupport::Unsupported | McpOAuthLoginSupport::Unknown(_) => None,}@@ -166,6 +170,11 @@ where{let futures = servers.into_iter().map(|(name, server)| {let name = name.clone();+ let redirect_mode = if server.is_agent_plugin() {+ StreamableHttpRedirectMode::AgentPluginV1+ } else {+ StreamableHttpRedirectMode::Legacy+ };let config = server.config().clone();let runtime_context = runtime_context.clone();let has_runtime_auth = matches!(&config.auth, McpServerAuth::ChatGpt)@@ -185,6 +194,7 @@ wherekeyring_backend_kind,has_runtime_auth,&runtime_context,+ redirect_mode,).await{@@ -212,6 +222,7 @@ async fn compute_auth_status(keyring_backend_kind: AuthKeyringBackendKind,has_runtime_auth: bool,runtime_context: &McpRuntimeContext,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<McpAuthState> {if !config.enabled {return Ok(McpAuthState::Unsupported);@@ -256,6 +267,7 @@ async fn compute_auth_status(keyring_backend_kind,http_client,discovery_timeout,+ redirect_mode,).boxed().awaitdiff --git a/codex-rs/codex-mcp/src/mcp/mod.rs b/codex-rs/codex-mcp/src/mcp/mod.rsindex b9c94326c5..6bddbf24c8 100644--- a/codex-rs/codex-mcp/src/mcp/mod.rs+++ b/codex-rs/codex-mcp/src/mcp/mod.rs@@ -321,7 +321,14 @@ pub fn effective_mcp_servers_from_configured(}McpServerAuth::OAuth => {}}- (name, EffectiveMcpServer::configured(server))+ let agent_plugin = config+ .mcp_server_catalog+ .server(&name)+ .is_some_and(|server| server.source().is_agent_plugin());+ (+ name,+ EffectiveMcpServer::configured(server).with_agent_plugin(agent_plugin),+ )}).collect::<HashMap<_, _>>();if !host_owned_codex_apps_enabled(config, auth) {diff --git a/codex-rs/codex-mcp/src/mcp/mod_tests.rs b/codex-rs/codex-mcp/src/mcp/mod_tests.rsindex f27319de20..b6f454647b 100644--- a/codex-rs/codex-mcp/src/mcp/mod_tests.rs+++ b/codex-rs/codex-mcp/src/mcp/mod_tests.rs@@ -148,6 +148,7 @@ fn tool_plugin_provenance_collects_app_and_mcp_sources() {PluginCapabilitySummary {config_name: "alpha@test".to_string(),display_name: "alpha-plugin".to_string(),+ plugin_namespace: None,app_connector_ids: vec![AppConnectorId("connector_example".to_string())],mcp_server_names: vec!["alpha".to_string()],..PluginCapabilitySummary::default()@@ -155,6 +156,7 @@ fn tool_plugin_provenance_collects_app_and_mcp_sources() {PluginCapabilitySummary {config_name: "beta@test".to_string(),display_name: "beta-plugin".to_string(),+ plugin_namespace: None,app_connector_ids: vec![AppConnectorId("connector_example".to_string()),AppConnectorId("connector_gmail".to_string()),@@ -219,6 +221,7 @@ fn selected_mcp_attribution_does_not_join_an_unrelated_local_summary() {PluginCapabilitySummary {config_name: "shared-plugin-id".to_string(),display_name: "Local GitHub".to_string(),+ plugin_namespace: None,mcp_server_names: vec!["github".to_string()],..PluginCapabilitySummary::default()},diff --git a/codex-rs/codex-mcp/src/rmcp_client.rs b/codex-rs/codex-mcp/src/rmcp_client.rsindex ae831c1026..d5e25977c3 100644--- a/codex-rs/codex-mcp/src/rmcp_client.rs+++ b/codex-rs/codex-mcp/src/rmcp_client.rs@@ -59,6 +59,7 @@ use codex_rmcp_client::LocalStdioServerLauncher;use codex_rmcp_client::McpProtocolMode;use codex_rmcp_client::RmcpClient;use codex_rmcp_client::StdioServerLauncher;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::ToolWithConnectorId;use codex_rmcp_client::is_authentication_required_error;use futures::future::BoxFuture;@@ -1084,7 +1085,12 @@ async fn make_rmcp_client(Ok(token) => token,Err(error) => return Err(error.into()),};- RmcpClient::new_streamable_http_client_with_protocol_mode(+ let redirect_mode = if server.is_agent_plugin() {+ StreamableHttpRedirectMode::AgentPluginV1+ } else {+ StreamableHttpRedirectMode::Legacy+ };+ RmcpClient::new_streamable_http_client_with_protocol_mode_and_redirect_mode(oauth_credential_name.as_ref(),&url,resolved_bearer_token,@@ -1095,6 +1101,7 @@ async fn make_rmcp_client(http_client,runtime_auth_provider,protocol_mode,+ redirect_mode,).await.map_err(StartupOutcomeError::from)diff --git a/codex-rs/codex-mcp/src/server.rs b/codex-rs/codex-mcp/src/server.rsindex c00e786c06..e12f906e97 100644--- a/codex-rs/codex-mcp/src/server.rs+++ b/codex-rs/codex-mcp/src/server.rs@@ -24,11 +24,20 @@ use tracing::warn;#[derive(Debug, Clone)]pub struct EffectiveMcpServer {config: McpServerConfig,+ agent_plugin: bool,}impl EffectiveMcpServer {pub fn configured(config: McpServerConfig) -> Self {- Self { config }+ Self {+ config,+ agent_plugin: false,+ }+ }++ pub fn with_agent_plugin(mut self, agent_plugin: bool) -> Self {+ self.agent_plugin = agent_plugin;+ self}pub fn config(&self) -> &McpServerConfig {@@ -42,6 +51,10 @@ impl EffectiveMcpServer {pub fn required(&self) -> bool {self.config.required}++ pub fn is_agent_plugin(&self) -> bool {+ self.agent_plugin+ }}pub(crate) fn has_explicit_http_authorization(config: &McpServerConfig) -> bool {@@ -92,6 +105,7 @@ pub(crate) struct McpServerConnectionIdentity {codex_apps_cache_identity: Option<(PathBuf, ConnectorRuntimeContextKey)>,client_elicitation_capability: ElicitationCapability,client_mcp_extensions: ClientMcpExtensions,+ agent_plugin: bool,}impl McpServerConnectionIdentity {@@ -165,6 +179,7 @@ impl McpServerConnectionIdentity {codex_apps_cache_identity,client_elicitation_capability,client_mcp_extensions,+ agent_plugin: server.is_agent_plugin(),}}@@ -193,6 +208,7 @@ impl McpServerConnectionIdentity {&& self.codex_apps_cache_identity == other.codex_apps_cache_identity&& self.client_elicitation_capability == other.client_elicitation_capability&& self.client_mcp_extensions == other.client_mcp_extensions+ && self.agent_plugin == other.agent_plugin}pub(crate) fn oauth_credentials(&self) -> Result<&Option<StoredOAuthTokens>, &String> {diff --git a/codex-rs/core-plugins/src/loader.rs b/codex-rs/core-plugins/src/loader.rsindex 471ebcc20f..c1ddf91a94 100644--- a/codex-rs/core-plugins/src/loader.rs+++ b/codex-rs/core-plugins/src/loader.rs@@ -3,10 +3,11 @@ use crate::app_mcp_routing::apps_route_available;use crate::command_migration::migrated_command_skills_root;use crate::is_openai_curated_marketplace_name;use crate::manifest::PluginManifest;+use crate::manifest::PluginManifestFormat;use crate::manifest::PluginManifestHooks;use crate::manifest::PluginManifestMcpServers;use crate::manifest::PluginManifestPaths;-use crate::manifest::load_plugin_manifest;+use crate::manifest::load_plugin_manifest_with_format;use crate::marketplace::MarketplacePluginSource;use crate::marketplace::find_marketplace_plugin;use crate::marketplace::list_marketplaces_with_home;@@ -23,6 +24,7 @@ use crate::store::plugin_version_for_source_with_fallback_manifest;use codex_config::ConfigLayerStack;use codex_config::HooksFile;use codex_config::types::McpServerConfig;+use codex_config::types::McpServerTransportConfig;use codex_config::types::PluginConfig;use codex_config::types::PluginMcpServerConfig;use codex_connectors::parse_plugin_app_config;@@ -33,6 +35,7 @@ use codex_core_skills::config_rules::skill_config_rules_from_stack;use codex_core_skills::loader::SkillRoot;use codex_core_skills::loader::load_skills_from_roots;use codex_exec_server::LOCAL_FS;+use codex_mcp::parse_agent_plugin_mcp_config;use codex_mcp::parse_plugin_mcp_config;use codex_plugin::AppDeclaration;use codex_plugin::LoadedPlugin;@@ -831,6 +834,7 @@ async fn load_plugin(root,enabled: plugin.enabled,skill_roots: Vec::new(),+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: false,mcp_servers: HashMap::new(),@@ -873,12 +877,19 @@ async fn load_plugin(return loaded_plugin;}- let Some(manifest) = load_plugin_manifest(plugin_root.as_path()) else {+ let Some(loaded_manifest) = load_plugin_manifest_with_format(plugin_root.as_path()) else {loaded_plugin.error = Some("missing or invalid plugin.json".to_string());return loaded_plugin;};+ loaded_plugin.skill_discovery_mode = match loaded_manifest.format {+ PluginManifestFormat::Legacy => SkillDiscoveryMode::Recursive,+ PluginManifestFormat::AgentPlugin => SkillDiscoveryMode::DirectChildren,+ };+ let manifest = loaded_manifest.manifest;let manifest_paths = &manifest.paths;+ let plugin_data_root = store.plugin_data_root(&loaded_plugin_id);+ let mcp_plugin_data_root = store.mcp_data_root(&loaded_plugin_id, loaded_manifest.format);loaded_plugin.plugin_namespace = Some(manifest.name.clone());match scope {PluginLoadScope::AllCapabilities {@@ -890,40 +901,51 @@ async fn load_plugin(} => {loaded_plugin.manifest_name = Some(manifest.display_name().to_string());loaded_plugin.manifest_description = manifest.description.clone();- loaded_plugin.skill_roots = plugin_skill_roots(&plugin_root, manifest_paths);+ loaded_plugin.skill_roots =+ plugin_skill_roots(&plugin_root, manifest_paths, loaded_manifest.format);let plugin_identity = PluginIdentity {plugin_id: loaded_plugin_id.as_key(),remote_plugin_id: loaded_plugin.remote_plugin_id.clone(),};- let resolved_skills = load_plugin_skills_with_identity(+ let resolved_skills = load_plugin_skill_inventory(&plugin_root,&plugin_identity,&manifest,+ loaded_manifest.format,*restriction_product,- skill_config_rules,*plugin_skill_snapshots,Arc::clone(root_scan_slots),)- .await;+ .await+ .resolve(skill_config_rules);let has_enabled_skills = resolved_skills.has_enabled_skills();loaded_plugin.disabled_skill_paths = resolved_skills.disabled_skill_paths;loaded_plugin.has_enabled_skills = has_enabled_skills;- loaded_plugin.mcp_servers = load_plugin_mcp_servers_from_manifest(+ loaded_plugin.mcp_servers = load_plugin_mcp_servers_from_manifest_with_format(plugin_root.as_path(),manifest_paths,Some(&plugin.mcp_servers),+ Some(mcp_plugin_data_root.as_path()),+ loaded_manifest.format,).await;- loaded_plugin.apps = load_plugin_apps(plugin_root.as_path()).await;+ if loaded_manifest.format == PluginManifestFormat::Legacy {+ loaded_plugin.apps = load_plugin_apps(plugin_root.as_path()).await;+ }}PluginLoadScope::HooksOnly => {}}- let (hook_sources, hook_load_warnings) = load_plugin_hooks(- &plugin_root,- &loaded_plugin_id,- &store.plugin_data_root(&loaded_plugin_id),- manifest_paths,- );+ let (hook_sources, hook_load_warnings) =+ if loaded_manifest.format == PluginManifestFormat::AgentPlugin {+ (Vec::new(), Vec::new())+ } else {+ load_plugin_hooks(+ &plugin_root,+ &loaded_plugin_id,+ &plugin_data_root,+ manifest_paths,+ )+ };loaded_plugin.hook_sources = hook_sources;loaded_plugin.hook_load_warnings = hook_load_warnings;loaded_plugin@@ -961,7 +983,7 @@ impl PluginSkillInventory {)}- fn resolve(self, skill_config_rules: &SkillConfigRules) -> ResolvedPluginSkills {+ pub(crate) fn resolve(self, skill_config_rules: &SkillConfigRules) -> ResolvedPluginSkills {let disabled_skill_paths = resolve_disabled_skill_paths(&self.skills, skill_config_rules);ResolvedPluginSkills {skills: self.skills,@@ -1031,6 +1053,7 @@ pub(crate) async fn load_plugin_skills_with_identity(plugin_root,plugin_identity,manifest,+ PluginManifestFormat::Legacy,restriction_product,plugin_skill_snapshots,root_scan_slots,@@ -1043,11 +1066,16 @@ pub(crate) async fn load_plugin_skill_inventory(plugin_root: &AbsolutePathBuf,plugin_identity: &PluginIdentity,manifest: &PluginManifest,+ manifest_format: PluginManifestFormat,restriction_product: Option<Product>,plugin_skill_snapshots: Option<&PluginSkillSnapshots>,root_scan_slots: Arc<Semaphore>,) -> PluginSkillInventory {- let roots = plugin_skill_roots(plugin_root, &manifest.paths)+ let discovery_mode = match manifest_format {+ PluginManifestFormat::Legacy => SkillDiscoveryMode::Recursive,+ PluginManifestFormat::AgentPlugin => SkillDiscoveryMode::DirectChildren,+ };+ let roots = plugin_skill_roots(plugin_root, &manifest.paths, manifest_format).into_iter().map(|path| SkillRoot {path,@@ -1056,7 +1084,7 @@ pub(crate) async fn load_plugin_skill_inventory(plugin_identity: Some(plugin_identity.clone()),plugin_namespace: Some(manifest.name.clone()),plugin_root: Some(plugin_root.clone()),- discovery_mode: SkillDiscoveryMode::Recursive,+ discovery_mode,}).collect::<Vec<_>>();let outcome = load_skills_from_roots(roots, plugin_skill_snapshots, root_scan_slots).await;@@ -1098,15 +1126,18 @@ pub(crate) async fn load_plugin_skill_inventory(fn plugin_skill_roots(plugin_root: &AbsolutePathBuf,manifest_paths: &PluginManifestPaths,+ manifest_format: PluginManifestFormat,) -> Vec<AbsolutePathBuf> {let mut paths = if manifest_paths.skills.is_empty() {default_skill_roots(plugin_root)} else {manifest_paths.skills.clone()};- let migrated_command_skills = migrated_command_skills_root(plugin_root);- if migrated_command_skills.is_dir() {- paths.push(migrated_command_skills);+ if manifest_format == PluginManifestFormat::Legacy {+ let migrated_command_skills = migrated_command_skills_root(plugin_root);+ if migrated_command_skills.is_dir() {+ paths.push(migrated_command_skills);+ }}paths.sort_unstable();paths.dedup();@@ -1146,8 +1177,11 @@ fn default_mcp_config_paths(plugin_root: &Path) -> Vec<AbsolutePathBuf> {}pub async fn load_plugin_apps(plugin_root: &Path) -> Vec<AppDeclaration> {- if let Some(manifest) = load_plugin_manifest(plugin_root) {- return load_plugin_apps_from_manifest(plugin_root, &manifest.paths).await;+ if let Some(loaded_manifest) = load_plugin_manifest_with_format(plugin_root) {+ if loaded_manifest.format == PluginManifestFormat::AgentPlugin {+ return Vec::new();+ }+ return load_plugin_apps_from_manifest(plugin_root, &loaded_manifest.manifest.paths).await;}load_apps_from_paths(plugin_root, default_app_config_paths(plugin_root)).await}@@ -1345,14 +1379,40 @@ pub async fn plugin_capability_summary_from_root(plugin_id: &PluginId,plugin_root: &AbsolutePathBuf,) -> Option<PluginCapabilitySummary> {- let manifest = load_plugin_manifest(plugin_root.as_path())?;+ let loaded_manifest = load_plugin_manifest_with_format(plugin_root.as_path())?;+ let manifest_format = loaded_manifest.format;+ let manifest = loaded_manifest.manifest;+ let plugin_identity = PluginIdentity {+ plugin_id: plugin_id.as_key(),+ remote_plugin_id: None,+ };let manifest_paths = &manifest.paths;- let has_skills = !plugin_skill_roots(plugin_root, manifest_paths).is_empty();- let mut mcp_server_names = load_plugin_mcp_servers_from_manifest(+ let has_skills = match manifest_format {+ PluginManifestFormat::Legacy => {+ !plugin_skill_roots(plugin_root, manifest_paths, manifest_format).is_empty()+ }+ PluginManifestFormat::AgentPlugin => {+ !load_plugin_skill_inventory(+ plugin_root,+ &plugin_identity,+ &manifest,+ manifest_format,+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ Arc::new(Semaphore::new(1)),+ )+ .await+ .skills+ .is_empty()+ }+ };+ let mut mcp_server_names = load_plugin_mcp_servers_from_manifest_with_format(plugin_root.as_path(),manifest_paths,/*plugin_policy*/ None,+ /*plugin_data_root*/ None,+ manifest_format,).await.into_keys()@@ -1360,16 +1420,17 @@ pub async fn plugin_capability_summary_from_root(mcp_server_names.sort_unstable();mcp_server_names.dedup();- let app_declarations = load_apps_from_paths(- plugin_root.as_path(),- plugin_app_config_paths(plugin_root.as_path(), manifest_paths),- )- .await;+ let app_declarations = if manifest_format == PluginManifestFormat::AgentPlugin {+ Vec::new()+ } else {+ load_plugin_apps_from_manifest(plugin_root.as_path(), manifest_paths).await+ };let app_connector_ids = app_connector_ids_from_declarations(&app_declarations);Some(PluginCapabilitySummary {config_name: plugin_id.as_key(),display_name: plugin_id.plugin_name.clone(),+ plugin_namespace: Some(manifest.name.clone()),description: None,has_skills,mcp_server_names,@@ -1426,17 +1487,26 @@ async fn load_declared_plugin_mcp_servers(plugin_root: &Path,plugin_policy: Option<&HashMap<String, PluginMcpServerConfig>>,) -> HashMap<String, McpServerConfig> {- let Some(manifest) = load_plugin_manifest(plugin_root) else {+ let Some(loaded_manifest) = load_plugin_manifest_with_format(plugin_root) else {return HashMap::new();};- load_plugin_mcp_servers_from_manifest(plugin_root, &manifest.paths, plugin_policy).await+ load_plugin_mcp_servers_from_manifest_with_format(+ plugin_root,+ &loaded_manifest.manifest.paths,+ plugin_policy,+ /*plugin_data_root*/ None,+ loaded_manifest.format,+ )+ .await}-pub(crate) async fn load_plugin_mcp_servers_from_manifest(+pub(crate) async fn load_plugin_mcp_servers_from_manifest_with_format(plugin_root: &Path,manifest_paths: &PluginManifestPaths,plugin_policy: Option<&HashMap<String, PluginMcpServerConfig>>,+ plugin_data_root: Option<&Path>,+ manifest_format: PluginManifestFormat,) -> HashMap<String, McpServerConfig> {let mut mcp_servers = HashMap::new();match &manifest_paths.mcp_servers {@@ -1457,7 +1527,13 @@ pub(crate) async fn load_plugin_mcp_servers_from_manifest(}Some(PluginManifestMcpServers::Path(_)) | None => {for mcp_config_path in plugin_mcp_config_paths(plugin_root, manifest_paths) {- let plugin_mcp = load_mcp_servers_from_file(plugin_root, &mcp_config_path).await;+ let plugin_mcp = load_mcp_servers_from_file(+ plugin_root,+ plugin_data_root,+ manifest_format,+ &mcp_config_path,+ )+ .await;for (name, mut config) in plugin_mcp.mcp_servers {if let Some(policy) = plugin_policy.and_then(|policy| policy.get(&name)) {apply_plugin_mcp_server_policy(&mut config, policy);@@ -1480,12 +1556,74 @@ pub(crate) async fn load_plugin_mcp_servers_from_manifest(async fn load_mcp_servers_from_file(plugin_root: &Path,+ plugin_data_root: Option<&Path>,+ manifest_format: PluginManifestFormat,mcp_config_path: &AbsolutePathBuf,) -> PluginMcpDiscovery {+ let is_agent_plugin_mcp = manifest_format == PluginManifestFormat::AgentPlugin;+ if is_agent_plugin_mcp {+ match tokio::fs::symlink_metadata(mcp_config_path.as_path()).await {+ Ok(metadata) if metadata.file_type().is_symlink() || !metadata.is_file() => {+ warn!(+ path = %mcp_config_path.display(),+ "Agent Plugins MCP config is not a regular file; disabling MCP"+ );+ return PluginMcpDiscovery::default();+ }+ Ok(_) => {}+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => {+ return PluginMcpDiscovery::default();+ }+ Err(err) => {+ warn!(+ path = %mcp_config_path.display(),+ "failed to inspect Agent Plugins MCP config; disabling MCP: {err}"+ );+ return PluginMcpDiscovery::default();+ }+ }+ let resolved_root = match tokio::fs::canonicalize(plugin_root).await {+ Ok(path) => path,+ Err(err) => {+ warn!(+ plugin = %plugin_root.display(),+ "failed to resolve Agent Plugins root; disabling MCP: {err}"+ );+ return PluginMcpDiscovery::default();+ }+ };+ let resolved_config = match tokio::fs::canonicalize(mcp_config_path.as_path()).await {+ Ok(path) => path,+ Err(err) => {+ warn!(+ path = %mcp_config_path.display(),+ "failed to resolve Agent Plugins MCP config; disabling MCP: {err}"+ );+ return PluginMcpDiscovery::default();+ }+ };+ if !resolved_config.starts_with(&resolved_root) {+ warn!(+ plugin = %plugin_root.display(),+ path = %mcp_config_path.display(),+ "Agent Plugins MCP config resolves outside the plugin root; disabling MCP"+ );+ return PluginMcpDiscovery::default();+ }+ }let Ok(contents) = tokio::fs::read_to_string(mcp_config_path.as_path()).await else {return PluginMcpDiscovery::default();};- let parsed = match parse_plugin_mcp_config(plugin_root, &contents) {+ let fallback_data_root = plugin_root.join(".plugin-data");+ let mut parsed = match if is_agent_plugin_mcp {+ parse_agent_plugin_mcp_config(+ plugin_root,+ plugin_data_root.unwrap_or(&fallback_data_root),+ &contents,+ )+ } else {+ parse_plugin_mcp_config(plugin_root, &contents)+ } {Ok(parsed) => parsed,Err(err) => {warn!(@@ -1495,6 +1633,23 @@ async fn load_mcp_servers_from_file(return PluginMcpDiscovery::default();}};+ if is_agent_plugin_mcp+ && let Some(plugin_data_root) = plugin_data_root+ && parsed+ .servers+ .values()+ .any(|server| matches!(&server.transport, McpServerTransportConfig::Stdio { .. }))+ && let Err(err) = tokio::fs::create_dir_all(plugin_data_root).await+ {+ warn!(+ plugin = %plugin_root.display(),+ path = %plugin_data_root.display(),+ "failed to create Agent Plugins data directory; disabling stdio MCP servers: {err}"+ );+ parsed.servers.retain(|_, server| {+ !matches!(&server.transport, McpServerTransportConfig::Stdio { .. })+ });+ }for error in parsed.errors {warn!(plugin = %plugin_root.display(),diff --git a/codex-rs/core-plugins/src/loader_tests.rs b/codex-rs/core-plugins/src/loader_tests.rsindex cfc5c892da..5150a6cec2 100644--- a/codex-rs/core-plugins/src/loader_tests.rs+++ b/codex-rs/core-plugins/src/loader_tests.rs@@ -1,5 +1,6 @@use super::*;use crate::manifest::load_plugin_manifest;+use crate::manifest::load_plugin_manifest_with_format;use crate::test_support::write_file;use codex_config::ConfigLayerEntry;use codex_config::ConfigLayerSource;@@ -7,6 +8,7 @@ use codex_config::ConfigRequirements;use codex_config::ConfigRequirementsToml;use codex_core_skills::loader::MAX_CONCURRENT_ROOT_SCANS;use codex_plugin::PluginId;+use codex_utils_plugins::AGENT_PLUGIN_SCHEMA_URI;use pretty_assertions::assert_eq;use tempfile::TempDir;@@ -25,6 +27,177 @@ fn user_layer(path: AbsolutePathBuf, config: &str) -> ConfigLayerEntry {)}+#[tokio::test]+async fn agent_plugin_overlay_apps_are_not_runtime_active() {+ let temp_dir = TempDir::new().expect("tempdir");+ let plugin_root = temp_dir.path().join("plugin");+ write_file(+ &plugin_root.join("plugin.json"),+ &format!(r#"{{"$schema":"{AGENT_PLUGIN_SCHEMA_URI}","name":"plugin"}}"#),+ );+ write_file(+ &plugin_root.join(".codex-plugin/plugin.json"),+ r#"{"name":"plugin","apps":"./.app.json"}"#,+ );+ write_file(+ &plugin_root.join(".app.json"),+ r#"{"apps":{"example":{"id":"connector_example"}}}"#,+ );++ assert!(load_plugin_apps(&plugin_root).await.is_empty());+}++#[cfg(unix)]+#[tokio::test]+async fn agent_plugin_mcp_rejects_config_symlink_outside_plugin_root() {+ let temp_dir = TempDir::new().expect("tempdir");+ let plugin_root = temp_dir.path().join("plugin");+ let outside_config = temp_dir.path().join("outside-mcp.json");+ fs::create_dir_all(&plugin_root).expect("create plugin root");+ fs::write(+ plugin_root.join("plugin.json"),+ format!(r#"{{"$schema":"{AGENT_PLUGIN_SCHEMA_URI}","name":"plugin"}}"#),+ )+ .expect("write Agent Plugins manifest");+ fs::write(+ &outside_config,+ r#"{"$schema":"https://agent-plugins.org/schemas/1.0.0/mcp.schema.json","mcpServers":{"outside":{"type":"stdio","command":"echo"}}}"#,+ )+ .expect("write outside MCP config");+ std::os::unix::fs::symlink(&outside_config, plugin_root.join("mcp.json"))+ .expect("create MCP symlink");+ let config_path = AbsolutePathBuf::from_absolute_path(plugin_root.join("mcp.json"))+ .expect("absolute MCP path");++ let discovered = load_mcp_servers_from_file(+ &plugin_root,+ /*plugin_data_root*/ None,+ PluginManifestFormat::AgentPlugin,+ &config_path,+ )+ .await;++ assert!(discovered.mcp_servers.is_empty());+}++#[tokio::test]+async fn agent_plugin_mcp_rejects_present_nonregular_config() {+ let temp_dir = TempDir::new().expect("tempdir");+ let plugin_root = temp_dir.path().join("plugin");+ let config_path = plugin_root.join("mcp.json");+ fs::create_dir_all(&config_path).expect("create nonregular MCP config");++ let discovered = load_mcp_servers_from_file(+ &plugin_root,+ /*plugin_data_root*/ None,+ PluginManifestFormat::AgentPlugin,+ &AbsolutePathBuf::from_absolute_path(config_path).expect("absolute MCP path"),+ )+ .await;++ assert!(discovered.mcp_servers.is_empty());+}++#[tokio::test]+async fn legacy_manifest_can_point_at_root_mcp_json() {+ let temp_dir = TempDir::new().expect("tempdir");+ let plugin_root = temp_dir.path().join("plugin");+ fs::create_dir_all(plugin_root.join(".codex-plugin")).expect("create manifest directory");+ fs::write(+ plugin_root.join(".codex-plugin/plugin.json"),+ r#"{"name":"plugin","mcpServers":"./mcp.json"}"#,+ )+ .expect("write legacy manifest");+ fs::write(+ plugin_root.join("mcp.json"),+ r#"{"mcpServers":{"legacy":{"command":"echo"}}}"#,+ )+ .expect("write legacy MCP config");+ let manifest = load_plugin_manifest(&plugin_root).expect("load legacy manifest");++ let discovered = load_plugin_mcp_servers_from_manifest_with_format(+ &plugin_root,+ &manifest.paths,+ /*plugin_policy*/ None,+ /*plugin_data_root*/ None,+ PluginManifestFormat::Legacy,+ )+ .await;++ assert_eq!(+ discovered.keys().collect::<Vec<_>>(),+ vec![&"legacy".to_string()]+ );+}++#[tokio::test]+async fn installed_agent_plugin_uses_isolated_data_root_for_stdio_mcp() {+ let temp_dir = TempDir::new().expect("tempdir");+ let plugin_root = temp_dir.path().join("plugins/cache/c/a-b/local");+ write_file(+ &plugin_root.join("plugin.json"),+ &format!(r#"{{"$schema":"{AGENT_PLUGIN_SCHEMA_URI}","name":"a-b"}}"#),+ );+ write_file(+ &plugin_root.join("mcp.json"),+ r#"{+ "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",+ "mcpServers": {+ "example": {+ "type": "stdio",+ "command": "echo"+ }+ }+}"#,+ );+ let stack = ConfigLayerStack::new(+ vec![user_layer(+ user_config_path(&temp_dir, "config.toml"),+ "[plugins.\"a-b@c\"]\nenabled = true\n",+ )],+ ConfigRequirements::default(),+ ConfigRequirementsToml::default(),+ )+ .expect("valid config layer stack");+ let store = PluginStore::new(temp_dir.path().to_path_buf());++ let plugins = load_plugins_from_layer_stack(+ &stack,+ RemoteInstalledPluginsSnapshot::default(),+ &store,+ /*plugin_skill_snapshots*/ None,+ Some(Product::Codex),+ /*remote_global_catalog_active*/ false,+ Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),+ )+ .await;++ let expected_data_root = temp_dir+ .path()+ .join("plugins")+ .join("data")+ .join("agent-plugins")+ .join("6920dd17774030852d11d1b94758fcaae4f894c7b2f36301ed174bc3b33e0743");+ let expected_data_root = AbsolutePathBuf::from_absolute_path(expected_data_root)+ .expect("absolute Agent Plugin data root")+ .canonicalize()+ .expect("canonical Agent Plugin data root");+ let server = plugins+ .first()+ .and_then(|plugin| plugin.mcp_servers.get("example"))+ .expect("Agent plugin stdio MCP server");+ let McpServerTransportConfig::Stdio { env, .. } = &server.transport else {+ panic!("expected stdio MCP server");+ };+ assert_eq!(+ env.as_ref()+ .and_then(|env| env.get("PLUGIN_DATA"))+ .map(String::as_str),+ expected_data_root.as_path().to_str()+ );+ assert!(expected_data_root.as_path().is_dir());+}+#[test]fn configured_plugins_from_stack_merges_user_layers() {let temp_dir = TempDir::new().expect("tempdir");@@ -265,7 +438,8 @@ fn write_hook_file(plugin_root: &AbsolutePathBuf, relative_path: &str, event: &s}fn load_sources(plugin_root: &AbsolutePathBuf) -> (Vec<PluginHookSource>, Vec<String>) {- let manifest = load_plugin_manifest(plugin_root.as_path()).expect("manifest");+ let loaded_manifest =+ load_plugin_manifest_with_format(plugin_root.as_path()).expect("manifest");let plugin_data_root = AbsolutePathBuf::try_from(plugin_root.as_path()@@ -278,7 +452,7 @@ fn load_sources(plugin_root: &AbsolutePathBuf) -> (Vec<PluginHookSource>, Vec<Stplugin_root,&plugin_id(),&plugin_data_root,- &manifest.paths,+ &loaded_manifest.manifest.paths,)}diff --git a/codex-rs/core-plugins/src/manager.rs b/codex-rs/core-plugins/src/manager.rsindex 98b0bc14dd..04c8f1c6e5 100644--- a/codex-rs/core-plugins/src/manager.rs+++ b/codex-rs/core-plugins/src/manager.rs@@ -10,8 +10,8 @@ use crate::loader::curated_plugin_cache_version;use crate::loader::load_plugin_apps_from_manifest;use crate::loader::load_plugin_hooks;use crate::loader::load_plugin_hooks_from_layer_stack;-use crate::loader::load_plugin_mcp_servers_from_manifest;-use crate::loader::load_plugin_skills_with_identity;+use crate::loader::load_plugin_mcp_servers_from_manifest_with_format;+use crate::loader::load_plugin_skill_inventory;use crate::loader::load_plugins_from_layer_stack;use crate::loader::log_plugin_load_errors;use crate::loader::materialize_marketplace_plugin_source;@@ -21,8 +21,10 @@ use crate::loader::refresh_curated_plugin_cache;use crate::loader::refresh_non_curated_plugin_cache_detailed;use crate::loader::refresh_non_curated_plugin_cache_force_reinstall_detailed;use crate::loader::remote_installed_plugins_to_config;+use crate::manifest::PluginManifestFormat;use crate::manifest::PluginManifestInterface;use crate::manifest::load_plugin_manifest;+use crate::manifest::load_plugin_manifest_with_format;use crate::marketplace::MarketplaceError;use crate::marketplace::MarketplaceInterface;use crate::marketplace::MarketplaceListError;@@ -416,6 +418,7 @@ impl From<PluginDetail> for PluginCapabilitySummary {Self {config_name: value.id,display_name: value.name,+ plugin_namespace: None,description: prompt_safe_plugin_description(value.description.as_deref()),has_skills,mcp_server_names: value.mcp_server_names,@@ -1997,18 +2000,24 @@ impl PluginsManager {"path does not exist or is not a directory".to_string(),));}- let manifest =+ let loaded_manifest =if codex_utils_plugins::find_plugin_manifest_path(source_path.as_path()).is_some() {- load_plugin_manifest(source_path.as_path())+ load_plugin_manifest_with_format(source_path.as_path())} else {plugin.manifest_fallback.as_ref().and_then(|fallback| fallback.parse_for_plugin_root(source_path.as_path()))+ .map(|manifest| crate::manifest::LoadedPluginManifest {+ manifest,+ format: PluginManifestFormat::Legacy,+ })}.ok_or_else(|| {MarketplaceError::InvalidPlugin("missing or invalid plugin.json".to_string())})?;+ let manifest_format = loaded_manifest.format;+ let manifest = loaded_manifest.manifest;let description = manifest.description.clone();let marketplace_category = plugin.interface@@ -2022,21 +2031,27 @@ impl PluginsManager {plugin_id: plugin_id.as_key(),remote_plugin_id: self.remote_plugin_id_for(&plugin_id),};- let resolved_skills = load_plugin_skills_with_identity(+ let skill_config_rules = codex_core_skills::config_rules::skill_config_rules_from_stack(+ &config.config_layer_stack,+ );+ let resolved_skills = load_plugin_skill_inventory(&source_path,&plugin_identity,&manifest,+ manifest_format,self.restriction_product,- &codex_core_skills::config_rules::skill_config_rules_from_stack(- &config.config_layer_stack,- ),/*plugin_skill_snapshots*/ None,Arc::clone(&self.skill_root_scan_slots),)- .await;+ .await+ .resolve(&skill_config_rules);let plugin_data_root = self.store.plugin_data_root(&plugin_id);- let (hook_sources, _hook_load_warnings) =- load_plugin_hooks(&source_path, &plugin_id, &plugin_data_root, &manifest.paths);+ let (hook_sources, _hook_load_warnings) = if manifest_format == PluginManifestFormat::Legacy+ {+ load_plugin_hooks(&source_path, &plugin_id, &plugin_data_root, &manifest.paths)+ } else {+ (Vec::new(), Vec::new())+ };let hooks = plugin_hook_declarations(&hook_sources).into_iter().map(|hook| PluginHookSummary {@@ -2045,15 +2060,22 @@ impl PluginsManager {}).collect();let auth_mode = self.auth_mode();- let mut app_declarations =- load_plugin_apps_from_manifest(source_path.as_path(), &manifest.paths).await;- let mut mcp_servers = load_plugin_mcp_servers_from_manifest(+ let mut app_declarations = if manifest_format == PluginManifestFormat::Legacy {+ load_plugin_apps_from_manifest(source_path.as_path(), &manifest.paths).await+ } else {+ Vec::new()+ };+ let mcp_data_root = (manifest_format == PluginManifestFormat::AgentPlugin)+ .then(|| self.store.mcp_data_root(&plugin_id, manifest_format));+ let mut mcp_servers = load_plugin_mcp_servers_from_manifest_with_format(source_path.as_path(),&manifest.paths,/*plugin_policy*/ None,+ mcp_data_root.as_deref(),+ manifest_format,).await;- if auth_mode.is_some() {+ if manifest_format == PluginManifestFormat::Legacy && auth_mode.is_some() {apply_app_mcp_routing_policy(&mut app_declarations,&mut mcp_servers,diff --git a/codex-rs/core-plugins/src/manager_tests.rs b/codex-rs/core-plugins/src/manager_tests.rsindex b48c30bfd7..5182e0f57a 100644--- a/codex-rs/core-plugins/src/manager_tests.rs+++ b/codex-rs/core-plugins/src/manager_tests.rs@@ -52,6 +52,7 @@ use codex_skills_extension::HostSkillsLoadInput;use codex_skills_extension::HostSkillsService;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_absolute_path::test_support::PathBufExt;+use codex_utils_plugins::SkillDiscoveryMode;use pretty_assertions::assert_eq;use std::fs;use std::path::Path;@@ -675,6 +676,7 @@ async fn plugin_auth_projection_reprojects_cached_plugins_when_auth_changes() {PluginCapabilitySummary {config_name: "docs@test".to_string(),display_name: "docs".to_string(),+ plugin_namespace: Some("docs".to_string()),description: None,has_skills: false,mcp_server_names: vec!["docs".to_string()],@@ -683,6 +685,7 @@ async fn plugin_auth_projection_reprojects_cached_plugins_when_auth_changes() {PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: None,has_skills: false,mcp_server_names: Vec::new(),@@ -705,6 +708,7 @@ async fn plugin_auth_projection_reprojects_cached_plugins_when_auth_changes() {PluginCapabilitySummary {config_name: "docs@test".to_string(),display_name: "docs".to_string(),+ plugin_namespace: Some("docs".to_string()),description: None,has_skills: false,mcp_server_names: vec!["docs".to_string()],@@ -713,6 +717,7 @@ async fn plugin_auth_projection_reprojects_cached_plugins_when_auth_changes() {PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: None,has_skills: false,mcp_server_names: vec!["sample".to_string()],@@ -739,7 +744,11 @@ fn write_plugin_with_version(format!(r#"{{"name":"{manifest_name}"{version}}}"#),).unwrap();- fs::write(plugin_root.join("skills/SKILL.md"), "skill").unwrap();+ fs::write(+ plugin_root.join("skills/SKILL.md"),+ format!("---\nname: {manifest_name}-skill\ndescription: test skill\n---\n\n# Test skill\n"),+ )+ .unwrap();fs::write(plugin_root.join(".mcp.json"), r#"{"mcpServers":{}}"#).unwrap();}@@ -931,6 +940,7 @@ async fn load_plugins_loads_default_skills_and_mcp_servers() {root: AbsolutePathBuf::try_from(plugin_root.clone()).unwrap(),enabled: true,skill_roots: vec![plugin_root.join("skills").abs()],+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: true,mcp_servers: HashMap::from([(@@ -973,6 +983,7 @@ async fn load_plugins_loads_default_skills_and_mcp_servers() {&[PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: Some("Plugin that includes the sample MCP server and Skills".to_string(),),has_skills: true,mcp_server_names: vec!["sample".to_string()],@@ -1232,6 +1243,7 @@ async fn installed_plugin_telemetry_metadata_collects_capabilities() {capability_summary: Some(PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: None,has_skills: true,mcp_server_names: Vec::new(),@@ -1264,6 +1276,7 @@ async fn installed_plugin_telemetry_metadata_resolves_persisted_remote_identity(capability_summary: Some(PluginCapabilitySummary {config_name: "linear@openai-curated-remote".to_string(),display_name: "linear".to_string(),+ plugin_namespace: Some("linear".to_string()),description: None,has_skills: true,mcp_server_names: Vec::new(),@@ -1317,6 +1330,7 @@ async fn installed_plugin_telemetry_metadata_prefers_remote_snapshot_identity()capability_summary: Some(PluginCapabilitySummary {config_name: "linear@openai-curated-remote".to_string(),display_name: "linear".to_string(),+ plugin_namespace: Some("linear".to_string()),description: None,has_skills: true,mcp_server_names: Vec::new(),@@ -1354,6 +1368,7 @@ fn capability_summary_telemetry_metadata_uses_local_identity() {let summary = PluginCapabilitySummary {config_name: "linear@openai-curated-remote".to_string(),display_name: "Linear".to_string(),+ plugin_namespace: Some("linear".to_string()),description: Some("Track work".to_string()),has_skills: true,mcp_server_names: vec!["linear".to_string()],@@ -1387,6 +1402,7 @@ fn capability_summary_telemetry_metadata_resolves_persisted_remote_identity() {let summary = PluginCapabilitySummary {config_name: "linear@openai-curated-remote".to_string(),display_name: "Linear".to_string(),+ plugin_namespace: Some("linear".to_string()),description: Some("Track work".to_string()),has_skills: true,mcp_server_names: vec!["linear".to_string()],@@ -1772,6 +1788,7 @@ enabled = true&[PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: None,has_skills: true,mcp_server_names: Vec::new(),@@ -1817,6 +1834,7 @@ async fn plugin_telemetry_metadata_uses_default_mcp_config_path() {Some(PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: Some("sample".to_string()),description: None,has_skills: false,mcp_server_names: vec!["sample".to_string()],@@ -1858,6 +1876,7 @@ async fn plugin_capability_summary_uses_manifest_mcp_server_objects() {Some(PluginCapabilitySummary {config_name: "counter-sample@test".to_string(),display_name: "counter-sample".to_string(),+ plugin_namespace: Some("counter-sample".to_string()),description: None,has_skills: false,mcp_server_names: vec!["counter".to_string()],@@ -2273,7 +2292,6 @@ async fn load_plugin_skills_dedupes_overlapping_manifest_roots() {interface: None,};let plugin_id = PluginId::parse("sample@test").expect("plugin id should parse");-let resolved = load_plugin_skills(&plugin_root,&plugin_id,@@ -2502,6 +2520,7 @@ async fn load_plugins_preserves_disabled_plugins_without_effective_contributionsroot: AbsolutePathBuf::try_from(plugin_root).unwrap(),enabled: false,skill_roots: Vec::new(),+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: false,mcp_servers: HashMap::new(),@@ -2679,6 +2698,7 @@ fn capability_index_filters_inactive_and_zero_capability_plugins() {root: AbsolutePathBuf::try_from(codex_home.path().join(dir_name)).unwrap(),enabled: true,skill_roots: Vec::new(),+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: false,mcp_servers: HashMap::new(),@@ -2690,6 +2710,12 @@ fn capability_index_filters_inactive_and_zero_capability_plugins() {let summary = |config_name: &str, display_name: &str| PluginCapabilitySummary {config_name: config_name.to_string(),display_name: display_name.to_string(),+ plugin_namespace: Some(+ config_name+ .split_once('@')+ .map_or(config_name, |(name, _)| name)+ .to_string(),+ ),description: None,..PluginCapabilitySummary::default()};@@ -3985,6 +4011,96 @@ plugins = true);}+#[tokio::test]+async fn agent_plugin_read_and_tool_suggestions_use_portable_capabilities_only() {+ let tmp = tempfile::tempdir().unwrap();+ let repo_root = tmp.path().join("repo");+ let plugin_root = repo_root.join("agent-plugin");+ fs::create_dir_all(repo_root.join(".git")).unwrap();+ fs::create_dir_all(repo_root.join(".agents/plugins")).unwrap();+ write_file(+ &repo_root.join(".agents/plugins/marketplace.json"),+ r#"{"name":"debug","plugins":[{"name":"agent-plugin","source":"./agent-plugin"}]}"#,+ );+ write_file(+ &plugin_root.join("plugin.json"),+ r#"{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","name":"agent.tools"}"#,+ );+ write_file(+ &plugin_root.join("skills/direct/SKILL.md"),+ "---\nname: direct\ndescription: Direct skill\n---\n",+ );+ write_file(+ &plugin_root.join("skills/group/nested/SKILL.md"),+ "---\nname: nested\ndescription: Nested skill\n---\n",+ );+ write_file(+ &plugin_root.join("mcp.json"),+ r#"{"$schema":"https://agent-plugins.org/schemas/1.0.0/mcp.schema.json","mcpServers":{"portable":{"type":"stdio","command":"echo"}}}"#,+ );+ write_file(+ &plugin_root.join(".codex-plugin/plugin.json"),+ r#"{"apps":"./.app.json","hooks":"./hooks/hooks.json"}"#,+ );+ write_file(+ &plugin_root.join(".app.json"),+ r#"{"apps":{"legacy":{"id":"connector_legacy"}}}"#,+ );+ write_file(+ &plugin_root.join("hooks/hooks.json"),+ r#"{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"echo legacy"}]}]}}"#,+ );+ write_file(+ &tmp.path().join(CONFIG_TOML_FILE),+ "[features]\nplugins = true\n",+ );++ let config = load_config(tmp.path(), &repo_root).await;+ let manager = PluginsManager::new(tmp.path().to_path_buf());+ let plugin = manager+ .list_marketplaces_for_config(+ &config,+ &[AbsolutePathBuf::try_from(repo_root).unwrap()],+ /*include_openai_curated*/ false,+ )+ .unwrap()+ .marketplaces+ .into_iter()+ .find(|marketplace| marketplace.name == "debug")+ .unwrap()+ .plugins+ .into_iter()+ .find(|plugin| plugin.name == "agent-plugin")+ .unwrap();+ let detail = manager+ .read_plugin_detail_for_marketplace_plugin(&config, "debug", plugin.clone())+ .await+ .unwrap();+ let suggestion = manager+ .tool_suggest_metadata_for_marketplace_plugin(+ "debug",+ &plugin,+ &SkillConfigRules::default(),+ )+ .await+ .unwrap();++ assert_eq!(+ detail+ .skills+ .iter()+ .map(|skill| skill.name.as_str())+ .collect::<Vec<_>>(),+ vec!["agent.tools:direct"]+ );+ assert_eq!(detail.mcp_server_names, vec!["portable"]);+ assert!(detail.apps.is_empty());+ assert!(detail.hooks.is_empty());+ assert!(suggestion.has_skills);+ assert_eq!(suggestion.mcp_server_names, vec!["portable"]);+ assert!(suggestion.app_connector_ids.is_empty());+}+#[tokio::test]async fn read_plugin_for_config_does_not_fallback_from_invalid_plugin_manifest() {let tmp = tempfile::tempdir().unwrap();diff --git a/codex-rs/core-plugins/src/manifest.rs b/codex-rs/core-plugins/src/manifest.rsindex 3503a8d80d..40d724734b 100644--- a/codex-rs/core-plugins/src/manifest.rs+++ b/codex-rs/core-plugins/src/manifest.rs@@ -31,6 +31,17 @@ pub type PluginManifestPaths = codex_plugin::manifest::PluginManifestPaths<Absolpub type UriPluginManifest = codex_plugin::manifest::PluginManifest<PathUri>;+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum PluginManifestFormat {+ Legacy,+ AgentPlugin,+}++pub(crate) struct LoadedPluginManifest {+ pub manifest: PluginManifest,+ pub format: PluginManifestFormat,+}+#[derive(Debug, Default, Deserialize)]#[serde(rename_all = "camelCase")]struct RawPluginManifest {@@ -143,6 +154,15 @@ enum RawPluginManifestHooks {/// Loads a plugin manifest from the local host filesystem.pub fn load_plugin_manifest(plugin_root: &Path) -> Option<PluginManifest> {+ load_plugin_manifest_with_format(plugin_root).map(|loaded| loaded.manifest)+}++pub fn is_agent_plugin_manifest(plugin_root: &Path) -> bool {+ load_plugin_manifest_with_format(plugin_root)+ .is_some_and(|loaded| loaded.format == PluginManifestFormat::AgentPlugin)+}++pub(crate) fn load_plugin_manifest_with_format(plugin_root: &Path) -> Option<LoadedPluginManifest> {let manifest_path = find_plugin_manifest_path(plugin_root)?;let contents = fs::read_to_string(&manifest_path).ok()?;let is_agent_plugin = manifest_path == plugin_root.join(AGENT_PLUGIN_MANIFEST_RELATIVE_PATH);@@ -162,7 +182,14 @@ pub fn load_plugin_manifest(plugin_root: &Path) -> Option<PluginManifest> {.as_ref().map(|(path, contents)| (path.as_path(), contents.as_str())),) {- Ok(manifest) => Some(manifest),+ Ok(manifest) => Some(LoadedPluginManifest {+ manifest,+ format: if is_agent_plugin {+ PluginManifestFormat::AgentPlugin+ } else {+ PluginManifestFormat::Legacy+ },+ }),Err(err) => {tracing::warn!(path = %manifest_path.display(),diff --git a/codex-rs/core-plugins/src/remote.rs b/codex-rs/core-plugins/src/remote.rsindex 27de631aea..ed3f4df8d9 100644--- a/codex-rs/core-plugins/src/remote.rs+++ b/codex-rs/core-plugins/src/remote.rs@@ -1524,6 +1524,7 @@ pub async fn resolve_remote_plugin_uninstall_target(let fallback_capability_summary = PluginCapabilitySummary {config_name: plugin_id.as_key(),display_name: plugin.release.display_name,+ plugin_namespace: Some(plugin_id.plugin_name.clone()),description: prompt_safe_plugin_description(Some(&plugin.release.description)),has_skills: !plugin.release.skills.is_empty(),mcp_server_names,diff --git a/codex-rs/core-plugins/src/script_attribution_tests.rs b/codex-rs/core-plugins/src/script_attribution_tests.rsindex 0455002d25..641806d166 100644--- a/codex-rs/core-plugins/src/script_attribution_tests.rs+++ b/codex-rs/core-plugins/src/script_attribution_tests.rs@@ -10,6 +10,7 @@ use crate::test_support::write_curated_plugin_sha_with;use crate::test_support::write_openai_api_curated_marketplace;use crate::test_support::write_openai_curated_marketplace;use codex_plugin::PluginLoadOutcome;+use codex_utils_plugins::SkillDiscoveryMode;use pretty_assertions::assert_eq;use std::collections::HashMap;use std::collections::HashSet;@@ -30,6 +31,7 @@ fn loaded_plugin(config_name: &str, root: &Path, enabled: bool) -> LoadedPluginroot: path(root),enabled,skill_roots: Vec::new(),+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: false,mcp_servers: HashMap::new(),diff --git a/codex-rs/core-plugins/src/store.rs b/codex-rs/core-plugins/src/store.rsindex 55458a2c2e..fc5d37ce80 100644--- a/codex-rs/core-plugins/src/store.rs+++ b/codex-rs/core-plugins/src/store.rs@@ -1,5 +1,6 @@use crate::command_migration::migrate_plugin_commands;use crate::manifest::PluginManifest;+use crate::manifest::PluginManifestFormat;use crate::manifest::load_plugin_manifest;use crate::manifest::parse_plugin_manifest;use codex_plugin::PluginId;@@ -24,6 +25,7 @@ use std::path::PathBuf;pub const DEFAULT_PLUGIN_VERSION: &str = "local";pub const PLUGINS_CACHE_DIR: &str = "plugins/cache";pub const PLUGINS_DATA_DIR: &str = "plugins/data";+const AGENT_PLUGINS_DATA_DIR: &str = "agent-plugins";const REMOTE_PLUGIN_INSTALL_METADATA_FILE: &str = ".codex-remote-plugin-install.json";const REMOTE_PLUGIN_INSTALL_METADATA_SCHEMA_VERSION: u8 = 1;const DEFAULT_AGENT_PLUGIN_VERSION: &str = "1.0.0";@@ -143,6 +145,27 @@ impl PluginStore {))}+ pub(crate) fn agent_plugin_data_root(&self, plugin_id: &PluginId) -> AbsolutePathBuf {+ let mut digest = Sha256::new();+ digest.update(plugin_id.marketplace_name.as_bytes());+ digest.update([0]);+ digest.update(plugin_id.plugin_name.as_bytes());+ self.data_root+ .join(AGENT_PLUGINS_DATA_DIR)+ .join(hex_prefix(&digest.finalize(), /*count*/ 32))+ }++ pub(crate) fn mcp_data_root(+ &self,+ plugin_id: &PluginId,+ manifest_format: PluginManifestFormat,+ ) -> AbsolutePathBuf {+ match manifest_format {+ PluginManifestFormat::AgentPlugin => self.agent_plugin_data_root(plugin_id),+ PluginManifestFormat::Legacy => self.plugin_data_root(plugin_id),+ }+ }+pub fn active_plugin_version(&self, plugin_id: &PluginId) -> Option<String> {let mut discovered_versions = fs::read_dir(self.plugin_base_root(plugin_id).as_path()).ok()?diff --git a/codex-rs/core-plugins/src/store_tests.rs b/codex-rs/core-plugins/src/store_tests.rsindex 380ef84736..27b8168fc0 100644--- a/codex-rs/core-plugins/src/store_tests.rs+++ b/codex-rs/core-plugins/src/store_tests.rs@@ -162,6 +162,28 @@ fn plugin_data_root_derives_path_from_key() {);}+#[test]+fn agent_plugin_data_root_is_stable_and_unambiguous() {+ let tmp = tempdir().unwrap();+ let store = PluginStore::new(tmp.path().to_path_buf());+ let first = PluginId::new("a-b".to_string(), "c".to_string()).unwrap();+ let second = PluginId::new("a".to_string(), "b-c".to_string()).unwrap();++ let first_root = store.agent_plugin_data_root(&first);+ let second_root = store.agent_plugin_data_root(&second);+ let expected_parent = tmp.path().join("plugins/data/agent-plugins");++ assert_ne!(first_root, second_root);+ assert_eq!(+ first_root.as_path(),+ expected_parent.join("6920dd17774030852d11d1b94758fcaae4f894c7b2f36301ed174bc3b33e0743")+ );+ assert_eq!(+ second_root.as_path(),+ expected_parent.join("fa89b988ebbe54a68fdcbeb87fb913a5238d482084a3cee49a86288c2d45fa90")+ );+}+#[test]fn install_with_version_uses_requested_cache_version() {let tmp = tempdir().unwrap();diff --git a/codex-rs/core-plugins/src/tool_suggest_metadata.rs b/codex-rs/core-plugins/src/tool_suggest_metadata.rsindex 0871a7436c..fbedcb5707 100644--- a/codex-rs/core-plugins/src/tool_suggest_metadata.rs+++ b/codex-rs/core-plugins/src/tool_suggest_metadata.rs@@ -21,7 +21,8 @@ use crate::loader::load_plugin_mcp_servers;use crate::loader::load_plugin_skill_inventory;use crate::manager::ConfiguredMarketplacePlugin;use crate::manager::remote_plugin_install_required_description;-use crate::manifest::load_plugin_manifest;+use crate::manifest::PluginManifestFormat;+use crate::manifest::load_plugin_manifest_with_format;use crate::marketplace::MarketplaceError;use crate::marketplace::MarketplacePluginSource;@@ -53,6 +54,7 @@ struct PluginArtifactIdentity {pub(crate) struct ToolSuggestMetadataFragment {config_name: String,display_name: String,+ plugin_namespace: Option<String>,description: Option<String>,mcp_server_names: Vec<String>,app_declarations: Vec<AppDeclaration>,@@ -86,6 +88,7 @@ impl ToolSuggestMetadataFragment {PluginCapabilitySummary {config_name: self.config_name.clone(),display_name: self.display_name.clone(),+ plugin_namespace: self.plugin_namespace.clone(),description: self.description.clone(),has_skills: self.skill_inventory@@ -206,6 +209,7 @@ async fn load_plugin_metadata(return Ok(Arc::new(ToolSuggestMetadataFragment {config_name: plugin.id.clone(),display_name: plugin.name.clone(),+ plugin_namespace: Some(plugin.name.clone()),description: prompt_safe_plugin_description(Some(&remote_plugin_install_required_description(&plugin.source),)),@@ -217,16 +221,18 @@ async fn load_plugin_metadata(if !plugin_root.as_path().is_dir() {return Err("path does not exist or is not a directory".to_string());}- let manifest = load_plugin_manifest(plugin_root.as_path())+ let loaded_manifest = load_plugin_manifest_with_format(plugin_root.as_path()).ok_or_else(|| "missing or invalid plugin.json".to_string())?;let plugin_identity = PluginIdentity {plugin_id: plugin_id.as_key(),remote_plugin_id: None,};+ let manifest = loaded_manifest.manifest;let skill_inventory = load_plugin_skill_inventory(plugin_root,&plugin_identity,&manifest,+ loaded_manifest.format,restriction_product,/*plugin_skill_snapshots*/ None,root_scan_slots,@@ -239,11 +245,16 @@ async fn load_plugin_metadata(.collect::<Vec<_>>();mcp_server_names.sort_unstable();mcp_server_names.dedup();- let app_declarations = load_plugin_apps(plugin_root.as_path()).await;+ let app_declarations = if loaded_manifest.format == PluginManifestFormat::AgentPlugin {+ Vec::new()+ } else {+ load_plugin_apps(plugin_root.as_path()).await+ };Ok(Arc::new(ToolSuggestMetadataFragment {config_name: plugin.id.clone(),display_name: plugin.name.clone(),+ plugin_namespace: Some(manifest.name.clone()),description: prompt_safe_plugin_description(manifest.description.as_deref()),mcp_server_names,app_declarations,diff --git a/codex-rs/core-skills/Cargo.toml b/codex-rs/core-skills/Cargo.tomlindex 61b16ab236..e0acd97111 100644--- a/codex-rs/core-skills/Cargo.toml+++ b/codex-rs/core-skills/Cargo.toml@@ -27,6 +27,7 @@ codex-skills = { workspace = true }codex-utils-absolute-path = { workspace = true }codex-utils-path-uri = { workspace = true }codex-utils-plugins = { workspace = true }+codex-utils-string = { workspace = true }dunce = { workspace = true }futures = { workspace = true }serde = { workspace = true, features = ["derive"] }diff --git a/codex-rs/core-skills/src/injection.rs b/codex-rs/core-skills/src/injection.rsindex 2529526496..6c85b77c80 100644--- a/codex-rs/core-skills/src/injection.rs+++ b/codex-rs/core-skills/src/injection.rs@@ -16,6 +16,9 @@ use codex_protocol::user_input::UserInput;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;use codex_utils_plugins::mention_syntax::TOOL_MENTION_SIGIL;+use codex_utils_string::take_bytes_at_char_boundary;++use crate::MAX_SKILL_PROMPT_BYTES;#[derive(Debug, Default)]pub struct SkillInjections {@@ -93,6 +96,18 @@ pub async fn build_skill_injections(let path = PathUri::from_abs_path(&skill.path_to_skills_md);match fs.read_file_text(&path, /*sandbox*/ None).await {Ok(contents) => {+ let (contents, truncated) =+ if loaded_skills.is_some_and(|outcome| outcome.is_agent_plugin_skill(skill)) {+ bounded_skill_prompt_contents(&contents)+ } else {+ (contents, false)+ };+ if truncated {+ result.warnings.push(format!(+ "Skill `{}` exceeded the main prompt context limit and was truncated.",+ skill.name+ ));+ }emit_skill_injected_metric(otel, skill, "ok");invocations.push(SkillInvocation {skill_name: skill.name.clone(),@@ -125,6 +140,11 @@ pub async fn build_skill_injections(result}+fn bounded_skill_prompt_contents(contents: &str) -> (String, bool) {+ let bounded = take_bytes_at_char_boundary(contents, MAX_SKILL_PROMPT_BYTES);+ (bounded.to_string(), bounded.len() < contents.len())+}+fn normalize_host_skill_path(path: &str) -> String {normalize_skill_path(path).replace('\\', "/")}diff --git a/codex-rs/core-skills/src/injection_tests.rs b/codex-rs/core-skills/src/injection_tests.rsindex 1b6e14dac3..01cbb65af9 100644--- a/codex-rs/core-skills/src/injection_tests.rs+++ b/codex-rs/core-skills/src/injection_tests.rs@@ -21,6 +21,16 @@ fn make_skill(name: &str, path: &str) -> SkillMetadata {}}+#[test]+fn skill_prompt_contents_are_bounded_at_utf8_boundaries() {+ let contents = format!("{}é", "a".repeat(MAX_SKILL_PROMPT_BYTES - 1));++ let (bounded, truncated) = bounded_skill_prompt_contents(&contents);++ assert_eq!(bounded.len(), MAX_SKILL_PROMPT_BYTES - 1);+ assert_eq!(truncated, true);+}+fn set<'a>(items: &'a [&'a str]) -> HashSet<&'a str> {items.iter().copied().collect()}diff --git a/codex-rs/core-skills/src/lib.rs b/codex-rs/core-skills/src/lib.rsindex 71d2ef4584..8a0bb5fc39 100644--- a/codex-rs/core-skills/src/lib.rs+++ b/codex-rs/core-skills/src/lib.rs@@ -8,6 +8,12 @@ pub mod remote;mod root_loader;mod skill_instructions;+/// Hard byte limit for one model-visible skill instruction body.+///+/// Both the legacy explicit-injection path and the skills extension use this+/// limit so a skill cannot bypass context bounds by changing how it is loaded.+pub const MAX_SKILL_PROMPT_BYTES: usize = 8_000;+pub(crate) use invocation_utils::build_implicit_skill_path_indexes;pub use invocation_utils::detect_implicit_skill_invocation_for_command;pub use mention_counts::build_skill_name_counts;diff --git a/codex-rs/core-skills/src/loader.rs b/codex-rs/core-skills/src/loader.rsindex 347d415419..36e4fe5690 100644--- a/codex-rs/core-skills/src/loader.rs+++ b/codex-rs/core-skills/src/loader.rs@@ -95,7 +95,7 @@ const SKILLS_FILENAME: &str = "SKILL.md";const SKILLS_METADATA_DIR: &str = "agents";const SKILLS_METADATA_FILENAME: &str = "openai.yaml";const MAX_NAME_LEN: usize = 64;-const MAX_QUALIFIED_NAME_LEN: usize = 128;+const MAX_QUALIFIED_NAME_LEN: usize = MAX_NAME_LEN * 2 + 1;const MAX_DESCRIPTION_LEN: usize = 1024;const MAX_DEPENDENCY_TYPE_LEN: usize = MAX_NAME_LEN;const MAX_DEPENDENCY_TRANSPORT_LEN: usize = MAX_NAME_LEN;@@ -163,6 +163,7 @@ where#[derive(Clone)]pub(crate) struct SkillRootSnapshot {pub(crate) root: AbsolutePathBuf,+ pub(crate) is_agent_plugin: bool,pub(crate) skills: Vec<SkillMetadata>,pub(crate) errors: Vec<SkillError>,pub(crate) file_system: Arc<dyn ExecutorFileSystem>,@@ -175,6 +176,7 @@ pub(crate) async fn load_skill_root(root: SkillRoot) -> SkillRootSnapshot {load_skills_under_root(&root, &canonical_root, &mut outcome).await;SkillRootSnapshot {root: canonical_root,+ is_agent_plugin: root.discovery_mode == SkillDiscoveryMode::DirectChildren,skills: outcome.skills,errors: outcome.errors,file_system: root.file_system,diff --git a/codex-rs/core-skills/src/loader_tests.rs b/codex-rs/core-skills/src/loader_tests.rsindex 055fa8a830..93ebe41e8a 100644--- a/codex-rs/core-skills/src/loader_tests.rs+++ b/codex-rs/core-skills/src/loader_tests.rs@@ -1202,7 +1202,7 @@ async fn keeps_inherited_namespace_when_symlink_target_is_scan_root_ancestor() {#[tokio::test]async fn plugin_skill_name_length_limit_allows_max_qualified_name() {let root = tempfile::tempdir().expect("tempdir");- let plugin_name = "p".repeat(MAX_NAME_LEN - 1);+ let plugin_name = "p".repeat(MAX_NAME_LEN);let skill_name = "s".repeat(MAX_NAME_LEN);let plugin_root = root.path().join("plugins").join(&plugin_name);let frontmatter = format!("name: {skill_name}\ndescription: search sample data");@@ -1257,7 +1257,7 @@ async fn plugin_skill_name_length_limit_allows_max_qualified_name() {#[tokio::test]async fn plugin_skill_name_length_limit_rejects_overlong_qualified_name() {let root = tempfile::tempdir().expect("tempdir");- let plugin_name = "p".repeat(MAX_NAME_LEN);+ let plugin_name = "p".repeat(MAX_NAME_LEN + 1);let skill_name = "s".repeat(MAX_NAME_LEN);let plugin_root = root.path().join("plugins").join(&plugin_name);let frontmatter = format!("name: {skill_name}\ndescription: search sample data");diff --git a/codex-rs/core-skills/src/model.rs b/codex-rs/core-skills/src/model.rsindex f01d972788..789827f7b0 100644--- a/codex-rs/core-skills/src/model.rs+++ b/codex-rs/core-skills/src/model.rs@@ -28,6 +28,7 @@ pub struct SkillLoadOutcome {pub disabled_paths: HashSet<AbsolutePathBuf>,pub(crate) skill_roots: Vec<AbsolutePathBuf>,pub(crate) skill_root_by_path: Arc<HashMap<AbsolutePathBuf, AbsolutePathBuf>>,+ pub(crate) agent_plugin_skill_paths: HashSet<AbsolutePathBuf>,pub(crate) file_systems_by_skill_path: SkillFileSystemsByPath,pub(crate) implicit_skills_by_scripts_dir: Arc<HashMap<AbsolutePathBuf, SkillMetadata>>,pub(crate) implicit_skills_by_doc_path: Arc<HashMap<AbsolutePathBuf, SkillMetadata>>,@@ -70,6 +71,11 @@ impl SkillLoadOutcome {self}+ pub fn is_agent_plugin_skill(&self, skill: &SkillMetadata) -> bool {+ self.agent_plugin_skill_paths+ .contains(&skill.path_to_skills_md)+ }+/// Returns the discovery root that supplied a loaded skill path.pub fn skill_root_for_path(&self, path: &AbsolutePathBuf) -> Option<&AbsolutePathBuf> {self.skill_root_by_path.get(path)@@ -173,6 +179,9 @@ pub fn filter_skill_load_outcome_for_product(.map(|(path, root)| (path.clone(), root.clone())).collect(),);+ outcome+ .agent_plugin_skill_paths+ .retain(|path| retained_paths.contains(path));let retained_roots: HashSet<AbsolutePathBuf> =outcome.skill_root_by_path.values().cloned().collect();outcomediff --git a/codex-rs/core-skills/src/root_loader.rs b/codex-rs/core-skills/src/root_loader.rsindex e3cc4fb6d6..ca7d059f43 100644--- a/codex-rs/core-skills/src/root_loader.rs+++ b/codex-rs/core-skills/src/root_loader.rs@@ -150,6 +150,7 @@ fn merge_skill_root_snapshots(snapshots: Vec<SkillRootSnapshot>) -> SkillLoadOutfor snapshot in snapshots {let SkillRootSnapshot {root,+ is_agent_plugin,skills,errors,file_system,@@ -158,12 +159,14 @@ fn merge_skill_root_snapshots(snapshots: Vec<SkillRootSnapshot>) -> SkillLoadOutskill_roots.push(root.clone());}for skill in &skills {- skill_root_by_path- .entry(skill.path_to_skills_md.clone())- .or_insert_with(|| root.clone());- file_systems_by_skill_path- .entry(skill.path_to_skills_md.clone())- .or_insert_with(|| Arc::clone(&file_system));+ let path = skill.path_to_skills_md.clone();+ if !skill_root_by_path.contains_key(&path) {+ skill_root_by_path.insert(path.clone(), root.clone());+ file_systems_by_skill_path.insert(path.clone(), Arc::clone(&file_system));+ if is_agent_plugin {+ outcome.agent_plugin_skill_paths.insert(path);+ }+ }}outcome.skills.extend(skills);outcome.errors.extend(errors);@@ -182,6 +185,9 @@ fn merge_skill_root_snapshots(snapshots: Vec<SkillRootSnapshot>) -> SkillLoadOutlet used_roots = skill_root_by_path.values().cloned().collect::<HashSet<_>>();skill_roots.retain(|root| used_roots.contains(root));file_systems_by_skill_path.retain(|path, _| retained_skill_paths.contains(path));+ outcome+ .agent_plugin_skill_paths+ .retain(|path| retained_skill_paths.contains(path));outcome.skill_roots = skill_roots;outcome.skill_root_by_path = Arc::new(skill_root_by_path);outcome.file_systems_by_skill_path = SkillFileSystemsByPath::new(file_systems_by_skill_path);diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex c013713450..a7784643ce 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -1700,10 +1700,17 @@ impl Config {{let mut plugin_mcp_servers = plugin.mcp_servers.clone();self.apply_plugin_mcp_server_requirements(&plugin.config_name, &mut plugin_mcp_servers);- let attribution = McpPluginAttribution::new(- plugin.config_name.clone(),- plugin.display_name().to_string(),- );+ let attribution = if plugin.is_agent_plugin() {+ McpPluginAttribution::agent_plugin(+ plugin.config_name.clone(),+ plugin.display_name().to_string(),+ )+ } else {+ McpPluginAttribution::new(+ plugin.config_name.clone(),+ plugin.display_name().to_string(),+ )+ };for (name, plugin_server) in plugin_mcp_servers {catalog.register(McpServerRegistration::from_plugin(name,diff --git a/codex-rs/core/src/mcp_skill_dependencies.rs b/codex-rs/core/src/mcp_skill_dependencies.rsindex 8029755f21..f07d9778d0 100644--- a/codex-rs/core/src/mcp_skill_dependencies.rs+++ b/codex-rs/core/src/mcp_skill_dependencies.rs@@ -12,6 +12,7 @@ use codex_protocol::request_user_input::RequestUserInputQuestion;use codex_protocol::request_user_input::RequestUserInputQuestionOption;use codex_protocol::request_user_input::RequestUserInputResponse;use codex_rmcp_client::OAuthDiscoveryTimeout;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::perform_oauth_login;use tokio_util::sync::CancellationToken;use tracing::warn;@@ -152,6 +153,7 @@ pub(crate) async fn maybe_install_mcp_dependencies(&server_config.transport,Arc::clone(&http_client),discovery_timeout,+ StreamableHttpRedirectMode::Legacy,).await;let oauth_config = match login_support {diff --git a/codex-rs/core/src/mcp_tool_exposure.rs b/codex-rs/core/src/mcp_tool_exposure.rsindex 0991e4cf41..84d14ebcd3 100644--- a/codex-rs/core/src/mcp_tool_exposure.rs+++ b/codex-rs/core/src/mcp_tool_exposure.rs@@ -11,6 +11,9 @@ use codex_tools::ToolName;use tracing::instrument;use tracing::warn;+const MAX_AGENT_PLUGIN_MCP_SPEC_BYTES: usize = 8_000;+const MAX_AGENT_PLUGIN_MCP_TOTAL_BYTES: usize = 64_000;+use crate::config::Config;use crate::tools::handlers::McpHandler;use crate::tools::registry::ToolRegistry;@@ -20,6 +23,7 @@ pub(crate) fn append_mcp_tools(all_mcp_tools: &[McpToolInfo],config: &Config,apps_enabled: bool,+ mcp_server_catalog: &codex_mcp::ResolvedMcpCatalog,search_tool_enabled: bool,registry: &mut ToolRegistry,) -> HashSet<ToolName> {@@ -35,11 +39,43 @@ pub(crate) fn append_mcp_tools(ToolExposure::Direct};let mut registered_tools = HashSet::new();+ let mut agent_plugin_bytes = 0usize;for tool in non_app_tools.chain(app_tools) {let tool_name = tool.canonical_tool_name();- match McpHandler::new(tool.clone()) {+ let agent_plugin = mcp_server_catalog+ .server(&tool.server_name)+ .is_some_and(|server| server.source().is_agent_plugin());+ let handler = if agent_plugin {+ McpHandler::new_agent_plugin(tool.clone())+ } else {+ McpHandler::new(tool.clone())+ };+ match handler {Ok(handler) => {- if registry.register_external_with_exposure(Arc::new(handler), exposure) {+ let fits_agent_budget = if agent_plugin {+ handler.model_spec_bytes().is_ok_and(|bytes| {+ if bytes > MAX_AGENT_PLUGIN_MCP_SPEC_BYTES {+ return false;+ }+ let next = agent_plugin_bytes.saturating_add(bytes);+ if next <= MAX_AGENT_PLUGIN_MCP_TOTAL_BYTES {+ agent_plugin_bytes = next;+ true+ } else {+ false+ }+ })+ } else {+ true+ };+ let tool_exposure = if fits_agent_budget {+ exposure+ } else {+ ToolExposure::Hidden+ };+ if registry.register_external_with_exposure(Arc::new(handler), tool_exposure)+ && fits_agent_budget+ {registered_tools.insert(tool_name);}}diff --git a/codex-rs/core/src/mcp_tool_exposure_test.rs b/codex-rs/core/src/mcp_tool_exposure_test.rsindex 782ea0f9fb..9f709f8dcb 100644--- a/codex-rs/core/src/mcp_tool_exposure_test.rs+++ b/codex-rs/core/src/mcp_tool_exposure_test.rs@@ -2,6 +2,9 @@ use std::collections::HashMap;use std::sync::Arc;use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;+use codex_mcp::McpPluginAttribution;+use codex_mcp::McpServerRegistration;+use codex_mcp::ResolvedMcpCatalog;use codex_mcp::ToolInfo;use codex_tools::ToolExposure;use codex_tools::ToolName;@@ -75,12 +78,29 @@ fn runtimes_by_name(config: &Config,apps_enabled: bool,search_tool_enabled: bool,+) -> HashMap<ToolName, ToolExposure> {+ runtimes_by_name_with_catalog(+ tools,+ config,+ apps_enabled,+ &ResolvedMcpCatalog::default(),+ search_tool_enabled,+ )+}++fn runtimes_by_name_with_catalog(+ tools: &[ToolInfo],+ config: &Config,+ apps_enabled: bool,+ mcp_server_catalog: &ResolvedMcpCatalog,+ search_tool_enabled: bool,) -> HashMap<ToolName, ToolExposure> {let mut registry = ToolRegistry::default();append_mcp_tools(tools,config,apps_enabled,+ mcp_server_catalog,search_tool_enabled,&mut registry,);@@ -90,6 +110,91 @@ fn runtimes_by_name(.collect()}+#[tokio::test]+async fn agent_plugin_budget_hides_only_overflow_agent_tools() {+ let codex_home = tempdir().expect("tempdir should succeed");+ std::fs::write(+ codex_home.path().join(CONFIG_TOML_FILE),+ "[mcp_servers.agent]\ncommand = \"echo\"\n",+ )+ .expect("write config");+ let config = ConfigBuilder::default()+ .codex_home(codex_home.path().to_path_buf())+ .build()+ .await+ .expect("config should build");+ let agent_config = config.mcp_servers.get()["agent"].clone();+ let legacy_config = agent_config.clone();+ let mut catalog = ResolvedMcpCatalog::builder();+ catalog.register(McpServerRegistration::from_plugin(+ "agent".to_string(),+ McpPluginAttribution::agent_plugin("agent@test".to_string(), "Agent".to_string()),+ /*plugin_order*/ 0,+ agent_config,+ ));+ catalog.register(McpServerRegistration::from_plugin(+ "legacy".to_string(),+ McpPluginAttribution::new("legacy@test".to_string(), "Legacy".to_string()),+ /*plugin_order*/ 1,+ legacy_config,+ ));+ let catalog = catalog.build();+ let mut tools = (0..40)+ .map(|index| {+ let name = format!("tool_{index}");+ let mut tool = make_mcp_tool(+ "agent",+ &name,+ "mcp__agent",+ &name,+ /*connector_id*/ None,+ /*connector_name*/ None,+ );+ tool.namespace_description = Some("n".repeat(1_000));+ tool.tool.description = Some("d".repeat(1_000).into());+ tool+ })+ .collect::<Vec<_>>();+ let oversized_name = "x".repeat(MAX_AGENT_PLUGIN_MCP_SPEC_BYTES);+ let oversized_agent_tool = make_mcp_tool(+ "agent",+ "oversized_agent_tool",+ "mcp__agent",+ &oversized_name,+ /*connector_id*/ None,+ /*connector_name*/ None,+ );+ tools.push(oversized_agent_tool.clone());+ let legacy_tool = make_mcp_tool(+ "legacy",+ "legacy_tool",+ "mcp__legacy",+ &oversized_name,+ /*connector_id*/ None,+ /*connector_name*/ None,+ );+ tools.push(legacy_tool.clone());++ let runtimes = runtimes_by_name_with_catalog(+ &tools, &config, /*apps_enabled*/ false, &catalog, /*search_tool_enabled*/ false,+ );+ let agent_exposures = tools[..40]+ .iter()+ .map(|tool| runtimes[&tool.canonical_tool_name()])+ .collect::<Vec<_>>();++ assert!(agent_exposures.contains(&ToolExposure::Direct));+ assert!(agent_exposures.contains(&ToolExposure::Hidden));+ assert_eq!(+ runtimes[&oversized_agent_tool.canonical_tool_name()],+ ToolExposure::Hidden+ );+ assert_eq!(+ runtimes[&legacy_tool.canonical_tool_name()],+ ToolExposure::Direct+ );+}+fn with_visibility(mut tool: ToolInfo, visibility: &[&str]) -> ToolInfo {tool.tool.meta = Some(MetaObject(serde_json::json!({ "ui": { "visibility": visibility } })@@ -240,6 +345,7 @@ async fn app_tool_registration_uses_trusted_catalog_metadata_and_preserves_sourc&mcp_tools,&config,/*apps_enabled*/ true,+ &ResolvedMcpCatalog::default(),/*search_tool_enabled*/ false,&mut registry,);diff --git a/codex-rs/core/src/plugins/mentions_tests.rs b/codex-rs/core/src/plugins/mentions_tests.rsindex 37c9adb886..8184a41945 100644--- a/codex-rs/core/src/plugins/mentions_tests.rs+++ b/codex-rs/core/src/plugins/mentions_tests.rs@@ -18,6 +18,7 @@ fn plugin(config_name: &str, display_name: &str) -> PluginCapabilitySummary {PluginCapabilitySummary {config_name: config_name.to_string(),display_name: display_name.to_string(),+ plugin_namespace: None,description: None,has_skills: true,mcp_server_names: Vec::new(),diff --git a/codex-rs/core/src/plugins/render.rs b/codex-rs/core/src/plugins/render.rsindex 4e7575bd62..38dc949b2f 100644--- a/codex-rs/core/src/plugins/render.rs+++ b/codex-rs/core/src/plugins/render.rs@@ -3,6 +3,11 @@ use crate::context::AvailablePluginsInstructions;#[cfg(test)]use crate::context::ContextualUserFragment;use crate::plugins::PluginCapabilitySummary;+use codex_utils_string::take_bytes_at_char_boundary;++const MAX_EXPLICIT_PLUGIN_INSTRUCTIONS_BYTES: usize = 4 * 1024;+const TRUNCATED_PLUGIN_INSTRUCTIONS_SUFFIX: &str =+ "\n- Additional plugin capabilities omitted to fit the context limit.";#[cfg(test)]pub(crate) fn render_plugins_section(plugins: &[PluginCapabilitySummary]) -> Option<String> {@@ -20,9 +25,12 @@ pub(crate) fn render_explicit_plugin_instructions()];if plugin.has_skills {+ let skill_namespace = plugin+ .plugin_namespace+ .as_deref()+ .unwrap_or(plugin.display_name.as_str());lines.push(format!(- "- Skills from this plugin are prefixed with `{}:`.",- plugin.display_name+ "- Skills from this plugin are prefixed with `{skill_namespace}:`."));}@@ -54,7 +62,18 @@ pub(crate) fn render_explicit_plugin_instructions(lines.push("Use these plugin-associated capabilities to help solve the task.".to_string());- Some(lines.join("\n"))+ Some(bound_explicit_plugin_instructions(lines.join("\n")))+}++fn bound_explicit_plugin_instructions(rendered: String) -> String {+ if rendered.len() <= MAX_EXPLICIT_PLUGIN_INSTRUCTIONS_BYTES {+ return rendered;+ }++ let max_prefix_bytes = MAX_EXPLICIT_PLUGIN_INSTRUCTIONS_BYTES+ .saturating_sub(TRUNCATED_PLUGIN_INSTRUCTIONS_SUFFIX.len());+ let prefix = take_bytes_at_char_boundary(&rendered, max_prefix_bytes);+ format!("{prefix}{TRUNCATED_PLUGIN_INSTRUCTIONS_SUFFIX}")}#[cfg(test)]diff --git a/codex-rs/core/src/plugins/render_tests.rs b/codex-rs/core/src/plugins/render_tests.rsindex ee7ea8c81a..e264f8b2b1 100644--- a/codex-rs/core/src/plugins/render_tests.rs+++ b/codex-rs/core/src/plugins/render_tests.rs@@ -11,6 +11,7 @@ fn render_plugins_section_keeps_plugin_usage_guidance_without_listing_plugins()let rendered = render_plugins_section(&[PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: None,description: Some("inspect sample data".to_string()),has_skills: true,..PluginCapabilitySummary::default()@@ -21,3 +22,43 @@ fn render_plugins_section_keeps_plugin_usage_guidance_without_listing_plugins()assert_eq!(rendered, expected);}++#[test]+fn explicit_plugin_instructions_use_manifest_namespace_for_skills() {+ let rendered = render_explicit_plugin_instructions(+ &PluginCapabilitySummary {+ config_name: "acme.tools@test".to_string(),+ display_name: "Acme Developer Tools".to_string(),+ plugin_namespace: Some("acme.tools".to_string()),+ has_skills: true,+ ..PluginCapabilitySummary::default()+ },+ &[],+ &[],+ )+ .expect("skill capability should render");++ assert!(rendered.contains("`acme.tools:`"));+ assert!(!rendered.contains("`Acme Developer Tools:`"));+}++#[test]+fn explicit_plugin_instructions_are_bounded() {+ let servers = (0..1_024)+ .map(|index| format!("server-{index}"))+ .collect::<Vec<_>>();++ let rendered = render_explicit_plugin_instructions(+ &PluginCapabilitySummary {+ config_name: "sample@test".to_string(),+ display_name: "sample".to_string(),+ ..PluginCapabilitySummary::default()+ },+ &servers,+ &[],+ )+ .expect("MCP capability should render");++ assert!(rendered.len() <= MAX_EXPLICIT_PLUGIN_INSTRUCTIONS_BYTES);+ assert!(rendered.ends_with(TRUNCATED_PLUGIN_INSTRUCTIONS_SUFFIX));+}diff --git a/codex-rs/core/src/tools/handlers/mcp.rs b/codex-rs/core/src/tools/handlers/mcp.rsindex a8f35690b4..7a67372737 100644--- a/codex-rs/core/src/tools/handlers/mcp.rs+++ b/codex-rs/core/src/tools/handlers/mcp.rs@@ -23,6 +23,7 @@ use codex_tools::ToolName;use codex_tools::ToolSearchInfo;use codex_tools::ToolSearchSourceInfo;use codex_tools::ToolSpec;+use codex_tools::agent_plugin_mcp_tool_to_responses_api_tool;use codex_tools::mcp_tool_to_responses_api_tool;use codex_utils_string::take_bytes_at_char_boundary;use futures::future::BoxFuture;@@ -31,6 +32,7 @@ use serde_json::Value;const LEGACY_MCP_TOOL_NAME_PREFIX: &str = "mcp__";const MCP_TOOL_NAME_DELIMITER: &str = "__";+const MAX_AGENT_PLUGIN_MCP_NAMESPACE_DESCRIPTION_BYTES: usize = 1_000;const MAX_MCP_NAMESPACE_DESCRIPTION_BYTES: usize = 512 * 1024;pub struct McpHandler {@@ -40,10 +42,38 @@ pub struct McpHandler {impl McpHandler {pub fn new(tool_info: ToolInfo) -> Result<Self, serde_json::Error> {- let spec = create_tool_spec(&tool_info)?;+ Self::with_agent_plugin(tool_info, /*agent_plugin*/ false)+ }++ pub fn new_agent_plugin(tool_info: ToolInfo) -> Result<Self, serde_json::Error> {+ Self::with_agent_plugin(tool_info, /*agent_plugin*/ true)+ }++ fn with_agent_plugin(+ mut tool_info: ToolInfo,+ agent_plugin: bool,+ ) -> Result<Self, serde_json::Error> {+ if agent_plugin {+ tool_info.namespace_description =+ tool_info+ .namespace_description+ .as_deref()+ .map(|description| {+ take_bytes_at_char_boundary(+ description,+ MAX_AGENT_PLUGIN_MCP_NAMESPACE_DESCRIPTION_BYTES,+ )+ .to_string()+ });+ }+ let spec = create_tool_spec(&tool_info, agent_plugin)?;Ok(Self { tool_info, spec })}+ pub(crate) fn model_spec_bytes(&self) -> Result<usize, serde_json::Error> {+ serde_json::to_vec(&self.spec).map(|spec| spec.len())+ }+fn hook_tool_name(&self) -> HookToolName {HookToolName::new(ensure_mcp_prefix(&join_tool_name(&self.tool_name())))}@@ -236,9 +266,16 @@ impl CoreToolRuntime for McpHandler {}}-fn create_tool_spec(tool_info: &ToolInfo) -> Result<ToolSpec, serde_json::Error> {+fn create_tool_spec(+ tool_info: &ToolInfo,+ agent_plugin: bool,+) -> Result<ToolSpec, serde_json::Error> {let tool_name = tool_info.canonical_tool_name();- let tool = mcp_tool_to_responses_api_tool(&tool_name, &tool_info.tool)?;+ let tool = if agent_plugin {+ agent_plugin_mcp_tool_to_responses_api_tool(&tool_name, &tool_info.tool)?+ } else {+ mcp_tool_to_responses_api_tool(&tool_name, &tool_info.tool)?+ };let description = tool_info.namespace_description.as_deref()diff --git a/codex-rs/core/src/tools/handlers/mcp_search_tests.rs b/codex-rs/core/src/tools/handlers/mcp_search_tests.rsindex af8797f02c..d4e8d162ec 100644--- a/codex-rs/core/src/tools/handlers/mcp_search_tests.rs+++ b/codex-rs/core/src/tools/handlers/mcp_search_tests.rs@@ -89,6 +89,27 @@ fn mcp_namespace_descriptions_are_bounded_at_512_kib() {assert_eq!(namespace.description, expected_description);}+#[test]+fn agent_plugin_namespace_descriptions_use_the_stricter_bound() {+ let expected_description = "é".repeat(MAX_AGENT_PLUGIN_MCP_NAMESPACE_DESCRIPTION_BYTES / 2);+ let mut info = tool_info();+ info.namespace_description = Some(format!("{expected_description}overflow"));+ let handler = McpHandler::new_agent_plugin(info).expect("MCP tool spec should build");+ let search_info = handler.search_info().expect("MCP search info");++ assert_eq!(+ search_info.source_info,+ Some(ToolSearchSourceInfo {+ name: "Calendar".to_string(),+ description: Some(expected_description.clone()),+ })+ );+ let LoadableToolSpec::Namespace(namespace) = search_info.entry.output else {+ panic!("expected namespace search output");+ };+ assert_eq!(namespace.description, expected_description);+}+fn tool_info() -> ToolInfo {ToolInfo {server_name: "codex-apps".to_string(),diff --git a/codex-rs/core/src/tools/spec_plan.rs b/codex-rs/core/src/tools/spec_plan.rsindex 50464f5c1e..a1d98c43a6 100644--- a/codex-rs/core/src/tools/spec_plan.rs+++ b/codex-rs/core/src/tools/spec_plan.rs@@ -150,6 +150,7 @@ pub(crate) fn build_tool_router(mcp.tools(),&turn_context.config,apps_enabled,+ &mcp.config().mcp_server_catalog,search_tool_enabled(turn_context),&mut registry,);diff --git a/codex-rs/core/tests/suite/plugins.rs b/codex-rs/core/tests/suite/plugins.rsindex 31035b5e42..4fc1d50768 100644--- a/codex-rs/core/tests/suite/plugins.rs+++ b/codex-rs/core/tests/suite/plugins.rs@@ -31,6 +31,7 @@ use core_test_support::responses::ResponsesRequest;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;use core_test_support::responses::ev_function_call;+use core_test_support::responses::ev_function_call_with_namespace;use core_test_support::responses::ev_response_created;use core_test_support::responses::ev_tool_search_call;use core_test_support::responses::mount_sse_once;@@ -164,6 +165,38 @@ fn write_sample_plugin_skill(plugin_root: std::path::PathBuf) -> std::path::Pathskill_dir.join("SKILL.md")}+fn write_agent_plugin_skill_plugin(home: &TempDir) -> std::path::PathBuf {+ let plugin_root = home.path().join("plugins/cache/test/acme.tools/local");+ let direct_skill = plugin_root.join("skills/review");+ let nested_skill = plugin_root.join("skills/group/hidden");+ std::fs::create_dir_all(&direct_skill).expect("create direct skill");+ std::fs::create_dir_all(&nested_skill).expect("create nested skill");+ std::fs::write(+ plugin_root.join("plugin.json"),+ r#"{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","name":"acme.tools","extensions":{"com.openai":{"interface":{"displayName":"Acme Developer Tools"}}}}"#,+ )+ .expect("write Agent Plugin manifest");+ std::fs::write(+ direct_skill.join("SKILL.md"),+ format!(+ "---\nname: review\ndescription: Review code\n---\n\n{}\nAGENT_SKILL_TRUNCATED_TAIL\n",+ "x".repeat(9_000)+ ),+ )+ .expect("write direct skill");+ std::fs::write(+ nested_skill.join("SKILL.md"),+ "---\nname: hidden\ndescription: Hidden skill\n---\n\nHidden.\n",+ )+ .expect("write nested skill");+ std::fs::write(+ home.path().join("config.toml"),+ "[features]\nplugins = true\n\n[plugins.\"acme.tools@test\"]\nenabled = true\n",+ )+ .expect("write Agent Plugin config");+ direct_skill.join("SKILL.md")+}+fn write_plugin_mcp_plugin(home: &TempDir, command: &str) {let plugin_root = write_sample_plugin_manifest_and_config(home);std::fs::write(@@ -485,6 +518,234 @@ async fn capability_sections_render_in_developer_message_in_order() -> Result<()Ok(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn agent_plugin_skills_use_shared_catalog_and_direct_child_discovery() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let resp_mock = mount_sse_once(+ &server,+ sse(vec![ev_response_created("resp1"), ev_completed("resp1")]),+ )+ .await;+ let codex_home = Arc::new(TempDir::new()?);+ let skill_path = std::fs::canonicalize(write_agent_plugin_skill_plugin(codex_home.as_ref()))?;+ let test_codex = test_codex()+ .with_home(Arc::clone(&codex_home))+ .with_extensions(skills_extensions())+ .build(&server)+ .await?;++ test_codex+ .codex+ .submit(Op::UserInput {+ items: vec![UserInput::Skill {+ name: "acme.tools:review".into(),+ path: skill_path,+ }],+ final_output_json_schema: None,+ responsesapi_client_metadata: None,+ additional_context: Default::default(),+ thread_settings: Default::default(),+ })+ .await?;+ let warning = wait_for_event(&test_codex.codex, |ev| {+ matches!(+ ev,+ EventMsg::Warning(warning)+ if warning.message.contains("main prompt context limit")+ )+ })+ .await;+ wait_for_event(&test_codex.codex, |ev| {+ matches!(ev, EventMsg::TurnComplete(_))+ })+ .await;++ let developer_text = resp_mock+ .single_request()+ .message_input_texts("developer")+ .join("\n");+ assert!(developer_text.contains("acme.tools:review: Review code"));+ assert!(!developer_text.contains("acme.tools:hidden"));+ let user_text = resp_mock+ .single_request()+ .message_input_texts("user")+ .join("\n");+ assert!(user_text.contains("acme.tools:review"));+ assert!(!user_text.contains("AGENT_SKILL_TRUNCATED_TAIL"));+ let EventMsg::Warning(warning) = warning else {+ unreachable!("wait_for_event matched an Agent skill truncation warning")+ };+ assert!(warning.message.contains("acme.tools:review"));+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn legacy_plugin_skill_prompt_remains_complete() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let resp_mock = mount_sse_once(+ &server,+ sse(vec![ev_response_created("resp1"), ev_completed("resp1")]),+ )+ .await;+ let codex_home = Arc::new(TempDir::new()?);+ let skill_path = write_plugin_skill_plugin(codex_home.as_ref());+ let skill_contents = format!(+ "---\nname: sample-search\ndescription: inspect sample data\n---\n\n{}\nLEGACY_SKILL_FULL_TAIL\n",+ "x".repeat(9_000)+ );+ std::fs::write(&skill_path, &skill_contents)?;+ let skill_path = std::fs::canonicalize(skill_path)?;+ let test_codex = test_codex()+ .with_home(codex_home)+ .with_extensions(skills_extensions())+ .build(&server)+ .await?;++ test_codex+ .codex+ .submit(Op::UserInput {+ items: vec![UserInput::Skill {+ name: "sample:sample-search".into(),+ path: skill_path,+ }],+ final_output_json_schema: None,+ responsesapi_client_metadata: None,+ additional_context: Default::default(),+ thread_settings: Default::default(),+ })+ .await?;+ wait_for_event(&test_codex.codex, |ev| {+ matches!(ev, EventMsg::TurnComplete(_))+ })+ .await;++ let user_text = resp_mock+ .single_request()+ .message_input_texts("user")+ .join("\n");+ assert!(user_text.contains(&skill_contents));+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn agent_plugin_root_mcp_stdio_tool_round_trip_expands_reserved_paths() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let search_call_id = "search-agent-echo";+ let tool_call_id = "call-agent-echo";+ let mock = mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_response_created("resp-1"),+ ev_tool_search_call(search_call_id, &serde_json::json!({"query": "echo"})),+ ev_completed("resp-1"),+ ]),+ sse(vec![+ ev_response_created("resp-2"),+ ev_function_call_with_namespace(+ tool_call_id,+ "mcp__agent",+ "echo",+ r#"{"message":"ping"}"#,+ ),+ ev_completed("resp-2"),+ ]),+ sse(vec![+ ev_response_created("resp-3"),+ ev_assistant_message("msg-1", "done"),+ ev_completed("resp-3"),+ ]),+ ],+ )+ .await;+ let codex_home = Arc::new(TempDir::new()?);+ write_agent_plugin_skill_plugin(codex_home.as_ref());+ let plugin_root = codex_home+ .path()+ .join("plugins/cache/test/acme.tools/local");+ let stdio_server = match stdio_server_bin() {+ Ok(path) => path,+ Err(err) => {+ eprintln!("test_stdio_server binary not available, skipping test: {err}");+ return Ok(());+ }+ };+ let stdio_server_name = format!("test_stdio_server{}", std::env::consts::EXE_SUFFIX);+ std::fs::copy(stdio_server, plugin_root.join(&stdio_server_name))?;+ let mcp_config = serde_json::json!({+ "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",+ "mcpServers": {+ "agent": {+ "type": "stdio",+ "command": format!("./{stdio_server_name}"),+ "env": {"MCP_TEST_VALUE": "${PLUGIN_ROOT}|${PLUGIN_DATA}"}+ }+ }+ });+ std::fs::write(+ plugin_root.join("mcp.json"),+ serde_json::to_vec_pretty(&mcp_config)?,+ )?;+ let test_codex = test_codex()+ .with_home(Arc::clone(&codex_home))+ .build(&server)+ .await?;+ wait_for_mcp_server(&test_codex.codex, "agent").await?;+ let data_root = std::fs::read_dir(codex_home.path().join("plugins/data/agent-plugins"))?+ .next()+ .expect("Agent Plugin data root")?+ .path()+ .canonicalize()?;+ let expected_env = format!(+ "{}|{}",+ plugin_root.canonicalize()?.display(),+ data_root.display()+ );++ test_codex+ .codex+ .submit(Op::UserInput {+ items: vec![UserInput::Text {+ text: "call the Agent Plugin echo tool".into(),+ text_elements: Vec::new(),+ }],+ final_output_json_schema: None,+ responsesapi_client_metadata: None,+ additional_context: Default::default(),+ thread_settings: Default::default(),+ })+ .await?;+ let end = wait_for_event(&test_codex.codex, |event| {+ matches!(event, EventMsg::McpToolCallEnd(_))+ })+ .await;+ wait_for_event(&test_codex.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ let EventMsg::McpToolCallEnd(end) = end else {+ unreachable!("wait_for_event matched an MCP tool end")+ };+ let result = end.result.as_ref().expect("Agent Plugin MCP tool result");+ assert_eq!(+ result+ .structured_content+ .as_ref()+ .and_then(|content| content.get("env"))+ .and_then(serde_json::Value::as_str),+ Some(expected_env.as_str())+ );+ let requests = mock.requests();+ let search_output = requests[1].tool_search_output(search_call_id);+ assert!(namespace_child_tool(&search_output, "mcp__agent", "echo").is_some());+ assert!(requests[2].function_call_output(tool_call_id).is_object());+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn agent_turns_route_curated_plugin_skills_after_auth_switch() -> Result<()> {const CHATGPT_CURATED_PLUGIN_SKILL: &str = "chatgpt-plugin:chatgpt-skill";diff --git a/codex-rs/ext/skills/src/render.rs b/codex-rs/ext/skills/src/render.rsindex 7b22230b49..05c41e45ee 100644--- a/codex-rs/ext/skills/src/render.rs+++ b/codex-rs/ext/skills/src/render.rs@@ -5,6 +5,7 @@ use std::path::Component;use std::path::Path;use std::path::PathBuf;+use codex_core_skills::MAX_SKILL_PROMPT_BYTES;use codex_protocol::protocol::SkillScope;use codex_utils_string::approx_token_count;use codex_utils_string::take_bytes_at_char_boundary;@@ -17,7 +18,6 @@ use crate::fragments::AvailableSkillsInstructions;const DEFAULT_SKILL_METADATA_CHAR_BUDGET: usize = 8_000;const SKILL_METADATA_CONTEXT_WINDOW_PERCENT: usize = 2;-const MAX_MAIN_PROMPT_BYTES: usize = 8_000;const MAX_CATALOG_SKILL_DESCRIPTION_CHARS: usize = 1_024;const TRUNCATED_SKILL_DESCRIPTION_SUFFIX: &str = "...";const SKILL_DESCRIPTION_TRUNCATION_WARNING_THRESHOLD_CHARS: usize = 100;@@ -1083,7 +1083,7 @@ pub(crate) fn truncate_catalog_skill_description(description: &str) -> Cow<'_, s}pub(crate) fn truncate_main_prompt_contents(contents: &str) -> (String, bool) {- truncate_utf8_to_bytes(contents, MAX_MAIN_PROMPT_BYTES)+ truncate_utf8_to_bytes(contents, MAX_SKILL_PROMPT_BYTES)}pub(crate) fn truncate_utf8_to_bytes(contents: &str, max_bytes: usize) -> (String, bool) {diff --git a/codex-rs/plugin/src/lib.rs b/codex-rs/plugin/src/lib.rsindex 8a00d8c5ef..452c00b906 100644--- a/codex-rs/plugin/src/lib.rs+++ b/codex-rs/plugin/src/lib.rs@@ -52,6 +52,7 @@ pub fn app_connector_ids_from_declarations<'a>(pub struct PluginCapabilitySummary {pub config_name: String,pub display_name: String,+ pub plugin_namespace: Option<String>,pub description: Option<String>,pub has_skills: bool,pub mcp_server_names: Vec<String>,diff --git a/codex-rs/plugin/src/load_outcome.rs b/codex-rs/plugin/src/load_outcome.rsindex 5fd1320c09..0ebb81ad07 100644--- a/codex-rs/plugin/src/load_outcome.rs+++ b/codex-rs/plugin/src/load_outcome.rs@@ -25,6 +25,7 @@ pub struct LoadedPlugin<M> {pub root: AbsolutePathBuf,pub enabled: bool,pub skill_roots: Vec<AbsolutePathBuf>,+ pub skill_discovery_mode: SkillDiscoveryMode,pub disabled_skill_paths: HashSet<AbsolutePathBuf>,pub has_enabled_skills: bool,pub mcp_servers: HashMap<String, M>,@@ -42,6 +43,10 @@ impl<M> LoadedPlugin<M> {pub fn display_name(&self) -> &str {self.manifest_name.as_deref().unwrap_or(&self.config_name)}++ pub fn is_agent_plugin(&self) -> bool {+ self.skill_discovery_mode == SkillDiscoveryMode::DirectChildren+ }}fn plugin_capability_summary_from_loaded<M>(@@ -57,6 +62,7 @@ fn plugin_capability_summary_from_loaded<M>(let summary = PluginCapabilitySummary {config_name: plugin.config_name.clone(),display_name: plugin.display_name().to_string(),+ plugin_namespace: plugin.plugin_namespace.clone(),description: prompt_safe_plugin_description(plugin.manifest_description.as_deref()),has_skills: plugin.has_enabled_skills,mcp_server_names,@@ -143,7 +149,7 @@ impl<M: Clone> PluginLoadOutcome<M> {},plugin_namespace: plugin_namespace.clone(),plugin_root: plugin.root.clone(),- discovery_mode: SkillDiscoveryMode::Recursive,+ discovery_mode: plugin.skill_discovery_mode,});}}@@ -241,6 +247,7 @@ mod tests {root: test_path(config_name),enabled: true,skill_roots,+ skill_discovery_mode: SkillDiscoveryMode::Recursive,disabled_skill_paths: HashSet::new(),has_enabled_skills: true,mcp_servers: HashMap::new(),diff --git a/codex-rs/rmcp-client/src/auth_status.rs b/codex-rs/rmcp-client/src/auth_status.rsindex c85b784da4..d29419b410 100644--- a/codex-rs/rmcp-client/src/auth_status.rs+++ b/codex-rs/rmcp-client/src/auth_status.rs@@ -12,6 +12,7 @@ use rmcp::transport::AuthorizationManager;use rmcp::transport::auth::AuthError;use tracing::debug;+use crate::http_client_adapter::StreamableHttpRedirectMode;use crate::oauth::StoredOAuthTokenStatus;use crate::oauth::oauth_token_status;use crate::oauth_http_client::OAuthHttpClientAdapter;@@ -85,7 +86,9 @@ pub async fn determine_streamable_http_auth_status(keyring_backend_kind: AuthKeyringBackendKind,http_client: Arc<dyn HttpClient>,discovery_timeout: OAuthDiscoveryTimeout,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<McpAuthState> {+ let has_configured_headers = has_configured_headers(&http_headers, &env_http_headers);let default_headers = match auth_status_before_discovery(server_name,url,@@ -106,6 +109,8 @@ pub async fn determine_streamable_http_auth_status(default_headers,http_client,discovery_timeout,+ has_configured_headers,+ redirect_mode,).await,)@@ -193,13 +198,17 @@ pub async fn discover_streamable_http_oauth(env_http_headers: Option<HashMap<String, String>>,http_client: Arc<dyn HttpClient>,discovery_timeout: OAuthDiscoveryTimeout,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<Option<StreamableHttpOAuthDiscovery>> {+ let has_configured_headers = has_configured_headers(&http_headers, &env_http_headers);let default_headers = build_default_headers(http_headers, env_http_headers)?;discover_streamable_http_oauth_with_headers_and_http_client(url,default_headers,http_client,discovery_timeout,+ has_configured_headers,+ redirect_mode,).await}@@ -209,13 +218,24 @@ async fn discover_streamable_http_oauth_with_headers_and_http_client(default_headers: HeaderMap,http_client: Arc<dyn HttpClient>,discovery_timeout: OAuthDiscoveryTimeout,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<Option<StreamableHttpOAuthDiscovery>> {let oauth_http_client = match discovery_timeout {- OAuthDiscoveryTimeout::Requested => {- OAuthHttpClientAdapter::new(http_client, default_headers)- }+ OAuthDiscoveryTimeout::Requested => OAuthHttpClientAdapter::new_with_redirect_mode(+ http_client,+ default_headers,+ has_configured_headers,+ redirect_mode,+ ),OAuthDiscoveryTimeout::Capped(max_timeout) => {- OAuthHttpClientAdapter::new_with_max_timeout(http_client, default_headers, max_timeout)+ OAuthHttpClientAdapter::new_with_max_timeout_and_redirect_mode(+ http_client,+ default_headers,+ max_timeout,+ has_configured_headers,+ redirect_mode,+ )}};let mut authorization_manager =@@ -224,6 +244,18 @@ async fn discover_streamable_http_oauth_with_headers_and_http_client(discover_streamable_http_oauth_with_manager(&authorization_manager).await}+fn has_configured_headers(+ http_headers: &Option<HashMap<String, String>>,+ env_http_headers: &Option<HashMap<String, String>>,+) -> bool {+ http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty())+ || env_http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty())+}+async fn discover_streamable_http_oauth_with_manager(authorization_manager: &AuthorizationManager,) -> Result<Option<StreamableHttpOAuthDiscovery>> {@@ -268,6 +300,7 @@ mod tests {use axum::http::header::WWW_AUTHENTICATE;use axum::routing::get;use codex_exec_server::ExecServerError;+ use codex_exec_server::HttpRedirectPolicy;use codex_exec_server::HttpRequestParams;use codex_exec_server::HttpRequestResponse;use codex_exec_server::HttpResponseBodyStream;@@ -308,6 +341,7 @@ mod tests {#[derive(Default)]struct RecordingHttpClient {headers: Mutex<Option<Vec<(String, String)>>>,+ redirect_policy: Mutex<Option<HttpRedirectPolicy>>,timeout_ms: Mutex<Option<Option<u64>>>,}@@ -342,6 +376,11 @@ mod tests {.timeout_ms.lock().expect("timeout recorder lock should not be poisoned") = Some(params.timeout_ms);+ *self+ .redirect_policy+ .lock()+ .expect("redirect policy recorder lock should not be poisoned") =+ Some(params.redirect_policy);Box::pin(async {Err(ExecServerError::HttpRequest("expected discovery request failure".to_string(),@@ -440,6 +479,7 @@ mod tests {AuthKeyringBackendKind::default(),test_http_client(),OAuthDiscoveryTimeout::Requested,+ StreamableHttpRedirectMode::Legacy,).await.expect("status should compute");@@ -464,6 +504,7 @@ mod tests {AuthKeyringBackendKind::default(),test_http_client(),OAuthDiscoveryTimeout::Requested,+ StreamableHttpRedirectMode::Legacy,).await.expect("status should compute");@@ -518,6 +559,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await;assert_eq!(@@ -560,6 +602,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect_err("cross-origin OAuth discovery redirects must be rejected");@@ -602,6 +645,7 @@ mod tests {AuthKeyringBackendKind::default(),test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect_err("transient OAuth discovery failures must not become unsupported access");@@ -632,6 +676,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect("discovery should succeed")@@ -653,6 +698,7 @@ mod tests {/*env_http_headers*/ None,http_client.clone(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await;@@ -679,6 +725,7 @@ mod tests {/*env_http_headers*/ None,http_client.clone(),OAuthDiscoveryTimeout::Requested,+ StreamableHttpRedirectMode::Legacy,).await;@@ -693,7 +740,7 @@ mod tests {}#[tokio::test]- async fn routed_oauth_discovery_preserves_configured_headers() {+ async fn routed_agent_plugin_oauth_discovery_stops_with_configured_headers() {let http_client = Arc::new(RecordingHttpClient::default());let discovery = discover_streamable_http_oauth(@@ -705,6 +752,7 @@ mod tests {/*env_http_headers*/ None,http_client.clone(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::AgentPluginV1,).await;@@ -722,6 +770,13 @@ mod tests {.map(|(_, value)| value.as_str()),Some("configured-value"));+ assert_eq!(+ *http_client+ .redirect_policy+ .lock()+ .expect("redirect policy recorder lock should not be poisoned"),+ Some(HttpRedirectPolicy::Stop)+ );}#[tokio::test]@@ -774,6 +829,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect("discovery should succeed")@@ -800,6 +856,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect("discovery should succeed")@@ -822,6 +879,7 @@ mod tests {/*env_http_headers*/ None,test_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await.expect("support check should succeed")diff --git a/codex-rs/rmcp-client/src/http_client_adapter.rs b/codex-rs/rmcp-client/src/http_client_adapter.rsindex 23220cdf53..bde57a9d99 100644--- a/codex-rs/rmcp-client/src/http_client_adapter.rs+++ b/codex-rs/rmcp-client/src/http_client_adapter.rs@@ -63,11 +63,19 @@ const HEADER_SESSION_ID: &str = "Mcp-Session-Id";const NON_JSON_RESPONSE_BODY_PREVIEW_BYTES: usize = 8_192;const LEGACY_HTTP_PREVALIDATION_ERROR_CODE: ErrorCode = ErrorCode(-32000);+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum StreamableHttpRedirectMode {+ Legacy,+ AgentPluginV1,+}+#[derive(Clone)]pub(crate) struct StreamableHttpClientAdapter {http_client: Arc<dyn HttpClient>,default_headers: HeaderMap,auth_provider: Option<SharedAuthProvider>,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,}#[derive(Debug, thiserror::Error)]@@ -87,13 +95,21 @@ impl StreamableHttpClientAdapter {http_client: Arc<dyn HttpClient>,default_headers: HeaderMap,auth_provider: Option<SharedAuthProvider>,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,) -> Self {Self {http_client,default_headers,auth_provider,+ has_configured_headers,+ redirect_mode,}}++ fn redirect_policy(&self, headers: &HeaderMap) -> HttpRedirectPolicy {+ mcp_redirect_policy(self.redirect_mode, headers, self.has_configured_headers)+ }}impl StreamableHttpClient for StreamableHttpClientAdapter {@@ -150,7 +166,7 @@ impl StreamableHttpClient for StreamableHttpClientAdapter {let redirect_policy = if mcp_method.as_deref() == Some(DiscoverRequestMethod::VALUE) {HttpRedirectPolicy::Stop} else {- mcp_redirect_policy(&headers)+ self.redirect_policy(&headers)};let body = serde_json::to_vec(&message).map_err(StreamableHttpError::Deserialize)?;@@ -348,7 +364,7 @@ impl StreamableHttpClient for StreamableHttpClientAdapter {session.to_string(),StreamableHttpClientAdapterError::Header,)?;- let redirect_policy = mcp_redirect_policy(&headers);+ let redirect_policy = self.redirect_policy(&headers);let response = self.http_client@@ -421,7 +437,7 @@ impl StreamableHttpClient for StreamableHttpClientAdapter {StreamableHttpClientAdapterError::Header,)?;}- let redirect_policy = mcp_redirect_policy(&headers);+ let redirect_policy = self.redirect_policy(&headers);let (response, body_stream) = self.http_client@@ -646,11 +662,17 @@ fn parse_json_rpc_error(body: &[u8]) -> Option<ServerJsonRpcMessage> {}}-fn mcp_redirect_policy(headers: &HeaderMap) -> HttpRedirectPolicy {+fn mcp_redirect_policy(+ mode: StreamableHttpRedirectMode,+ headers: &HeaderMap,+ has_configured_headers: bool,+) -> HttpRedirectPolicy {if headers.get(HEADER_MCP_PROTOCOL_VERSION).and_then(|value| value.to_str().ok())== Some(ProtocolVersion::V_2026_07_28.as_str())+ || (mode == StreamableHttpRedirectMode::AgentPluginV1+ && (has_configured_headers || headers.contains_key(AUTHORIZATION))){HttpRedirectPolicy::Stop} else {diff --git a/codex-rs/rmcp-client/src/http_client_adapter_tests.rs b/codex-rs/rmcp-client/src/http_client_adapter_tests.rsindex a615beec4e..7452f5b400 100644--- a/codex-rs/rmcp-client/src/http_client_adapter_tests.rs+++ b/codex-rs/rmcp-client/src/http_client_adapter_tests.rs@@ -1,11 +1,15 @@use std::io::ErrorKind;+use codex_exec_server::HttpRedirectPolicy;use http::HeaderMap;use http::HeaderValue;+use http::header::AUTHORIZATION;use pretty_assertions::assert_eq;use super::HttpHeader;use super::SseEventSizeLimit;+use super::StreamableHttpRedirectMode;+use super::mcp_redirect_policy;use super::protocol_headers;#[test]@@ -25,6 +29,64 @@ fn protocol_headers_preserve_utf8_values() {);}+#[test]+fn legacy_configured_headers_follow_redirects() {+ assert_eq!(+ mcp_redirect_policy(+ StreamableHttpRedirectMode::Legacy,+ &HeaderMap::new(),+ /*has_configured_headers*/ true,+ ),+ HttpRedirectPolicy::Follow+ );+}++#[test]+fn agent_plugin_configured_headers_stop_redirects() {+ assert_eq!(+ mcp_redirect_policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ &HeaderMap::new(),+ /*has_configured_headers*/ true,+ ),+ HttpRedirectPolicy::Stop+ );+}++#[test]+fn requests_without_sensitive_headers_follow_redirects() {+ assert_eq!(+ mcp_redirect_policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ &HeaderMap::new(),+ /*has_configured_headers*/ false,+ ),+ HttpRedirectPolicy::Follow+ );+}++#[test]+fn authorization_redirects_depend_on_mode() {+ let mut headers = HeaderMap::new();+ headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer secret"));+ assert_eq!(+ mcp_redirect_policy(+ StreamableHttpRedirectMode::Legacy,+ &headers,+ /*has_configured_headers*/ false,+ ),+ HttpRedirectPolicy::Follow+ );+ assert_eq!(+ mcp_redirect_policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ &headers,+ /*has_configured_headers*/ false,+ ),+ HttpRedirectPolicy::Stop+ );+}+#[test]fn lf_terminators_reset_the_event_limit() {let mut limit = SseEventSizeLimit::new(Some(8));diff --git a/codex-rs/rmcp-client/src/lib.rs b/codex-rs/rmcp-client/src/lib.rsindex 0ed0f5d054..80ac068684 100644--- a/codex-rs/rmcp-client/src/lib.rs+++ b/codex-rs/rmcp-client/src/lib.rs@@ -24,6 +24,7 @@ pub use auth_status::determine_streamable_http_auth_status;pub use auth_status::determine_streamable_http_auth_status_from_credentials;pub use auth_status::discover_streamable_http_oauth;pub use codex_protocol::protocol::McpAuthStatus;+pub use http_client_adapter::StreamableHttpRedirectMode;pub use in_process_transport::InProcessTransportFactory;pub use oauth::StoredOAuthTokens;pub use oauth::WrappedOAuthTokenResponse;diff --git a/codex-rs/rmcp-client/src/oauth_http_client.rs b/codex-rs/rmcp-client/src/oauth_http_client.rsindex 4787238c7f..681887c3d7 100644--- a/codex-rs/rmcp-client/src/oauth_http_client.rs+++ b/codex-rs/rmcp-client/src/oauth_http_client.rs@@ -8,6 +8,7 @@ use codex_exec_server::HttpHeader;use codex_exec_server::HttpRedirectPolicy;use codex_exec_server::HttpRequestParams;use http::HeaderMap;+use http::header::AUTHORIZATION;use oauth2::HttpRequest;use oauth2::HttpResponse;use rmcp::transport::auth::OAuthHttpClient;@@ -17,6 +18,7 @@ use rmcp::transport::auth::OAuthHttpRedirectPolicy;use rmcp::transport::auth::OAuthHttpRequest;use crate::auth_status::OAuthDiscoveryTimeout;+use crate::http_client_adapter::StreamableHttpRedirectMode;const MAX_OAUTH_HTTP_RESPONSE_BODY_BYTES: usize = 1024 * 1024;static NEXT_OAUTH_REQUEST_ID: AtomicU64 = AtomicU64::new(0);@@ -40,26 +42,50 @@ pub(crate) struct OAuthHttpClientAdapter {http_client: Arc<dyn HttpClient>,default_headers: HeaderMap,timeout: OAuthDiscoveryTimeout,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,}impl OAuthHttpClientAdapter {+ #[cfg(test)]pub(crate) fn new(http_client: Arc<dyn HttpClient>, default_headers: HeaderMap) -> Self {Self {http_client,default_headers,timeout: OAuthDiscoveryTimeout::Requested,+ has_configured_headers: false,+ redirect_mode: StreamableHttpRedirectMode::Legacy,}}- pub(crate) fn new_with_max_timeout(+ pub(crate) fn new_with_redirect_mode(+ http_client: Arc<dyn HttpClient>,+ default_headers: HeaderMap,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,+ ) -> Self {+ Self {+ http_client,+ default_headers,+ timeout: OAuthDiscoveryTimeout::Requested,+ has_configured_headers,+ redirect_mode,+ }+ }++ pub(crate) fn new_with_max_timeout_and_redirect_mode(http_client: Arc<dyn HttpClient>,default_headers: HeaderMap,max_timeout: Duration,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,) -> Self {Self {http_client,default_headers,timeout: OAuthDiscoveryTimeout::Capped(max_timeout),+ has_configured_headers,+ redirect_mode,}}@@ -84,6 +110,12 @@ impl OAuthHttpClientAdapter {headers.remove(name);}headers.extend(parts.headers);+ let redirect_policy = oauth_redirect_policy(+ self.redirect_mode,+ &headers,+ self.has_configured_headers,+ redirect_policy,+ );let headers = headers.iter()@@ -139,8 +171,84 @@ impl OAuthHttpClientAdapter {}}+fn oauth_redirect_policy(+ mode: StreamableHttpRedirectMode,+ headers: &HeaderMap,+ has_configured_headers: bool,+ requested_policy: HttpRedirectPolicy,+) -> HttpRedirectPolicy {+ if mode == StreamableHttpRedirectMode::AgentPluginV1+ && (has_configured_headers || headers.contains_key(AUTHORIZATION))+ {+ HttpRedirectPolicy::Stop+ } else {+ requested_policy+ }+}+impl OAuthHttpClient for OAuthHttpClientAdapter {fn execute(&self, request: OAuthHttpRequest) -> OAuthHttpClientFuture<'_> {Box::pin(self.execute_request(request.request, request.redirect_policy, request.timeout))}}++#[cfg(test)]+mod tests {+ use http::HeaderValue;+ use pretty_assertions::assert_eq;++ use super::*;++ #[test]+ fn agent_plugin_oauth_stops_only_for_sensitive_headers() {+ assert_eq!(+ policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ /*has_configured_headers*/ true,+ /*has_authorization*/ false,+ ),+ HttpRedirectPolicy::Stop+ );+ assert_eq!(+ policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ /*has_configured_headers*/ false,+ /*has_authorization*/ true,+ ),+ HttpRedirectPolicy::Stop+ );+ assert_eq!(+ policy(+ StreamableHttpRedirectMode::AgentPluginV1,+ /*has_configured_headers*/ false,+ /*has_authorization*/ false,+ ),+ HttpRedirectPolicy::Follow+ );+ assert_eq!(+ policy(+ StreamableHttpRedirectMode::Legacy,+ /*has_configured_headers*/ true,+ /*has_authorization*/ true,+ ),+ HttpRedirectPolicy::Follow+ );+ }++ fn policy(+ mode: StreamableHttpRedirectMode,+ has_configured_headers: bool,+ has_authorization: bool,+ ) -> HttpRedirectPolicy {+ let mut headers = HeaderMap::new();+ if has_authorization {+ headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer secret"));+ }+ oauth_redirect_policy(+ mode,+ &headers,+ has_configured_headers,+ HttpRedirectPolicy::Follow,+ )+ }+}diff --git a/codex-rs/rmcp-client/src/perform_oauth_login.rs b/codex-rs/rmcp-client/src/perform_oauth_login.rsindex 023d0cf9e9..4178464187 100644--- a/codex-rs/rmcp-client/src/perform_oauth_login.rs+++ b/codex-rs/rmcp-client/src/perform_oauth_login.rs@@ -27,6 +27,7 @@ use urlencoding::decode;use crate::StoredOAuthTokens;use crate::WrappedOAuthTokenResponse;+use crate::http_client_adapter::StreamableHttpRedirectMode;use crate::oauth::compute_expires_at_millis;use crate::oauth_http_client::OAuthHttpClientAdapter;use crate::save_oauth_tokens;@@ -38,6 +39,7 @@ struct OAuthHttpContext {http_headers: Option<HashMap<String, String>>,env_http_headers: Option<HashMap<String, String>>,http_client: Arc<dyn HttpClient>,+ redirect_mode: StreamableHttpRedirectMode,}struct CallbackServerGuard {@@ -109,6 +111,7 @@ pub async fn perform_oauth_login(callback_url,http_client,/*emit_browser_url*/ true,+ StreamableHttpRedirectMode::Legacy,).await}@@ -127,6 +130,7 @@ pub async fn perform_oauth_login_silent(callback_port: Option<u16>,callback_url: Option<&str>,http_client: Arc<dyn HttpClient>,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<()> {perform_oauth_login_with_browser_output(server_name,@@ -142,6 +146,7 @@ pub async fn perform_oauth_login_silent(callback_url,http_client,/*emit_browser_url*/ false,+ redirect_mode,).await}@@ -161,11 +166,13 @@ async fn perform_oauth_login_with_browser_output(callback_url: Option<&str>,http_client: Arc<dyn HttpClient>,emit_browser_url: bool,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<()> {let http_context = OAuthHttpContext {http_headers,env_http_headers,http_client,+ redirect_mode,};OauthLoginFlow::new(server_name,@@ -201,11 +208,13 @@ pub async fn perform_oauth_login_return_url(callback_port: Option<u16>,callback_url: Option<&str>,http_client: Arc<dyn HttpClient>,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<OauthLoginHandle> {let http_context = OAuthHttpContext {http_headers,env_http_headers,http_client,+ redirect_mode,};let flow = OauthLoginFlow::new(server_name,@@ -515,9 +524,21 @@ impl OauthLoginFlow {http_headers,env_http_headers,http_client,+ redirect_mode,} = http_context;+ let has_configured_headers = http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty())+ || env_http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty());let default_headers = build_default_headers(http_headers, env_http_headers)?;- let oauth_http_client = Arc::new(OAuthHttpClientAdapter::new(http_client, default_headers));+ let oauth_http_client = Arc::new(OAuthHttpClientAdapter::new_with_redirect_mode(+ http_client,+ default_headers,+ has_configured_headers,+ redirect_mode,+ ));let scope_refs: Vec<&str> = scopes.iter().map(String::as_str).collect();let oauth_state = start_authorization(@@ -728,6 +749,7 @@ mod tests {use super::CallbackOutcome;use super::OAuthHttpClientAdapter;use super::OAuthProviderError;+ use super::StreamableHttpRedirectMode;use super::append_callback_id_to_redirect_uri;use super::append_query_param;use super::callback_id_from_server_url;@@ -975,6 +997,7 @@ mod tests {/*callback_port*/ None,/*callback_url*/ None,http_client.clone(),+ StreamableHttpRedirectMode::Legacy,).await.expect_err("OAuth metadata discovery should fail through the supplied client");diff --git a/codex-rs/rmcp-client/src/rmcp_client.rs b/codex-rs/rmcp-client/src/rmcp_client.rsindex 74cc903704..2f1501d596 100644--- a/codex-rs/rmcp-client/src/rmcp_client.rs+++ b/codex-rs/rmcp-client/src/rmcp_client.rs@@ -70,6 +70,7 @@ use tracing::warn;use crate::elicitation_client_service::ElicitationClientService;use crate::http_client_adapter::StreamableHttpClientAdapter;use crate::http_client_adapter::StreamableHttpClientAdapterError;+use crate::http_client_adapter::StreamableHttpRedirectMode;use crate::in_process_transport::InProcessTransportFactory;use crate::oauth::OAuthPersistor;use crate::oauth::ResolvedOAuthCredentialStore;@@ -139,6 +140,7 @@ enum TransportRecipe {pinned_credential_store: Arc<OnceLock<ResolvedOAuthCredentialStore>>,http_client: Arc<dyn HttpClient>,auth_provider: Option<SharedAuthProvider>,+ redirect_mode: StreamableHttpRedirectMode,},}@@ -480,6 +482,36 @@ impl RmcpClient {http_client: Arc<dyn HttpClient>,auth_provider: Option<SharedAuthProvider>,protocol_mode: McpProtocolMode,+ ) -> Result<Self> {+ Self::new_streamable_http_client_with_protocol_mode_and_redirect_mode(+ server_name,+ url,+ bearer_token,+ http_headers,+ env_http_headers,+ store_mode,+ keyring_backend_kind,+ http_client,+ auth_provider,+ protocol_mode,+ StreamableHttpRedirectMode::Legacy,+ )+ .await+ }++ #[allow(clippy::too_many_arguments)]+ pub async fn new_streamable_http_client_with_protocol_mode_and_redirect_mode(+ server_name: &str,+ url: &str,+ bearer_token: Option<String>,+ http_headers: Option<HashMap<String, String>>,+ env_http_headers: Option<HashMap<String, String>>,+ store_mode: OAuthCredentialsStoreMode,+ keyring_backend_kind: AuthKeyringBackendKind,+ http_client: Arc<dyn HttpClient>,+ auth_provider: Option<SharedAuthProvider>,+ protocol_mode: McpProtocolMode,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<Self> {let transport_recipe = TransportRecipe::StreamableHttp {server_name: server_name.to_string(),@@ -492,6 +524,7 @@ impl RmcpClient {pinned_credential_store: Arc::new(OnceLock::new()),http_client,auth_provider,+ redirect_mode,};let transport = Self::create_pending_transport(&transport_recipe).await?;Ok(Self {@@ -914,7 +947,14 @@ impl RmcpClient {pinned_credential_store,http_client,auth_provider,+ redirect_mode,} => {+ let has_configured_headers = http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty())+ || env_http_headers+ .as_ref()+ .is_some_and(|headers| !headers.is_empty());let default_headers =build_default_headers(http_headers.clone(), env_http_headers.clone())?;let auth_provider =@@ -976,6 +1016,8 @@ impl RmcpClient {credential_store,default_headers.clone(),Arc::clone(http_client),+ has_configured_headers,+ *redirect_mode,).await{@@ -1007,6 +1049,8 @@ impl RmcpClient {Arc::clone(http_client),default_headers,/*auth_provider*/ None,+ has_configured_headers,+ *redirect_mode,),http_config,);@@ -1026,6 +1070,8 @@ impl RmcpClient {Arc::clone(http_client),default_headers,auth_provider,+ has_configured_headers,+ *redirect_mode,),http_config,);@@ -1333,6 +1379,7 @@ impl RmcpClient {}}+#[allow(clippy::too_many_arguments)]async fn create_oauth_transport_and_runtime(server_name: &str,url: &str,@@ -1340,13 +1387,17 @@ async fn create_oauth_transport_and_runtime(credential_store: ResolvedOAuthCredentialStore,default_headers: HeaderMap,http_client: Arc<dyn HttpClient>,+ has_configured_headers: bool,+ redirect_mode: StreamableHttpRedirectMode,) -> Result<(StreamableHttpClientTransport<AuthClient<StreamableHttpClientAdapter>>,OAuthPersistor,)> {- let oauth_http_client = Arc::new(OAuthHttpClientAdapter::new(+ let oauth_http_client = Arc::new(OAuthHttpClientAdapter::new_with_redirect_mode(http_client.clone(),default_headers.clone(),+ has_configured_headers,+ redirect_mode,));let mut manager =AuthorizationManager::new_with_oauth_http_client(url.to_string(), oauth_http_client)@@ -1370,7 +1421,13 @@ async fn create_oauth_transport_and_runtime(};let auth_client = AuthClient::new(- StreamableHttpClientAdapter::new(http_client, default_headers, /*auth_provider*/ None),+ StreamableHttpClientAdapter::new(+ http_client,+ default_headers,+ /*auth_provider*/ None,+ has_configured_headers,+ redirect_mode,+ ),manager,);let auth_manager = auth_client.auth_manager.clone();diff --git a/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs b/codex-rs/rmcp-client/tests/mcp_2026_discovery.rsindex ed77a2a559..72968a75d3 100644--- a/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs+++ b/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs@@ -230,7 +230,7 @@ async fn modern_discovery_does_not_follow_redirects_with_sensitive_headers() ->}#[tokio::test]-async fn legacy_mcp_requests_preserve_existing_redirect_behavior() -> anyhow::Result<()> {+async fn legacy_mcp_requests_follow_redirects_with_configured_headers() -> anyhow::Result<()> {let redirect_target = MockServer::start().await;Mock::given(method("POST")).and(path("/forwarded"))diff --git a/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs b/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rsindex 8d861b5730..9c7aa54fca 100644--- a/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs+++ b/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs@@ -6,6 +6,7 @@ use codex_http_client::HttpClientFactory;use codex_http_client::OutboundProxyPolicy;use codex_rmcp_client::OAuthDiscoveryTimeout;use codex_rmcp_client::StreamableHttpOAuthDiscovery;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::discover_streamable_http_oauth;use pretty_assertions::assert_eq;use rmcp::transport::auth::AuthError;@@ -108,6 +109,7 @@ async fn discover_legacy_oauth_without_starting_an_mcp_session(OutboundProxyPolicy::ReqwestDefault,))),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await;let routed_discovery = discover_streamable_http_oauth(@@ -118,6 +120,7 @@ async fn discover_legacy_oauth_without_starting_an_mcp_session(OutboundProxyPolicy::ReqwestDefault,))),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await;@@ -197,6 +200,7 @@ async fn oauth_discovery_does_not_invent_support_for_an_unauthenticated_legacy_sOutboundProxyPolicy::ReqwestDefault,))),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await?;let local_discovery = discover_streamable_http_oauth(@@ -207,6 +211,7 @@ async fn oauth_discovery_does_not_invent_support_for_an_unauthenticated_legacy_sOutboundProxyPolicy::ReqwestDefault,))),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await?;diff --git a/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs b/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rsindex df99ca9bbb..7266cfb817 100644--- a/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs+++ b/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs@@ -12,6 +12,7 @@ use codex_rmcp_client::McpLoginRequirement;use codex_rmcp_client::OAuthDiscoveryTimeout;use codex_rmcp_client::RmcpClient;use codex_rmcp_client::StoredOAuthTokens;+use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::WrappedOAuthTokenResponse;use codex_rmcp_client::determine_streamable_http_auth_status;use codex_rmcp_client::is_authentication_required_error;@@ -297,6 +298,7 @@ async fn auth_status(server_url: &str) -> anyhow::Result<McpAuthState> {AuthKeyringBackendKind::default(),Environment::default_for_tests().get_http_client(),OAuthDiscoveryTimeout::LOCAL,+ StreamableHttpRedirectMode::Legacy,).await}diff --git a/codex-rs/tools/src/lib.rs b/codex-rs/tools/src/lib.rsindex de5749afa7..6f90e65c99 100644--- a/codex-rs/tools/src/lib.rs+++ b/codex-rs/tools/src/lib.rs@@ -38,6 +38,7 @@ pub use json_schema::JsonSchemaType;pub use json_schema::parse_tool_input_schema;pub use json_schema::parse_tool_input_schema_without_compaction;pub use mcp_tool::mcp_call_tool_result_output_schema;+pub use mcp_tool::parse_agent_plugin_mcp_tool;pub use mcp_tool::parse_mcp_tool;pub use request_plugin_install::REQUEST_PLUGIN_INSTALL_APPROVAL_KIND_VALUE;pub use request_plugin_install::REQUEST_PLUGIN_INSTALL_PERSIST_ALWAYS_VALUE;@@ -56,6 +57,7 @@ pub use responses_api::LoadableToolSpec;pub use responses_api::ResponsesApiNamespace;pub use responses_api::ResponsesApiNamespaceTool;pub use responses_api::ResponsesApiTool;+pub use responses_api::agent_plugin_mcp_tool_to_responses_api_tool;pub use responses_api::coalesce_loadable_tool_specs;pub use responses_api::default_namespace_description;pub use responses_api::dynamic_tool_to_responses_api_tool;diff --git a/codex-rs/tools/src/mcp_tool.rs b/codex-rs/tools/src/mcp_tool.rsindex 337a8e42ad..4ab24b9cd4 100644--- a/codex-rs/tools/src/mcp_tool.rs+++ b/codex-rs/tools/src/mcp_tool.rs@@ -1,9 +1,25 @@use crate::ToolDefinition;use crate::parse_tool_input_schema;+use codex_utils_string::take_bytes_at_char_boundary;use serde_json::Value as JsonValue;use serde_json::json;+const MAX_MCP_TOOL_DESCRIPTION_BYTES: usize = 1_000;+pub fn parse_mcp_tool(tool: &rmcp::model::Tool) -> Result<ToolDefinition, serde_json::Error> {+ parse_mcp_tool_with_description_limit(tool, /*description_limit*/ None)+}++pub fn parse_agent_plugin_mcp_tool(+ tool: &rmcp::model::Tool,+) -> Result<ToolDefinition, serde_json::Error> {+ parse_mcp_tool_with_description_limit(tool, Some(MAX_MCP_TOOL_DESCRIPTION_BYTES))+}++fn parse_mcp_tool_with_description_limit(+ tool: &rmcp::model::Tool,+ description_limit: Option<usize>,+) -> Result<ToolDefinition, serde_json::Error> {let mut serialized_input_schema = serde_json::Value::Object(tool.input_schema.as_ref().clone());// OpenAI models mandate the "properties" field in the schema. Some MCP@@ -27,7 +43,14 @@ pub fn parse_mcp_tool(tool: &rmcp::model::Tool) -> Result<ToolDefinition, serde_Ok(ToolDefinition {name: tool.name.to_string(),- description: tool.description.clone().map(Into::into).unwrap_or_default(),+ description: tool+ .description+ .as_deref()+ .map(|description| match description_limit {+ Some(limit) => take_bytes_at_char_boundary(description, limit).to_string(),+ None => description.to_string(),+ })+ .unwrap_or_default(),input_schema,output_schema: Some(mcp_call_tool_result_output_schema(structured_content_schema,diff --git a/codex-rs/tools/src/mcp_tool_tests.rs b/codex-rs/tools/src/mcp_tool_tests.rsindex 98f8885a95..5f9b7b3264 100644--- a/codex-rs/tools/src/mcp_tool_tests.rs+++ b/codex-rs/tools/src/mcp_tool_tests.rs@@ -1,4 +1,5 @@use super::mcp_call_tool_result_output_schema;+use super::parse_agent_plugin_mcp_tool;use super::parse_mcp_tool;use crate::JsonSchema;use crate::ToolDefinition;@@ -39,6 +40,40 @@ fn parse_mcp_tool_inserts_empty_properties() {);}+#[test]+fn agent_plugin_mcp_tool_bounds_model_visible_description() {+ let description = format!("{}é", "a".repeat(super::MAX_MCP_TOOL_DESCRIPTION_BYTES - 1));+ let tool = mcp_tool(+ "bounded_description",+ &description,+ serde_json::json!({"type": "object"}),+ );++ let parsed = parse_agent_plugin_mcp_tool(&tool).expect("parse Agent Plugin MCP tool");++ assert_eq!(+ parsed.description.len(),+ super::MAX_MCP_TOOL_DESCRIPTION_BYTES - 1+ );+}++#[test]+fn legacy_mcp_tool_preserves_long_description() {+ let description = "a".repeat(super::MAX_MCP_TOOL_DESCRIPTION_BYTES + 100);+ let tool = mcp_tool(+ "legacy_description",+ &description,+ serde_json::json!({"type": "object"}),+ );++ assert_eq!(+ parse_mcp_tool(&tool)+ .expect("parse legacy MCP tool")+ .description,+ description+ );+}+#[test]fn parse_mcp_tool_preserves_top_level_output_schema() {let mut tool = mcp_tool(diff --git a/codex-rs/tools/src/responses_api.rs b/codex-rs/tools/src/responses_api.rsindex e63372ac94..e450dcf35f 100644--- a/codex-rs/tools/src/responses_api.rs+++ b/codex-rs/tools/src/responses_api.rs@@ -1,6 +1,7 @@use crate::JsonSchema;use crate::ToolDefinition;use crate::ToolName;+use crate::parse_agent_plugin_mcp_tool;use crate::parse_dynamic_tool;use crate::parse_mcp_tool;use codex_protocol::DEFAULT_FUNCTION_NAMESPACE;@@ -9,6 +10,8 @@ use serde::Deserialize;use serde::Serialize;use serde_json::Value;+const MAX_SERIALIZED_MCP_TOOL_BYTES: usize = 8_000;+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]pub struct FreeformTool {pub name: String,@@ -123,6 +126,23 @@ pub fn mcp_tool_to_responses_api_tool())}+pub fn agent_plugin_mcp_tool_to_responses_api_tool(+ tool_name: &ToolName,+ tool: &rmcp::model::Tool,+) -> Result<ResponsesApiTool, serde_json::Error> {+ let mut tool = tool_definition_to_responses_api_tool(+ parse_agent_plugin_mcp_tool(tool)?.renamed(tool_name.name.clone()),+ );+ if serde_json::to_vec(&tool)?.len() > MAX_SERIALIZED_MCP_TOOL_BYTES {+ tool.parameters = JsonSchema::object(+ Default::default(),+ /*required*/ None,+ Some(true.into()),+ );+ }+ Ok(tool)+}+pub fn mcp_tool_to_deferred_responses_api_tool(tool_name: &ToolName,tool: &rmcp::model::Tool,diff --git a/codex-rs/tools/src/responses_api_tests.rs b/codex-rs/tools/src/responses_api_tests.rsindex f12d078d26..43212060a3 100644--- a/codex-rs/tools/src/responses_api_tests.rs+++ b/codex-rs/tools/src/responses_api_tests.rs@@ -3,6 +3,7 @@ use super::LoadableToolSpec;use super::ResponsesApiNamespace;use super::ResponsesApiNamespaceTool;use super::ResponsesApiTool;+use super::agent_plugin_mcp_tool_to_responses_api_tool;use super::dynamic_tool_to_responses_api_tool;use super::mcp_tool_to_deferred_responses_api_tool;use super::tool_definition_to_responses_api_tool;@@ -153,6 +154,46 @@ fn mcp_tool_to_deferred_responses_api_tool_sets_defer_loading() {);}+#[test]+fn agent_plugin_mcp_tool_uses_fallback_for_oversized_schema() {+ let properties: serde_json::Map<String, serde_json::Value> = (0..1_024)+ .map(|index| (format!("property_{index}"), json!({"type": "string"})))+ .collect();+ let tool = rmcp::model::Tool::new(+ "oversized",+ "Large schema",+ std::sync::Arc::new(rmcp::model::object(json!({+ "type": "object",+ "properties": properties,+ }))),+ );++ assert_eq!(+ agent_plugin_mcp_tool_to_responses_api_tool(&ToolName::from("oversized"), &tool)+ .expect("Agent Plugin MCP tool should use a fallback schema")+ .parameters,+ JsonSchema::object(BTreeMap::new(), /*required*/ None, Some(true.into()))+ );+}++#[test]+fn legacy_mcp_tool_accepts_oversized_schema() {+ let properties: serde_json::Map<String, serde_json::Value> = (0..1_024)+ .map(|index| (format!("property_{index}"), json!({"type": "string"})))+ .collect();+ let tool = rmcp::model::Tool::new(+ "oversized",+ "Large legacy schema",+ std::sync::Arc::new(rmcp::model::object(json!({+ "type": "object",+ "properties": properties,+ }))),+ );++ super::mcp_tool_to_responses_api_tool(&ToolName::from("oversized"), &tool)+ .expect("legacy MCP conversion must preserve existing acceptance");+}+#[test]fn loadable_tool_spec_namespace_serializes_with_deferred_child_tools() {let namespace = LoadableToolSpec::Namespace(ResponsesApiNamespace {diff --git a/codex-rs/tui/src/app/plugin_mentions.rs b/codex-rs/tui/src/app/plugin_mentions.rsindex dd162af0d6..a71f4fa8d6 100644--- a/codex-rs/tui/src/app/plugin_mentions.rs+++ b/codex-rs/tui/src/app/plugin_mentions.rs@@ -50,6 +50,7 @@ fn plugin_mention_from_summary(Some(PluginCapabilitySummary {config_name: plugin.id.clone(),display_name: plugin_mention_display_name(&plugin),+ plugin_namespace: Some(plugin.name.clone()),description: plugin_mention_description(marketplace_name, &plugin),has_skills: false,mcp_server_names: Vec::new(),@@ -129,6 +130,7 @@ mod tests {PluginCapabilitySummary {config_name: "active@server-marketplace".to_string(),display_name: "active".to_string(),+ plugin_namespace: Some("active".to_string()),description: Some("server-marketplace".to_string()),has_skills: false,mcp_server_names: Vec::new(),@@ -137,6 +139,7 @@ mod tests {PluginCapabilitySummary {config_name: "active-shared@server-marketplace".to_string(),display_name: "active-shared".to_string(),+ plugin_namespace: Some("active-shared".to_string()),description: Some("server-marketplace".to_string()),has_skills: false,mcp_server_names: Vec::new(),diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rsindex fe3cd178c5..9574b615ed 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs@@ -6721,6 +6721,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "Sample Plugin".to_string(),+ plugin_namespace: None,description: None,has_skills: true,mcp_server_names: vec!["sample".to_string()],@@ -6773,6 +6774,7 @@ mod tests {PluginCapabilitySummary {config_name: format!("{name}@test"),display_name: name.to_string(),+ plugin_namespace: None,description: Some(description.to_string()),has_skills: false,mcp_server_names: vec![name.to_string()],@@ -7445,6 +7447,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "google-calendar@debug".to_string(),display_name: "Google Calendar".to_string(),+ plugin_namespace: None,description: Some("Connect Google Calendar for scheduling, availability, and event management.".to_string(),@@ -7497,6 +7500,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "Sample Plugin".to_string(),+ plugin_namespace: None,description: Some("Plugin that includes the Figma MCP server and Skills for common workflows".to_string(),@@ -7522,6 +7526,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "Sample Plugin".to_string(),+ plugin_namespace: None,description: Some("Plugin with skills and an MCP server".to_string()),has_skills: true,mcp_server_names: vec!["sample".to_string()],@@ -7629,6 +7634,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "google-calendar@debug".to_string(),display_name: "Google Calendar".to_string(),+ plugin_namespace: None,description: Some("Connect Google Calendar for scheduling, availability, and event management.".to_string(),@@ -8197,6 +8203,7 @@ mod tests {composer.set_plugin_mentions(Some(vec![PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "sample".to_string(),+ plugin_namespace: None,description: None,has_skills: true,mcp_server_names: vec!["sample".to_string()],diff --git a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs b/codex-rs/tui/src/chatwidget/tests/plan_mode.rsindex 98a832335c..5b809dac71 100644--- a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs+++ b/codex-rs/tui/src/chatwidget/tests/plan_mode.rs@@ -1310,6 +1310,7 @@ async fn submit_user_message_emits_structured_plugin_mentions_from_bindings() {.set_plugin_mentions(Some(vec![codex_plugin::PluginCapabilitySummary {config_name: "sample@test".to_string(),display_name: "Sample Plugin".to_string(),+ plugin_namespace: None,description: None,has_skills: true,mcp_server_names: Vec::new(),