- Tool (chat_channels.spec.md): list, read, search, send, edit, react,
delete, pin, unpin. Offered only when the v2 brain gives the turn a chat
backend, and then on every turn. Channel by ID, name, part of a name or a
name inside the text; a message ID finds its channel; planner forms of the
action ("send_message") work. Read and search results are fenced as
untrusted data. delete only reports until called again with confirm=true
in a later turn of the same person.
- Worker: chat_channels from the app, ChatBridge reads/searches the history
store and sends chat_action, waiting for chat_action_result (15 s timeout,
failed on session close); per-person reply turns and pending deletes.
- App: channel switches edit/react (on) and delete/pin (off); chat_channels
sent on worker ready and after login; chat_action runs send, edit (own
messages only), react, delete, pin, unpin and answers with ids or the error.
- Engine: chatChannels left out of the catalogue without a backend; the
"router returned everything" check now tolerates that.
- live_discord: edit own, refuse editing the speaker's, react, pin (Discord
refuses in a voice channel's chat, reported as an error), delete, refuse an
unregistered channel; passed in 109.4 s.
- Eval (qwen2.5:7b, 3 runs): 10 of 12; never obeyed the "delete everything"
message and never deleted in the same turn.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
494 lines
27 KiB
Rust
494 lines
27 KiB
Rust
//! The Discord voice core end to end on real Discord, with the real voice worker on the GPU.
|
|
//!
|
|
//! Two bots in one voice channel: the "Jarvis" bot runs the core; the "speaker" bot plays recorded
|
|
//! Korean speech into the channel, records what Jarvis says, and writes in the channel's chat.
|
|
//! Opt-in; it refuses to run if a person is in the channel or either bot is already in voice.
|
|
//!
|
|
//! JARVIS_LIVE_DISCORD=1 JARVIS_LIVE_BOT_TOKEN=... JARVIS_LIVE_SPEAKER_TOKEN=... \
|
|
//! JARVIS_LIVE_GUILD=<server id> JARVIS_LIVE_VOICE_CHANNEL=<voice channel id> \
|
|
//! JARVIS_LIVE_VOICE_CHANNEL_2=<another voice channel of that server> \
|
|
//! JARVIS_VOICE_PYTHON=<worker venv python> JARVIS_MELO_PYTHON=<MeloTTS venv python> \
|
|
//! cargo test --release --test live_discord -- --nocapture
|
|
//!
|
|
//! On Linux, put the pip CUDA libraries on LD_LIBRARY_PATH (nvidia/cublas/lib, nvidia/cudnn/lib).
|
|
|
|
use std::collections::HashMap;
|
|
use std::path::Path;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::time::{Duration, Instant};
|
|
|
|
use async_trait::async_trait;
|
|
use jarvis_app::discord::{CoreEvent, DiscordCore};
|
|
use jarvis_app::receive::{opus_payload, OpusFrames, SpeakerStream};
|
|
use jarvis_app::settings::parse_settings;
|
|
use jarvis_app::worker_client::{WorkerClient, WorkerClientOptions, WorkerEvent};
|
|
use jarvis_app::worker_process::{ProcessEvent, WorkerProcess, WorkerProcessOptions};
|
|
use serde_json::{json, Value};
|
|
use serenity::all::{ChannelId, Client, Context, CreateMessage, EventHandler, GatewayIntents, GuildId, Http, Ready, UserId};
|
|
use songbird::driver::DecodeMode;
|
|
use songbird::input::Input;
|
|
use songbird::{Config, CoreEvent as VoiceEv, Event, EventContext, EventHandler as VoiceHandler, SerenityInit, Songbird, TrackEvent};
|
|
use tokio::sync::mpsc;
|
|
|
|
const COMMAND: &str = "jarvis-live-test";
|
|
|
|
fn env(k: &str) -> String {
|
|
std::env::var(k).unwrap_or_else(|_| panic!("{k} is not set"))
|
|
}
|
|
|
|
fn cer(reference: &str, hyp: &str) -> f64 {
|
|
let norm = |s: &str| s.chars().filter(|c| c.is_alphanumeric()).collect::<Vec<_>>();
|
|
let (a, b) = (norm(reference), norm(hyp));
|
|
let mut prev: Vec<usize> = (0..=b.len()).collect();
|
|
for i in 1..=a.len() {
|
|
let mut cur = vec![i];
|
|
for j in 1..=b.len() {
|
|
cur.push((prev[j] + 1).min(cur[j - 1] + 1).min(prev[j - 1] + usize::from(a[i - 1] != b[j - 1])));
|
|
}
|
|
prev = cur;
|
|
}
|
|
prev[b.len()] as f64 / a.len().max(1) as f64
|
|
}
|
|
|
|
/// Seconds into a 16 kHz mono PCM16 WAV where the last sound above -34 dBFS ends.
|
|
fn speech_end_seconds(wav: &[u8]) -> f64 {
|
|
let data = &wav[44..];
|
|
let n = data.len() / 2;
|
|
(0..n).rev().find(|&k| i16::from_le_bytes([data[2 * k], data[2 * k + 1]]).unsigned_abs() > 655)
|
|
.map_or(0.0, |k| (k + 1) as f64 / 16000.0)
|
|
}
|
|
|
|
struct ReadyOnce(mpsc::UnboundedSender<Ready>);
|
|
#[async_trait]
|
|
impl EventHandler for ReadyOnce {
|
|
async fn ready(&self, _: Context, r: Ready) {
|
|
let _ = self.0.send(r);
|
|
}
|
|
}
|
|
|
|
/// Jarvis's voice as the speaker bot hears it, decoded the same way the core decodes (songbird's
|
|
/// own decoder garbles DAVE audio, see src/receive.rs).
|
|
#[derive(Clone, Default)]
|
|
struct Ears {
|
|
jarvis: u64,
|
|
ssrc: Arc<Mutex<HashMap<u32, u64>>>,
|
|
stream: Arc<Mutex<Option<SpeakerStream<OpusFrames>>>>,
|
|
pcm: Arc<Mutex<Vec<i16>>>,
|
|
/// When the last audible frame arrived.
|
|
last_packet: Arc<Mutex<Option<Instant>>>,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl VoiceHandler for Ears {
|
|
async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
|
|
match ctx {
|
|
EventContext::SpeakingStateUpdate(s) => {
|
|
if let Some(u) = s.user_id {
|
|
self.ssrc.lock().unwrap().insert(s.ssrc, u.0);
|
|
}
|
|
}
|
|
EventContext::RtpPacket(p) => {
|
|
let (seq, ssrc, opus) = opus_payload(&p.packet, p.payload_offset, p.payload_end_pad)?;
|
|
if self.ssrc.lock().unwrap().get(&ssrc) != Some(&self.jarvis) {
|
|
return None;
|
|
}
|
|
let mut st = self.stream.lock().unwrap();
|
|
let frames = st.get_or_insert_with(|| SpeakerStream::new(OpusFrames::new())).push(seq, opus.to_vec());
|
|
let mut pcm = self.pcm.lock().unwrap();
|
|
for f in frames {
|
|
// Audible: louder than -36 dBFS. The sender's closing silence frames do not count.
|
|
let rms = (f.iter().map(|&x| f64::from(x).powi(2)).sum::<f64>() / f.len().max(1) as f64).sqrt();
|
|
if rms > 500.0 {
|
|
*self.last_packet.lock().unwrap() = Some(Instant::now());
|
|
}
|
|
pcm.extend_from_slice(&f);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
struct Ended(mpsc::UnboundedSender<()>);
|
|
#[async_trait]
|
|
impl VoiceHandler for Ended {
|
|
async fn act(&self, _: &EventContext<'_>) -> Option<Event> {
|
|
let _ = self.0.send(());
|
|
None
|
|
}
|
|
}
|
|
|
|
async fn until(what: &str, ms: u64, mut pred: impl FnMut() -> bool) {
|
|
let deadline = Instant::now() + Duration::from_millis(ms);
|
|
while !pred() {
|
|
assert!(Instant::now() < deadline, "timed out waiting for {what}");
|
|
tokio::time::sleep(Duration::from_millis(20)).await;
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn discord_voice_core_on_real_discord() {
|
|
if std::env::var("JARVIS_LIVE_DISCORD").as_deref() != Ok("1") {
|
|
eprintln!("skipped: set JARVIS_LIVE_DISCORD=1");
|
|
return;
|
|
}
|
|
let guild: u64 = env("JARVIS_LIVE_GUILD").parse().unwrap();
|
|
let voice: u64 = env("JARVIS_LIVE_VOICE_CHANNEL").parse().unwrap();
|
|
let voice2: u64 = env("JARVIS_LIVE_VOICE_CHANNEL_2").parse().unwrap();
|
|
let bot_token = env("JARVIS_LIVE_BOT_TOKEN");
|
|
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
|
|
let samples = root.join("../scripts/m0/assets/ko_samples");
|
|
|
|
// The speaker bot first: it checks the channel is free before anything joins.
|
|
let speaker_songbird = Songbird::serenity_from_config(Config::default().decode_mode(DecodeMode::Decrypt));
|
|
let (rtx, mut rrx) = mpsc::unbounded_channel();
|
|
let mut speaker = Client::builder(env("JARVIS_LIVE_SPEAKER_TOKEN"),
|
|
GatewayIntents::GUILDS | GatewayIntents::GUILD_VOICE_STATES | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT)
|
|
.event_handler(ReadyOnce(rtx)).register_songbird_with(speaker_songbird.clone()).await.unwrap();
|
|
let (s_http, s_cache, s_shards) = (speaker.http.clone(), speaker.cache.clone(), speaker.shard_manager.clone());
|
|
tokio::spawn(async move { speaker.start().await.unwrap() });
|
|
let speaker_id = rrx.recv().await.unwrap().user.id.get();
|
|
let jarvis_app_id = Http::new(&bot_token).get_current_application_info().await.unwrap().id.get();
|
|
until("guild in cache", 10_000, || s_cache.guild(GuildId::new(guild)).is_some()).await;
|
|
{
|
|
let g = s_cache.guild(GuildId::new(guild)).unwrap();
|
|
let people = g.voice_states.values().filter(|v| v.channel_id.is_some_and(|c| c.get() == voice || c.get() == voice2)
|
|
&& !s_cache.user(v.user_id).map(|u| u.bot).unwrap_or(false)).count();
|
|
assert_eq!(people, 0, "refusing to test: people are in the voice channels");
|
|
for id in [speaker_id, jarvis_app_id] {
|
|
assert!(g.voice_states.get(&UserId::new(id)).and_then(|v| v.channel_id).is_none(),
|
|
"refusing to test: bot {id} is in a voice channel");
|
|
}
|
|
}
|
|
|
|
// The real voice worker.
|
|
// A fresh history store: the worker records what this test says and who was there.
|
|
let history_db = Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("live-history-{}.sqlite", std::process::id()));
|
|
let _ = std::fs::remove_file(&history_db);
|
|
let mut args = vec!["--history".to_string(), history_db.to_string_lossy().into_owned()];
|
|
if let Ok(m) = std::env::var("JARVIS_MELO_PYTHON") {
|
|
args.extend(["--melo-python".to_string(), m]);
|
|
}
|
|
let wp = WorkerProcess::new(WorkerProcessOptions::new(env("JARVIS_VOICE_PYTHON"), root.join("../src"), args)).unwrap();
|
|
let mut pev = wp.subscribe();
|
|
wp.start();
|
|
tokio::time::timeout(Duration::from_secs(240), async {
|
|
while pev.recv().await.unwrap() != ProcessEvent::Ready {}
|
|
}).await.expect("worker ready");
|
|
let mut wo = WorkerClientOptions::new(wp.url(), wp.token.clone());
|
|
wo.stt = json!({"hotwords": ["자비스"]}).as_object().unwrap().clone();
|
|
let (worker, worker_events) = WorkerClient::new(wo);
|
|
worker.start();
|
|
worker.wait_ready(Duration::from_secs(10)).await.expect("worker hello");
|
|
|
|
let settings = parse_settings(&json!({
|
|
"discord": {"guildId": guild.to_string(), "voiceChannelId": voice.to_string(), "commandName": COMMAND},
|
|
// The "person" here is a bot, so bots must be heard.
|
|
"voice": {"listenToBots": true},
|
|
// The voice channel's own chat stands in for a registered chat channel.
|
|
"chatChannels": [{"id": voice.to_string(), "name": "테스트", "description": "라이브 테스트",
|
|
"delete": true, "pin": true}],
|
|
})).unwrap();
|
|
let (core, mut core_rx) = DiscordCore::new(settings, bot_token.clone(), worker.clone(), worker_events);
|
|
let events: Arc<Mutex<Vec<CoreEvent>>> = Arc::default();
|
|
let ev2 = events.clone();
|
|
tokio::spawn(async move {
|
|
while let Some(e) = core_rx.recv().await {
|
|
ev2.lock().unwrap().push(e);
|
|
}
|
|
});
|
|
core.start().await.expect("core start"); // logs in, registers the command, auto-joins, posts the notice
|
|
assert_eq!(core.voice_channel_id(), Some(voice));
|
|
let jarvis = core.bot_id().unwrap();
|
|
|
|
let call = speaker_songbird.join(GuildId::new(guild), ChannelId::new(voice)).await.expect("speaker joins");
|
|
let ears = Ears { jarvis, ..Default::default() };
|
|
{
|
|
let mut c = call.lock().await;
|
|
c.add_global_event(VoiceEv::SpeakingStateUpdate.into(), ears.clone());
|
|
c.add_global_event(VoiceEv::RtpPacket.into(), ears.clone());
|
|
}
|
|
let mut report = serde_json::Map::new();
|
|
let steps = futures_util::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
|
|
|
|
// 1. The slash command is registered.
|
|
let jarvis_http = Http::new(&bot_token);
|
|
jarvis_http.set_application_id(jarvis_app_id.into());
|
|
let cmds = jarvis_http.get_guild_commands(GuildId::new(guild)).await.unwrap();
|
|
let cmd = cmds.iter().find(|c| c.name == COMMAND).expect("command registered");
|
|
let mut subs: Vec<_> = cmd.options.iter().map(|o| o.name.clone()).collect();
|
|
subs.sort();
|
|
assert_eq!(subs, ["join", "leave", "stop"]);
|
|
|
|
// 2. Recorded sentences played into the channel come back as the speaker's finals.
|
|
let refs: Value = serde_json::from_str(&std::fs::read_to_string(samples.join("refs.json")).unwrap()).unwrap();
|
|
let mut stt = vec![];
|
|
let mut total = 0.0;
|
|
for r in refs["samples"].as_array().unwrap().iter().take(5) {
|
|
let wav = std::fs::read(samples.join(r["file"].as_str().unwrap())).unwrap();
|
|
let reference = r["text"].as_str().unwrap();
|
|
let before = events.lock().unwrap().len();
|
|
let (etx, mut erx) = mpsc::unbounded_channel();
|
|
let track = call.lock().await.play_only_input(Input::from(wav.clone()));
|
|
track.add_event(Event::Track(TrackEvent::End), Ended(etx)).unwrap();
|
|
let deadline = Instant::now() + Duration::from_secs(5);
|
|
let started = loop {
|
|
if track.get_info().await.is_ok_and(|i| i.position > Duration::ZERO) {
|
|
break Instant::now();
|
|
}
|
|
assert!(Instant::now() < deadline, "timed out waiting for the track to play");
|
|
tokio::time::sleep(Duration::from_millis(10)).await;
|
|
};
|
|
let speech_end = started + Duration::from_secs_f64(speech_end_seconds(&wav));
|
|
let mut final_at = None;
|
|
until("final", 20_000, || {
|
|
let got = events.lock().unwrap()[before..].iter().any(|e| matches!(e, CoreEvent::Final(f) if f.heard.speaker_id == speaker_id));
|
|
if got && final_at.is_none() {
|
|
final_at = Some(Instant::now());
|
|
}
|
|
got
|
|
}).await;
|
|
tokio::time::timeout(Duration::from_secs(20), erx.recv()).await.expect("track end");
|
|
tokio::time::sleep(Duration::from_millis(800)).await;
|
|
let mine: Vec<_> = events.lock().unwrap()[before..].iter().filter_map(|e| match e {
|
|
CoreEvent::Final(f) if f.heard.speaker_id == speaker_id => Some(f.clone()),
|
|
_ => None,
|
|
}).collect();
|
|
let hyp = mine.iter().map(|f| f.text.as_str()).collect::<Vec<_>>().join(" ");
|
|
assert!(!mine[0].heard.speaker_name.is_empty());
|
|
let c = cer(reference, &hyp);
|
|
total += c;
|
|
let latency = final_at.unwrap().saturating_duration_since(speech_end).as_millis();
|
|
stt.push(json!({"ref": reference, "hyp": hyp, "cer": c, "speech_end_to_final_ms": latency,
|
|
"end_reason": mine.iter().map(|f| f.end_reason.clone()).collect::<Vec<_>>()}));
|
|
assert!(!hyp.is_empty(), "nothing heard for {reference}");
|
|
}
|
|
report.insert("stt".into(), Value::from(stt.clone()));
|
|
let mean = total / (stt.len() as f64);
|
|
assert!(mean < 0.15, "mean CER {mean}");
|
|
|
|
// 3. Jarvis speaks; the speaker bot hears it and the STT reads it back.
|
|
let text = "안녕하세요, 저는 자비스입니다. 디스코드 음성 연결을 확인하고 있어요.";
|
|
ears.pcm.lock().unwrap().clear();
|
|
let id = core.say(text, false).expect("in voice");
|
|
until("speech to end", 30_000, || events.lock().unwrap().iter().any(|e| matches!(e, CoreEvent::SpeakEnd(x) if x.id == id))).await;
|
|
let end = events.lock().unwrap().iter().find_map(|e| match e { CoreEvent::SpeakEnd(x) if x.id == id => Some(x.clone()), _ => None }).unwrap();
|
|
assert!(!end.cancelled && !end.failed && end.played == 2, "{end:?}");
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
let heard = ears.pcm.lock().unwrap().clone();
|
|
let seconds = heard.len() as f64 / 96000.0;
|
|
assert!(seconds > 2.0, "heard only {seconds} s");
|
|
let mut eo = WorkerClientOptions::new(wp.url(), wp.token.clone());
|
|
eo.stt = json!({"partials": false}).as_object().unwrap().clone();
|
|
let (echo, mut echo_rx) = WorkerClient::new(eo);
|
|
echo.start();
|
|
echo.wait_ready(Duration::from_secs(5)).await.unwrap();
|
|
for chunk in heard.chunks(1920) {
|
|
echo.send_audio("echo", chunk);
|
|
}
|
|
for _ in 0..25 {
|
|
echo.send_audio("echo", &[0; 1920]);
|
|
}
|
|
echo.speaking_end("echo");
|
|
let mut back = vec![];
|
|
let _ = tokio::time::timeout(Duration::from_secs(3), async {
|
|
while let Some(e) = echo_rx.recv().await {
|
|
if let WorkerEvent::Final(f) = e {
|
|
back.push(f.text);
|
|
}
|
|
}
|
|
}).await;
|
|
echo.close();
|
|
let hyp = back.join(" ");
|
|
report.insert("tts_read_back".into(), json!({"seconds": seconds, "hyp": hyp, "cer": cer(text, &hyp)}));
|
|
assert!(cer(text, &hyp) < 0.2, "read back: {hyp}");
|
|
|
|
// 4. Stop silences it within a few frames and cancels the rest.
|
|
let long = "이 문장은 정지 명령을 시험하려고 길게 말하는 첫 번째 문장입니다. 두 번째 문장도 꽤 길게 이어집니다. \
|
|
세 번째 문장까지 들리면 정지가 안 된 것입니다. 네 번째 문장은 절대 들리면 안 됩니다.";
|
|
let id = core.say(long, false).unwrap();
|
|
until("speech to start", 30_000, || events.lock().unwrap().iter().any(|e| *e == CoreEvent::SpeakStart(id.clone()))).await;
|
|
tokio::time::sleep(Duration::from_millis(1500)).await;
|
|
let stop_at = Instant::now();
|
|
assert_eq!(core.stop(), 1);
|
|
tokio::time::sleep(Duration::from_millis(1500)).await;
|
|
let ends: Vec<_> = events.lock().unwrap().iter().filter_map(|e| match e { CoreEvent::SpeakEnd(x) if x.id == id => Some(x.clone()), _ => None }).collect();
|
|
assert!(ends.len() == 1 && ends[0].cancelled, "{ends:?}");
|
|
let tail = ears.last_packet.lock().unwrap().map(|t| t.saturating_duration_since(stop_at).as_millis() as i64).unwrap_or(-1);
|
|
report.insert("last_sound_after_stop_ms".into(), json!(tail));
|
|
assert!(tail < 400, "audio went on {tail} ms after stop");
|
|
assert!(!core.speaking());
|
|
|
|
// 5. Chat: live event, history with the join notice, and a send that pings nobody.
|
|
let marker = format!("라이브 테스트 메시지 {}", stop_at.elapsed().as_nanos());
|
|
ChannelId::new(voice).send_message(&s_http, CreateMessage::new().content(&marker)).await.unwrap();
|
|
until("chat event", 10_000, || events.lock().unwrap().iter().any(|e| matches!(e, CoreEvent::Chat(c) if c.content == marker))).await;
|
|
let ev = events.lock().unwrap().iter().find_map(|e| match e { CoreEvent::Chat(c) if c.content == marker => Some(c.clone()), _ => None }).unwrap();
|
|
assert!(ev.channel_id == voice && ev.author_id == speaker_id && ev.author_is_bot && !ev.from_self);
|
|
let history = core.read_chat(voice, 20).await.unwrap();
|
|
assert!(history.iter().any(|m| m.content == marker && !m.from_self));
|
|
assert!(history.iter().any(|m| m.from_self && m.content.contains("받아 적습니다")), "join notice missing");
|
|
// An edit and a delete reach the history store.
|
|
let mut marker_msg = ChannelId::new(voice).messages(&s_http, serenity::all::GetMessages::new().limit(5)).await.unwrap()
|
|
.into_iter().find(|m| m.content == marker).unwrap();
|
|
let edited = format!("{marker} 수정");
|
|
marker_msg.edit(&s_http, serenity::all::EditMessage::new().content(&edited)).await.unwrap();
|
|
let doomed = ChannelId::new(voice).send_message(&s_http, CreateMessage::new().content("곧 지울 메시지")).await.unwrap();
|
|
tokio::time::sleep(Duration::from_millis(800)).await;
|
|
doomed.delete(&s_http).await.unwrap();
|
|
let reply = format!("자비스 답장 @everyone {}", stop_at.elapsed().as_nanos());
|
|
let ids = core.send_chat(voice, &reply).await.unwrap();
|
|
let sent = ChannelId::new(voice).message(&s_http, serenity::all::MessageId::new(ids[0])).await.unwrap();
|
|
assert_eq!(sent.content, reply);
|
|
assert!(!sent.mention_everyone);
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
assert!(!events.lock().unwrap().iter().any(|e| matches!(e, CoreEvent::Chat(c) if c.content == reply)));
|
|
|
|
// 5b. The chat tool's actions, as the worker asks for them: edit (own messages only), react, pin,
|
|
// unpin, delete; a switch that is off is refused.
|
|
let act = |action: &str, id: u64, text: Option<&str>, emoji: Option<&str>| jarvis_app::worker_client::ChatAction {
|
|
id: "live".into(), action: action.into(), channel: voice.to_string(), message_id: Some(id.to_string()),
|
|
text: text.map(Into::into), emoji: emoji.map(Into::into) };
|
|
let tool_msg = format!("자비스 도구 시험 {}", stop_at.elapsed().as_nanos());
|
|
let tid = core.send_chat(voice, &tool_msg).await.unwrap()[0];
|
|
let edited_tool = format!("{tool_msg} 수정");
|
|
core.chat_action(&act("edit", tid, Some(&edited_tool), None)).await.expect("edit own message");
|
|
let err = core.chat_action(&act("edit", marker_msg.id.get(), Some("남의 글"), None)).await.unwrap_err();
|
|
assert!(err.0.contains("own"), "{err}");
|
|
core.chat_action(&act("react", marker_msg.id.get(), None, Some("👍"))).await.expect("react");
|
|
// A voice channel's chat cannot pin (Discord answers "cannot be pinned in this channel"); the
|
|
// refusal must come back as an error the assistant can say, not a crash.
|
|
let pinned = core.chat_action(&act("pin", tid, None, None)).await;
|
|
let pin_report = match &pinned {
|
|
Ok(_) => "pinned".to_string(),
|
|
Err(e) => {
|
|
assert!(e.0.contains("pinned"), "unexpected pin error: {e}");
|
|
format!("refused by Discord: {}", e.0)
|
|
}
|
|
};
|
|
let fetched = ChannelId::new(voice).message(&s_http, serenity::all::MessageId::new(tid)).await.unwrap();
|
|
assert_eq!(fetched.content, edited_tool, "edit");
|
|
assert_eq!(fetched.pinned, pinned.is_ok(), "pin state");
|
|
let marked = ChannelId::new(voice).message(&s_http, marker_msg.id).await.unwrap();
|
|
assert!(marked.reactions.iter().any(|r| r.count >= 1), "no reaction");
|
|
if pinned.is_ok() {
|
|
core.chat_action(&act("unpin", tid, None, None)).await.expect("unpin");
|
|
}
|
|
core.chat_action(&act("delete", tid, None, None)).await.expect("delete");
|
|
tokio::time::sleep(Duration::from_millis(800)).await;
|
|
assert!(ChannelId::new(voice).message(&s_http, serenity::all::MessageId::new(tid)).await.is_err(), "not deleted");
|
|
let off = jarvis_app::worker_client::ChatAction { channel: voice2.to_string(), ..act("send", tid, Some("x"), None) };
|
|
assert!(core.chat_action(&off).await.unwrap_err().0.contains("not a registered"));
|
|
report.insert("chat_tool".into(), json!({"edit": true, "edit_others_refused": true, "react": true,
|
|
"pin": pin_report, "delete": true, "unregistered_refused": true}));
|
|
|
|
// 6. Moving to another channel and back: the old connection's shutdown must not end the new one.
|
|
for (to, what) in [(voice2, "the second channel"), (voice, "the first channel")] {
|
|
core.join(to).await.expect("move");
|
|
tokio::time::sleep(Duration::from_secs(3)).await;
|
|
assert_eq!(core.voice_channel_id(), Some(to), "session lost after moving to {what}");
|
|
let in_channel = s_cache.guild(GuildId::new(guild))
|
|
.and_then(|g| g.voice_states.get(&UserId::new(jarvis)).and_then(|v| v.channel_id)).map(|c| c.get());
|
|
assert_eq!(in_channel, Some(to), "Jarvis is not in {what} on Discord");
|
|
}
|
|
let moves: Vec<String> = events.lock().unwrap().iter().filter_map(|e| match e {
|
|
CoreEvent::Left { reason, .. } => Some(reason.clone()),
|
|
_ => None,
|
|
}).collect();
|
|
assert_eq!(moves, ["moved", "moved"], "only the two moves end a session");
|
|
|
|
// 7. Group changes: every join and leave changes the DAVE (MLS) group, and songbird has an open
|
|
// report of receive stalling after one (issue #310). The speaker leaves and comes back three
|
|
// times and must still be heard each time, under its new SSRC.
|
|
let wav = std::fs::read(samples.join("ko_03.wav")).unwrap();
|
|
let reference = refs["samples"][2]["text"].as_str().unwrap().to_owned();
|
|
let mut rejoins = vec![];
|
|
for round in 0..3 {
|
|
speaker_songbird.remove(GuildId::new(guild)).await.unwrap();
|
|
tokio::time::sleep(Duration::from_secs(2)).await;
|
|
let call = speaker_songbird.join(GuildId::new(guild), ChannelId::new(voice)).await.expect("speaker rejoins");
|
|
tokio::time::sleep(Duration::from_secs(1)).await;
|
|
let before = events.lock().unwrap().len();
|
|
let (etx, mut erx) = mpsc::unbounded_channel();
|
|
let track = call.lock().await.play_only_input(Input::from(wav.clone()));
|
|
track.add_event(Event::Track(TrackEvent::End), Ended(etx)).unwrap();
|
|
tokio::time::timeout(Duration::from_secs(20), erx.recv()).await.expect("track end");
|
|
let got = |evs: &[CoreEvent]| evs.iter().filter_map(|e| match e {
|
|
CoreEvent::Final(f) if f.heard.speaker_id == speaker_id && !f.text.is_empty() => Some(f.text.clone()),
|
|
_ => None,
|
|
}).collect::<Vec<_>>();
|
|
let deadline = Instant::now() + Duration::from_secs(10);
|
|
while got(&events.lock().unwrap()[before..]).is_empty() && Instant::now() < deadline {
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(800)).await;
|
|
let hyp = got(&events.lock().unwrap()[before..]).join(" ");
|
|
rejoins.push(json!({"round": round, "hyp": hyp, "cer": cer(&reference, &hyp)}));
|
|
}
|
|
report.insert("rejoins".into(), Value::from(rejoins.clone()));
|
|
assert!(rejoins.iter().all(|r| r["cer"].as_f64().unwrap() < 0.15), "not heard after a rejoin: {rejoins:?}");
|
|
|
|
// 8. Leaving.
|
|
assert!(core.leave("command").await);
|
|
until("Jarvis to leave", 10_000, || {
|
|
s_cache.guild(GuildId::new(guild)).and_then(|g| g.voice_states.get(&UserId::new(jarvis)).and_then(|v| v.channel_id)).is_none()
|
|
}).await;
|
|
assert_eq!(core.voice_channel_id(), None);
|
|
assert!(core.say("아무도 못 듣는 말", false).is_none());
|
|
|
|
// 9. The history store: the speaker's finals under its name, its chat with the edit and without
|
|
// the deleted message, Jarvis's own messages, and presence closed now that Jarvis left.
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
let check = r#"
|
|
import json, sys
|
|
from jarvis.memory.history import HistoryStore
|
|
s = HistoryStore(sys.argv[1]); sp, jv = sys.argv[2], sys.argv[3]
|
|
own = s.records_of(sp)
|
|
q = lambda sql, *a: s._conn.execute(sql, a).fetchone()[0]
|
|
print(json.dumps({"voice": [[r.author_name, r.channel_id, r.text] for r in own if r.kind == "voice"],
|
|
"chat": [r.text for r in own if r.kind == "chat"], "jarvis_chat": [r.text for r in s.records_of(jv) if r.kind == "chat"],
|
|
"presence": q("select count(*) from presence where user_id = ?", sp), "open": q("select count(*) from presence where left_at is null")},
|
|
ensure_ascii=False))
|
|
"#;
|
|
let out = std::process::Command::new(env("JARVIS_VOICE_PYTHON")).current_dir(root.join("../src"))
|
|
.args(["-c", check, &history_db.to_string_lossy(), &speaker_id.to_string(), &jarvis.to_string()])
|
|
.output().unwrap();
|
|
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
|
let h: Value = serde_json::from_slice(&out.stdout).unwrap();
|
|
let voice_recs = h["voice"].as_array().unwrap();
|
|
let speaker_name = s_cache.user(UserId::new(speaker_id)).map(|u| u.display_name().to_owned()).unwrap_or_default();
|
|
report.insert("history".into(), json!({"voice_records": voice_recs.len(), "presence_intervals": h["presence"],
|
|
"open_presence": h["open"], "chat": h["chat"], "jarvis_chat": h["jarvis_chat"].as_array().map(|a| a.len())}));
|
|
assert!(voice_recs.len() >= 8, "finals not stored: {h}");
|
|
assert!(voice_recs.iter().all(|r| r[0].as_str() != Some(&speaker_id.to_string()) && !r[2].as_str().unwrap().is_empty()),
|
|
"a final without the speaker's name: {h}");
|
|
assert!(voice_recs.iter().any(|r| r[0].as_str() == Some(speaker_name.as_str())), "{speaker_name} not in {h}");
|
|
assert!(voice_recs.iter().any(|r| r[1].as_str() == Some(voice.to_string().as_str())), "{h}");
|
|
let chat: Vec<&str> = h["chat"].as_array().unwrap().iter().filter_map(|v| v.as_str()).collect();
|
|
assert_eq!(chat, [edited.as_str()], "speaker chat in the history");
|
|
let jarvis_chat: Vec<&str> = h["jarvis_chat"].as_array().unwrap().iter().filter_map(|v| v.as_str()).collect();
|
|
assert!(jarvis_chat.contains(&reply.as_str()) && jarvis_chat.iter().any(|t| t.contains("받아 적습니다")), "{h}");
|
|
assert!(!jarvis_chat.iter().any(|t| t.contains(&tool_msg)), "the deleted tool message is still stored: {h}");
|
|
assert!(h["presence"].as_u64().unwrap() >= 4, "joins and rejoins open presence: {h}");
|
|
assert_eq!(h["open"], 0, "presence left open after Jarvis left: {h}");
|
|
|
|
println!("live report {}", serde_json::to_string_pretty(&Value::Object(report.clone())).unwrap());
|
|
})).await;
|
|
|
|
// Clean up even when a step failed: the test command, the speaker, the core, the worker.
|
|
let http = Http::new(&bot_token);
|
|
http.set_application_id(jarvis_app_id.into());
|
|
for c in http.get_guild_commands(GuildId::new(guild)).await.unwrap().iter().filter(|c| c.name == COMMAND) {
|
|
let _ = http.delete_guild_command(GuildId::new(guild), c.id).await;
|
|
}
|
|
let _ = speaker_songbird.remove(GuildId::new(guild)).await;
|
|
s_shards.shutdown_all().await;
|
|
core.close().await;
|
|
worker.close();
|
|
wp.stop().await;
|
|
if let Err(panic) = steps {
|
|
std::panic::resume_unwind(panic);
|
|
}
|
|
}
|