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::api::context::ApiContext;
use axum::Router;
use axum::extract::DefaultBodyLimit;
use axum::routing::post;
use context::GLOBAL_CONTEXT;
use model::version::{ServiceNameState, VersionedApiServiceName, validate_api_version};
use tower::ServiceBuilder;
use tower_http::limit::RequestBodyLimitLayer;
use utoipa::OpenApi;
use utoipa_swagger_ui::SwaggerUi;
// Utilities
mod citations;
mod completions;
mod confirmed_actions;
pub mod context;
mod decisions;
mod health;
mod id_mapping;
mod preview;
pub mod stream;
pub(crate) mod swagger;
pub mod utils;
mod attachments;
mod chats;
mod database_query;
pub mod structured_completion;
pub(crate) mod tool_selection;
#[cfg(test)]
mod test;
const GATEWAY_PATH_PREFIX: &str = "/cognition";
/// Build the cognition API on the harness listener, preserving its gateway prefix.
pub fn build_router(state: ApiContext) -> Router {
if GLOBAL_CONTEXT.set(state.clone()).is_err() {
panic!("GLOBAL_CONTEXT is set already")
}
let routes = api_router(state)
.merge(health::router())
.layer(macro_cors::cors_layer())
.layer(DefaultBodyLimit::disable())
.layer(RequestBodyLimitLayer::new(1024 * 1024 * 1024))
.layer(
ServiceBuilder::new()
.layer(
macro_tower_layers::MacroRequestIdAndTracingLayer::new(
std::time::Duration::from_millis(200),
)
.into_inner(),
)
.layer(axum::middleware::from_fn_with_state(
ServiceNameState {
service_name: VersionedApiServiceName::DocumentCognitionService,
},
validate_api_version,
)),
);
mount_router(routes)
}
fn mount_router(routes: Router) -> Router {
Router::new().nest(GATEWAY_PATH_PREFIX, routes).merge(
SwaggerUi::new("/cognition/docs")
.url("/cognition/api-doc/openapi.json", prefixed_openapi()),
)
}
fn prefixed_openapi() -> utoipa::openapi::OpenApi {
let mut openapi = swagger::ApiDoc::openapi();
openapi.servers = Some(vec![utoipa::openapi::Server::new(GATEWAY_PATH_PREFIX)]);
openapi
}
fn api_router(api_context: ApiContext) -> Router {
let memory_service = api_context.memory_service.clone();
let usage_service = api_context.usage_service.clone();
let ai_projections_service = api_context.ai_projections_service.clone();
let import_service = api_context.import_service.clone();
let onboarding_service = api_context.onboarding_service.clone();
let authorization_state = api_context.authorization_state.clone();
let mcp_state = api_context.mcp_state.clone();
let image_generation_state =
image_generation::inbound::axum_router::ImageGenerationRouterState {
service: std::sync::Arc::new(
image_generation::domain::service::AdmittedImageGenerationService::new(
api_context
.tool_service_context
.image_generation_tool_context
.service
.clone(),
api_context.ai_admission.clone(),
),
),
authorization_state: authorization_state.clone(),
non_user_owners: api_context.non_user_owners,
};
let web_state = web_search::inbound::axum_router::WebRouterState::new(
std::sync::Arc::new(web_search::domain::service::WebSearchService::new(
api_context.tool_service_context.web_search_provider.clone(),
api_context.ai_admission.clone(),
api_context.tool_service_context.recorder.clone(),
)),
api_context.web_rate_limiter.clone(),
authorization_state.clone(),
);
let internal_router = Router::new()
.nest("/chats", chats::router(api_context.clone()))
.nest("/stream", stream::router())
.route(
"/structured-completion",
post(structured_completion::structured_completion),
)
.route("/decisions", decisions::route())
.route(
"/email/send-confirmed",
post(confirmed_actions::send_confirmed_email),
)
.route(
"/calendar/events/create-confirmed",
post(confirmed_actions::create_confirmed_calendar_event),
)
.route("/chat/completions", post(completions::handler))
.route(
"/database-query",
post(database_query::generate_database_query),
)
.nest("/attachments", attachments::router())
.nest("/citations", citations::router())
.nest("/preview", preview::router())
.nest("/id_mapping", id_mapping::router())
.merge(memory::inbound::axum_router::memory_router(
memory::inbound::axum_router::MemoryRouterState {
service: memory_service,
authorization_state: authorization_state.clone(),
},
))
.merge(import::inbound::axum_router::import_router(
import::inbound::axum_router::ImportRouterState {
service: import_service,
authorization_state: authorization_state.clone(),
},
))
.merge(onboarding::inbound::axum_router::onboarding_router(
onboarding::inbound::axum_router::OnboardingRouterState {
service: onboarding_service,
authorization_state: authorization_state.clone(),
},
))
.merge(ai_usage::inbound::ai_usage_router(
ai_usage::inbound::AiUsageRouterState {
service: usage_service,
authorization_state: authorization_state.clone(),
},
))
.merge(ai_projections::inbound::axum_router::ai_projections_router(
ai_projections::inbound::axum_router::AiProjectionRouterState {
service: ai_projections_service,
authorization_state,
},
))
.merge(
image_generation::inbound::axum_router::image_generation_router(image_generation_state),
)
.merge(web_search::inbound::axum_router::web_router(web_state))
.merge(mcp_client::inbound::mcp_router(mcp_state.clone()))
.merge(pipedream_mcp::inbound::pipedream_mcp_router(
api_context.pipedream_state.clone(),
))
.with_state(api_context.clone());
// Pipedream calls this one itself, so it sits outside the authenticated
// router and is guarded by the secret baked into the configured
// `webhook_uri`. If the secret is unset, the route is not mounted.
let app = Router::new()
.nest("/{version}", internal_router.clone())
.merge(internal_router)
.merge(mcp_client::inbound::mcp_oauth_callback_router(mcp_state))
.merge(granola_sync::inbound::webhook_router(
api_context.granola_sync.clone(),
))
// Macro Connect's consent finishes on this page; it records nothing.
.merge(pipedream_mcp::inbound::pipedream_connect_callback_router());
match api_context.config.pipedream_webhook_secret.value() {
Some(secret) => app.merge(pipedream_mcp::inbound::pipedream_webhook_router(
secret.to_owned(),
)),
None => app,
}
}