mirror of
https://github.com/tinyhumansai/openhuman.git
synced 2026-07-27 21:08:00 +00:00
593 lines
24 KiB
Rust
593 lines
24 KiB
Rust
//! End-to-end scenario simulation for the subconscious **trigger pipeline**.
|
|
//!
|
|
//! This exercises the real public pipeline functions wired together —
|
|
//! `normalize` → `TriggerRegistry::admit` (dedupe + rate) → gate mapping
|
|
//! (`map_triage_to_gate` + `apply_budget`) → `OrchestratorQueue` — across
|
|
//! every trigger source and gate outcome, plus the real `notify_user`
|
|
//! handoff (event bus + reserved-thread persistence) and the reserved-thread
|
|
//! cold-boot contract the long-lived session depends on.
|
|
//!
|
|
//! It is hermetic (no network, no model) and deterministic: the LLM gate is
|
|
//! simulated by feeding the real `map_triage_to_gate` a `TriageDecision` for
|
|
//! each `TriageAction`, so we test *our* promote/drop/dedupe/budget/queue
|
|
//! logic exhaustively. The actual triage model call and the full agent turn
|
|
//! run through the native bus + global provider and are covered by the
|
|
//! `agent::triage` and agent-harness test suites.
|
|
//!
|
|
//! Run with a visible trace:
|
|
//! `cargo test --test subconscious_triggers_e2e -- --nocapture`
|
|
|
|
use std::sync::{Arc, Mutex as StdMutex, OnceLock};
|
|
|
|
use openhuman_core::core::event_bus::{global, init_global, DomainEvent};
|
|
use openhuman_core::openhuman::agent::triage::{TriageAction, TriageDecision};
|
|
use openhuman_core::openhuman::subconscious::{
|
|
notify_user, ORCHESTRATOR_THREAD_ID, USER_THREAD_ID,
|
|
};
|
|
use openhuman_core::openhuman::subconscious_triggers::gate::{apply_budget, map_triage_to_gate};
|
|
use openhuman_core::openhuman::subconscious_triggers::{
|
|
normalize, AdmitOutcome, DedupeWindow, EnqueueOutcome, GateDecision, OrchestratorQueue,
|
|
PromotionBudget, RateLimiter, Trigger, TriggerPriority, TriggerRegistry, TriggerSource,
|
|
};
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Event constructors for the four v1 trigger sources.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
fn cron_event(job_id: &str, name: &str) -> DomainEvent {
|
|
DomainEvent::CronJobTriggered {
|
|
job_id: job_id.into(),
|
|
job_name: name.into(),
|
|
job_type: "agent".into(),
|
|
}
|
|
}
|
|
|
|
fn user_event(channel: &str, sender: Option<&str>, message: &str) -> DomainEvent {
|
|
DomainEvent::ChannelInboundMessage {
|
|
event_name: "msg".into(),
|
|
channel: channel.into(),
|
|
message: message.into(),
|
|
sender: sender.map(str::to_string),
|
|
reply_target: Some("dm".into()),
|
|
thread_ts: Some("t1".into()),
|
|
raw_data: serde_json::Value::Null,
|
|
}
|
|
}
|
|
|
|
fn composio_event(metadata_id: &str, subject: &str) -> DomainEvent {
|
|
DomainEvent::ComposioTriggerReceived {
|
|
toolkit: "gmail".into(),
|
|
trigger: "GMAIL_NEW_GMAIL_MESSAGE".into(),
|
|
metadata_id: metadata_id.into(),
|
|
metadata_uuid: format!("{metadata_id}-uuid"),
|
|
payload: serde_json::json!({ "subject": subject, "body": "PRIVATE BODY" }),
|
|
}
|
|
}
|
|
|
|
fn subagent_done_event(task_id: &str, agent_id: &str) -> DomainEvent {
|
|
DomainEvent::SubagentCompleted {
|
|
parent_session: "subconscious:orchestrator".into(),
|
|
task_id: task_id.into(),
|
|
agent_id: agent_id.into(),
|
|
elapsed_ms: 10,
|
|
output_chars: 100,
|
|
iterations: 2,
|
|
}
|
|
}
|
|
|
|
fn triage(action: TriageAction, prompt: Option<&str>) -> TriageDecision {
|
|
TriageDecision {
|
|
action,
|
|
target_agent: prompt.map(|_| "orchestrator".into()),
|
|
prompt: prompt.map(str::to_string),
|
|
reason: "simulated gate verdict".into(),
|
|
}
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 1 — normalization: every source maps with the right shape.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn scenario_normalization_covers_all_sources() {
|
|
let now = 100.0;
|
|
|
|
let cron = normalize(&cron_event("j1", "morning brief"), now).expect("cron normalizes");
|
|
assert_eq!(cron.priority, TriggerPriority::Low);
|
|
assert!(!cron.external_content);
|
|
assert!(matches!(cron.source, TriggerSource::Cron { .. }));
|
|
|
|
let user = normalize(&user_event("slack", Some("U1"), "what's on my plate?"), now)
|
|
.expect("user normalizes");
|
|
assert_eq!(user.priority, TriggerPriority::High);
|
|
assert!(
|
|
user.external_content,
|
|
"inbound channel messages are untrusted"
|
|
);
|
|
assert!(user.payload.gate_summary.contains("what's on my plate"));
|
|
|
|
let composio =
|
|
normalize(&composio_event("evt-1", "Invoice #42"), now).expect("composio normalizes");
|
|
assert_eq!(composio.priority, TriggerPriority::Normal);
|
|
assert!(composio.external_content, "third-party content is tainted");
|
|
// Redaction: the private body never reaches the gate summary.
|
|
assert!(!composio.payload.gate_summary.contains("PRIVATE BODY"));
|
|
// …but is retained in raw for promotion synthesis.
|
|
assert_eq!(composio.payload.raw["payload"]["body"], "PRIVATE BODY");
|
|
|
|
let subagent =
|
|
normalize(&subagent_done_event("task-1", "researcher"), now).expect("subagent normalizes");
|
|
assert!(matches!(
|
|
subagent.source,
|
|
TriggerSource::SubagentConclusion { ok: true, .. }
|
|
));
|
|
|
|
// A self-authored proactive message must NOT become a trigger (anti-loop).
|
|
assert!(
|
|
normalize(&user_event("slack", Some("subconscious"), "proactive"), now).is_none(),
|
|
"orchestrator's own output must not re-trigger it"
|
|
);
|
|
|
|
// Unrelated events are ignored.
|
|
assert!(normalize(
|
|
&DomainEvent::ChannelConnected {
|
|
channel: "slack".into()
|
|
},
|
|
now
|
|
)
|
|
.is_none());
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 2 — admission: dedupe collapses storms, rate limits floods.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn scenario_dedupe_collapses_webhook_storm() {
|
|
let reg = TriggerRegistry::with_defaults();
|
|
// 50 identical Gmail webhooks (same metadata_id) within the TTL window.
|
|
let mut admitted = 0;
|
|
let mut duplicates = 0;
|
|
for i in 0..50 {
|
|
let ev = composio_event("same-evt", "dup");
|
|
let t = normalize(&ev, 1000.0 + i as f64 * 0.01).expect("normalize");
|
|
match reg.admit(&t, 1000.0 + i as f64 * 0.01) {
|
|
AdmitOutcome::Admitted => admitted += 1,
|
|
AdmitOutcome::Duplicate => duplicates += 1,
|
|
AdmitOutcome::RateLimited => {}
|
|
}
|
|
}
|
|
assert_eq!(admitted, 1, "only the first of the storm is admitted");
|
|
assert_eq!(duplicates, 49);
|
|
}
|
|
|
|
#[test]
|
|
fn scenario_rate_limit_caps_distinct_events_per_source() {
|
|
// Tiny bucket: capacity 2, no refill, so the 3rd distinct event of the
|
|
// same family is rate-limited even though it passes dedupe.
|
|
let reg = TriggerRegistry::new(DedupeWindow::new(600.0), RateLimiter::new(2.0, 0.0));
|
|
let outcomes: Vec<AdmitOutcome> = (0..3)
|
|
.map(|i| {
|
|
let ev = composio_event(&format!("evt-{i}"), "x");
|
|
let t = normalize(&ev, 5.0).expect("normalize");
|
|
reg.admit(&t, 5.0)
|
|
})
|
|
.collect();
|
|
assert_eq!(outcomes[0], AdmitOutcome::Admitted);
|
|
assert_eq!(outcomes[1], AdmitOutcome::Admitted);
|
|
assert_eq!(outcomes[2], AdmitOutcome::RateLimited);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 3 — gate decisions: every triage action maps correctly.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn scenario_gate_maps_every_triage_action() {
|
|
let now = 0.0;
|
|
let budget = PromotionBudget::new(100);
|
|
let base = normalize(&composio_event("g1", "subj"), now).expect("normalize");
|
|
|
|
// Drop → dropped, not acknowledged.
|
|
let d = apply_budget(
|
|
map_triage_to_gate(&triage(TriageAction::Drop, None), &base),
|
|
&budget,
|
|
now,
|
|
);
|
|
assert!(matches!(
|
|
d,
|
|
GateDecision::Drop {
|
|
acknowledge: false,
|
|
..
|
|
}
|
|
));
|
|
|
|
// Acknowledge → dropped but acknowledged.
|
|
let a = apply_budget(
|
|
map_triage_to_gate(&triage(TriageAction::Acknowledge, None), &base),
|
|
&budget,
|
|
now,
|
|
);
|
|
assert!(matches!(
|
|
a,
|
|
GateDecision::Drop {
|
|
acknowledge: true,
|
|
..
|
|
}
|
|
));
|
|
|
|
// React → promote, keeping the trigger's own priority.
|
|
let r = map_triage_to_gate(&triage(TriageAction::React, Some("ack it")), &base);
|
|
match r {
|
|
GateDecision::Promote {
|
|
priority,
|
|
synthesized_summary,
|
|
..
|
|
} => {
|
|
assert_eq!(priority, base.priority);
|
|
assert!(synthesized_summary.contains("ack it"));
|
|
}
|
|
other => panic!("expected promote, got {other:?}"),
|
|
}
|
|
|
|
// Escalate → promote at >= High.
|
|
let e = map_triage_to_gate(&triage(TriageAction::Escalate, Some("draft reply")), &base);
|
|
match e {
|
|
GateDecision::Promote { priority, .. } => assert!(priority >= TriggerPriority::High),
|
|
other => panic!("expected promote, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn scenario_promotion_budget_exhaustion_downgrades_to_ack_drop() {
|
|
let now = 0.0;
|
|
let budget = PromotionBudget::new(1); // one promotion per hour
|
|
let base = normalize(&user_event("slack", Some("U1"), "urgent!"), now).expect("normalize");
|
|
let escalate = || map_triage_to_gate(&triage(TriageAction::Escalate, Some("do it")), &base);
|
|
|
|
// First escalation promotes.
|
|
assert!(apply_budget(escalate(), &budget, now).is_promote());
|
|
// Second within the hour is downgraded to an acknowledged drop — noted,
|
|
// but no reasoning-tier session run is spent.
|
|
match apply_budget(escalate(), &budget, now) {
|
|
GateDecision::Drop {
|
|
acknowledge,
|
|
reason,
|
|
} => {
|
|
assert!(acknowledge);
|
|
assert!(reason.contains("budget exhausted"));
|
|
}
|
|
other => panic!("expected budget downgrade, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 4 — queue: priority ordering + overflow eviction.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
fn promoted(label: &str, priority: TriggerPriority) -> Trigger {
|
|
let mut t = normalize(&cron_event("j", label), 0.0).expect("normalize");
|
|
t.display_label = label.into();
|
|
t.priority = priority;
|
|
t
|
|
}
|
|
|
|
#[test]
|
|
fn scenario_queue_serves_highest_priority_first() {
|
|
let q = OrchestratorQueue::new(16);
|
|
q.push(promoted("cron-low", TriggerPriority::Low));
|
|
q.push(promoted("user-high", TriggerPriority::High));
|
|
q.push(promoted("webhook-normal", TriggerPriority::Normal));
|
|
q.push(promoted("interrupt-urgent", TriggerPriority::Urgent));
|
|
|
|
let drained: Vec<String> = std::iter::from_fn(|| q.pop())
|
|
.map(|t| t.display_label)
|
|
.collect();
|
|
assert_eq!(
|
|
drained,
|
|
vec![
|
|
"interrupt-urgent",
|
|
"user-high",
|
|
"webhook-normal",
|
|
"cron-low"
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn scenario_queue_overflow_sheds_lowest_priority() {
|
|
let q = OrchestratorQueue::new(2);
|
|
assert_eq!(
|
|
q.push(promoted("low", TriggerPriority::Low)),
|
|
EnqueueOutcome::Accepted
|
|
);
|
|
assert_eq!(
|
|
q.push(promoted("normal", TriggerPriority::Normal)),
|
|
EnqueueOutcome::Accepted
|
|
);
|
|
// Full; an Urgent arrival evicts the lowest-priority held item.
|
|
match q.push(promoted("urgent", TriggerPriority::Urgent)) {
|
|
EnqueueOutcome::EvictedLowest { evicted } => assert_eq!(evicted.display_label, "low"),
|
|
other => panic!("expected eviction, got {other:?}"),
|
|
}
|
|
// Full again; a Low arrival is dropped rather than evicting a better item.
|
|
assert_eq!(
|
|
q.push(promoted("late-low", TriggerPriority::Low)),
|
|
EnqueueOutcome::DroppedIncoming
|
|
);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 5 — full pipeline simulation across scenarios, with a printed trace.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
/// One scenario: a raw event + the gate verdict the (simulated) LLM returns.
|
|
struct Scenario {
|
|
name: &'static str,
|
|
event: DomainEvent,
|
|
action: TriageAction,
|
|
prompt: Option<&'static str>,
|
|
}
|
|
|
|
/// Outcome of running a scenario through the whole pipeline.
|
|
#[derive(Debug)]
|
|
enum Outcome {
|
|
Ignored,
|
|
Duplicate,
|
|
RateLimited,
|
|
Dropped,
|
|
Promoted { priority: TriggerPriority },
|
|
}
|
|
|
|
/// Drive one event through normalize → admit → gate → enqueue, returning what
|
|
/// happened and (on promotion) pushing onto `queue`.
|
|
fn run_scenario(
|
|
s: &Scenario,
|
|
reg: &TriggerRegistry,
|
|
budget: &PromotionBudget,
|
|
queue: &OrchestratorQueue,
|
|
now: f64,
|
|
) -> Outcome {
|
|
let Some(trigger) = normalize(&s.event, now) else {
|
|
return Outcome::Ignored;
|
|
};
|
|
match reg.admit(&trigger, now) {
|
|
AdmitOutcome::Duplicate => return Outcome::Duplicate,
|
|
AdmitOutcome::RateLimited => return Outcome::RateLimited,
|
|
AdmitOutcome::Admitted => {}
|
|
}
|
|
let decision = apply_budget(
|
|
map_triage_to_gate(&triage(s.action, s.prompt), &trigger),
|
|
budget,
|
|
now,
|
|
);
|
|
match decision {
|
|
GateDecision::Drop { .. } => Outcome::Dropped,
|
|
GateDecision::Promote {
|
|
priority,
|
|
synthesized_summary,
|
|
..
|
|
} => {
|
|
let mut item = trigger;
|
|
item.priority = priority;
|
|
item.payload.gate_summary = synthesized_summary;
|
|
queue.push(item);
|
|
Outcome::Promoted { priority }
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn scenario_full_pipeline_simulation_with_trace() {
|
|
let reg = TriggerRegistry::with_defaults();
|
|
let budget = PromotionBudget::new(2); // tight budget to exercise exhaustion
|
|
let queue = OrchestratorQueue::new(64);
|
|
|
|
let scenarios = vec![
|
|
Scenario {
|
|
name: "cron tick — gate drops routine noise",
|
|
event: cron_event("nightly", "nightly recap"),
|
|
action: TriageAction::Drop,
|
|
prompt: None,
|
|
},
|
|
Scenario {
|
|
name: "user message — gate escalates (promote #1)",
|
|
event: user_event("slack", Some("U1"), "can you prep the Q3 deck?"),
|
|
action: TriageAction::Escalate,
|
|
prompt: Some("prepare the Q3 deck"),
|
|
},
|
|
Scenario {
|
|
name: "composio gmail — gate reacts (promote #2)",
|
|
event: composio_event("inv-1", "Invoice overdue"),
|
|
action: TriageAction::React,
|
|
prompt: Some("flag the overdue invoice"),
|
|
},
|
|
Scenario {
|
|
name: "composio gmail DUPLICATE — collapsed by dedupe",
|
|
event: composio_event("inv-1", "Invoice overdue"),
|
|
action: TriageAction::React,
|
|
prompt: Some("flag the overdue invoice"),
|
|
},
|
|
Scenario {
|
|
name: "subagent conclusion — would promote but budget exhausted",
|
|
event: subagent_done_event("task-9", "researcher"),
|
|
action: TriageAction::Escalate,
|
|
prompt: Some("merge the research findings"),
|
|
},
|
|
Scenario {
|
|
name: "self-authored proactive echo — ignored (anti-loop)",
|
|
event: user_event("slack", Some("subconscious"), "FYI: deck is ready"),
|
|
action: TriageAction::Escalate,
|
|
prompt: Some("should never run"),
|
|
},
|
|
];
|
|
|
|
println!("\n=== subconscious trigger pipeline — scenario trace ===");
|
|
let mut promotions = 0;
|
|
let mut trace = Vec::new();
|
|
for (i, s) in scenarios.iter().enumerate() {
|
|
let outcome = run_scenario(s, ®, &budget, &queue, 1000.0 + i as f64);
|
|
if matches!(outcome, Outcome::Promoted { .. }) {
|
|
promotions += 1;
|
|
}
|
|
println!(" [{i}] {:<55} -> {outcome:?}", s.name);
|
|
trace.push(outcome);
|
|
}
|
|
println!(" queue depth after gating: {}", queue.len());
|
|
println!("=== drain (highest priority first) ===");
|
|
while let Some(item) = queue.pop() {
|
|
println!(
|
|
" run -> {:<24} priority={}",
|
|
item.display_label,
|
|
item.priority.as_str()
|
|
);
|
|
}
|
|
|
|
// Assertions on what the pipeline decided.
|
|
assert!(matches!(trace[0], Outcome::Dropped), "cron noise dropped");
|
|
assert!(
|
|
matches!(trace[1], Outcome::Promoted { priority } if priority >= TriggerPriority::High),
|
|
"user escalation promoted at >= High"
|
|
);
|
|
assert!(
|
|
matches!(trace[2], Outcome::Promoted { .. }),
|
|
"gmail react promoted"
|
|
);
|
|
assert!(
|
|
matches!(trace[3], Outcome::Duplicate),
|
|
"duplicate gmail collapsed"
|
|
);
|
|
assert!(
|
|
matches!(trace[4], Outcome::Dropped),
|
|
"budget (2) exhausted → 3rd promotion downgraded to drop"
|
|
);
|
|
assert!(matches!(trace[5], Outcome::Ignored), "self-echo ignored");
|
|
assert_eq!(promotions, 2, "exactly two promotions within the budget");
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 6 — notify_user: real event bus + reserved user-thread persistence.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
/// Serializes tests that touch the process-global event bus so concurrent
|
|
/// captures don't cross-talk.
|
|
fn bus_lock() -> std::sync::MutexGuard<'static, ()> {
|
|
static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
|
|
LOCK.get_or_init(|| StdMutex::new(()))
|
|
.lock()
|
|
.unwrap_or_else(|p| p.into_inner())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn scenario_notify_user_delivers_and_persists() {
|
|
let _guard = bus_lock();
|
|
init_global(64);
|
|
|
|
let captured: Arc<StdMutex<Vec<DomainEvent>>> = Arc::new(StdMutex::new(Vec::new()));
|
|
let sink = Arc::clone(&captured);
|
|
let _sub = global()
|
|
.expect("bus initialized")
|
|
.on("e2e-notify-capture", move |event| {
|
|
let sink = Arc::clone(&sink);
|
|
let event = event.clone();
|
|
Box::pin(async move {
|
|
if let DomainEvent::ProactiveMessageRequested { .. } = &event {
|
|
sink.lock().unwrap().push(event);
|
|
}
|
|
})
|
|
});
|
|
|
|
let tmp = tempfile::tempdir().expect("tempdir");
|
|
let workspace = tmp.path().to_path_buf();
|
|
|
|
let unique = "E2E-NOTIFY-MARKER-7321";
|
|
notify_user(workspace.clone(), unique, Some("heads-up"));
|
|
|
|
// Give the async broadcast a moment to deliver.
|
|
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
|
|
|
// 1) The proactive delivery event fired, tagged as subconscious-sourced.
|
|
let events = captured.lock().unwrap();
|
|
let found = events.iter().any(|e| match e {
|
|
DomainEvent::ProactiveMessageRequested {
|
|
source, message, ..
|
|
} => source == "subconscious" && message == unique,
|
|
_ => false,
|
|
});
|
|
assert!(
|
|
found,
|
|
"notify_user must publish a ProactiveMessageRequested event"
|
|
);
|
|
|
|
// 2) The message landed in the reserved user-facing thread.
|
|
let persisted =
|
|
openhuman_core::openhuman::memory_conversations::get_messages(workspace, USER_THREAD_ID)
|
|
.expect("read user thread");
|
|
assert!(
|
|
persisted
|
|
.iter()
|
|
.any(|m| m.content == unique && m.sender == "agent"),
|
|
"notify_user must persist to the user-facing thread"
|
|
);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Section 7 — reserved-thread cold-boot contract (what the session resumes from).
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn scenario_reserved_threads_are_distinct_and_persist() {
|
|
use openhuman_core::openhuman::memory_conversations::{
|
|
append_message, ensure_thread, get_messages, ConversationMessage, CreateConversationThread,
|
|
};
|
|
|
|
assert_ne!(
|
|
ORCHESTRATOR_THREAD_ID, USER_THREAD_ID,
|
|
"orchestrator and user threads must be distinct"
|
|
);
|
|
|
|
let tmp = tempfile::tempdir().expect("tempdir");
|
|
let workspace = tmp.path().to_path_buf();
|
|
|
|
// The reserved thread must exist before appending (the production code
|
|
// ensures this lazily; mirror it here).
|
|
ensure_thread(
|
|
workspace.clone(),
|
|
CreateConversationThread {
|
|
id: ORCHESTRATOR_THREAD_ID.into(),
|
|
title: "Subconscious Orchestrator".into(),
|
|
created_at: "2026-06-12T00:00:00Z".into(),
|
|
parent_thread_id: None,
|
|
labels: None,
|
|
personality_id: None,
|
|
},
|
|
)
|
|
.expect("ensure thread");
|
|
|
|
// Simulate prior orchestrator history that a long-lived session would
|
|
// cold-boot resume from via seed_resume_from_messages.
|
|
for (sender, content) in [
|
|
("user", "[composio/gmail] new invoice"),
|
|
("agent", "Noted; I'll watch for the follow-up."),
|
|
] {
|
|
append_message(
|
|
workspace.clone(),
|
|
ORCHESTRATOR_THREAD_ID,
|
|
ConversationMessage {
|
|
id: format!("m-{sender}"),
|
|
content: content.into(),
|
|
message_type: "text".into(),
|
|
extra_metadata: serde_json::Value::Null,
|
|
sender: sender.into(),
|
|
created_at: "2026-06-12T00:00:00Z".into(),
|
|
},
|
|
)
|
|
.expect("append");
|
|
}
|
|
|
|
let history = get_messages(workspace, ORCHESTRATOR_THREAD_ID).expect("read");
|
|
assert_eq!(history.len(), 2);
|
|
assert_eq!(history[0].sender, "user");
|
|
assert_eq!(history[1].sender, "agent");
|
|
}
|