Cache consent disclosure at warmup; first audio pays zero Piper synth

freestream/bot.py

@@ -60,6 +60,7 @@ class BotSession:
         self.transcriber = Transcriber()
         self.segmenter = Segmenter()
         self.first_utterance_done = False
+        self.disclosure_segment = None  # (pcm, sr) consent line, cached at warmup
 
     # -- state ---------------------------------------------------------------
     def set_state(self, s: str, **extra):
@@ -114,10 +115,11 @@ class BotSession:
             np.copyto(np.frombuffer(frame.data, dtype=np.int16), piece)
             await self.audio_source.capture_frame(frame)
 
-    async def speak(self, text: str, **timing):
-        """Pipelined sentence synthesis (docs/LATENCY.md #2): sentence 1 is
-        synthesized and starts playing while the remaining sentences are
-        synthesized in a background task — no gaps between sentences."""
+    async def speak(self, text: str, pre_segment=None, **timing):
+        """Pipelined sentence synthesis (docs/LATENCY.md #2): playback starts
+        while later sentences are still synthesizing. pre_segment is an
+        optional (pcm, sr) already synthesized at session start — the fixed
+        consent disclosure — so the first audible output pays no synth cost."""
         import re
 
         sentences = [s.strip() for s in re.split(r"(?<=[.!?])\s+", text) if s.strip()]
@@ -128,23 +130,18 @@ class BotSession:
         total_audio = 0.0
         total_chars = 0
 
-        pcm, sr = await asyncio.to_thread(self.voice_backend.synthesize, sentences[0])
-        t_first_synth = time.perf_counter()
-        emit({"event": "timing", "session_id": self.session_id,
-              "sentence": 1, "synth_s": round(t_first_synth - t0, 3),
-              "chars": len(sentences[0])})
         rest_q: asyncio.Queue = asyncio.Queue()
 
         async def synth_rest():
-            for i, s in enumerate(sentences[1:], start=2):
+            for s in sentences:
                 p, r = await asyncio.to_thread(self.voice_backend.synthesize, s)
-                await rest_q.put((p, r, i, len(s)))
+                await rest_q.put((p, r, len(s)))
             await rest_q.put(None)
 
         rest_task = asyncio.create_task(synth_rest())  # synthesizes while we play
 
-        async def play_one(pcm_i, sr_i, idx, chars):
-            nonlocal total_audio, total_chars
+        async def play_one(pcm_i, sr_i, chars):
+            nonlocal total_audio, total_chars, first_audio
             mouth = avatar_mod.build_mouth_sequence(pcm_i, sr_i)
             duration = len(pcm_i) / sr_i
             total_audio += duration
@@ -160,28 +157,24 @@ class BotSession:
             task = asyncio.create_task(mouth_driver())
             if first_audio is None:
                 await asyncio.sleep(PRE_ROLL_S)  # avatar starts moving first
-                first_audio_local = time.perf_counter()
-            else:
-                first_audio_local = None
+                first_audio = time.perf_counter()
             await self.push_audio(pcm_i, sr_i)
             await task
-            return first_audio_local
 
-        first_audio = await play_one(pcm, sr, 1, len(sentences[0]))
+        if pre_segment is not None:
+            await play_one(pre_segment[0], pre_segment[1], 0)
         while True:
             item = await rest_q.get()
             if item is None:
                 break
-            p, r, i, chars = item
-            fa = await play_one(p, r, i, chars)
-            if first_audio is None:
-                first_audio = fa
+            p, r, chars = item
+            await play_one(p, r, chars)
         await rest_task
         if first_audio is None:
             raise RuntimeError("synthesis produced no audio")
         self.log.append("tts.synthesized", text=text, chars=total_chars,
                         backend="piper", seconds=round(first_audio - t0, 3),
-                        sentences=len(sentences))
+                        sentences=len(sentences), pre_cached=pre_segment is not None)
         emit({"event": "timing", "session_id": self.session_id,
               "tts_first_s": round(first_audio - t0, 3),
               "spoken_chars": total_chars, "audio_s": round(total_audio, 3)})
@@ -209,13 +202,14 @@ class BotSession:
         self.log.append("asr.final", text=text, seconds=round(asr_s, 3),
                         audio_s=round(len(utt) / 16000, 2))
         reply = self.agent.reply(text)
+        pre = None
         if not self.first_utterance_done:
-            reply = self.agent.first_utterance() + " " + reply
+            pre = self.disclosure_segment  # cached consent line, zero synth cost
             self.first_utterance_done = True
         self.log.append("agent.speak", text=reply)
         self.set_state("speaking")
         try:
-            await self.speak(reply, t0=t_speech_end)
+            await self.speak(reply, pre_segment=pre, t0=t_speech_end)
         except Exception as e:  # noqa: BLE001 — surface as session error, keep bot alive
             import traceback
             self.log.append("session.error", error=str(e)[:200],
@@ -242,6 +236,11 @@ class BotSession:
         try:
             await asyncio.to_thread(self.transcriber._load)
             await asyncio.to_thread(self.voice_backend.synthesize, "Warmup.")
+            # Pre-synthesize the fixed consent disclosure (CONSENT.md #2): it is
+            # static text, so the first turn's first audio never pays Piper's
+            # in-context synth latency (measured RTF ~1.2 in-process).
+            self.disclosure_segment = await asyncio.to_thread(
+                self.voice_backend.synthesize, self.agent.first_utterance())
         except Exception as e:  # noqa: BLE001
             self.log.append("session.error", error=f"warmup failed: {e}")
             self.set_state("error", error=str(e)[:200])