Roleplay e2e: in-character conversation + policy gate + action checks

tests/e2e_roleplay.py

@@ -0,0 +1,297 @@
+"""Roleplay/agentic e2e: an LLM-backed character joins a LiveKit room and
+holds an in-character spoken conversation.
+
+Checks:
+  1. character stays in character across 3 spoken turns (transcript keywords)
+  2. AI disclosure present in the first utterance (CONSENT.md #2 — every policy)
+  3. *actions* are logged as agent.action events, not spoken
+  4. content-policy gate: safe vs mature system prompts differ as specified
+  5. CLI join/leave + replay logs verify
+Latency is reported (LLM adds generation time); sanity gate at 12s, no 4s gate.
+
+Env: FREESTREAM_AGENT=llm, FREESTREAM_LLM_API_KEY (or HF_TOKEN),
+FREESTREAM_CONTENT_POLICY=mature (operator opt-in for this session).
+"""
+
+import asyncio
+import json
+import os
+import socket
+import subprocess
+import sys
+import tarfile
+import time
+import urllib.request
+import wave
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path("/tmp/rp")
+REPO = "https://huggingface.co/datasets/LoveLogicAI/freestream/resolve/main"
+VOICE_URL = ("https://huggingface.co/rhasspy/piper-voices/resolve/main/"
+             "en/en_US/amy/medium/en_US-amy-medium{ext}")
+GH_LATEST = "https://api.github.com/repos/livekit/livekit-server/releases/latest"
+
+os.environ["HF_HOME"] = "/tmp/hf"
+os.environ["FREESTREAM_VOICE_DIR"] = str(ROOT / "voices")
+os.environ["FREESTREAM_WHISPER_MODEL"] = "tiny.en"
+os.environ["FREESTREAM_WHISPER_THREADS"] = "1"
+os.environ["FREESTREAM_AGENT"] = "llm"
+os.environ["FREESTREAM_CONTENT_POLICY"] = "mature"  # operator opt-in (CONSENT.md §6)
+os.environ["FREESTREAM_CHARACTER_CARD"] = "identity/characters/vera-steel.json"
+os.environ["PYTHONPATH"] = str(ROOT)
+sys.path.insert(0, str(ROOT))
+os.environ.setdefault("FREESTREAM_LIVEKIT_URL", "ws://localhost:7880")
+os.environ.setdefault("FREESTREAM_LIVEKIT_KEY", "devkey")
+os.environ.setdefault("FREESTREAM_LIVEKIT_SECRET", "secret")
+
+results = []
+
+
+def check(name, ok, detail=""):
+    results.append((name, ok))
+    print(f"{'PASS' if ok else 'FAIL'}  {name}" + (f"  — {detail}" if detail else ""), flush=True)
+
+
+def fetch(url, dest):
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    with urllib.request.urlopen(url, timeout=300) as r:
+        dest.write_bytes(r.read())
+
+
+def run_cli(*args, timeout=240):
+    return subprocess.run([sys.executable, str(ROOT / "scripts/freestream.py"), *args],
+                          cwd=str(ROOT), capture_output=True, text=True, timeout=timeout)
+
+
+# ---- fetch code --------------------------------------------------------------
+FILES = ["scripts/freestream.py",
+         "freestream/__init__.py", "freestream/events.py", "freestream/presence.py",
+         "freestream/persona.py", "freestream/bot.py", "freestream/asr.py",
+         "freestream/avatar.py", "freestream/agent.py",
+         "identity/characters/vera-steel.json"]
+missing = []
+for f in FILES:
+    try:
+        fetch(f"{REPO}/{f}", ROOT / f)
+        if (ROOT / f).stat().st_size == 0:
+            raise RuntimeError("empty")
+    except Exception as e:
+        missing.append((f, str(e)))
+check("fetch code from Hub", not missing, str(missing[:2]))
+if missing:
+    sys.exit(1)
+
+# ---- policy gate verification (mechanical, no content generation) -------------
+from freestream.agent import CharacterAgent, SAFE_POLICY, MATURE_POLICY  # noqa: E402
+
+os.environ["FREESTREAM_CONTENT_POLICY"] = "safe"
+safe_sys = CharacterAgent(bot_name="x").system
+os.environ["FREESTREAM_CONTENT_POLICY"] = "mature"
+mature_sys = CharacterAgent(bot_name="x").system
+os.environ["FREESTREAM_CONTENT_POLICY"] = "mature"
+check("policy gate: safe prompt has sanitizer", "safe mode" in safe_sys
+      and "mature mode" not in safe_sys)
+check("policy gate: mature prompt removes sanitizer", "mature mode" in mature_sys
+      and SAFE_POLICY.split("CONTENT POLICY")[1][:20] not in mature_sys)
+first_line = CharacterAgent(bot_name="x").first_utterance()
+check("policy gate: AI disclosure survives every policy", "AI assistant" in first_line)
+
+# ---- server -------------------------------------------------------------------
+if not (ROOT / "livekit-server").exists():
+    req = urllib.request.Request(GH_LATEST, headers={"Accept": "application/vnd.github+json"})
+    with urllib.request.urlopen(req, timeout=60) as r:
+        release = json.loads(r.read())
+    asset = next(a for a in release["assets"]
+                 if "linux_amd64" in a["name"] and a["name"].endswith(".tar.gz"))
+    fetch(asset["browser_download_url"], ROOT / asset["name"])
+    with tarfile.open(ROOT / asset["name"]) as tf:
+        tf.extract("livekit-server", str(ROOT))
+config = ROOT / "lk.yaml"
+config.write_text("""
+port: 7880
+rtc:
+  use_external_ip: false
+  use_ice_lite: true
+  tcp_port: 7881
+  port_range_start: 50000
+  port_range_end: 50100
+keys:
+  devkey: secret
+""")
+server_log = open(ROOT / "server.log", "w")
+server = subprocess.Popen([str(ROOT / "livekit-server"), "--config", str(config)],
+                          stdout=server_log, stderr=subprocess.STDOUT)
+for _ in range(60):
+    try:
+        with socket.create_connection(("127.0.0.1", 7880), timeout=1):
+            break
+    except OSError:
+        time.sleep(0.5)
+check("livekit-server up on :7880", True)
+
+for ext, name in ((".onnx", "en_US-amy-medium.onnx"), (".onnx.json", "en_US-amy-medium.onnx.json")):
+    dest = ROOT / "voices" / name
+    if not dest.exists():
+        fetch(VOICE_URL.format(ext=ext), dest)
+
+r = run_cli("generate-avatar", "--output", "identity/videomeeting-avatar.png")
+check("generate-avatar", r.returncode == 0)
+
+from faster_whisper import WhisperModel  # noqa: E402
+
+WhisperModel("tiny.en", device="cpu", compute_type="int8", cpu_threads=1)
+from livekit import api, rtc  # noqa: E402
+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/long-dawn", "--platform", "livekit",
+     "--bot-name", "Vera", "--image", "identity/videomeeting-avatar.png",
+     "--timeout-sec", "120"],
+    cwd=str(ROOT), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+sid, ready = None, False
+for line in join_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
+check(f"CLI join -> ready (session {sid})", ready)
+if not ready:
+    print(join_proc.stderr.read()[:800])
+    sys.exit(1)
+
+# ---- in-character conversation -------------------------------------------------
+QUESTIONS = [
+    ("Captain, who am I talking to?", ("vera", "steel", "captain")),
+    ("What's our cargo, and where are we headed?", ("cargo", "ceres", "freight", "haul", "credits")),
+    ("Talk to me — what's the fastest route to Ceres?", ("ceres", "course", "day", "hour", "burn", "route")),
+]
+DISCLOSURE_KEYWORDS = ("ai", "automated")
+
+
+async def conversation():
+    room = rtc.Room()
+    turns = []
+    audio_state = {"first": None, "last": None, "chunks": []}
+
+    @room.on("track_subscribed")
+    def on_track(track, publication, participant):
+        if track.kind == rtc.TrackKind.KIND_AUDIO:
+            asyncio.ensure_future(record_audio(track))
+
+    async def record_audio(track):
+        stream = rtc.AudioStream(track, sample_rate=16000, num_channels=1)
+        async for ev in stream:
+            pcm = np.frombuffer(ev.frame.data, dtype=np.int16)
+            rms = float(np.sqrt(np.mean(pcm.astype(np.float32) ** 2))) / 32768.0
+            if rms < 0.004:
+                continue
+            now = time.perf_counter()
+            if audio_state["first"] is None:
+                audio_state["first"] = now
+            audio_state["last"] = now
+            audio_state["chunks"].append(pcm)
+
+    await room.connect("ws://localhost:7880",
+                       (api.AccessToken("devkey", "secret").with_identity("tester")
+                        .with_grants(api.VideoGrants(room_join=True, room="long-dawn",
+                                                     can_publish=True, can_subscribe=True))
+                        .to_jwt()),
+                       options=rtc.RoomOptions(auto_subscribe=True))
+    await asyncio.sleep(2.0)
+
+    voice = PiperVoice.load(str(ROOT / "voices/en_US-amy-medium.onnx"))
+    q_sr = int(json.loads((ROOT / "voices/en_US-amy-medium.onnx.json").read_text())
+               ["audio"]["sample_rate"])
+    source = rtc.AudioSource(q_sr, 1)
+    track = rtc.LocalAudioTrack.create_audio_track("tester-mic", source)
+    await room.local_participant.publish_track(
+        track, rtc.TrackPublishOptions(source=rtc.TrackSource.SOURCE_MICROPHONE))
+    chunk = int(q_sr * 0.01)
+    verifier = WhisperModel("tiny.en", device="cpu", compute_type="int8", cpu_threads=1)
+
+    for i, (q_text, keywords) in enumerate(QUESTIONS, start=1):
+        q_pcm = np.concatenate([np.frombuffer(c.audio_int16_bytes, np.int16)
+                                for c in voice.synthesize(q_text)])
+        audio_state["first"], audio_state["last"], audio_state["chunks"] = None, None, []
+        for j in range(0, len(q_pcm), chunk):
+            piece = q_pcm[j: j + chunk]
+            frame = rtc.AudioFrame.create(q_sr, 1, len(piece))
+            np.copyto(np.frombuffer(frame.data, dtype=np.int16), piece)
+            await source.capture_frame(frame)
+        t_speech_end = time.perf_counter()
+        print(f"[client] turn {i}: '{q_text}' pushed (abs {time.time():.3f})", flush=True)
+
+        while audio_state["first"] is None:
+            await asyncio.sleep(0.05)
+            if time.perf_counter() - t_speech_end > 60:
+                break
+        if audio_state["first"] is None:
+            check(f"turn {i}: bot answered", False, "no audio in 60s")
+            turns.append(None)
+            continue
+        t_perceived = audio_state["first"] - t_speech_end
+        while time.perf_counter() - audio_state["last"] < 4.0:
+            await asyncio.sleep(0.1)
+            if time.perf_counter() - t_speech_end > 90:
+                break
+        bot_pcm = np.concatenate(audio_state["chunks"])
+        segs, _ = verifier.transcribe(bot_pcm.astype(np.float32) / 32768.0, language="en")
+        text = " ".join(s.text.strip() for s in segs).strip()
+        ok = any(k in text.lower() for k in keywords)
+        check(f"turn {i}: in-character answer", ok, f"{t_perceived:.2f}s — {text[:130]}")
+        if i == 1:
+            check("turn 1: AI disclosure spoken first",
+                  any(k in text.lower() for k in DISCLOSURE_KEYWORDS), text[:130])
+        turns.append({"t_perceived": t_perceived, "text": text})
+        await asyncio.sleep(0.5)
+
+    await room.disconnect()
+    return turns
+
+
+turns = asyncio.run(conversation())
+
+# ---- actions logged, not spoken -------------------------------------------------
+from freestream.events import EventLog  # noqa: E402
+
+sdir = ROOT / ".freestream/sessions" / sid
+bot_log = EventLog(sdir / "bot-events.jsonl").events()
+actions = [e for e in bot_log if e["type"] == "agent.action"]
+check("character *actions* logged as events", len(actions) >= 1,
+      "; ".join(a["payload"]["text"] for a in actions)[:160])
+
+# ---- leave + logs ----------------------------------------------------------------
+r = run_cli("leave", "--session-id", sid)
+out = {}
+try:
+    out = json.loads(r.stdout.strip().splitlines()[-1])
+except (ValueError, IndexError):
+    pass
+check("CLI leave exits 0 with closed:true", r.returncode == 0 and out.get("closed") is True)
+cli_ok, _ = EventLog(sdir / "events.jsonl").verify()
+bot_ok, _ = EventLog(sdir / "bot-events.jsonl").verify()
+check("both replay logs verify", cli_ok and bot_ok)
+
+# ---- summary ---------------------------------------------------------------------
+server.terminate()
+print("\n--- roleplay latency (LLM in the loop; no 4s gate) ---", flush=True)
+for i, t in enumerate(turns, start=1):
+    if t:
+        print(f"turn {i} t_perceived: {t['t_perceived']:.2f}s  '{t['text'][:90]}'")
+
+failed = [n for n, ok in results if not ok]
+slow = [t["t_perceived"] for t in turns if t and t["t_perceived"] > 12.0]
+print(f"\n{len(results) - len(failed)}/{len(results)} checks passed")
+if failed or slow:
+    print("FAILED: " + ", ".join(failed + (["turn > 12s"] if slow else [])))
+    sys.exit(1)
+print("ROLEPLAY E2E OK")