perf: reduce TTS latency - shorter chunks + sub-segment streaming

- Split long sentences at clause boundaries (~120 char max per chunk)
- Add synthesize_custom_voice_streaming() for partial audio yields
- Shorter chunks = faster generation per chunk = smoother playback

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

tts.py

@@ -20,13 +20,44 @@ import numpy as np
 logger = logging.getLogger(__name__)
 
 _SENTENCE_RE = re.compile(r'(?<=[.!?;])\s+')
+_CLAUSE_RE = re.compile(r'(?<=[,;:\u2014])\s+|(?<=\.)\s+|(?<=[!?])\s+')
 _SENTINEL = object()
 
+# Target chunk length — shorter chunks = lower latency per chunk
+_MAX_CHUNK_CHARS = 120
+
 
 def split_into_chunks(text: str) -> list[str]:
-    """Split text into sentence-level chunks suitable for TTS streaming."""
-    parts = _SENTENCE_RE.split(text.strip())
-    return [p.strip() for p in parts if p.strip()]
+    """Split text into short chunks suitable for low-latency TTS streaming.
+    
+    Splits by sentence first, then further splits long sentences by clause
+    boundaries (commas, semicolons, em-dashes) to keep each chunk under
+    ~120 chars for faster TTS generation.
+    """
+    sentences = _SENTENCE_RE.split(text.strip())
+    chunks = []
+    for sent in sentences:
+        sent = sent.strip()
+        if not sent:
+            continue
+        if len(sent) <= _MAX_CHUNK_CHARS:
+            chunks.append(sent)
+        else:
+            # Split long sentence into clauses
+            clauses = _CLAUSE_RE.split(sent)
+            current = ""
+            for clause in clauses:
+                clause = clause.strip()
+                if not clause:
+                    continue
+                if current and len(current) + len(clause) + 1 > _MAX_CHUNK_CHARS:
+                    chunks.append(current.strip())
+                    current = clause
+                else:
+                    current = f"{current} {clause}".strip() if current else clause
+            if current.strip():
+                chunks.append(current.strip())
+    return [c for c in chunks if c]
 
 
 def generate_audio_stream(
@@ -93,13 +124,21 @@ def _start_qwen_worker(chunks, profile_id, chunk_q):
 
 
 def _start_custom_voice_worker(chunks, speaker, chunk_q):
-    """Background thread: synthesize chunks with Qwen3-TTS CustomVoice (0.6B)."""
+    """Background thread: synthesize chunks with Qwen3-TTS CustomVoice (0.6B).
+    Uses sub-segment streaming for lower latency — yields partial audio as generated."""
     def _worker():
-        from voice_clone import synthesize_custom_voice
+        from voice_clone import synthesize_custom_voice_streaming
+        import numpy as np
         for i, stmt in enumerate(chunks):
             try:
-                wav, _sr = synthesize_custom_voice(stmt, speaker=speaker)
-                chunk_q.put((i, wav, None))
+                segments = []
+                for seg, _sr in synthesize_custom_voice_streaming(stmt, speaker=speaker):
+                    segments.append(seg)
+                if segments:
+                    wav = np.concatenate(segments)
+                    chunk_q.put((i, wav, None))
+                else:
+                    chunk_q.put((i, np.zeros(0, dtype=np.float32), None))
             except Exception as exc:
                 logger.exception("CustomVoice synthesis failed on chunk %d", i)
                 chunk_q.put((i, None, str(exc)))

voice_clone.py

@@ -390,6 +390,30 @@ def synthesize_cloned(text: str, profile_id: str) -> tuple[np.ndarray, int]:
     return wav, sample_rate
 
 
+def synthesize_custom_voice_streaming(
+    text: str, speaker: str = "vivian", language: str = "english"
+):
+    """
+    Synthesize text with the 0.6B CustomVoice model, yielding partial audio segments
+    as they become available for lower latency.
+    Yields (wav_segment, sample_rate) tuples.
+    """
+    model = get_custom_voice_model()
+
+    audio_list, sample_rate = model.generate_custom_voice(
+        text=text,
+        speaker=speaker,
+        language=language,
+        non_streaming_mode=False,
+        **GENERATION_PARAMS,
+    )
+
+    # Yield each segment as it was generated
+    for segment in audio_list:
+        if segment is not None and len(segment) > 0:
+            yield segment, sample_rate
+
+
 def synthesize_custom_voice(
     text: str, speaker: str = "vivian", language: str = "english"
 ) -> tuple[np.ndarray, int]: