Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
127 KB
Raw Blame
use super::account::McpToolAccountError;
use super::*;
use crate::config::ConfigBuilder;
use crate::config::ManagedFeatures;
use crate::environment_selection::EnvironmentConfigOrigin;
use crate::environment_selection::TurnEnvironmentState;
use crate::session::step_context::StepContext;
use crate::session::tests::make_session_and_context;
use crate::session::tests::make_session_and_context_with_rx;
use crate::session::tests::mcp_config_for_test;
use crate::session::tests::test_environment_id;
use crate::session::tests::update_selected_settings_for_test;
use crate::session::tests::update_turn_settings_for_test;
use crate::session::turn_context::TurnEnvironment;
use crate::state::ActiveTurn;
use crate::test_support::models_manager_with_provider;
use crate::tools::hook_names::HookToolName;
use crate::turn_metadata::ExecutionMetadata;
use codex_app_server_protocol as app_server_protocol;
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_features::Features;
use codex_hooks::HooksConfig;
use codex_model_provider::create_model_provider;
use codex_protocol::ResponseItemId;
use codex_protocol::models::PermissionProfile;
use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EnvironmentConfig;
use codex_protocol::protocol::EnvironmentConfigState;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::GranularApprovalConfig;
use codex_protocol::protocol::InternalSessionSource;
use codex_protocol::protocol::McpInvocation;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::TurnEnvironmentSelection;
use codex_protocol::turn_input::ResponsesApiClientMetadataUpdate;
use codex_utils_path_uri::PathUri;
use core_test_support::hooks::trusted_config_layer_stack;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_response_created;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::sse;
use core_test_support::responses::start_mock_server;
use opentelemetry::trace::TracerProvider;
use opentelemetry_sdk::trace::InMemorySpanExporter;
use opentelemetry_sdk::trace::SdkTracerProvider;
use pretty_assertions::assert_eq;
use serde::Deserialize;
use std::collections::HashMap;
use std::sync::Arc;
use tempfile::tempdir;
use tracing::Instrument;
use tracing::Level;
use tracing_subscriber::fmt::format::FmtSpan;
use tracing_subscriber::prelude::*;
use tracing_test::internal::MockWriter;

fn annotations(
    read_only: Option<bool>,
    destructive: Option<bool>,
    open_world: Option<bool>,
) -> ToolAnnotations {
    ToolAnnotations::from_raw(
        /*title*/ None,
        read_only,
        destructive,
        /*idempotent_hint*/ None,
        open_world,
    )
}

fn approval_metadata(
    connector_id: Option<&str>,
    connector_name: Option<&str>,
    connector_description: Option<&str>,
    tool_title: Option<&str>,
    tool_description: Option<&str>,
) -> McpToolApprovalMetadata {
    McpToolApprovalMetadata {
        annotations: None,
        connector_id: connector_id.map(str::to_string),
        link_id: None,
        connector_name: connector_name.map(str::to_string),
        connector_description: connector_description.map(str::to_string),
        connected_account_email: None,
        plugin_id: None,
        tool_title: tool_title.map(str::to_string),
        tool_description: tool_description.map(str::to_string),
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    }
}

fn approval_config(turn_context: &TurnContext) -> codex_mcp::McpConfig {
    (*mcp_config_for_test(&turn_context.config)).clone()
}

#[test_case::test_case(false, None, Ok(Some("default_link")); "catalog_account")]
#[test_case::test_case(true, None, Err(McpToolAccountError::InvalidSelector); "required_selector_omitted")]
#[test_case::test_case(true, Some(serde_json::json!(null)), Err(McpToolAccountError::InvalidSelector); "null_selector")]
#[test_case::test_case(true, Some(serde_json::json!(42)), Err(McpToolAccountError::InvalidSelector); "invalid_selector")]
#[test_case::test_case(true, Some(serde_json::json!(" ")), Err(McpToolAccountError::InvalidSelector); "empty_selector")]
#[test_case::test_case(true, Some(serde_json::json!(" selected_link ")), Ok(Some(" selected_link ")); "opaque_selector")]
#[test_case::test_case(false, Some(serde_json::json!("selected_link")), Ok(Some("default_link")); "unrelated_link_argument")]
fn mcp_tool_metadata_resolves_advertised_account_selector(
    requires_explicit_link_id: bool,
    selected_link: Option<JsonValue>,
    expected: Result<Option<&str>, McpToolAccountError>,
) {
    let tool_info = serde_json::from_value(serde_json::json!({
        "server_name": CODEX_APPS_MCP_SERVER_NAME,
        "tool_name": "events/create",
        "tool_namespace": "calendar",
        "connector_id": "calendar",
        "tool": {
            "name": "calendar/events/create",
            "inputSchema": {},
            "_meta": {
                "link_id": "default_link",
                "_codex_apps": {
                    "requires_explicit_link_id": requires_explicit_link_id,
                },
            },
        },
    }))
    .expect("tool info");
    let arguments = selected_link.map(|link_id| serde_json::json!({ "link_id": link_id }));
    assert_eq!(
        mcp_tool_metadata(&tool_info, /*plugin_id*/ None, arguments.as_ref())
            .map(|metadata| metadata.link_id),
        expected.map(|link_id| link_id.map(str::to_owned)),
    );
}

#[test_case::test_case(None, Ok(None); "no_tool_metadata_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({})), Ok(None); "no_apps_metadata_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": {} })), Ok(None); "missing_selector_flag_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": { "requires_explicit_link_id": false } })), Ok(None); "false_selector_flag_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": { "requires_explicit_link_id": null } })), Ok(None); "null_selector_flag_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": { "requires_explicit_link_id": "true" } })), Ok(None); "string_true_does_not_require_selector")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": { "requires_explicit_link_id": 1 } })), Ok(None); "numeric_one_does_not_require_selector")]
#[test_case::test_case(Some(serde_json::json!({ "_codex_apps": [] })), Ok(None); "malformed_apps_metadata_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "link_id": null })), Ok(None); "null_catalog_link_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "link_id": 42, "_codex_apps": { "requires_explicit_link_id": false } })), Ok(None); "invalid_optional_catalog_link_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "link_id": " ", "_codex_apps": { "requires_explicit_link_id": false } })), Ok(None); "empty_optional_catalog_link_uses_legacy_fallback")]
#[test_case::test_case(Some(serde_json::json!({ "link_id": "default_link" })), Ok(Some("default_link")); "legacy_catalog_link_needs_no_selector_metadata")]
fn mcp_tool_metadata_preserves_legacy_account_fallback(
    meta: Option<JsonValue>,
    expected: Result<Option<&str>, McpToolAccountError>,
) {
    let mut tool = serde_json::json!({ "name": "calendar/events/create", "inputSchema": {} });
    if let Some(meta) = meta {
        tool["_meta"] = meta;
    }
    let tool_info = serde_json::from_value(serde_json::json!({
        "server_name": CODEX_APPS_MCP_SERVER_NAME,
        "tool_name": "events/create",
        "tool_namespace": "calendar",
        "connector_id": "calendar",
        "tool": tool,
    }))
    .expect("tool info");

    assert_eq!(
        mcp_tool_metadata(&tool_info, /*plugin_id*/ None, /*arguments*/ None)
            .map(|metadata| metadata.link_id),
        expected.map(|link_id| link_id.map(str::to_owned)),
    );
}

#[test_case::test_case(serde_json::json!({}); "no_account_metadata")]
#[test_case::test_case(serde_json::json!({ "_codex_apps": { "requires_explicit_link_id": true } }); "unrelated_apps_metadata")]
fn non_apps_tool_does_not_require_account_metadata(meta: JsonValue) {
    let tool_info = serde_json::from_value(serde_json::json!({
        "server_name": "custom_server",
        "tool_name": "events/create",
        "tool_namespace": "calendar",
        "tool": { "name": "calendar/events/create", "inputSchema": {}, "_meta": meta },
    }))
    .expect("tool info");

    assert_eq!(
        mcp_tool_metadata(&tool_info, /*plugin_id*/ None, /*arguments*/ None)
            .map(|metadata| metadata.link_id),
        Ok(None),
    );
}

fn mcp_turn_metadata_context(turn_context: &TurnContext) -> ExecutionMetadata<'_> {
    ExecutionMetadata {
        model: turn_context.model_info().slug.as_str(),
        reasoning_effort: turn_context.effective_reasoning_effort(),
        node_repl_disabled: turn_context.model_info().node_repl_disabled,
        auto_review_enabled: crate::guardian::routes_approval_policy_to_guardian(
            turn_context.approval_policy(),
            turn_context.config.approvals_reviewer,
        ),
        node_repl_auto_review_required: turn_context.model_info().node_repl_auto_review_required,
    }
}

fn expected_mcp_turn_metadata(turn_context: &TurnContext) -> serde_json::Value {
    turn_context
        .turn_metadata_state
        .current_meta_value_for_mcp_request(mcp_turn_metadata_context(turn_context))
        .expect("turn metadata")
}

fn write_sample_plugin_mcp(codex_home: &std::path::Path) {
    let plugin_root = codex_home.join("plugins/cache/test/sample/local");
    std::fs::create_dir_all(plugin_root.join(".codex-plugin")).expect("create plugin manifest dir");
    std::fs::write(
        plugin_root.join(".codex-plugin/plugin.json"),
        r#"{
  "name": "sample"
}"#,
    )
    .expect("write plugin manifest");
    std::fs::write(
        plugin_root.join(".mcp.json"),
        r#"{
  "mcpServers": {
    "sample": {
      "type": "http",
      "url": "https://sample.example/mcp"
    }
  }
}"#,
    )
    .expect("write plugin mcp config");
}

fn prompt_options(
    allow_session_remember: bool,
    allow_persistent_approval: bool,
) -> McpToolApprovalPromptOptions {
    McpToolApprovalPromptOptions {
        allow_session_remember,
        allow_persistent_approval,
    }
}

fn install_mcp_permission_request_hook(
    session: &mut Session,
    turn_context: &TurnContext,
    matcher: &str,
    hook_output: &serde_json::Value,
) -> std::path::PathBuf {
    let script_path = turn_context
        .config
        .codex_home
        .join("mcp_permission_request_hook.py");
    let log_path = turn_context
        .config
        .codex_home
        .join("mcp_permission_request_hook_log.jsonl");
    let hook_output = hook_output.to_string();
    std::fs::create_dir_all(&turn_context.config.codex_home)
        .expect("create codex home for MCP permission hook");
    let script = format!(
        r#"import json
from pathlib import Path
import sys

payload = json.load(sys.stdin)
with Path(r"{log_path}").open("a", encoding="utf-8") as handle:
    handle.write(json.dumps(payload) + "\n")

print({hook_output:?})
"#,
        log_path = log_path.display(),
        hook_output = hook_output,
    );

    std::fs::write(&script_path, script).expect("write MCP permission hook script");
    let python = if cfg!(windows) { "python" } else { "python3" };
    let script_path_arg = if cfg!(windows) {
        script_path.display().to_string()
    } else {
        format!(
            "'{}'",
            script_path.display().to_string().replace('\'', "'\\''")
        )
    };
    std::fs::write(
        turn_context.config.codex_home.join("hooks.json"),
        serde_json::json!({
            "hooks": {
                "PermissionRequest": [{
                    "matcher": matcher,
                    "hooks": [{
                        "type": "command",
                        "command": format!("{python} {script_path_arg}"),
                        "timeout_sec": 5,
                    }]
                }]
            }
        })
        .to_string(),
    )
    .expect("write hooks.json");
    let hook_list = codex_hooks::list_hooks(HooksConfig {
        feature_enabled: true,
        config_layer_stack: Some(turn_context.config.config_layer_stack.clone()),
        ..HooksConfig::default()
    });
    assert_eq!(hook_list.hooks.len(), 1);
    let trusted_config_layer_stack = trusted_config_layer_stack(
        &turn_context.config.config_layer_stack,
        &turn_context.config.codex_home,
        hook_list.hooks,
    );

    let hooks = session.hooks().reconfigured(HooksConfig {
        feature_enabled: true,
        config_layer_stack: Some(trusted_config_layer_stack),
        shell_program: (!cfg!(windows)).then_some("/bin/sh".to_string()),
        shell_args: if cfg!(windows) {
            Vec::new()
        } else {
            vec!["-c".to_string()]
        },
        ..HooksConfig::default()
    });
    session.services.hooks.store(Arc::new(hooks));

    log_path.to_path_buf()
}

#[test]
fn mcp_app_resource_uri_reads_known_tool_meta_keys() {
    let nested = serde_json::json!({
        "ui": {
            "resourceUri": "ui://widget/nested.html",
        },
    });
    assert_eq!(
        get_mcp_app_resource_uri(nested.as_object()),
        Some("ui://widget/nested.html".to_string())
    );

    let flat = serde_json::json!({
        "ui/resourceUri": "ui://widget/flat.html",
    });
    assert_eq!(
        get_mcp_app_resource_uri(flat.as_object()),
        Some("ui://widget/flat.html".to_string())
    );

    let output_template = serde_json::json!({
        "openai/outputTemplate": "ui://widget/output-template.html",
    });
    assert_eq!(
        get_mcp_app_resource_uri(output_template.as_object()),
        Some("ui://widget/output-template.html".to_string())
    );
}

#[test]
fn openai_file_params_are_only_honored_for_codex_apps() {
    let params = HashMap::from([("file".to_string(), Vec::new())]);

    assert_eq!(
        openai_file_input_optional_fields_for_server(CODEX_APPS_MCP_SERVER_NAME, &params),
        Some(params.clone())
    );
    assert_eq!(
        openai_file_input_optional_fields_for_server("minimaltest", &params),
        None
    );
}

#[test]
fn approval_required_when_read_only_false_and_destructive() {
    let annotations = annotations(Some(false), Some(true), /*open_world*/ None);
    assert_eq!(requires_mcp_tool_approval(Some(&annotations)), true);
}

#[test]
fn approval_required_when_read_only_false_and_open_world() {
    let annotations = annotations(Some(false), /*destructive*/ None, Some(true));
    assert_eq!(requires_mcp_tool_approval(Some(&annotations)), true);
}

#[test]
fn approval_required_when_destructive_even_if_read_only_true() {
    let annotations = annotations(Some(true), Some(true), Some(true));
    assert_eq!(requires_mcp_tool_approval(Some(&annotations)), true);
}

#[test]
fn approval_required_when_annotations_are_absent() {
    assert_eq!(requires_mcp_tool_approval(/*annotations*/ None), true);
}

#[test]
fn approval_not_required_when_read_only_and_other_hints_are_absent() {
    let annotations = annotations(
        Some(true),
        /*destructive*/ None,
        /*open_world*/ None,
    );
    assert_eq!(requires_mcp_tool_approval(Some(&annotations)), false);
}

#[test]
fn writes_mode_requires_approval_for_non_read_only_tools() {
    let annotations = annotations(Some(false), Some(false), Some(false));
    assert_eq!(
        requires_mcp_tool_approval_for_mode(Some(&annotations), AppToolApproval::Writes),
        true
    );
    assert_eq!(
        requires_mcp_tool_approval_for_mode(/*annotations*/ None, AppToolApproval::Writes),
        true
    );
}

#[test]
fn writes_mode_does_not_require_approval_for_read_only_tools() {
    let annotations = annotations(Some(true), Some(true), Some(true));
    assert_eq!(
        requires_mcp_tool_approval_for_mode(Some(&annotations), AppToolApproval::Writes),
        false
    );
}

#[test]
fn prompting_modes_do_not_allow_persistent_remember() {
    for approval_mode in [AppToolApproval::Prompt, AppToolApproval::Writes] {
        assert_eq!(
            normalize_approval_decision_for_mode(ReviewDecision::ApprovedForSession, approval_mode,),
            ReviewDecision::Approved
        );
        assert_eq!(
            normalize_approval_decision_for_mode(
                ReviewDecision::ApprovedMcpPolicyAmendment,
                approval_mode,
            ),
            ReviewDecision::Approved
        );
    }
}

#[tokio::test]
async fn mcp_tool_call_span_records_expected_fields() {
    let buffer: &'static std::sync::Mutex<Vec<u8>> =
        Box::leak(Box::new(std::sync::Mutex::new(Vec::new())));
    let subscriber = tracing_subscriber::fmt()
        .with_level(true)
        .with_ansi(false)
        .with_max_level(Level::TRACE)
        .with_span_events(FmtSpan::FULL)
        .with_writer(MockWriter::new(buffer))
        .finish();
    let _guard = tracing::subscriber::set_default(subscriber);

    let (session, turn_context) = make_session_and_context().await;

    async {}
        .instrument(mcp_tool_call_span(
            &session,
            &turn_context,
            McpToolCallSpanFields {
                server_name: "rmcp",
                tool_name: "echo",
                call_id: "call-123",
                server_origin: Some("https://example.com:8443/mcp"),
                connector_id: Some("calendar"),
                connector_name: Some("Calendar"),
            },
        ))
        .await;

    let logs = String::from_utf8(buffer.lock().expect("buffer lock").clone()).expect("utf8 logs");
    assert!(
        logs.contains("mcp.tools.call{otel.kind=\"client\"")
            && logs.contains("rpc.system=\"jsonrpc\"")
            && logs.contains("rpc.method=\"tools/call\"")
            && logs.contains("mcp.server.name=\"rmcp\"")
            && logs.contains("mcp.server.origin=\"https://example.com:8443/mcp\"")
            && logs.contains("mcp.transport=\"streamable_http\"")
            && logs.contains("mcp.connector.id=\"calendar\"")
            && logs.contains("mcp.connector.name=\"Calendar\"")
            && logs.contains("tool.name=\"echo\"")
            && logs.contains("tool.call_id=\"call-123\"")
            && logs.contains("server.address=\"example.com\"")
            && logs.contains("server.port=8443")
            && logs.contains("conversation.id=")
            && logs.contains("session.id=")
            && logs.contains("turn.id="),
        "missing MCP tool span fields\nlogs:\n{logs}"
    );
}

#[test_case::test_case(Some("RATE_LIMITED"), None, None, "RATE_LIMITED"; "structured error")]
#[test_case::test_case(None, Some("credential-sentinel"), None, "unknown"; "sensitive metadata")]
#[test_case::test_case(None, None, Some("transport_closed"), "transport_closed"; "closed transport")]
#[tokio::test]
async fn mcp_tool_call_span_records_error_type_and_error_code(
    structured_code: Option<&str>,
    metadata_code: Option<&str>,
    request_error_code: Option<&str>,
    expected_code: &str,
) {
    let exporter = InMemorySpanExporter::default();
    let provider = SdkTracerProvider::builder()
        .with_simple_exporter(exporter.clone())
        .build();
    let subscriber = tracing_subscriber::registry()
        .with(tracing_opentelemetry::layer().with_tracer(provider.tracer("mcp-error-test")));
    let _guard = tracing::subscriber::set_default(subscriber);

    let (session, turn_context) = make_session_and_context().await;
    let result = Ok(CallToolResult {
        content: Vec::new(),
        structured_content: structured_code.map(|code| serde_json::json!({"error_code": code})),
        is_error: Some(true),
        meta: metadata_code.map(|code| {
            serde_json::json!({
                "codex/telemetry": {"error_code": code},
            })
        }),
    });
    let result = if request_error_code.is_some() {
        Err("request failed".to_string())
    } else {
        result
    };
    let span = mcp_tool_call_span(
        &session,
        &turn_context,
        McpToolCallSpanFields {
            server_name: CODEX_APPS_MCP_SERVER_NAME,
            tool_name: "calendar_search",
            call_id: "call-123",
            server_origin: Some("https://chatgpt.com/api/codex/ps/mcp"),
            connector_id: Some("calendar"),
            connector_name: Some("Calendar"),
        },
    );

    async {
        record_mcp_result_span_telemetry(&Span::current(), &result, request_error_code);
    }
    .instrument(span)
    .await;

    provider.force_flush().expect("flush spans");
    let spans = exporter.get_finished_spans().expect("exported spans");
    let span = spans
        .iter()
        .find(|span| span.name == "mcp.tools.call")
        .expect("MCP tool span");
    let error_codes = span
        .attributes
        .iter()
        .filter(|attribute| attribute.key.as_str() == "codex.mcp.error.code")
        .map(|attribute| attribute.value.to_string())
        .collect::<Vec<_>>();
    assert_eq!(error_codes, vec![expected_code.to_string()]);
    let error_types = span
        .attributes
        .iter()
        .filter(|attribute| attribute.key.as_str() == "error.type")
        .map(|attribute| attribute.value.to_string())
        .collect::<Vec<_>>();
    assert_eq!(
        error_types,
        vec![if request_error_code.is_some() {
            "mcp_request".to_string()
        } else {
            "tool_result".to_string()
        }]
    );
    assert!(
        span.attributes
            .iter()
            .all(|attribute| !attribute.value.to_string().contains("credential-sentinel"))
    );
}

async fn mcp_result_telemetry_span_logs(meta: Option<serde_json::Value>) -> String {
    let buffer: &'static std::sync::Mutex<Vec<u8>> =
        Box::leak(Box::new(std::sync::Mutex::new(Vec::new())));
    let subscriber = tracing_subscriber::fmt()
        .with_level(true)
        .with_ansi(false)
        .with_max_level(Level::TRACE)
        .with_span_events(FmtSpan::FULL)
        .with_writer(MockWriter::new(buffer))
        .finish();
    let _guard = tracing::subscriber::set_default(subscriber);

    let (session, turn_context) = make_session_and_context().await;
    let result = Ok(CallToolResult {
        content: Vec::new(),
        structured_content: None,
        is_error: None,
        meta,
    });

    {
        let span = mcp_tool_call_span(
            &session,
            &turn_context,
            McpToolCallSpanFields {
                server_name: "rmcp",
                tool_name: "echo",
                call_id: "call-123",
                server_origin: None,
                connector_id: None,
                connector_name: None,
            },
        );

        async {
            record_mcp_result_span_telemetry(
                &Span::current(),
                &result,
                /*request_error_code*/ None,
            );
        }
        .instrument(span)
        .await;
    }

    String::from_utf8(buffer.lock().expect("buffer lock").clone()).expect("utf8 logs")
}

#[tokio::test]
async fn mcp_result_telemetry_records_allowlisted_span_fields() {
    let logs = mcp_result_telemetry_span_logs(Some(serde_json::json!({
        "codex/telemetry": {
            "span": {
                "target_id": "com.apple.reminders",
                "did_trigger_server_user_flow": false,
                "not_promoted_sentinel_key": "not_promoted_sentinel_value",
            },
        },
    })))
    .await;

    assert!(
        logs.contains("codex.mcp.target.id=\"com.apple.reminders\"")
            && logs.contains("codex.mcp.server_user_flow.triggered=false"),
        "missing MCP result telemetry span fields\nlogs:\n{logs}"
    );
    assert!(
        !logs.contains("not_promoted_sentinel_key")
            && !logs.contains("not_promoted_sentinel_value"),
        "unknown MCP result telemetry keys should be ignored\nlogs:\n{logs}"
    );
}

#[tokio::test]
async fn mcp_result_telemetry_ignores_invalid_and_missing_values() {
    let invalid_logs = mcp_result_telemetry_span_logs(Some(serde_json::json!({
        "codex/telemetry": {
            "span": {
                "target_id": 123,
                "did_trigger_server_user_flow": "false",
            },
        },
    })))
    .await;
    assert!(
        !invalid_logs.contains("codex.mcp.target.id=")
            && !invalid_logs.contains("codex.mcp.server_user_flow.triggered="),
        "invalid MCP result telemetry values should be ignored\nlogs:\n{invalid_logs}"
    );

    let missing_logs = mcp_result_telemetry_span_logs(Some(serde_json::json!({
        "codex/telemetry": {},
    })))
    .await;
    assert!(
        !missing_logs.contains("codex.mcp.target.id=")
            && !missing_logs.contains("codex.mcp.server_user_flow.triggered="),
        "missing MCP result telemetry span object should be ignored\nlogs:\n{missing_logs}"
    );

    let no_meta_logs = mcp_result_telemetry_span_logs(/*meta*/ None).await;
    assert!(
        !no_meta_logs.contains("codex.mcp.target.id=")
            && !no_meta_logs.contains("codex.mcp.server_user_flow.triggered="),
        "missing MCP result metadata should be ignored\nlogs:\n{no_meta_logs}"
    );
}

#[tokio::test]
async fn mcp_result_telemetry_truncates_long_target_id() {
    let truncated = "x".repeat(MCP_RESULT_TELEMETRY_TARGET_ID_MAX_CHARS);
    let target_id = format!("{truncated}tail");
    let logs = mcp_result_telemetry_span_logs(Some(serde_json::json!({
        "codex/telemetry": {
            "span": {
                "target_id": target_id,
            },
        },
    })))
    .await;

    assert!(
        logs.contains(&format!("codex.mcp.target.id=\"{truncated}\"")) && !logs.contains("tail"),
        "long MCP result telemetry target_id should be truncated\nlogs:\n{logs}"
    );
}

#[test]
fn truncates_strings_on_char_boundaries() {
    let prefix = "á".repeat(MCP_RESULT_TELEMETRY_TARGET_ID_MAX_CHARS);
    let value = format!("{prefix}tail");
    let truncated = truncate_str_to_char_boundary(&value, MCP_RESULT_TELEMETRY_TARGET_ID_MAX_CHARS);

    assert_eq!(truncated, prefix);
    assert_eq!(
        truncate_str_to_char_boundary("short", MCP_RESULT_TELEMETRY_TARGET_ID_MAX_CHARS),
        "short"
    );
}

#[test]
fn approval_elicitation_request_uses_message_override_and_preserves_tool_params_keys() {
    let question = build_mcp_tool_approval_question(
        "q".to_string(),
        CODEX_APPS_MCP_SERVER_NAME,
        "create_event",
        Some("Calendar"),
        prompt_options(
            /*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
        ),
        Some("Allow Calendar to create an event?"),
    );

    let request = build_mcp_tool_approval_elicitation_request(McpToolApprovalElicitationRequest {
        server: CODEX_APPS_MCP_SERVER_NAME,
        metadata: Some(&approval_metadata(
            Some("calendar"),
            Some("Calendar"),
            Some("Manage events and schedules."),
            Some("Create Event"),
            Some("Create a calendar event."),
        )),
        tool_params: Some(&serde_json::json!({
            "calendar_id": "primary",
            "title": "Roadmap review",
        })),
        tool_params_display: Some(&[
            RenderedMcpToolApprovalParam {
                name: "calendar_id".to_string(),
                value: serde_json::json!("primary"),
                display_name: "Calendar".to_string(),
            },
            RenderedMcpToolApprovalParam {
                name: "title".to_string(),
                value: serde_json::json!("Roadmap review"),
                display_name: "Title".to_string(),
            },
        ]),
        question,
        message_override: Some("Allow Calendar to create an event?"),
        prompt_options: prompt_options(
            /*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
        ),
    });

    assert_eq!(
        request,
        ElicitationRequest::Form {
            meta: Some(serde_json::json!({
                MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
                MCP_TOOL_APPROVAL_PERSIST_KEY: [
                    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: {
                    "calendar_id": "primary",
                    "title": "Roadmap review",
                },
                MCP_TOOL_APPROVAL_TOOL_PARAMS_DISPLAY_KEY: [
                    {
                        "name": "calendar_id",
                        "value": "primary",
                        "display_name": "Calendar",
                    },
                    {
                        "name": "title",
                        "value": "Roadmap review",
                        "display_name": "Title",
                    },
                ],
            })),
            message: "Allow Calendar to create an event?".to_string(),
            requested_schema: serde_json::json!({
                "type": "object",
                "properties": {},
            }),
        }
    );
}

#[test]
fn custom_mcp_tool_question_mentions_server_name() {
    let question = build_mcp_tool_approval_question(
        "q".to_string(),
        "custom_server",
        "run_action",
        /*connector_name*/ None,
        prompt_options(
            /*allow_session_remember*/ false, /*allow_persistent_approval*/ false,
        ),
        /*question_override*/ None,
    );

    assert_eq!(question.header, "Approve app tool call?");
    assert_eq!(
        question.question,
        "Allow the custom_server MCP server to run tool \"run_action\"?"
    );
    assert!(
        !question
            .options
            .expect("options")
            .into_iter()
            .map(|option| option.label)
            .any(|label| label == MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER)
    );
}

#[test]
fn codex_apps_tool_question_uses_fallback_app_label() {
    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,
        "run_action",
        Some("Calendar"),
        prompt_options(
            /*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
        ),
        /*question_override*/ None,
    );
    let options = question.options.expect("options");

    assert!(options.iter().any(|option| {
        option.label == MCP_TOOL_APPROVAL_ACCEPT_FOR_SESSION
            && option.description == "Run the tool and remember this choice for this session."
    }));
    assert!(options.iter().any(|option| {
        option.label == MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER
            && option.description == "Run the tool and remember this choice for future tool calls."
    }));
    assert_eq!(
        options
            .into_iter()
            .map(|option| option.label)
            .collect::<Vec<_>>(),
        vec![
            MCP_TOOL_APPROVAL_ACCEPT.to_string(),
            MCP_TOOL_APPROVAL_ACCEPT_FOR_SESSION.to_string(),
            MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER.to_string(),
            MCP_TOOL_APPROVAL_CANCEL.to_string(),
        ]
    );
}

#[test]
fn codex_apps_tool_question_without_elicitation_omits_always_allow() {
    let question = build_mcp_tool_approval_question(
        "q".to_string(),
        CODEX_APPS_MCP_SERVER_NAME,
        "run_action",
        Some("Calendar"),
        mcp_tool_approval_prompt_options(
            /*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
            /*tool_call_mcp_elicitation_enabled*/ false,
        ),
        /*question_override*/ None,
    );

    assert_eq!(
        question
            .options
            .expect("options")
            .into_iter()
            .map(|option| option.label)
            .collect::<Vec<_>>(),
        vec![
            MCP_TOOL_APPROVAL_ACCEPT.to_string(),
            MCP_TOOL_APPROVAL_ACCEPT_FOR_SESSION.to_string(),
            MCP_TOOL_APPROVAL_CANCEL.to_string(),
        ]
    );
}

#[test]
fn custom_mcp_tool_question_offers_session_remember_and_always_allow() {
    let question = build_mcp_tool_approval_question(
        "q".to_string(),
        "custom_server",
        "run_action",
        /*connector_name*/ None,
        prompt_options(
            /*allow_session_remember*/ true, /*allow_persistent_approval*/ true,
        ),
        /*question_override*/ None,
    );

    assert_eq!(
        question
            .options
            .expect("options")
            .into_iter()
            .map(|option| option.label)
            .collect::<Vec<_>>(),
        vec![
            MCP_TOOL_APPROVAL_ACCEPT.to_string(),
            MCP_TOOL_APPROVAL_ACCEPT_FOR_SESSION.to_string(),
            MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER.to_string(),
            MCP_TOOL_APPROVAL_CANCEL.to_string(),
        ]
    );
}

#[test]
fn custom_servers_support_session_and_persistent_approval() {
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "run_action".to_string(),
        arguments: None,
    };
    let expected = McpToolApprovalKey {
        server: "custom_server".to_string(),
        plugin_id: None,
        connector_id: None,
        link_id: None,
        tool_name: "run_action".to_string(),
    };

    assert_eq!(
        session_mcp_tool_approval_key(&invocation, /*metadata*/ None, AppToolApproval::Auto),
        Some(expected.clone())
    );
    assert_eq!(
        persistent_mcp_tool_approval_key(
            &invocation,
            /*metadata*/ None,
            AppToolApproval::Auto
        ),
        Some(expected.clone())
    );
    let mut metadata = approval_metadata(
        /*connector_id*/ None, /*connector_name*/ None,
        /*connector_description*/ None, /*tool_title*/ None,
        /*tool_description*/ None,
    );
    for plugin_id in ["alpha@test", "beta@test"] {
        metadata.plugin_id = Some(plugin_id.to_string());
        let plugin_key = McpToolApprovalKey {
            plugin_id: Some(plugin_id.to_string()),
            ..expected.clone()
        };
        assert_eq!(
            session_mcp_tool_approval_key(&invocation, Some(&metadata), AppToolApproval::Auto),
            Some(plugin_key)
        );
    }
}

#[test]
fn codex_apps_connectors_support_persistent_approval() {
    let invocation = McpInvocation {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        tool: "calendar/list_events".to_string(),
        arguments: None,
    };
    let mut metadata = approval_metadata(
        Some("calendar"),
        Some("Calendar"),
        /*connector_description*/ None,
        /*tool_title*/ None,
        /*tool_description*/ None,
    );
    metadata.link_id = Some("link_a".to_string());
    let expected = McpToolApprovalKey {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        plugin_id: None,
        connector_id: Some("calendar".to_string()),
        link_id: Some("link_a".to_string()),
        tool_name: "calendar/list_events".to_string(),
    };

    assert_eq!(
        session_mcp_tool_approval_key(&invocation, Some(&metadata), AppToolApproval::Auto),
        Some(expected.clone())
    );
    assert_eq!(
        persistent_mcp_tool_approval_key(&invocation, Some(&metadata), AppToolApproval::Auto),
        Some(expected)
    );
}

#[test]
fn sanitize_mcp_tool_result_for_model_rewrites_unsupported_media_content() {
    let result = Ok(CallToolResult {
        content: vec![
            serde_json::json!({
                "type": "image",
                "data": "Zm9v",
                "mimeType": "image/png",
            }),
            serde_json::json!({
                "type": "audio",
                "data": "YmFy",
                "mimeType": "audio/wav",
            }),
            serde_json::json!({
                "type": "text",
                "text": "hello",
            }),
        ],
        structured_content: None,
        is_error: Some(false),
        meta: None,
    });

    let got = sanitize_mcp_tool_result_for_model(&[InputModality::Text], result)
        .expect("sanitized result");

    assert_eq!(
        got,
        CallToolResult {
            content: vec![
                serde_json::json!({
                    "type": "text",
                    "text": "<image content omitted because you do not support image input>",
                }),
                serde_json::json!({
                    "type": "text",
                    "text": "<audio content omitted because you do not support audio input>",
                }),
                serde_json::json!({
                    "type": "text",
                    "text": "hello",
                }),
            ],
            structured_content: None,
            is_error: Some(false),
            meta: None,
        }
    );
}

#[test]
fn sanitize_mcp_tool_result_for_model_preserves_supported_media() {
    let original = CallToolResult {
        content: vec![
            serde_json::json!({
                "type": "image",
                "data": "Zm9v",
                "mimeType": "image/png",
            }),
            serde_json::json!({
                "type": "audio",
                "data": "YmFy",
                "mimeType": "audio/wav",
            }),
        ],
        structured_content: Some(serde_json::json!({"x": 1})),
        is_error: Some(false),
        meta: Some(serde_json::json!({"k": "v"})),
    };

    let got = sanitize_mcp_tool_result_for_model(
        &[
            InputModality::Text,
            InputModality::Image,
            InputModality::Audio,
        ],
        Ok(original.clone()),
    )
    .expect("unsanitized result");

    assert_eq!(got, original);
}

#[test]
fn truncate_mcp_tool_result_for_event_bounds_large_error() {
    let got = truncate_mcp_tool_result_for_event(&Err("error-message-".repeat(200_000)))
        .expect_err("large error should remain an error");

    // `truncate_text` includes its own marker, so allow a small amount of
    // overhead beyond the requested byte budget.
    assert!(got.len() < MCP_TOOL_CALL_EVENT_RESULT_MAX_BYTES + 1024);
    assert!(got.contains("truncated"));
}

#[tokio::test]
async fn mcp_tool_call_request_meta_includes_turn_metadata_for_custom_server() {
    let (_, turn_context) = make_session_and_context().await;
    let turn_context = Arc::new(turn_context);
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    let client_metadata = HashMap::from([
        (
            "node_repl_auto_review_required".to_string(),
            "true".to_string(),
        ),
        ("node_repl_disabled".to_string(), "true".to_string()),
    ]);
    turn_context
        .turn_metadata_state
        .update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
            replacement: Some(client_metadata),
            ..Default::default()
        });
    let expected_turn_metadata = expected_mcp_turn_metadata(&turn_context);

    let meta = build_mcp_tool_call_request_meta(
        &step_context,
        "custom_server",
        "call-custom",
        /*metadata*/ None,
        /*is_host_owned_apps*/ false,
    )
    .expect("custom servers should receive turn metadata");
    let turn_metadata = meta
        .get(crate::X_CODEX_TURN_METADATA_HEADER)
        .expect("turn metadata should be present");

    assert_eq!(
        turn_metadata
            .get("model")
            .and_then(serde_json::Value::as_str),
        Some(step_context.settings.model_info.slug.as_str())
    );
    assert_eq!(
        turn_metadata["node_repl_auto_review_required"],
        serde_json::Value::Bool(
            step_context
                .settings
                .model_info
                .node_repl_auto_review_required
        ),
    );
    assert_eq!(
        turn_metadata["node_repl_disabled"],
        serde_json::Value::Bool(step_context.settings.model_info.node_repl_disabled),
    );
    assert_eq!(
        turn_metadata
            .get("reasoning_effort")
            .and_then(serde_json::Value::as_str),
        step_context
            .settings
            .effective_reasoning_effort()
            .map(|effort| effort.to_string())
            .as_deref()
    );

    assert_eq!(
        meta,
        serde_json::json!({
            "callId": "call-custom",
            crate::X_CODEX_TURN_METADATA_HEADER: expected_turn_metadata,
        })
    );
}

#[test_case::test_case(Some(ReasoningEffortConfig::Low), "low"; "configured effort")]
#[test_case::test_case(None, "high"; "pinned model default")]
#[tokio::test]
async fn mcp_tool_call_request_meta_uses_the_issuing_step(
    effort: Option<ReasoningEffortConfig>,
    expected_effort: &str,
) {
    let (_, turn_context) = make_session_and_context().await;
    let turn_context = Arc::new(turn_context);
    let step_a = StepContext::for_test(Arc::clone(&turn_context));
    let original_meta = build_mcp_tool_call_request_meta(
        &step_a,
        "node_repl",
        "call-a",
        /*metadata*/ None,
        /*is_host_owned_apps*/ false,
    );
    let mut step_b = StepContext::for_test(Arc::clone(&turn_context));
    let settings = Arc::make_mut(&mut Arc::get_mut(&mut step_b).expect("unique step").settings);
    update_selected_settings_for_test(settings, |selected| {
        selected.collaboration_mode = selected.collaboration_mode.with_updates(
            Some("model-b".to_string()),
            Some(effort),
            /*developer_instructions*/ None,
        );
    });
    let model = Arc::make_mut(&mut settings.model_info);
    model.slug = "model-b".to_string();
    model.default_reasoning_level = Some(ReasoningEffortConfig::High);
    model.node_repl_disabled = true;
    // Node review requirements are captured with the issuing step.
    model.node_repl_auto_review_required =
        !turn_context.model_info().node_repl_auto_review_required;

    let mut expected = expected_mcp_turn_metadata(&turn_context);
    expected["model"] = serde_json::json!("model-b");
    expected["reasoning_effort"] = serde_json::json!(expected_effort);
    expected["node_repl_disabled"] = serde_json::json!(true);
    expected["node_repl_auto_review_required"] =
        serde_json::json!(step_b.settings.model_info.node_repl_auto_review_required);
    assert_eq!(
        build_mcp_tool_call_request_meta(
            &step_b,
            "node_repl",
            "call-b",
            /*metadata*/ None,
            /*is_host_owned_apps*/ false
        ),
        Some(serde_json::json!({
            "callId": "call-b",
            crate::X_CODEX_TURN_METADATA_HEADER: expected,
            CONFIRMATION_POLICIES_META_KEY: {},
        })),
    );
    assert_eq!(
        build_mcp_tool_call_request_meta(
            &step_a,
            "node_repl",
            "call-a",
            /*metadata*/ None,
            /*is_host_owned_apps*/ false
        ),
        original_meta,
    );
}

#[tokio::test]
async fn guardian_mcp_tool_call_request_meta_excludes_actor_confirmation_policy() {
    for session_source in [
        SessionSource::Internal(InternalSessionSource::Guardian),
        SessionSource::SubAgent(SubAgentSource::Other(
            crate::guardian::GUARDIAN_REVIEWER_NAME.to_string(),
        )),
    ] {
        let (_, mut turn_context) = make_session_and_context().await;
        turn_context.session_source = session_source;
        update_turn_settings_for_test(&mut turn_context, |settings| {
            Arc::make_mut(&mut settings.model_info).model_messages = Some(
                serde_json::from_value(serde_json::json!({
                    "confirmation_policies": {
                        "browser_use": "actor-only raw Markdown",
                        "computer_use": "actor-only native Markdown",
                    },
                }))
                .expect("confirmation policy fixture should deserialize"),
            );
        });
        let expected = Some(serde_json::json!({
            "callId": "call-guardian",
            crate::X_CODEX_TURN_METADATA_HEADER: expected_mcp_turn_metadata(&turn_context),
        }));
        let step_context = StepContext::for_test(Arc::new(turn_context));

        for server in ["node_repl", "cua_repl"] {
            assert_eq!(
                build_mcp_tool_call_request_meta(
                    &step_context,
                    server,
                    "call-guardian",
                    /*metadata*/ None,
                    /*is_host_owned_apps*/ false
                ),
                expected,
                "{server}: {:?}",
                step_context.turn.session_source,
            );
        }
    }
}

#[tokio::test]
async fn mcp_tool_call_request_meta_includes_turn_started_at_unix_ms() {
    let (_, turn_context) = make_session_and_context().await;
    let turn_context = Arc::new(turn_context);
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    turn_context
        .turn_metadata_state
        .set_turn_started_at_unix_ms(/*turn_started_at_unix_ms*/ 1_700_000_000_123);

    let meta = build_mcp_tool_call_request_meta(
        &step_context,
        "custom_server",
        "call-custom",
        /*metadata*/ None,
        /*is_host_owned_apps*/ false,
    )
    .expect("custom servers should receive turn metadata");
    let turn_metadata = meta
        .get(crate::X_CODEX_TURN_METADATA_HEADER)
        .expect("turn metadata should be present");

    assert_eq!(
        turn_metadata
            .get("turn_started_at_unix_ms")
            .and_then(serde_json::Value::as_i64),
        Some(1_700_000_000_123)
    );
}

#[tokio::test]
async fn mcp_sandbox_cwd_uses_matching_server_environment_uri() -> anyhow::Result<()> {
    let (_, mut turn_context) = make_session_and_context().await;
    let secondary_cwd = PathUri::parse("file:///C:/remote/project")?;
    let environment = turn_context
        .initial_environments
        .primary()
        .expect("primary environment")
        .environment
        .clone();
    turn_context
        .initial_environments
        .environments
        .push(TurnEnvironmentState::Ready(TurnEnvironment::new(
            TurnEnvironmentSelection {
                selected_capability_roots: Default::default(),
                environment_id: "remote".to_string(),
                cwd: secondary_cwd.clone(),
                workspace_roots: Vec::new(),
                config: EnvironmentConfigState::Ready(EnvironmentConfig {
                    environment_hooks: Default::default(),
                    allow_login_shell: true,
                    workspace_roots: Vec::new(),
                    windows_sandbox_level: turn_context.windows_sandbox_level,
                    windows_sandbox_type: turn_context.config.permissions.windows_sandbox_type,
                    use_legacy_landlock: turn_context.config.features.use_legacy_landlock(),
                    permission_profile: turn_context
                        .config
                        .permissions
                        .permission_profile_state()
                        .snapshot(),
                    shell_environment_policy: Default::default(),
                    exec_policy: None,
                    mcp_policy: None,
                    network_policy: None,
                    selected_capability_roots: Vec::new(),
                }),
            },
            EnvironmentConfigOrigin::Thread,
            environment,
            /*shell*/ None,
        )));

    let step_context = StepContext::for_test(Arc::new(turn_context));
    let sandbox_cwd = sandbox_cwd_for_mcp_server(&step_context, "remote");

    assert_eq!(sandbox_cwd, Some(secondary_cwd));
    Ok(())
}

#[tokio::test]
async fn mcp_sandbox_cwd_is_none_for_unselected_server_environment() -> anyhow::Result<()> {
    let (_, turn_context) = make_session_and_context().await;

    let step_context = StepContext::for_test(Arc::new(turn_context));
    let sandbox_cwd = sandbox_cwd_for_mcp_server(&step_context, "remote");

    assert_eq!(sandbox_cwd, None);
    Ok(())
}

#[tokio::test]
async fn plugin_mcp_tool_call_request_meta_includes_plugin_id() {
    let (_, turn_context) = make_session_and_context().await;
    let turn_context = Arc::new(turn_context);
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    let expected_turn_metadata = expected_mcp_turn_metadata(&turn_context);
    let mut metadata = approval_metadata(
        /*connector_id*/ None, /*connector_name*/ None,
        /*connector_description*/ None, /*tool_title*/ None,
        /*tool_description*/ None,
    );
    metadata.plugin_id = Some("sample@test".to_string());

    assert_eq!(
        build_mcp_tool_call_request_meta(
            &step_context,
            "sample",
            "call-plugin",
            Some(&metadata),
            /*is_host_owned_apps*/ false
        ),
        Some(serde_json::json!({
            "callId": "call-plugin",
            crate::X_CODEX_TURN_METADATA_HEADER: expected_turn_metadata,
            MCP_TOOL_PLUGIN_ID_META_KEY: "sample@test",
        }))
    );
}

#[test]
fn mcp_tool_call_item_metadata_only_trusts_codex_apps_identity() {
    let mut metadata = approval_metadata(
        Some("asdk_app_0123456789abcdef0123456789abcdef"),
        Some("Calendar"),
        /*connector_description*/ None,
        Some("Create a calendar event"),
        /*tool_description*/ None,
    );
    metadata.link_id = Some("link_fedcba9876543210fedcba9876543210".to_string());
    metadata.annotations = Some(annotations(
        Some(false),
        /*destructive*/ None,
        /*open_world*/ None,
    ));
    metadata.codex_apps_meta = Some(
        serde_json::json!({
            "resource_uri": "/asdk_app_0123456789abcdef0123456789abcdef/link_fedcba9876543210fedcba9876543210/create_event",
        })
        .as_object()
        .cloned()
        .expect("_codex_apps metadata should be an object"),
    );

    assert_eq!(
        McpToolCallItemMetadata::from_tool_metadata(CODEX_APPS_MCP_SERVER_NAME, Some(&metadata),),
        McpToolCallItemMetadata {
            connector_id: Some("asdk_app_0123456789abcdef0123456789abcdef".to_string()),
            link_id: Some("link_fedcba9876543210fedcba9876543210".to_string()),
            mcp_app_resource_uri: None,
            mcp_app_ui: None,
            app_name: Some("Calendar".to_string()),
            action_name: Some("create_event".to_string()),
            plugin_id: None,
            read_only_hint: Some(false),
        }
    );
    assert_eq!(
        McpToolCallItemMetadata::from_tool_metadata("custom_server", Some(&metadata)),
        McpToolCallItemMetadata {
            connector_id: None,
            link_id: None,
            mcp_app_resource_uri: None,
            mcp_app_ui: None,
            app_name: None,
            action_name: None,
            plugin_id: None,
            read_only_hint: Some(false),
        }
    );
}

#[tokio::test]
async fn mcp_tool_call_item_includes_app_identity() {
    let (session, turn_context, rx_event) = make_session_and_context_with_rx().await;

    notify_mcp_tool_call_started(
        &session,
        &turn_context,
        "call-plugin",
        McpInvocation {
            server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
            tool: "echo".to_string(),
            arguments: None,
        },
        McpToolCallItemMetadata {
            connector_id: Some("asdk_app_0123456789abcdef0123456789abcdef".to_string()),
            link_id: Some("link_fedcba9876543210fedcba9876543210".to_string()),
            mcp_app_resource_uri: None,
            mcp_app_ui: None,
            app_name: Some("Calendar".to_string()),
            action_name: Some("create_event".to_string()),
            plugin_id: Some("sample@test".to_string()),
            read_only_hint: Some(false),
        },
    )
    .await;

    let event = tokio::time::timeout(std::time::Duration::from_secs(1), rx_event.recv())
        .await
        .expect("tool call item timed out")
        .expect("tool call item event");
    let EventMsg::ItemStarted(item_started) = event.msg else {
        panic!("expected ItemStarted event");
    };
    let TurnItem::McpToolCall(item) = item_started.item else {
        panic!("expected MCP tool call item");
    };

    assert_eq!(
        item.connector_id.as_deref(),
        Some("asdk_app_0123456789abcdef0123456789abcdef")
    );
    assert_eq!(
        item.link_id.as_deref(),
        Some("link_fedcba9876543210fedcba9876543210")
    );
    assert_eq!(item.plugin_id.as_deref(), Some("sample@test"));
    assert_eq!(item.app_name.as_deref(), Some("Calendar"));
    assert_eq!(item.action_name.as_deref(), Some("create_event"));
    assert_eq!(item.read_only_hint, Some(false));
}

#[test_case::test_case(false; "user configured Apps name")]
#[test_case::test_case(true; "host owned Apps")]
#[tokio::test]
async fn codex_apps_tool_call_request_meta_includes_turn_metadata_and_codex_apps_meta(
    is_host_owned_apps: bool,
) {
    let (_, turn_context) = make_session_and_context().await;
    turn_context
        .turn_metadata_state
        .set_root_turn_id("causal-root".to_string());
    let turn_context = Arc::new(turn_context);
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    let expected_turn_metadata = expected_mcp_turn_metadata(&turn_context);
    let metadata = McpToolApprovalMetadata {
        annotations: None,
        connector_id: Some("calendar".to_string()),
        link_id: None,
        connector_name: Some("Calendar".to_string()),
        connector_description: Some("Manage events".to_string()),
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Create Event".to_string()),
        tool_description: Some("Create a calendar event.".to_string()),
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: Some(
            serde_json::json!({
                "resource_uri": "connector://calendar/tools/calendar_create_event",
                "contains_mcp_source": true,
                "connector_id": "calendar",
                "root_turn_id": "untrusted-tool-metadata",
            })
            .as_object()
            .cloned()
            .expect("_codex_apps metadata should be an object"),
        ),
        openai_file_input_optional_fields: None,
    };

    let mut expected_apps_meta = serde_json::json!({
        "call_id": "call_abc123xyz789",
        "resource_uri": "connector://calendar/tools/calendar_create_event",
        "contains_mcp_source": true,
        "connector_id": "calendar",
    });
    if is_host_owned_apps {
        expected_apps_meta["root_turn_id"] = serde_json::json!("causal-root");
    }

    assert_eq!(
        build_mcp_tool_call_request_meta(
            &step_context,
            CODEX_APPS_MCP_SERVER_NAME,
            "call_abc123xyz789",
            Some(&metadata),
            is_host_owned_apps
        ),
        Some(serde_json::json!({
            "callId": "call_abc123xyz789",
            crate::X_CODEX_TURN_METADATA_HEADER: expected_turn_metadata,
            MCP_TOOL_CODEX_APPS_META_KEY: expected_apps_meta,
        }))
    );
}

#[tokio::test]
async fn codex_apps_tool_call_request_meta_includes_call_id_without_existing_codex_apps_meta() {
    let (_, turn_context) = make_session_and_context().await;
    let turn_context = Arc::new(turn_context);
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    let expected_turn_metadata = expected_mcp_turn_metadata(&turn_context);

    assert_eq!(
        build_mcp_tool_call_request_meta(
            &step_context,
            CODEX_APPS_MCP_SERVER_NAME,
            "call_abc123xyz789",
            /*metadata*/ None,
            /*is_host_owned_apps*/ false
        ),
        Some(serde_json::json!({
            "callId": "call_abc123xyz789",
            crate::X_CODEX_TURN_METADATA_HEADER: expected_turn_metadata,
            MCP_TOOL_CODEX_APPS_META_KEY: {
                "call_id": "call_abc123xyz789",
            },
        }))
    );
}

fn codex_apps_auth_failure_result() -> CallToolResult {
    CallToolResult {
        content: vec![serde_json::json!({
            "type": "text",
            "text": "Connector reauthentication required",
        })],
        structured_content: None,
        is_error: Some(true),
        meta: Some(serde_json::json!({
            MCP_TOOL_CODEX_APPS_META_KEY: {
                "connector_auth_failure": {
                    "is_auth_failure": true,
                    "auth_reason": "reauthentication_required",
                    "connector_id": "connector_calendar",
                    "connector_name": "Untrusted Calendar",
                    "link_id": "link_123",
                    "error_code": "UNAUTHORIZED",
                    "error_http_status_code": 401,
                    "error_action": "TRIGGER_REAUTHENTICATION",
                },
            },
        })),
    }
}

fn codex_apps_auth_failure_metadata() -> McpToolApprovalMetadata {
    approval_metadata(
        Some("connector_calendar"),
        Some("Google Calendar"),
        Some("Manage events and schedules."),
        Some("Create Event"),
        Some("Create a calendar event."),
    )
}

#[test]
fn codex_apps_auth_classification_requires_the_trusted_server_and_connector() {
    let result = codex_apps_auth_failure_result();

    assert_eq!(
        mcp_tool_call_auth_elicitation_type(
            "untrusted_mcp_server",
            Some("connector_calendar"),
            &result,
        ),
        None
    );
    assert_eq!(
        mcp_tool_call_auth_elicitation_type(
            CODEX_APPS_MCP_SERVER_NAME,
            Some("connector_drive"),
            &result,
        ),
        None
    );
}

#[tokio::test]
async fn codex_apps_auth_elicitation_feature_disabled_returns_original_result() {
    let (session, mut turn_context, rx_event) = make_session_and_context_with_rx().await;
    let mut features = Features::with_defaults();
    features.disable(Feature::AuthElicitation);
    let mutable_turn_context = Arc::get_mut(&mut turn_context).expect("single turn context ref");
    Arc::make_mut(&mut mutable_turn_context.config).features = ManagedFeatures::from(features);
    let result = codex_apps_auth_failure_result();
    let metadata = codex_apps_auth_failure_metadata();

    let returned = maybe_request_codex_apps_auth_elicitation(
        &session,
        &turn_context,
        turn_context.approval_policy(),
        "call_123",
        CODEX_APPS_MCP_SERVER_NAME,
        Some(&metadata),
        result.clone(),
    )
    .await;

    assert_eq!(returned, result);
    assert!(rx_event.try_recv().is_err());
}

#[tokio::test]
async fn codex_apps_auth_elicitation_disallowed_by_policy_returns_original_result() {
    let (session, mut turn_context, rx_event) = make_session_and_context_with_rx().await;
    let mut features = Features::with_defaults();
    features.enable(Feature::AuthElicitation);
    let mutable_turn_context = Arc::get_mut(&mut turn_context).expect("single turn context ref");
    Arc::make_mut(&mut mutable_turn_context.config).features = ManagedFeatures::from(features);
    let result = codex_apps_auth_failure_result();
    let metadata = codex_apps_auth_failure_metadata();

    let returned = maybe_request_codex_apps_auth_elicitation(
        &session,
        &turn_context,
        AskForApproval::Never,
        "call_123",
        CODEX_APPS_MCP_SERVER_NAME,
        Some(&metadata),
        result.clone(),
    )
    .await;

    assert_eq!(returned, result);
    assert!(rx_event.try_recv().is_err());
}

#[tokio::test]
async fn codex_apps_auth_elicitation_granular_mcp_disabled_returns_original_result() {
    let (session, mut turn_context, rx_event) = make_session_and_context_with_rx().await;
    let mut features = Features::with_defaults();
    features.enable(Feature::AuthElicitation);
    let mutable_turn_context = Arc::get_mut(&mut turn_context).expect("single turn context ref");
    Arc::make_mut(&mut mutable_turn_context.config).features = ManagedFeatures::from(features);
    Arc::make_mut(&mut mutable_turn_context.config)
        .permissions
        .approval_policy
        .set(AskForApproval::Granular(GranularApprovalConfig {
            sandbox_approval: true,
            rules: true,
            skill_approval: true,
            request_permissions: true,
            mcp_elicitations: false,
        }))
        .expect("test setup should allow updating approval policy");
    let result = codex_apps_auth_failure_result();
    let metadata = codex_apps_auth_failure_metadata();

    let returned = maybe_request_codex_apps_auth_elicitation(
        &session,
        &turn_context,
        turn_context.approval_policy(),
        "call_123",
        CODEX_APPS_MCP_SERVER_NAME,
        Some(&metadata),
        result.clone(),
    )
    .await;

    assert_eq!(returned, result);
    assert!(rx_event.try_recv().is_err());
}

#[test_case::test_case(SessionSource::Exec; "root")]
#[test_case::test_case(SessionSource::SubAgent(SubAgentSource::Review); "subagent")]
#[test_case::test_case(SessionSource::Internal(InternalSessionSource::Guardian); "guardian")]
#[tokio::test]
async fn codex_apps_auth_elicitation_enabled_by_default_requests_elicitation(
    source: SessionSource,
) {
    let (session, mut turn_context, rx_event) = make_session_and_context_with_rx().await;
    Arc::get_mut(&mut turn_context)
        .expect("single turn context ref")
        .session_source = source;
    *session.active_turn.lock().await = Some(ActiveTurn::default());
    let result = codex_apps_auth_failure_result();
    let metadata = codex_apps_auth_failure_metadata();

    let request_task = tokio::spawn({
        let session = Arc::clone(&session);
        let turn_context = Arc::clone(&turn_context);
        async move {
            maybe_request_codex_apps_auth_elicitation(
                &session,
                &turn_context,
                turn_context.approval_policy(),
                "call_123",
                CODEX_APPS_MCP_SERVER_NAME,
                Some(&metadata),
                result,
            )
            .await
        }
    });

    let request = loop {
        let event = tokio::time::timeout(std::time::Duration::from_secs(1), rx_event.recv())
            .await
            .expect("elicitation event timed out")
            .expect("expected elicitation event");
        if let EventMsg::ElicitationRequest(request) = event.msg {
            break request;
        }
    };
    assert_eq!(request.server_name, CODEX_APPS_MCP_SERVER_NAME);
    assert_eq!(
        request.id,
        codex_protocol::mcp::RequestId::String("codex_apps_auth_call_123".to_string())
    );
    assert!(matches!(
        request.request,
        codex_protocol::approvals::ElicitationRequest::Url { .. }
    ));

    session
        .resolve_elicitation(
            CODEX_APPS_MCP_SERVER_NAME.to_string(),
            rmcp::model::RequestId::String("codex_apps_auth_call_123".into()),
            ElicitationResponse {
                action: ElicitationAction::Accept,
                content: None,
                meta: None,
            },
        )
        .await
        .expect("elicitation should resolve");
    let returned = tokio::time::timeout(std::time::Duration::from_secs(1), request_task)
        .await
        .expect("auth elicitation task timed out")
        .expect("auth elicitation task failed");
    assert_eq!(
        returned.content,
        vec![serde_json::json!({
            "type": "text",
            "text": "Authentication for Google Calendar was requested and accepted. Retry this tool call now.",
        })]
    );
}

#[test]
fn mcp_tool_call_ids_are_added_to_request_meta() {
    let origin = crate::tools::context::ToolCallOrigin {
        item_id: Some(ResponseItemId::from_server("fc-live".to_string())),
        window_id: "thread-live:2".to_string(),
    };

    assert_eq!(
        with_mcp_tool_call_ids_meta(
            Some(serde_json::json!({
                "source": "test-client",
                "threadId": "stale-thread",
                "sessionId": "stale-session",
                "windowId": "stale-window",
                "itemId": "stale-item",
            })),
            "thread-live",
            "session-live",
            Some(&origin),
        ),
        Some(serde_json::json!({
            "source": "test-client",
            "threadId": "thread-live",
            "sessionId": "session-live",
            "itemId": "fc-live",
            "windowId": "thread-live:2",
        }))
    );

    assert_eq!(
        with_mcp_tool_call_ids_meta(
            /*meta*/ None,
            "thread-live",
            "session-live",
            /*originating_call*/ None,
        ),
        Some(serde_json::json!({
            "threadId": "thread-live",
            "sessionId": "session-live",
        }))
    );

    assert_eq!(
        with_mcp_tool_call_ids_meta(
            Some(serde_json::json!("invalid-meta")),
            "thread-live",
            "session-live",
            /*originating_call*/ None,
        ),
        Some(serde_json::json!("invalid-meta"))
    );
}

#[test]
fn accepted_elicitation_content_converts_to_request_user_input_response() {
    let response = request_user_input_response_from_elicitation_content(Some(serde_json::json!(
        {
            "approval": MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER,
        }
    )));

    assert_eq!(
        response,
        Some(RequestUserInputResponse {
            answers: std::collections::HashMap::from([(
                "approval".to_string(),
                RequestUserInputAnswer {
                    answers: vec![MCP_TOOL_APPROVAL_ACCEPT_AND_REMEMBER.to_string()],
                },
            )]),
        })
    );
}

#[test]
fn approval_elicitation_meta_marks_tool_approvals() {
    assert_eq!(
        build_mcp_tool_approval_elicitation_meta(
            "custom_server",
            /*metadata*/ None,
            /*tool_params*/ None,
            /*tool_params_display*/ None,
            prompt_options(
                /*allow_session_remember*/ false, /*allow_persistent_approval*/ false
            ),
        ),
        Some(serde_json::json!({
            MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
        }))
    );
}

#[test]
fn approval_elicitation_meta_merges_session_and_always_persist_for_custom_servers() {
    assert_eq!(
        build_mcp_tool_approval_elicitation_meta(
            "custom_server",
            Some(&approval_metadata(
                /*connector_id*/ None,
                /*connector_name*/ None,
                /*connector_description*/ None,
                Some("Run Action"),
                Some("Runs the selected action."),
            )),
            Some(&serde_json::json!({"id": 1})),
            /*tool_params_display*/ None,
            prompt_options(
                /*allow_session_remember*/ true, /*allow_persistent_approval*/ true
            ),
        ),
        Some(serde_json::json!({
            MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
            MCP_TOOL_APPROVAL_PERSIST_KEY: [
                MCP_TOOL_APPROVAL_PERSIST_SESSION,
                MCP_TOOL_APPROVAL_PERSIST_ALWAYS,
            ],
            MCP_TOOL_APPROVAL_TOOL_TITLE_KEY: "Run Action",
            MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY: "Runs the selected action.",
            MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY: {
                "id": 1,
            },
        }))
    );
}

#[test]
fn guardian_mcp_review_request_includes_invocation_metadata() {
    let invocation = McpInvocation {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        tool: "browser_navigate".to_string(),
        arguments: Some(serde_json::json!({
            "url": "https://example.com",
        })),
    };

    let mut metadata = approval_metadata(
        Some("playwright"),
        Some("Playwright"),
        Some("Browser automation"),
        Some("Navigate"),
        Some("Open a page"),
    );
    metadata.connected_account_email = Some("[email protected]".to_string());
    let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));

    assert_eq!(
        request,
        GuardianApprovalRequest::McpToolCall {
            id: "call-1".to_string(),
            server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
            tool_name: "browser_navigate".to_string(),
            arguments: Some(serde_json::json!({
                "url": "https://example.com",
            })),
            connector_id: Some("playwright".to_string()),
            connector_name: Some("Playwright".to_string()),
            connector_description: Some("Browser automation".to_string()),
            connected_account_email: Some("[email protected]".to_string()),
            tool_title: Some("Navigate".to_string()),
            tool_description: Some("Open a page".to_string()),
            annotations: None,
        }
    );
}

#[test]
fn guardian_mcp_review_request_includes_annotations_when_present() {
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "dangerous_tool".to_string(),
        arguments: None,
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(Some(false), Some(true), Some(true))),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: None,
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));

    assert_eq!(
        request,
        GuardianApprovalRequest::McpToolCall {
            id: "call-1".to_string(),
            server: "custom_server".to_string(),
            tool_name: "dangerous_tool".to_string(),
            arguments: None,
            connector_id: None,
            connector_name: None,
            connector_description: None,
            connected_account_email: None,
            tool_title: None,
            tool_description: None,
            annotations: Some(GuardianMcpAnnotations {
                destructive_hint: Some(true),
                open_world_hint: Some(true),
                read_only_hint: Some(false),
            }),
        }
    );
}

#[test]
fn guardian_mcp_review_request_ignores_untrusted_connected_account_email() {
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "dangerous_tool".to_string(),
        arguments: None,
    };
    let mut metadata = approval_metadata(
        /*connector_id*/ None, /*connector_name*/ None,
        /*connector_description*/ None, /*tool_title*/ None,
        /*tool_description*/ None,
    );
    metadata.connected_account_email = Some("[email protected]".to_string());

    let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));

    assert_eq!(
        request,
        GuardianApprovalRequest::McpToolCall {
            id: "call-1".to_string(),
            server: "custom_server".to_string(),
            tool_name: "dangerous_tool".to_string(),
            arguments: None,
            connector_id: None,
            connector_name: None,
            connector_description: None,
            connected_account_email: None,
            tool_title: None,
            tool_description: None,
            annotations: None,
        }
    );
}

#[test]
fn approval_elicitation_meta_includes_connector_source_for_codex_apps() {
    assert_eq!(
        build_mcp_tool_approval_elicitation_meta(
            CODEX_APPS_MCP_SERVER_NAME,
            Some(&approval_metadata(
                Some("calendar"),
                Some("Calendar"),
                Some("Manage events and schedules."),
                Some("Run Action"),
                Some("Runs the selected action."),
            )),
            Some(&serde_json::json!({
                "calendar_id": "primary",
            })),
            /*tool_params_display*/ None,
            prompt_options(
                /*allow_session_remember*/ false, /*allow_persistent_approval*/ false
            ),
        ),
        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: {
                "calendar_id": "primary",
            },
        }))
    );
}

#[test]
fn approval_elicitation_meta_merges_session_and_always_persist_with_connector_source() {
    assert_eq!(
        build_mcp_tool_approval_elicitation_meta(
            CODEX_APPS_MCP_SERVER_NAME,
            Some(&approval_metadata(
                Some("calendar"),
                Some("Calendar"),
                Some("Manage events and schedules."),
                Some("Run Action"),
                Some("Runs the selected action."),
            )),
            Some(&serde_json::json!({
                "calendar_id": "primary",
            })),
            /*tool_params_display*/ None,
            prompt_options(
                /*allow_session_remember*/ true, /*allow_persistent_approval*/ true
            ),
        ),
        Some(serde_json::json!({
            MCP_TOOL_APPROVAL_KIND_KEY: MCP_TOOL_APPROVAL_KIND_MCP_TOOL_CALL,
            MCP_TOOL_APPROVAL_PERSIST_KEY: [
                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: {
                "calendar_id": "primary",
            },
        }))
    );
}

#[test]
fn declined_elicitation_response_stays_decline() {
    let response = parse_mcp_tool_approval_elicitation_response(
        Some(ElicitationResponse {
            action: ElicitationAction::Decline,
            content: Some(serde_json::json!({
                "approval": MCP_TOOL_APPROVAL_ACCEPT,
            })),
            meta: None,
        }),
        "approval",
    );

    assert_eq!(
        response,
        ReviewDecision::denied("user rejected MCP tool call")
    );
}

#[test]
fn accepted_elicitation_response_uses_always_persist_meta() {
    let response = parse_mcp_tool_approval_elicitation_response(
        Some(ElicitationResponse {
            action: ElicitationAction::Accept,
            content: None,
            meta: Some(serde_json::json!({
                MCP_TOOL_APPROVAL_PERSIST_KEY: MCP_TOOL_APPROVAL_PERSIST_ALWAYS,
            })),
        }),
        "approval",
    );

    assert_eq!(response, ReviewDecision::ApprovedMcpPolicyAmendment);
}

#[test]
fn accepted_elicitation_response_uses_session_persist_meta() {
    let response = parse_mcp_tool_approval_elicitation_response(
        Some(ElicitationResponse {
            action: ElicitationAction::Accept,
            content: None,
            meta: Some(serde_json::json!({
                MCP_TOOL_APPROVAL_PERSIST_KEY: MCP_TOOL_APPROVAL_PERSIST_SESSION,
            })),
        }),
        "approval",
    );

    assert_eq!(response, ReviewDecision::ApprovedForSession);
}

#[test]
fn accepted_elicitation_without_content_defaults_to_accept() {
    let response = parse_mcp_tool_approval_elicitation_response(
        Some(ElicitationResponse {
            action: ElicitationAction::Accept,
            content: None,
            meta: None,
        }),
        "approval",
    );

    assert_eq!(response, ReviewDecision::Approved);
}

#[tokio::test]
async fn dispatched_mcp_approval_with_closed_response_is_classified_as_approval() {
    use wiremock::matchers::method;
    use wiremock::matchers::path;

    let server = wiremock::MockServer::start().await;
    wiremock::Mock::given(method("POST"))
        .and(path("/codex/analytics-events/events"))
        .respond_with(wiremock::ResponseTemplate::new(200))
        .mount(&server)
        .await;

    let (mut session, turn_context, rx_event) = make_session_and_context_with_rx().await;
    let client = codex_analytics::AnalyticsEventsClient::new(
        crate::test_support::auth_manager_from_auth(
            codex_login::CodexAuth::create_dummy_chatgpt_auth_for_testing(),
        ),
        server.uri(),
        /*analytics_enabled*/ Some(true),
    );
    Arc::get_mut(&mut session)
        .expect("session should be uniquely owned")
        .services
        .analytics_events_client = client.clone();
    *session.active_turn.lock().await = Some(ActiveTurn::default());

    let call_id = "modern-missing-response";
    let thread_id = session.thread_id.to_string();
    let turn_id = turn_context.sub_id.clone();
    client.track_initialize(
        /*connection_id*/ 1,
        app_server_protocol::InitializeParams::default(),
        "test-client".to_string(),
        codex_analytics::AppServerRpcTransport::Stdio,
    );
    let response = serde_json::from_value(serde_json::json!({
        "thread": {
            "id": thread_id, "sessionId": thread_id, "preview": "", "ephemeral": false,
            "modelProvider": "openai", "createdAt": 1, "updatedAt": 1,
            "status": {"type": "idle"}, "cwd": &turn_context.config.cwd,
            "cliVersion": "0.0.0", "source": "exec", "turns": [],
        },
        "model": "test-model", "modelProvider": "openai", "cwd": &turn_context.config.cwd,
        "approvalPolicy": "on-request", "approvalsReviewer": "user",
        "sandbox": {"type": "dangerFullAccess"},
    }))
    .expect("thread-start response should deserialize");
    client.track_response(
        /*connection_id*/ 1,
        app_server_protocol::RequestId::Integer(1),
        &app_server_protocol::ClientResponsePayload::ThreadStart(response),
    );
    client.track_notification(&app_server_protocol::ServerNotification::TurnStarted(
        serde_json::from_value(serde_json::json!({
            "threadId": thread_id,
            "turn": {"id": turn_id, "items": [], "status": "inProgress"},
        }))
        .expect("turn-started notification should deserialize"),
    ));
    let mut item = serde_json::json!({
        "type": "mcpToolCall", "id": call_id, "server": "calendar", "tool": "send",
        "status": "inProgress", "arguments": {},
        "appContext": {"connectorId": "calendar"},
    });
    client.track_notification(&app_server_protocol::ServerNotification::ItemStarted(
        serde_json::from_value(serde_json::json!({
            "threadId": thread_id, "turnId": turn_id, "startedAtMs": 1, "item": item,
        }))
        .expect("item-started notification should deserialize"),
    ));

    let action = ApprovalAction::McpToolCall {
        id: call_id.to_string(),
        environment_id: test_environment_id(&turn_context).to_owned(),
        server: "calendar".to_string(),
        tool_name: "send".to_string(),
        arguments: None,
        connector_id: Some("calendar".to_string()),
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        tool_title: None,
        tool_description: None,
        annotations: None,
        hook_tool_name: HookToolName::new("mcp__calendar__send"),
        approval_policy: AskForApproval::OnRequest,
        reviewer: ApprovalsReviewer::User,
        approval_mode: AppToolApproval::Auto,
        allow_session_remember: true,
        allow_persistent_approval: true,
    };
    let approval = tokio::spawn({
        let session = Arc::clone(&session);
        let turn_context = Arc::clone(&turn_context);
        async move { request_mcp_tool_user_approval(&session, &turn_context, call_id, &action).await }
    });
    let event = tokio::time::timeout(std::time::Duration::from_secs(1), rx_event.recv())
        .await
        .expect("approval request should be dispatched")
        .expect("approval request should be received");
    assert!(matches!(event.msg, EventMsg::ElicitationRequest(_)));
    *session.active_turn.lock().await = None;
    assert_eq!(
        approval.await.expect("approval task should complete"),
        ApprovalResolution {
            decision: ReviewDecision::Abort,
            source: ApprovalResolutionSource::User,
            cancellation_reason: Some(McpApprovalCancellationReason::Interrupted),
        }
    );

    item["status"] = serde_json::json!("failed");
    client.track_notification(&app_server_protocol::ServerNotification::ItemCompleted(
        serde_json::from_value(serde_json::json!({
            "threadId": thread_id, "turnId": turn_id, "completedAtMs": 2, "item": item,
        }))
        .expect("item-completed notification should deserialize"),
    ));
    client.flush().await;
    let events = server
        .received_requests()
        .await
        .expect("analytics requests should be recorded")
        .into_iter()
        .flat_map(|request| {
            serde_json::from_slice::<serde_json::Value>(&request.body)
                .expect("analytics request should deserialize")["events"]
                .as_array()
                .expect("analytics events should be an array")
                .clone()
        })
        .collect::<Vec<_>>();
    let mcp_events = events
        .iter()
        .filter(|event| {
            event["event_type"] == "codex_mcp_tool_call_event"
                && event["event_params"]["item_id"] == call_id
        })
        .collect::<Vec<_>>();
    assert_eq!(mcp_events.len(), 1);
    assert_eq!(
        mcp_events[0]["event_params"]["elicitation_type"],
        "approval"
    );
}

#[tokio::test]
async fn persist_codex_app_tool_approval_writes_tool_override() {
    let tmp = tempdir().expect("tempdir");
    let config = ConfigBuilder::default()
        .codex_home(tmp.path().to_path_buf())
        .build()
        .await
        .expect("load config");

    persist_codex_app_tool_approval(&config, "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,
                    omit_tools_from: None,
                    approvals_reviewer: None,
                    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),
                            },
                        )]),
                    }),
                    links: None,
                },
            )]),
        })
    );
    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");
    std::fs::write(
        tmp.path().join(CONFIG_TOML_FILE),
        "[mcp_servers.docs]\ncommand = \"docs-server\"\n",
    )
    .expect("seed config");
    let config = ConfigBuilder::default()
        .codex_home(tmp.path().to_path_buf())
        .build()
        .await
        .expect("load config");

    persist_custom_mcp_tool_approval(&config, "docs", "search")
        .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");
    let tool = parsed
        .mcp_servers
        .get("docs")
        .and_then(|server| server.tools.get("search"))
        .expect("docs/search tool config exists");

    assert_eq!(
        tool,
        &McpServerToolConfig {
            approval_mode: Some(AppToolApproval::Approve),
            ..Default::default()
        }
    );
    assert!(contents.contains("[mcp_servers.docs.tools.search]"));
}

#[tokio::test]
async fn custom_mcp_tool_approval_mode_uses_server_default_with_tool_override() {
    let tmp = tempdir().expect("tempdir");
    std::fs::write(
        tmp.path().join(CONFIG_TOML_FILE),
        r#"
[mcp_servers.docs]
command = "docs-server"
default_tools_approval_mode = "approve"

[mcp_servers.docs.tools.search]
approval_mode = "prompt"
"#,
    )
    .expect("seed config");
    let config = ConfigBuilder::default()
        .codex_home(tmp.path().to_path_buf())
        .build()
        .await
        .expect("load config");
    let (session, mut turn_context) = make_session_and_context().await;
    turn_context.config = Arc::new(config);

    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "docs", "read").await,
        AppToolApproval::Approve
    );
    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "docs", "search").await,
        AppToolApproval::Prompt
    );
    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "unknown", "search").await,
        AppToolApproval::Auto
    );
}

#[tokio::test]
async fn custom_mcp_tool_approval_mode_uses_plugin_mcp_policy() {
    let (session, mut turn_context) = make_session_and_context().await;
    let codex_home = session.codex_home().await;
    write_sample_plugin_mcp(codex_home.as_path());
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        r#"
[features]
plugins = true

[plugins."sample@test"]
enabled = true

[plugins."sample@test".mcp_servers.sample]
default_tools_approval_mode = "prompt"

[plugins."sample@test".mcp_servers.sample.tools.search]
approval_mode = "approve"
"#,
    )
    .expect("seed config");
    let config = ConfigBuilder::default()
        .codex_home(codex_home.to_path_buf())
        .build()
        .await
        .expect("load config");
    turn_context.config = Arc::new(config);
    session.services.plugins_manager.clear_cache();

    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "sample", "read").await,
        AppToolApproval::Prompt
    );
    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "sample", "search").await,
        AppToolApproval::Approve
    );
}

#[tokio::test]
async fn custom_mcp_tool_approval_mode_uses_updated_plugin_mcp_policy_after_cache_warm() {
    let (session, mut turn_context) = make_session_and_context().await;
    let codex_home = session.codex_home().await;
    write_sample_plugin_mcp(codex_home.as_path());
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        r#"
[features]
plugins = true

[plugins."sample@test"]
enabled = true
"#,
    )
    .expect("seed config");
    let initial_config = ConfigBuilder::default()
        .codex_home(codex_home.to_path_buf())
        .build()
        .await
        .expect("load initial config");
    session
        .services
        .plugins_manager
        .plugins_for_config(&initial_config.plugins_config_input())
        .await;
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        r#"
[features]
plugins = true

[plugins."sample@test"]
enabled = true

[plugins."sample@test".mcp_servers.sample.tools.search]
approval_mode = "approve"
"#,
    )
    .expect("update config");
    let updated_config = ConfigBuilder::default()
        .codex_home(codex_home.to_path_buf())
        .build()
        .await
        .expect("load updated config");
    turn_context.config = Arc::new(updated_config);

    assert_eq!(
        custom_mcp_tool_approval_mode(&session, &turn_context, "sample", "search").await,
        AppToolApproval::Approve
    );
}

#[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(),
        plugin_id: None,
        connector_id: Some("calendar".to_string()),
        link_id: None,
        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, mut 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");
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        "[mcp_servers.docs]\ncommand = \"docs-server\"\n",
    )
    .expect("seed config");
    let config = ConfigBuilder::without_managed_config_for_tests()
        .codex_home(codex_home.clone().to_path_buf())
        .build()
        .await
        .expect("load config");
    turn_context.config = Arc::new(config);
    let key = McpToolApprovalKey {
        server: "docs".to_string(),
        plugin_id: None,
        connector_id: None,
        link_id: None,
        tool_name: "search".to_string(),
    };

    maybe_persist_mcp_tool_approval(&session, &turn_context, key.clone()).await;

    let config = session.get_config().await;
    let mcp_servers_toml = config
        .config_layer_stack
        .effective_config()
        .as_table()
        .and_then(|table| table.get("mcp_servers"))
        .cloned()
        .expect("mcp_servers table");
    let mcp_servers = HashMap::<String, McpServerConfig>::deserialize(mcp_servers_toml)
        .expect("deserialize MCP servers");
    let tool = mcp_servers
        .get("docs")
        .and_then(|server| server.tools.get("search"))
        .expect("docs/search tool config exists");

    assert_eq!(
        tool,
        &McpServerToolConfig {
            approval_mode: Some(AppToolApproval::Approve),
            ..Default::default()
        }
    );
    assert_eq!(mcp_tool_approval_is_remembered(&session, &key).await, true);
}

#[tokio::test]
async fn maybe_persist_mcp_tool_approval_preserves_plugin_default_activation() {
    let (session, turn_context) = make_session_and_context().await;
    let codex_home = session.codex_home().await;
    write_sample_plugin_mcp(codex_home.as_path());
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        "[features]\nplugins = true\n",
    )
    .expect("seed config");
    let key = McpToolApprovalKey {
        server: "sample".to_string(),
        plugin_id: Some("sample@test".to_string()),
        connector_id: None,
        link_id: None,
        tool_name: "search".to_string(),
    };

    maybe_persist_mcp_tool_approval(&session, &turn_context, key.clone()).await;

    let contents = std::fs::read_to_string(codex_home.join(CONFIG_TOML_FILE)).expect("read config");
    let parsed: ConfigToml = toml::from_str(&contents).expect("parse config");
    let tool = parsed
        .plugins
        .plugins
        .get("sample@test")
        .and_then(|plugin| plugin.mcp_servers.get("sample"))
        .and_then(|server| server.tools.get("search"))
        .expect("sample/search tool config exists");

    assert_eq!(
        tool,
        &McpServerToolConfig {
            approval_mode: Some(AppToolApproval::Approve),
            ..Default::default()
        }
    );
    assert!(contents.contains(r#"[plugins."sample@test".mcp_servers.sample.tools.search]"#));
    assert_eq!(parsed.plugins.plugins["sample@test"].enabled, None);
    assert_eq!(mcp_tool_approval_is_remembered(&session, &key).await, true);

    let config = session.get_config().await;
    let servers = codex_mcp::configured_mcp_servers(
        &config
            .to_mcp_config(session.services.plugins_manager.as_ref())
            .await,
    );
    assert_eq!(&servers["sample"].tools["search"], tool);

    ConfigEditsBuilder::for_config(&config)
        .with_edits([ConfigEdit::SetPath {
            segments: vec![
                "plugins".to_string(),
                "_default".to_string(),
                "enabled".to_string(),
            ],
            value: value(false),
        }])
        .apply()
        .await
        .expect("disable plugins by default");
    session.reload_user_config_layer().await;

    let config = session.get_config().await;
    assert_eq!(config.plugins.plugins, parsed.plugins.plugins);
    assert!(
        codex_mcp::configured_mcp_servers(
            &config
                .to_mcp_config(session.services.plugins_manager.as_ref())
                .await,
        )
        .is_empty()
    );
}

#[tokio::test]
async fn maybe_persist_mcp_tool_approval_writes_project_config_for_project_server() {
    let (session, mut turn_context) = make_session_and_context().await;
    let codex_home = session.codex_home().await;
    let project_dir = tempdir().expect("tempdir");
    std::fs::write(project_dir.path().join(".git"), "gitdir: nowhere").expect("seed git marker");
    let project_codex_dir = project_dir.path().join(".codex");
    std::fs::create_dir_all(&project_codex_dir).expect("create project .codex dir");
    std::fs::write(
        project_codex_dir.join(CONFIG_TOML_FILE),
        "[mcp_servers.docs]\ncommand = \"docs-server\"\n",
    )
    .expect("seed project config");
    ConfigEditsBuilder::new(&codex_home)
        .set_project_trust_level(
            project_dir.path(),
            codex_protocol::config_types::TrustLevel::Trusted,
        )
        .apply()
        .await
        .expect("trust project");
    let config = ConfigBuilder::default()
        .codex_home(codex_home.to_path_buf())
        .fallback_cwd(Some(project_dir.path().to_path_buf()))
        .build()
        .await
        .expect("load project config");
    turn_context.config = Arc::new(config);
    let key = McpToolApprovalKey {
        server: "docs".to_string(),
        plugin_id: None,
        connector_id: None,
        link_id: None,
        tool_name: "search".to_string(),
    };

    maybe_persist_mcp_tool_approval(&session, &turn_context, key.clone()).await;

    let contents = std::fs::read_to_string(project_codex_dir.join(CONFIG_TOML_FILE))
        .expect("read project config");
    let parsed: ConfigToml = toml::from_str(&contents).expect("parse project config");
    let tool = parsed
        .mcp_servers
        .get("docs")
        .and_then(|server| server.tools.get("search"))
        .expect("docs/search tool config exists");

    assert_eq!(
        tool,
        &McpServerToolConfig {
            approval_mode: Some(AppToolApproval::Approve),
            ..Default::default()
        }
    );
    assert!(contents.contains("[mcp_servers.docs.tools.search]"));
    assert_eq!(mcp_tool_approval_is_remembered(&session, &key).await, true);
}

#[tokio::test]
async fn approve_mode_skips_when_annotations_do_not_require_approval() {
    let (session, turn_context) = make_session_and_context().await;
    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "read_only_tool".to_string(),
        arguments: None,
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(true),
            /*destructive*/ None,
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Read Only Tool".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let decision = maybe_request_mcp_tool_approval(
        &session,
        &StepContext::for_test(Arc::clone(&turn_context)),
        &CancellationToken::new(),
        "call-1",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__test__tool"),
        &metadata,
        &approval_config(&turn_context),
        turn_context.config.permissions.permission_profile(),
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Approve),
    )
    .await;

    assert_eq!(decision, None);
}

#[tokio::test]
async fn guardian_mode_skips_auto_when_annotations_do_not_require_approval() {
    use wiremock::Mock;
    use wiremock::ResponseTemplate;
    use wiremock::matchers::method;
    use wiremock::matchers::path;

    let server = start_mock_server().await;
    Mock::given(method("POST"))
        .and(path("/v1/responses"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let (mut session, mut turn_context) = make_session_and_context().await;
    Arc::make_mut(&mut turn_context.config)
        .permissions
        .approval_policy
        .set(AskForApproval::OnRequest)
        .expect("test setup should allow updating approval policy");
    let mut config = (*turn_context.config).clone();
    config.model_provider.base_url = Some(format!("{}/v1", server.uri()));
    config.approvals_reviewer = ApprovalsReviewer::AutoReview;
    let config = Arc::new(config);
    let models_manager = models_manager_with_provider(
        config.codex_home.to_path_buf(),
        Arc::clone(&session.services.auth_manager),
        config.model_provider.clone(),
    );
    session.services.models_manager = models_manager;
    turn_context.config = Arc::clone(&config);
    turn_context.provider = create_model_provider(
        config.model_provider.clone(),
        turn_context.auth_manager.clone(),
    );

    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "read_only_tool".to_string(),
        arguments: None,
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(true),
            /*destructive*/ None,
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Read Only Tool".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let decision = maybe_request_mcp_tool_approval(
        &session,
        &StepContext::for_test(Arc::clone(&turn_context)),
        &CancellationToken::new(),
        "call-guardian",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__test__tool"),
        &metadata,
        &approval_config(&turn_context),
        turn_context.config.permissions.permission_profile(),
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Auto),
    )
    .await;

    assert_eq!(decision, None);
}

#[tokio::test]
async fn permission_request_hook_allows_mcp_tool_call() {
    let (mut session, turn_context) = make_session_and_context().await;
    let log_path = install_mcp_permission_request_hook(
        &mut session,
        &turn_context,
        "mcp__memory__.*",
        &serde_json::json!({
            "hookSpecificOutput": {
                "hookEventName": "PermissionRequest",
                "decision": { "behavior": "allow" }
            }
        }),
    );
    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: "memory".to_string(),
        tool: "create_entities".to_string(),
        arguments: Some(serde_json::json!({
            "entities": [{
                "name": "Ada",
                "entityType": "person"
            }]
        })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(false),
            Some(true),
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Create entities".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let decision = maybe_request_mcp_tool_approval(
        &session,
        &StepContext::for_test(Arc::clone(&turn_context)),
        &CancellationToken::new(),
        "call-mcp-hook",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__memory__create_entities"),
        &metadata,
        &approval_config(&turn_context),
        turn_context.config.permissions.permission_profile(),
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Auto),
    )
    .await;

    assert_eq!(
        decision,
        Some(McpToolApproval {
            decision: ReviewDecision::Approved,
            source: Some(ApprovalResolutionSource::Hook),
            cancellation_reason: None,
        })
    );
    let log = std::fs::read_to_string(log_path).expect("read MCP permission hook log");
    let inputs = log
        .lines()
        .map(|line| serde_json::from_str::<serde_json::Value>(line).expect("parse hook input"))
        .collect::<Vec<_>>();
    #[allow(deprecated)]
    let turn_cwd = turn_context.cwd.clone();
    assert_eq!(
        inputs,
        vec![serde_json::json!({
            "session_id": session.session_id(),
            "turn_id": "turn_id",
            "cwd": turn_cwd,
            "transcript_path": null,
            "model": turn_context.model_info().slug,
            "permission_mode": "default",
            "tool_name": "mcp__memory__create_entities",
            "hook_event_name": "PermissionRequest",
            "tool_input": {
                "entities": [{
                    "name": "Ada",
                    "entityType": "person"
                }]
            }
        })]
    );
}

#[tokio::test]
async fn permission_request_hook_uses_hook_tool_name_without_metadata() {
    let (mut session, turn_context) = make_session_and_context().await;
    let log_path = install_mcp_permission_request_hook(
        &mut session,
        &turn_context,
        "mcp__memory__.*",
        &serde_json::json!({
            "hookSpecificOutput": {
                "hookEventName": "PermissionRequest",
                "decision": { "behavior": "allow" }
            }
        }),
    );
    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: "memory".to_string(),
        tool: "create_entities".to_string(),
        arguments: Some(serde_json::json!({ "entities": [] })),
    };
    let metadata = approval_metadata(
        /*connector_id*/ None, /*connector_name*/ None,
        /*connector_description*/ None, /*tool_title*/ None,
        /*tool_description*/ None,
    );

    let decision = maybe_request_mcp_tool_approval(
        &session,
        &StepContext::for_test(Arc::clone(&turn_context)),
        &CancellationToken::new(),
        "call-mcp-hook-no-metadata",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__memory__create_entities"),
        &metadata,
        &approval_config(&turn_context),
        turn_context.config.permissions.permission_profile(),
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Auto),
    )
    .await;

    assert_eq!(
        decision,
        Some(McpToolApproval {
            decision: ReviewDecision::Approved,
            source: Some(ApprovalResolutionSource::Hook),
            cancellation_reason: None,
        })
    );
    let log = std::fs::read_to_string(log_path).expect("read MCP permission hook log");
    let inputs = log
        .lines()
        .map(|line| serde_json::from_str::<serde_json::Value>(line).expect("parse hook input"))
        .collect::<Vec<_>>();
    #[allow(deprecated)]
    let turn_cwd = turn_context.cwd.clone();
    assert_eq!(
        inputs,
        vec![serde_json::json!({
            "session_id": session.session_id(),
            "turn_id": "turn_id",
            "cwd": turn_cwd,
            "transcript_path": null,
            "model": turn_context.model_info().slug,
            "permission_mode": "default",
            "tool_name": "mcp__memory__create_entities",
            "hook_event_name": "PermissionRequest",
            "tool_input": { "entities": [] }
        })]
    );
}

#[tokio::test]
async fn permission_request_hook_runs_after_remembered_mcp_approval() {
    let (mut session, turn_context) = make_session_and_context().await;
    let log_path = install_mcp_permission_request_hook(
        &mut session,
        &turn_context,
        "mcp__memory__.*",
        &serde_json::json!({
            "hookSpecificOutput": {
                "hookEventName": "PermissionRequest",
                "decision": {
                    "behavior": "deny",
                    "message": "should be skipped"
                }
            }
        }),
    );
    let invocation = McpInvocation {
        server: "memory".to_string(),
        tool: "create_entities".to_string(),
        arguments: Some(serde_json::json!({ "entities": [] })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(false),
            Some(true),
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Create entities".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };
    let remembered_key =
        session_mcp_tool_approval_key(&invocation, Some(&metadata), AppToolApproval::Auto)
            .expect("memory MCP tool should support session approval");
    remember_mcp_tool_approval(&session, remembered_key).await;

    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let decision = maybe_request_mcp_tool_approval(
        &session,
        &StepContext::for_test(Arc::clone(&turn_context)),
        &CancellationToken::new(),
        "call-mcp-remembered",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__memory__create_entities"),
        &metadata,
        &approval_config(&turn_context),
        turn_context.config.permissions.permission_profile(),
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Auto),
    )
    .await;

    assert_eq!(
        decision,
        Some(McpToolApproval {
            decision: ReviewDecision::Approved,
            source: None,
            cancellation_reason: None,
        })
    );
    assert!(
        !log_path.exists(),
        "remembered approval should skip PermissionRequest hooks"
    );
}

#[tokio::test]
async fn strict_auto_review_forces_guardian_for_mcp_policy_skip() {
    let server = start_mock_server().await;
    let guardian_request_log = mount_sse_once(
        &server,
        sse(vec![
            ev_response_created("resp-guardian"),
            ev_assistant_message(
                "msg-guardian",
                &serde_json::json!({
                    "risk_level": "high",
                    "user_authorization": "low",
                    "outcome": "deny",
                    "rationale": "The tool call would expose private calendar data without clear user authorization.",
                })
                .to_string(),
            ),
            ev_completed("resp-guardian"),
        ]),
    )
    .await;

    let (mut session, mut turn_context) = make_session_and_context().await;
    Arc::make_mut(&mut turn_context.config)
        .permissions
        .approval_policy
        .set(AskForApproval::UnlessTrusted)
        .expect("test setup should allow updating approval policy");
    let mut config = (*turn_context.config).clone();
    config.model_provider.base_url = Some(format!("{}/v1", server.uri()));
    config.approvals_reviewer = ApprovalsReviewer::User;
    let config = Arc::new(config);
    let models_manager = models_manager_with_provider(
        config.codex_home.to_path_buf(),
        Arc::clone(&session.services.auth_manager),
        config.model_provider.clone(),
    );
    session.services.models_manager = models_manager;
    turn_context.config = Arc::clone(&config);
    turn_context.provider = create_model_provider(
        config.model_provider.clone(),
        turn_context.auth_manager.clone(),
    );

    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "dangerous_tool".to_string(),
        arguments: Some(serde_json::json!({ "calendar_id": "primary" })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(Some(false), Some(true), Some(true))),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Dangerous Tool".to_string()),
        tool_description: Some("Reads calendar data.".to_string()),
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };
    let mut captured_mcp_config = approval_config(&turn_context);
    captured_mcp_config
        .approval_policy
        .set(AskForApproval::OnRequest)
        .expect("captured MCP policy should allow updating approval policy");

    turn_context.record_granted_permissions(
        codex_exec_server::LOCAL_ENVIRONMENT_ID,
        Default::default(),
        /*strict_auto_review*/ true,
    );
    let step_context = StepContext::for_test(Arc::clone(&turn_context));
    let decision = maybe_request_mcp_tool_approval(
        &session,
        &step_context,
        &CancellationToken::new(),
        "call-guardian-deny",
        &invocation,
        &ToolName::namespaced(&invocation.server, &invocation.tool),
        &HookToolName::new("mcp__test__tool"),
        &metadata,
        &captured_mcp_config,
        &captured_mcp_config.permission_profile,
        test_environment_id(&turn_context),
        McpToolApprovalPolicy::for_server(AppToolApproval::Approve),
    )
    .await;

    let Some(McpToolApproval {
        decision: ReviewDecision::Denied { rejection: message },
        source: Some(ApprovalResolutionSource::Guardian),
        cancellation_reason: None,
    }) = decision
    else {
        panic!("guardian-denied MCP approval should carry a rejection message");
    };
    assert!(message.contains("Reason: The tool call would expose private calendar data"));
    assert!(message.contains("policy circumvention"));
    assert_eq!(
        guardian_request_log.single_request().path(),
        "/v1/responses"
    );
}

#[tokio::test]
async fn session_approval_preserves_mcp_session_persistence_choice() {
    assert_mcp_user_approval_persistence(
        MCP_TOOL_APPROVAL_PERSIST_SESSION,
        ReviewDecision::ApprovedForSession,
    )
    .await;
}

#[tokio::test]
async fn session_approval_preserves_mcp_always_persistence_choice() {
    assert_mcp_user_approval_persistence(
        MCP_TOOL_APPROVAL_PERSIST_ALWAYS,
        ReviewDecision::ApprovedMcpPolicyAmendment,
    )
    .await;
}

async fn assert_mcp_user_approval_persistence(
    persistence: &'static str,
    expected_decision: ReviewDecision,
) {
    let (session, turn_context, rx_event) = make_session_and_context_with_rx().await;
    *session.active_turn.lock().await = Some(ActiveTurn::default());
    let invocation = McpInvocation {
        server: "memory".to_string(),
        tool: "create_entities".to_string(),
        arguments: Some(serde_json::json!({ "entities": [] })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(false),
            Some(true),
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Create entities".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let approval_task = tokio::spawn({
        let session = Arc::clone(&session);
        let turn_context = Arc::clone(&turn_context);
        async move {
            maybe_request_mcp_tool_approval(
                &session,
                &StepContext::for_test(Arc::clone(&turn_context)),
                &CancellationToken::new(),
                "call-mcp-persist",
                &invocation,
                &ToolName::namespaced(&invocation.server, &invocation.tool),
                &HookToolName::new("mcp__memory__create_entities"),
                &metadata,
                &approval_config(&turn_context),
                turn_context.config.permissions.permission_profile(),
                test_environment_id(&turn_context),
                McpToolApprovalPolicy::for_server(AppToolApproval::Auto),
            )
            .await
        }
    });

    let request = loop {
        let event = tokio::time::timeout(std::time::Duration::from_secs(1), rx_event.recv())
            .await
            .expect("MCP approval elicitation timed out")
            .expect("expected MCP approval elicitation event");
        if let EventMsg::ElicitationRequest(request) = event.msg {
            break request;
        }
    };
    assert_eq!(request.server_name, "memory");
    session
        .resolve_elicitation(
            "memory".to_string(),
            rmcp::model::RequestId::String("mcp_tool_call_approval_call-mcp-persist".into()),
            ElicitationResponse {
                action: ElicitationAction::Accept,
                content: None,
                meta: Some(serde_json::json!({
                    MCP_TOOL_APPROVAL_PERSIST_KEY: persistence,
                })),
            },
        )
        .await
        .expect("MCP approval elicitation should resolve");

    assert_eq!(
        tokio::time::timeout(std::time::Duration::from_secs(1), approval_task)
            .await
            .expect("MCP approval task timed out")
            .expect("MCP approval task failed"),
        Some(McpToolApproval {
            decision: expected_decision,
            source: Some(ApprovalResolutionSource::User),
            cancellation_reason: None,
        }),
    );
}

#[tokio::test]
async fn prompt_mode_waits_for_approval_when_annotations_do_not_require_approval() {
    let (session, turn_context, _rx_event) = make_session_and_context_with_rx().await;
    {
        let mut active_turn = session.active_turn.lock().await;
        *active_turn = Some(ActiveTurn::default());
    }
    let invocation = McpInvocation {
        server: "custom_server".to_string(),
        tool: "read_only_tool".to_string(),
        arguments: None,
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(
            Some(true),
            /*destructive*/ None,
            /*open_world*/ None,
        )),
        connector_id: None,
        link_id: None,
        connector_name: None,
        connector_description: None,
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Read Only Tool".to_string()),
        tool_description: None,
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    let mut approval_task = {
        let session = Arc::clone(&session);
        let turn_context = Arc::clone(&turn_context);
        tokio::spawn(async move {
            maybe_request_mcp_tool_approval(
                &session,
                &StepContext::for_test(Arc::clone(&turn_context)),
                &CancellationToken::new(),
                "call-prompt",
                &invocation,
                &ToolName::namespaced(&invocation.server, &invocation.tool),
                &HookToolName::new("mcp__test__tool"),
                &metadata,
                &approval_config(&turn_context),
                turn_context.config.permissions.permission_profile(),
                test_environment_id(&turn_context),
                McpToolApprovalPolicy::for_server(AppToolApproval::Prompt),
            )
            .await
        })
    };

    assert!(
        tokio::time::timeout(std::time::Duration::from_millis(200), &mut approval_task)
            .await
            .is_err(),
        "prompt mode should wait for approval instead of auto-allowing"
    );
    approval_task.abort();
}

#[tokio::test]
async fn full_access_mode_skips_mcp_tool_approval_for_all_approval_modes() {
    let (session, mut turn_context) = make_session_and_context().await;
    Arc::make_mut(&mut turn_context.config)
        .permissions
        .approval_policy
        .set(AskForApproval::Never)
        .expect("test setup should allow updating approval policy");
    Arc::make_mut(&mut turn_context.config)
        .permissions
        .set_permission_profile(PermissionProfile::Disabled)
        .expect("test setup should allow updating permission profile");

    let session = Arc::new(session);
    let turn_context = Arc::new(turn_context);
    let invocation = McpInvocation {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        tool: "dangerous_tool".to_string(),
        arguments: Some(serde_json::json!({ "id": 1 })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(Some(false), Some(true), Some(true))),
        connector_id: Some("calendar".to_string()),
        link_id: None,
        connector_name: Some("Calendar".to_string()),
        connector_description: Some("Manage events".to_string()),
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Dangerous Tool".to_string()),
        tool_description: Some("Performs a risky action.".to_string()),
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    for approval_mode in [
        AppToolApproval::Auto,
        AppToolApproval::Prompt,
        AppToolApproval::Approve,
    ] {
        let decision = maybe_request_mcp_tool_approval(
            &session,
            &StepContext::for_test(Arc::clone(&turn_context)),
            &CancellationToken::new(),
            "call-2",
            &invocation,
            &ToolName::namespaced(&invocation.server, &invocation.tool),
            &HookToolName::new("mcp__test__tool"),
            &metadata,
            &approval_config(&turn_context),
            turn_context.config.permissions.permission_profile(),
            test_environment_id(&turn_context),
            McpToolApprovalPolicy::for_server(approval_mode),
        )
        .await;

        assert_eq!(decision, None);
    }
}

#[tokio::test]
async fn approve_mode_skips_guardian_in_every_permission_mode() {
    use wiremock::Mock;
    use wiremock::ResponseTemplate;
    use wiremock::matchers::method;
    use wiremock::matchers::path;

    let server = start_mock_server().await;
    Mock::given(method("POST"))
        .and(path("/v1/responses"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let invocation = McpInvocation {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        tool: "dangerous_tool".to_string(),
        arguments: Some(serde_json::json!({ "id": 1 })),
    };
    let metadata = McpToolApprovalMetadata {
        annotations: Some(annotations(Some(false), Some(true), Some(true))),
        connector_id: Some("calendar".to_string()),
        link_id: None,
        connector_name: Some("Calendar".to_string()),
        connector_description: Some("Manage events".to_string()),
        connected_account_email: None,
        plugin_id: None,
        tool_title: Some("Dangerous Tool".to_string()),
        tool_description: Some("Performs a risky action.".to_string()),
        mcp_app_resource_uri: None,
        mcp_app_ui: None,
        codex_apps_meta: None,
        openai_file_input_optional_fields: None,
    };

    for approval_policy in [
        AskForApproval::UnlessTrusted,
        AskForApproval::OnRequest,
        AskForApproval::Granular(GranularApprovalConfig {
            sandbox_approval: true,
            rules: true,
            skill_approval: true,
            request_permissions: true,
            mcp_elicitations: true,
        }),
        AskForApproval::Never,
    ] {
        let (mut session, mut turn_context) = make_session_and_context().await;
        turn_context.auth_manager = Some(crate::test_support::auth_manager_from_auth(
            codex_login::CodexAuth::create_dummy_chatgpt_auth_for_testing(),
        ));
        Arc::make_mut(&mut turn_context.config)
            .permissions
            .approval_policy
            .set(approval_policy)
            .expect("test setup should allow updating approval policy");
        let mut config = (*turn_context.config).clone();
        config.chatgpt_base_url = server.uri();
        config.model_provider.base_url = Some(format!("{}/v1", server.uri()));
        config.approvals_reviewer = ApprovalsReviewer::User;
        let config = Arc::new(config);
        let models_manager = models_manager_with_provider(
            config.codex_home.to_path_buf(),
            Arc::clone(&session.services.auth_manager),
            config.model_provider.clone(),
        );
        session.services.models_manager = models_manager;
        turn_context.config = Arc::clone(&config);
        turn_context.provider = create_model_provider(
            config.model_provider.clone(),
            turn_context.auth_manager.clone(),
        );

        let session = Arc::new(session);
        let turn_context = Arc::new(turn_context);
        let decision = maybe_request_mcp_tool_approval(
            &session,
            &StepContext::for_test(Arc::clone(&turn_context)),
            &CancellationToken::new(),
            "call-3",
            &invocation,
            &ToolName::namespaced(&invocation.server, &invocation.tool),
            &HookToolName::new("mcp__test__tool"),
            &metadata,
            &approval_config(&turn_context),
            turn_context.config.permissions.permission_profile(),
            test_environment_id(&turn_context),
            McpToolApprovalPolicy::for_server(AppToolApproval::Approve),
        )
        .await;

        assert_eq!(decision, None);
    }
}

#[tokio::test]
async fn approval_metadata_is_released_when_the_invocation_future_is_dropped() {
    let (session, turn_context) = crate::session::tests::make_session_and_context().await;
    let review_context = GuardianReviewContext::from(Arc::new(turn_context));
    let invocation = McpInvocation {
        server: CODEX_APPS_MCP_SERVER_NAME.to_string(),
        tool: "write_record".to_string(),
        arguments: Some(serde_json::json!({"value": 42})),
    };
    let metadata = approval_metadata(
        Some("connector"),
        /*connector_name*/ None,
        /*connector_description*/ None,
        /*tool_title*/ None,
        /*tool_description*/ None,
    );
    let mut call = Box::pin(async {
        let _approval_metadata = session.register_mcp_tool_approval_metadata(
            "call",
            &invocation,
            metadata.clone(),
            review_context.clone(),
        );
        std::future::pending::<()>().await;
    });
    assert!(futures::poll!(call.as_mut()).is_pending());
    let _other_metadata = session.register_mcp_tool_approval_metadata(
        "other-call",
        &invocation,
        metadata.clone(),
        review_context.clone(),
    );
    assert_eq!(
        session
            .mcp_tool_approval_metadata(CODEX_APPS_MCP_SERVER_NAME, "call")
            .map(|context| (context.invocation, context.metadata.connector_id)),
        Some((Some(invocation.clone()), Some("connector".to_string()))),
    );
    assert!(
        session
            .mcp_tool_approval_metadata("another-server", "call")
            .is_none()
    );
    drop(call);
    assert!(
        session
            .mcp_tool_approval_metadata(CODEX_APPS_MCP_SERVER_NAME, "call")
            .is_none()
    );
    let _next_metadata = session.register_mcp_tool_approval_metadata(
        "next-call",
        &invocation,
        metadata,
        review_context,
    );
    let registry = session.mcp_tool_approval_metadata.lock().unwrap();
    let mut keys = registry.keys().cloned().collect::<Vec<_>>();
    keys.sort();
    assert_eq!(
        keys,
        vec![
            (
                CODEX_APPS_MCP_SERVER_NAME.to_string(),
                "next-call".to_string()
            ),
            (
                CODEX_APPS_MCP_SERVER_NAME.to_string(),
                "other-call".to_string()
            ),
        ],
    );
}