Update

app.py

@@ -1,97 +1,51 @@
 
-# app.py - KC Robot AI V4.1 (Full - FPT female TTS)
-# Full-feature Flask server:
-#  - /ask (text) -> HF LLM
-#  - /tts (text) -> HF TTS (default: NguyenManhTuan/VietnameseTTS_FPT_AI_Female)
-#  - /stt (audio) -> HF STT (default: openai/whisper-small)
-#  - /presence (radar event) -> greeting + Telegram notify
-#  - /display -> OLED lines
-#  - Web UI for quick test
-#  - Telegram poller (background thread) to accept /ask, /say, /status
-#
-# Configuration via environment variables / Secrets in HF Space:
-#   HF_API_TOKEN (required for HF inference)
-#   HF_MODEL (optional, default google/flan-t5-large)
-#   HF_TTS_MODEL (optional, default NguyenManhTuan/VietnameseTTS_FPT_AI_Female)
-#   HF_STT_MODEL (optional, default openai/whisper-small)
-#   TELEGRAM_TOKEN (optional)
-#   TELEGRAM_CHATID (optional)
-#
-# Keep requirements minimal to improve HF Space stability:
-#   flask, requests
-#
-# Important: set tokens in HF Space Settings -> Secrets (do not hardcode)
-
-import os
-import io
-import time
-import json
-import uuid
-import logging
-import threading
-from typing import Optional, List, Tuple
+# app.py - KC Robot AI V4.4 (Web STT from browser mic + TTS greeting + Telegram + Radar)
+import os, io, time, json, threading, logging, requests, uuid
 from pathlib import Path
-
-import requests
 from flask import Flask, request, jsonify, send_file, render_template_string, abort
 
-# ----------------- Config & Logging -----------------
+# ---------- Config ----------
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("kcrobot.v4")
+logger = logging.getLogger("kcrobot.v4.4")
 
 app = Flask(__name__)
 
-# Directory for temporary files (tts audio)
 TMP_DIR = Path("/tmp/kcrobot") if os.name != "nt" else Path.cwd() / "tmp_kcrobot"
 TMP_DIR.mkdir(parents=True, exist_ok=True)
 
-# Environment / Secrets (set these in HF Space)
 HF_API_TOKEN = os.getenv("HF_API_TOKEN", "").strip()
 HF_MODEL = os.getenv("HF_MODEL", "google/flan-t5-large").strip()
-# Default FPT female Vietnamese TTS
 HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "NguyenManhTuan/VietnameseTTS_FPT_AI_Female").strip()
 HF_STT_MODEL = os.getenv("HF_STT_MODEL", "openai/whisper-small").strip()
 TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "").strip()
 TELEGRAM_CHATID = os.getenv("TELEGRAM_CHATID", "").strip()
-
-# Port (HF sets PORT env in runtime)
-PORT = int(os.getenv("PORT", os.getenv("SERVER_PORT", 7860)))
-
-if not HF_API_TOKEN:
-    logger.warning("HF_API_TOKEN is not set — HF inference will fail until you add it in Secrets.")
+PORT = int(os.getenv("PORT", 7860))
 
 HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
+if not HF_API_TOKEN:
+    logger.warning("⚠️ HF_API_TOKEN not set — STT/TTS/LLM calls will fail without it.")
 
-# ----------------- In-memory buffers -----------------
-CONV: List[Tuple[str, str]] = []         # list of (user, bot)
-DISPLAY_LINES: List[str] = []            # lines for OLED display
+# ---------- In-memory ----------
+CONV = []             # list of (user,bot)
+DISPLAY_LINES = []    # for ESP32 OLED
 
-def push_display(line: str, limit: int = 6):
-    """Keep last `limit` lines for display."""
-    global DISPLAY_LINES
+def push_display(line: str, limit=8):
     DISPLAY_LINES.append(line)
     if len(DISPLAY_LINES) > limit:
-        DISPLAY_LINES = DISPLAY_LINES[-limit:]
+        del DISPLAY_LINES[0: len(DISPLAY_LINES)-limit]
 
-# ----------------- Helper: Hugging Face inference -----------------
+# ---------- HF helpers ----------
 def hf_post_json(model_id: str, payload: dict, timeout: int = 120):
-    """POST JSON to HF inference; return parsed JSON or raise."""
     if not HF_API_TOKEN:
         raise RuntimeError("HF_API_TOKEN missing (set in Secrets).")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
-    headers = dict(HF_HEADERS)
-    headers["Content-Type"] = "application/json"
-    r = requests.post(url, headers=headers, json=payload, timeout=timeout)
+    r = requests.post(url, headers={**HF_HEADERS, "Content-Type": "application/json"}, json=payload, timeout=timeout)
     if not r.ok:
         logger.error("HF POST JSON error %s: %s", r.status_code, r.text[:400])
         r.raise_for_status()
-    try:
-        return r.json()
-    except Exception:
-        return r.text
+    return r.json()
 
 def hf_post_bytes(model_id: str, data: bytes, content_type: str = "application/octet-stream", timeout: int = 180):
-    """POST binary data (audio) to HF inference; return response object or raise."""
     if not HF_API_TOKEN:
         raise RuntimeError("HF_API_TOKEN missing (set in Secrets).")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
@@ -103,341 +57,267 @@ def hf_post_bytes(model_id: str, data: bytes, content_type: str = "application/o
         r.raise_for_status()
     return r
 
-# ----------------- Text generation (LLM) -----------------
-def hf_text_generate(prompt: str, model: Optional[str] = None, max_new_tokens: int = 256, temperature: float = 0.7) -> str:
-    model = model or HF_MODEL
-    payload = {
-        "inputs": prompt,
-        "parameters": {"max_new_tokens": int(max_new_tokens), "temperature": float(temperature)},
-        "options": {"wait_for_model": True}
-    }
-    out = hf_post_json(model, payload, timeout=120)
+def hf_text_generate(prompt: str):
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 256, "temperature": 0.7}, "options": {"wait_for_model": True}}
+    out = hf_post_json(HF_MODEL, payload)
     # parse common shapes
-    if isinstance(out, list) and len(out) > 0:
-        first = out[0]
-        if isinstance(first, dict) and "generated_text" in first:
-            return first["generated_text"]
-        return str(first)
+    if isinstance(out, list) and len(out) and isinstance(out[0], dict):
+        return out[0].get("generated_text", "") or str(out[0])
     if isinstance(out, dict):
-        for k in ("generated_text", "text", "summary_text"):
+        for k in ("generated_text", "text"):
             if k in out:
                 return out[k]
-        return json.dumps(out)
     return str(out)
 
-# ----------------- TTS (Text -> audio bytes) -----------------
-def hf_tts_get_audio_bytes(text: str, model: Optional[str] = None) -> bytes:
-    """Call HF TTS model and return audio bytes (commonly mp3 or wav)."""
-    model = model or HF_TTS_MODEL
+def hf_tts_bytes(text: str):
     payload = {"inputs": text}
-    r = requests.post(f"https://api-inference.huggingface.co/models/{model}", headers={**HF_HEADERS, "Content-Type": "application/json"}, json=payload, timeout=120)
+    url = f"https://api-inference.huggingface.co/models/{HF_TTS_MODEL}"
+    r = requests.post(url, headers={**HF_HEADERS, "Content-Type": "application/json"}, json=payload, timeout=120)
     if not r.ok:
         logger.error("HF TTS error %s: %s", r.status_code, r.text[:400])
         r.raise_for_status()
     return r.content
 
-def save_tts_temp(audio_bytes: bytes, ext_hint: str = "mp3") -> str:
-    """Save bytes to a temp file under TMP_DIR and return filename."""
-    fname = f"tts_{int(time.time())}_{uuid.uuid4().hex}.{ext_hint}"
-    p = TMP_DIR / fname
-    p.write_bytes(audio_bytes)
-    return fname
-
-# ----------------- STT (audio bytes -> text) -----------------
-def hf_stt_from_bytes(audio_bytes: bytes, model: Optional[str] = None) -> str:
-    model = model or HF_STT_MODEL
-    r = hf_post_bytes(model, audio_bytes, content_type="application/octet-stream", timeout=180)
-    # often returns {"text": "..."}
+def hf_stt_from_bytes(audio_bytes: bytes):
+    # call HF STT model (whisper) with raw audio bytes
+    r = hf_post_bytes(HF_STT_MODEL, audio_bytes, content_type="application/octet-stream", timeout=180)
     try:
         j = r.json()
         if isinstance(j, dict) and "text" in j:
             return j["text"]
-        if isinstance(j, list) and len(j) and isinstance(j[0], dict) and "text" in j[0]:
-            return j[0]["text"]
         return str(j)
     except Exception:
         return r.text if hasattr(r, "text") else ""
 
-# ----------------- Endpoints for ESP32 / Web -----------------
+# ---------- Telegram ----------
+def send_telegram_message(text: str):
+    if not TELEGRAM_TOKEN or not TELEGRAM_CHATID:
+        return False
+    try:
+        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+        r = requests.post(url, json={"chat_id": TELEGRAM_CHATID, "text": text}, timeout=10)
+        return r.ok
+    except Exception as e:
+        logger.exception("Telegram send failed")
+        return False
+
+# ---------- Routes ----------
 @app.route("/health", methods=["GET"])
 def health():
-    return jsonify({
-        "ok": True,
-        "hf_api_token": bool(HF_API_TOKEN),
-        "hf_model": HF_MODEL,
-        "hf_tts_model": HF_TTS_MODEL,
-        "hf_stt_model": HF_STT_MODEL,
-        "telegram": bool(TELEGRAM_TOKEN and TELEGRAM_CHATID),
-        "tmp_dir": str(TMP_DIR),
-    })
+    return {"ok": True, "hf": bool(HF_API_TOKEN), "tts_model": HF_TTS_MODEL, "stt_model": HF_STT_MODEL}
 
 @app.route("/ask", methods=["POST"])
 def route_ask():
-    """
-    POST JSON: { "text": "...", "lang": "vi"|"en"|"auto" (optional) }
-    Returns: { "answer": "..." }
-    """
+    data = request.get_json(force=True, silent=True) or {}
+    text = (data.get("text") or "").strip()
+    if not text:
+        return jsonify({"error":"no text"}), 400
+    prompt = f"You are KC Robot AI, bilingual assistant (Vietnamese/English). Answer concisely in the same language as the user.\n\nUser: {text}\nAssistant:"
     try:
-        data = request.get_json(force=True) or {}
-        text = (data.get("text") or "").strip()
-        lang = (data.get("lang") or "auto").lower()
-        if not text:
-            return jsonify({"error": "no text"}), 400
-
-        # build bilingual instruction
-        if lang == "vi":
-            prompt = f"Bạn là trợ lý thông minh, trả lời bằng tiếng Việt, ngắn gọn và lịch sự:\n\n{text}"
-        elif lang == "en":
-            prompt = f"You are a helpful assistant. Answer in clear English, concise:\n\n{text}"
-        else:
-            prompt = f"Bạn là trợ lý thông minh song ngữ (Vietnamese/English). Trả lời bằng ngôn ngữ phù hợp với câu hỏi:\n\n{text}"
-
-        answer = hf_text_generate(prompt)
-        # store conversation and display preview
-        CONV.append((text, answer))
-        push_display("YOU: " + (text[:40]))
-        push_display("BOT: " + (answer[:40]))
-        return jsonify({"answer": answer})
+        ans = hf_text_generate(prompt)
     except Exception as e:
-        logger.exception("route_ask failed")
-        return jsonify({"error": str(e)}), 500
+        logger.exception("hf_text_generate failed")
+        ans = f"[HF error] {e}"
+    CONV.append((text, ans))
+    push_display("YOU: " + text[:80])
+    push_display("BOT: " + ans[:80])
+    return jsonify({"answer": ans})
 
 @app.route("/tts", methods=["POST"])
 def route_tts():
-    """
-    POST JSON: { "text":"..." }
-    Returns: audio bytes (audio/mpeg) - HF TTS output (mp3/wav)
-    """
+    data = request.get_json(force=True, silent=True) or {}
+    text = (data.get("text") or "").strip()
+    if not text:
+        return jsonify({"error":"no text"}), 400
     try:
-        data = request.get_json(force=True) or {}
-        text = (data.get("text") or "").strip()
-        if not text:
-            return jsonify({"error": "no text"}), 400
-        audio_bytes = hf_tts_get_audio_bytes(text)
-        # Try to detect extension: if content-type present? HF sometimes returns mp3 bytes.
-        # We'll send as audio/mpeg (mp3) which is widely supported by ESP32 players.
-        return send_file(io.BytesIO(audio_bytes), mimetype="audio/mpeg", as_attachment=False, download_name="tts.mp3")
+        audio = hf_tts_bytes(text)
     except Exception as e:
-        logger.exception("route_tts failed")
+        logger.exception("hf_tts failed")
         return jsonify({"error": str(e)}), 500
+    return send_file(io.BytesIO(audio), mimetype="audio/mpeg", as_attachment=False, download_name="tts.mp3")
 
 @app.route("/stt", methods=["POST"])
 def route_stt():
     """
-    Accepts multipart 'file' or raw audio bytes in body.
-    Returns JSON: { "text": "recognized text" }
+    Accepts multipart 'file' (browser upload) or raw body bytes (fetch).
+    Returns JSON {text: "..."}
     """
     try:
+        audio_bytes = None
         if "file" in request.files:
             f = request.files["file"]
             audio_bytes = f.read()
         else:
             audio_bytes = request.get_data() or b""
         if not audio_bytes:
-            return jsonify({"error": "no audio"}), 400
-        text = hf_stt_from_bytes(audio_bytes)
-        push_display("UserAudio: " + (text[:40]))
-        return jsonify({"text": text})
+            return jsonify({"error":"no audio"}), 400
+        txt = hf_stt_from_bytes(audio_bytes)
+        push_display("STT: " + (txt[:80] if isinstance(txt, str) else str(txt)))
+        return jsonify({"text": txt})
     except Exception as e:
-        logger.exception("route_stt failed")
+        logger.exception("stt failed")
         return jsonify({"error": str(e)}), 500
 
 @app.route("/presence", methods=["POST"])
 def route_presence():
-    """
-    ESP32 radar posts: JSON {"note": "..." }
-    Server responds with greeting, and optionally sends Telegram alert.
-    """
-    try:
-        data = request.get_json(force=True) or {}
-        note = data.get("note", "Có người tới")
-        greeting = f"Xin chào! {note}"
-        CONV.append(("__presence__", greeting))
-        push_display("RADAR: " + note[:40])
-        # Telegram notify
-        if TELEGRAM_TOKEN and TELEGRAM_CHATID:
-            try:
-                send_telegram_message(f"⚠️ Robot: Phát hiện: {note}")
-            except Exception:
-                logger.exception("Telegram notify failed")
-        return jsonify({"greeting": greeting})
-    except Exception as e:
-        logger.exception("route_presence failed")
-        return jsonify({"error": str(e)}), 500
+    data = request.get_json(force=True, silent=True) or {}
+    note = (data.get("note") or "Có người tới").strip()
+    greeting_vi = f"Xin chào! {note}"
+    greeting_en = "Hello! Someone is near the robot."
+    combined = f"{greeting_vi}\n{greeting_en}"
+    CONV.append(("__presence__", combined))
+    push_display("RADAR: " + note[:80])
+    # generate greeting audios asynchronously so UI/ESP32 can call /tts if needed
+    def gen():
+        try:
+            _ = hf_tts_bytes(greeting_vi)  # cached on HF side; we don't store here
+        except Exception:
+            logger.exception("generate greeting vi failed")
+        try:
+            _ = hf_tts_bytes(greeting_en)
+        except Exception:
+            logger.exception("generate greeting en failed")
+    threading.Thread(target=gen, daemon=True).start()
+    if TELEGRAM_TOKEN and TELEGRAM_CHATID:
+        send_telegram_message("⚠️ Robot: Phát hiện người - " + note)
+    return jsonify({"greeting": combined})
 
 @app.route("/display", methods=["GET"])
 def route_display():
-    return jsonify({"lines": DISPLAY_LINES[-6:], "conv_len": len(CONV)})
+    return jsonify({"lines": DISPLAY_LINES[-8:], "conv_len": len(CONV)})
 
-# Serve tts files by filename if needed
-@app.route("/tts_file/<path:fname>", methods=["GET"])
-def serve_tts_file(fname):
-    p = TMP_DIR / fname
-    if not p.exists():
-        return abort(404)
-    # guess mime
-    mime = "audio/mpeg" if str(fname).lower().endswith(".mp3") else "audio/wav"
-    return send_file(str(p), mimetype=mime)
-
-# ----------------- Simple Web UI for testing -----------------
+# ---------- Web UI (enhanced: record mic, STT, ask, TTS playback) ----------
 INDEX_HTML = """
 <!doctype html>
-<html>
+<html lang="vi">
 <head>
-  <meta charset="utf-8">
-  <title>KC Robot AI V4.1</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style>
-    body{font-family:Arial,Helvetica, sans-serif; margin:12px; color:#111}
-    textarea{width:100%; height:90px; padding:8px; font-size:16px}
-    #chat{border:1px solid #ddd; padding:8px; height:260px; overflow:auto; background:#fbfbfb}
-    button{padding:8px 12px; margin-top:8px; font-size:15px}
-  </style>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1"/>
+<title>KC Robot AI V4.4</title>
+<style>
+  body{font-family:Arial,Helvetica,sans-serif;background:#0f1720;color:#e6eef6;margin:0;padding:12px}
+  .wrap{max-width:980px;margin:auto}
+  header{display:flex;align-items:center;gap:12px}
+  h1{margin:0;font-size:20px;color:#7ee787}
+  #chat{background:#0b1220;border-radius:8px;padding:10px;height:420px;overflow:auto;border:1px solid #223344}
+  .msg{margin:6px 0;padding:8px;border-radius:8px;display:inline-block}
+  .user{background:#163a9b22;color:#cfe7ff;float:right;clear:both}
+  .bot{background:#1b6b2b22;color:#dfffdc;float:left;clear:both}
+  .controls{margin-top:10px;display:flex;gap:8px;align-items:center}
+  button{background:#0ea5a4;border:none;padding:10px 12px;border-radius:8px;color:#fff;cursor:pointer}
+  button.secondary{background:#334155}
+  input[type=text]{flex:1;padding:10px;border-radius:8px;border:1px solid #334155;background:#021427;color:#e6eef6}
+  audio{width:100%;margin-top:8px}
+  .small{font-size:12px;color:#99a0b0}
+</style>
 </head>
 <body>
-  <h2>KC Robot AI V4.1 — Cloud Brain (FPT female)</h2>
+<div class="wrap">
+  <header><h1>🤖 KC Robot AI V4.4 — Web STT (mic) + TTS</h1></header>
   <div id="chat"></div>
-  <textarea id="txt" placeholder="Nhập tiếng Việt hoặc English..."></textarea><br>
-  <button onclick="ask()">Gửi (Ask)</button>
-  <button onclick="playLast()">Phát TTS</button>
-  <hr/>
-  <input type="file" id="afile" accept="audio/*"><button onclick="uploadAudio()">Upload audio → STT</button>
-  <hr/>
-  <div id="log"></div>
-  <script>
-    window._lastAnswer = "";
-    async function ask(){
-      let t = document.getElementById('txt').value;
-      if(!t) return;
-      appendUser(t);
-      let res = await fetch('/ask', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({text:t})});
-      let j = await res.json();
-      if(j.answer){ appendBot(j.answer); window._lastAnswer = j.answer; }
-      else appendBot('[Error] ' + JSON.stringify(j));
-    }
-    function appendUser(t){ document.getElementById('chat').innerHTML += '<div style="color:#006"><b>You:</b> '+escapeHtml(t)+'</div>'; scroll();}
-    function appendBot(t){ document.getElementById('chat').innerHTML += '<div style="color:#080"><b>Robot:</b> '+escapeHtml(t)+'</div>'; scroll();}
-    function escapeHtml(s){ return (s+'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
-    function scroll(){ let c = document.getElementById('chat'); c.scrollTop = c.scrollHeight; }
-    async function playLast(){
-      const txt = window._lastAnswer || document.getElementById('txt').value;
-      if(!txt) return alert('Chưa có câu trả lời');
-      let r = await fetch('/tts',{method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({text: txt})});
-      if(!r.ok) return alert('TTS lỗi');
-      const b = await r.blob();
-      const url = URL.createObjectURL(b);
-      const a = new Audio(url);
-      a.play();
-    }
-    async function uploadAudio(){
-      const f = document.getElementById('afile').files[0];
-      if(!f) return alert('Chọn file audio');
-      const fd = new FormData(); fd.append('file', f);
-      const r = await fetch('/stt', {method:'POST', body: fd});
+  <div class="controls">
+    <input id="txt" type="text" placeholder="Gõ câu hỏi (VN/EN) hoặc bấm Ghi để nói..." />
+    <button id="sendBtn">Gửi</button>
+    <button id="recBtn">🎙 Ghi</button>
+    <button id="playGreeting" class="secondary">▶ Chào (TTS)</button>
+  </div>
+  <audio id="player" controls></audio>
+  <p class="small">Lưu ý: cần đặt HF_API_TOKEN trong Secrets để STT/TTS/LLM hoạt động.</p>
+</div>
+
+<script>
+let mediaRecorder, audioChunks=[];
+const chat = document.getElementById('chat');
+const player = document.getElementById('player');
+
+function appendUser(t){ chat.innerHTML += `<div class="msg user">${escapeHtml(t)}</div>`; chat.scrollTop = chat.scrollHeight; }
+function appendBot(t){ chat.innerHTML += `<div class="msg bot">${escapeHtml(t)}</div>`; chat.scrollTop = chat.scrollHeight; }
+function escapeHtml(s){ return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+
+document.getElementById('sendBtn').onclick = async ()=>{
+  const v = document.getElementById('txt').value.trim();
+  if(!v) return;
+  appendUser(v); document.getElementById('txt').value='';
+  const res = await fetch('/ask',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text:v})});
+  const j = await res.json(); const ans = j.answer || j.error || 'No answer';
+  appendBot(ans);
+  // request TTS for the answer and play
+  const tts = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text: ans})});
+  if(tts.ok){ const blob = await tts.blob(); const url = URL.createObjectURL(blob); player.src = url; player.play(); }
+};
+
+document.getElementById('recBtn').onclick = async ()=>{
+  if(mediaRecorder && mediaRecorder.state === 'recording'){
+    mediaRecorder.stop();
+    return;
+  }
+  // start recording
+  if(!navigator.mediaDevices) return alert('Trình duyệt không hỗ trợ microphone.');
+  try{
+    const stream = await navigator.mediaDevices.getUserMedia({audio:true});
+    mediaRecorder = new MediaRecorder(stream);
+    audioChunks = [];
+    mediaRecorder.ondataavailable = e => audioChunks.push(e.data);
+    mediaRecorder.onstop = async () => {
+      const blob = new Blob(audioChunks, {type:'audio/webm'});
+      // send blob to /stt (multipart)
+      const fd = new FormData(); fd.append('file', blob, 'rec.webm');
+      const r = await fetch('/stt',{method:'POST', body: fd});
       const j = await r.json();
-      if(j.text) appendUser('[voice] '+j.text);
-      else appendUser('[stt error] '+JSON.stringify(j));
-    }
-  </script>
+      if(j.text){
+        appendUser('[voice] ' + j.text);
+        // auto ask with transcribed text
+        const res = await fetch('/ask',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text: j.text})});
+        const ansj = await res.json(); const ans = ansj.answer || ansj.error || 'No answer';
+        appendBot(ans);
+        // play TTS
+        const tts = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text: ans})});
+        if(tts.ok){ const blob2 = await tts.blob(); const url = URL.createObjectURL(blob2); player.src = url; player.play(); }
+      } else {
+        appendBot('[STT lỗi] ' + JSON.stringify(j));
+      }
+    };
+    mediaRecorder.start();
+    document.getElementById('recBtn').textContent = '■ Dừng';
+  }catch(err){
+    alert('Không thể truy cập microphone: ' + err);
+  }
+};
+
+document.getElementById('playGreeting').onclick = async ()=>{
+  // call /presence with sample note to generate TTS greeting and get combined text
+  const r = await fetch('/presence',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({note: 'Xin chào chủ nhân'})});
+  const j = await r.json();
+  const txt = j.greeting || '';
+  if(!txt) return;
+  // play TTS of full greeting via /tts
+  const t = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text: txt})});
+  if(t.ok){ const b = await t.blob(); const url = URL.createObjectURL(b); player.src = url; player.play(); }
+};
+</script>
 </body>
 </html>
 """
+
 @app.route("/", methods=["GET"])
 def index():
     return render_template_string(INDEX_HTML)
 
-# ----------------- Telegram helpers & poller -----------------
-def send_telegram_message(text: str) -> bool:
-    if not TELEGRAM_TOKEN or not TELEGRAM_CHATID:
-        logger.debug("Telegram not configured")
-        return False
-    try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
-        r = requests.post(url, json={"chat_id": TELEGRAM_CHATID, "text": text}, timeout=10)
-        if not r.ok:
-            logger.warning("Telegram send failed: %s %s", r.status_code, r.text)
-            return False
-        return True
-    except Exception:
-        logger.exception("send_telegram_message exception")
-        return False
-
-def telegram_poll_loop():
-    """Long-polling loop to fetch updates and respond to simple commands."""
-    if not TELEGRAM_TOKEN:
-        logger.info("telegram_poll_loop: TELEGRAM_TOKEN not set, exiting poller.")
-        return
-    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
-    offset = None
-    logger.info("telegram_poll_loop: starting.")
-    while True:
+# ---------- Startup greeting ----------
+def startup_actions():
+    logger.info("KC Robot AI V4.4 starting up — generating greeting (async).")
+    def gen():
         try:
-            params = {"timeout": 30}
-            if offset:
-                params["offset"] = offset
-            r = requests.get(base + "/getUpdates", params=params, timeout=35)
-            if not r.ok:
-                logger.warning("telegram getUpdates failed: %s", r.status_code)
-                time.sleep(2)
-                continue
-            j = r.json()
-            for upd in j.get("result", []):
-                offset = upd["update_id"] + 1
-                msg = upd.get("message") or {}
-                chat = msg.get("chat", {})
-                chat_id = chat.get("id")
-                text = (msg.get("text") or "").strip()
-                if not text:
-                    continue
-                logger.info("TG msg %s: %s", chat_id, text)
-                lower = text.lower()
-                if lower.startswith("/ask "):
-                    q = text[5:].strip()
-                    try:
-                        ans = hf_text_generate(q)
-                    except Exception as e:
-                        ans = f"[HF error] {e}"
-                    try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": ans}, timeout=10)
-                    except Exception:
-                        logger.exception("tg reply failed")
-                elif lower.startswith("/say "):
-                    tts_text = text[5:].strip()
-                    try:
-                        audio = hf_tts_get_audio_bytes(tts_text)
-                        files = {"audio": ("reply.mp3", audio, "audio/mpeg")}
-                        requests.post(base + "/sendAudio", files=files, data={"chat_id": chat_id}, timeout=30)
-                    except Exception:
-                        logger.exception("tg say failed")
-                elif lower.startswith("/status"):
-                    try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "KC Robot AI is running."}, timeout=10)
-                    except Exception:
-                        pass
-                else:
-                    try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "Commands: /ask <q> | /say <text> | /status"}, timeout=10)
-                    except Exception:
-                        pass
+            # try to generate greeting to warm model cache (non-blocking)
+            _ = hf_tts_bytes("Xin chào chủ nhân! Em là KC Robot và đã sẵn sàng!") if HF_API_TOKEN else None
         except Exception:
-            logger.exception("telegram_poll_loop exception, sleeping 3s")
-            time.sleep(3)
-
-def start_background_tasks():
-    # start telegram poller thread (if token provided)
-    if TELEGRAM_TOKEN:
-        t = threading.Thread(target=telegram_poll_loop, daemon=True)
-        t.start()
-        logger.info("Started Telegram poller thread.")
-    else:
-        logger.info("Telegram token not provided; poller disabled.")
+            logger.exception("warmup tts failed")
+    threading.Thread(target=gen, daemon=True).start()
 
 @app.before_first_request
-def _startup():
-    start_background_tasks()
+def _before_first():
+    startup_actions()
 
-# ----------------- Run -----------------
+# ---------- Run ----------
 if __name__ == "__main__":
-    logger.info("Starting KC Robot AI V4.1 (FPT female TTS).")
-    start_background_tasks()
     app.run(host="0.0.0.0", port=PORT)