Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use crate::cognition::model::stream::ToolSet;
use ai_tools::{AiToolSet, ToolMcpSelector, ToolServiceContext};
use macro_user_id::user_id::MacroUserIdStr;
use mcp_select::ConnectorSelect;
use std::sync::{Arc, LazyLock};
#[cfg(test)]
mod test;
/// The tools this service runs for a turn, as one dispatchable set.
pub(crate) type SelectedTools<Context> = Arc<dyn ai_toolset::ToolSet<Context> + Send + Sync>;
/// Database-only agent instructions: the base prompt and how Macro databases
/// work, from `DatabaseNamespace`'s `@agent` guidance.
static DATABASE_TOOL_USE_PROMPT: LazyLock<String> = LazyLock::new(|| {
format!(
"{}# Macro databases\n{}\n",
prompt::BASE_PROMPT,
agent_code_mode::domain::entity_guide("databases").unwrap_or_default()
)
});
/// The system prompt that describes the tools `selection` grants.
pub(crate) fn choose_tools_prompt<'a>(
selection: &ToolSet,
all_tools_prompt: &'a (dyn std::fmt::Display + Sync),
) -> &'a (dyn std::fmt::Display + Sync) {
match selection {
ToolSet::All => all_tools_prompt,
ToolSet::None => &prompt::BASE_PROMPT,
ToolSet::DatabasesReadOnly => &prompt::DATABASE_READ_ONLY_TOOL_USE_PROMPT,
ToolSet::Databases => &*DATABASE_TOOL_USE_PROMPT,
}
}
/// Keep the database dialect and parameter reference in both discovery and
/// formatting. Tool descriptions come from the registered schemas, so frontend
/// callers cannot drift onto a second, obsolete copy of the SQL grammar.
pub(crate) fn structured_completion_prompt(
selection: &ToolSet,
all_tools_prompt: &(dyn std::fmt::Display + Sync),
additional_instructions: Option<&str>,
schemas: &[ai_toolset::RequestSchema],
) -> String {
let mut prompt = choose_tools_prompt(selection, all_tools_prompt).to_string();
if matches!(selection, ToolSet::Databases | ToolSet::DatabasesReadOnly) {
prompt.push_str("\n## Registered database tools\nThese are the available tools and their authoritative reference. Read-only host restrictions override any write examples in a shared tool description.\n");
for tool in schemas {
prompt.push_str(&format!(
"\n### {}\n{:#}\n",
tool.name,
tool.schema.as_value()
));
}
}
if let Some(instructions) = additional_instructions {
prompt.push('\n');
prompt.push_str(instructions);
}
prompt
}
/// The service's tools for `selection`: a database toolset, or every static
/// tool plus the user's connectors.
pub(crate) async fn service_tools(
selection: &ToolSet,
static_tools: Arc<AiToolSet>,
mcp_selector: &ToolMcpSelector,
user_id: &MacroUserIdStr<'static>,
) -> SelectedTools<ToolServiceContext> {
select_tools(
selection,
async {
let tools: SelectedTools<ToolServiceContext> = Arc::new(ai_tools::database_tools());
tools
},
async {
let tools: SelectedTools<ToolServiceContext> =
Arc::new(ai_tools::database_read_only_tools());
tools
},
async {
let mcp_tools = mcp_selector.user_toolset(user_id).await;
let tools: SelectedTools<ToolServiceContext> =
Arc::new(mcp_select::CombinedToolSet::new(static_tools, mcp_tools));
tools
},
)
.await
}
/// Select actual capabilities before polling discovery. Restricting the prompt
/// alone does not remove tools, and scoped requests must not load connectors.
pub(crate) async fn select_tools<Context: Send + Sync + 'static>(
selection: &ToolSet,
database_tools: impl Future<Output = SelectedTools<Context>>,
database_read_only_tools: impl Future<Output = SelectedTools<Context>>,
all_tools: impl Future<Output = SelectedTools<Context>>,
) -> SelectedTools<Context> {
match selection {
ToolSet::None => Arc::new(ai_toolset::AsyncToolCollection::new()),
ToolSet::Databases => database_tools.await,
ToolSet::DatabasesReadOnly => database_read_only_tools.await,
ToolSet::All => all_tools.await,
}
}