Remove Codex Apps MCP privilege
This commit is contained in:
parent
6d3c17cd0f
commit
92d92ecca3
17 changed files with 93 additions and 2599 deletions
|
|
@ -835,6 +835,15 @@ returns empty, app prompt instructions and app-rendering code were deleted,
|
|||
tiny default stub so legacy callers compile. User-declared MCP servers remain
|
||||
the only MCP authority; Codex Apps are not part of the OpenAI auth/model spine.
|
||||
|
||||
The Codex Apps MCP privilege layer has been cut below core too. MCP tool
|
||||
exposure no longer separates Codex Apps from ordinary MCP tools, core MCP tool
|
||||
calls no longer consult app policy, forward `_codex_apps` metadata, emit app
|
||||
invocation telemetry, render bundled app approval templates, or persist
|
||||
approvals under `[apps.*]`, and `codex-mcp` no longer injects `codex_apps`,
|
||||
exports `with_codex_apps_mcp`, keeps a ChatGPT-auth-keyed app tool cache, or
|
||||
normalizes app callable names/namespaces/titles. MCP remains JSON-RPC at the
|
||||
edge; only user-declared MCP servers are runtime MCP authority.
|
||||
|
||||
The Phase 6 freshness slice is landed. It exposes read-only
|
||||
`thread/epiphany/freshness` from live retrieval summaries plus graph
|
||||
frontier/churn state and, for loaded threads, watcher-backed invalidation
|
||||
|
|
|
|||
Binary file not shown.
File diff suppressed because one or more lines are too long
5
vendor/codex/codex-rs/codex-mcp/src/lib.rs
vendored
5
vendor/codex/codex-rs/codex-mcp/src/lib.rs
vendored
|
|
@ -2,7 +2,6 @@ pub(crate) mod mcp;
|
|||
pub(crate) mod mcp_connection_manager;
|
||||
pub(crate) mod mcp_tool_names;
|
||||
|
||||
pub use mcp::CODEX_APPS_MCP_SERVER_NAME;
|
||||
pub use mcp::McpAuthStatusEntry;
|
||||
pub use mcp::McpConfig;
|
||||
pub use mcp::McpManager;
|
||||
|
|
@ -34,14 +33,10 @@ pub use mcp::resolve_oauth_scopes;
|
|||
pub use mcp::should_retry_without_scopes;
|
||||
pub use mcp::split_qualified_tool_name;
|
||||
pub use mcp::tool_plugin_provenance;
|
||||
pub use mcp::with_codex_apps_mcp;
|
||||
pub use mcp_connection_manager::CodexAppsToolsCacheKey;
|
||||
pub use mcp_connection_manager::DEFAULT_STARTUP_TIMEOUT;
|
||||
pub use mcp_connection_manager::MCP_SANDBOX_STATE_META_CAPABILITY;
|
||||
pub use mcp_connection_manager::McpConnectionManager;
|
||||
pub use mcp_connection_manager::McpRuntimeEnvironment;
|
||||
pub use mcp_connection_manager::SandboxState;
|
||||
pub use mcp_connection_manager::ToolInfo;
|
||||
pub use mcp_connection_manager::codex_apps_tools_cache_key;
|
||||
pub use mcp_connection_manager::declared_openai_file_input_param_names;
|
||||
pub use mcp_connection_manager::filter_non_codex_apps_mcp_tools_only;
|
||||
|
|
|
|||
128
vendor/codex/codex-rs/codex-mcp/src/mcp/mod.rs
vendored
128
vendor/codex/codex-rs/codex-mcp/src/mcp/mod.rs
vendored
|
|
@ -14,14 +14,11 @@ pub use skill_dependencies::canonical_mcp_server_key;
|
|||
pub use skill_dependencies::collect_missing_mcp_dependencies;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::env;
|
||||
use std::path::PathBuf;
|
||||
use std::time::Duration;
|
||||
|
||||
use async_channel::unbounded;
|
||||
use codex_config::Constrained;
|
||||
use codex_config::McpServerConfig;
|
||||
use codex_config::McpServerTransportConfig;
|
||||
use codex_config::types::OAuthCredentialsStoreMode;
|
||||
use codex_login::CodexAuth;
|
||||
use codex_plugin::PluginCapabilitySummary;
|
||||
|
|
@ -38,14 +35,10 @@ use serde_json::Value;
|
|||
|
||||
use crate::mcp_connection_manager::McpConnectionManager;
|
||||
use crate::mcp_connection_manager::McpRuntimeEnvironment;
|
||||
use crate::mcp_connection_manager::codex_apps_tools_cache_key;
|
||||
pub type McpManager = McpConnectionManager;
|
||||
|
||||
const MCP_TOOL_NAME_PREFIX: &str = "mcp";
|
||||
const MCP_TOOL_NAME_DELIMITER: &str = "__";
|
||||
pub const CODEX_APPS_MCP_SERVER_NAME: &str = "codex_apps";
|
||||
const CODEX_CONNECTORS_TOKEN_ENV_VAR: &str = "CODEX_CONNECTORS_TOKEN";
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum McpSnapshotDetail {
|
||||
#[default]
|
||||
|
|
@ -105,7 +98,7 @@ pub fn mcp_permission_prompt_is_auto_approved(
|
|||
/// approval/sandbox policy, locate OAuth state, and merge plugin-provided MCP
|
||||
/// servers. Request-scoped or auth-scoped state should not be stored here;
|
||||
/// thread those values explicitly into runtime entry points such as
|
||||
/// [`with_codex_apps_mcp`] and [`collect_mcp_snapshot`] so config objects do
|
||||
/// [`effective_mcp_servers`] and [`collect_mcp_snapshot`] so config objects do
|
||||
/// not go stale when auth changes.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct McpConfig {
|
||||
|
|
@ -196,124 +189,15 @@ impl ToolPluginProvenance {
|
|||
}
|
||||
}
|
||||
|
||||
fn codex_apps_mcp_bearer_token_env_var() -> Option<String> {
|
||||
match env::var(CODEX_CONNECTORS_TOKEN_ENV_VAR) {
|
||||
Ok(value) if !value.trim().is_empty() => Some(CODEX_CONNECTORS_TOKEN_ENV_VAR.to_string()),
|
||||
Ok(_) => None,
|
||||
Err(env::VarError::NotPresent) => None,
|
||||
Err(env::VarError::NotUnicode(_)) => Some(CODEX_CONNECTORS_TOKEN_ENV_VAR.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
fn codex_apps_mcp_bearer_token(auth: Option<&CodexAuth>) -> Option<String> {
|
||||
let token = auth.and_then(|auth| auth.get_token().ok())?;
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(token.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
fn codex_apps_mcp_http_headers(auth: Option<&CodexAuth>) -> Option<HashMap<String, String>> {
|
||||
let mut headers = HashMap::new();
|
||||
if let Some(token) = codex_apps_mcp_bearer_token(auth) {
|
||||
headers.insert("Authorization".to_string(), format!("Bearer {token}"));
|
||||
}
|
||||
if let Some(account_id) = auth.and_then(CodexAuth::get_account_id) {
|
||||
headers.insert("ChatGPT-Account-ID".to_string(), account_id);
|
||||
}
|
||||
if headers.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(headers)
|
||||
}
|
||||
}
|
||||
|
||||
fn normalize_codex_apps_base_url(base_url: &str) -> String {
|
||||
let mut base_url = base_url.trim_end_matches('/').to_string();
|
||||
if (base_url.starts_with("https://chatgpt.com")
|
||||
|| base_url.starts_with("https://chat.openai.com"))
|
||||
&& !base_url.contains("/backend-api")
|
||||
{
|
||||
base_url = format!("{base_url}/backend-api");
|
||||
}
|
||||
base_url
|
||||
}
|
||||
|
||||
fn codex_apps_mcp_url_for_base_url(base_url: &str) -> String {
|
||||
let base_url = normalize_codex_apps_base_url(base_url);
|
||||
if base_url.contains("/backend-api") {
|
||||
format!("{base_url}/wham/apps")
|
||||
} else if base_url.contains("/api/codex") {
|
||||
format!("{base_url}/apps")
|
||||
} else {
|
||||
format!("{base_url}/api/codex/apps")
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn codex_apps_mcp_url(config: &McpConfig) -> String {
|
||||
codex_apps_mcp_url_for_base_url(&config.chatgpt_base_url)
|
||||
}
|
||||
|
||||
fn codex_apps_mcp_server_config(config: &McpConfig, auth: Option<&CodexAuth>) -> McpServerConfig {
|
||||
let bearer_token_env_var = codex_apps_mcp_bearer_token_env_var();
|
||||
let http_headers = if bearer_token_env_var.is_some() {
|
||||
None
|
||||
} else {
|
||||
codex_apps_mcp_http_headers(auth)
|
||||
};
|
||||
let url = codex_apps_mcp_url(config);
|
||||
|
||||
McpServerConfig {
|
||||
transport: McpServerTransportConfig::StreamableHttp {
|
||||
url,
|
||||
bearer_token_env_var,
|
||||
http_headers,
|
||||
env_http_headers: None,
|
||||
},
|
||||
experimental_environment: None,
|
||||
enabled: true,
|
||||
required: false,
|
||||
supports_parallel_tool_calls: false,
|
||||
disabled_reason: None,
|
||||
startup_timeout_sec: Some(Duration::from_secs(30)),
|
||||
tool_timeout_sec: None,
|
||||
default_tools_approval_mode: None,
|
||||
enabled_tools: None,
|
||||
disabled_tools: None,
|
||||
scopes: None,
|
||||
oauth_resource: None,
|
||||
tools: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_codex_apps_mcp(
|
||||
mut servers: HashMap<String, McpServerConfig>,
|
||||
auth: Option<&CodexAuth>,
|
||||
config: &McpConfig,
|
||||
) -> HashMap<String, McpServerConfig> {
|
||||
if config.apps_enabled && auth.is_some_and(CodexAuth::is_chatgpt_auth) {
|
||||
servers.insert(
|
||||
CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
codex_apps_mcp_server_config(config, auth),
|
||||
);
|
||||
} else {
|
||||
servers.remove(CODEX_APPS_MCP_SERVER_NAME);
|
||||
}
|
||||
servers
|
||||
}
|
||||
|
||||
pub fn configured_mcp_servers(config: &McpConfig) -> HashMap<String, McpServerConfig> {
|
||||
config.configured_mcp_servers.clone()
|
||||
}
|
||||
|
||||
pub fn effective_mcp_servers(
|
||||
config: &McpConfig,
|
||||
auth: Option<&CodexAuth>,
|
||||
_auth: Option<&CodexAuth>,
|
||||
) -> HashMap<String, McpServerConfig> {
|
||||
let servers = configured_mcp_servers(config);
|
||||
with_codex_apps_mcp(servers, auth, config)
|
||||
configured_mcp_servers(config)
|
||||
}
|
||||
|
||||
pub fn tool_plugin_provenance(config: &McpConfig) -> ToolPluginProvenance {
|
||||
|
|
@ -342,8 +226,6 @@ pub async fn read_mcp_resource(
|
|||
tx_event,
|
||||
SandboxPolicy::new_read_only_policy(),
|
||||
runtime_environment,
|
||||
config.codex_home.clone(),
|
||||
codex_apps_tools_cache_key(auth),
|
||||
tool_plugin_provenance(config),
|
||||
)
|
||||
.await;
|
||||
|
|
@ -410,8 +292,6 @@ pub async fn collect_mcp_snapshot_with_detail(
|
|||
tx_event,
|
||||
SandboxPolicy::new_read_only_policy(),
|
||||
runtime_environment,
|
||||
config.codex_home.clone(),
|
||||
codex_apps_tools_cache_key(auth),
|
||||
tool_plugin_provenance,
|
||||
)
|
||||
.await;
|
||||
|
|
@ -485,8 +365,6 @@ pub async fn collect_mcp_server_status_snapshot_with_detail(
|
|||
tx_event,
|
||||
SandboxPolicy::new_read_only_policy(),
|
||||
runtime_environment,
|
||||
config.codex_home.clone(),
|
||||
codex_apps_tools_cache_key(auth),
|
||||
tool_plugin_provenance,
|
||||
)
|
||||
.await;
|
||||
|
|
|
|||
|
|
@ -14,13 +14,10 @@ use std::ffi::OsString;
|
|||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex as StdMutex;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
|
||||
use crate::McpAuthStatusEntry;
|
||||
use crate::mcp::CODEX_APPS_MCP_SERVER_NAME;
|
||||
use crate::mcp::McpConfig;
|
||||
use crate::mcp::ToolPluginProvenance;
|
||||
use crate::mcp::configured_mcp_servers;
|
||||
|
|
@ -81,8 +78,6 @@ use serde::Deserialize;
|
|||
use serde::Serialize;
|
||||
use serde_json::Map;
|
||||
use serde_json::Value as JsonValue;
|
||||
use sha1::Digest;
|
||||
use sha1::Sha1;
|
||||
use tokio::sync::Mutex;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio::task::JoinSet;
|
||||
|
|
@ -94,8 +89,6 @@ use url::Url;
|
|||
use codex_config::McpServerConfig;
|
||||
use codex_config::McpServerTransportConfig;
|
||||
use codex_login::CodexAuth;
|
||||
use codex_utils_plugins::mcp_connector::is_connector_id_allowed;
|
||||
use codex_utils_plugins::mcp_connector::sanitize_name;
|
||||
|
||||
/// Delimiter used to separate MCP tool-name parts.
|
||||
const MCP_TOOL_NAME_DELIMITER: &str = "__";
|
||||
|
|
@ -106,37 +99,8 @@ pub const DEFAULT_STARTUP_TIMEOUT: Duration = Duration::from_secs(30);
|
|||
/// Default timeout for individual tool calls.
|
||||
const DEFAULT_TOOL_TIMEOUT: Duration = Duration::from_secs(120);
|
||||
|
||||
const CODEX_APPS_TOOLS_CACHE_SCHEMA_VERSION: u8 = 2;
|
||||
const CODEX_APPS_TOOLS_CACHE_DIR: &str = "cache/codex_apps_tools";
|
||||
const MCP_TOOLS_LIST_DURATION_METRIC: &str = "codex.mcp.tools.list.duration_ms";
|
||||
const MCP_TOOLS_FETCH_UNCACHED_DURATION_METRIC: &str = "codex.mcp.tools.fetch_uncached.duration_ms";
|
||||
const MCP_TOOLS_CACHE_WRITE_DURATION_METRIC: &str = "codex.mcp.tools.cache_write.duration_ms";
|
||||
|
||||
fn sha1_hex(s: &str) -> String {
|
||||
let mut hasher = Sha1::new();
|
||||
hasher.update(s.as_bytes());
|
||||
let sha1 = hasher.finalize();
|
||||
format!("{sha1:x}")
|
||||
}
|
||||
|
||||
pub fn codex_apps_tools_cache_key(auth: Option<&CodexAuth>) -> CodexAppsToolsCacheKey {
|
||||
let token_data = auth.and_then(|auth| auth.get_token_data().ok());
|
||||
let account_id = token_data
|
||||
.as_ref()
|
||||
.and_then(|token_data| token_data.account_id.clone());
|
||||
let chatgpt_user_id = token_data
|
||||
.as_ref()
|
||||
.and_then(|token_data| token_data.id_token.chatgpt_user_id.clone());
|
||||
let is_workspace_account = token_data
|
||||
.as_ref()
|
||||
.is_some_and(|token_data| token_data.id_token.is_workspace_account());
|
||||
|
||||
CodexAppsToolsCacheKey {
|
||||
account_id,
|
||||
chatgpt_user_id,
|
||||
is_workspace_account,
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ToolInfo {
|
||||
|
|
@ -185,105 +149,6 @@ pub fn declared_openai_file_input_param_names(
|
|||
.collect()
|
||||
}
|
||||
|
||||
/// Returns the model-visible view of a tool while preserving the raw metadata
|
||||
/// used by execution. Keep cache entries raw and call this at manager return
|
||||
/// boundaries.
|
||||
fn tool_with_model_visible_input_schema(tool: &Tool) -> Tool {
|
||||
let file_params = declared_openai_file_input_param_names(tool.meta.as_deref());
|
||||
if file_params.is_empty() {
|
||||
return tool.clone();
|
||||
}
|
||||
|
||||
let mut tool = tool.clone();
|
||||
let mut input_schema = JsonValue::Object(tool.input_schema.as_ref().clone());
|
||||
mask_input_schema_for_file_path_params(&mut input_schema, &file_params);
|
||||
if let JsonValue::Object(input_schema) = input_schema {
|
||||
tool.input_schema = Arc::new(input_schema);
|
||||
}
|
||||
tool
|
||||
}
|
||||
|
||||
fn mask_input_schema_for_file_path_params(input_schema: &mut JsonValue, file_params: &[String]) {
|
||||
let Some(properties) = input_schema
|
||||
.as_object_mut()
|
||||
.and_then(|schema| schema.get_mut("properties"))
|
||||
.and_then(JsonValue::as_object_mut)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
|
||||
for field_name in file_params {
|
||||
let Some(property_schema) = properties.get_mut(field_name) else {
|
||||
continue;
|
||||
};
|
||||
mask_input_property_schema(property_schema);
|
||||
}
|
||||
}
|
||||
|
||||
fn mask_input_property_schema(schema: &mut JsonValue) {
|
||||
let Some(object) = schema.as_object_mut() else {
|
||||
return;
|
||||
};
|
||||
|
||||
let mut description = object
|
||||
.get("description")
|
||||
.and_then(JsonValue::as_str)
|
||||
.map(str::to_string)
|
||||
.unwrap_or_default();
|
||||
let guidance = "This parameter expects an absolute local file path. If you want to upload a file, provide the absolute path to that file here.";
|
||||
if description.is_empty() {
|
||||
description = guidance.to_string();
|
||||
} else if !description.contains(guidance) {
|
||||
description = format!("{description} {guidance}");
|
||||
}
|
||||
|
||||
let is_array = object.get("type").and_then(JsonValue::as_str) == Some("array")
|
||||
|| object.get("items").is_some();
|
||||
object.clear();
|
||||
object.insert("description".to_string(), JsonValue::String(description));
|
||||
if is_array {
|
||||
object.insert("type".to_string(), JsonValue::String("array".to_string()));
|
||||
object.insert("items".to_string(), serde_json::json!({ "type": "string" }));
|
||||
} else {
|
||||
object.insert("type".to_string(), JsonValue::String("string".to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct CodexAppsToolsCacheKey {
|
||||
account_id: Option<String>,
|
||||
chatgpt_user_id: Option<String>,
|
||||
is_workspace_account: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct CodexAppsToolsCacheContext {
|
||||
codex_home: PathBuf,
|
||||
user_key: CodexAppsToolsCacheKey,
|
||||
}
|
||||
|
||||
impl CodexAppsToolsCacheContext {
|
||||
fn cache_path(&self) -> PathBuf {
|
||||
let user_key_json = serde_json::to_string(&self.user_key).unwrap_or_default();
|
||||
let user_key_hash = sha1_hex(&user_key_json);
|
||||
self.codex_home
|
||||
.join(CODEX_APPS_TOOLS_CACHE_DIR)
|
||||
.join(format!("{user_key_hash}.json"))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
struct CodexAppsToolsDiskCache {
|
||||
schema_version: u8,
|
||||
tools: Vec<ToolInfo>,
|
||||
}
|
||||
|
||||
enum CachedCodexAppsToolsLoad {
|
||||
Hit(Vec<ToolInfo>),
|
||||
Missing,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
type ResponderMap = HashMap<(String, RequestId), oneshot::Sender<ElicitationResponse>>;
|
||||
|
||||
fn elicitation_is_rejected_by_policy(approval_policy: AskForApproval) -> bool {
|
||||
|
|
@ -442,34 +307,11 @@ struct ManagedClient {
|
|||
tools: Vec<ToolInfo>,
|
||||
tool_filter: ToolFilter,
|
||||
tool_timeout: Option<Duration>,
|
||||
server_instructions: Option<String>,
|
||||
server_supports_sandbox_state_meta_capability: bool,
|
||||
codex_apps_tools_cache_context: Option<CodexAppsToolsCacheContext>,
|
||||
}
|
||||
|
||||
impl ManagedClient {
|
||||
fn listed_tools(&self) -> Vec<ToolInfo> {
|
||||
let total_start = Instant::now();
|
||||
if let Some(cache_context) = self.codex_apps_tools_cache_context.as_ref()
|
||||
&& let CachedCodexAppsToolsLoad::Hit(tools) =
|
||||
load_cached_codex_apps_tools(cache_context)
|
||||
{
|
||||
emit_duration(
|
||||
MCP_TOOLS_LIST_DURATION_METRIC,
|
||||
total_start.elapsed(),
|
||||
&[("cache", "hit")],
|
||||
);
|
||||
return filter_tools(tools, &self.tool_filter);
|
||||
}
|
||||
|
||||
if self.codex_apps_tools_cache_context.is_some() {
|
||||
emit_duration(
|
||||
MCP_TOOLS_LIST_DURATION_METRIC,
|
||||
total_start.elapsed(),
|
||||
&[("cache", "miss")],
|
||||
);
|
||||
}
|
||||
|
||||
self.tools.clone()
|
||||
}
|
||||
}
|
||||
|
|
@ -477,8 +319,6 @@ impl ManagedClient {
|
|||
#[derive(Clone)]
|
||||
struct AsyncManagedClient {
|
||||
client: Shared<BoxFuture<'static, Result<ManagedClient, StartupOutcomeError>>>,
|
||||
startup_snapshot: Option<Vec<ToolInfo>>,
|
||||
startup_complete: Arc<AtomicBool>,
|
||||
tool_plugin_provenance: Arc<ToolPluginProvenance>,
|
||||
}
|
||||
|
||||
|
|
@ -493,19 +333,11 @@ impl AsyncManagedClient {
|
|||
cancel_token: CancellationToken,
|
||||
tx_event: Sender<Event>,
|
||||
elicitation_requests: ElicitationRequestManager,
|
||||
codex_apps_tools_cache_context: Option<CodexAppsToolsCacheContext>,
|
||||
tool_plugin_provenance: Arc<ToolPluginProvenance>,
|
||||
runtime_environment: McpRuntimeEnvironment,
|
||||
) -> Self {
|
||||
let tool_filter = ToolFilter::from_config(&config);
|
||||
let startup_snapshot = load_startup_cached_codex_apps_tools_snapshot(
|
||||
&server_name,
|
||||
codex_apps_tools_cache_context.as_ref(),
|
||||
)
|
||||
.map(|tools| filter_tools(tools, &tool_filter));
|
||||
let startup_tool_filter = tool_filter;
|
||||
let startup_complete = Arc::new(AtomicBool::new(false));
|
||||
let startup_complete_for_fut = Arc::clone(&startup_complete);
|
||||
let fut = async move {
|
||||
let outcome = async {
|
||||
if let Err(error) = validate_mcp_server_name(&server_name) {
|
||||
|
|
@ -532,7 +364,6 @@ impl AsyncManagedClient {
|
|||
tool_filter: startup_tool_filter,
|
||||
tx_event,
|
||||
elicitation_requests,
|
||||
codex_apps_tools_cache_context,
|
||||
},
|
||||
)
|
||||
.or_cancel(&cancel_token)
|
||||
|
|
@ -544,21 +375,12 @@ impl AsyncManagedClient {
|
|||
}
|
||||
.await;
|
||||
|
||||
startup_complete_for_fut.store(true, Ordering::Release);
|
||||
outcome
|
||||
};
|
||||
let client = fut.boxed().shared();
|
||||
if startup_snapshot.is_some() {
|
||||
let startup_task = client.clone();
|
||||
tokio::spawn(async move {
|
||||
let _ = startup_task.await;
|
||||
});
|
||||
}
|
||||
|
||||
Self {
|
||||
client,
|
||||
startup_snapshot,
|
||||
startup_complete,
|
||||
tool_plugin_provenance,
|
||||
}
|
||||
}
|
||||
|
|
@ -567,21 +389,10 @@ impl AsyncManagedClient {
|
|||
self.client.clone().await
|
||||
}
|
||||
|
||||
fn startup_snapshot_while_initializing(&self) -> Option<Vec<ToolInfo>> {
|
||||
if !self.startup_complete.load(Ordering::Acquire) {
|
||||
return self.startup_snapshot.clone();
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
async fn listed_tools(&self) -> Option<Vec<ToolInfo>> {
|
||||
let annotate_tools = |tools: Vec<ToolInfo>| {
|
||||
let mut tools = tools;
|
||||
for tool in &mut tools {
|
||||
if tool.server_name == CODEX_APPS_MCP_SERVER_NAME {
|
||||
tool.tool = tool_with_model_visible_input_schema(&tool.tool);
|
||||
}
|
||||
|
||||
let plugin_names = match tool.connector_id.as_deref() {
|
||||
Some(connector_id) => self
|
||||
.tool_plugin_provenance
|
||||
|
|
@ -626,14 +437,9 @@ impl AsyncManagedClient {
|
|||
tools
|
||||
};
|
||||
|
||||
// Keep cache payloads raw; plugin provenance is resolved per-session at read time.
|
||||
let tools = if let Some(startup_tools) = self.startup_snapshot_while_initializing() {
|
||||
Some(startup_tools)
|
||||
} else {
|
||||
match self.client().await {
|
||||
Ok(client) => Some(client.listed_tools()),
|
||||
Err(_) => self.startup_snapshot.clone(),
|
||||
}
|
||||
let tools = match self.client().await {
|
||||
Ok(client) => Some(client.listed_tools()),
|
||||
Err(_) => None,
|
||||
};
|
||||
tools.map(annotate_tools)
|
||||
}
|
||||
|
|
@ -752,8 +558,6 @@ impl McpConnectionManager {
|
|||
tx_event: Sender<Event>,
|
||||
initial_sandbox_policy: SandboxPolicy,
|
||||
runtime_environment: McpRuntimeEnvironment,
|
||||
codex_home: PathBuf,
|
||||
codex_apps_tools_cache_key: CodexAppsToolsCacheKey,
|
||||
tool_plugin_provenance: ToolPluginProvenance,
|
||||
) -> (Self, CancellationToken) {
|
||||
let cancel_token = CancellationToken::new();
|
||||
|
|
@ -779,14 +583,6 @@ impl McpConnectionManager {
|
|||
},
|
||||
)
|
||||
.await;
|
||||
let codex_apps_tools_cache_context = if server_name == CODEX_APPS_MCP_SERVER_NAME {
|
||||
Some(CodexAppsToolsCacheContext {
|
||||
codex_home: codex_home.clone(),
|
||||
user_key: codex_apps_tools_cache_key.clone(),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let async_managed_client = AsyncManagedClient::new(
|
||||
server_name.clone(),
|
||||
cfg,
|
||||
|
|
@ -794,7 +590,6 @@ impl McpConnectionManager {
|
|||
cancel_token.clone(),
|
||||
tx_event.clone(),
|
||||
elicitation_requests.clone(),
|
||||
codex_apps_tools_cache_context,
|
||||
Arc::clone(&tool_plugin_provenance),
|
||||
runtime_environment.clone(),
|
||||
);
|
||||
|
|
@ -933,57 +728,6 @@ impl McpConnectionManager {
|
|||
qualify_tools(tools)
|
||||
}
|
||||
|
||||
/// Force-refresh codex apps tools by bypassing the in-process cache.
|
||||
///
|
||||
/// On success, the refreshed tools replace the cache contents and the
|
||||
/// latest filtered tool map is returned directly to the caller. On
|
||||
/// failure, the existing cache remains unchanged.
|
||||
pub async fn hard_refresh_codex_apps_tools_cache(&self) -> Result<HashMap<String, ToolInfo>> {
|
||||
let managed_client = self
|
||||
.clients
|
||||
.get(CODEX_APPS_MCP_SERVER_NAME)
|
||||
.ok_or_else(|| anyhow!("unknown MCP server '{CODEX_APPS_MCP_SERVER_NAME}'"))?
|
||||
.client()
|
||||
.await
|
||||
.context("failed to get client")?;
|
||||
|
||||
let list_start = Instant::now();
|
||||
let fetch_start = Instant::now();
|
||||
let tools = list_tools_for_client_uncached(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
&managed_client.client,
|
||||
managed_client.tool_timeout,
|
||||
managed_client.server_instructions.as_deref(),
|
||||
)
|
||||
.await
|
||||
.with_context(|| {
|
||||
format!("failed to refresh tools for MCP server '{CODEX_APPS_MCP_SERVER_NAME}'")
|
||||
})?;
|
||||
emit_duration(
|
||||
MCP_TOOLS_FETCH_UNCACHED_DURATION_METRIC,
|
||||
fetch_start.elapsed(),
|
||||
&[],
|
||||
);
|
||||
|
||||
write_cached_codex_apps_tools_if_needed(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
managed_client.codex_apps_tools_cache_context.as_ref(),
|
||||
&tools,
|
||||
);
|
||||
emit_duration(
|
||||
MCP_TOOLS_LIST_DURATION_METRIC,
|
||||
list_start.elapsed(),
|
||||
&[("cache", "miss")],
|
||||
);
|
||||
let tools = filter_tools(tools, &managed_client.tool_filter)
|
||||
.into_iter()
|
||||
.map(|mut tool| {
|
||||
tool.tool = tool_with_model_visible_input_schema(&tool.tool);
|
||||
tool
|
||||
});
|
||||
Ok(qualify_tools(tools))
|
||||
}
|
||||
|
||||
/// Returns a single map that contains all resources. Each key is the
|
||||
/// server name and the value is a vector of resources.
|
||||
pub async fn list_all_resources(&self) -> HashMap<String, Vec<Resource>> {
|
||||
|
|
@ -1280,96 +1024,6 @@ fn filter_tools(tools: Vec<ToolInfo>, filter: &ToolFilter) -> Vec<ToolInfo> {
|
|||
.collect()
|
||||
}
|
||||
|
||||
pub fn filter_non_codex_apps_mcp_tools_only(
|
||||
mcp_tools: &HashMap<String, ToolInfo>,
|
||||
) -> HashMap<String, ToolInfo> {
|
||||
mcp_tools
|
||||
.iter()
|
||||
.filter(|(_, tool)| tool.server_name != CODEX_APPS_MCP_SERVER_NAME)
|
||||
.map(|(name, tool)| (name.clone(), tool.clone()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn normalize_codex_apps_tool_title(
|
||||
server_name: &str,
|
||||
connector_name: Option<&str>,
|
||||
value: &str,
|
||||
) -> String {
|
||||
if server_name != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return value.to_string();
|
||||
}
|
||||
|
||||
let Some(connector_name) = connector_name
|
||||
.map(str::trim)
|
||||
.filter(|name| !name.is_empty())
|
||||
else {
|
||||
return value.to_string();
|
||||
};
|
||||
|
||||
let prefix = format!("{connector_name}_");
|
||||
if let Some(stripped) = value.strip_prefix(&prefix)
|
||||
&& !stripped.is_empty()
|
||||
{
|
||||
return stripped.to_string();
|
||||
}
|
||||
|
||||
value.to_string()
|
||||
}
|
||||
|
||||
fn normalize_codex_apps_callable_name(
|
||||
server_name: &str,
|
||||
tool_name: &str,
|
||||
connector_id: Option<&str>,
|
||||
connector_name: Option<&str>,
|
||||
) -> String {
|
||||
if server_name != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return tool_name.to_string();
|
||||
}
|
||||
|
||||
let tool_name = sanitize_name(tool_name);
|
||||
|
||||
if let Some(connector_name) = connector_name
|
||||
.map(str::trim)
|
||||
.map(sanitize_name)
|
||||
.filter(|name| !name.is_empty())
|
||||
&& let Some(stripped) = tool_name.strip_prefix(&connector_name)
|
||||
&& !stripped.is_empty()
|
||||
{
|
||||
return stripped.to_string();
|
||||
}
|
||||
|
||||
if let Some(connector_id) = connector_id
|
||||
.map(str::trim)
|
||||
.map(sanitize_name)
|
||||
.filter(|name| !name.is_empty())
|
||||
&& let Some(stripped) = tool_name.strip_prefix(&connector_id)
|
||||
&& !stripped.is_empty()
|
||||
{
|
||||
return stripped.to_string();
|
||||
}
|
||||
|
||||
tool_name
|
||||
}
|
||||
|
||||
fn normalize_codex_apps_callable_namespace(
|
||||
server_name: &str,
|
||||
connector_name: Option<&str>,
|
||||
) -> String {
|
||||
if server_name == CODEX_APPS_MCP_SERVER_NAME
|
||||
&& let Some(connector_name) = connector_name
|
||||
{
|
||||
format!(
|
||||
"mcp{}{}{}{}",
|
||||
MCP_TOOL_NAME_DELIMITER,
|
||||
server_name,
|
||||
MCP_TOOL_NAME_DELIMITER,
|
||||
sanitize_name(connector_name)
|
||||
)
|
||||
} else {
|
||||
format!("mcp{MCP_TOOL_NAME_DELIMITER}{server_name}{MCP_TOOL_NAME_DELIMITER}")
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_bearer_token(
|
||||
server_name: &str,
|
||||
bearer_token_env_var: Option<&str>,
|
||||
|
|
@ -1437,7 +1091,6 @@ async fn start_server_task(
|
|||
tool_filter,
|
||||
tx_event,
|
||||
elicitation_requests,
|
||||
codex_apps_tools_cache_context,
|
||||
} = params;
|
||||
let elicitation = elicitation_capability_for_server(&server_name);
|
||||
let params = InitializeRequestParams {
|
||||
|
|
@ -1489,18 +1142,7 @@ async fn start_server_task(
|
|||
fetch_start.elapsed(),
|
||||
&[],
|
||||
);
|
||||
write_cached_codex_apps_tools_if_needed(
|
||||
&server_name,
|
||||
codex_apps_tools_cache_context.as_ref(),
|
||||
&tools,
|
||||
);
|
||||
if server_name == CODEX_APPS_MCP_SERVER_NAME {
|
||||
emit_duration(
|
||||
MCP_TOOLS_LIST_DURATION_METRIC,
|
||||
list_start.elapsed(),
|
||||
&[("cache", "miss")],
|
||||
);
|
||||
}
|
||||
emit_duration(MCP_TOOLS_LIST_DURATION_METRIC, list_start.elapsed(), &[]);
|
||||
let tools = filter_tools(tools, &tool_filter);
|
||||
|
||||
let managed = ManagedClient {
|
||||
|
|
@ -1508,9 +1150,7 @@ async fn start_server_task(
|
|||
tools,
|
||||
tool_timeout: Some(tool_timeout),
|
||||
tool_filter,
|
||||
server_instructions: initialize_result.instructions,
|
||||
server_supports_sandbox_state_meta_capability,
|
||||
codex_apps_tools_cache_context,
|
||||
};
|
||||
|
||||
Ok(managed)
|
||||
|
|
@ -1522,7 +1162,6 @@ struct StartServerTaskParams {
|
|||
tool_filter: ToolFilter,
|
||||
tx_event: Sender<Event>,
|
||||
elicitation_requests: ElicitationRequestManager,
|
||||
codex_apps_tools_cache_context: Option<CodexAppsToolsCacheContext>,
|
||||
}
|
||||
|
||||
async fn make_rmcp_client(
|
||||
|
|
@ -1616,101 +1255,6 @@ async fn make_rmcp_client(
|
|||
}
|
||||
}
|
||||
|
||||
fn write_cached_codex_apps_tools_if_needed(
|
||||
server_name: &str,
|
||||
cache_context: Option<&CodexAppsToolsCacheContext>,
|
||||
tools: &[ToolInfo],
|
||||
) {
|
||||
if server_name != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return;
|
||||
}
|
||||
|
||||
if let Some(cache_context) = cache_context {
|
||||
let cache_write_start = Instant::now();
|
||||
write_cached_codex_apps_tools(cache_context, tools);
|
||||
emit_duration(
|
||||
MCP_TOOLS_CACHE_WRITE_DURATION_METRIC,
|
||||
cache_write_start.elapsed(),
|
||||
&[],
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn load_startup_cached_codex_apps_tools_snapshot(
|
||||
server_name: &str,
|
||||
cache_context: Option<&CodexAppsToolsCacheContext>,
|
||||
) -> Option<Vec<ToolInfo>> {
|
||||
if server_name != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return None;
|
||||
}
|
||||
|
||||
let cache_context = cache_context?;
|
||||
|
||||
match load_cached_codex_apps_tools(cache_context) {
|
||||
CachedCodexAppsToolsLoad::Hit(tools) => Some(tools),
|
||||
CachedCodexAppsToolsLoad::Missing | CachedCodexAppsToolsLoad::Invalid => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn read_cached_codex_apps_tools(
|
||||
cache_context: &CodexAppsToolsCacheContext,
|
||||
) -> Option<Vec<ToolInfo>> {
|
||||
match load_cached_codex_apps_tools(cache_context) {
|
||||
CachedCodexAppsToolsLoad::Hit(tools) => Some(tools),
|
||||
CachedCodexAppsToolsLoad::Missing | CachedCodexAppsToolsLoad::Invalid => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn load_cached_codex_apps_tools(
|
||||
cache_context: &CodexAppsToolsCacheContext,
|
||||
) -> CachedCodexAppsToolsLoad {
|
||||
let cache_path = cache_context.cache_path();
|
||||
let bytes = match std::fs::read(cache_path) {
|
||||
Ok(bytes) => bytes,
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
|
||||
return CachedCodexAppsToolsLoad::Missing;
|
||||
}
|
||||
Err(_) => return CachedCodexAppsToolsLoad::Invalid,
|
||||
};
|
||||
let cache: CodexAppsToolsDiskCache = match serde_json::from_slice(&bytes) {
|
||||
Ok(cache) => cache,
|
||||
Err(_) => return CachedCodexAppsToolsLoad::Invalid,
|
||||
};
|
||||
if cache.schema_version != CODEX_APPS_TOOLS_CACHE_SCHEMA_VERSION {
|
||||
return CachedCodexAppsToolsLoad::Invalid;
|
||||
}
|
||||
CachedCodexAppsToolsLoad::Hit(filter_disallowed_codex_apps_tools(cache.tools))
|
||||
}
|
||||
|
||||
fn write_cached_codex_apps_tools(cache_context: &CodexAppsToolsCacheContext, tools: &[ToolInfo]) {
|
||||
let cache_path = cache_context.cache_path();
|
||||
if let Some(parent) = cache_path.parent()
|
||||
&& std::fs::create_dir_all(parent).is_err()
|
||||
{
|
||||
return;
|
||||
}
|
||||
let tools = filter_disallowed_codex_apps_tools(tools.to_vec());
|
||||
let Ok(bytes) = serde_json::to_vec_pretty(&CodexAppsToolsDiskCache {
|
||||
schema_version: CODEX_APPS_TOOLS_CACHE_SCHEMA_VERSION,
|
||||
tools,
|
||||
}) else {
|
||||
return;
|
||||
};
|
||||
let _ = std::fs::write(cache_path, bytes);
|
||||
}
|
||||
|
||||
fn filter_disallowed_codex_apps_tools(tools: Vec<ToolInfo>) -> Vec<ToolInfo> {
|
||||
tools
|
||||
.into_iter()
|
||||
.filter(|tool| {
|
||||
tool.connector_id
|
||||
.as_deref()
|
||||
.is_none_or(is_connector_id_allowed)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn emit_duration(metric: &str, duration: Duration, tags: &[(&str, &str)]) {
|
||||
if let Some(metrics) = codex_otel::global() {
|
||||
let _ = metrics.record_duration(metric, duration, tags);
|
||||
|
|
@ -1740,32 +1284,17 @@ async fn list_tools_for_client_uncached(
|
|||
.tools
|
||||
.into_iter()
|
||||
.map(|tool| {
|
||||
let callable_name = normalize_codex_apps_callable_name(
|
||||
server_name,
|
||||
&tool.tool.name,
|
||||
tool.connector_id.as_deref(),
|
||||
tool.connector_name.as_deref(),
|
||||
);
|
||||
let callable_namespace = normalize_codex_apps_callable_namespace(
|
||||
server_name,
|
||||
tool.connector_name.as_deref(),
|
||||
);
|
||||
let callable_name = tool.tool.name.to_string();
|
||||
let callable_namespace =
|
||||
format!("mcp{MCP_TOOL_NAME_DELIMITER}{server_name}{MCP_TOOL_NAME_DELIMITER}");
|
||||
let connector_name = tool.connector_name;
|
||||
let connector_description = tool.connector_description;
|
||||
let mut tool_def = tool.tool;
|
||||
if let Some(title) = tool_def.title.as_deref() {
|
||||
let normalized_title =
|
||||
normalize_codex_apps_tool_title(server_name, connector_name.as_deref(), title);
|
||||
if tool_def.title.as_deref() != Some(normalized_title.as_str()) {
|
||||
tool_def.title = Some(normalized_title);
|
||||
}
|
||||
}
|
||||
ToolInfo {
|
||||
server_name: server_name.to_owned(),
|
||||
callable_name,
|
||||
callable_namespace,
|
||||
server_instructions: server_instructions.map(str::to_string),
|
||||
tool: tool_def,
|
||||
tool: tool.tool,
|
||||
connector_id: tool.connector_id,
|
||||
connector_name,
|
||||
plugin_display_names: Vec::new(),
|
||||
|
|
@ -1773,9 +1302,6 @@ async fn list_tools_for_client_uncached(
|
|||
}
|
||||
})
|
||||
.collect();
|
||||
if server_name == CODEX_APPS_MCP_SERVER_NAME {
|
||||
return Ok(filter_disallowed_codex_apps_tools(tools));
|
||||
}
|
||||
Ok(tools)
|
||||
}
|
||||
|
||||
|
|
|
|||
31
vendor/codex/codex-rs/core/src/connectors.rs
vendored
31
vendor/codex/codex-rs/core/src/connectors.rs
vendored
|
|
@ -1,27 +1,10 @@
|
|||
pub use codex_app_server_protocol::AppBranding;
|
||||
pub use codex_app_server_protocol::AppInfo;
|
||||
pub use codex_app_server_protocol::AppMetadata;
|
||||
use codex_config::types::AppToolApproval;
|
||||
use codex_mcp::ToolInfo;
|
||||
use rmcp::model::ToolAnnotations;
|
||||
|
||||
use crate::config::Config;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub(crate) struct AppToolPolicy {
|
||||
pub enabled: bool,
|
||||
pub approval: AppToolApproval,
|
||||
}
|
||||
|
||||
impl Default for AppToolPolicy {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
enabled: true,
|
||||
approval: AppToolApproval::Auto,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AccessibleConnectorsStatus {
|
||||
pub connectors: Vec<AppInfo>,
|
||||
|
|
@ -77,17 +60,3 @@ pub fn accessible_connectors_from_mcp_tools(
|
|||
pub fn with_app_enabled_state(connectors: Vec<AppInfo>, _config: &Config) -> Vec<AppInfo> {
|
||||
connectors
|
||||
}
|
||||
|
||||
pub(crate) fn app_tool_policy(
|
||||
_config: &Config,
|
||||
_connector_id: Option<&str>,
|
||||
_tool_name: &str,
|
||||
_tool_title: Option<&str>,
|
||||
_annotations: Option<&ToolAnnotations>,
|
||||
) -> AppToolPolicy {
|
||||
AppToolPolicy::default()
|
||||
}
|
||||
|
||||
pub(crate) fn codex_app_tool_is_enabled(_config: &Config, _tool_info: &ToolInfo) -> bool {
|
||||
true
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,962 +0,0 @@
|
|||
{
|
||||
"schema_version": 4,
|
||||
"templates": [
|
||||
{
|
||||
"source_tool_index": 0,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_comment_to_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "comment",
|
||||
"label": "Comment"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a comment to a pull request?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 1,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_reaction_to_issue_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a reaction to an issue comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 2,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_reaction_to_pr",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a reaction to a pull request?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 3,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_reaction_to_pr_review_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a reaction to a pull request review comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 4,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_review_to_pr",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "action",
|
||||
"label": "Action"
|
||||
},
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "review",
|
||||
"label": "Review"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to submit a pull request review?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 5,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_blob",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "content",
|
||||
"label": "Content"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a Git blob?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 6,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_branch",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "branch_name",
|
||||
"label": "Branch"
|
||||
},
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a branch?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 7,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_commit",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "message",
|
||||
"label": "Message"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a commit?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 8,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_pull_request",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
},
|
||||
{
|
||||
"name": "head_branch",
|
||||
"label": "Head branch"
|
||||
},
|
||||
{
|
||||
"name": "base_branch",
|
||||
"label": "Base branch"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a pull request?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 9,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_tree",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "tree_elements",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a Git tree?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 10,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "enable_auto_merge",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to enable pull request auto-merge?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 11,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "label_pr",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "label",
|
||||
"label": "Label"
|
||||
},
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a label to a pull request?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 12,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "remove_reaction_from_issue_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction_id",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to remove a reaction from an issue comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 13,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "remove_reaction_from_pr",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction_id",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to remove a reaction from a pull request?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 14,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "remove_reaction_from_pr_review_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "reaction_id",
|
||||
"label": "Reaction"
|
||||
},
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to remove a reaction from a pull request review comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 15,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "reply_to_review_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "pr_number",
|
||||
"label": "Pull request"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "comment",
|
||||
"label": "Comment"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to reply to a pull request review comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 16,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_issue_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment ID"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "comment",
|
||||
"label": "Comment"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update an issue comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 17,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_ref",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "branch_name",
|
||||
"label": "Branch"
|
||||
},
|
||||
{
|
||||
"name": "repository_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "sha",
|
||||
"label": "Commit"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update a branch reference?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 18,
|
||||
"connector_id": "connector_76869538009648d5b282a4bb21c3d157",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_review_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment ID"
|
||||
},
|
||||
{
|
||||
"name": "repo_full_name",
|
||||
"label": "Repository"
|
||||
},
|
||||
{
|
||||
"name": "comment",
|
||||
"label": "Comment"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update a pull request review comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 19,
|
||||
"connector_id": "connector_947e0d954944416db111db556030eea6",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_event",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
},
|
||||
{
|
||||
"name": "start_time",
|
||||
"label": "Start"
|
||||
},
|
||||
{
|
||||
"name": "attendees",
|
||||
"label": "Attendees"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create an event?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 20,
|
||||
"connector_id": "connector_947e0d954944416db111db556030eea6",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "delete_event",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "event_id",
|
||||
"label": "Event"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to delete an event?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 21,
|
||||
"connector_id": "connector_947e0d954944416db111db556030eea6",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "respond_event",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "response_status",
|
||||
"label": "Response Status"
|
||||
},
|
||||
{
|
||||
"name": "event_id",
|
||||
"label": "Event"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to respond to an event?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 22,
|
||||
"connector_id": "connector_947e0d954944416db111db556030eea6",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_event",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "event_id",
|
||||
"label": "Event"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update an event?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 23,
|
||||
"connector_id": "connector_9d7cfa34e6654a5f98d3387af34b2e1c",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "batch_update",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "spreadsheet_url",
|
||||
"label": "Spreadsheet"
|
||||
},
|
||||
{
|
||||
"name": "requests",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to apply spreadsheet updates?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 24,
|
||||
"connector_id": "connector_9d7cfa34e6654a5f98d3387af34b2e1c",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_spreadsheet",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a spreadsheet?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 25,
|
||||
"connector_id": "connector_9d7cfa34e6654a5f98d3387af34b2e1c",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "duplicate_sheet_in_new_file",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "source_sheet_name",
|
||||
"label": "Source Sheet Name"
|
||||
},
|
||||
{
|
||||
"name": "spreadsheet_url",
|
||||
"label": "Spreadsheet"
|
||||
},
|
||||
{
|
||||
"name": "new_file_name",
|
||||
"label": "New File Name"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to copy a sheet into a new spreadsheet?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 26,
|
||||
"connector_id": "connector_6f1ec045b8fa4ced8738e32c7f74514b",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "batch_update",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "presentation_url",
|
||||
"label": "Presentation"
|
||||
},
|
||||
{
|
||||
"name": "requests",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to apply presentation updates?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 27,
|
||||
"connector_id": "connector_6f1ec045b8fa4ced8738e32c7f74514b",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_presentation",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a presentation?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 28,
|
||||
"connector_id": "connector_4964e3b22e3e427e9b4ae1acf2c1fa34",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "batch_update",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "document_url",
|
||||
"label": "Document"
|
||||
},
|
||||
{
|
||||
"name": "requests",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to apply document updates?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 29,
|
||||
"connector_id": "connector_4964e3b22e3e427e9b4ae1acf2c1fa34",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_document",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a document?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 30,
|
||||
"connector_id": "connector_5f3c8c41a1e54ad7a76272c89e2554fa",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "copy_document",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "url",
|
||||
"label": "URL"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to copy a file?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 31,
|
||||
"connector_id": "connector_5f3c8c41a1e54ad7a76272c89e2554fa",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "share_document",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "url",
|
||||
"label": "URL"
|
||||
},
|
||||
{
|
||||
"name": "permission",
|
||||
"label": "Permission"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to change file sharing?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 32,
|
||||
"connector_id": "asdk_app_69a1d78e929881919bba0dbda1f6436d",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "slack_send_message",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "channel_id",
|
||||
"label": "Conversation"
|
||||
},
|
||||
{
|
||||
"name": "message",
|
||||
"label": "Message"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to send a message?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 33,
|
||||
"connector_id": "asdk_app_69a1d78e929881919bba0dbda1f6436d",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "slack_schedule_message",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "channel_id",
|
||||
"label": "Conversation"
|
||||
},
|
||||
{
|
||||
"name": "post_at",
|
||||
"label": "Send at"
|
||||
},
|
||||
{
|
||||
"name": "message",
|
||||
"label": "Message"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to schedule a message?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 34,
|
||||
"connector_id": "asdk_app_69a1d78e929881919bba0dbda1f6436d",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "slack_create_canvas",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
},
|
||||
{
|
||||
"name": "content",
|
||||
"label": "Content"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a canvas?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 35,
|
||||
"connector_id": "asdk_app_69a1d78e929881919bba0dbda1f6436d",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "slack_send_message_draft",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "channel_id",
|
||||
"label": "Conversation"
|
||||
},
|
||||
{
|
||||
"name": "message",
|
||||
"label": "Message"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a message draft?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 36,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_comment_to_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"label": "Body"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a comment to an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 37,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_label_to_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "label_id",
|
||||
"label": "Label"
|
||||
},
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to add a label to an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 38,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "add_url_attachment_to_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "url",
|
||||
"label": "URL"
|
||||
},
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
},
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to attach a link to an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 39,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "assign_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
},
|
||||
{
|
||||
"name": "user_id",
|
||||
"label": "User"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to assign an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 40,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "title",
|
||||
"label": "Title"
|
||||
},
|
||||
{
|
||||
"name": "team_id",
|
||||
"label": "Team"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 41,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_label",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "label_name",
|
||||
"label": "Label Name"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a label?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 42,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_project",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "name",
|
||||
"label": "Name"
|
||||
},
|
||||
{
|
||||
"name": "team_id",
|
||||
"label": "Team"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a project?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 43,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "remove_label_from_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "label_id",
|
||||
"label": "Label"
|
||||
},
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to remove a label from an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 44,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "resolve_comment",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "comment_id",
|
||||
"label": "Comment"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to resolve a comment?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 45,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "set_issue_state",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
},
|
||||
{
|
||||
"name": "state_id",
|
||||
"label": "State"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to change issue state?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 46,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "unassign_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to unassign an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 47,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_issue",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "issue_id",
|
||||
"label": "Issue"
|
||||
},
|
||||
{
|
||||
"name": "issue_update",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update an issue?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 48,
|
||||
"connector_id": "connector_686fad9b54914a35b75be6d06a0f6f31",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "update_project",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "project_id",
|
||||
"label": "Project"
|
||||
},
|
||||
{
|
||||
"name": "update_fields",
|
||||
"label": "Changes"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to update a project?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 49,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "apply_labels_to_emails",
|
||||
"template_params": [],
|
||||
"template": "Allow {connector_name} to apply label changes to messages?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 50,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "batch_modify_email",
|
||||
"template_params": [],
|
||||
"template": "Allow {connector_name} to update message labels?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 51,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "bulk_label_matching_emails",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "label_name",
|
||||
"label": "Label Name"
|
||||
},
|
||||
{
|
||||
"name": "query",
|
||||
"label": "Query"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to label matching messages?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 52,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_draft",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "to",
|
||||
"label": "To"
|
||||
},
|
||||
{
|
||||
"name": "subject",
|
||||
"label": "Subject"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"label": "Body"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create an email draft?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 53,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "create_label",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "name",
|
||||
"label": "Name"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to create a label?"
|
||||
},
|
||||
{
|
||||
"source_tool_index": 54,
|
||||
"connector_id": "connector_2128aebfecb84f64a069897515042a44",
|
||||
"server_name": "codex_apps",
|
||||
"tool_title": "send_email",
|
||||
"template_params": [
|
||||
{
|
||||
"name": "to",
|
||||
"label": "To"
|
||||
},
|
||||
{
|
||||
"name": "subject",
|
||||
"label": "Subject"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"label": "Body"
|
||||
}
|
||||
],
|
||||
"template": "Allow {connector_name} to send an email?"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -1,18 +1,5 @@
|
|||
use std::collections::HashSet;
|
||||
use std::sync::LazyLock;
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
use serde_json::Map;
|
||||
use serde_json::Value;
|
||||
use tracing::warn;
|
||||
|
||||
const CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES_SCHEMA_VERSION: u8 = 4;
|
||||
const CONNECTOR_NAME_TEMPLATE_VAR: &str = "{connector_name}";
|
||||
|
||||
static CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES: LazyLock<
|
||||
Option<Vec<ConsequentialToolMessageTemplate>>,
|
||||
> = LazyLock::new(load_consequential_tool_message_templates);
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) struct RenderedMcpToolApprovalTemplate {
|
||||
|
|
@ -29,343 +16,12 @@ pub(crate) struct RenderedMcpToolApprovalParam {
|
|||
pub(crate) display_name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct ConsequentialToolMessageTemplatesFile {
|
||||
schema_version: u8,
|
||||
templates: Vec<ConsequentialToolMessageTemplate>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
|
||||
struct ConsequentialToolMessageTemplate {
|
||||
connector_id: String,
|
||||
server_name: String,
|
||||
tool_title: String,
|
||||
template: String,
|
||||
template_params: Vec<ConsequentialToolTemplateParam>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
|
||||
struct ConsequentialToolTemplateParam {
|
||||
name: String,
|
||||
label: String,
|
||||
}
|
||||
|
||||
pub(crate) fn render_mcp_tool_approval_template(
|
||||
server_name: &str,
|
||||
connector_id: Option<&str>,
|
||||
connector_name: Option<&str>,
|
||||
tool_title: Option<&str>,
|
||||
tool_params: Option<&Value>,
|
||||
_server_name: &str,
|
||||
_connector_id: Option<&str>,
|
||||
_connector_name: Option<&str>,
|
||||
_tool_title: Option<&str>,
|
||||
_tool_params: Option<&Value>,
|
||||
) -> Option<RenderedMcpToolApprovalTemplate> {
|
||||
let templates = CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES.as_ref()?;
|
||||
render_mcp_tool_approval_template_from_templates(
|
||||
templates,
|
||||
server_name,
|
||||
connector_id,
|
||||
connector_name,
|
||||
tool_title,
|
||||
tool_params,
|
||||
)
|
||||
}
|
||||
|
||||
fn load_consequential_tool_message_templates() -> Option<Vec<ConsequentialToolMessageTemplate>> {
|
||||
let templates = match serde_json::from_str::<ConsequentialToolMessageTemplatesFile>(
|
||||
include_str!("consequential_tool_message_templates.json"),
|
||||
) {
|
||||
Ok(templates) => templates,
|
||||
Err(err) => {
|
||||
warn!(error = %err, "failed to parse consequential tool approval templates");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
if templates.schema_version != CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES_SCHEMA_VERSION {
|
||||
warn!(
|
||||
found_schema_version = templates.schema_version,
|
||||
expected_schema_version = CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES_SCHEMA_VERSION,
|
||||
"unexpected consequential tool approval templates schema version"
|
||||
);
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(templates.templates)
|
||||
}
|
||||
|
||||
fn render_mcp_tool_approval_template_from_templates(
|
||||
templates: &[ConsequentialToolMessageTemplate],
|
||||
server_name: &str,
|
||||
connector_id: Option<&str>,
|
||||
connector_name: Option<&str>,
|
||||
tool_title: Option<&str>,
|
||||
tool_params: Option<&Value>,
|
||||
) -> Option<RenderedMcpToolApprovalTemplate> {
|
||||
let connector_id = connector_id?;
|
||||
let tool_title = tool_title.map(str::trim).filter(|name| !name.is_empty())?;
|
||||
let template = templates.iter().find(|template| {
|
||||
template.server_name == server_name
|
||||
&& template.connector_id == connector_id
|
||||
&& template.tool_title == tool_title
|
||||
})?;
|
||||
let elicitation_message = render_question_template(&template.template, connector_name)?;
|
||||
let (tool_params, tool_params_display) = match tool_params {
|
||||
Some(Value::Object(tool_params)) => {
|
||||
render_tool_params(tool_params, &template.template_params)?
|
||||
}
|
||||
Some(_) => return None,
|
||||
None => (None, Vec::new()),
|
||||
};
|
||||
|
||||
Some(RenderedMcpToolApprovalTemplate {
|
||||
question: elicitation_message.clone(),
|
||||
elicitation_message,
|
||||
tool_params,
|
||||
tool_params_display,
|
||||
})
|
||||
}
|
||||
|
||||
fn render_question_template(template: &str, connector_name: Option<&str>) -> Option<String> {
|
||||
let template = template.trim();
|
||||
if template.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
if template.contains(CONNECTOR_NAME_TEMPLATE_VAR) {
|
||||
let connector_name = connector_name
|
||||
.map(str::trim)
|
||||
.filter(|name| !name.is_empty())?;
|
||||
return Some(template.replace(CONNECTOR_NAME_TEMPLATE_VAR, connector_name));
|
||||
}
|
||||
|
||||
Some(template.to_string())
|
||||
}
|
||||
|
||||
fn render_tool_params(
|
||||
tool_params: &Map<String, Value>,
|
||||
template_params: &[ConsequentialToolTemplateParam],
|
||||
) -> Option<(Option<Value>, Vec<RenderedMcpToolApprovalParam>)> {
|
||||
let mut display_params = Vec::new();
|
||||
let mut display_names = HashSet::new();
|
||||
let mut handled_names = HashSet::new();
|
||||
|
||||
for template_param in template_params {
|
||||
let label = template_param.label.trim();
|
||||
if label.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let Some(value) = tool_params.get(&template_param.name) else {
|
||||
continue;
|
||||
};
|
||||
if !display_names.insert(label.to_string()) {
|
||||
return None;
|
||||
}
|
||||
display_params.push(RenderedMcpToolApprovalParam {
|
||||
name: template_param.name.clone(),
|
||||
value: value.clone(),
|
||||
display_name: label.to_string(),
|
||||
});
|
||||
handled_names.insert(template_param.name.as_str());
|
||||
}
|
||||
|
||||
let mut remaining_params = tool_params
|
||||
.iter()
|
||||
.filter(|(name, _)| !handled_names.contains(name.as_str()))
|
||||
.collect::<Vec<_>>();
|
||||
remaining_params.sort_by(|(left_name, _), (right_name, _)| left_name.cmp(right_name));
|
||||
|
||||
for (name, value) in remaining_params {
|
||||
if handled_names.contains(name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
if !display_names.insert(name.clone()) {
|
||||
return None;
|
||||
}
|
||||
display_params.push(RenderedMcpToolApprovalParam {
|
||||
name: name.clone(),
|
||||
value: value.clone(),
|
||||
display_name: name.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
Some((Some(Value::Object(tool_params.clone())), display_params))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use pretty_assertions::assert_eq;
|
||||
use serde_json::json;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn renders_exact_match_with_readable_param_labels() {
|
||||
let templates = vec![ConsequentialToolMessageTemplate {
|
||||
connector_id: "calendar".to_string(),
|
||||
server_name: "codex_apps".to_string(),
|
||||
tool_title: "create_event".to_string(),
|
||||
template: "Allow {connector_name} to create an event?".to_string(),
|
||||
template_params: vec![
|
||||
ConsequentialToolTemplateParam {
|
||||
name: "calendar_id".to_string(),
|
||||
label: "Calendar".to_string(),
|
||||
},
|
||||
ConsequentialToolTemplateParam {
|
||||
name: "title".to_string(),
|
||||
label: "Title".to_string(),
|
||||
},
|
||||
],
|
||||
}];
|
||||
|
||||
let rendered = render_mcp_tool_approval_template_from_templates(
|
||||
&templates,
|
||||
"codex_apps",
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
Some("create_event"),
|
||||
Some(&json!({
|
||||
"title": "Roadmap review",
|
||||
"calendar_id": "primary",
|
||||
"timezone": "UTC",
|
||||
})),
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
rendered,
|
||||
Some(RenderedMcpToolApprovalTemplate {
|
||||
question: "Allow Calendar to create an event?".to_string(),
|
||||
elicitation_message: "Allow Calendar to create an event?".to_string(),
|
||||
tool_params: Some(json!({
|
||||
"title": "Roadmap review",
|
||||
"calendar_id": "primary",
|
||||
"timezone": "UTC",
|
||||
})),
|
||||
tool_params_display: vec![
|
||||
RenderedMcpToolApprovalParam {
|
||||
name: "calendar_id".to_string(),
|
||||
value: json!("primary"),
|
||||
display_name: "Calendar".to_string(),
|
||||
},
|
||||
RenderedMcpToolApprovalParam {
|
||||
name: "title".to_string(),
|
||||
value: json!("Roadmap review"),
|
||||
display_name: "Title".to_string(),
|
||||
},
|
||||
RenderedMcpToolApprovalParam {
|
||||
name: "timezone".to_string(),
|
||||
value: json!("UTC"),
|
||||
display_name: "timezone".to_string(),
|
||||
},
|
||||
],
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_none_when_no_exact_match_exists() {
|
||||
let templates = vec![ConsequentialToolMessageTemplate {
|
||||
connector_id: "calendar".to_string(),
|
||||
server_name: "codex_apps".to_string(),
|
||||
tool_title: "create_event".to_string(),
|
||||
template: "Allow {connector_name} to create an event?".to_string(),
|
||||
template_params: Vec::new(),
|
||||
}];
|
||||
|
||||
assert_eq!(
|
||||
render_mcp_tool_approval_template_from_templates(
|
||||
&templates,
|
||||
"codex_apps",
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
Some("delete_event"),
|
||||
Some(&json!({})),
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_none_when_relabeling_would_collide() {
|
||||
let templates = vec![ConsequentialToolMessageTemplate {
|
||||
connector_id: "calendar".to_string(),
|
||||
server_name: "codex_apps".to_string(),
|
||||
tool_title: "create_event".to_string(),
|
||||
template: "Allow {connector_name} to create an event?".to_string(),
|
||||
template_params: vec![ConsequentialToolTemplateParam {
|
||||
name: "calendar_id".to_string(),
|
||||
label: "timezone".to_string(),
|
||||
}],
|
||||
}];
|
||||
|
||||
assert_eq!(
|
||||
render_mcp_tool_approval_template_from_templates(
|
||||
&templates,
|
||||
"codex_apps",
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
Some("create_event"),
|
||||
Some(&json!({
|
||||
"calendar_id": "primary",
|
||||
"timezone": "UTC",
|
||||
})),
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bundled_templates_load() {
|
||||
assert_eq!(CONSEQUENTIAL_TOOL_MESSAGE_TEMPLATES.is_some(), true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn renders_literal_template_without_connector_substitution() {
|
||||
let templates = vec![ConsequentialToolMessageTemplate {
|
||||
connector_id: "github".to_string(),
|
||||
server_name: "codex_apps".to_string(),
|
||||
tool_title: "add_comment".to_string(),
|
||||
template: "Allow GitHub to add a comment to a pull request?".to_string(),
|
||||
template_params: Vec::new(),
|
||||
}];
|
||||
|
||||
let rendered = render_mcp_tool_approval_template_from_templates(
|
||||
&templates,
|
||||
"codex_apps",
|
||||
Some("github"),
|
||||
/*connector_name*/ None,
|
||||
Some("add_comment"),
|
||||
Some(&json!({})),
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
rendered,
|
||||
Some(RenderedMcpToolApprovalTemplate {
|
||||
question: "Allow GitHub to add a comment to a pull request?".to_string(),
|
||||
elicitation_message: "Allow GitHub to add a comment to a pull request?".to_string(),
|
||||
tool_params: Some(json!({})),
|
||||
tool_params_display: Vec::new(),
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_none_when_connector_placeholder_has_no_value() {
|
||||
let templates = vec![ConsequentialToolMessageTemplate {
|
||||
connector_id: "calendar".to_string(),
|
||||
server_name: "codex_apps".to_string(),
|
||||
tool_title: "create_event".to_string(),
|
||||
template: "Allow {connector_name} to create an event?".to_string(),
|
||||
template_params: Vec::new(),
|
||||
}];
|
||||
|
||||
assert_eq!(
|
||||
render_mcp_tool_approval_template_from_templates(
|
||||
&templates,
|
||||
"codex_apps",
|
||||
Some("calendar"),
|
||||
/*connector_name*/ None,
|
||||
Some("create_event"),
|
||||
Some(&json!({})),
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
|
|
|||
250
vendor/codex/codex-rs/core/src/mcp_tool_call.rs
vendored
250
vendor/codex/codex-rs/core/src/mcp_tool_call.rs
vendored
|
|
@ -16,7 +16,6 @@ use crate::config::Config;
|
|||
use crate::config::edit::ConfigEdit;
|
||||
use crate::config::edit::ConfigEditsBuilder;
|
||||
use crate::config::load_global_mcp_servers;
|
||||
use crate::connectors;
|
||||
use crate::guardian::GuardianApprovalRequest;
|
||||
use crate::guardian::GuardianMcpAnnotations;
|
||||
use crate::guardian::guardian_approval_request_to_json;
|
||||
|
|
@ -30,12 +29,8 @@ use crate::mcp_tool_approval_templates::RenderedMcpToolApprovalParam;
|
|||
use crate::mcp_tool_approval_templates::render_mcp_tool_approval_template;
|
||||
use crate::session::session::Session;
|
||||
use crate::session::turn_context::TurnContext;
|
||||
use codex_analytics::AppInvocation;
|
||||
use codex_analytics::InvocationType;
|
||||
use codex_analytics::build_track_events_context;
|
||||
use codex_config::types::AppToolApproval;
|
||||
use codex_features::Feature;
|
||||
use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
|
||||
use codex_mcp::SandboxState;
|
||||
use codex_mcp::declared_openai_file_input_param_names;
|
||||
use codex_mcp::mcp_permission_prompt_is_auto_approved;
|
||||
|
|
@ -104,48 +99,7 @@ pub(crate) async fn handle_mcp_tool_call(
|
|||
let mcp_app_resource_uri = metadata
|
||||
.as_ref()
|
||||
.and_then(|metadata| metadata.mcp_app_resource_uri.clone());
|
||||
let app_tool_policy = if server == CODEX_APPS_MCP_SERVER_NAME {
|
||||
connectors::app_tool_policy(
|
||||
&turn_context.config,
|
||||
metadata
|
||||
.as_ref()
|
||||
.and_then(|metadata| metadata.connector_id.as_deref()),
|
||||
&tool_name,
|
||||
metadata
|
||||
.as_ref()
|
||||
.and_then(|metadata| metadata.tool_title.as_deref()),
|
||||
metadata
|
||||
.as_ref()
|
||||
.and_then(|metadata| metadata.annotations.as_ref()),
|
||||
)
|
||||
} else {
|
||||
connectors::AppToolPolicy::default()
|
||||
};
|
||||
let approval_mode = if server == CODEX_APPS_MCP_SERVER_NAME {
|
||||
app_tool_policy.approval
|
||||
} else {
|
||||
custom_mcp_tool_approval_mode(turn_context.as_ref(), &server, &tool_name)
|
||||
};
|
||||
|
||||
if server == CODEX_APPS_MCP_SERVER_NAME && !app_tool_policy.enabled {
|
||||
let result = notify_mcp_tool_call_skip(
|
||||
sess.as_ref(),
|
||||
turn_context.as_ref(),
|
||||
&call_id,
|
||||
invocation,
|
||||
mcp_app_resource_uri.clone(),
|
||||
"MCP tool call blocked by app configuration".to_string(),
|
||||
/*already_started*/ false,
|
||||
)
|
||||
.await;
|
||||
let status = if result.is_ok() { "ok" } else { "error" };
|
||||
turn_context.session_telemetry.counter(
|
||||
MCP_CALL_COUNT_METRIC,
|
||||
/*inc*/ 1,
|
||||
&[("status", status)],
|
||||
);
|
||||
return CallToolResult::from_result(result);
|
||||
}
|
||||
let approval_mode = custom_mcp_tool_approval_mode(turn_context.as_ref(), &server, &tool_name);
|
||||
let request_meta =
|
||||
build_mcp_tool_call_request_meta(turn_context.as_ref(), &server, metadata.as_ref());
|
||||
let connector_id = metadata
|
||||
|
|
@ -228,13 +182,6 @@ pub(crate) async fn handle_mcp_tool_call(
|
|||
tool_call_end_event.clone(),
|
||||
)
|
||||
.await;
|
||||
maybe_track_codex_app_used(
|
||||
sess.as_ref(),
|
||||
turn_context.as_ref(),
|
||||
&server,
|
||||
&tool_name,
|
||||
)
|
||||
.await;
|
||||
(result, Some(duration))
|
||||
}
|
||||
McpToolApprovalDecision::Decline { message } => {
|
||||
|
|
@ -345,7 +292,6 @@ pub(crate) async fn handle_mcp_tool_call(
|
|||
tool_call_end_event.clone(),
|
||||
)
|
||||
.await;
|
||||
maybe_track_codex_app_used(sess.as_ref(), turn_context.as_ref(), &server, &tool_name).await;
|
||||
|
||||
let status = if result.is_ok() { "ok" } else { "error" };
|
||||
emit_mcp_call_metrics(
|
||||
|
|
@ -593,41 +539,6 @@ async fn notify_mcp_tool_call_event(sess: &Session, turn_context: &TurnContext,
|
|||
sess.send_event(turn_context, event).await;
|
||||
}
|
||||
|
||||
struct McpAppUsageMetadata {
|
||||
connector_id: Option<String>,
|
||||
app_name: Option<String>,
|
||||
}
|
||||
|
||||
async fn maybe_track_codex_app_used(
|
||||
sess: &Session,
|
||||
turn_context: &TurnContext,
|
||||
server: &str,
|
||||
tool_name: &str,
|
||||
) {
|
||||
if server != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return;
|
||||
}
|
||||
let metadata = lookup_mcp_app_usage_metadata(sess, server, tool_name).await;
|
||||
let (connector_id, app_name) = metadata
|
||||
.map(|metadata| (metadata.connector_id, metadata.app_name))
|
||||
.unwrap_or((None, None));
|
||||
let invocation_type = InvocationType::Implicit;
|
||||
|
||||
let tracking = build_track_events_context(
|
||||
turn_context.model_info.slug.clone(),
|
||||
sess.conversation_id.to_string(),
|
||||
turn_context.sub_id.clone(),
|
||||
);
|
||||
sess.services.analytics_events_client.track_app_used(
|
||||
tracking,
|
||||
AppInvocation {
|
||||
connector_id,
|
||||
app_name,
|
||||
invocation_type: Some(invocation_type),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
enum McpToolApprovalDecision {
|
||||
Accept,
|
||||
|
|
@ -646,11 +557,9 @@ pub(crate) struct McpToolApprovalMetadata {
|
|||
tool_title: Option<String>,
|
||||
tool_description: Option<String>,
|
||||
mcp_app_resource_uri: Option<String>,
|
||||
codex_apps_meta: Option<serde_json::Map<String, serde_json::Value>>,
|
||||
openai_file_input_params: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
const MCP_TOOL_CODEX_APPS_META_KEY: &str = "_codex_apps";
|
||||
const MCP_TOOL_OPENAI_OUTPUT_TEMPLATE_META_KEY: &str = "openai/outputTemplate";
|
||||
const MCP_TOOL_UI_RESOURCE_URI_META_KEY: &str = "ui/resourceUri";
|
||||
const MCP_TOOL_THREAD_ID_META_KEY: &str = "threadId";
|
||||
|
|
@ -683,8 +592,8 @@ fn custom_mcp_tool_approval_mode(
|
|||
|
||||
fn build_mcp_tool_call_request_meta(
|
||||
turn_context: &TurnContext,
|
||||
server: &str,
|
||||
metadata: Option<&McpToolApprovalMetadata>,
|
||||
_server: &str,
|
||||
_metadata: Option<&McpToolApprovalMetadata>,
|
||||
) -> Option<serde_json::Value> {
|
||||
let mut request_meta = serde_json::Map::new();
|
||||
|
||||
|
|
@ -695,16 +604,6 @@ fn build_mcp_tool_call_request_meta(
|
|||
);
|
||||
}
|
||||
|
||||
if server == CODEX_APPS_MCP_SERVER_NAME
|
||||
&& let Some(codex_apps_meta) =
|
||||
metadata.and_then(|metadata| metadata.codex_apps_meta.clone())
|
||||
{
|
||||
request_meta.insert(
|
||||
MCP_TOOL_CODEX_APPS_META_KEY.to_string(),
|
||||
serde_json::Value::Object(codex_apps_meta),
|
||||
);
|
||||
}
|
||||
|
||||
(!request_meta.is_empty()).then_some(serde_json::Value::Object(request_meta))
|
||||
}
|
||||
|
||||
|
|
@ -763,11 +662,6 @@ const MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL: &str = "mcp_tool_call";
|
|||
const MCP_TOOL_APPROVAL_PERSIST_KEY: &str = "persist";
|
||||
const MCP_TOOL_APPROVAL_PERSIST_SESSION: &str = "session";
|
||||
const MCP_TOOL_APPROVAL_PERSIST_ALWAYS: &str = "always";
|
||||
const MCP_TOOL_APPROVAL_SOURCE_KEY: &str = "source";
|
||||
const MCP_TOOL_APPROVAL_SOURCE_CONNECTOR: &str = "connector";
|
||||
const MCP_TOOL_APPROVAL_CONNECTOR_ID_KEY: &str = "connector_id";
|
||||
const MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY: &str = "connector_name";
|
||||
const MCP_TOOL_APPROVAL_CONNECTOR_DESCRIPTION_KEY: &str = "connector_description";
|
||||
const MCP_TOOL_APPROVAL_TOOL_TITLE_KEY: &str = "tool_title";
|
||||
const MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY: &str = "tool_description";
|
||||
const MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY: &str = "tool_params";
|
||||
|
|
@ -1013,9 +907,6 @@ fn session_mcp_tool_approval_key(
|
|||
}
|
||||
|
||||
let connector_id = metadata.and_then(|metadata| metadata.connector_id.clone());
|
||||
if invocation.server == CODEX_APPS_MCP_SERVER_NAME && connector_id.is_none() {
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(McpToolApprovalKey {
|
||||
server: invocation.server.clone(),
|
||||
|
|
@ -1095,7 +986,7 @@ fn mcp_tool_approval_callsite_mode(
|
|||
)]
|
||||
pub(crate) async fn lookup_mcp_tool_metadata(
|
||||
sess: &Session,
|
||||
turn_context: &TurnContext,
|
||||
_turn_context: &TurnContext,
|
||||
server: &str,
|
||||
tool_name: &str,
|
||||
) -> Option<McpToolApprovalMetadata> {
|
||||
|
|
@ -1109,45 +1000,15 @@ pub(crate) async fn lookup_mcp_tool_metadata(
|
|||
let tool_info = tools
|
||||
.into_values()
|
||||
.find(|tool_info| tool_info.server_name == server && tool_info.tool.name == tool_name)?;
|
||||
let connector_description = if server == CODEX_APPS_MCP_SERVER_NAME {
|
||||
let connectors = match connectors::list_cached_accessible_connectors_from_mcp_tools(
|
||||
turn_context.config.as_ref(),
|
||||
)
|
||||
.await
|
||||
{
|
||||
Some(connectors) => Some(connectors),
|
||||
None => {
|
||||
connectors::list_accessible_connectors_from_mcp_tools(turn_context.config.as_ref())
|
||||
.await
|
||||
.ok()
|
||||
}
|
||||
};
|
||||
connectors.and_then(|connectors| {
|
||||
let connector_id = tool_info.connector_id.as_deref()?;
|
||||
connectors
|
||||
.into_iter()
|
||||
.find(|connector| connector.id == connector_id)
|
||||
.and_then(|connector| connector.description)
|
||||
})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
Some(McpToolApprovalMetadata {
|
||||
annotations: tool_info.tool.annotations,
|
||||
connector_id: tool_info.connector_id,
|
||||
connector_name: tool_info.connector_name,
|
||||
connector_description,
|
||||
connector_description: tool_info.connector_description,
|
||||
tool_title: tool_info.tool.title,
|
||||
tool_description: tool_info.tool.description.map(std::borrow::Cow::into_owned),
|
||||
mcp_app_resource_uri: get_mcp_app_resource_uri(tool_info.tool.meta.as_deref()),
|
||||
codex_apps_meta: tool_info
|
||||
.tool
|
||||
.meta
|
||||
.as_ref()
|
||||
.and_then(|meta| meta.get(MCP_TOOL_CODEX_APPS_META_KEY))
|
||||
.and_then(serde_json::Value::as_object)
|
||||
.cloned(),
|
||||
openai_file_input_params: Some(declared_openai_file_input_param_names(
|
||||
tool_info.tool.meta.as_deref(),
|
||||
))
|
||||
|
|
@ -1175,35 +1036,6 @@ fn get_mcp_app_resource_uri(
|
|||
})
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::await_holding_invalid_type,
|
||||
reason = "MCP app metadata reads through the session-owned manager guard"
|
||||
)]
|
||||
async fn lookup_mcp_app_usage_metadata(
|
||||
sess: &Session,
|
||||
server: &str,
|
||||
tool_name: &str,
|
||||
) -> Option<McpAppUsageMetadata> {
|
||||
let tools = sess
|
||||
.services
|
||||
.mcp_connection_manager
|
||||
.read()
|
||||
.await
|
||||
.list_all_tools()
|
||||
.await;
|
||||
|
||||
tools.into_values().find_map(|tool_info| {
|
||||
if tool_info.server_name == server && tool_info.tool.name == tool_name {
|
||||
Some(McpAppUsageMetadata {
|
||||
connector_id: tool_info.connector_id,
|
||||
app_name: tool_info.connector_name,
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn build_mcp_tool_approval_question(
|
||||
question_id: String,
|
||||
server: &str,
|
||||
|
|
@ -1242,7 +1074,7 @@ fn build_mcp_tool_approval_question(
|
|||
|
||||
RequestUserInputQuestion {
|
||||
id: question_id,
|
||||
header: "Approve app tool call?".to_string(),
|
||||
header: "Approve MCP tool call?".to_string(),
|
||||
question,
|
||||
is_other: false,
|
||||
is_secret: false,
|
||||
|
|
@ -1259,13 +1091,7 @@ fn build_mcp_tool_approval_fallback_message(
|
|||
.map(str::trim)
|
||||
.filter(|name| !name.is_empty())
|
||||
.map(ToString::to_string)
|
||||
.unwrap_or_else(|| {
|
||||
if server == CODEX_APPS_MCP_SERVER_NAME {
|
||||
"this app".to_string()
|
||||
} else {
|
||||
format!("the {server} MCP server")
|
||||
}
|
||||
});
|
||||
.unwrap_or_else(|| format!("the {server} MCP server"));
|
||||
format!("Allow {actor} to run tool \"{tool_name}\"?")
|
||||
}
|
||||
|
||||
|
|
@ -1321,7 +1147,7 @@ fn build_mcp_tool_approval_elicitation_request(
|
|||
}
|
||||
|
||||
fn build_mcp_tool_approval_elicitation_meta(
|
||||
server: &str,
|
||||
_server: &str,
|
||||
metadata: Option<&McpToolApprovalMetadata>,
|
||||
tool_params: Option<&serde_json::Value>,
|
||||
tool_params_display: Option<&[RenderedMcpToolApprovalParam]>,
|
||||
|
|
@ -1372,34 +1198,6 @@ fn build_mcp_tool_approval_elicitation_meta(
|
|||
serde_json::Value::String(tool_description.clone()),
|
||||
);
|
||||
}
|
||||
if server == CODEX_APPS_MCP_SERVER_NAME
|
||||
&& (metadata.connector_id.is_some()
|
||||
|| metadata.connector_name.is_some()
|
||||
|| metadata.connector_description.is_some())
|
||||
{
|
||||
meta.insert(
|
||||
MCP_TOOL_APPROVAL_SOURCE_KEY.to_string(),
|
||||
serde_json::Value::String(MCP_TOOL_APPROVAL_SOURCE_CONNECTOR.to_string()),
|
||||
);
|
||||
if let Some(connector_id) = metadata.connector_id.as_deref() {
|
||||
meta.insert(
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_ID_KEY.to_string(),
|
||||
serde_json::Value::String(connector_id.to_string()),
|
||||
);
|
||||
}
|
||||
if let Some(connector_name) = metadata.connector_name.as_ref() {
|
||||
meta.insert(
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY.to_string(),
|
||||
serde_json::Value::String(connector_name.clone()),
|
||||
);
|
||||
}
|
||||
if let Some(connector_description) = metadata.connector_description.as_ref() {
|
||||
meta.insert(
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_DESCRIPTION_KEY.to_string(),
|
||||
serde_json::Value::String(connector_description.clone()),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(tool_params) = tool_params {
|
||||
meta.insert(
|
||||
|
|
@ -1600,16 +1398,8 @@ async fn maybe_persist_mcp_tool_approval(
|
|||
) {
|
||||
let tool_name = key.tool_name.clone();
|
||||
|
||||
let persist_result = if key.server == CODEX_APPS_MCP_SERVER_NAME {
|
||||
let Some(connector_id) = key.connector_id.clone() else {
|
||||
remember_mcp_tool_approval(sess, key).await;
|
||||
return;
|
||||
};
|
||||
persist_codex_app_tool_approval(&turn_context.config.codex_home, &connector_id, &tool_name)
|
||||
.await
|
||||
} else {
|
||||
persist_custom_mcp_tool_approval(&turn_context.config, &key.server, &tool_name).await
|
||||
};
|
||||
let persist_result =
|
||||
persist_custom_mcp_tool_approval(&turn_context.config, &key.server, &tool_name).await;
|
||||
|
||||
if let Err(err) = persist_result {
|
||||
error!(
|
||||
|
|
@ -1626,26 +1416,6 @@ async fn maybe_persist_mcp_tool_approval(
|
|||
remember_mcp_tool_approval(sess, key).await;
|
||||
}
|
||||
|
||||
async fn persist_codex_app_tool_approval(
|
||||
codex_home: &AbsolutePathBuf,
|
||||
connector_id: &str,
|
||||
tool_name: &str,
|
||||
) -> anyhow::Result<()> {
|
||||
ConfigEditsBuilder::new(codex_home)
|
||||
.with_edits([ConfigEdit::SetPath {
|
||||
segments: vec![
|
||||
"apps".to_string(),
|
||||
connector_id.to_string(),
|
||||
"tools".to_string(),
|
||||
tool_name.to_string(),
|
||||
"approval_mode".to_string(),
|
||||
],
|
||||
value: value("approve"),
|
||||
}])
|
||||
.apply()
|
||||
.await
|
||||
}
|
||||
|
||||
async fn persist_custom_mcp_tool_approval(
|
||||
config: &Config,
|
||||
server: &str,
|
||||
|
|
|
|||
|
|
@ -5,17 +5,12 @@ use crate::session::tests::make_session_and_context_with_rx;
|
|||
use crate::state::ActiveTurn;
|
||||
use codex_config::CONFIG_TOML_FILE;
|
||||
use codex_config::config_toml::ConfigToml;
|
||||
use codex_config::types::AppConfig;
|
||||
use codex_config::types::AppToolConfig;
|
||||
use codex_config::types::AppToolsConfig;
|
||||
use codex_config::types::ApprovalsReviewer;
|
||||
use codex_config::types::AppsConfigToml;
|
||||
use codex_config::types::McpServerConfig;
|
||||
use codex_config::types::McpServerToolConfig;
|
||||
use codex_model_provider::create_model_provider;
|
||||
use codex_protocol::protocol::AskForApproval;
|
||||
use codex_protocol::protocol::SandboxPolicy;
|
||||
use core_test_support::PathExt;
|
||||
use core_test_support::responses::ev_assistant_message;
|
||||
use core_test_support::responses::ev_completed;
|
||||
use core_test_support::responses::ev_response_created;
|
||||
|
|
@ -61,7 +56,6 @@ fn approval_metadata(
|
|||
tool_title: tool_title.map(str::to_string),
|
||||
tool_description: tool_description.map(str::to_string),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
}
|
||||
}
|
||||
|
|
@ -223,7 +217,7 @@ async fn approval_elicitation_request_uses_message_override_and_preserves_tool_p
|
|||
let (session, turn_context) = make_session_and_context().await;
|
||||
let question = build_mcp_tool_approval_question(
|
||||
"q".to_string(),
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"custom_server",
|
||||
"create_event",
|
||||
Some("Calendar"),
|
||||
prompt_options(
|
||||
|
|
@ -236,7 +230,7 @@ async fn approval_elicitation_request_uses_message_override_and_preserves_tool_p
|
|||
&session,
|
||||
&turn_context,
|
||||
McpToolApprovalElicitationRequest {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME,
|
||||
server: "custom_server",
|
||||
metadata: Some(&approval_metadata(
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
|
|
@ -273,7 +267,7 @@ async fn approval_elicitation_request_uses_message_override_and_preserves_tool_p
|
|||
McpServerElicitationRequestParams {
|
||||
thread_id: session.conversation_id.to_string(),
|
||||
turn_id: Some(turn_context.sub_id),
|
||||
server_name: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server_name: "custom_server".to_string(),
|
||||
request: McpServerElicitationRequest::Form {
|
||||
meta: Some(serde_json::json!({
|
||||
MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
|
||||
|
|
@ -281,10 +275,6 @@ async fn approval_elicitation_request_uses_message_override_and_preserves_tool_p
|
|||
MCP_TOOL_APPROVAL_PERSIST_SESSION,
|
||||
MCP_TOOL_APPROVAL_PERSIST_ALWAYS,
|
||||
],
|
||||
MCP_TOOL_APPROVAL_SOURCE_KEY: MCP_TOOL_APPROVAL_SOURCE_CONNECTOR,
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_ID_KEY: "calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY: "Calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_DESCRIPTION_KEY: "Manage events and schedules.",
|
||||
MCP_TOOL_APPROVAL_TOOL_TITLE_KEY: "Create Event",
|
||||
MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY: "Create a calendar event.",
|
||||
MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY: {
|
||||
|
|
@ -329,7 +319,7 @@ fn custom_mcp_tool_question_mentions_server_name() {
|
|||
/*question_override*/ None,
|
||||
);
|
||||
|
||||
assert_eq!(question.header, "Approve app tool call?");
|
||||
assert_eq!(question.header, "Approve MCP tool call?");
|
||||
assert_eq!(
|
||||
question.question,
|
||||
"Allow the custom_server MCP server to run tool \"run_action\"?"
|
||||
|
|
@ -345,29 +335,10 @@ fn custom_mcp_tool_question_mentions_server_name() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn codex_apps_tool_question_uses_fallback_app_label() {
|
||||
fn trusted_mcp_tool_question_offers_always_allow() {
|
||||
let question = build_mcp_tool_approval_question(
|
||||
"q".to_string(),
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"run_action",
|
||||
/*connector_name*/ None,
|
||||
prompt_options(
|
||||
/*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
|
||||
),
|
||||
/*question_override*/ None,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
question.question,
|
||||
"Allow this app to run tool \"run_action\"?"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trusted_codex_apps_tool_question_offers_always_allow() {
|
||||
let question = build_mcp_tool_approval_question(
|
||||
"q".to_string(),
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"custom_server",
|
||||
"run_action",
|
||||
Some("Calendar"),
|
||||
prompt_options(
|
||||
|
|
@ -400,16 +371,16 @@ fn trusted_codex_apps_tool_question_offers_always_allow() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn codex_apps_tool_question_without_elicitation_omits_always_allow() {
|
||||
fn trusted_mcp_tool_question_without_elicitation_omits_always_allow() {
|
||||
let session_key = McpToolApprovalKey {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
connector_id: Some("calendar".to_string()),
|
||||
tool_name: "run_action".to_string(),
|
||||
};
|
||||
let persistent_key = session_key.clone();
|
||||
let question = build_mcp_tool_approval_question(
|
||||
"q".to_string(),
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"custom_server",
|
||||
"run_action",
|
||||
Some("Calendar"),
|
||||
mcp_tool_approval_prompt_options(
|
||||
|
|
@ -492,9 +463,9 @@ fn custom_servers_support_session_and_persistent_approval() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn codex_apps_connectors_support_persistent_approval() {
|
||||
fn connector_metadata_can_scope_persistent_approval() {
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "calendar/list_events".to_string(),
|
||||
arguments: None,
|
||||
};
|
||||
|
|
@ -506,7 +477,7 @@ fn codex_apps_connectors_support_persistent_approval() {
|
|||
/*tool_description*/ None,
|
||||
);
|
||||
let expected = McpToolApprovalKey {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
connector_id: Some("calendar".to_string()),
|
||||
tool_name: "calendar/list_events".to_string(),
|
||||
};
|
||||
|
|
@ -603,54 +574,6 @@ async fn mcp_tool_call_request_meta_includes_turn_metadata_for_custom_server() {
|
|||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn codex_apps_tool_call_request_meta_includes_turn_metadata_and_codex_apps_meta() {
|
||||
let (_, turn_context) = make_session_and_context().await;
|
||||
let expected_turn_metadata = serde_json::from_str::<serde_json::Value>(
|
||||
&turn_context
|
||||
.turn_metadata_state
|
||||
.current_header_value()
|
||||
.expect("turn metadata header"),
|
||||
)
|
||||
.expect("turn metadata json");
|
||||
let metadata = McpToolApprovalMetadata {
|
||||
annotations: None,
|
||||
connector_id: Some("calendar".to_string()),
|
||||
connector_name: Some("Calendar".to_string()),
|
||||
connector_description: Some("Manage events".to_string()),
|
||||
tool_title: Some("Create Event".to_string()),
|
||||
tool_description: Some("Create a calendar event.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: Some(
|
||||
serde_json::json!({
|
||||
"resource_uri": "connector://calendar/tools/calendar_create_event",
|
||||
"contains_mcp_source": true,
|
||||
"connector_id": "calendar",
|
||||
})
|
||||
.as_object()
|
||||
.cloned()
|
||||
.expect("_codex_apps metadata should be an object"),
|
||||
),
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
build_mcp_tool_call_request_meta(
|
||||
&turn_context,
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
Some(&metadata),
|
||||
),
|
||||
Some(serde_json::json!({
|
||||
crate::X_CODEX_TURN_METADATA_HEADER: expected_turn_metadata,
|
||||
MCP_TOOL_CODEX_APPS_META_KEY: {
|
||||
"resource_uri": "connector://calendar/tools/calendar_create_event",
|
||||
"contains_mcp_source": true,
|
||||
"connector_id": "calendar",
|
||||
},
|
||||
}))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mcp_tool_call_thread_id_meta_is_added_to_request_meta() {
|
||||
assert_eq!(
|
||||
|
|
@ -755,7 +678,7 @@ fn approval_elicitation_meta_merges_session_and_always_persist_for_custom_server
|
|||
#[test]
|
||||
fn guardian_mcp_review_request_includes_invocation_metadata() {
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "browser_navigate".to_string(),
|
||||
arguments: Some(serde_json::json!({
|
||||
"url": "https://example.com",
|
||||
|
|
@ -778,7 +701,7 @@ fn guardian_mcp_review_request_includes_invocation_metadata() {
|
|||
request,
|
||||
GuardianApprovalRequest::McpToolCall {
|
||||
id: "call-1".to_string(),
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool_name: "browser_navigate".to_string(),
|
||||
arguments: Some(serde_json::json!({
|
||||
"url": "https://example.com",
|
||||
|
|
@ -808,7 +731,6 @@ fn guardian_mcp_review_request_includes_annotations_when_present() {
|
|||
tool_title: None,
|
||||
tool_description: None,
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -838,7 +760,7 @@ fn guardian_mcp_review_request_includes_annotations_when_present() {
|
|||
#[test]
|
||||
fn prepare_arc_request_action_serializes_mcp_tool_call_shape() {
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "browser_navigate".to_string(),
|
||||
arguments: Some(serde_json::json!({
|
||||
"url": "https://example.com",
|
||||
|
|
@ -860,7 +782,7 @@ fn prepare_arc_request_action_serializes_mcp_tool_call_shape() {
|
|||
action,
|
||||
serde_json::json!({
|
||||
"tool": "mcp_tool_call",
|
||||
"server": CODEX_APPS_MCP_SERVER_NAME,
|
||||
"server": "custom_server",
|
||||
"tool_name": "browser_navigate",
|
||||
"arguments": {
|
||||
"url": "https://example.com",
|
||||
|
|
@ -932,10 +854,10 @@ async fn guardian_review_decision_maps_to_mcp_tool_decision() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn approval_elicitation_meta_includes_connector_source_for_codex_apps() {
|
||||
fn approval_elicitation_meta_includes_tool_details_for_mcp_server() {
|
||||
assert_eq!(
|
||||
build_mcp_tool_approval_elicitation_meta(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"custom_server",
|
||||
Some(&approval_metadata(
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
|
|
@ -953,10 +875,6 @@ fn approval_elicitation_meta_includes_connector_source_for_codex_apps() {
|
|||
),
|
||||
Some(serde_json::json!({
|
||||
MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
|
||||
MCP_TOOL_APPROVAL_SOURCE_KEY: MCP_TOOL_APPROVAL_SOURCE_CONNECTOR,
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_ID_KEY: "calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY: "Calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_DESCRIPTION_KEY: "Manage events and schedules.",
|
||||
MCP_TOOL_APPROVAL_TOOL_TITLE_KEY: "Run Action",
|
||||
MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY: "Runs the selected action.",
|
||||
MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY: {
|
||||
|
|
@ -967,10 +885,10 @@ fn approval_elicitation_meta_includes_connector_source_for_codex_apps() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn approval_elicitation_meta_merges_session_and_always_persist_with_connector_source() {
|
||||
fn approval_elicitation_meta_merges_session_and_always_persist() {
|
||||
assert_eq!(
|
||||
build_mcp_tool_approval_elicitation_meta(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"custom_server",
|
||||
Some(&approval_metadata(
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
|
|
@ -992,10 +910,6 @@ fn approval_elicitation_meta_merges_session_and_always_persist_with_connector_so
|
|||
MCP_TOOL_APPROVAL_PERSIST_SESSION,
|
||||
MCP_TOOL_APPROVAL_PERSIST_ALWAYS,
|
||||
],
|
||||
MCP_TOOL_APPROVAL_SOURCE_KEY: MCP_TOOL_APPROVAL_SOURCE_CONNECTOR,
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_ID_KEY: "calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY: "Calendar",
|
||||
MCP_TOOL_APPROVAL_CONNECTOR_DESCRIPTION_KEY: "Manage events and schedules.",
|
||||
MCP_TOOL_APPROVAL_TOOL_TITLE_KEY: "Run Action",
|
||||
MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY: "Runs the selected action.",
|
||||
MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY: {
|
||||
|
|
@ -1102,45 +1016,6 @@ fn accepted_elicitation_without_content_defaults_to_accept() {
|
|||
assert_eq!(response, McpToolApprovalDecision::Accept);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn persist_codex_app_tool_approval_writes_tool_override() {
|
||||
let tmp = tempdir().expect("tempdir");
|
||||
|
||||
persist_codex_app_tool_approval(&tmp.path().abs(), "calendar", "calendar/list_events")
|
||||
.await
|
||||
.expect("persist approval");
|
||||
|
||||
let contents = std::fs::read_to_string(tmp.path().join(CONFIG_TOML_FILE)).expect("read config");
|
||||
let parsed: ConfigToml = toml::from_str(&contents).expect("parse config");
|
||||
|
||||
assert_eq!(
|
||||
parsed.apps,
|
||||
Some(AppsConfigToml {
|
||||
default: None,
|
||||
apps: HashMap::from([(
|
||||
"calendar".to_string(),
|
||||
AppConfig {
|
||||
enabled: true,
|
||||
destructive_enabled: None,
|
||||
open_world_enabled: None,
|
||||
default_tools_approval_mode: None,
|
||||
default_tools_enabled: None,
|
||||
tools: Some(AppToolsConfig {
|
||||
tools: HashMap::from([(
|
||||
"calendar/list_events".to_string(),
|
||||
AppToolConfig {
|
||||
enabled: None,
|
||||
approval_mode: Some(AppToolApproval::Approve),
|
||||
},
|
||||
)]),
|
||||
}),
|
||||
},
|
||||
)]),
|
||||
})
|
||||
);
|
||||
assert!(contents.contains("[apps.calendar.tools.\"calendar/list_events\"]"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn persist_custom_mcp_tool_approval_writes_tool_override() {
|
||||
let tmp = tempdir().expect("tempdir");
|
||||
|
|
@ -1213,45 +1088,6 @@ approval_mode = "prompt"
|
|||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn maybe_persist_mcp_tool_approval_reloads_session_config() {
|
||||
let (session, turn_context) = make_session_and_context().await;
|
||||
let codex_home = session.codex_home().await;
|
||||
std::fs::create_dir_all(&codex_home).expect("create codex home");
|
||||
let key = McpToolApprovalKey {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
connector_id: Some("calendar".to_string()),
|
||||
tool_name: "calendar/list_events".to_string(),
|
||||
};
|
||||
|
||||
maybe_persist_mcp_tool_approval(&session, &turn_context, key.clone()).await;
|
||||
|
||||
let config = session.get_config().await;
|
||||
let apps_toml = config
|
||||
.config_layer_stack
|
||||
.effective_config()
|
||||
.as_table()
|
||||
.and_then(|table| table.get("apps"))
|
||||
.cloned()
|
||||
.expect("apps table");
|
||||
let apps = AppsConfigToml::deserialize(apps_toml).expect("deserialize apps config");
|
||||
let tool = apps
|
||||
.apps
|
||||
.get("calendar")
|
||||
.and_then(|app| app.tools.as_ref())
|
||||
.and_then(|tools| tools.tools.get("calendar/list_events"))
|
||||
.expect("calendar/list_events tool config exists");
|
||||
|
||||
assert_eq!(
|
||||
tool,
|
||||
&AppToolConfig {
|
||||
enabled: None,
|
||||
approval_mode: Some(AppToolApproval::Approve),
|
||||
}
|
||||
);
|
||||
assert_eq!(mcp_tool_approval_is_remembered(&session, &key).await, true);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn maybe_persist_mcp_tool_approval_reloads_session_config_for_custom_server() {
|
||||
let (session, turn_context) = make_session_and_context().await;
|
||||
|
|
@ -1372,7 +1208,6 @@ async fn approve_mode_skips_when_annotations_do_not_require_approval() {
|
|||
tool_title: Some("Read Only Tool".to_string()),
|
||||
tool_description: None,
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1444,7 +1279,6 @@ async fn guardian_mode_skips_auto_when_annotations_do_not_require_approval() {
|
|||
tool_title: Some("Read Only Tool".to_string()),
|
||||
tool_description: None,
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1519,7 +1353,6 @@ async fn guardian_mode_mcp_denial_returns_rationale_message() {
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Reads calendar data.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1571,7 +1404,6 @@ async fn prompt_mode_waits_for_approval_when_annotations_do_not_require_approval
|
|||
tool_title: Some("Read Only Tool".to_string()),
|
||||
tool_description: None,
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1637,7 +1469,7 @@ async fn approve_mode_blocks_when_arc_returns_interrupt_for_model() {
|
|||
let session = Arc::new(session);
|
||||
let turn_context = Arc::new(turn_context);
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "dangerous_tool".to_string(),
|
||||
arguments: Some(serde_json::json!({ "id": 1 })),
|
||||
};
|
||||
|
|
@ -1649,7 +1481,6 @@ async fn approve_mode_blocks_when_arc_returns_interrupt_for_model() {
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Performs a risky action.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1720,7 +1551,6 @@ async fn custom_approve_mode_blocks_when_arc_returns_interrupt_for_model() {
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Performs a risky action.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1779,7 +1609,7 @@ async fn approve_mode_blocks_when_arc_returns_interrupt_without_annotations() {
|
|||
let session = Arc::new(session);
|
||||
let turn_context = Arc::new(turn_context);
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "dangerous_tool".to_string(),
|
||||
arguments: Some(serde_json::json!({ "id": 1 })),
|
||||
};
|
||||
|
|
@ -1791,7 +1621,6 @@ async fn approve_mode_blocks_when_arc_returns_interrupt_without_annotations() {
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Performs a risky action.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1858,7 +1687,7 @@ async fn full_access_mode_skips_arc_monitor_for_all_approval_modes() {
|
|||
let session = Arc::new(session);
|
||||
let turn_context = Arc::new(turn_context);
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "dangerous_tool".to_string(),
|
||||
arguments: Some(serde_json::json!({ "id": 1 })),
|
||||
};
|
||||
|
|
@ -1870,7 +1699,6 @@ async fn full_access_mode_skips_arc_monitor_for_all_approval_modes() {
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Performs a risky action.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
@ -1964,7 +1792,7 @@ async fn approve_mode_routes_arc_ask_user_to_guardian_when_guardian_reviewer_is_
|
|||
let session = Arc::new(session);
|
||||
let turn_context = Arc::new(turn_context);
|
||||
let invocation = McpInvocation {
|
||||
server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
|
||||
server: "custom_server".to_string(),
|
||||
tool: "dangerous_tool".to_string(),
|
||||
arguments: Some(serde_json::json!({ "id": 1 })),
|
||||
};
|
||||
|
|
@ -1976,7 +1804,6 @@ async fn approve_mode_routes_arc_ask_user_to_guardian_when_guardian_reviewer_is_
|
|||
tool_title: Some("Dangerous Tool".to_string()),
|
||||
tool_description: Some("Performs a risky action.".to_string()),
|
||||
mcp_app_resource_uri: None,
|
||||
codex_apps_meta: None,
|
||||
openai_file_input_params: None,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,14 +1,10 @@
|
|||
use std::collections::HashMap;
|
||||
use std::collections::HashSet;
|
||||
|
||||
use codex_features::Feature;
|
||||
use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
|
||||
use codex_mcp::ToolInfo as McpToolInfo;
|
||||
use codex_mcp::filter_non_codex_apps_mcp_tools_only;
|
||||
use codex_tools::ToolsConfig;
|
||||
|
||||
use crate::config::Config;
|
||||
use crate::connectors;
|
||||
|
||||
pub(crate) const DIRECT_MCP_TOOL_EXPOSURE_THRESHOLD: usize = 100;
|
||||
|
||||
|
|
@ -19,20 +15,10 @@ pub(crate) struct McpToolExposure {
|
|||
|
||||
pub(crate) fn build_mcp_tool_exposure(
|
||||
all_mcp_tools: &HashMap<String, McpToolInfo>,
|
||||
connectors: Option<&[connectors::AppInfo]>,
|
||||
explicitly_enabled_connectors: &[connectors::AppInfo],
|
||||
config: &Config,
|
||||
tools_config: &ToolsConfig,
|
||||
) -> McpToolExposure {
|
||||
let mut deferred_tools = filter_non_codex_apps_mcp_tools_only(all_mcp_tools);
|
||||
if let Some(connectors) = connectors {
|
||||
deferred_tools.extend(filter_codex_apps_mcp_tools(
|
||||
all_mcp_tools,
|
||||
connectors,
|
||||
config,
|
||||
));
|
||||
}
|
||||
|
||||
let deferred_tools = all_mcp_tools.clone();
|
||||
let should_defer = tools_config.search_tool
|
||||
&& (config
|
||||
.features
|
||||
|
|
@ -46,43 +32,12 @@ pub(crate) fn build_mcp_tool_exposure(
|
|||
};
|
||||
}
|
||||
|
||||
let direct_tools =
|
||||
filter_codex_apps_mcp_tools(all_mcp_tools, explicitly_enabled_connectors, config);
|
||||
for direct_tool_name in direct_tools.keys() {
|
||||
deferred_tools.remove(direct_tool_name);
|
||||
}
|
||||
|
||||
McpToolExposure {
|
||||
direct_tools,
|
||||
direct_tools: HashMap::new(),
|
||||
deferred_tools: (!deferred_tools.is_empty()).then_some(deferred_tools),
|
||||
}
|
||||
}
|
||||
|
||||
fn filter_codex_apps_mcp_tools(
|
||||
mcp_tools: &HashMap<String, McpToolInfo>,
|
||||
connectors: &[connectors::AppInfo],
|
||||
config: &Config,
|
||||
) -> HashMap<String, McpToolInfo> {
|
||||
let allowed: HashSet<&str> = connectors
|
||||
.iter()
|
||||
.map(|connector| connector.id.as_str())
|
||||
.collect();
|
||||
|
||||
mcp_tools
|
||||
.iter()
|
||||
.filter(|(_, tool)| {
|
||||
if tool.server_name != CODEX_APPS_MCP_SERVER_NAME {
|
||||
return false;
|
||||
}
|
||||
let Some(connector_id) = tool.connector_id.as_deref() else {
|
||||
return false;
|
||||
};
|
||||
allowed.contains(connector_id) && connectors::codex_app_tool_is_enabled(config, tool)
|
||||
})
|
||||
.map(|(name, tool)| (name.clone(), tool.clone()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "mcp_tool_exposure_test.rs"]
|
||||
mod tests;
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use codex_connectors::metadata::sanitize_name;
|
||||
use codex_features::Feature;
|
||||
use codex_features::Features;
|
||||
use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
|
||||
use codex_mcp::ToolInfo;
|
||||
use codex_models_manager::manager::ModelsManager;
|
||||
use codex_protocol::config_types::WebSearchMode;
|
||||
|
|
@ -19,45 +17,12 @@ use rmcp::model::Tool;
|
|||
|
||||
use super::*;
|
||||
use crate::config::test_config;
|
||||
use crate::connectors::AppInfo;
|
||||
|
||||
fn make_connector(id: &str, name: &str) -> AppInfo {
|
||||
AppInfo {
|
||||
id: id.to_string(),
|
||||
name: name.to_string(),
|
||||
description: None,
|
||||
logo_url: None,
|
||||
logo_url_dark: None,
|
||||
distribution_channel: None,
|
||||
branding: None,
|
||||
app_metadata: None,
|
||||
labels: None,
|
||||
install_url: None,
|
||||
is_accessible: true,
|
||||
is_enabled: true,
|
||||
plugin_display_names: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn make_mcp_tool(
|
||||
server_name: &str,
|
||||
tool_name: &str,
|
||||
connector_id: Option<&str>,
|
||||
connector_name: Option<&str>,
|
||||
) -> ToolInfo {
|
||||
let tool_namespace = if server_name == CODEX_APPS_MCP_SERVER_NAME {
|
||||
connector_name
|
||||
.map(sanitize_name)
|
||||
.map(|connector_name| format!("mcp__{server_name}__{connector_name}"))
|
||||
.unwrap_or_else(|| server_name.to_string())
|
||||
} else {
|
||||
format!("mcp__{server_name}__")
|
||||
};
|
||||
|
||||
fn make_mcp_tool(server_name: &str, tool_name: &str) -> ToolInfo {
|
||||
ToolInfo {
|
||||
server_name: server_name.to_string(),
|
||||
callable_name: tool_name.to_string(),
|
||||
callable_namespace: tool_namespace,
|
||||
callable_namespace: format!("mcp__{server_name}__"),
|
||||
server_instructions: None,
|
||||
tool: Tool {
|
||||
name: tool_name.to_string().into(),
|
||||
|
|
@ -70,8 +35,8 @@ fn make_mcp_tool(
|
|||
icons: None,
|
||||
meta: None,
|
||||
},
|
||||
connector_id: connector_id.map(str::to_string),
|
||||
connector_name: connector_name.map(str::to_string),
|
||||
connector_id: None,
|
||||
connector_name: None,
|
||||
plugin_display_names: Vec::new(),
|
||||
connector_description: None,
|
||||
}
|
||||
|
|
@ -83,9 +48,7 @@ fn numbered_mcp_tools(count: usize) -> HashMap<String, ToolInfo> {
|
|||
let tool_name = format!("tool_{index}");
|
||||
(
|
||||
format!("mcp__rmcp__{tool_name}"),
|
||||
make_mcp_tool(
|
||||
"rmcp", &tool_name, /*connector_id*/ None, /*connector_name*/ None,
|
||||
),
|
||||
make_mcp_tool("rmcp", &tool_name),
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
|
|
@ -114,18 +77,12 @@ async fn tools_config_for_mcp_tool_exposure(search_tool: bool) -> ToolsConfig {
|
|||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn directly_exposes_small_effective_tool_sets() {
|
||||
async fn directly_exposes_small_mcp_tool_sets() {
|
||||
let config = test_config().await;
|
||||
let tools_config = tools_config_for_mcp_tool_exposure(/*search_tool*/ true).await;
|
||||
let mcp_tools = numbered_mcp_tools(DIRECT_MCP_TOOL_EXPOSURE_THRESHOLD - 1);
|
||||
|
||||
let exposure = build_mcp_tool_exposure(
|
||||
&mcp_tools,
|
||||
/*connectors*/ None,
|
||||
&[],
|
||||
&config,
|
||||
&tools_config,
|
||||
);
|
||||
let exposure = build_mcp_tool_exposure(&mcp_tools, &config, &tools_config);
|
||||
|
||||
let mut direct_tool_names: Vec<_> = exposure.direct_tools.keys().cloned().collect();
|
||||
direct_tool_names.sort();
|
||||
|
|
@ -136,18 +93,12 @@ async fn directly_exposes_small_effective_tool_sets() {
|
|||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn searches_large_effective_tool_sets() {
|
||||
async fn searches_large_mcp_tool_sets() {
|
||||
let config = test_config().await;
|
||||
let tools_config = tools_config_for_mcp_tool_exposure(/*search_tool*/ true).await;
|
||||
let mcp_tools = numbered_mcp_tools(DIRECT_MCP_TOOL_EXPOSURE_THRESHOLD);
|
||||
|
||||
let exposure = build_mcp_tool_exposure(
|
||||
&mcp_tools,
|
||||
/*connectors*/ None,
|
||||
&[],
|
||||
&config,
|
||||
&tools_config,
|
||||
);
|
||||
let exposure = build_mcp_tool_exposure(&mcp_tools, &config, &tools_config);
|
||||
|
||||
assert!(exposure.direct_tools.is_empty());
|
||||
let deferred_tools = exposure
|
||||
|
|
@ -162,55 +113,7 @@ async fn searches_large_effective_tool_sets() {
|
|||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn directly_exposes_explicit_apps_without_deferred_overlap() {
|
||||
let config = test_config().await;
|
||||
let tools_config = tools_config_for_mcp_tool_exposure(/*search_tool*/ true).await;
|
||||
let mut mcp_tools = numbered_mcp_tools(DIRECT_MCP_TOOL_EXPOSURE_THRESHOLD - 1);
|
||||
mcp_tools.extend([(
|
||||
"mcp__codex_apps__calendar_create_event".to_string(),
|
||||
make_mcp_tool(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"calendar_create_event",
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
),
|
||||
)]);
|
||||
let connectors = vec![make_connector("calendar", "Calendar")];
|
||||
|
||||
let exposure = build_mcp_tool_exposure(
|
||||
&mcp_tools,
|
||||
Some(connectors.as_slice()),
|
||||
connectors.as_slice(),
|
||||
&config,
|
||||
&tools_config,
|
||||
);
|
||||
|
||||
let mut tool_names: Vec<String> = exposure.direct_tools.into_keys().collect();
|
||||
tool_names.sort();
|
||||
assert_eq!(
|
||||
tool_names,
|
||||
vec!["mcp__codex_apps__calendar_create_event".to_string()]
|
||||
);
|
||||
assert_eq!(
|
||||
exposure.deferred_tools.as_ref().map(HashMap::len),
|
||||
Some(DIRECT_MCP_TOOL_EXPOSURE_THRESHOLD - 1)
|
||||
);
|
||||
let deferred_tools = exposure
|
||||
.deferred_tools
|
||||
.as_ref()
|
||||
.expect("large tool sets should be discoverable through tool_search");
|
||||
assert!(
|
||||
tool_names
|
||||
.iter()
|
||||
.all(|direct_tool_name| !deferred_tools.contains_key(direct_tool_name)),
|
||||
"direct tools should not also be deferred: {tool_names:?}"
|
||||
);
|
||||
assert!(!deferred_tools.contains_key("mcp__codex_apps__calendar_create_event"));
|
||||
assert!(deferred_tools.contains_key("mcp__rmcp__tool_0"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn always_defer_feature_preserves_explicit_apps() {
|
||||
async fn always_defer_feature_defers_all_mcp_tools_uniformly() {
|
||||
let mut config = test_config().await;
|
||||
config
|
||||
.features
|
||||
|
|
@ -218,42 +121,21 @@ async fn always_defer_feature_preserves_explicit_apps() {
|
|||
.expect("test config should allow feature update");
|
||||
let tools_config = tools_config_for_mcp_tool_exposure(/*search_tool*/ true).await;
|
||||
let mcp_tools = HashMap::from([
|
||||
("mcp__rmcp__tool".to_string(), make_mcp_tool("rmcp", "tool")),
|
||||
(
|
||||
"mcp__rmcp__tool".to_string(),
|
||||
make_mcp_tool(
|
||||
"rmcp", "tool", /*connector_id*/ None, /*connector_name*/ None,
|
||||
),
|
||||
),
|
||||
(
|
||||
"mcp__codex_apps__calendar_create_event".to_string(),
|
||||
make_mcp_tool(
|
||||
CODEX_APPS_MCP_SERVER_NAME,
|
||||
"calendar_create_event",
|
||||
Some("calendar"),
|
||||
Some("Calendar"),
|
||||
),
|
||||
"mcp__custom__calendar_create_event".to_string(),
|
||||
make_mcp_tool("custom", "calendar_create_event"),
|
||||
),
|
||||
]);
|
||||
let connectors = vec![make_connector("calendar", "Calendar")];
|
||||
|
||||
let exposure = build_mcp_tool_exposure(
|
||||
&mcp_tools,
|
||||
Some(connectors.as_slice()),
|
||||
connectors.as_slice(),
|
||||
&config,
|
||||
&tools_config,
|
||||
);
|
||||
let exposure = build_mcp_tool_exposure(&mcp_tools, &config, &tools_config);
|
||||
|
||||
let mut direct_tool_names: Vec<String> = exposure.direct_tools.into_keys().collect();
|
||||
direct_tool_names.sort();
|
||||
assert_eq!(
|
||||
direct_tool_names,
|
||||
vec!["mcp__codex_apps__calendar_create_event".to_string()]
|
||||
);
|
||||
assert!(exposure.direct_tools.is_empty());
|
||||
let deferred_tools = exposure
|
||||
.deferred_tools
|
||||
.as_ref()
|
||||
.expect("MCP tools should be discoverable through tool_search");
|
||||
assert_eq!(deferred_tools.len(), 2);
|
||||
assert!(deferred_tools.contains_key("mcp__rmcp__tool"));
|
||||
assert!(!deferred_tools.contains_key("mcp__codex_apps__calendar_create_event"));
|
||||
assert!(deferred_tools.contains_key("mcp__custom__calendar_create_event"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -208,8 +208,6 @@ impl Session {
|
|||
mcp_servers: HashMap<String, McpServerConfig>,
|
||||
store_mode: OAuthCredentialsStoreMode,
|
||||
) {
|
||||
let auth = self.services.auth_manager.auth().await;
|
||||
let config = self.get_config().await;
|
||||
let auth_statuses = compute_auth_statuses(mcp_servers.iter(), store_mode).await;
|
||||
{
|
||||
let mut guard = self.services.mcp_startup_cancellation_token.lock().await;
|
||||
|
|
@ -231,8 +229,6 @@ impl Session {
|
|||
.unwrap_or_else(|| self.services.environment_manager.local_environment()),
|
||||
turn_context.cwd.to_path_buf(),
|
||||
),
|
||||
config.codex_home.to_path_buf(),
|
||||
codex_apps_tools_cache_key(auth.as_ref()),
|
||||
ToolPluginProvenance::default(),
|
||||
)
|
||||
.await;
|
||||
|
|
|
|||
|
|
@ -57,7 +57,6 @@ use codex_mcp::McpConnectionManager;
|
|||
use codex_mcp::McpRuntimeEnvironment;
|
||||
use codex_mcp::ToolInfo;
|
||||
use codex_mcp::ToolPluginProvenance;
|
||||
use codex_mcp::codex_apps_tools_cache_key;
|
||||
#[cfg(test)]
|
||||
use codex_models_manager::collaboration_mode_presets::CollaborationModesConfig;
|
||||
use codex_models_manager::manager::ModelsManager;
|
||||
|
|
|
|||
|
|
@ -850,8 +850,6 @@ impl Session {
|
|||
.unwrap_or_else(|| sess.services.environment_manager.local_environment()),
|
||||
session_configuration.cwd.to_path_buf(),
|
||||
),
|
||||
config.codex_home.to_path_buf(),
|
||||
codex_apps_tools_cache_key(auth),
|
||||
ToolPluginProvenance::default(),
|
||||
)
|
||||
.instrument(info_span!(
|
||||
|
|
|
|||
|
|
@ -868,8 +868,6 @@ pub(crate) async fn built_tools(
|
|||
drop(mcp_connection_manager);
|
||||
let mcp_tool_exposure = build_mcp_tool_exposure(
|
||||
&all_mcp_tools,
|
||||
None,
|
||||
&[],
|
||||
&turn_context.config,
|
||||
&turn_context.tools_config,
|
||||
);
|
||||
|
|
|
|||
Reference in a new issue