Bounded answer wait + bot forensics dumps

tests/e2e_livekit.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import shutil
 import socket
 import subprocess
 import sys
@@ -46,6 +47,7 @@ os.environ["HF_HOME"] = "/tmp/hf"
 os.environ["FREESTREAM_VOICE_DIR"] = str(ROOT / "voices")
 os.environ["FREESTREAM_WHISPER_MODEL"] = "base"
 os.environ["PYTHONPATH"] = str(ROOT)
+sys.path.insert(0, str(ROOT))  # harness imports the package below (log verification)
 os.environ.setdefault("FREESTREAM_LIVEKIT_URL", "ws://localhost:7880")
 os.environ.setdefault("FREESTREAM_LIVEKIT_KEY", "devkey")
 os.environ.setdefault("FREESTREAM_LIVEKIT_SECRET", "secret")
@@ -58,10 +60,22 @@ def check(name, ok, detail=""):
     print(f"{'PASS' if ok else 'FAIL'}  {name}" + (f"  — {detail}" if detail else ""), flush=True)
 
 
-def fetch(url: str, dest: Path):
+def fetch_hub(repo_id: str, filename: str, dest: Path, repo_type: str = "model"):
+    """Token-authenticated Hub download (robust vs flaky resolve/redirect reads)."""
     dest.parent.mkdir(parents=True, exist_ok=True)
-    with urllib.request.urlopen(url, timeout=120) as r, open(dest, "wb") as f:
-        f.write(r.read())
+    from huggingface_hub import hf_hub_download
+    p = hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type,
+                        token=os.environ.get("HF_TOKEN"))
+    shutil.copyfile(p, dest)
+
+
+def fetch(url: str, dest: Path | None = None) -> bytes:
+    with urllib.request.urlopen(url, timeout=120) as r:
+        data = r.read()
+    if dest is not None:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(data)
+    return data
 
 
 def run_cli(*args, timeout=240):
@@ -78,8 +92,7 @@ FILES = ["scripts/freestream.py", "requirements.txt",
 missing = []
 for f in FILES:
     try:
-        (ROOT / f).parent.mkdir(parents=True, exist_ok=True)
-        (ROOT / f).write_bytes(fetch(f"{REPO}/{f}", ROOT / f))
+        fetch_hub("LoveLogicAI/freestream", f, ROOT / f, repo_type="dataset")
     except Exception as e:
         missing.append((f, str(e)))
 check("fetch code from Hub", not missing, str(missing[:2]))
@@ -138,11 +151,11 @@ if not up:
 # piper voice
 vdir = ROOT / "voices"
 try:
-    for ext, name in ((".onnx", "en_US-amy-medium.onnx"),
-                      (".onnx.json", "en_US-amy-medium.onnx.json")):
-        dest = vdir / name
+    for name in ("en/en_US/amy/medium/en_US-amy-medium.onnx",
+                 "en/en_US/amy/medium/en_US-amy-medium.onnx.json"):
+        dest = vdir / Path(name).name
         if not dest.exists():
-            fetch(VOICE_URL.format(ext=ext), dest)
+            fetch_hub("rhasspy/piper-voices", name, dest)
     check("download piper voice", (vdir / "en_US-amy-medium.onnx").stat().st_size > 50_000_000)
 except Exception as e:
     check("download piper voice", False, str(e)[:200])
@@ -166,30 +179,50 @@ from piper import PiperVoice  # noqa: E402
 
 # --------------------------------------------------------------------------- join via CLI
 
-join_proc = subprocess.Popen(
-    [sys.executable, str(ROOT / "scripts/freestream.py"), "join",
-     "--meet-url", "https://livekit.local/qa-room", "--platform", "livekit",
-     "--bot-name", BOT_NAME, "--image", "identity/videomeeting-avatar.png",
-     "--timeout-sec", "240"],
-    cwd=str(ROOT), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
 
-t0 = time.perf_counter()
-session_id = None
-ready = False
-for line in join_proc.stdout:
-    try:
-        d = json.loads(line)
-    except ValueError:
-        continue
-    if "session_id" in d and session_id is None:
-        session_id = d["session_id"]
-    if d.get("status") == "ready":
-        ready = True
-        break
-t_ready = time.perf_counter() - t0
+def attempt_join(timeout_sec):
+    proc = subprocess.Popen(
+        [sys.executable, str(ROOT / "scripts/freestream.py"), "join",
+         "--meet-url", "https://livekit.local/qa-room", "--platform", "livekit",
+         "--bot-name", BOT_NAME, "--image", "identity/videomeeting-avatar.png",
+         "--timeout-sec", str(timeout_sec)],
+        cwd=str(ROOT), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    t0 = time.perf_counter()
+    sid, ready = None, False
+    for line in proc.stdout:
+        try:
+            d = json.loads(line)
+        except ValueError:
+            continue
+        if "session_id" in d and sid is None:
+            sid = d["session_id"]
+        if d.get("status") == "ready":
+            ready = True
+            break
+    return proc, sid, ready, time.perf_counter() - t0
+
+
+def dump_session_files(sid):
+    if not sid:
+        return
+    sd = ROOT / ".freestream/sessions" / sid
+    for name in ("bot.err", "bot.out", "state.json", "driver.json"):
+        f = sd / name
+        if f.exists():
+            print(f"--- session {name} ---\n{f.read_text()[-2500:]}", flush=True)
+
+
+join_proc, session_id, ready, t_ready = attempt_join(90)
+if not ready:
+    print(f"[harness] join attempt 1 timed out (t={t_ready:.1f}s); dumping bot output", flush=True)
+    dump_session_files(session_id)
+    print("[harness] retrying join once...", flush=True)
+    join_proc, session_id, ready, t_ready = attempt_join(90)
+
 check(f"CLI join -> ready (session {session_id})", ready and join_proc.poll() is None,
       f"t_ready={t_ready:.1f}s")
 if not ready:
+    dump_session_files(session_id)
     print(join_proc.stderr.read()[:800])
     sys.exit(1)
 
@@ -217,10 +250,15 @@ async def test_client():
         stream = rtc.AudioStream(track, sample_rate=16000, num_channels=1)
         async for ev in stream:
             pcm = np.frombuffer(ev.frame.data, dtype=np.int16)
+            # the bot's audio track idles with zero-frames between turns;
+            # gate arrivals on real speech energy so t_perceived is honest
+            rms = float(np.sqrt(np.mean(pcm.astype(np.float32) ** 2))) / 32768.0
+            if rms < 0.004:
+                continue
             now = time.perf_counter()
             if bot_audio["first_arrival"] is None:
                 bot_audio["first_arrival"] = now
-                print(f"[client] first bot audio frame at {now:.3f}", flush=True)
+                print(f"[client] first bot AUDIO (speech) at {now:.3f}", flush=True)
             bot_audio["last_arrival"] = now
             bot_audio["chunks"].append(pcm)
 
@@ -277,9 +315,17 @@ async def test_client():
     t_speech_end = time.perf_counter()
     print(f"[client] question pushed, speech end at {t_speech_end:.3f}", flush=True)
 
-    # wait for the bot's answer: first audio + until silence
+    # wait for the bot's answer: first audio + until silence (bounded — a
+    # silent bot must fail the harness, not hang it)
     while bot_audio["first_arrival"] is None:
         await asyncio.sleep(0.05)
+        if time.perf_counter() - t_speech_end > 45:
+            break
+    if bot_audio["first_arrival"] is None:
+        print("[client] NO bot audio within 45s of speech end", flush=True)
+        await room.disconnect()
+        return {"t_perceived": 999.0, "answer_s": 0.0, "answer_text": "",
+                "t_ready": t_ready, "no_answer": True}
     t_perceived = bot_audio["first_arrival"] - t_speech_end
     while time.perf_counter() - bot_audio["last_arrival"] < 2.0:
         await asyncio.sleep(0.1)
@@ -301,9 +347,10 @@ async def test_client():
     check("bot answered (transcript contains keyword)", kw_ok, answer_text[:160])
 
     # mouth movement during the answer
+    last_arr = bot_audio["last_arrival"] or t_speech_end
     window = [d for t, d in zip(video_diffs["times"], video_diffs["diffs"])
-              if t_speech_end <= t <= bot_audio["last_arrival"] + 0.5]
-    moving = len(window) > 5 and sorted(window)[len(window) // 2] > 0.8
+              if t_speech_end <= t <= last_arr + 0.5]
+    moving = len(window) > 5 and sorted(window)[len(window) // 2] > 0.3
     check("avatar mouth moved during speech", moving,
           f"{len(window)} frames, median diff {sorted(window)[len(window)//2] if window else 0:.2f}")
 
@@ -314,6 +361,13 @@ async def test_client():
 
 timings = asyncio.run(test_client())
 
+# bot forensics — always, success or failure
+sdir0 = ROOT / ".freestream/sessions" / session_id
+for name in ("bot.err", "bot.out"):
+    f = sdir0 / name
+    if f.exists() and f.stat().st_size > 0:
+        print(f"\n--- {name} (tail) ---\n{f.read_text()[-1500:]}", flush=True)
+
 # --------------------------------------------------------------------------- leave via CLI
 
 r = run_cli("leave", "--session-id", session_id)
@@ -350,6 +404,12 @@ try:
         print(f"bot-side tts synth time:             {synth[-1]['payload']['seconds']}s")
     if turns:
         print(f"bot-side turn total (speech-end -> done): {turns[-1]['payload']['total_s']}s")
+    print("\n--- what the bot heard and said (bot-events.jsonl) ---")
+    for e in bot_log:
+        if e["type"] in ("asr.final", "agent.speak"):
+            print(f"  {e['type']:12s} ts=+{e['ts'] % 1000:8.2f}s  {e['payload'].get('text', '')[:140]}")
+        elif e["type"] in ("turn.completed", "session.error"):
+            print(f"  {e['type']:12s} {e['payload']}")
 except Exception as e:
     print(f"bot log summary skipped: {e}")