Download tests/e2e_roleplay.py from LoveLogicAI/freestream: direct link, hf CLI and curl.
- Browser
- Download file 17.6 kB
-
https://huggingface.co/datasets/LoveLogicAI/freestream/resolve/main/tests/e2e_roleplay.py
- Command line
-
hf download hf://datasets/LoveLogicAI/freestream/tests/e2e_roleplay.py
-
curl -L -o e2e_roleplay.py https://huggingface.co/datasets/LoveLogicAI/freestream/resolve/main/tests/e2e_roleplay.py
17.6 kB
| """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["FREESTREAM_TOOLS"] = "fs,shell" # the tool turn needs a real shell (CONSENT.md §6 audit) | |
| os.environ["FREESTREAM_WORKSPACE"] = str(ROOT / "workspace") # where the manifest is seeded | |
| os.environ["FREESTREAM_TOOLS"] = "fs,shell" # operator grants the character a terminal | |
| os.environ["FREESTREAM_WORKSPACE"] = str(ROOT / "workspace") | |
| 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) | |
| # ---- seed the ship's workspace (the character's tool sandbox) ---------------- | |
| workspace = ROOT / "workspace" | |
| workspace.mkdir(parents=True, exist_ok=True) | |
| (workspace / "manifest.txt").write_text( | |
| "LONG DAWN — CARGO MANIFEST, REV 7\n" | |
| "1. cryo-seed vaults x12 (ArborGen charter) — bay 2\n" | |
| "2. fusion torch liners x40 — bay 1\n" | |
| "3. patient-nanite kits x900 (sealed) — bay 3\n" | |
| "DESTINATION: Ceres Station, high dock. ETA 11 days at burn-0.3g.\n") | |
| # ---- 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", "cryo", "vault", "liner", | |
| "nanite", "seed", "destination")), | |
| ("Talk to me — what's the fastest route to Ceres?", ("ceres", "course", "day", "hour", "burn", "route")), | |
| # tool turn: the answer must come from the REAL file via the character's terminal | |
| ("Run a scan of the manifest on the bridge console and tell me exactly what we're carrying.", | |
| ("cryo", "seed", "manifest", "grain")), | |
| ] | |
| DISCLOSURE_KEYWORDS = ("ai", "automated") | |
| async def conversation(): | |
| room = rtc.Room() | |
| turns = [] | |
| video_state = {"bottom": []} # laptop-region luminance samples | |
| audio_state = {"first": None, "last": None, "chunks": []} | |
| video_state = {"bottom": [], "last_img": None} # device-luminance channel | |
| def on_track(track, publication, participant): | |
| if track.kind == rtc.TrackKind.KIND_AUDIO: | |
| asyncio.ensure_future(record_audio(track)) | |
| else: | |
| asyncio.ensure_future(sample_video(track)) | |
| async def sample_video(track): | |
| """Track the laptop region's luminance (rows 400-500, cols 176-336): | |
| the dark laptop sliding in during tool work drops this sharply. | |
| Stream-level resilience: resubscribe on iterator death — a sampler | |
| must never take down (or silently stop) the luminance channel.""" | |
| while True: | |
| try: | |
| stream = rtc.VideoStream(track) | |
| async for ev in stream: | |
| try: | |
| f = ev.frame | |
| w, h = f.width, f.height | |
| data = bytes(f.data) | |
| if h < 500 or w < 336: | |
| continue | |
| if len(data) >= w * h * 1.5 and len(data) < w * h * 4: # I420 luma | |
| img = np.frombuffer(data[: w * h], dtype=np.uint8).reshape(h, w) | |
| elif len(data) == w * h * 4: # RGBA luma approx | |
| rgba = np.frombuffer(data, dtype=np.uint8).reshape(h, w, 4) | |
| img = rgba[:, :, :3].mean(axis=2).astype(np.uint8) | |
| else: | |
| continue | |
| region = img[400:500, 176:336] | |
| video_state["bottom"].append( | |
| (time.perf_counter(), float(region.mean()))) | |
| except Exception: | |
| continue # per-frame: never fatal | |
| except Exception: | |
| await asyncio.sleep(0.5) # stream died: resubscribe and keep sampling | |
| 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() | |
| t_speech_end_abs = time.time() # captured AT speech end, not at append | |
| print(f"[client] turn {i}: '{q_text}' pushed (abs {t_speech_end_abs:.3f})", flush=True) | |
| while audio_state["first"] is None: | |
| await asyncio.sleep(0.05) | |
| if time.perf_counter() - t_speech_end > 90: # router cold starts can be slow | |
| break | |
| if audio_state["first"] is None: | |
| check(f"turn {i}: bot answered", False, "no audio in 90s") | |
| 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"]) | |
| t_end_abs = time.time() # end of the answer (silence wait included) | |
| 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, | |
| "t_speech_end": t_speech_end, | |
| "t_end": audio_state["last"], | |
| "t_speech_end_abs": t_speech_end_abs, | |
| "t_end_abs": t_end_abs}) | |
| await asyncio.sleep(0.5) | |
| await room.disconnect() | |
| return turns, video_state | |
| turns, video_state = 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]) | |
| tools = [e for e in bot_log if e["type"] == "agent.tool"] | |
| ok_tools = [e for e in tools if e["payload"].get("ok")] | |
| check("character used the terminal (audited agent.tool call)", len(ok_tools) >= 1, | |
| " | ".join(f"{e['payload']['tool']}:{str(e['payload'].get('args'))[:60]}" | |
| for e in tools)[:200]) | |
| # device-work visible: EITHER on-camera laptop-region luminance drops ≥8 below | |
| # the idle baseline during the tool turn, OR the bot's own render-state chain | |
| # (persona.posture, epoch ts) shows the working posture held through the turn. | |
| try: | |
| # baseline: the first turn that actually produced audio (t_end not None) | |
| t1 = next(t for t in turns if t and t.get("t_end") is not None) | |
| t4 = turns[3] | |
| def region_med(t): | |
| vals = [m for ts, m in video_state["bottom"] | |
| if t["t_speech_end"] <= ts <= (t["t_end"] or t["t_speech_end"]) + 1.0] | |
| vals.sort() | |
| return vals[len(vals) // 2] if vals else None | |
| m1, m4 = region_med(t1), region_med(t4) | |
| luma_ok = m1 is not None and m4 is not None and m4 < m1 - 8 | |
| working = [e for e in bot_log if e["type"] == "persona.posture" | |
| and e["payload"].get("mode") == "working" | |
| and t4["t_speech_end_abs"] - 1 <= e["ts"] <= t4["t_end_abs"] + 2] | |
| # one continuous tool block logs exactly one working-posture entry | |
| posture_ok = len(working) >= 1 | |
| check("avatar visibly works the device during tool call", | |
| luma_ok or posture_ok, | |
| f"luma idle {m1 and round(m1, 1)} -> tool {m4 and round(m4, 1)}; " | |
| f"working-posture events in window: {len(working)}") | |
| except Exception as e: | |
| check("avatar visibly works the device during tool call", False, f"{e}") | |
| # ---- 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] | |
| # roleplay profile: LLM generation + tool roundtrips dominate — 20s gate for | |
| # normal turns, 30s for the tool turn (documented in the docstring) | |
| slow = [f"turn {i}: {t['t_perceived']:.1f}s" for i, t in enumerate(turns, 1) | |
| if t and t["t_perceived"] > (30.0 if i == len(turns) else 20.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") |