Files
javis_bot/app/src/conversation.rs
javis-bot ea2d3ba958 feat: reminders and scheduled tasks (schedule tool, app store and delivery)
The brain gets a schedule tool (add, list, delete the asker's own reminders,
timers and tasks) offered only with a schedule backend. The voice worker asks
the app through schedule_action and runs fired tasks as reply via task with
read-only tools, no MCP and a fresh short-term memory. The app keeps the
schedules in config/schedules.json, fires them every 5 s, speaks them when the
person is in Jarvis's voice channel and otherwise posts in the chat channel
they asked in (or schedule.chatChannel for voice). A feature switch and a
예약 screen list and delete everyone's schedules.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:27:42 +09:00

947 lines
44 KiB
Rust

//! The conversation loop (`app/src/conversation.spec.md`): finished utterances go through call
//! detection and the response policy, and the policy's actions become brain answers, stops and
//! missed-request records.
//!
//! `Conversation` holds no Discord or worker types: it talks to the voice side through `Voice`, so the
//! glue is tested with a fake. `run` drives it from the core's events with a timer for the policy.
use std::collections::{HashMap, HashSet, VecDeque};
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use crate::calls::{Call, CallSettings};
use crate::discord::{CoreEvent, DiscordCore};
use crate::policy::{Action, MissReason, Policy, PolicySettings, Request};
use crate::debug_log;
/// How long the brain's "was it said to Jarvis?" answer is waited for; no answer counts as no.
pub const ADDRESSED_TIMEOUT: Duration = Duration::from_secs(5);
/// Missed requests kept for the dashboard (M5).
pub const MISSED_KEPT: usize = 100;
/// What the conversation needs from the voice side.
pub trait Voice {
/// Have the brain answer and speak it; the speech request id, or None when it cannot. `heard`:
/// when the request's speech ended and its final arrived (the dashboard times the answer by it).
fn answer(&self, user: u64, text: &str, heard: (Instant, Instant)) -> Option<String>;
/// Stop one speech request.
fn cancel(&self, id: &str);
/// Stop all speech at once.
fn stop_all(&self);
/// Play the earcon now (queued like speech; dropped by a stop).
fn earcon(&self);
/// A call is still being said (partial transcript): the brain may get ready to answer it.
fn prepare(&self, user: u64, text: &str);
fn ask_addressed(&self, id: &str, user: u64, text: &str) -> bool;
fn ask_rank(&self, id: &str, candidates: &[(String, u64, String)]) -> bool;
/// Have the brain answer a chat message (not spoken); its text comes as `CoreEvent::ReplyText`.
fn chat_answer(&self, id: &str, user: u64, channel: u64, text: &str) -> bool;
/// Post the chat answer `id` in `channel` as a reply to `message` (never pinging anyone), then
/// tell the brain whether it was posted.
fn send_reply(&self, id: &str, channel: u64, message: u64, text: &str);
/// Tell the brain the chat answer `id` was not posted (late, failed or empty).
fn reply_not_posted(&self, id: &str);
}
impl Voice for DiscordCore {
fn answer(&self, user: u64, text: &str, heard: (Instant, Instant)) -> Option<String> {
DiscordCore::answer(self, user, text, heard)
}
fn cancel(&self, id: &str) {
DiscordCore::cancel(self, id)
}
fn stop_all(&self) {
DiscordCore::stop(self);
}
fn earcon(&self) {
DiscordCore::earcon(self);
}
fn prepare(&self, user: u64, text: &str) {
DiscordCore::prepare(self, user, text);
}
fn ask_addressed(&self, id: &str, user: u64, text: &str) -> bool {
DiscordCore::ask_addressed(self, id, user, text)
}
fn ask_rank(&self, id: &str, candidates: &[(String, u64, String)]) -> bool {
DiscordCore::ask_rank(self, id, candidates)
}
fn chat_answer(&self, id: &str, user: u64, channel: u64, text: &str) -> bool {
DiscordCore::chat_answer(self, id, user, channel, text)
}
fn send_reply(&self, id: &str, channel: u64, message: u64, text: &str) {
let core = self.clone();
let (id, text) = (id.to_owned(), text.to_owned());
tokio::spawn(async move {
let posted = core.send_chat_reply(channel, message, &text).await;
if let Err(e) = &posted {
crate::error_log!("conversation", "could not post the chat answer in {channel}: {e}");
}
core.reply_delivered(&id, posted.is_ok());
});
}
fn reply_not_posted(&self, id: &str) {
self.reply_delivered(id, false);
}
}
/// How a registered chat channel is answered (`chatChannels[].answer`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ChatChannelCall {
/// Answer every message, not only those with a wake word.
pub everything: bool,
/// Sending is on; without it no answer could be posted, so none is asked for.
pub send: bool,
}
/// Call detection for chat: the chat wake words (`call.chatWakeWords`, else the voice ones) with the
/// shared designated-people switches, and each registered channel's answer setting.
#[derive(Debug, Clone, Default)]
pub struct ChatCalls {
pub calls: CallSettings,
pub channels: HashMap<u64, ChatChannelCall>,
}
impl ChatCalls {
pub fn from_settings(s: &crate::settings::Settings) -> Self {
let mut calls = s.call.clone();
if let Some(w) = &s.chat_wake_words {
calls.wake_words = w.clone();
}
let channels = s.chat_channels.iter()
.map(|c| (c.id, ChatChannelCall { everything: c.answer_all, send: c.send }))
.collect();
Self { calls, channels }
}
}
/// Chat answers waited for longer than this are forgotten (the brain or the worker went away).
const CHAT_ANSWER_KEPT: Duration = Duration::from_secs(300);
/// The missed requests, shared between the conversation loop and the dashboard.
pub type MissedLog = std::sync::Arc<std::sync::Mutex<VecDeque<Missed>>>;
/// A request that was not answered, or an answer that was stopped. No text: only who, why and when.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Missed {
pub speaker: u64,
pub reason: MissReason,
pub at: Instant,
pub chars: usize,
}
pub struct Conversation<V: Voice> {
voice: V,
calls: CallSettings,
policy: Policy,
next_id: u64,
/// Policy request id -> speech request id, and back.
answers: HashMap<u64, String>,
by_speech: HashMap<String, u64>,
/// Ask id -> the request it becomes on a yes, and when it was asked.
asks: HashMap<String, (Request, Instant)>,
/// Shared with the dashboard (`missed_handle`).
missed: MissedLog,
chat: ChatCalls,
/// Chat answer id -> the message it answers (channel, message) and when it was asked.
chat_answers: HashMap<String, (u64, u64, Instant)>,
/// Each speaker's latest utterance that started and whose final has not come yet.
started: HashMap<u64, u32>,
/// A wake word said alone, per speaker, waiting for what they say next; the deadline for the next
/// utterance to start (None while it runs).
wakes: HashMap<u64, (Request, Option<Instant>)>,
/// Requests whose earcon already played (a wake word said alone was answered with it).
chimed: HashSet<u64>,
}
impl<V: Voice> Conversation<V> {
pub fn new(voice: V, calls: CallSettings, policy: PolicySettings) -> Self {
Self { voice, calls, policy: Policy::new(policy), next_id: 0, answers: HashMap::new(),
by_speech: HashMap::new(), asks: HashMap::new(), missed: MissedLog::default(), chat: ChatCalls::default(),
chat_answers: HashMap::new(), started: HashMap::new(), wakes: HashMap::new(),
chimed: HashSet::new() }
}
/// Answer the registered chat channels too.
pub fn with_chat(mut self, chat: ChatCalls) -> Self {
self.chat = chat;
self
}
fn on_chat(&mut self, m: &crate::chat::ChatMessage, now: Instant) {
// Other bots are never answered, so two bots cannot keep answering each other.
if m.author_is_bot || m.from_self {
return;
}
let Some(ch) = self.chat.channels.get(&m.channel_id).copied() else { return };
if !ch.send {
return;
}
let calls = CallSettings {
mode: if ch.everything { crate::calls::CallMode::Everything } else { crate::calls::CallMode::WakeWord },
..self.chat.calls.clone()
};
let call = calls.judge(m.author_id, &m.content);
debug_log!("conversation", "chat {} in {} from {} call={call:?}", m.message_id, m.channel_id, m.author_id);
// A chat message is answered in chat; a stop there is not a question.
if !matches!(call, Call::Request { .. }) {
return;
}
self.chat_answers.retain(|_, (_, _, at)| now < *at + CHAT_ANSWER_KEPT);
self.next_id += 1;
let id = format!("c{}", self.next_id);
if self.voice.chat_answer(&id, m.author_id, m.channel_id, &m.content) {
self.chat_answers.insert(id, (m.channel_id, m.message_id, now));
}
}
/// A partial that already reads as a call (joined to a waiting wake word alone, as its final
/// would be) lets the brain get ready while the speaker is still talking. Not while Jarvis is
/// answering: the call may not be taken, and the brain is busy with the answer.
fn on_partial(&mut self, speaker: u64, partial: &str) {
if !self.answers.is_empty() {
return;
}
let text = match self.wakes.get(&speaker) {
Some((wake, _)) => format!("{} {}", wake.text, partial),
None => partial.to_owned(),
};
if matches!(self.calls.judge(speaker, &text), Call::Request { .. }) && !self.calls.wake_word_only(&text) {
self.voice.prepare(speaker, &text);
}
}
/// The missed requests kept, oldest first.
pub fn missed(&self) -> std::vec::IntoIter<Missed> {
self.missed.lock().unwrap().iter().cloned().collect::<Vec<_>>().into_iter()
}
/// The same records for the dashboard, readable while the loop runs.
pub fn missed_handle(&self) -> MissedLog {
self.missed.clone()
}
pub fn on_event(&mut self, ev: &CoreEvent, now: Instant) {
match ev {
CoreEvent::SpeechStart(h) => {
self.policy.utterance_open(h.speaker_id);
self.started.insert(h.speaker_id, h.utt);
if let Some((_, deadline)) = self.wakes.get_mut(&h.speaker_id) {
*deadline = None; // they go on: wait for this utterance's final
}
}
CoreEvent::Chat(m) => self.on_chat(m, now),
CoreEvent::Partial(h, partial) => self.on_partial(h.speaker_id, partial),
CoreEvent::ReplyText { id, text, failed } => {
if let Some((channel, message, asked)) = self.chat_answers.remove(id) {
let late = now >= asked + CHAT_ANSWER_KEPT;
debug_log!("conversation", "chat answer {id} chars={} failed={failed} late={late}",
text.chars().count());
if !failed && !late && !text.trim().is_empty() {
self.voice.send_reply(id, channel, message, text);
} else {
self.voice.reply_not_posted(id);
}
}
}
CoreEvent::SpeakingStopped(user) => self.policy.speaking_stopped(*user, now),
CoreEvent::Final(f) => {
let speaker = f.heard.speaker_id;
if self.started.get(&speaker) == Some(&f.heard.utt) {
self.started.remove(&speaker);
}
// What follows a wake word said alone is joined to it.
let (text, chimed) = match self.wakes.remove(&speaker) {
Some((wake, _)) => (format!("{} {}", wake.text, f.text), self.chimed.remove(&wake.id)),
None => (f.text.clone(), false),
};
self.next_id += 1;
if chimed {
self.chimed.insert(self.next_id);
}
let req = Request { id: self.next_id, speaker, text: text.clone(), direct: false,
ended_at: now.checked_sub(Duration::from_millis(f.wait_ms)).unwrap_or(now), arrived_at: now };
let call = self.calls.judge(speaker, &text);
debug_log!("conversation", "final speaker={speaker} req={} call={call:?}", req.id);
if matches!(call, Call::Request { direct: true }) && self.calls.wake_word_only(&text) {
let going_on = self.started.contains_key(&speaker);
debug_log!("conversation", "wake word alone req={} speaker={speaker} going_on={going_on}", req.id);
if !going_on {
let a = self.policy.utterance_closed(speaker, now);
self.apply(a, now);
}
// "I heard you" at once, as voice assistants do after their name; only when
// Jarvis is free, since a busy Jarvis may not take the question.
if self.calls.earcon && self.answers.is_empty() && self.chimed.insert(req.id) {
self.voice.earcon();
}
let deadline = (!going_on).then(|| now + self.calls.follow_up);
self.wakes.insert(speaker, (Request { direct: true, ..req }, deadline));
return;
}
match call {
Call::Ignore => {
let a = self.policy.utterance_closed(speaker, now);
self.apply(a, now);
}
Call::Stop => {
self.voice.stop_all();
self.stop_everything(now);
let a = self.policy.utterance_closed(speaker, now);
self.apply(a, now);
}
Call::Request { direct } => {
let a = self.policy.request(Request { direct, ..req }, now);
self.apply(a, now);
}
Call::Ask => {
let id = format!("q{}", req.id);
if self.voice.ask_addressed(&id, speaker, &text) {
self.asks.insert(id, (req, now));
} else {
let a = self.policy.utterance_closed(speaker, now);
self.apply(a, now);
}
}
}
}
CoreEvent::Addressed { id, addressed } => {
if let Some((req, asked)) = self.asks.remove(id) {
// An answer after the timeout counts as no, even before the timer ran.
let yes = *addressed && now < asked + ADDRESSED_TIMEOUT;
debug_log!("conversation", "addressed req={} yes={yes}", req.id);
let a = if yes {
self.policy.request(req, now)
} else {
self.policy.utterance_closed(req.speaker, now)
};
self.apply(a, now);
}
}
CoreEvent::Ranked { id, order } => {
let (Some(rank_id), order) = (id.strip_prefix('k').and_then(|n| n.parse().ok()),
order.iter().filter_map(|o| o.parse().ok()).collect::<Vec<u64>>()) else { return };
let a = self.policy.ranked(rank_id, &order, now);
self.apply(a, now);
}
CoreEvent::SpeakEnd(e) => {
if let Some(pid) = self.by_speech.remove(&e.id) {
self.answers.remove(&pid);
debug_log!("conversation", "answer req={pid} done played={} cancelled={} failed={}",
e.played, e.cancelled, e.failed);
let a = self.policy.answer_done(pid, now);
self.apply(a, now);
}
}
// All speech was stopped (slash command, leaving): drop what was waiting before the stopped
// speech's end could start the next answer. After a voice stop this finds nothing left.
CoreEvent::Stopped => self.stop_everything(now),
// Utterances in progress end with the session or the worker: their finals will not come
// (a restarted worker numbers utterances afresh), so nothing waits for them.
CoreEvent::Left { .. } => {
self.started.clear();
self.stop_everything(now);
}
CoreEvent::WorkerLost => {
self.started.clear();
for (_, (req, _)) in self.wakes.drain() {
self.chimed.remove(&req.id);
}
}
_ => {}
}
}
/// The policy's stop, and every pending "was it said to Jarvis?" question is void.
fn stop_everything(&mut self, now: Instant) {
self.wakes.clear();
let a = self.policy.stop();
self.apply(a, now);
self.chimed.clear(); // nothing is waiting any more
for (_, (req, _)) in self.asks.drain().collect::<Vec<_>>() {
let a = self.policy.utterance_closed(req.speaker, now);
self.apply(a, now);
}
}
/// Timers: the policy's and unanswered "was it said to Jarvis?" questions.
pub fn tick(&mut self, now: Instant) {
let late: Vec<String> = self.asks.iter()
.filter(|(_, (_, at))| now >= *at + ADDRESSED_TIMEOUT).map(|(id, _)| id.clone()).collect();
for id in late {
if let Some((req, _)) = self.asks.remove(&id) {
debug_log!("conversation", "addressed req={} timed out", req.id);
let a = self.policy.utterance_closed(req.speaker, now);
self.apply(a, now);
}
}
// Nothing followed a wake word said alone: it is the request.
let due: Vec<u64> = self.wakes.iter()
.filter(|(_, (_, d))| d.is_some_and(|d| now >= d)).map(|(s, _)| *s).collect();
for speaker in due {
if let Some((req, _)) = self.wakes.remove(&speaker) {
debug_log!("conversation", "wake word alone req={} answered alone", req.id);
let a = self.policy.request(req, now);
self.apply(a, now);
}
}
let a = self.policy.tick(now);
self.apply(a, now);
}
pub fn next_deadline(&self) -> Option<Instant> {
let asks = self.asks.values().map(|(_, at)| *at + ADDRESSED_TIMEOUT);
let wakes = self.wakes.values().filter_map(|(_, d)| *d);
self.policy.next_deadline().into_iter().chain(asks).chain(wakes).min()
}
fn apply(&mut self, actions: Vec<Action>, now: Instant) {
for action in actions {
match action {
Action::Answer(r) => match {
// The earcon plays first, then the answer as soon as it is written.
if self.calls.earcon && !self.chimed.remove(&r.id) {
self.voice.earcon();
}
self.voice.answer(r.speaker, &r.text, (r.ended_at, r.arrived_at))
} {
Some(sid) => {
debug_log!("conversation", "answer req={} speaker={} speech={sid}", r.id, r.speaker);
self.by_speech.insert(sid.clone(), r.id);
self.answers.insert(r.id, sid);
}
None => {
let a = self.policy.answer_done(r.id, now);
self.apply(a, now);
}
},
Action::StopAnswer(pid) => {
if let Some(sid) = self.answers.remove(&pid) {
self.by_speech.remove(&sid);
self.voice.cancel(&sid);
}
}
Action::Missed(r, reason) => {
self.chimed.remove(&r.id);
debug_log!("conversation", "missed req={} speaker={} reason={reason:?}", r.id, r.speaker);
let mut missed = self.missed.lock().unwrap();
if missed.len() == MISSED_KEPT {
missed.pop_front();
}
missed.push_back(Missed { speaker: r.speaker, reason, at: now, chars: r.text.chars().count() });
}
Action::Rank { id, candidates } => {
let c: Vec<(String, u64, String)> =
candidates.iter().map(|r| (r.id.to_string(), r.speaker, r.text.clone())).collect();
debug_log!("conversation", "rank k{id} candidates={}", c.len());
// Not sent: the policy's ranking timeout picks the earliest-ended.
self.voice.ask_rank(&format!("k{id}"), &c);
}
}
}
}
}
/// Drive a conversation from the core's events, passing every event on to `out`.
pub async fn run<V: Voice>(mut conv: Conversation<V>, mut events: mpsc::UnboundedReceiver<CoreEvent>,
out: mpsc::UnboundedSender<CoreEvent>) {
loop {
let deadline = conv.next_deadline();
tokio::select! {
ev = events.recv() => match ev {
Some(ev) => {
conv.on_event(&ev, Instant::now());
let _ = out.send(ev);
}
None => return,
},
_ = async {
match deadline {
Some(d) => tokio::time::sleep_until(d.into()).await,
None => std::future::pending::<()>().await,
}
} => conv.tick(Instant::now()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::discord::{Heard, HeardFinal};
use crate::playback::PlaybackEnd;
use crate::policy::PolicyKind;
use crate::calls::CallMode;
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Debug, Clone, PartialEq)]
enum Did {
Answer(u64, String),
Cancel(String),
StopAll,
Earcon,
Prepare(u64, String),
Addressed(String, u64),
Rank(String, Vec<String>),
ChatAnswer(String, u64, String),
/// The channel a chat answer was asked for.
ChatIn(u64),
SendReply(String, u64, u64, String),
NotPosted(String),
}
#[derive(Clone, Default)]
struct Fake {
did: Rc<RefCell<Vec<Did>>>,
n: Rc<RefCell<u32>>,
chat_in: Rc<RefCell<Vec<Did>>>,
}
impl Voice for Fake {
fn answer(&self, user: u64, text: &str, _heard: (Instant, Instant)) -> Option<String> {
*self.n.borrow_mut() += 1;
self.did.borrow_mut().push(Did::Answer(user, text.into()));
Some(format!("s{}", self.n.borrow()))
}
fn cancel(&self, id: &str) {
self.did.borrow_mut().push(Did::Cancel(id.into()));
}
fn stop_all(&self) {
self.did.borrow_mut().push(Did::StopAll);
}
fn earcon(&self) {
self.did.borrow_mut().push(Did::Earcon);
}
fn prepare(&self, user: u64, text: &str) {
self.did.borrow_mut().push(Did::Prepare(user, text.into()));
}
fn ask_addressed(&self, id: &str, user: u64, _text: &str) -> bool {
self.did.borrow_mut().push(Did::Addressed(id.into(), user));
true
}
fn ask_rank(&self, id: &str, c: &[(String, u64, String)]) -> bool {
self.did.borrow_mut().push(Did::Rank(id.into(), c.iter().map(|x| x.0.clone()).collect()));
true
}
fn chat_answer(&self, id: &str, user: u64, channel: u64, text: &str) -> bool {
self.chat_in.borrow_mut().push(Did::ChatIn(channel));
self.did.borrow_mut().push(Did::ChatAnswer(id.into(), user, text.into()));
true
}
fn send_reply(&self, id: &str, channel: u64, message: u64, text: &str) {
self.did.borrow_mut().push(Did::SendReply(id.into(), channel, message, text.into()));
}
fn reply_not_posted(&self, id: &str) {
self.did.borrow_mut().push(Did::NotPosted(id.into()));
}
}
impl Fake {
fn take(&self) -> Vec<Did> {
std::mem::take(&mut self.did.borrow_mut())
}
}
const A: u64 = 11;
const B: u64 = 22;
fn conv(kind: PolicyKind, mode: CallMode) -> (Conversation<Fake>, Fake, Instant) {
let f = Fake::default();
let calls = CallSettings { mode, earcon: false, ..CallSettings::default() };
let policy = PolicySettings { kind, collect: Duration::ZERO, ..PolicySettings::default() };
(Conversation::new(f.clone(), calls, policy), f, Instant::now())
}
fn conv_earcon(kind: PolicyKind) -> (Conversation<Fake>, Fake, Instant) {
let f = Fake::default();
let policy = PolicySettings { kind, collect: Duration::ZERO, ..PolicySettings::default() };
(Conversation::new(f.clone(), CallSettings::default(), policy), f, Instant::now())
}
#[test]
fn the_earcon_plays_right_before_each_answer_is_asked_for() {
let (mut c, f, t) = conv_earcon(PolicyKind::InOrder);
c.on_event(&fin(A, "자비스 날씨 어때", 100), ms(t, 0));
assert_eq!(f.take(), vec![Did::Earcon, Did::Answer(A, "자비스 날씨 어때".into())]);
c.on_event(&fin(B, "자비스 불 꺼 줘", 100), ms(t, 200));
assert!(f.take().is_empty(), "a waiting request gets its earcon when its answer starts");
c.on_event(&end("s1", false), ms(t, 3000));
assert_eq!(f.take(), vec![Did::Earcon, Did::Answer(B, "자비스 불 꺼 줘".into())]);
c.on_event(&fin(B, "오늘 뭐 먹지", 100), ms(t, 3100));
assert!(f.take().is_empty(), "no call, no earcon");
}
#[test]
fn a_wake_word_alone_gets_the_earcon_at_once_and_its_question_does_not_get_another() {
let (mut c, f, t) = conv_earcon(PolicyKind::First);
c.on_event(&start(A, 1), ms(t, 0));
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 900));
assert_eq!(f.take(), vec![Did::Earcon]);
c.on_event(&start(A, 2), ms(t, 1200));
c.on_event(&fin_utt(A, 2, "지금 몇 시야?"), ms(t, 3000));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스 지금 몇 시야?".into())]);
// Nothing followed the next one: it is answered alone, still with one earcon.
c.on_event(&end("s1", false), ms(t, 5000));
c.on_event(&fin_utt(A, 3, "자비스"), ms(t, 6000));
c.tick(ms(t, 6000) + CallSettings::default().follow_up);
assert_eq!(f.take(), vec![Did::Earcon, Did::Answer(A, "자비스".into())]);
}
#[test]
fn a_busy_jarvis_gives_no_earcon_for_a_call_it_does_not_take() {
let (mut c, f, t) = conv_earcon(PolicyKind::First);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
assert_eq!(f.take(), vec![Did::Earcon, Did::Answer(A, "자비스 날씨".into())]);
c.on_event(&fin(B, "자비스 안녕", 100), ms(t, 100));
c.on_event(&fin_utt(B, 2, "자비스"), ms(t, 200));
assert!(f.take().is_empty(), "missed while busy, and a wake word alone waits silently");
}
fn partial(speaker: u64, text: &str) -> CoreEvent {
CoreEvent::Partial(Heard { speaker_id: speaker, speaker_name: "x".into(), utt: 1, session: Some(1) }, text.into())
}
#[test]
fn a_partial_that_reads_as_a_call_lets_the_brain_get_ready() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&partial(A, "자비스 오늘"), ms(t, 0));
c.on_event(&partial(B, "오늘 뭐 먹지"), ms(t, 0)); // not a call
c.on_event(&partial(A, "자비스"), ms(t, 0)); // the name alone: nothing to get ready for
c.on_event(&partial(A, "자비스 멈춰"), ms(t, 0)); // a stop is not answered
assert_eq!(f.take(), vec![Did::Prepare(A, "자비스 오늘".into())]);
// After a wake word said alone, the next utterance's partial is joined to it, as its final.
c.on_event(&fin_utt(B, 1, "자비스"), ms(t, 100));
c.on_event(&partial(B, "지금 몇 시"), ms(t, 300));
assert_eq!(f.take(), vec![Did::Prepare(B, "자비스 지금 몇 시".into())]);
// Not while an answer runs.
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 400));
f.take();
c.on_event(&partial(A, "자비스 내일은"), ms(t, 500));
assert!(f.take().is_empty());
}
#[test]
fn the_earcon_can_be_turned_off() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 0));
c.on_event(&fin_utt(A, 2, "안녕"), ms(t, 500));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스 안녕".into())]);
}
fn fin(speaker: u64, text: &str, wait_ms: u64) -> CoreEvent {
CoreEvent::Final(HeardFinal { heard: Heard { speaker_id: speaker, speaker_name: "x".into(), utt: 1, session: Some(1) },
text: text.into(), end_reason: "silence".into(), audio_ms: 1000, wait_ms, stt_ms: 100 })
}
fn end(id: &str, cancelled: bool) -> CoreEvent {
CoreEvent::SpeakEnd(PlaybackEnd { id: id.into(), played: 1, cancelled, failed: false })
}
fn ms(t: Instant, n: u64) -> Instant {
t + Duration::from_millis(n)
}
fn fin_utt(speaker: u64, utt: u32, text: &str) -> CoreEvent {
CoreEvent::Final(HeardFinal { heard: Heard { speaker_id: speaker, speaker_name: "x".into(), utt, session: Some(1) },
text: text.into(), end_reason: "silence".into(), audio_ms: 1000, wait_ms: 100, stt_ms: 100 })
}
fn start(speaker: u64, utt: u32) -> CoreEvent {
CoreEvent::SpeechStart(Heard { speaker_id: speaker, speaker_name: "x".into(), utt, session: Some(1) })
}
#[test]
fn a_wake_word_alone_waits_for_what_the_speaker_says_next() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
// "자비스," then a pause that ended the utterance; the question follows.
c.on_event(&start(A, 1), ms(t, 0));
c.on_event(&fin_utt(A, 1, "자비스,"), ms(t, 900));
assert!(f.take().is_empty(), "a wake word alone is not the question yet");
c.on_event(&start(A, 2), ms(t, 1200));
c.tick(ms(t, 5000)); // still talking: no time limit while the next utterance runs
assert!(f.take().is_empty());
c.on_event(&fin_utt(A, 2, "지금 몇 시야?"), ms(t, 5200));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스, 지금 몇 시야?".into())]);
assert_eq!(c.missed().count(), 0);
}
#[test]
fn a_wake_word_alone_waits_for_a_next_utterance_that_already_started() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&start(A, 1), ms(t, 0));
c.on_event(&start(A, 2), ms(t, 600)); // the final of utterance 1 comes after 2 started
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 900));
c.tick(ms(t, 900) + CallSettings::default().follow_up + Duration::from_millis(1));
assert!(f.take().is_empty());
c.on_event(&fin_utt(A, 2, "멈춰"), ms(t, 3000));
assert_eq!(f.take(), vec![Did::StopAll], "joined, it is a stop");
}
#[test]
fn a_wake_word_alone_is_answered_when_nothing_follows() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&start(A, 1), ms(t, 0));
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 900));
let wait = CallSettings::default().follow_up;
assert_eq!(c.next_deadline(), Some(ms(t, 900) + wait));
c.tick(ms(t, 900) + wait - Duration::from_millis(1));
assert!(f.take().is_empty());
c.tick(ms(t, 900) + wait);
assert_eq!(f.take(), vec![Did::Answer(A, "자비스".into())]);
// Another speaker's words do not join it.
c.on_event(&end("s1", false), ms(t, 4000));
c.on_event(&start(A, 2), ms(t, 4100));
c.on_event(&fin_utt(A, 2, "자비스"), ms(t, 4500));
c.on_event(&fin_utt(B, 1, "오늘 뭐 먹지"), ms(t, 4600));
c.tick(ms(t, 4500) + wait);
assert_eq!(f.take(), vec![Did::Answer(A, "자비스".into())]);
}
#[test]
fn a_lost_worker_drops_a_waiting_wake_word_and_what_was_running() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&start(A, 1), ms(t, 0));
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 900));
c.on_event(&start(A, 2), ms(t, 1200)); // the final of utterance 2 is lost with the worker
c.on_event(&CoreEvent::WorkerLost, ms(t, 2000));
assert_eq!(c.next_deadline(), None);
// The restarted worker numbers utterances from 1 again; nothing old joins or holds them.
c.on_event(&start(A, 1), ms(t, 60_000));
c.on_event(&fin_utt(A, 1, "오늘 뭐 먹지"), ms(t, 61_000));
assert!(f.take().is_empty(), "no wake word: not a call");
c.on_event(&start(A, 2), ms(t, 62_000));
c.on_event(&fin_utt(A, 2, "자비스"), ms(t, 63_000));
let wait = CallSettings::default().follow_up;
assert_eq!(c.next_deadline(), Some(ms(t, 63_000) + wait));
c.tick(ms(t, 63_000) + wait);
assert_eq!(f.take(), vec![Did::Answer(A, "자비스".into())]);
}
#[test]
fn a_stop_drops_a_waiting_wake_word() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&fin_utt(A, 1, "자비스"), ms(t, 900));
c.on_event(&CoreEvent::Stopped, ms(t, 1000));
c.tick(ms(t, 900) + CallSettings::default().follow_up);
assert!(f.take().is_empty());
assert_eq!(c.next_deadline(), None);
}
#[test]
fn a_call_is_answered_and_the_next_one_waits_for_its_speech_to_end() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 날씨 어때", 100), ms(t, 0));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스 날씨 어때".into())]);
c.on_event(&fin(B, "오늘 뭐 먹지", 100), ms(t, 100)); // not a call
c.on_event(&fin(B, "자비스 불 꺼 줘", 100), ms(t, 200));
assert!(f.take().is_empty(), "queued behind the answer");
c.on_event(&end("s1", false), ms(t, 3000));
assert_eq!(f.take(), vec![Did::Answer(B, "자비스 불 꺼 줘".into())]);
assert_eq!(c.missed().count(), 0);
}
#[test]
fn first_drops_a_call_while_busy_and_records_it_without_text() {
let (mut c, f, t) = conv(PolicyKind::First, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
c.on_event(&fin(B, "자비스 안녕", 100), ms(t, 100));
assert_eq!(f.take().len(), 1);
let m: Vec<_> = c.missed().collect();
assert_eq!(m, vec![Missed { speaker: B, reason: MissReason::Busy, at: ms(t, 100), chars: "자비스 안녕".chars().count() }]);
}
#[test]
fn a_voice_stop_silences_everything_and_drops_the_queue() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
c.on_event(&fin(B, "자비스 안녕", 100), ms(t, 100));
f.take();
c.on_event(&fin(B, "자비스 멈춰", 100), ms(t, 200));
let did = f.take();
assert_eq!(did[0], Did::StopAll);
assert!(!did.iter().any(|d| matches!(d, Did::Answer(..))));
// The stopped speech's end starts nothing.
c.on_event(&end("s1", true), ms(t, 300));
assert!(f.take().iter().all(|d| !matches!(d, Did::Answer(..))));
assert_eq!(c.missed().filter(|m| m.reason == MissReason::Stopped).count(), 2);
}
#[test]
fn addressed_mode_asks_the_brain_and_answers_only_a_yes() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::Addressed);
c.on_event(&fin(A, "불 좀 꺼 줄래", 100), ms(t, 0));
let Did::Addressed(q, user) = f.take().remove(0) else { panic!() };
assert_eq!(user, A);
c.on_event(&CoreEvent::Addressed { id: q, addressed: true }, ms(t, 300));
assert_eq!(f.take(), vec![Did::Answer(A, "불 좀 꺼 줄래".into())]);
c.on_event(&end("s1", false), ms(t, 2000));
c.on_event(&fin(B, "너 어제 그거 봤어?", 100), ms(t, 2100));
let Did::Addressed(q, _) = f.take().remove(0) else { panic!() };
c.on_event(&CoreEvent::Addressed { id: q, addressed: false }, ms(t, 2300));
assert!(f.take().is_empty());
// No answer at all counts as no once the timeout passes.
c.on_event(&fin(B, "음", 100), ms(t, 3000));
f.take();
assert_eq!(c.next_deadline(), Some(ms(t, 3000) + ADDRESSED_TIMEOUT));
c.tick(ms(t, 3000) + ADDRESSED_TIMEOUT);
assert!(f.take().is_empty());
assert_eq!(c.next_deadline(), None);
}
#[test]
fn latest_cancels_the_running_answer_for_a_newer_call() {
let (mut c, f, t) = conv(PolicyKind::Latest, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
c.on_event(&fin(B, "자비스 뉴스", 100), ms(t, 500));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스 날씨".into()), Did::Cancel("s1".into()),
Did::Answer(B, "자비스 뉴스".into())]);
// The cancelled speech's end does not end the new answer.
c.on_event(&end("s1", true), ms(t, 600));
c.on_event(&fin(A, "자비스 하나 더", 100), ms(t, 700));
assert_eq!(f.take(), vec![Did::Cancel("s2".into()), Did::Answer(A, "자비스 하나 더".into())]);
}
#[test]
fn a_tie_in_important_is_ranked_by_the_brain() {
let (mut c, f, t) = conv(PolicyKind::Important, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
f.take();
c.on_event(&fin(B, "자비스 불 꺼", 100), ms(t, 200));
let Did::Rank(k, ids) = f.take().remove(0) else { panic!() };
assert_eq!(ids, vec!["1", "2"]);
c.on_event(&CoreEvent::Ranked { id: k, order: vec!["2".into(), "1".into()] }, ms(t, 400));
assert_eq!(f.take(), vec![Did::Cancel("s1".into()), Did::Answer(B, "자비스 불 꺼".into())]);
}
#[test]
fn a_voice_stop_also_drops_a_pending_addressed_question() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::Addressed);
c.on_event(&fin(A, "불 좀 꺼 줄래", 100), ms(t, 0));
let Did::Addressed(q, _) = f.take().remove(0) else { panic!() };
c.on_event(&fin(B, "자비스 멈춰", 100), ms(t, 100));
f.take();
c.on_event(&CoreEvent::Addressed { id: q, addressed: true }, ms(t, 300));
assert!(f.take().is_empty(), "the question asked before the stop is void");
assert_eq!(c.next_deadline(), None);
}
#[test]
fn a_stop_from_elsewhere_drops_the_queue_before_the_cancelled_speech_ends() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::Addressed);
c.on_event(&fin(A, "자비스 날씨", 100), ms(t, 0));
c.on_event(&fin(B, "자비스 뉴스", 100), ms(t, 100));
c.on_event(&fin(B, "불 좀 꺼 줄래", 100), ms(t, 200)); // waiting for "addressed"
let did = f.take();
let q = did.iter().find_map(|d| if let Did::Addressed(q, _) = d { Some(q.clone()) } else { None }).unwrap();
// The slash command stops all speech: Stopped comes before the speech's end.
c.on_event(&CoreEvent::Stopped, ms(t, 300));
c.on_event(&end("s1", true), ms(t, 310));
c.on_event(&CoreEvent::Addressed { id: q, addressed: true }, ms(t, 400));
assert!(!f.take().iter().any(|d| matches!(d, Did::Answer(..))), "nothing starts after a stop");
assert_eq!(c.missed().filter(|m| m.reason == MissReason::Stopped).count(), 2);
}
#[test]
fn an_addressed_answer_after_its_timeout_counts_as_no() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::Addressed);
c.on_event(&fin(A, "불 좀 꺼 줄래", 100), ms(t, 0));
let Did::Addressed(q, _) = f.take().remove(0) else { panic!() };
c.on_event(&CoreEvent::Addressed { id: q, addressed: true }, ms(t, 0) + ADDRESSED_TIMEOUT);
assert!(f.take().is_empty());
}
const CH_WAKE: u64 = 100;
const CH_ALL: u64 = 200;
const CH_MUTE: u64 = 300;
fn chat_conv(calls: CallSettings) -> (Conversation<Fake>, Fake, Instant) {
let f = Fake::default();
let chat = ChatCalls { calls, channels: [
(CH_WAKE, ChatChannelCall { everything: false, send: true }),
(CH_ALL, ChatChannelCall { everything: true, send: true }),
(CH_MUTE, ChatChannelCall { everything: true, send: false }),
].into() };
let voice = CallSettings { earcon: false, ..CallSettings::default() };
let c = Conversation::new(f.clone(), voice, PolicySettings::default()).with_chat(chat);
(c, f, Instant::now())
}
fn chat(channel: u64, message: u64, author: u64, bot: bool, text: &str) -> CoreEvent {
CoreEvent::Chat(crate::chat::ChatMessage { channel_id: channel, message_id: message, author_id: author,
author_name: "x".into(), author_is_bot: bot, from_self: false, content: text.into(),
created_at: String::new() })
}
#[test]
fn a_chat_call_is_answered_as_a_reply_to_its_message() {
let (mut c, f, t) = chat_conv(CallSettings::default());
c.on_event(&chat(CH_WAKE, 5, A, false, "자비스 내일 일정 알려 줘"), t);
let Did::ChatAnswer(id, user, text) = f.take().remove(0) else { panic!() };
assert_eq!((user, text.as_str()), (A, "자비스 내일 일정 알려 줘"));
assert_eq!(*f.chat_in.borrow(), vec![Did::ChatIn(CH_WAKE)], "the brain is told where it was asked");
c.on_event(&CoreEvent::ReplyText { id: id.clone(), text: "내일은 비어 있어요.".into(), failed: false }, t);
assert_eq!(f.take(), vec![Did::SendReply(id.clone(), CH_WAKE, 5, "내일은 비어 있어요.".into())]);
// A second reply_text for the same id sends nothing.
c.on_event(&CoreEvent::ReplyText { id, text: "x".into(), failed: false }, t);
assert!(f.take().is_empty());
}
#[test]
fn chat_answers_follow_each_channels_switch_and_never_answer_bots() {
let (mut c, f, t) = chat_conv(CallSettings::default());
c.on_event(&chat(CH_WAKE, 1, A, false, "오늘 뭐 먹지"), t);
assert!(f.take().is_empty(), "wake word only");
c.on_event(&chat(CH_ALL, 2, A, false, "오늘 뭐 먹지"), t);
assert!(matches!(f.take()[..], [Did::ChatAnswer(..)]), "every message");
c.on_event(&chat(CH_MUTE, 3, A, false, "자비스 안녕"), t);
assert!(f.take().is_empty(), "sending is off: no answer could be posted");
c.on_event(&chat(CH_ALL, 4, B, true, "자비스 안녕"), t);
assert!(f.take().is_empty(), "other bots are never answered");
c.on_event(&chat(999, 6, A, false, "자비스 안녕"), t);
assert!(f.take().is_empty(), "not a registered channel");
c.on_event(&chat(CH_ALL, 7, A, false, "자비스 멈춰"), t);
assert!(f.take().is_empty(), "a stop in chat is not a question");
}
#[test]
fn chat_uses_its_own_wake_words_and_the_designated_people() {
let calls = CallSettings { wake_words: vec!["봇".into()], designated: [A].into(), designated_only: true,
..CallSettings::default() };
let (mut c, f, t) = chat_conv(calls);
c.on_event(&chat(CH_WAKE, 1, A, false, "봇 안녕"), t);
assert_eq!(f.take().len(), 1);
c.on_event(&chat(CH_WAKE, 2, B, false, "봇 안녕"), t);
assert!(f.take().is_empty(), "only designated people");
c.on_event(&chat(CH_WAKE, 3, A, false, "자비스 안녕"), t);
assert!(f.take().is_empty(), "the voice wake word is not the chat one here");
}
#[test]
fn a_failed_chat_answer_posts_nothing_and_chat_leaves_voice_alone() {
let (mut c, f, t) = chat_conv(CallSettings::default());
c.on_event(&fin(A, "자비스 날씨", 100), t);
c.on_event(&chat(CH_ALL, 9, B, false, "안녕"), t);
let did = f.take();
assert!(matches!(did[0], Did::Answer(..)) && matches!(did[1], Did::ChatAnswer(..)), "{did:?}");
let Did::ChatAnswer(id, ..) = &did[1] else { panic!() };
c.on_event(&CoreEvent::ReplyText { id: id.clone(), text: String::new(), failed: true }, t);
assert_eq!(f.take(), vec![Did::NotPosted(id.clone())]);
assert_eq!(c.missed().count(), 0, "a chat message never takes the voice turn");
}
#[test]
fn a_chat_answer_after_its_keep_time_is_not_posted() {
let (mut c, f, t) = chat_conv(CallSettings::default());
c.on_event(&chat(CH_WAKE, 5, A, false, "자비스 안녕"), t);
let Did::ChatAnswer(id, ..) = f.take().remove(0) else { panic!() };
c.on_event(&CoreEvent::ReplyText { id: id.clone(), text: "안녕하세요.".into(), failed: false }, t + CHAT_ANSWER_KEPT);
assert_eq!(f.take(), vec![Did::NotPosted(id)], "too late: the conversation has moved on");
}
#[test]
fn end_times_come_from_the_finals_wait() {
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::WakeWord);
c.on_event(&fin(A, "자비스 하나", 0), ms(t, 0));
c.on_event(&fin(B, "자비스 둘", 0), ms(t, 1000));
c.on_event(&fin(A, "자비스 셋", 900), ms(t, 1500)); // ended at 600, before 둘
f.take();
c.on_event(&end("s1", false), ms(t, 2000));
assert_eq!(f.take(), vec![Did::Answer(A, "자비스 셋".into())]);
}
}