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 chrono::{DateTime, Utc};
use uuid::Uuid;
use crate::calendar_event::CalendarEventSearchScope;
use crate::call_record::CallRecordSearchResponseItemWithMetadata;
use crate::channel::{ChannelMessageSearchResponseItem, ChannelNameSearchResponseItem};
use crate::chat::ChatSearchResponseItemWithMetadata;
use crate::document::DocumentSearchResponseItemWithMetadata;
use crate::email::EmailSearchResponseItemWithMetadata;
use crate::project::ProjectSearchResponseItemWithMetadata;
use crate::{
MatchType, SearchOn, call_record::SimpleCallRecordSearchResponseBaseItem,
channel::SimpleChannelSearchReponseBaseItem, chat::SimpleChatSearchResponseBaseItem,
document::SimpleDocumentSearchResponseBaseItem, email::SimpleEmailSearchResponseBaseItem,
project::SimpleProjectSearchResponseBaseItem,
};
use item_filters::{
CalendarEventFilters, CallFilters, ChannelFilters, ChatFilters, DocumentFilters, EmailFilters,
EntityFilters, ProjectFilters, ast::document::resolve_file_types,
};
use model_file_type::{FileAssociation, FileType};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
#[derive(Debug, Serialize, Deserialize, Clone, ToSchema, JsonSchema, Eq, PartialEq, Hash)]
#[serde(rename_all = "lowercase")]
pub enum UnifiedSearchIndex {
#[serde(rename = "agent_sessions")]
AgentSessions,
Documents,
Chats,
Emails,
Channels,
Projects,
#[serde(rename = "call_records")]
CallRecords,
#[serde(rename = "calendar_events")]
CalendarEvents,
}
const NIL_UUID: &str = "00000000-0000-0000-0000-000000000000";
/// Build an [EntityFilters] from a list of [UnifiedSearchIndex] to include.
/// Entity types not in the list are excluded via NIL UUID.
/// If the list is empty, all entity types are included.
pub fn entity_filters_from_include(
include: Vec<UnifiedSearchIndex>,
base: EntityFilters,
) -> EntityFilters {
let mut filters = base;
if include.is_empty() {
filters.agent_session_filters.include = true;
return filters;
}
let exclude = vec![NIL_UUID.to_string()];
if include.contains(&UnifiedSearchIndex::AgentSessions) {
filters.agent_session_filters.include = true;
} else {
filters.agent_session_filters.ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::Documents) {
filters.document_filters.document_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::Chats) {
filters.chat_filters.chat_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::Emails) {
filters.email_filters.email_thread_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::Channels) {
filters.channel_filters.channel_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::Projects) {
filters.project_filters.project_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::CallRecords) {
filters.call_filters.channel_ids = exclude.clone();
}
if !include.contains(&UnifiedSearchIndex::CalendarEvents) {
filters.calendar_event_filters.calendar_event_ids = exclude;
}
filters
}
// TODO: query, match_type are common to all requests. consolidate.
#[derive(Debug, Serialize, Deserialize, ToSchema, Clone, JsonSchema)]
pub struct UnifiedSearchRequest {
/// The search query string. Must be at least 3 characters.
pub query: String,
/// How to match the search terms. 'exact' for precise case-sensitive phrase matches, 'partial' for prefix/partial matches. REQUIRED field.
pub match_type: MatchType,
/// Entity filters in the same shape as soup. Entity types with a NIL UUID in their primary ID field are excluded from search.
#[serde(default)]
pub filters: EntityFilters,
/// Fields to search on (Name, Content, NameContent). Defaults to Content
#[serde(default)]
pub search_on: SearchOn,
/// Opt in to searching the caller's team CRM companies (name/domain).
/// Off by default: CRM results are only included when this is true and
/// the caller has a qualifying team membership. CRM has no content
/// index, so it is searched only under Name / NameContent.
#[serde(default)]
pub include_crm: bool,
/// Which calendar events to search. Defaults to `own`: events on the
/// caller's own and delegated calendars. `shared_with_you` searches only
/// events shared with a channel the caller belongs to that are on none of
/// their calendars.
#[serde(default)]
pub calendar_event_scope: CalendarEventSearchScope,
#[schemars(skip)]
pub collapse: Option<bool>,
}
/// Whether a [FileAssociation] is indexed by the search processing service.
pub fn is_searchable_association(assoc: &FileAssociation) -> bool {
matches!(
assoc,
FileAssociation::Pdf(_)
| FileAssociation::Write(_)
| FileAssociation::Code(_)
| FileAssociation::Canvas(_)
| FileAssociation::Md(_)
)
}
/// Whether documents of a file type have their content indexed by the search
/// processing service: the searchable associations, and the design files the
/// native engines read - Figma designs, Photoshop documents, and Illustrator
/// documents - while other vector files are not.
pub fn is_searchable_file_type(file_type: &FileType) -> bool {
matches!(
file_type,
FileType::Fig | FileType::Psd | FileType::Psb | FileType::Ai
) || is_searchable_association(&file_type.macro_app_path())
}
/// Converted entity filters for the search service.
/// Determines which entity types to include based on NIL UUID exclusion
/// and expands file association prefixes (e.g. `assoc:code`) to concrete extensions.
#[derive(Debug, Clone)]
pub struct SearchEntityFilters {
/// Whether to include folded agent sessions.
pub should_include_agent_sessions: bool,
/// Agent-session filters.
pub agent_session_filters: item_filters::AgentSessionFilters,
/// Whether to include documents in search results
pub should_include_documents: bool,
/// Whether to include chats in search results
pub should_include_chats: bool,
/// Whether to include emails in search results
pub should_include_emails: bool,
/// Whether to include channels in search results
pub should_include_channels: bool,
/// Whether to include projects in search results
pub should_include_projects: bool,
/// Whether to include call records in search results
pub should_include_call_records: bool,
/// Whether to include calendar events in search results
pub should_include_calendar_events: bool,
/// Document filters with file associations expanded
pub document_filters: DocumentFilters,
/// Chat filters
pub chat_filters: ChatFilters,
/// Email filters
pub email_filters: EmailFilters,
/// Channel filters
pub channel_filters: ChannelFilters,
/// Project filters
pub project_filters: ProjectFilters,
/// Call filters
pub call_filters: CallFilters,
/// Calendar event filters
pub calendar_event_filters: CalendarEventFilters,
}
fn contains_nil_uuid(ids: &[String]) -> bool {
ids.iter().any(|id| id == NIL_UUID)
}
fn strip_nil_uuids(ids: &mut Vec<String>) {
ids.retain(|id| id != NIL_UUID);
}
/// Resolve file type strings to concrete extensions for search, dropping
/// non-searchable types. Handles both plain extensions (`"md"`) and `assoc:*`
/// prefixes (`"assoc:code"`).
fn expand_file_types_for_search(file_types: Vec<String>) -> Vec<String> {
file_types
.iter()
.flat_map(|ft| resolve_file_types(ft))
.filter(is_searchable_file_type)
.map(|ty| ty.as_str().to_string())
.collect()
}
impl From<EntityFilters> for SearchEntityFilters {
fn from(filters: EntityFilters) -> Self {
let mut agent_session_filters = filters.agent_session_filters;
let should_include_agent_sessions = (agent_session_filters.include
|| !agent_session_filters.ids.is_empty()
|| !agent_session_filters.owners.is_empty())
&& !contains_nil_uuid(&agent_session_filters.ids);
strip_nil_uuids(&mut agent_session_filters.ids);
let mut document_filters = filters.document_filters;
let mut chat_filters = filters.chat_filters;
let mut email_filters = filters.email_filters;
let mut channel_filters = filters.channel_filters;
let mut project_filters = filters.project_filters;
let mut call_filters = filters.call_filters;
let mut calendar_event_filters = filters.calendar_event_filters;
let should_include_documents = !contains_nil_uuid(&document_filters.document_ids);
let should_include_chats = !contains_nil_uuid(&chat_filters.chat_ids);
let should_include_emails = !contains_nil_uuid(&email_filters.email_thread_ids);
let should_include_channels = !contains_nil_uuid(&channel_filters.channel_ids);
let should_include_projects = !contains_nil_uuid(&project_filters.project_ids);
let should_include_call_records = !contains_nil_uuid(&call_filters.channel_ids);
let should_include_calendar_events =
!contains_nil_uuid(&calendar_event_filters.calendar_event_ids);
strip_nil_uuids(&mut document_filters.document_ids);
strip_nil_uuids(&mut chat_filters.chat_ids);
strip_nil_uuids(&mut email_filters.email_thread_ids);
strip_nil_uuids(&mut email_filters.recipients);
strip_nil_uuids(&mut channel_filters.channel_ids);
strip_nil_uuids(&mut project_filters.project_ids);
strip_nil_uuids(&mut call_filters.channel_ids);
strip_nil_uuids(&mut calendar_event_filters.calendar_event_ids);
document_filters.file_types = expand_file_types_for_search(document_filters.file_types);
Self {
should_include_agent_sessions,
agent_session_filters,
should_include_documents,
should_include_chats,
should_include_emails,
should_include_channels,
should_include_projects,
should_include_call_records,
should_include_calendar_events,
document_filters,
chat_filters,
email_filters,
channel_filters,
project_filters,
call_filters,
calendar_event_filters,
}
}
}
#[derive(Debug, Serialize, Deserialize, ToSchema, JsonSchema)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum UnifiedSearchResponseItem {
Document(DocumentSearchResponseItemWithMetadata),
Chat(ChatSearchResponseItemWithMetadata),
Email(EmailSearchResponseItemWithMetadata),
ChannelMessage(ChannelMessageSearchResponseItem),
Channel(ChannelNameSearchResponseItem),
Project(ProjectSearchResponseItemWithMetadata),
Call(CallRecordSearchResponseItemWithMetadata),
Company(crate::crm_company::CrmCompanySearchResponseItem),
CalendarEvent(crate::calendar_event::CalendarEventSearchResponseItemWithMetadata),
AgentSession(crate::agent_session::AgentSessionSearchResponseItem),
}
impl UnifiedSearchResponseItem {
pub fn entity_id(&self) -> Uuid {
match self {
Self::AgentSession(item) => item.id,
Self::Document(item) => item.extra.id,
Self::Chat(item) => item.extra.id,
Self::Email(item) => item.extra.id,
Self::ChannelMessage(item) => item.channel_id,
Self::Channel(item) => item.channel_id,
Self::Project(item) => item.extra.id,
Self::Call(item) => item.extra.id,
Self::Company(item) => item.id,
Self::CalendarEvent(item) => item.extra.id,
}
}
/// Get the updated_at timestamp for each item
pub fn updated_at(&self) -> Option<DateTime<Utc>> {
match self {
Self::AgentSession(item) => Some(item.updated_at),
Self::Document(item) => item.metadata.as_ref().map(|m| m.updated_at),
Self::Chat(item) => item.metadata.as_ref().map(|m| m.updated_at),
Self::Email(item) => Some(item.updated_at),
Self::ChannelMessage(item) => Some(item.updated_at),
Self::Channel(item) => item.metadata.as_ref().map(|metadata| metadata.updated_at),
Self::Project(item) => item.metadata.as_ref().map(|m| m.updated_at),
Self::Call(item) => item.metadata.as_ref().map(|m| m.updated_at),
Self::Company(item) => Some(item.updated_at),
Self::CalendarEvent(item) => item.metadata.as_ref().map(|m| m.updated_at),
}
}
}
#[derive(Debug, Serialize, Deserialize, ToSchema, Default)]
pub struct UnifiedSearchResponse {
/// The search results
pub results: Vec<UnifiedSearchResponseItem>,
/// The next cursor to use for paginating results
pub next_cursor: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, ToSchema, JsonSchema)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum SimpleUnifiedSearchResponseBaseItem<T> {
Document(SimpleDocumentSearchResponseBaseItem<T>),
Chat(SimpleChatSearchResponseBaseItem<T>),
Email(SimpleEmailSearchResponseBaseItem<T>),
Channel(SimpleChannelSearchReponseBaseItem<T>),
Project(SimpleProjectSearchResponseBaseItem<T>),
Call(SimpleCallRecordSearchResponseBaseItem<T>),
CalendarEvent(crate::calendar_event::SimpleCalendarEventSearchResponseBaseItem<T>),
}
pub type SimpleUnifiedSearchResponseItem =
SimpleUnifiedSearchResponseBaseItem<crate::HumanReadableTimestamp>;
#[derive(Debug, Serialize, Deserialize, ToSchema, Default)]
pub struct SimpleUnifiedSearchBaseResponse<T> {
pub results: Vec<SimpleUnifiedSearchResponseBaseItem<T>>,
}
pub type SimpleUnifiedSearchResponse =
SimpleUnifiedSearchBaseResponse<crate::HumanReadableTimestamp>;
#[cfg(test)]
mod test;