feat(app): answer registered chat channels in chat
- chatChannels[].answer: wakeWord (default) or everything. Chat uses call.chatWakeWords (else the voice wake words) with the shared designated-people switches. - The brain's answer (reply via chat, not spoken) is posted as a Discord reply to the message, pinging nobody; failed or empty answers post nothing. Bots, channels with sending off and stops are not answered. - Chat runs beside the voice conversation and never takes its turn. - Core: send_chat_reply, chat_answer and the ReplyText event; the worker client's reply takes via. - Specs (conversation, discord core) and the roadmap updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -178,7 +178,7 @@ mod tests {
|
||||
|
||||
fn ch(id: u64, read: bool, send: bool) -> ChatChannelSettings {
|
||||
ChatChannelSettings { id, name: String::new(), description: String::new(), read, send, edit: true,
|
||||
react: true, delete: false, pin: false }
|
||||
react: true, delete: false, pin: false, answer_all: false }
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -30,6 +30,10 @@ pub trait Voice {
|
||||
fn stop_all(&self);
|
||||
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, text: &str) -> bool;
|
||||
/// Post `text` in `channel` as a reply to `message` (never pinging anyone).
|
||||
fn send_reply(&self, channel: u64, message: u64, text: &str);
|
||||
}
|
||||
|
||||
impl Voice for DiscordCore {
|
||||
@@ -48,8 +52,53 @@ impl Voice for DiscordCore {
|
||||
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, text: &str) -> bool {
|
||||
DiscordCore::chat_answer(self, id, user, text)
|
||||
}
|
||||
fn send_reply(&self, channel: u64, message: u64, text: &str) {
|
||||
let core = self.clone();
|
||||
let text = text.to_owned();
|
||||
tokio::spawn(async move {
|
||||
if let Err(e) = core.send_chat_reply(channel, message, &text).await {
|
||||
crate::error_log!("conversation", "could not post the chat answer in {channel}: {e}");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// 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);
|
||||
|
||||
/// 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 {
|
||||
@@ -70,12 +119,49 @@ pub struct Conversation<V: Voice> {
|
||||
/// Ask id -> the request it becomes on a yes, and when it was asked.
|
||||
asks: HashMap<String, (Request, Instant)>,
|
||||
missed: VecDeque<Missed>,
|
||||
chat: ChatCalls,
|
||||
/// Chat answer id -> the message it answers (channel, message) and when it was asked.
|
||||
chat_answers: HashMap<String, (u64, u64, Instant)>,
|
||||
}
|
||||
|
||||
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: VecDeque::new() }
|
||||
by_speech: HashMap::new(), asks: HashMap::new(), missed: VecDeque::new(), chat: ChatCalls::default(),
|
||||
chat_answers: HashMap::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.content) {
|
||||
self.chat_answers.insert(id, (m.channel_id, m.message_id, now));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn missed(&self) -> impl Iterator<Item = &Missed> {
|
||||
@@ -85,6 +171,15 @@ impl<V: Voice> Conversation<V> {
|
||||
pub fn on_event(&mut self, ev: &CoreEvent, now: Instant) {
|
||||
match ev {
|
||||
CoreEvent::SpeechStart(h) => self.policy.utterance_open(h.speaker_id),
|
||||
CoreEvent::Chat(m) => self.on_chat(m, now),
|
||||
CoreEvent::ReplyText { id, text, failed } => {
|
||||
if let Some((channel, message, _)) = self.chat_answers.remove(id) {
|
||||
debug_log!("conversation", "chat answer {id} chars={} failed={failed}", text.chars().count());
|
||||
if !failed && !text.trim().is_empty() {
|
||||
self.voice.send_reply(channel, message, text);
|
||||
}
|
||||
}
|
||||
}
|
||||
CoreEvent::SpeakingStopped(user) => self.policy.speaking_stopped(*user, now),
|
||||
CoreEvent::Final(f) => {
|
||||
let speaker = f.heard.speaker_id;
|
||||
@@ -266,6 +361,8 @@ mod tests {
|
||||
StopAll,
|
||||
Addressed(String, u64),
|
||||
Rank(String, Vec<String>),
|
||||
ChatAnswer(String, u64, String),
|
||||
SendReply(u64, u64, String),
|
||||
}
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
@@ -293,6 +390,13 @@ mod tests {
|
||||
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, text: &str) -> bool {
|
||||
self.did.borrow_mut().push(Did::ChatAnswer(id.into(), user, text.into()));
|
||||
true
|
||||
}
|
||||
fn send_reply(&self, channel: u64, message: u64, text: &str) {
|
||||
self.did.borrow_mut().push(Did::SendReply(channel, message, text.into()));
|
||||
}
|
||||
}
|
||||
impl Fake {
|
||||
fn take(&self) -> Vec<Did> {
|
||||
@@ -445,6 +549,82 @@ mod tests {
|
||||
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 c = Conversation::new(f.clone(), CallSettings::default(), 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, "자비스 내일 일정 알려 줘"));
|
||||
c.on_event(&CoreEvent::ReplyText { id: id.clone(), text: "내일은 비어 있어요.".into(), failed: false }, t);
|
||||
assert_eq!(f.take(), vec![Did::SendReply(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!(f.take().is_empty());
|
||||
assert_eq!(c.missed().count(), 0, "a chat message never takes the voice turn");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end_times_come_from_the_finals_wait() {
|
||||
let (mut c, f, t) = conv(PolicyKind::InOrder, CallMode::WakeWord);
|
||||
|
||||
@@ -114,12 +114,36 @@ request first, the answer stops (missed, `interrupted`) and the new request is a
|
||||
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.
|
||||
|
||||
## Chat calls
|
||||
|
||||
Registered chat channels are answered in chat, by text, beside the voice conversation: a chat message
|
||||
never takes the voice turn and never goes through the response policy.
|
||||
|
||||
| Key | Default | Meaning |
|
||||
|---|---|---|
|
||||
| `chatChannels[].answer` | `"wakeWord"` | `wakeWord`: answer messages that call a wake word. `everything`: answer every message. |
|
||||
|
||||
- The wake words are `call.chatWakeWords` (or `voice.wakeWords` when it is `null`), with the same
|
||||
similarity and the same designated-people switches as voice; `call.mode` is voice only.
|
||||
- Only messages of a registered channel with reading on reach the loop (the core's rule), and only a
|
||||
channel with sending on is answered: there an answer could not be posted, so none is asked for.
|
||||
- Messages from bots (other bots and Jarvis itself) are never answered, so two bots cannot keep
|
||||
answering each other.
|
||||
- Only a request is answered: a stop in chat ("자비스 멈춰") is not a question and gets no answer.
|
||||
- The brain answers through `reply` with `via: "chat"` and `speak: false`; the answer is posted in the
|
||||
same channel as a Discord reply to the message (so the history records it as an answer to that
|
||||
person), pinging nobody. A failed or empty answer posts nothing. Answers waited for over 5 minutes
|
||||
are forgotten.
|
||||
- Known limit: the worker writes one reply at a time, so a voice answer waits while a chat answer is
|
||||
being written (the LLM's parallel requests for "answer everything" channels are M5/M6 settings).
|
||||
|
||||
## The conversation loop
|
||||
|
||||
`app/src/conversation.rs` runs between the core's events and everything else that reads them (every
|
||||
event is passed on unchanged). It talks to the core through a small `Voice` interface (answer, cancel
|
||||
one request, stop all, ask "addressed", ask "rank"), so the glue is tested with a fake.
|
||||
|
||||
- `Chat` and `ReplyText`: chat calls, above.
|
||||
- `SpeechStart` opens the speaker's utterance; `SpeakingStopped` marks it ending.
|
||||
- `Final`: a request gets the next id, `ended_at` = arrival minus the final's `wait_ms`, and goes
|
||||
through call detection. Ignore closes the utterance. Stop stops all speech, runs the policy's stop,
|
||||
@@ -149,5 +173,6 @@ modes) and every policy rule above with fake times (settling, ordering by end ti
|
||||
interruption, ranking tie, ranking timeout, stop dropping the queue), and the conversation loop with a
|
||||
fake voice side (answering and queueing, a busy drop recorded without text, voice stop, addressed yes,
|
||||
no and timeout, interruption cancelling the right speech, a ranking deciding, end times from
|
||||
`wait_ms`). `tests/worker_protocol.rs` checks an answer spoken under its id and both judgements against
|
||||
`wait_ms`, and chat: an answer posted as a reply once, per-channel switches, no answers to bots or to
|
||||
a stop, chat wake words and designated people, a failed answer posting nothing). `tests/worker_protocol.rs` checks an answer spoken under its id and both judgements against
|
||||
the real Python worker with a fake brain.
|
||||
|
||||
@@ -67,6 +67,8 @@ pub enum CoreEvent {
|
||||
/// `SpeakEnd`s of what it stopped.
|
||||
Stopped,
|
||||
Chat(ChatMessage),
|
||||
/// The brain's answer text for a `reply` (`answer()` or `chat_answer()`).
|
||||
ReplyText { id: String, text: String, failed: bool },
|
||||
/// The brain's answer to `addressed()`.
|
||||
Addressed { id: String, addressed: bool },
|
||||
/// The brain's answer to `rank()`: candidate ids, most important first (empty: failed).
|
||||
@@ -405,10 +407,15 @@ impl DiscordCore {
|
||||
pub fn answer(&self, user: u64, text: &str) -> Option<String> {
|
||||
self.voice_channel_id()?;
|
||||
let id = with_playback(&self.inner, |p| p.adopt());
|
||||
self.inner.worker.reply(&id, user, text, true);
|
||||
self.inner.worker.reply(&id, user, text, "voice", true);
|
||||
Some(id)
|
||||
}
|
||||
|
||||
/// Have the brain answer a chat message under `id`; the text comes as `CoreEvent::ReplyText`.
|
||||
pub fn chat_answer(&self, id: &str, user: u64, text: &str) -> bool {
|
||||
self.inner.worker.reply(id, user, text, "chat", false)
|
||||
}
|
||||
|
||||
/// Stop one request (an answer or a `say`); the rest of the queue goes on.
|
||||
pub fn cancel(&self, id: &str) {
|
||||
with_playback(&self.inner, |p| p.cancel(id));
|
||||
@@ -474,6 +481,27 @@ impl DiscordCore {
|
||||
Ok(ids)
|
||||
}
|
||||
|
||||
/// Send `text` to a registered channel as a reply to `message` (the first part carries the reply;
|
||||
/// nobody is pinged, not even the person answered). The message ids.
|
||||
pub async fn send_chat_reply(&self, channel_id: u64, message: u64, text: &str) -> Result<Vec<u64>, CoreError> {
|
||||
self.inner.chat.check_send(channel_id)?;
|
||||
if text.trim().is_empty() {
|
||||
return Err(CoreError("nothing to send".into()));
|
||||
}
|
||||
let http = self.http()?;
|
||||
let mut ids = vec![];
|
||||
for (i, part) in split_message(text, MESSAGE_LIMIT).into_iter().enumerate() {
|
||||
let mut m = CreateMessage::new().content(part).allowed_mentions(CreateAllowedMentions::new().replied_user(false));
|
||||
if i == 0 {
|
||||
m = m.reference_message((ChannelId::new(channel_id), MessageId::new(message)));
|
||||
}
|
||||
let sent = ChannelId::new(channel_id).send_message(http.as_ref(), m).await.map_err(cerr("could not send"))?;
|
||||
ids.push(sent.id.get());
|
||||
}
|
||||
debug_log!("chat", "chat answer sent to {channel_id} parts={} chars={}", ids.len(), text.chars().count());
|
||||
Ok(ids)
|
||||
}
|
||||
|
||||
/// Do what the brain's chat channel tool asked (chat_channels.spec.md). The message ids made or
|
||||
/// touched. Every action needs its channel switch; edits only the bot's own messages.
|
||||
pub async fn chat_action(&self, a: &ChatAction) -> Result<Vec<u64>, CoreError> {
|
||||
@@ -660,6 +688,7 @@ async fn worker_task(core: std::sync::Weak<Inner>, mut rx: mpsc::UnboundedReceiv
|
||||
WorkerEvent::TtsDone(d) => with_playback(&inner, |p| p.done(&d)),
|
||||
WorkerEvent::ReplyText { id, text, failed } => {
|
||||
debug_log!("voice", "reply {id} chars={} failed={failed}", text.chars().count());
|
||||
let _ = inner.events.send(CoreEvent::ReplyText { id, text, failed });
|
||||
}
|
||||
WorkerEvent::Addressed { id, addressed } => {
|
||||
let _ = inner.events.send(CoreEvent::Addressed { id, addressed });
|
||||
|
||||
@@ -67,7 +67,7 @@ strings (numbers would lose precision).
|
||||
| `voice.joinNotice` | "자비스가 이 음성 채널에 들어왔습니다. 이 채널의 대화는 자비스가 받아 적습니다." | Posted in the voice channel's chat on every join. Must not be empty. |
|
||||
| `voice.wakeWords` | `["자비스"]` | Sent to the worker as STT `hotwords`, and the voice wake words of call detection. |
|
||||
| `voice.stt` | `{}` | Other worker STT settings (`partials`, `end_silence_ms`, `final_beam`, `language`, ...); the worker validates them. |
|
||||
| `chatChannels` | `[]` | `{id, name, description, read (true), send (true), edit (true), react (true), delete (false), pin (false)}` per channel. |
|
||||
| `chatChannels` | `[]` | `{id, name, description, read (true), send (true), edit (true), react (true), delete (false), pin (false), answer ("wakeWord")}` per channel; `answer` is in `conversation.spec.md`. |
|
||||
| `voiceWorker.python` | `python3` (`python.exe` on Windows) | Python of the worker venv. |
|
||||
| `voiceWorker.cwd` | the repo's `src/` (development builds) | Folder holding the `voice_worker` package. |
|
||||
| `voiceWorker.args` | `[]` | Extra worker arguments, e.g. `["--melo-python", "<MeloTTS venv python>"]`. |
|
||||
@@ -188,6 +188,9 @@ registered until it is removed (M5 setup).
|
||||
- **Send**: `send_chat(channel_id, text)` sends to a registered channel with sending on, split at
|
||||
Discord's 2,000-character limit at the last newline or space (never inside a character), and returns
|
||||
the message ids.
|
||||
- **Answer** (M4): `send_chat_reply(channel_id, message_id, text)` sends like Send, with the first
|
||||
part as a Discord reply to the message; nobody is pinged, not even its author. `chat_answer(id, user,
|
||||
text)` asks the brain for a chat answer (`reply` with `via: "chat"`); its text comes as `ReplyText`.
|
||||
- A channel that is not registered, or has the needed switch off, is refused with an access error.
|
||||
- **Chat tool actions** (M3, `chat_channels.spec.md`): when the worker link is ready and after login,
|
||||
the core sends `chat_channels` (every registered channel with its switches, and the bot's user ID).
|
||||
|
||||
@@ -56,10 +56,12 @@ pub async fn start_services(data_dir: &Path) -> Result<Services, Box<dyn std::er
|
||||
});
|
||||
|
||||
let (calls, response) = (settings.call.clone(), settings.response.clone());
|
||||
let chat_calls = conversation::ChatCalls::from_settings(&settings);
|
||||
let (core, core_events) = DiscordCore::new(settings, token, worker.clone(), worker_events);
|
||||
// Call detection and the response policy answer what is heard; every event still reaches `events`.
|
||||
let (out, events) = mpsc::unbounded_channel();
|
||||
tokio::spawn(conversation::run(Conversation::new(core.clone(), calls, response), core_events, out));
|
||||
let conv = Conversation::new(core.clone(), calls, response).with_chat(chat_calls);
|
||||
tokio::spawn(conversation::run(conv, core_events, out));
|
||||
if let Err(e) = core.start().await {
|
||||
worker.close();
|
||||
worker_process.stop().await;
|
||||
|
||||
@@ -30,6 +30,9 @@ pub struct ChatChannelSettings {
|
||||
pub delete: bool,
|
||||
/// The assistant may pin and unpin messages here. Off by default.
|
||||
pub pin: bool,
|
||||
/// Answer every message here (`answer: "everything"`), not only those calling a wake word (`"wakeWord"`,
|
||||
/// the default; conversation.spec.md).
|
||||
pub answer_all: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
@@ -349,6 +352,11 @@ pub fn parse_settings(raw: &Value) -> Result<Settings, SettingsError> {
|
||||
react: get_bool(Some(m), "react", &path, true)?,
|
||||
delete: get_bool(Some(m), "delete", &path, false)?,
|
||||
pin: get_bool(Some(m), "pin", &path, false)?,
|
||||
answer_all: match get_str(Some(m), "answer", &path, "wakeWord")?.as_str() {
|
||||
"wakeWord" => false,
|
||||
"everything" => true,
|
||||
_ => return err(format!("{path}.answer must be wakeWord or everything")),
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -435,7 +443,7 @@ mod tests {
|
||||
assert_eq!(s.voice.stt.get("end_silence_ms"), Some(&json!(250)));
|
||||
assert_eq!(s.chat_channels, vec![ChatChannelSettings { id: IDN, name: "일정".into(),
|
||||
description: "일정 올리는 곳".into(), read: true, send: false, edit: true, react: true, delete: false,
|
||||
pin: false }]);
|
||||
pin: false, answer_all: false }]);
|
||||
assert_eq!(s.voice_worker.args, vec!["--melo-python", "/m/python"]);
|
||||
assert_eq!(s.voice_worker.cwd, PathBuf::from("/repo/src"));
|
||||
}
|
||||
@@ -453,6 +461,7 @@ mod tests {
|
||||
(json!({"chatChannels": [{"id": ID}, {"id": ID}]}), "twice"),
|
||||
(json!({"chatChannels": [{"id": "1"}]}), "chatChannels[0].id"),
|
||||
(json!({"chatChannels": {}}), "chatChannels"),
|
||||
(json!({"chatChannels": [{"id": ID, "answer": "sometimes"}]}), "chatChannels[0].answer"),
|
||||
(json!({"voice": []}), "voice"),
|
||||
(json!([]), "object"),
|
||||
];
|
||||
@@ -483,6 +492,8 @@ mod tests {
|
||||
assert_eq!(s.response.collect, Duration::from_millis(500));
|
||||
assert_eq!(s.response.settle, Duration::ZERO);
|
||||
assert_eq!(s.response.priorities.get(&IDN), Some(&2));
|
||||
let s = parse_settings(&json!({"chatChannels": [{"id": ID, "answer": "everything"}]})).unwrap();
|
||||
assert!(s.chat_channels[0].answer_all);
|
||||
|
||||
let cases = [
|
||||
(json!({"call": {"similarity": 0.9}}), "call.similarity"),
|
||||
|
||||
@@ -312,12 +312,13 @@ impl WorkerClient {
|
||||
/// Ask the brain to answer `user`. With `speak` the answer is spoken under `id` (its audio and
|
||||
/// `tts_done` come like a TTS request's); it ends as failed when it cannot be sent, the brain gives
|
||||
/// no answer, or the worker refuses it.
|
||||
pub fn reply(&self, id: &str, user: u64, text: &str, speak: bool) -> bool {
|
||||
/// `via`: `voice` or `chat` (the brain's history scope and where the answer is stored).
|
||||
pub fn reply(&self, id: &str, user: u64, text: &str, via: &str, speak: bool) -> bool {
|
||||
if speak {
|
||||
self.inner.state.lock().unwrap().open_tts.insert(id.to_owned());
|
||||
}
|
||||
let sent = self.send_json(json!({"type": "reply", "id": id, "user": user.to_string(), "text": text,
|
||||
"via": "voice", "speak": speak}));
|
||||
"via": via, "speak": speak}));
|
||||
if !sent && speak {
|
||||
self.end_failed(id);
|
||||
}
|
||||
|
||||
@@ -268,7 +268,7 @@ async fn chat_channels_go_out_and_chat_actions_come_back_with_their_results() {
|
||||
c.start();
|
||||
c.wait_ready(Duration::from_secs(2)).await.expect("ready");
|
||||
c.chat_channels(Some(900), &[ChatChannelSettings { id: 5, name: "일정".into(), description: "약속".into(),
|
||||
read: true, send: true, edit: true, react: true, delete: false, pin: false }]);
|
||||
read: true, send: true, edit: true, react: true, delete: false, pin: false, answer_all: false }]);
|
||||
w.send(Message::text(json!({"type": "chat_action", "id": "a1", "action": "react", "channel": "5",
|
||||
"message_id": "77", "emoji": "👍"}).to_string()));
|
||||
let ev = next_matching(&mut rx, |e| matches!(e, WorkerEvent::ChatAction(_))).await;
|
||||
@@ -293,8 +293,8 @@ async fn a_spoken_reply_takes_its_audio_and_a_failed_one_ends_its_speech() {
|
||||
let (c, mut rx) = client(&w.url(), json!({}));
|
||||
c.start();
|
||||
c.wait_ready(Duration::from_secs(2)).await.expect("ready");
|
||||
assert!(c.reply("r1", 42, "자비스 날씨 어때", true));
|
||||
assert!(c.reply("r2", 43, "자비스 안녕", true));
|
||||
assert!(c.reply("r1", 42, "자비스 날씨 어때", "voice", true));
|
||||
assert!(c.reply("r2", 43, "자비스 안녕", "voice", true));
|
||||
until(|| w.got().len() >= 3).await;
|
||||
assert_eq!(w.got()[1], Got::Json(json!({"type": "reply", "id": "r1", "user": "42", "text": "자비스 날씨 어때",
|
||||
"via": "voice", "speak": true})));
|
||||
@@ -317,14 +317,14 @@ async fn a_reply_the_worker_cannot_answer_or_send_ends_as_failed() {
|
||||
let (c, mut rx) = client(&w.url(), json!({}));
|
||||
c.start();
|
||||
c.wait_ready(Duration::from_secs(2)).await.expect("ready");
|
||||
c.reply("r3", 42, "x", true);
|
||||
c.reply("r3", 42, "x", "voice", true);
|
||||
w.send(Message::text(json!({"type": "error", "code": "brain_unavailable", "message": "no", "id": "r3"}).to_string()));
|
||||
let e = next_matching(&mut rx, |e| matches!(e, WorkerEvent::TtsDone(_))).await;
|
||||
assert_eq!(e, WorkerEvent::TtsDone(TtsDone { id: "r3".into(), chunks: 0, cancelled: false, failed: true }));
|
||||
c.close();
|
||||
|
||||
let (c, mut rx) = client("ws://127.0.0.1:1", json!({}));
|
||||
assert!(!c.reply("r4", 42, "x", true));
|
||||
assert!(!c.reply("r4", 42, "x", "voice", true));
|
||||
let e = next_matching(&mut rx, |_| true).await;
|
||||
assert_eq!(e, WorkerEvent::TtsDone(TtsDone { id: "r4".into(), chunks: 0, cancelled: false, failed: true }));
|
||||
}
|
||||
@@ -359,3 +359,20 @@ async fn addressed_and_rank_questions_go_out_and_their_answers_come_back() {
|
||||
assert_eq!(e, WorkerEvent::Ranked { id: "k4".into(), order: vec![] });
|
||||
c.close();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_chat_reply_is_not_spoken_and_its_text_comes_back() {
|
||||
let w = FakeWorker::start(0).await;
|
||||
let (c, mut rx) = client(&w.url(), json!({}));
|
||||
c.start();
|
||||
c.wait_ready(Duration::from_secs(2)).await.expect("ready");
|
||||
assert!(c.reply("c1", 42, "자비스 일정", "chat", false));
|
||||
until(|| w.got().len() >= 2).await;
|
||||
assert_eq!(w.got()[1], Got::Json(json!({"type": "reply", "id": "c1", "user": "42", "text": "자비스 일정",
|
||||
"via": "chat", "speak": false})));
|
||||
w.send(tts_frame("c1", 0)); // not a speech the app asked for
|
||||
w.send(Message::text(json!({"type": "reply_text", "id": "c1", "text": "", "failed": true}).to_string()));
|
||||
let e = next_matching(&mut rx, |e| !matches!(e, WorkerEvent::Ready(_))).await;
|
||||
assert_eq!(e, WorkerEvent::ReplyText { id: "c1".into(), text: String::new(), failed: true });
|
||||
c.close();
|
||||
}
|
||||
|
||||
@@ -108,7 +108,7 @@ async fn audio_and_tts_round_trip_through_the_python_server() {
|
||||
|
||||
// A spoken brain answer plays under the adopted id, like a TTS request.
|
||||
let id = p.adopt();
|
||||
assert!(c.reply(&id, 42, "자비스 안녕", true));
|
||||
assert!(c.reply(&id, 42, "자비스 안녕", "voice", true));
|
||||
let end = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
match rx.recv().await.unwrap() {
|
||||
|
||||
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user