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 std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
use agent_client_protocol::schema::v1::{
SessionConfigOption, SessionConfigSelectOption, SessionConfigValueId,
};
use super::*;
fn caller() -> MacroUserIdStr<'static> {
MacroUserIdStr::try_from_email("[email protected]").unwrap()
}
fn options() -> Vec<SessionConfigOption> {
vec![SessionConfigOption::select(
"model",
"Model",
SessionConfigValueId::new("fast"),
vec![SessionConfigSelectOption::new("fast", "Fast")],
)]
}
struct Access(bool);
impl HarnessModelAccess for Access {
async fn can_use(
&self,
_caller: &MacroUserIdStr<'static>,
_harness: HarnessId,
) -> Result<bool, String> {
Ok(self.0)
}
}
struct Probe {
callers: std::sync::Mutex<Vec<MacroUserIdStr<'static>>>,
calls: AtomicUsize,
result: fn() -> Result<RawModelProbe, ModelProbeError>,
}
impl Probe {
fn new(result: fn() -> Result<RawModelProbe, ModelProbeError>) -> Self {
Self {
calls: AtomicUsize::new(0),
callers: std::sync::Mutex::new(Vec::new()),
result,
}
}
fn calls(&self) -> usize {
self.calls.load(Ordering::Relaxed)
}
}
impl InMemoryModelProbe for Probe {
async fn probe(
&self,
caller: &MacroUserIdStr<'static>,
) -> Result<RawModelProbe, ModelProbeError> {
self.callers.lock().unwrap().push(caller.clone());
self.calls.fetch_add(1, Ordering::Relaxed);
(self.result)()
}
}
impl CursorModelProbe for Probe {
async fn probe(
&self,
_caller: &MacroUserIdStr<'static>,
) -> Result<RawModelProbe, ModelProbeError> {
self.calls.fetch_add(1, Ordering::Relaxed);
(self.result)()
}
}
impl MacrodModelProbe for Probe {
async fn probe(&self, _harness: HarnessId) -> Result<RawModelProbe, ModelProbeError> {
self.calls.fetch_add(1, Ordering::Relaxed);
(self.result)()
}
}
fn available() -> Result<RawModelProbe, ModelProbeError> {
Ok(RawModelProbe::Options(options()))
}
fn unsupported() -> Result<RawModelProbe, ModelProbeError> {
Ok(RawModelProbe::Unsupported)
}
struct HangingCursor;
impl CursorModelProbe for HangingCursor {
async fn probe(
&self,
_caller: &MacroUserIdStr<'static>,
) -> Result<RawModelProbe, ModelProbeError> {
std::future::pending().await
}
}
#[tokio::test]
async fn macrod_authorizes_before_dispatch_and_projects_the_catalog() {
let in_memory = Probe::new(unsupported);
let cursor = Probe::new(unsupported);
let macrod = Probe::new(available);
let service = AgentModelsServiceImpl::new(
Access(true),
in_memory,
cursor,
macrod,
Duration::from_secs(1),
);
let result = service
.load(
caller(),
LoadAgentModels {
harness: ModelHarness::Macrod,
harness_id: Some(HarnessId::TEST_A),
},
)
.await
.unwrap();
assert_eq!(result.status, AgentModelsStatus::Available);
assert_eq!(result.current_model.as_deref(), Some("fast"));
assert_eq!(result.models[0].id, "fast");
assert_eq!(service.in_memory.calls(), 0);
assert_eq!(service.cursor.calls(), 0);
assert_eq!(service.macrod.calls(), 1);
}
#[tokio::test]
async fn invisible_macrod_is_forbidden_without_probing() {
let service = AgentModelsServiceImpl::new(
Access(false),
Probe::new(unsupported),
Probe::new(unsupported),
Probe::new(available),
Duration::from_secs(1),
);
let result = service
.load(
caller(),
LoadAgentModels {
harness: ModelHarness::Macrod,
harness_id: Some(HarnessId::TEST_A),
},
)
.await;
assert!(matches!(result, Err(LoadAgentModelsError::Forbidden)));
assert_eq!(service.macrod.calls(), 0);
}
#[tokio::test]
async fn unsupported_provider_returns_the_supported_response_shape() {
let service = AgentModelsServiceImpl::new(
Access(true),
Probe::new(unsupported),
Probe::new(available),
Probe::new(available),
Duration::from_secs(1),
);
let result = service
.load(
caller(),
LoadAgentModels {
harness: ModelHarness::InMemory,
harness_id: None,
},
)
.await
.unwrap();
assert_eq!(result, AgentModels::unsupported());
assert_eq!(service.in_memory.calls(), 1);
assert_eq!(*service.in_memory.callers.lock().unwrap(), vec![caller()]);
assert_eq!(service.cursor.calls(), 0);
}
#[tokio::test]
async fn cursor_probe_obeys_the_service_timeout() {
let service = AgentModelsServiceImpl::new(
Access(true),
Probe::new(unsupported),
HangingCursor,
Probe::new(unsupported),
Duration::from_millis(1),
);
let result = service
.load(
caller(),
LoadAgentModels {
harness: ModelHarness::Cursor,
harness_id: None,
},
)
.await;
assert!(matches!(result, Err(LoadAgentModelsError::Timeout)));
}