Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

30.8 KB
Raw Blame
//! Toolset construction tests.
//!
//! Adding a tool to a toolset runs its input schema through
//! `generate_validated_input_schema` (via `AsyncToolObject::try_from_tool`),
//! which enforces the strict-mode requirements shared by OpenAI and
//! Anthropic. On a validation failure that path `.expect()`-panics, so a tool
//! with an unsupported schema (e.g. a `HashMap` that emits
//! `additionalProperties`) used to surface only at runtime when the service
//! built its toolset.
//!
//! These tests build every toolset the crate exposes. If any tool fails
//! schema validation, construction panics and the corresponding test fails —
//! turning that runtime failure into a test-time failure.

use super::*;
use ai_toolset::ToolSet as _;

#[test]
fn connector_discovery_is_eager_only_in_agent_sessions() {
    assert!(EAGER_TOOLS.contains(&"DiscoverConnectors"));
    assert!(
        tools_for(AiHost::AgentSession)
            .toolset
            .tools
            .contains_key("DiscoverConnectors")
    );
    for host in [AiHost::Chat, AiHost::ChannelBot, AiHost::Mcp] {
        assert!(
            !tools_for(host)
                .toolset
                .tools
                .contains_key("DiscoverConnectors")
        );
    }
}

#[test]
fn subagent_toolset_passes_schema_validation() {
    let tools = subagent_toolset();
    for name in [
        "ListDatabases",
        "DescribeDatabase",
        "QueryDatabase",
        "SaveDatabaseView",
    ] {
        assert!(
            tools.tools.contains_key(name),
            "delegated agents need {name}"
        );
    }
}

#[test]
fn database_only_toolset_exposes_exactly_its_database_capabilities() {
    let tools = database_tools();
    let names = tools
        .tools
        .keys()
        .map(String::as_str)
        .collect::<std::collections::BTreeSet<_>>();
    let expected = [
        "ListDatabases",
        "DescribeDatabase",
        "QueryDatabase",
        "SaveDatabaseView",
        "DeleteDatabaseView",
        "SaveDatabaseQuery",
    ]
    .into_iter()
    .collect();
    assert_eq!(names, expected);
    assert!(
        tools.user_tools.is_empty(),
        "database actions must not expose email/calendar composers"
    );
}

#[test]
fn every_host_toolset_passes_schema_validation() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        assert!(
            tools.toolset.tools.contains_key("GenerateImage"),
            "{host:?} must expose image generation"
        );
    }
}

/// Gemini rejects a whole request when one tool schema has a `$ref` loop of
/// required fields, so every turn advertising that tool fails.
#[test]
fn no_tool_schema_has_a_ref_loop_of_required_fields() {
    let mut schemas = Vec::new();
    for tools in [
        tools_for(AiHost::Chat),
        tools_for(AiHost::AgentSession),
        tools_for(AiHost::ChannelBot),
        tools_for(AiHost::Mcp),
        tools_for_agent_code_mode(),
    ] {
        let advertised = tools.toolset.request_schemas().unwrap_or_default();
        schemas.extend(advertised.into_iter().map(|tool| (tool.name, tool.schema)));
        schemas.extend(
            tools
                .deferred
                .iter()
                .map(|tool| (tool.name.clone(), tool.schema.clone())),
        );
    }
    let subagent = subagent_toolset().request_schemas().unwrap_or_default();
    schemas.extend(subagent.into_iter().map(|tool| (tool.name, tool.schema)));
    assert!(schemas.iter().any(|(name, _)| name == "DisplayResults"));
    for (name, schema) in schemas {
        assert_eq!(
            ai_toolset::schema::required_ref_loop(schema.as_value()),
            None,
            "{name}"
        );
    }
}

#[test]
fn coding_dispatch_is_available_to_every_host_but_not_internal_subagents() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in [
            "ListCodingAgents",
            "ListAgentUpdates",
            "DispatchCodingAgent",
        ] {
            assert!(tools.toolset.tools.contains_key(name), "{host:?}: {name}");
        }
        for name in ["ListCodingAgents", "DispatchCodingAgent"] {
            assert!(tools.prompt.to_string().contains(name), "{host:?}: {name}");
        }
    }
    let subagent = subagent_toolset();
    for name in [
        "ListCodingAgents",
        "ListAgentUpdates",
        "DispatchCodingAgent",
    ] {
        assert!(!subagent.tools.contains_key(name));
    }
}

#[test]
fn code_mode_runs_confirmed_actions_through_the_sdk_instead_of_the_tools() {
    let tools = tools_for_agent_code_mode();
    let prompt = tools.prompt.to_string();
    for name in ["SendConfirmedEmail", "CreateConfirmedCalendarEvent"] {
        assert!(!tools.toolset.tools.contains_key(name), "{name}");
        assert!(
            !tools.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
        assert!(!prompt.contains(name), "{name}");
    }
    assert!(prompt.contains("macro.email.sendConfirmed"));
    assert!(prompt.contains("macro.calendar.createConfirmed"));
}

#[test]
fn code_mode_starts_agents_through_the_sdk_instead_of_dispatch_tools() {
    let tools = tools_for_agent_code_mode();
    let prompt = tools.prompt.to_string();
    for name in ["ListCodingAgents", "DispatchCodingAgent"] {
        assert!(!tools.toolset.tools.contains_key(name), "{name}");
        assert!(
            !tools.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
        assert!(!prompt.contains(name), "{name}");
    }
    assert!(tools.toolset.tools.contains_key("ListAgentUpdates"));
    assert!(prompt.contains("macro.agents.list()"));
    assert!(prompt.contains("macro.agentSessions.createManaged"));
    assert!(
        !tools_for(AiHost::AgentSession)
            .prompt
            .to_string()
            .contains("createManaged")
    );
}

#[test]
fn code_mode_manages_bots_through_the_sdk_but_keeps_the_credential_card() {
    let tools = tools_for_agent_code_mode();
    for name in [
        "ListBots",
        "CreateBot",
        "ConfigureBot",
        "DeleteBot",
        "GetBotWebhooks",
        "ManageBotChannelAccess",
    ] {
        assert!(!tools.toolset.tools.contains_key(name), "{name}");
        assert!(
            !tools.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
    }
    assert!(tools.toolset.tools.contains_key("IssueBotCredential"));
}

#[test]
fn code_mode_reads_and_edits_office_and_design_files_through_the_sdk() {
    let tools = tools_for_agent_code_mode();
    for name in [
        "ReadPresentation",
        "EditPresentation",
        "ReadWordDocument",
        "EditWordDocument",
        "ReadDesign",
        "ReadPhotoshopDocument",
        "ReadIllustratorDocument",
    ] {
        assert!(!tools.toolset.tools.contains_key(name), "{name}");
        assert!(
            !tools.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
    }
    assert!(
        tools_for(AiHost::AgentSession)
            .toolset
            .tools
            .contains_key("EditPresentation")
    );
}

#[test]
fn project_workflows_are_available_in_every_host_alongside_folder_and_property_tools() {
    let names = [
        "ListInitiatives",
        "ReadInitiative",
        "CreateInitiative",
        "UpdateInitiative",
        "DeleteInitiative",
        "UpdateInitiativeSharing",
        "ReadInitiativeActivity",
        "SetEntityProperty",
        "ReadDiscussion",
        "Comment",
        "CommentOnText",
        "ResolveComment",
        "CreateProject",
        "ReadProject",
    ];
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let json = frontend_schemas_builder()
            .merge(&tools_for(host))
            .build()
            .to_json_pretty()
            .expect("schemas serialize");
        let schema: serde_json::Value = serde_json::from_str(&json).unwrap();
        let tools = schema["tools"].as_array().unwrap();
        for name in names {
            assert!(
                tools.iter().any(|tool| tool["name"] == name),
                "{host:?} must expose {name}"
            );
        }
    }
}

/// Every host, including MCP, can take the item actions the app's menus
/// offer: editing channel messages and comments, trashing, duplicating,
/// renaming, sharing, favoriting, and muting items, DMs, CRM records, calls,
/// skills, and routines.
#[test]
fn app_item_actions_are_available_in_every_host() {
    let names = [
        "EditChannelMessage",
        "DeleteChannelMessage",
        "ReactToChannelMessage",
        "OpenDirectMessage",
        "EditComment",
        "DeleteComment",
        "CreateSkill",
        "MoveToTrash",
        "DuplicateItem",
        "RenameItem",
        "UpdateSharing",
        "SetFavorite",
        "MuteNotifications",
        "RunRoutine",
        "DeleteRoutine",
        "CreateCompany",
        "CreateContact",
        "UpdateCallRecord",
        "DeleteCallRecord",
    ];
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in names {
            assert!(
                tools.toolset.tools.contains_key(name),
                "{host:?} must expose {name}"
            );
        }
    }
}

/// Every host reads the design files the native engines open, and each
/// reader's description says the file is read-only to tools.
#[test]
fn design_file_readers_are_available_in_every_host_with_their_guidance() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in [
            "ReadDesign",
            "ReadPhotoshopDocument",
            "ReadIllustratorDocument",
        ] {
            let tool = &tools.toolset.tools[name];
            assert!(
                tool.description
                    .contains("describe changes for the user to make"),
                "{host:?}: {name}"
            );
        }
    }
    assert!(
        subagent_toolset()
            .tools
            .contains_key("ReadPhotoshopDocument")
    );
    assert!(
        subagent_toolset()
            .tools
            .contains_key("ReadIllustratorDocument")
    );
}

/// Document answers get the one SQL tool, not a read-only twin: the access
/// they run over refuses the writes (see `databases_sql`'s view-only tests).
#[test]
fn document_answers_expose_discovery_and_the_one_query_tool() {
    let tools = database_read_only_tools();
    let names = tools
        .tools
        .keys()
        .map(String::as_str)
        .collect::<std::collections::BTreeSet<_>>();
    assert_eq!(
        names,
        ["ListDatabases", "DescribeDatabase", "QueryDatabase"]
            .into_iter()
            .collect()
    );
    assert_eq!(
        tools.tools["QueryDatabase"].annotations,
        database_tools().tools["QueryDatabase"].annotations,
        "the same QueryDatabase every host gets"
    );
    assert!(tools.user_tools.is_empty());
}

/// An agent session finishes user tools in the turn, so it keeps chat's
/// deferring registrations - and gets the prompt that says a review card,
/// not a pending composer, is what follows the call.
#[test]
fn the_agent_session_host_keeps_chats_user_tools_with_the_review_prompt() {
    let session = tools_for(AiHost::AgentSession);
    assert!(
        session
            .toolset
            .user_tools
            .contains_key("CreateCalendarEvent")
    );
    assert!(session.toolset.user_tools.contains_key("SendEmail"));
    // The confirmed twins execute in the loop, beside the deferring tools,
    // for the prompts a session reads out of a thread.
    assert!(session.toolset.tools.contains_key("SendConfirmedEmail"));
    assert!(
        session
            .toolset
            .tools
            .contains_key("CreateConfirmedCalendarEvent")
    );
    let prompt = session.prompt.to_string();
    assert!(prompt.contains("review card"));
    assert!(!prompt.contains("PendingUserExecution"));
    assert_eq!(
        session.toolset.request_schemas().map(|schemas| schemas
            .into_iter()
            .filter(|schema| schema.name != "DiscoverConnectors")
            .count()),
        tools_for(AiHost::Chat)
            .toolset
            .request_schemas()
            .map(|schemas| schemas
                .into_iter()
                .filter(|schema| schema.name != "DisplayResults")
                .count()),
        "the same tools as chat except agent-session connector discovery and \
         chat's DisplayResults, which sessions replace with the harness's execution.views.present"
    );
}

/// Hosts without a composer cannot finish a deferred user tool, so their
/// toolsets must execute calendar creation directly and omit SendEmail
/// entirely — a `UserToolResponse` output there would mean a call that
/// nothing can ever execute.
#[test]
fn composerless_hosts_execute_calendar_create_directly_and_omit_send_email() {
    for host in [AiHost::ChannelBot, AiHost::Mcp] {
        let json = frontend_schemas_builder()
            .merge(&tools_for(host))
            .build()
            .to_json_pretty()
            .expect("host schemas serialize");
        let schemas: serde_json::Value = serde_json::from_str(&json).expect("valid schema json");
        let tools = schemas["tools"].as_array().expect("tools array");

        let create = tools
            .iter()
            .find(|tool| tool["name"] == "CreateCalendarEvent")
            .expect("composer-less toolset keeps CreateCalendarEvent");
        assert_eq!(create["output"], "ToolCalendarEvent", "{host:?}");

        assert!(
            !tools.iter().any(|tool| tool["name"] == "SendEmail"),
            "{host:?} toolset must not expose SendEmail"
        );
        // The confirmed twins are for the in-process agent's thread turns;
        // these hosts already create directly and keep their own policy.
        for name in ["SendConfirmedEmail", "CreateConfirmedCalendarEvent"] {
            assert!(
                !tools.iter().any(|tool| tool["name"] == name),
                "{host:?} toolset must not expose {name}"
            );
        }
    }
}

#[test]
fn no_tools_passes_schema_validation() {
    let _ = no_tools();
}

#[test]
fn search_toolset_passes_schema_validation() {
    let _ = search_toolset();
}

#[test]
fn frontend_schemas_build() {
    let json = all_tool_frontend_schemas().to_json_pretty().unwrap();
    let schemas: serde_json::Value = serde_json::from_str(&json).unwrap();
    let mut names = std::collections::HashSet::new();
    for tool in schemas["tools"].as_array().unwrap() {
        let name = tool["name"].as_str().unwrap();
        assert!(names.insert(name), "duplicate frontend tool: {name}");
    }
    assert!(names.contains("QueryDatabase"));
    assert!(names.contains("DiscoverConnectors"));
    // DisplayResults renders from the fold's decoded view, not a tool schema.
    for name in tools_for(AiHost::Chat).toolset.tools.keys() {
        if name == "DisplayResults" {
            assert!(
                !names.contains(name.as_str()),
                "DisplayResults has a frontend schema"
            );
            continue;
        }
        assert!(names.contains(name.as_str()), "missing chat tool: {name}");
    }
    for name in [
        "CreateDatabase",
        "CreateTable",
        "RenameDatabase",
        "RenameTable",
        "ReorderTables",
        "DeleteTable",
        "AddColumn",
        "AddColumnOptions",
        "RenameColumn",
        "ChangeColumnType",
        "DeleteColumn",
        "ReorderColumns",
    ] {
        assert!(
            !names.contains(name),
            "removed tool {name} must not be generated"
        );
    }
}

#[test]
fn frontend_schemas_distinguish_user_tool_response_types() {
    let json = all_tool_frontend_schemas()
        .to_json_pretty()
        .expect("frontend schemas serialize");
    let schemas: serde_json::Value = serde_json::from_str(&json).expect("valid schema json");
    let tools = schemas["tools"].as_array().expect("tools array");
    let output_for = |name: &str| {
        tools
            .iter()
            .find(|tool| tool["name"] == name)
            .and_then(|tool| tool["output"].as_str())
            .expect("tool output schema")
    };

    assert_eq!(
        output_for("CreateCalendarEvent"),
        "UserToolResponseForToolCalendarEvent"
    );
    assert_eq!(
        output_for("SendEmail"),
        "UserToolResponseForSendEmailResponse"
    );
}

/// The configure-agent system skill walks an agent through `ListAgents` and
/// `ConfigureAgent`; a host that reads the skill must be able to follow it.
#[test]
fn every_host_exposes_agent_configuration() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in ["ListAgents", "ConfigureAgent", "ConfigureBot"] {
            assert!(
                tools.toolset.tools.contains_key(name),
                "{host:?} missing {name}"
            );
        }
    }
}

#[test]
fn every_host_exposes_skill_discovery_and_reading() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in ["ListSkills", "SearchSkills", "ReadSkill"] {
            assert!(
                tools.toolset.tools.contains_key(name),
                "{host:?} missing {name}"
            );
        }
        assert!(
            tools.toolset.tools["SearchSkills"]
                .description
                .contains("ReadSkill"),
            "{host:?} missing skill reading instructions"
        );
    }
}

#[test]
fn hosts_with_tool_search_defer_all_but_the_core_tools() {
    for host in [AiHost::Chat, AiHost::AgentSession, AiHost::ChannelBot] {
        let tools = tools_for(host);
        let lazy = DeferredToolSet::new(tools.toolset.clone(), tools.deferred.clone());
        let sent: Vec<String> = lazy
            .request_schemas()
            .unwrap_or_default()
            .into_iter()
            .map(|schema| schema.name)
            .collect();
        let catalog: Vec<String> = lazy
            .searchable_catalog()
            .into_iter()
            .map(|tool| tool.name)
            .collect();
        let prompt = tools.prompt.to_string();

        for name in ["ReadContent", "ContentSearch", "LoadTools", "SearchTools"] {
            assert!(sent.contains(&name.to_string()), "{host:?} sends {name}");
        }
        for name in ["EditPresentation", "EditSpreadsheet", "QueryDatabase"] {
            assert!(!sent.contains(&name.to_string()), "{host:?} defers {name}");
            assert!(
                catalog.contains(&name.to_string()),
                "{host:?} catalogs {name}"
            );
            assert!(
                prompt.contains(&format!("\n- {name}: ")),
                "{host:?} lists {name} in the prompt"
            );
        }
        assert_eq!(
            sent.len() + catalog.len(),
            tools.toolset.tools.len(),
            "{host:?}: every tool is either sent or catalogued"
        );
    }
}

#[test]
fn the_mcp_host_defers_nothing() {
    let tools = tools_for(AiHost::Mcp);

    assert!(tools.deferred.is_empty());
    assert!(!tools.prompt.to_string().contains("LoadTools"));
}

/// Only an MCP client can PUT bytes to the upload URL, so the tool is not
/// offered to in-app hosts, which would call it and then have no way to use it.
#[test]
fn channel_media_uploads_are_mcp_only() {
    assert!(
        tools_for(AiHost::Mcp)
            .toolset
            .tools
            .contains_key("CreateChannelMediaUpload")
    );
    for host in [AiHost::Chat, AiHost::AgentSession, AiHost::ChannelBot] {
        assert!(
            !tools_for(host)
                .toolset
                .tools
                .contains_key("CreateChannelMediaUpload"),
            "{host:?}"
        );
    }
}

#[test]
fn every_eager_tool_exists() {
    let session = tools_for(AiHost::AgentSession);
    let chat = tools_for(AiHost::Chat);
    for name in EAGER_TOOLS {
        assert!(
            session.toolset.tools.contains_key(*name) || chat.toolset.tools.contains_key(*name),
            "{name} is not a tool"
        );
    }
}

#[test]
fn forms_are_discoverable_and_execute_directly_on_every_host() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in [
            "CreateForm",
            "ReadForm",
            "EditForm",
            "ListForms",
            "SetFormAccess",
        ] {
            assert!(tools.toolset.tools.contains_key(name), "{host:?}: {name}");
            if !matches!(host, AiHost::Mcp) {
                assert!(tools.prompt.to_string().contains(name), "{host:?}: {name}");
            }
        }
        assert!(!tools.toolset.user_tools.contains_key("SetFormAccess"));
    }
    let delegated = subagent_toolset();
    for name in ["CreateForm", "ReadForm", "EditForm", "ListForms"] {
        assert!(delegated.tools.contains_key(name));
    }
    assert!(!delegated.tools.contains_key("SetFormAccess"));
}

#[test]
fn booking_link_mutations_execute_without_a_review_on_every_host() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host).toolset;
        assert!(tools.tools.contains_key("ListBookingLinks"));
        for name in ["CreateBookingLink", "EditBookingLink"] {
            assert!(tools.tools.contains_key(name));
            assert!(!tools.user_tools.contains_key(name));
        }
    }
}

mod booking_links;

#[test]
fn booking_management_has_mcp_and_chat_parity() {
    let names = [
        "ReadBookingSettings",
        "UpdateBookingSettings",
        "ListBookings",
        "GetBookingInsights",
        "GetBookingRescheduleSlots",
        "ChangeBooking",
    ];
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        for name in names {
            assert!(
                tools.toolset.tools.contains_key(name),
                "{host:?} must expose {name}"
            );
        }
    }
}

#[test]
fn code_mode_manages_booking_links_through_the_sdk_instead_of_the_tools() {
    let standard = tools_for(AiHost::AgentSession);
    let direct = tools_for_agent_code_mode();
    for name in [
        "ReadBookingSettings",
        "UpdateBookingSettings",
        "ListBookings",
        "GetBookingInsights",
        "GetBookingRescheduleSlots",
        "ChangeBooking",
        "ListBookingLinks",
        "CreateBookingLink",
        "EditBookingLink",
    ] {
        assert!(standard.toolset.tools.contains_key(name), "{name}");
        assert!(!direct.toolset.tools.contains_key(name), "{name}");
        assert!(
            !direct.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
    }
}

#[test]
fn code_mode_retains_direct_lifecycles_and_hides_sdk_methods_from_lazy_discovery() {
    let standard = tools_for(AiHost::AgentSession);
    let direct = tools_for_agent_code_mode();
    let sdk = code_mode_tools();
    assert!(direct.toolset.tools.len() < standard.toolset.tools.len());
    // macro.search, macro.workspace and macro.chats replace the search tools.
    for name in [
        "ReadContent",
        "EditDocument",
        "NameSearch",
        "ListEntities",
        "ContentSearch",
        "DiscoverConnectors",
        "ConnectMcpServer",
    ] {
        assert!(standard.toolset.tools.contains_key(name), "{name}");
        assert!(sdk.tools.contains_key(name), "{name}");
        assert!(!direct.toolset.tools.contains_key(name), "{name}");
        assert!(!direct.deferred.iter().any(|t| t.name == name), "{name}");
    }
    for name in [
        "CreateDocument",
        "ListSkills",
        "SearchSkills",
        "ReadSkill",
        "EditSpreadsheet",
        "ReadCanvas",
        "RenderCanvas",
        "ApplyCanvasEdits",
        "EditCanvas",
        "Subagent",
        "SearchTools",
        "LoadTools",
        "BashCodeExecution",
        "TextEditorCodeExecution",
    ] {
        assert!(direct.toolset.tools.contains_key(name), "{name}");
    }
    for name in standard.toolset.user_tools.keys() {
        assert!(direct.toolset.user_tools.contains_key(name), "{name}");
        if matches!(name.as_str(), "SendEmail" | "CreateCalendarEvent") {
            assert!(!direct.toolset.tools.contains_key(name), "{name}");
            assert!(
                !direct.deferred.iter().any(|tool| tool.name == *name),
                "{name}"
            );
        } else {
            assert!(direct.toolset.tools.contains_key(name), "{name}");
        }
    }
    let standard_deferred =
        DeferredToolSet::new(standard.toolset.clone(), standard.deferred.clone());
    assert!(
        standard_deferred
            .request_schemas()
            .unwrap()
            .iter()
            .any(|schema| schema.name == "ListEntities")
    );
    let deferred = DeferredToolSet::new(direct.toolset.clone(), direct.deferred.clone());
    let eager = deferred.request_schemas().unwrap();
    for name in ["SendEmail", "CreateCalendarEvent"] {
        assert!(standard.toolset.tools.contains_key(name));
        assert!(sdk.tools.contains_key(name));
        assert!(!eager.iter().any(|tool| tool.name == name));
        assert!(deferred.routing_description(name).is_none());
    }
    let prompt = direct.prompt.to_string();
    assert!(!prompt.contains("the turn waits while the user"));
    assert!(!prompt.contains("you MUST use the `SendEmail` tool"));
    assert!(prompt.contains("Do not wait for the user to act on a saved review"));
    assert!(!prompt.contains("- ReadMetadata:"));
    let code_mode = prompt::code_mode::PROMPT.to_string();
    assert!(prompt.contains(&code_mode));
    assert!(!standard.prompt.to_string().contains(&code_mode));
    for host in [AiHost::Chat, AiHost::ChannelBot, AiHost::Mcp] {
        assert!(!tools_for(host).prompt.to_string().contains(&code_mode));
    }
}

#[test]
fn session_reader_is_available_to_every_conversation_host_and_mcp() {
    for host in [
        AiHost::Chat,
        AiHost::AgentSession,
        AiHost::ChannelBot,
        AiHost::Mcp,
    ] {
        let tools = tools_for(host);
        assert!(tools.toolset.tools.contains_key("ReadAgentSession"));
        assert!(
            !tools
                .deferred
                .iter()
                .any(|tool| tool.name == "ReadAgentSession")
        );
    }
    assert!(subagent_toolset().tools.contains_key("ReadAgentSession"));
}

#[test]
fn code_mode_hides_tools_the_sdk_replaces() {
    let standard = tools_for(AiHost::AgentSession);
    let code_mode = tools_for_agent_code_mode();
    let prompt = code_mode.prompt.to_string();
    for name in [
        "ReadAgentSession",
        "ManageAgentSession",
        "ReadAgentSessionSharing",
        "UpdateAgentSessionSharing",
        "ListDatabases",
        "DescribeDatabase",
        "QueryDatabase",
        "SaveDatabaseView",
        "DeleteDatabaseView",
        "CreateRoutine",
        "ListRoutines",
        "ReadRoutine",
        "UpdateRoutine",
        "RunRoutine",
        "DeleteRoutine",
        "ReadCalendarEvent",
        "AddSharedCalendarEvent",
        "GenerateImage",
        "DuplicateItem",
        "RenameItem",
    ] {
        assert!(standard.toolset.tools.contains_key(name), "{name}");
        assert!(!code_mode.toolset.tools.contains_key(name), "{name}");
        assert!(
            !code_mode.deferred.iter().any(|tool| tool.name == name),
            "{name}"
        );
    }
    assert!(prompt.contains("macro.agentSessions.byId()"));
    assert!(!code_mode.toolset.tools.contains_key("ReadChat"));
    assert!(!prompt.contains("ReadChat"));
}

#[test]
fn conversation_tools_only_advertise_new_sessions() {
    for tools in [
        tools_for(AiHost::Chat),
        tools_for(AiHost::AgentSession),
        tools_for(AiHost::ChannelBot),
        tools_for(AiHost::Mcp),
    ] {
        assert!(!tools.toolset.tools.contains_key("ReadChat"));
        assert!(!tools.prompt.to_string().contains("ReadChat"));
        for name in [
            "ReadAgentSession",
            "ReadAgentSessionSharing",
            "UpdateAgentSessionSharing",
            "CreateAgentSession",
            "ManageAgentSession",
        ] {
            assert!(tools.toolset.tools.contains_key(name), "missing {name}");
        }
        for schema in tools.toolset.request_schemas().unwrap() {
            let json = serde_json::to_string(&schema.schema).unwrap();
            if [
                "NameSearch",
                "ContentSearch",
                "ListEntities",
                "RenameItem",
                "MoveToTrash",
                "MoveToProject",
                "DuplicateItem",
                "UpdateSharing",
                "ShareWithChannel",
                "SetFavorite",
                "GetEntityProperties",
                "SetEntityProperty",
                "BulkSetEntityPropertyOptions",
                "ListNotifications",
            ]
            .contains(&schema.name.as_str())
            {
                assert!(
                    !json.contains("\"chat\""),
                    "{} advertises legacy chats",
                    schema.name
                );
                assert!(
                    !json.contains("\"chats\""),
                    "{} advertises legacy chat search",
                    schema.name
                );
                assert!(
                    !json.contains("\"ai_chat\""),
                    "{} advertises legacy chat listing",
                    schema.name
                );
            }
        }
    }
    assert!(!subagent_toolset().tools.contains_key("ReadChat"));
}

#[test]
fn unrouted_prompts_inline_the_sdk_area_guidance_and_routed_ones_leave_it_to_the_turn() {
    use agent_code_mode::domain::{GuideHost, inline_guides};
    let code = tools_for_agent_code_mode();
    let unrouted = code.prompt.to_string();
    let routed = code.routed_prompt.to_string();
    assert!(unrouted.contains(inline_guides(GuideHost::Code)));
    assert!(!routed.contains("How Macro databases work"));
    assert_eq!(
        unrouted.replacen(inline_guides(GuideHost::Code), "", 1),
        routed
    );
    for host in [AiHost::AgentSession, AiHost::Chat, AiHost::ChannelBot] {
        let tools = tools_for(host);
        let prompt = tools.prompt.to_string();
        assert!(
            prompt.contains(inline_guides(GuideHost::Direct)),
            "{host:?}"
        );
        assert!(prompt.contains("DispatchCodingAgent"), "{host:?}");
        assert_eq!(prompt, tools.routed_prompt.to_string(), "{host:?}");
    }
}