diff --git a/app/src/conversation.spec.md b/app/src/conversation.spec.md index ac8a809..5907d35 100644 --- a/app/src/conversation.spec.md +++ b/app/src/conversation.spec.md @@ -98,8 +98,14 @@ Per policy: `important` ranks by (1) priority, (2) `direct`, then (3) the brain's importance ranking, asked for only when two or more candidates tie on (1) and (2). While the ranking is pending nothing new starts; if it -does not come within 1.5 s, or fails, the earliest-ended of the tied candidates wins. A candidate -beats the running answer only on (1) or (2); the ranking is not asked for an interruption. +does not come within 1.5 s (a ranking that arrives later counts as late), or fails, the earliest-ended +of the tied candidates wins. Candidates are kept in `ended_at` order, whenever they arrived. + +A new request that beats the running answer on (1) or (2) interrupts it at once. One that ties it on +both is ranked against it (the running answer keeps playing meanwhile): if the ranking puts the new +request first, the answer stops (missed, `interrupted`) and the new request is answered; if it puts the +running answer first, or does not come in time, the answer goes on and the new request waits. The +ranking is dropped when the running answer ends first. ## Tests diff --git a/app/src/policy.rs b/app/src/policy.rs index 6415a0d..d30cf39 100644 --- a/app/src/policy.rs +++ b/app/src/policy.rs @@ -97,8 +97,15 @@ pub struct Policy { open: HashMap, /// `important`: no choice before this. collect_until: Option, - /// `important`: the tied candidates being ranked and when to give up waiting. - ranking: Option<(HashSet, Instant)>, + /// `important`: a ranking the brain was asked for. + ranking: Option, +} + +struct Ranking { + ids: HashSet, + deadline: Instant, + /// Asked about interrupting the running answer with this id (it is one of `ids`). + against: Option, } impl Policy { @@ -161,11 +168,20 @@ impl Policy { } } PolicyKind::Important => { - let beats = self.score(&req) > self.score(&cur); - self.waiting.push(req); - if beats { + let (new, running) = (self.score(&req), self.score(&cur)); + self.enqueue(req.clone(), &mut out); + if new > running { self.interrupt(&mut out); self.collect_until = None; + self.ranking = None; + } else if new == running && self.ranking.is_none() { + // A tie on priority and wake word: the brain's importance decides. + self.ranking = Some(Ranking { + ids: [cur.id, req.id].into(), + deadline: now + self.s.rank_timeout, + against: Some(cur.id), + }); + out.push(Action::Rank(vec![cur, req])); } } } @@ -217,31 +233,50 @@ impl Policy { return vec![]; } self.current = None; + // An interruption ranking is moot once the answer it was about has ended. + if self.ranking.as_ref().is_some_and(|r| r.against.is_some()) { + self.ranking = None; + } self.choose(now, None) } - /// The brain's ranking of the tied candidates, best first. + /// The brain's ranking of the tied candidates, best first. After the deadline it counts as a + /// timeout. pub fn ranked(&mut self, order: &[u64], now: Instant) -> Vec { - let Some((tied, _)) = self.ranking.take() else { return vec![] }; - let winner = order.iter().copied().find(|id| tied.contains(id)); - self.choose(now, Some(winner)) + let Some(r) = self.ranking.take() else { return vec![] }; + let winner = if now >= r.deadline { None } else { order.iter().copied().find(|id| r.ids.contains(id)) }; + self.resolve(r, winner, now) + } + + fn resolve(&mut self, r: Ranking, winner: Option, now: Instant) -> Vec { + let Some(running) = r.against else { return self.choose(now, Some(winner)) }; + // Interrupt only when the ranking put a waiting request above the running answer; a timeout + // keeps the running answer, which ended first. + let mut out = vec![]; + match winner { + Some(w) if w != running && self.current() == Some(running) && self.waiting.iter().any(|q| q.id == w) => { + self.interrupt(&mut out); + self.collect_until = None; + out.extend(self.choose(now, Some(Some(w)))); + } + _ => out.extend(self.choose(now, None)), + } + out } /// Timers: settling, collecting and the ranking timeout. pub fn tick(&mut self, now: Instant) -> Vec { - if let Some((_, deadline)) = &self.ranking { - if now >= *deadline { - self.ranking = None; - return self.choose(now, Some(None)); - } + if self.ranking.as_ref().is_some_and(|r| now >= r.deadline) { + let r = self.ranking.take().expect("checked"); + return self.resolve(r, None, now); } self.choose(now, None) } /// When `tick` should run next. pub fn next_deadline(&self) -> Option { - if let Some((_, t)) = &self.ranking { - return Some(*t); + if let Some(r) = &self.ranking { + return Some(r.deadline); } let mut d: Vec = vec![]; if self.current.is_none() && !self.waiting.is_empty() { @@ -287,6 +322,7 @@ impl Policy { if now < t { return out; } + self.collect_until = None; } if self.blocked(now) { return out; @@ -306,7 +342,11 @@ impl Policy { Some(_) => tied[0], None if tied.len() >= 2 => { let cands: Vec = tied.iter().map(|&i| self.waiting[i].clone()).collect(); - self.ranking = Some((cands.iter().map(|r| r.id).collect(), now + self.s.rank_timeout)); + self.ranking = Some(Ranking { + ids: cands.iter().map(|r| r.id).collect(), + deadline: now + self.s.rank_timeout, + against: None, + }); out.push(Action::Rank(cands)); return out; } @@ -534,6 +574,71 @@ mod tests { assert_eq!(answered(&out), vec![c]); } + fn ranks(a: &[Action]) -> Vec> { + a.iter().filter_map(|x| if let Action::Rank(c) = x { Some(c.iter().map(|r| r.id).collect()) } else { None }) + .collect() + } + + #[test] + fn important_asks_the_ranking_when_a_new_request_ties_the_running_answer() { + let s = PolicySettings { kind: PolicyKind::Important, collect: Duration::ZERO, ..PolicySettings::default() }; + // The ranking says the new one matters more: the answer stops for it. + let mut t = T::with(s.clone()); + let (a, _) = t.call(A, true, 0, 100); + let (b, out) = t.call(B, true, 200, 300); + assert_eq!(ranks(&out), vec![vec![a, b]]); + assert!(stopped(&out).is_empty(), "keeps speaking while ranking"); + let out = t.p.ranked(&[b, a], t.at(400)); + assert_eq!(stopped(&out), vec![a]); + assert_eq!(missed(&out), vec![(a, MissReason::Interrupted)]); + assert_eq!(answered(&out), vec![b]); + // The ranking keeps the running answer: the new one waits for it. + let mut t = T::with(s.clone()); + let (a, _) = t.call(A, true, 0, 100); + let (b, _) = t.call(B, true, 200, 300); + assert!(stopped(&t.p.ranked(&[a, b], t.at(400))).is_empty()); + assert_eq!(answered(&t.p.answer_done(a, t.at(1000))), vec![b]); + // No ranking in time: the running answer ended first, so it goes on. + let mut t = T::with(s); + let (a, _) = t.call(A, true, 0, 100); + let (b, _) = t.call(B, true, 200, 300); + assert!(stopped(&t.p.tick(t.at(300 + 1500))).is_empty()); + assert_eq!(answered(&t.p.answer_done(a, t.at(2000))), vec![b]); + } + + #[test] + fn a_ranking_after_its_deadline_counts_as_a_timeout() { + let mut t = T::new(PolicyKind::Important); + let (a, _) = t.call(A, true, 0, 100); + let (b, _) = t.call(B, true, 50, 200); + t.p.tick(t.at(800)); + assert_eq!(answered(&t.p.ranked(&[b, a], t.at(2400))), vec![a], "late: earliest-ended wins"); + } + + #[test] + fn candidates_collected_while_busy_keep_end_time_order_for_the_fallback() { + let mut t = T::with(PolicySettings { kind: PolicyKind::Important, collect: Duration::ZERO, + ..PolicySettings::default() }); + let (a, _) = t.call(A, false, 0, 100); + let (_late, _) = t.call(B, false, 900, 1000); + let (early, _) = t.call(C, false, 600, 1200); // ended first, arrived last + let out = t.p.answer_done(a, t.at(1300)); + assert_eq!(ranks(&out), vec![vec![early, _late]]); + assert_eq!(answered(&t.p.tick(t.at(1300 + 1500))), vec![early]); + } + + #[test] + fn a_finished_collect_timer_is_not_reported_again_while_settling() { + let mut t = T::new(PolicyKind::Important); + t.p.utterance_open(B); + t.p.speaking_stopped(B, t.at(50)); + let (a, _) = t.call(A, true, 0, 100); + assert_eq!(t.p.next_deadline(), Some(t.at(800))); + assert!(answered(&t.p.tick(t.at(800))).is_empty(), "still waiting for B"); + assert_eq!(t.p.next_deadline(), Some(t.at(100 + 800)), "the settle deadline, not the spent collect timer"); + assert_eq!(answered(&t.p.tick(t.at(900))), vec![a]); + } + #[test] fn stop_ends_the_answer_and_drops_the_queue_in_every_policy() { for kind in [PolicyKind::First, PolicyKind::InOrder, PolicyKind::Latest, PolicyKind::Important] {