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 agent_runtime_protocol::domain::action::{AgentAction, AgentActionId};
use agent_session::domain::model::AgentSessionId;
use super::*;
fn prompt_entry(text: &str) -> QueuedEntry {
QueuedEntry {
action_id: AgentActionId::mint(),
action: AgentAction::prompt(text),
actor: None,
announce: None,
announced: None,
created_at: Utc::now(),
context: None,
}
}
fn prompt_text(action: &AgentAction) -> &str {
match action {
AgentAction::Prompt(prompt) => &prompt.prompt,
other => panic!("expected a prompt, got {other:?}"),
}
}
#[test]
fn entries_come_back_out_oldest_first() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let second = prompt_entry("second");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, second.clone()).unwrap();
assert_eq!(
queues
.list(session)
.iter()
.map(|entry| entry.action_id)
.collect::<Vec<_>>(),
[first.action_id, second.action_id]
);
assert_eq!(
queues.claim_next(session).unwrap().action_id,
first.action_id
);
assert_eq!(
queues.claim_next(session).unwrap().action_id,
second.action_id
);
assert!(queues.claim_next(session).is_none());
assert!(queues.list(session).is_empty());
}
#[test]
fn sessions_do_not_share_a_queue() {
let queues = SessionQueues::new();
queues
.enqueue(AgentSessionId::TEST_A, prompt_entry("a's work"))
.unwrap();
assert!(queues.claim_next(AgentSessionId::TEST_B).is_none());
assert!(queues.list(AgentSessionId::TEST_B).is_empty());
assert_eq!(queues.list(AgentSessionId::TEST_A).len(), 1);
}
#[test]
fn editing_replaces_the_text_and_keeps_the_place() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let second = prompt_entry("second");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, second.clone()).unwrap();
queues
.edit_prompt(session, first.action_id, "rewritten".to_owned(), None)
.unwrap();
let claimed = queues.claim_next(session).unwrap();
assert_eq!(claimed.action_id, first.action_id);
assert_eq!(prompt_text(&claimed.action), "rewritten");
}
#[test]
fn editing_reattributes_the_entry_to_the_editor() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let mut first = prompt_entry("first");
first.actor = Some(MacroUserIdStr::try_from_email("[email protected]").unwrap());
queues.enqueue(session, first.clone()).unwrap();
let editor = MacroUserIdStr::try_from_email("[email protected]").unwrap();
queues
.edit_prompt(
session,
first.action_id,
"rewritten".to_owned(),
Some(editor.clone()),
)
.unwrap();
let claimed = queues.claim_next(session).unwrap();
assert_eq!(claimed.actor.as_ref(), Some(&editor));
assert_eq!(prompt_text(&claimed.action), "rewritten");
}
#[test]
fn a_claimed_entry_is_gone_for_editing_and_removal() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let entry = prompt_entry("work");
queues.enqueue(session, entry.clone()).unwrap();
queues.claim_next(session).unwrap();
assert_eq!(
queues.edit_prompt(session, entry.action_id, "late".to_owned(), None),
Err(QueueError::NotFound)
);
assert_eq!(
queues.remove(session, entry.action_id),
Err(QueueError::NotFound)
);
}
#[test]
fn only_prompts_are_editable() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let compact = QueuedEntry {
action_id: AgentActionId::mint(),
action: AgentAction::Compact,
actor: None,
announce: None,
announced: None,
created_at: Utc::now(),
context: None,
};
queues.enqueue(session, compact.clone()).unwrap();
assert_eq!(
queues.edit_prompt(session, compact.action_id, "text".to_owned(), None),
Err(QueueError::NotEditable)
);
// Still removable.
queues.remove(session, compact.action_id).unwrap();
}
#[test]
fn removal_skips_the_removed_entry_at_dispatch() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let second = prompt_entry("second");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, second.clone()).unwrap();
queues.remove(session, first.action_id).unwrap();
assert_eq!(
queues.claim_next(session).unwrap().action_id,
second.action_id
);
}
#[test]
fn mark_announced_remembers_the_chip_on_the_waiting_entry() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let second = prompt_entry("second");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, second.clone()).unwrap();
let chip = Uuid::from_u128(0xc1);
queues
.mark_announced(session, second.action_id, chip)
.unwrap();
assert_eq!(queues.claim_next(session).unwrap().announced, None);
assert_eq!(queues.claim_next(session).unwrap().announced, Some(chip));
}
#[test]
fn a_requeued_entry_is_next_in_line() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let second = prompt_entry("second");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, second.clone()).unwrap();
let claimed = queues.claim_next(session).unwrap();
queues.requeue_front(session, claimed);
assert_eq!(
queues.claim_next(session).unwrap().action_id,
first.action_id
);
}
#[test]
fn move_to_front_promotes_a_waiting_entry_and_keeps_the_rest() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let first = prompt_entry("first");
let steered = prompt_entry("steer");
let third = prompt_entry("third");
queues.enqueue(session, first.clone()).unwrap();
queues.enqueue(session, steered.clone()).unwrap();
queues.enqueue(session, third.clone()).unwrap();
queues.move_to_front(session, steered.action_id).unwrap();
queues.move_to_front(session, steered.action_id).unwrap();
assert_eq!(
queues
.list(session)
.iter()
.map(|entry| entry.action_id)
.collect::<Vec<_>>(),
[steered.action_id, first.action_id, third.action_id]
);
assert_eq!(
queues.move_to_front(session, AgentActionId::mint()),
Err(QueueError::NotFound)
);
}
#[test]
fn enqueue_front_puts_the_entry_ahead_of_waiting_work() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
let waiting = prompt_entry("queued earlier");
let steer = prompt_entry("steer");
queues.enqueue(session, waiting.clone()).unwrap();
queues.enqueue_front(session, steer.clone()).unwrap();
assert_eq!(
queues
.list(session)
.iter()
.map(|entry| entry.action_id)
.collect::<Vec<_>>(),
[steer.action_id, waiting.action_id]
);
assert_eq!(
queues.claim_next(session).unwrap().action_id,
steer.action_id
);
assert_eq!(
queues.claim_next(session).unwrap().action_id,
waiting.action_id
);
}
#[test]
fn a_snapshot_round_trips_through_the_durable_shape() {
let session = AgentSessionId::TEST_A;
let mut entry = prompt_entry("keep me");
entry.announce = Some(AnnounceOrigin {
reply_placement: Default::default(),
reuse_origin_message: false,
parent: messages::domain::models::MessageParent::Channel(Uuid::from_u128(0xf0)),
thread_id: Uuid::from_u128(0xf1),
message_id: Uuid::from_u128(0xf2),
});
entry.announced = Some(Uuid::from_u128(0xf3));
let queues = SessionQueues::new();
queues.enqueue(session, entry.clone()).unwrap();
let stored = queues.snapshot(session)[0].to_stored().unwrap();
let restored = QueuedEntry::from_stored(stored).unwrap();
assert_eq!(restored.action_id, entry.action_id);
assert_eq!(prompt_text(&restored.action), "keep me");
assert_eq!(restored.announce, entry.announce);
assert_eq!(restored.announced, entry.announced);
let other = SessionQueues::new();
other.replace(session, vec![restored]);
assert_eq!(other.list(session).len(), 1);
assert_eq!(
prompt_text(&other.claim_next(session).unwrap().action),
"keep me"
);
}
#[test]
fn the_cap_refuses_the_overflowing_entry() {
let queues = SessionQueues::new();
let session = AgentSessionId::TEST_A;
for n in 0..QUEUE_CAP {
queues
.enqueue(session, prompt_entry(&format!("{n}")))
.unwrap();
}
assert_eq!(
queues.enqueue(session, prompt_entry("one too many")),
Err(QueueError::Full)
);
assert_eq!(
queues.enqueue_front(session, prompt_entry("nor at the front")),
Err(QueueError::Full)
);
}
/// Only a person's prompt typed into the session itself follows it. A thread
/// mention names its origin, a runtime-forwarded trigger names its context,
/// and system turns, bot turns and compaction act for nobody in particular.
#[test]
fn only_a_human_prompt_from_the_session_itself_has_a_direct_prompter() {
let person = MacroUserIdStr::try_from_email("[email protected]").unwrap();
let direct = QueuedEntry {
actor: Some(person.clone()),
..prompt_entry("from the session view")
};
assert_eq!(direct.direct_prompter(), Some(&person));
let thread_mention = QueuedEntry {
announce: Some(AnnounceOrigin {
reply_placement: Default::default(),
reuse_origin_message: false,
parent: messages::domain::models::MessageParent::Call(Uuid::from_u128(0xf0)),
thread_id: Uuid::from_u128(0xf1),
message_id: Uuid::from_u128(0xf2),
}),
..direct.clone()
};
let forwarded_trigger = QueuedEntry {
context: Some(TriggerContext::Requested(
trigger_context::RequestedContext {
requested_by: trigger_context::ContextPerson {
id: person.to_string(),
name: "Prompter".to_owned(),
email: None,
},
requested_at: Utc::now(),
repo_url: None,
},
)),
..direct.clone()
};
let system_turn = QueuedEntry {
action: AgentAction::notification(Vec::new()),
..direct.clone()
};
let bot_turn = QueuedEntry {
actor: None,
..direct.clone()
};
let compaction = QueuedEntry {
action: AgentAction::Compact,
..direct.clone()
};
for (name, entry) in [
("thread mention", thread_mention),
("forwarded trigger", forwarded_trigger),
("system turn", system_turn),
("bot turn", bot_turn),
("compaction", compaction),
] {
assert_eq!(entry.direct_prompter(), None, "{name}");
}
}