Upload 8 files

README.md

@@ -0,0 +1,47 @@
+# Belarusian XTTS + Gemini Voice Assistant (Hugging Face Space)
+
+Праект для запуску на **Hugging Face Spaces** (тып: Gradio, **ZeroGPU**),
+які аб'ядноўвае:
+- форк Coqui XTTS ад **tuteishygpt** (`coqui-ai-TTS`)
+- Belarusian XTTS-мадэль з Hugging Face
+- Google Gemini 2.5 Flash-Lite
+- Gradio UI з аўтаматычным мікрафонам, стрымінгам і бардж-ін.
+
+## Як разгарнуць на Spaces
+
+1. Ствары Space:
+   - Space type: **Gradio**
+   - Hardware: **ZeroGPU**
+2. Загрузі ў рэпазіторый усе файлы з гэтага архіва:
+   - `app.py`
+   - `ui.py`
+   - `assistant.py`
+   - `gemini_client.py`
+   - `tts_model.py`
+   - `config.py`
+   - `requirements.txt`
+   - `README.md`
+3. У наладах Space:
+   - зайдзі ў **Settings → Variables and secrets**
+   - дадай:
+     - `GEMINI_API_KEY` — твай API-ключ Google Gemini
+
+Пасля аўтаматычнага `pip install -r requirements.txt` Space павінен запусціць `app.py`,
+дзе ўжо створаны Gradio Blocks.
+
+## Лакальны запуск (не абавязкова)
+
+Калі хочаш праганяць лакальна перад загрузкай у Space:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+pip install --upgrade pip
+pip install -r requirements.txt
+
+export GEMINI_API_KEY="ТВОЙ_API_KEY"  # або праз .env / PowerShell
+python app.py
+```
+
+На ZeroGPU код будзе працаваць на CPU (калі `torch.cuda.is_available()` = False),
+але лагіка для GPU таксама застаецца на выпадак іншых тыпаў машын.

app.py

@@ -0,0 +1,7 @@
+from ui import create_app
+
+demo = create_app()
+
+if __name__ == "__main__":
+    # Лакальны запуск
+    demo.queue().launch()

assistant.py

@@ -0,0 +1,109 @@
+import os
+import base64
+import tempfile
+from typing import Generator, Tuple, Optional
+
+import gradio as gr
+
+from gemini_client import gemini_answer_from_audio, reset_gemini_dialog
+from tts_model import text_to_speech
+
+
+def voice_assistant_from_mic(
+    mic_audio_path: str,
+    speaker_audio: Optional[str],
+) -> Generator[Tuple[str, Optional[str]], None, None]:
+    """
+    Мікрафонны файл → Gemini → стрымінг тэкст→голас.
+    """
+    if not mic_audio_path:
+        raise gr.Error("Спачатку запішы фразу з мікрафона 🙂")
+
+    reply_text = gemini_answer_from_audio(mic_audio_path)
+    if not reply_text:
+        raise gr.Error("Gemini нічога не адказаў або ўзнікла памылка 🙃")
+
+    for chunk in text_to_speech(
+        text_input=reply_text,
+        speaker_audio=speaker_audio,
+    ):
+        yield chunk
+
+
+def safe_voice_assistant(mic_path: str, ref_voice: Optional[str]):
+    """
+    Абгортка для стрымінгу з мікрафона.
+    """
+    if not mic_path:
+        yield gr.update(), gr.update()
+        return
+
+    for item in voice_assistant_from_mic(mic_path, ref_voice):
+        if isinstance(item, (list, tuple)):
+            if len(item) >= 2:
+                stream, log = item[0], item[1]
+            elif len(item) == 1:
+                stream, log = item[0], None
+            else:
+                stream, log = None, None
+        else:
+            stream, log = item, None
+        yield stream, log
+
+
+def handle_b64_wav(b64_audio: str, ref_voice: Optional[str]):
+    """
+    Прыміць base64-WAV з фронта, захаваць у часовы .wav
+    і перадаць у існы пайплайн safe_voice_assistant.
+    """
+    print("handle_b64_wav: called, has_audio =", bool(b64_audio), flush=True)
+
+    if not b64_audio:
+        print("handle_b64_wav: empty audio, returning no-op", flush=True)
+        yield gr.update(), gr.update()
+        return
+
+    try:
+        audio_bytes = base64.b64decode(b64_audio)
+        print("handle_b64_wav: decoded bytes =", len(audio_bytes), flush=True)
+    except Exception as e:
+        print("handle_b64_wav: ERROR in b64decode:", e, flush=True)
+        yield gr.update(), gr.update()
+        return
+
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+        f.write(audio_bytes)
+        temp_path = f.name
+
+    try:
+        for item in safe_voice_assistant(temp_path, ref_voice):
+            yield item
+    finally:
+        try:
+            os.remove(temp_path)
+        except OSError:
+            pass
+
+
+def reset_session() -> str:
+    """
+    Скід гісторыі размовы Gemini + HTML для статуснага блоку.
+    """
+    try:
+        reset_gemini_dialog()
+    except NameError:
+        pass
+
+    return """
+<div id='wa-log' style='font-family:system-ui;font-size:14px;'>
+  <div style='display:flex;align-items:center;gap:10px;'>
+    <div style='width:10px;height:10px;border-radius:999px;background:#6366F1;box-shadow:0 0 0 4px #6366F122;'></div>
+    <div>
+      <div style='font-weight:600;'>🧹 Новая размова</div>
+      <div style='font-size:12px;opacity:0.8;'>
+        Гісторыя размовы ачышчана. Можаш пачаць з чыстага ліста 🙂
+      </div>
+    </div>
+  </div>
+</div>
+"""

config.py

@@ -0,0 +1,26 @@
+import os
+
+# ---- Coqui / HF ----
+REPO_ID = "archivartaunik/BE_XTTS_V2_10ep250k"
+
+MODEL_DIR = os.path.abspath("./model")
+CHECKPOINT_FILE = os.path.join(MODEL_DIR, "model.pth")
+CONFIG_FILE = os.path.join(MODEL_DIR, "config.json")
+VOCAB_FILE = os.path.join(MODEL_DIR, "vocab.json")
+DEFAULT_VOICE_FILE = os.path.join(MODEL_DIR, "voice.wav")
+
+# ---- Streaming / TTS ----
+INITIAL_MIN_BUFFER_S = 0.20   # першы буфер, сек
+MIN_BUFFER_S        = 0.05    # наступныя буферы, сек
+FADE_S              = 0.005
+ENABLE_TEXT_SPLITTING = True
+FIRST_SEGMENT_LIMIT = 160     # сімвалаў
+
+# ---- Gemini ----
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "PASTE_YOUR_KEY_HERE")
+GEMINI_MODEL = "gemini-2.5-flash-lite"
+
+DEFAULT_SYSTEM_PROMPT = (
+    "Ты галасавы беларускамоўны асістэнт. "
+    "Адказвай коратка, натуральна і па-беларуску. "
+)

gemini_client.py

@@ -0,0 +1,72 @@
+from typing import List
+
+from google import genai
+from google.genai import types
+
+from config import GEMINI_API_KEY, GEMINI_MODEL, DEFAULT_SYSTEM_PROMPT
+
+DIALOG_HISTORY: List[types.Content] = []
+
+if not GEMINI_API_KEY or GEMINI_API_KEY == "PASTE_YOUR_KEY_HERE":
+    print("⚠️ Увага: задай GEMINI_API_KEY перад выкарыстаннем голасавага асістэнта.")
+
+gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+
+
+def reset_gemini_dialog() -> str:
+    """
+    Ачышчае глабальную гісторыю дыялогу Gemini.
+    """
+    global DIALOG_HISTORY
+    DIALOG_HISTORY = []
+    return "🧹 Гісторыя размовы Gemini ачышчана. Можаш пачынаць новую размову."
+
+
+def gemini_answer_from_audio(
+    audio_path: str,
+    system_prompt: str = DEFAULT_SYSTEM_PROMPT,
+) -> str:
+    """
+    Аўдыё з файла → Gemini 2.5 Flash-Lite → тэкставы адказ з улікам DIALOG_HISTORY.
+    """
+    global DIALOG_HISTORY
+
+    if not audio_path:
+        return ""
+
+    with open(audio_path, "rb") as f:
+        audio_bytes = f.read()
+
+    user_turn = types.Content(
+        role="user",
+        parts=[
+            types.Part.from_bytes(
+                data=audio_bytes,
+                mime_type="audio/wav",
+            ),
+        ],
+    )
+
+    try:
+        response = gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=[*DIALOG_HISTORY, user_turn],
+            config=types.GenerateContentConfig(
+                system_instruction=system_prompt,
+            ),
+        )
+    except Exception as e:
+        print("Памылка Gemini:", e)
+        return ""
+
+    text = (getattr(response, "text", "") or "").strip()
+    if not text:
+        return ""
+
+    assistant_turn = types.Content(
+        role="model",
+        parts=[types.Part.from_text(text=text)],
+    )
+    DIALOG_HISTORY.extend([user_turn, assistant_turn])
+
+    return text

requirements.txt

@@ -0,0 +1,7 @@
+git+https://github.com/tuteishygpt/coqui-ai-TTS.git#egg=TTS
+torch
+numpy
+gradio
+huggingface_hub
+scipy
+google-genai

tts_model.py

@@ -0,0 +1,360 @@
+import os
+import re
+import time
+import json
+import base64
+import pathlib
+import hashlib
+from dataclasses import dataclass
+from typing import Iterable, Iterator, Optional, Tuple, List, Any
+
+import numpy as np
+import torch
+import gradio as gr
+from huggingface_hub import hf_hub_download
+
+# ВАЖНА: выкарыстоўваем менавіта форк TTS з GitHub:
+# git+https://github.com/tuteishygpt/coqui-ai-TTS.git#egg=TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from TTS.tts.layers.xtts.tokenizer import VoiceBpeTokenizer, split_sentence
+
+from config import (
+    REPO_ID,
+    MODEL_DIR,
+    CHECKPOINT_FILE,
+    CONFIG_FILE,
+    VOCAB_FILE,
+    DEFAULT_VOICE_FILE,
+    INITIAL_MIN_BUFFER_S,
+    MIN_BUFFER_S,
+    ENABLE_TEXT_SPLITTING,
+    FIRST_SEGMENT_LIMIT,
+)
+
+# Мінімізуем колькасць патокаў для стабільнасці на ZeroGPU / CPU
+os.environ.setdefault("OMP_NUM_THREADS", "1")
+os.environ.setdefault("MKL_NUM_THREADS", "1")
+os.environ.setdefault("NUMEXPR_NUM_THREADS", "1")
+
+# ---------------------------------------------------------
+# 1) загрузка мадэльных файлаў
+# ---------------------------------------------------------
+os.makedirs(MODEL_DIR, exist_ok=True)
+for fname in ("model.pth", "config.json", "vocab.json", "voice.wav"):
+    fpath = os.path.join(MODEL_DIR, fname)
+    if not os.path.exists(fpath):
+        hf_hub_download(REPO_ID, filename=fname, local_dir=MODEL_DIR)
+
+# ---------------------------------------------------------
+# 2) ініцыялізацыя мадэлі XTTS
+# ---------------------------------------------------------
+config = XttsConfig()
+config.load_json(CONFIG_FILE)
+XTTS_MODEL = Xtts.init_from_config(config)
+XTTS_MODEL.load_checkpoint(
+    config,
+    checkpoint_path=CHECKPOINT_FILE,
+    vocab_path=VOCAB_FILE,
+    use_deepspeed=False,
+)
+
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+torch.set_num_threads(1)
+if device.startswith("cuda"):
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.backends.cudnn.benchmark = True
+    try:
+        torch.set_float32_matmul_precision("high")
+    except Exception:
+        pass
+
+XTTS_MODEL.to(device).eval()
+sampling_rate = int(XTTS_MODEL.config.audio["sample_rate"])
+
+tokenizer = VoiceBpeTokenizer(vocab_file=VOCAB_FILE)
+XTTS_MODEL.tokenizer = tokenizer
+
+# ---------------------------------------------------------
+# 3) Кэш латэнтаў
+# ---------------------------------------------------------
+PERSIST_LATENTS_DIR = pathlib.Path("./latents_cache")
+PERSIST_LATENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+@dataclass(frozen=True)
+class LatentsMeta:
+    model_id: str
+    gpt_cond_len: int
+    max_ref_len: int
+    sound_norm_refs: bool
+
+
+LATENT_CACHE: dict[str, Tuple[torch.Tensor, torch.Tensor]] = {}
+GPU_LATENT_CACHE: dict[Tuple[str, str], Tuple[torch.Tensor, torch.Tensor]] = {}
+
+
+def _latents_key(path: Optional[str], meta: LatentsMeta) -> str:
+    base = (
+        f"{os.path.abspath(path)}:{os.path.getmtime(path)}:{os.path.getsize(path)}"
+        if path and os.path.exists(path)
+        else "default_voice"
+    )
+    h = hashlib.md5()
+    h.update((base + "|" + json.dumps(meta.__dict__, sort_keys=True)).encode("utf-8"))
+    return h.hexdigest()
+
+
+def _latents_for(path: Optional[str], *, to_device: Optional[str] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+    cfg = XTTS_MODEL.config
+    meta = LatentsMeta(
+        model_id=REPO_ID,
+        gpt_cond_len=cfg.gpt_cond_len,
+        max_ref_len=cfg.max_ref_len,
+        sound_norm_refs=cfg.sound_norm_refs,
+    )
+    key = _latents_key(path, meta)
+    g, s = LATENT_CACHE.get(key) or (None, None)
+    if g is None:
+        disk_path = PERSIST_LATENTS_DIR / f"{key}.pt"
+        if disk_path.exists():
+            data = torch.load(disk_path, map_location="cpu")
+            g, s = data["gpt_cond_latent"], data["speaker_embedding"]
+        else:
+            print(f"Разлік латэнтаў для {path or 'стандартнага голасу'}...")
+            with torch.inference_mode():
+                g_cpu, s_cpu = XTTS_MODEL.get_conditioning_latents(audio_path=path)
+            g, s = g_cpu.cpu(), s_cpu.cpu()
+            torch.save({"gpt_cond_latent": g, "speaker_embedding": s}, disk_path)
+            print("Латэнты захаваны ў кэш.")
+        LATENT_CACHE[key] = (g, s)
+    if to_device:
+        dev_key = (key, to_device)
+        if dev_key in GPU_LATENT_CACHE:
+            return GPU_LATENT_CACHE[dev_key]
+        g, s = g.to(to_device, non_blocking=True), s.to(to_device, non_blocking=True)
+        GPU_LATENT_CACHE[dev_key] = (g, s)
+    return g, s
+
+
+try:
+    if os.path.exists(DEFAULT_VOICE_FILE):
+        _latents_for(DEFAULT_VOICE_FILE, to_device=device)
+        print("Стандартны голас паспяхова пракэшаваны.")
+except Exception as e:
+    print(f"Папярэджанне: не атрымалася папярэдне кэшаваць стандартны голас: {e}")
+
+# ---------------------------------------------------------
+# 4) Дапаможнікі па аўдыё
+# ---------------------------------------------------------
+def _to_np_audio(x: Any) -> np.ndarray:
+    if isinstance(x, dict) and "wav" in x:
+        x = x["wav"]
+    if isinstance(x, torch.Tensor):
+        x = x.detach().cpu().float().contiguous().view(-1).numpy()
+    x = np.asarray(x, dtype=np.float32)
+    return x.reshape(-1)
+
+
+def _seconds_to_samples(sec: float, sr: int) -> int:
+    return max(1, int(sec * sr))
+
+
+def _chunker(
+    chunks: Iterable[np.ndarray],
+    sr: int,
+    initial_target_s: float,
+    target_s: float,
+) -> Iterator[np.ndarray]:
+    is_first = True
+    target_samples = _seconds_to_samples(initial_target_s, sr)
+    min_first = _seconds_to_samples(0.12, sr)   # мін. 120 мс
+    min_next  = _seconds_to_samples(0.05, sr)   # мін. 50 мс
+    buffer = np.array([], dtype=np.float32)
+    for c_np in map(_to_np_audio, chunks):
+        if c_np.size == 0:
+            continue
+        buffer = np.concatenate([buffer, c_np])
+        need = target_samples if buffer.size < target_samples else 0
+        if buffer.size >= max(min_first if is_first else min_next, need):
+            yield buffer
+            buffer = np.array([], dtype=np.float32)
+            if is_first:
+                is_first = False
+                target_samples = _seconds_to_samples(target_s, sr)
+    if buffer.size > 0:
+        yield buffer
+
+
+def _pcm_f32_to_b64(x: np.ndarray) -> str:
+    return base64.b64encode(x.tobytes()).decode("ascii")
+
+# ---------------------------------------------------------
+# 5) Падзел тэксту
+# ---------------------------------------------------------
+_SENT_END = re.compile(r"([\.\!\?…]+[»")\]]*\s+)")
+_WS = re.compile(r"\s+")
+
+
+def _fast_split(text: str, limit: int) -> List[str]:
+    text = text.strip()
+    if not text:
+        return []
+    parts, start = [], 0
+    for m in _SENT_END.finditer(text):
+        end = m.end()
+        parts.append(text[start:end].strip())
+        start = end
+    if start < len(text):
+        parts.append(text[start:].strip())
+    chunks, cur = [], ""
+    for s in parts:
+        if len(cur) + 1 + len(s) <= limit:
+            cur = (cur + " " + s).strip() if cur else s
+        else:
+            if cur:
+                chunks.append(cur)
+            if len(s) <= limit:
+                cur = s
+            else:
+                w = _WS.split(s)
+                acc = ""
+                for tok in w:
+                    if len(acc) + 1 + len(tok) <= limit:
+                        acc = (acc + " " + tok).strip() if acc else tok
+                    else:
+                        if acc:
+                            chunks.append(acc)
+                        acc = tok
+                cur = acc or ""
+    if cur:
+        chunks.append(cur)
+    return [c for c in chunks if c]
+
+
+def _split_text_smart(text_in: str, lang_short: str, chunk_limit: int) -> List[str]:
+    text_in = text_in.strip()
+    if not text_in:
+        return []
+    parts: List[str] = []
+    if len(text_in) > FIRST_SEGMENT_LIMIT:
+        head = text_in[:FIRST_SEGMENT_LIMIT]
+        m = re.search(r".*[\.\!\?…»)]", head)
+        if m and len(m.group(0)) > 30:
+            head = m.group(0)
+        tail = text_in[len(head):].lstrip()
+        parts.append(head)
+        text_for_rest = tail
+    else:
+        text_for_rest = text_in
+    if not text_for_rest:
+        return parts or [text_in]
+
+    rest = _fast_split(text_for_rest, chunk_limit)
+    if not rest or sum(len(x) for x in rest) < int(0.6 * len(text_for_rest)):
+        try:
+            rest2 = split_sentence(text_for_rest, lang=lang_short, text_split_length=chunk_limit)
+            rest2 = [s.strip() for s in rest2 if s and s.strip()]
+            if rest2:
+                rest = rest2
+        except Exception:
+            pass
+    return parts + (rest or [text_for_rest])
+
+# ---------------------------------------------------------
+# 6) Асноўная функцыя TTS (стрымінг)
+# ---------------------------------------------------------
+def text_to_speech(
+    text_input: str,
+    speaker_audio: Optional[str],
+    initial_buffer_s: Optional[float] = None,
+    subsequent_buffer_s: Optional[float] = None,
+):
+    """
+    Генератар: вяртае (b64_float32_wav, metrics_json_or_None)
+    """
+    if initial_buffer_s is None:
+        initial_buffer_s = INITIAL_MIN_BUFFER_S
+    if subsequent_buffer_s is None:
+        subsequent_buffer_s = MIN_BUFFER_S
+
+    t_start_req = time.perf_counter()
+    if not text_input or not str(text_input).strip():
+        raise gr.Error("Увядзі хоць нейкі тэкст 🙂")
+
+    # Латэнты
+    t_lat_0 = time.perf_counter()
+    gpt_cond_latent, speaker_embedding = _latents_for(
+        speaker_audio or DEFAULT_VOICE_FILE,
+        to_device=device,
+    )
+    t_lat_1 = time.perf_counter()
+
+    # Падзел тэксту
+    t_split_0 = time.perf_counter()
+    char_limit_cfg = getattr(XTTS_MODEL, "tokenizer", None)
+    be_limit = 250
+    if char_limit_cfg and hasattr(char_limit_cfg, "char_limits"):
+        be_limit = char_limit_cfg.char_limits.get("be", 250)
+    char_limit = min(180, be_limit)
+    texts = (
+        _split_text_smart(str(text_input).strip(), "be", char_limit)
+        if ENABLE_TEXT_SPLITTING
+        else [str(text_input).strip()]
+    )
+    t_split_1 = time.perf_counter()
+
+    server_metrics = {
+        "latents_s": t_lat_1 - t_lat_0,
+        "text_split_s": t_split_1 - t_split_0,
+        "initial_buffer_s": initial_buffer_s,
+        "subsequent_buffer_s": subsequent_buffer_s,
+    }
+
+    # 1-е паведамленне — толькі метрыкі
+    yield ("", json.dumps(server_metrics))
+
+    first_chunk_sent = False
+    t_gen_start = time.perf_counter()
+
+    with torch.inference_mode(), torch.autocast(
+        device_type="cuda",
+        dtype=torch.float16,
+        enabled=str(device).startswith("cuda"),
+    ):
+        all_chunks_iterator = (
+            _to_np_audio(chunk)
+            for part in texts
+            for chunk in XTTS_MODEL.inference_stream(
+                text=part,
+                language="be",
+                gpt_cond_latent=gpt_cond_latent,
+                speaker_embedding=speaker_embedding,
+                temperature=0.25,
+                length_penalty=0.9,
+                repetition_penalty=7.0,
+                top_k=10,
+                top_p=0.80,
+            )
+        )
+
+        for audio_chunk in _chunker(
+            all_chunks_iterator,
+            sampling_rate,
+            initial_buffer_s,
+            subsequent_buffer_s,
+        ):
+            if not first_chunk_sent:
+                t_first_chunk_ready = time.perf_counter()
+                server_metrics["gen_init_to_first_chunk_s"] = (
+                    t_first_chunk_ready - t_gen_start
+                )
+                server_metrics["until_first_chunk_total_s"] = (
+                    t_first_chunk_ready - t_start_req
+                )
+                yield (_pcm_f32_to_b64(audio_chunk), json.dumps(server_metrics))
+                first_chunk_sent = True
+            else:
+                yield (_pcm_f32_to_b64(audio_chunk), None)

ui.py

@@ -0,0 +1,506 @@
+import gradio as gr
+
+from tts_model import sampling_rate, text_to_speech
+from assistant import handle_b64_wav, reset_session
+
+
+def create_app():
+    with gr.Blocks() as demo:
+        gr.Markdown("## Belarusian TTS — Streaming (форк coqui-ai-TTS + Gemini)")
+
+        # CSS
+        gr.HTML(
+            """
+<style>
+/* Мікрафон */
+#mic-input {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+#mic-input {
+  position: relative !important;
+  width: 80px !important;
+  height: 80px !important;
+  border-radius: 999px !important;
+  border: none !important;
+  cursor: pointer !important;
+  background: radial-gradient(circle at 30% 30%, #f97316, #b91c1c) !important;
+  box-shadow: 0 10px 25px rgba(0,0,0,.35) !important;
+  display: flex !important;
+  align-items: center !important;
+  justify-content: center !important;
+  padding: 0 !important;
+  font-size: 0 !important;
+  color: transparent !important;
+}
+#mic-input::before {
+  content: "" !important;
+  position: absolute !important;
+  inset: -6px !important;
+  border-radius: 999px !important;
+  border: 2px solid #f97316 !important;
+  animation: mic-pulse 1.6s infinite !important;
+}
+#mic-input::after {
+  content: "🎙️" !important;
+  font-size: 34px !important;
+  color: #fee2e2 !important;
+}
+@keyframes mic-pulse {
+  0%   { transform: scale(1);    opacity: 0.9; }
+  70%  { transform: scale(1.35); opacity: 0;   }
+  100% { transform: scale(1.35); opacity: 0;   }
+}
+
+/* Кнопка «Пачаць новую размову» */
+#reset-btn {
+  margin-top: 10px !important;
+  padding: 10px 18px !important;
+  border-radius: 999px !important;
+  border: none !important;
+  cursor: pointer !important;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif !important;
+  font-size: 14px !important;
+  font-weight: 600 !important;
+  background: linear-gradient(135deg, #4f46e5, #0ea5e9) !important;
+  color: #eff6ff !important;
+  box-shadow: 0 6px 18px rgba(15,23,42,0.35) !important;
+  display: inline-flex !important;
+  align-items: center !important;
+  gap: 8px !important;
+}
+#reset-btn::before {
+  content: "🧹" !important;
+  font-size: 16px !important;
+}
+#reset-btn:hover {
+  filter: brightness(1.05);
+  transform: translateY(-1px);
+}
+#reset-btn:active {
+  filter: brightness(0.98);
+  transform: translateY(0);
+}
+</style>
+"""
+        )
+
+        # Верхні радок
+        with gr.Row():
+            gr.Column(scale=1)
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎙️ Мікрафон — спытайся ў асістэнта")
+
+                mic_btn = gr.Button("", elem_id="mic-input")
+                dummy_in = gr.Textbox(visible=False)
+
+                reset_btn = gr.Button("Пачаць новую размову", elem_id="reset-btn")
+            gr.Column(scale=1)
+
+        # Статус
+        log_panel = gr.HTML(
+            value="""
+<div id='wa-log' style='font-family:system-ui;font-size:14px;'>
+  <div style='display:flex;align-items:center;gap:10px;'>
+    <div style='width:10px;height:10px;border-radius:999px;background:#10B981;box-shadow:0 0 0 4px #10B98122;'></div>
+    <div>
+      <div style='font-weight:600;'>✅ Гатова</div>
+      <div style='font-size:12px;opacity:0.8;'>Няма актыўнай генерацыі. Можаш задаць запыт.</div>
+    </div>
+  </div>
+</div>
+""",
+            label="Статус асістэнта",
+        )
+
+        reset_btn.click(
+            fn=reset_session,
+            inputs=None,
+            outputs=log_panel,
+        )
+
+        stream_pipe = gr.Textbox(visible=False)
+        log_pipe = gr.Textbox(visible=False)
+
+        # Ніжні блок: TTS
+        with gr.Accordion("Налады TTS (па жаданні)", open=False):
+            with gr.Row():
+                inp_text = gr.Textbox(
+                    lines=3,
+                    label="Тэкст на беларускай мове",
+                )
+                inp_voice = gr.Audio(
+                    type="filepath",
+                    label="Прыклад голасу (6–10 сек)",
+                )
+            with gr.Row():
+                run_btn = gr.Button("Згенераваць (тэкст → голас)")
+                gr.Markdown(f"**Частата дыскрэтызацыі:** {int(sampling_rate)} Гц")
+
+        run_btn.click(
+            fn=text_to_speech,
+            inputs=[inp_text, inp_voice],
+            outputs=[stream_pipe, log_pipe],
+        )
+
+        # -------- JS_PLAYER --------
+        JS_PLAYER = """
+(b64) => {
+  if (!window.__wa) {
+    const sampleRate = SAMPLE_RATE_HZ;
+    const AC = window.AudioContext || window.webkitAudioContext;
+    if (!AC) { console.error('AudioContext is not supported.'); return; }
+    const ctx = new AC({ sampleRate });
+    const node = ctx.createScriptProcessor(2048, 1, 1);
+
+    let queue = [];
+    let playing = false;
+    let hasPlayedOnce = false;
+    let idleSince = null;
+    let autoMicStarted = false;
+    let stoppedByMic = false;
+
+    function autoStartMic() {
+      setTimeout(() => {
+        const btn = document.getElementById('mic-input');
+        if (!btn) return;
+        btn.click();
+      }, 300);
+    }
+
+    function logUpdate(state) {
+      const el = document.getElementById('wa-log');
+      if (!el) return;
+
+      let title = '✅ Гатова';
+      let subtitle = 'Можаш задаць наступнае пытанне.';
+      let color = '#10B981';
+
+      if (state === 'speaking') {
+        title = '🗣️ Кажу';
+        subtitle = 'Ідзе прайграванне згенераванага голасу.';
+        color = '#3B82F6';
+      } else if (state === 'buffering') {
+        title = '👂 Слухаю';
+        subtitle = 'Прылятаюць новыя аўдыя-чанкі ад мадэлі…';
+        color = '#6366F1';
+      } else if (state === 'idle') {
+        title = '✅ Гатова';
+        subtitle = 'Стрымінг завершаны. Можаш пытацца яшчэ 🙂';
+        color = '#10B981';
+      }
+
+      const html = `
+<div style="display:flex;align-items:center;gap:10px;">
+  <div style="width:10px;height:10px;border-radius:999px;background:${color};box-shadow:0 0 0 4px ${color}22;"></div>
+  <div>
+    <div style="font-weight:600;">${title}</div>
+    <div style="font-size:12px;opacity:0.8;">${subtitle}</div>
+  </div>
+</div>`;
+      el.innerHTML = html;
+    }
+
+    node.onaudioprocess = (e) => {
+      const out = e.outputBuffer.getChannelData(0);
+      let i = 0;
+
+      while (i < out.length) {
+        if (queue.length === 0) {
+          out[i++] = 0.0;
+          continue;
+        }
+        let cur = queue[0];
+        const take = Math.min(cur.length, out.length - i);
+        out.set(cur.subarray(0, take), i);
+        i += take;
+        if (take === cur.length) {
+          queue.shift();
+        } else {
+          queue[0] = cur.subarray(take);
+        }
+      }
+
+      const now = performance.now();
+
+      if (queue.length === 0) {
+        if (playing) {
+          playing = false;
+          logUpdate('idle');
+        }
+        if (hasPlayedOnce && !stoppedByMic && !autoMicStarted) {
+          if (idleSince === null) idleSince = now;
+          if (now - idleSince > 700) {
+            autoMicStarted = true;
+            autoStartMic();
+          }
+        }
+      } else {
+        if (!playing) {
+          playing = true;
+          logUpdate('speaking');
+        } else {
+          logUpdate('buffering');
+        }
+        idleSince = null;
+      }
+    };
+
+    node.connect(ctx.destination);
+
+    window.__wa = {
+      push: (b64in) => {
+        if (!b64in) return;
+
+        stoppedByMic = false;
+        autoMicStarted = false;
+
+        try {
+          const bin = atob(b64in);
+          const buf = new ArrayBuffer(bin.length);
+          const view = new Uint8Array(buf);
+          for (let i = 0; i < bin.length; i++) view[i] = bin.charCodeAt(i);
+          const f32 = new Float32Array(buf);
+          if (f32.length > 0) {
+            queue.push(f32);
+            hasPlayedOnce = true;
+          }
+        } catch (err) {
+          console.error('Failed to decode audio chunk', err);
+        }
+
+        if (!playing && queue.length > 0 && ctx.state === 'suspended') {
+          ctx.resume();
+        }
+        if (!playing && queue.length > 0) {
+          playing = true;
+          logUpdate('speaking');
+        } else if (playing) {
+          logUpdate('buffering');
+        }
+      },
+
+      stop: () => {
+        queue.length = 0;
+        playing = false;
+        stoppedByMic = true;
+        idleSince = null;
+        autoMicStarted = false;
+        logUpdate('idle');
+        if (ctx && ctx.state === 'running') {
+          ctx.suspend();
+        }
+      },
+
+      update_server_metrics: (js) => {},
+
+      reset: () => {
+        queue.length = 0;
+        playing = false;
+        hasPlayedOnce = false;
+        idleSince = null;
+        autoMicStarted = false;
+        stoppedByMic = false;
+        logUpdate('idle');
+      },
+
+      ctx: ctx
+    };
+
+    logUpdate('idle');
+  }
+
+  if (!b64) return;
+  if (window.__wa) {
+    window.__wa.push(b64);
+  }
+}
+"""
+        JS_PLAYER = JS_PLAYER.replace("SAMPLE_RATE_HZ", str(int(sampling_rate)))
+
+        stream_pipe.change(fn=None, inputs=[stream_pipe], js=JS_PLAYER)
+        log_pipe.change(
+            fn=None,
+            inputs=[log_pipe],
+            js="(js) => { if(window.__wa) window.__wa.update_server_metrics(js); }",
+        )
+
+        # -------- JS_RECORDER --------
+        JS_RECORDER = """
+(dummy, ref_voice) => {
+  return new Promise(async (resolve, reject) => {
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+      console.error("getUserMedia not supported");
+      resolve([null, ref_voice]);
+      return;
+    }
+
+    let stream = null;
+    let ctx = null;
+    let source = null;
+    let processor = null;
+    let stopped = false;
+    let speechStarted = false;
+    let lastSpeechTime = 0;
+    let startTime = performance.now();
+    const silenceMsAfterSpeech = 800;
+    const maxTotalMs = 15000;
+    const voiceThreshold = 0.012;
+    let recordedBuffers = [];
+
+    function setLog(title, subtitle, color) {
+      const el = document.getElementById('wa-log');
+      if (!el) return;
+      const html =
+        '<div style="display:flex;align-items:center;gap:10px;">' +
+          '<div style="width:10px;height:10px;border-radius:999px;background:' + color +
+            ';box-shadow:0 0 0 4px ' + color + '22;"></div>' +
+          '<div>' +
+            '<div style="font-weight:600;">' + title + '</div>' +
+            '<div style="font-size:12px;opacity:0.8;">' + subtitle + '</div>' +
+          '</div>' +
+        '</div>';
+      el.innerHTML = html;
+    }
+
+    function cleanup() {
+      try { if (processor) { processor.disconnect(); processor.onaudioprocess = null; } } catch (e) {}
+      try { if (source) { source.disconnect(); } } catch (e) {}
+      if (stream) { stream.getTracks().forEach(t => t.stop()); }
+      if (ctx && ctx.state !== 'closed') { ctx.close(); }
+    }
+
+    function stopWithResolve(b64) {
+      if (stopped) return;
+      stopped = true;
+      cleanup();
+      resolve([b64, ref_voice]);
+    }
+
+    function encodeWAV(samples, sampleRate) {
+      const buffer = new ArrayBuffer(44 + samples.length * 2);
+      const view = new DataView(buffer);
+
+      function writeString(view, offset, string) {
+        for (let i = 0; i < string.length; i++) {
+          view.setUint8(offset + i, string.charCodeAt(i));
+        }
+      }
+
+      let offset = 0;
+      writeString(view, offset, 'RIFF'); offset += 4;
+      view.setUint32(offset, 36 + samples.length * 2, true); offset += 4;
+      writeString(view, offset, 'WAVE'); offset += 4;
+      writeString(view, offset, 'fmt '); offset += 4;
+      view.setUint32(offset, 16, true); offset += 4;
+      view.setUint16(offset, 1, true); offset += 2;
+      view.setUint16(offset, 1, true); offset += 2;
+      view.setUint32(offset, sampleRate, true); offset += 4;
+      view.setUint32(offset, sampleRate * 2, true); offset += 4;
+      view.setUint16(offset, 2, true); offset += 2;
+      view.setUint16(offset, 16, true); offset += 2;
+      writeString(view, offset, 'data'); offset += 4;
+      view.setUint32(offset, samples.length * 2, true); offset += 4;
+
+      let index = 44;
+      for (let i = 0; i < samples.length; i++, index += 2) {
+        let s = Math.max(-1, Math.min(1, samples[i]));
+        view.setInt16(index, s < 0 ? s * 0x8000 : s * 0x7FFF, true);
+      }
+
+      return buffer;
+    }
+
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    } catch (err) {
+      console.error('Mic error', err);
+      setLog('⚠️ Памылка мікрафона', 'Не атрымалася атрымаць доступ да мікрафона.', '#EF4444');
+      stopWithResolve(null);
+      return;
+    }
+
+    setLog('🎤 Слухаю', 'Сесія актыўная. Пачынай гаварыць.', '#6366F1');
+
+    const AC = window.AudioContext || window.webkitAudioContext;
+    ctx = new AC();
+    source = ctx.createMediaStreamSource(stream);
+    const bufferSize = 2048;
+    processor = ctx.createScriptProcessor(bufferSize, 1, 1);
+
+    source.connect(processor);
+    processor.connect(ctx.destination);
+
+    processor.onaudioprocess = (e) => {
+      if (stopped) return;
+      const input = e.inputBuffer.getChannelData(0);
+      if (!input) return;
+
+      let sum = 0.0;
+      for (let i = 0; i < input.length; i++) {
+        const s = input[i];
+        sum += s * s;
+      }
+      const rms = Math.sqrt(sum / input.length);
+      const now = performance.now();
+
+      if (rms > voiceThreshold) {
+        if (!speechStarted) {
+          speechStarted = true;
+          lastSpeechTime = now;
+          recordedBuffers = [];
+
+          if (window.__wa && typeof window.__wa.stop === 'function') {
+            window.__wa.stop();
+          }
+          setLog('👂 Слухаю', 'Фіксую тваю фразу…', '#6366F1');
+        } else {
+          lastSpeechTime = now;
+        }
+        recordedBuffers.push(new Float32Array(input));
+      } else {
+        if (speechStarted && (now - lastSpeechTime > silenceMsAfterSpeech)) {
+          if (!recordedBuffers.length) {
+            setLog('✅ Гатова', 'Голас не зафіксаваны.', '#10B981');
+            stopWithResolve(null);
+            return;
+          }
+          let totalLength = 0;
+          for (const b of recordedBuffers) totalLength += b.length;
+          const merged = new Float32Array(totalLength);
+          let offset = 0;
+          for (const b of recordedBuffers) {
+            merged.set(b, offset);
+            offset += b.length;
+          }
+          const wavBuffer = encodeWAV(merged, ctx.sampleRate);
+          const bytes = new Uint8Array(wavBuffer);
+          let binary = '';
+          for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          const b64 = btoa(binary);
+          setLog('🤖 Думаю', 'Адпраўляю фразу асістэнту…', '#F59E0B');
+          stopWithResolve(b64);
+          return;
+        }
+      }
+
+      if (!speechStarted && (now - startTime > maxTotalMs)) {
+        setLog('✅ Гатова', 'Голас не зафіксаваны.', '#10B981');
+        stopWithResolve(null);
+      }
+    };
+  });
+}
+"""
+
+        mic_btn.click(
+            fn=handle_b64_wav,
+            inputs=[dummy_in, inp_voice],
+            outputs=[stream_pipe, log_pipe],
+            js=JS_RECORDER,
+        )
+
+    return demo