Update

app.py

@@ -1,152 +1,105 @@
 
-# app.py — KC Robot AI v5.5 FINAL
-# Flask server for Hugging Face Space
-# - Requirements: see requirements.txt
-# - Secrets expected: HF_API_TOKEN (required), optional: HF_MODEL, HF_TTS_MODEL, HF_STT_MODEL, TELEGRAM_TOKEN, TELEGRAM_CHATID
+# app.py — KC Robot AI V5.2 (Full)
+# Flask server + Hugging Face inference (LLM/STT/TTS) + Telegram poller + web UI (browser mic)
+# Secrets expected in HF Space Settings:
+#   HF_API_TOKEN  (required)
+#   TELEGRAM_TOKEN (optional)
+#   TELEGRAM_CHATID (optional)
+# Optional env overrides:
+#   HF_MODEL, HF_TTS_MODEL, HF_STT_MODEL, PORT
 
 import os
 import io
 import time
 import json
-import base64
 import threading
 import logging
-from typing import Optional
 from pathlib import Path
+from typing import List, Tuple, Optional
 
 import requests
-from flask import Flask, request, jsonify, render_template_string
+from flask import Flask, request, jsonify, send_file, render_template_string
 
-# Fallback TTS
-from gtts import gTTS
-
-# Logging
+# ---------- config & logging ----------
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("kcrobot.v5.5.final")
+logger = logging.getLogger("kcrobot.v5.2")
 
 app = Flask(__name__)
 
-# Config / Secrets (set in Space -> Settings -> Secrets)
+TMP_DIR = Path("/tmp/kcrobot")
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+
+# Environment / Secrets (set in Space -> Settings -> Secrets)
 HF_API_TOKEN = os.getenv("HF_API_TOKEN", "").strip()
-HF_MODEL = os.getenv("HF_MODEL", "bkai-foundation-models/vietnamese-llama2-7b").strip()
-HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "doanthang/vietTTS-southern-female").strip()  # optional public HF TTS
-HF_STT_MODEL = os.getenv("HF_STT_MODEL", "openai/whisper-small").strip()               # optional
+HF_MODEL = os.getenv("HF_MODEL", "google/flan-t5-large").strip()
+HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "doanthang/vietTTS-southern-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()
 
-HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
-
-# Temp storage for history
-TMP_DIR = Path("/tmp/kcrobot")
-TMP_DIR.mkdir(parents=True, exist_ok=True)
-HISTORY_FILE = TMP_DIR / "history.json"
-
-def read_history():
-    try:
-        if HISTORY_FILE.exists():
-            with open(HISTORY_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-    except Exception:
-        logger.exception("read_history")
-    return []
+PORT = int(os.getenv("PORT", 7860))
 
-def append_history(user_text, bot_text):
-    rec = {"user": user_text, "bot": bot_text, "ts": time.time()}
-    data = read_history()
-    data.append(rec)
-    try:
-        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-    except Exception:
-        logger.exception("append_history")
+if not HF_API_TOKEN:
+    logger.warning("⚠️ HF_API_TOKEN not set — put your Hugging Face token into Space Secrets (HF_API_TOKEN).")
 
-def clear_history():
-    try:
-        if HISTORY_FILE.exists():
-            HISTORY_FILE.unlink()
-    except Exception:
-        logger.exception("clear_history")
+HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
 
-# Language detection heuristic (Vietnamese characters)
-VI_CHARS = set("ăâđêôơưáàảãạắằẳẵặấầẩẫậéèẻẽẹíìỉĩịóòỏõọúùủũụýỳỷỹỵ")
+# ---------- in-memory state ----------
+CONV: List[Tuple[str, str]] = []     # (user, bot)
+DISPLAY_LINES: List[str] = []        # lines for small OLED displays
 
-def detect_lang(text: str) -> str:
-    if not text:
-        return "en"
-    for ch in text.lower():
-        if ch in VI_CHARS:
-            return "vi"
-    return "en"
+def push_display(line: str, limit: int = 8):
+    DISPLAY_LINES.append(line)
+    if len(DISPLAY_LINES) > limit:
+        del DISPLAY_LINES[0: len(DISPLAY_LINES)-limit]
 
-# ---------------- Hugging Face helpers ----------------
+# ---------- Hugging Face helpers ----------
 def hf_post_json(model_id: str, payload: dict, timeout: int = 120):
     if not HF_API_TOKEN:
-        raise RuntimeError("HF_API_TOKEN not set in Space Secrets.")
+        raise RuntimeError("HF_API_TOKEN missing (set in Space Secrets).")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
-    headers = {**HF_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.warning("HF json POST %s returned %s: %s", model_id, r.status_code, r.text[:300])
+        logger.error("HF JSON POST error %s: %s", r.status_code, r.text[:400])
         r.raise_for_status()
     try:
         return r.json()
     except Exception:
         return r.content
 
-def hf_post_bytes(model_id: str, bytes_data: bytes, content_type: str = "application/octet-stream", timeout: int = 180):
+def hf_post_bytes(model_id: str, data: bytes, content_type: str = "application/octet-stream", timeout: int = 180):
     if not HF_API_TOKEN:
-        raise RuntimeError("HF_API_TOKEN not set in Space Secrets.")
+        raise RuntimeError("HF_API_TOKEN missing (set in Space Secrets).")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
     headers = dict(HF_HEADERS)
     headers["Content-Type"] = content_type
-    r = requests.post(url, headers=headers, data=bytes_data, timeout=timeout)
+    r = requests.post(url, headers=headers, data=data, timeout=timeout)
     if not r.ok:
-        logger.warning("HF bytes POST %s returned %s: %s", model_id, r.status_code, r.text[:300])
+        logger.error("HF BYTES POST error %s: %s", r.status_code, r.text[:400])
         r.raise_for_status()
     return r
 
 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}
-    }
+    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)
-    # parse common shapes
-    try:
-        if isinstance(out, list) and len(out) and isinstance(out[0], dict):
-            return out[0].get("generated_text") or out[0].get("text") or str(out[0])
-        if isinstance(out, dict):
-            if "generated_text" in out:
-                return out.get("generated_text")
-            if "text" in out:
-                return out.get("text")
-            # some models return choices...
-            if "choices" in out and isinstance(out["choices"], list) and out["choices"]:
-                c = out["choices"][0]
-                return c.get("text") or c.get("message", {}).get("content", "") or str(c)
-        return str(out)
-    except Exception:
-        logger.exception("hf_text_generate parse")
-        return str(out)
-
-def hf_tts_bytes(text: str, model: Optional[str] = None) -> Optional[bytes]:
+    # parse typical shapes
+    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):
+        return out.get("generated_text") or out.get("text") or str(out)
+    return str(out)
+
+def hf_tts_bytes(text: str, model: Optional[str] = None) -> bytes:
     model = model or HF_TTS_MODEL
-    if not model:
-        return None
-    try:
-        payload = {"inputs": text}
-        url = f"https://api-inference.huggingface.co/models/{model}"
-        r = requests.post(url, headers={**HF_HEADERS, "Content-Type": "application/json"}, json=payload, timeout=120)
-        if r.ok:
-            return r.content
-        else:
-            logger.warning("hf_tts_bytes returned %s: %s", r.status_code, r.text[:200])
-            return None
-    except Exception:
-        logger.exception("hf_tts_bytes")
-        return None
+    payload = {"inputs": text}
+    url = f"https://api-inference.huggingface.co/models/{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 hf_stt_from_bytes(audio_bytes: bytes, model: Optional[str] = None) -> str:
     model = model or HF_STT_MODEL
@@ -155,41 +108,18 @@ def hf_stt_from_bytes(audio_bytes: bytes, model: Optional[str] = None) -> str:
         j = r.json()
         if isinstance(j, dict) and "text" in j:
             return j["text"]
+        # external shapes
         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:
+        # r may be raw string
         return r.text if hasattr(r, "text") else ""
 
-# ---------------- TTS fallback using gTTS ----------------
-def tts_gtts_base64(text: str, lang: str = "vi") -> str:
-    try:
-        tts = gTTS(text=text, lang=lang)
-        bio = io.BytesIO()
-        tts.write_to_fp(bio)
-        bio.seek(0)
-        return base64.b64encode(bio.read()).decode("ascii")
-    except Exception:
-        logger.exception("tts_gtts_base64 failed")
-        return ""
-
-def tts_get_audio_for_text(text: str, detected_lang: str = "vi"):
-    # 1. try HF TTS model if configured
-    audio_bytes = None
-    if HF_TTS_MODEL:
-        audio_bytes = hf_tts_bytes(text, HF_TTS_MODEL)
-        if audio_bytes:
-            return {"audio_base64": base64.b64encode(audio_bytes).decode("ascii"), "mime": "audio/mpeg"}
-    # 2. fallback to gTTS for vi/en
-    lang = "vi" if detected_lang == "vi" else "en"
-    b64 = tts_gtts_base64(text, lang=lang)
-    if b64:
-        return {"audio_base64": b64, "mime": "audio/mpeg"}
-    return {"audio_base64": "", "mime": ""}
-
-# ---------------- Telegram ----------------
+# ---------- Telegram helpers ----------
 def send_telegram_message(text: str):
-    if not (TELEGRAM_TOKEN and TELEGRAM_CHATID):
+    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"
@@ -198,16 +128,31 @@ def send_telegram_message(text: str):
             logger.warning("Telegram send failed: %s %s", r.status_code, r.text[:200])
         return r.ok
     except Exception:
-        logger.exception("send_telegram_message")
+        logger.exception("send_telegram_message failed")
+        return False
+
+def telegram_send_audio(chat_id: str, audio_bytes: bytes, filename: str = "reply.mp3"):
+    if not TELEGRAM_TOKEN:
+        return False
+    try:
+        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendAudio"
+        files = {"audio": (filename, audio_bytes, "audio/mpeg")}
+        data = {"chat_id": chat_id}
+        r = requests.post(url, files=files, data=data, timeout=30)
+        if not r.ok:
+            logger.warning("Telegram sendAudio failed: %s %s", r.status_code, r.text[:200])
+        return r.ok
+    except Exception:
+        logger.exception("telegram_send_audio failed")
         return False
 
 def telegram_poll_loop():
     if not TELEGRAM_TOKEN:
-        logger.info("telegram poll disabled")
+        logger.info("Telegram poller disabled (no TELEGRAM_TOKEN).")
         return
     base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
     offset = None
-    logger.info("Starting telegram poller")
+    logger.info("Telegram poller started.")
     while True:
         try:
             params = {"timeout": 30}
@@ -234,16 +179,15 @@ def telegram_poll_loop():
                     try:
                         requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": ans}, timeout=10)
                     except Exception:
-                        logger.exception("telegram reply failed")
+                        logger.exception("tg reply failed")
                 elif low.startswith("/say "):
                     phrase = text[5:].strip()
-                    # TTS and send audio
+                    # try TTS then send audio
                     try:
-                        audio = hf_tts_bytes(phrase) or base64.b64decode(tts_gtts_base64(phrase, lang="vi" if detect_lang(phrase)=="vi" else "en"))
-                        files = {"audio": ("say.mp3", audio, "audio/mpeg")}
-                        requests.post(base + "/sendAudio", files=files, data={"chat_id": chat_id}, timeout=30)
+                        audio = hf_tts_bytes(phrase)
+                        telegram_send_audio(chat_id, audio, filename="say.mp3")
                     except Exception:
-                        logger.exception("telegram say failed")
+                        logger.exception("tg say failed")
                 elif low.startswith("/status"):
                     try:
                         requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "KC Robot brain running."}, timeout=10)
@@ -255,231 +199,257 @@ def telegram_poll_loop():
                     except Exception:
                         pass
         except Exception:
-            logger.exception("telegram poll loop error")
+            logger.exception("telegram_poll_loop crashed, sleeping 3s")
             time.sleep(3)
 
-# start telegram poller thread
+# start telegram poller thread if token exists
 if TELEGRAM_TOKEN:
     try:
         t = threading.Thread(target=telegram_poll_loop, daemon=True)
         t.start()
     except Exception:
-        logger.exception("start telegram thread failed")
-
-# ---------------- Web UI HTML ----------------
-INDEX_HTML = """
-<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<title>KC Robot AI v5.5 Final</title>
-<style>
-body{font-family:Arial;background:#06111a;color:#dff; padding:12px}
-.container{max-width:980px;margin:auto}
-#chat{background:#04101a;padding:10px;border-radius:8px;height:420px;overflow:auto;border:1px solid #223344}
-.user{color:#bfe7ff;text-align:right;margin:6px}
-.bot{color:#dfffdc;text-align:left;margin:6px}
-.controls{display:flex;gap:8px;margin-top:8px}
-input[type=text]{flex:1;padding:10px;border-radius:8px;border:1px solid #223344;background:#021427;color:#e6eef6}
-button{padding:10px 12px;border-radius:8px;border:none;background:#0ea5a4;color:#fff;cursor:pointer}
-small{color:#99a0b0}
-</style></head><body>
-<div class="container">
-<h2>🤖 KC Robot AI v5.5 — Final (Miền Nam voice, song ngữ)</h2>
-<div id="chat"></div>
-<div class="controls">
-<input id="txt" placeholder="Gõ câu hỏi (VN/EN) hoặc bấm Ghi..." type="text"/>
-<button id="sendBtn">Gửi</button>
-<button id="recBtn">🎙 Ghi</button>
-<button id="greetBtn">▶ Chào</button>
-<button id="historyBtn">🗂 Lịch sử</button>
-</div>
-<audio id="player" controls style="width:100%;margin-top:10px"></audio>
-<p><small>Secrets: HF_API_TOKEN (required). Optionals: HF_MODEL, HF_TTS_MODEL, TELEGRAM_TOKEN, TELEGRAM_CHATID</small></p>
-</div>
+        logger.exception("Failed to start telegram poller thread")
+
+# ---------- Routes (ESP32 & web) ----------
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({
+        "ok": True,
+        "hf_token": bool(HF_API_TOKEN),
+        "hf_model": HF_MODEL,
+        "tts_model": HF_TTS_MODEL,
+        "stt_model": HF_STT_MODEL,
+        "telegram": bool(TELEGRAM_TOKEN)
+    })
+
+@app.route("/ask", methods=["POST"])
+def route_ask():
+    data = request.get_json(force=True, silent=True) or {}
+    text = (data.get("text") or "").strip()
+    lang = (data.get("lang") or "auto").strip().lower()
+    if not text:
+        return jsonify({"error": "no text"}), 400
+    # make instructive prompt
+    if lang == "vi":
+        prompt = "Bạn là trợ lý thông minh, trả lời bằng tiếng Việt, rõ ràng và ngắn gọn:\n\n" + text
+    elif lang == "en":
+        prompt = "You are a helpful assistant. Answer in clear English:\n\n" + text
+    else:
+        prompt = "You are a bilingual assistant (Vietnamese/English). Answer in the language of the user.\n\n" + text
+    try:
+        ans = hf_text_generate(prompt)
+    except Exception as e:
+        logger.exception("hf_text_generate failed")
+        return jsonify({"error": str(e)}), 500
+    CONV.append((text, ans))
+    push_display("YOU: " + text[:80])
+    push_display("BOT: " + ans[:80])
+    # optionally notify telegram summary
+    if TELEGRAM_TOKEN and TELEGRAM_CHATID:
+        try:
+            send_telegram_message(f"You: {text}\nBot: {ans}")
+        except Exception:
+            logger.exception("telegram notify failed")
+    return jsonify({"answer": ans})
+
+@app.route("/tts", methods=["POST"])
+def route_tts():
+    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:
+        audio = hf_tts_bytes(text)
+    except Exception as e:
+        logger.exception("hf_tts failed")
+        return jsonify({"error": str(e)}), 500
+    # return audio bytes as audio/mpeg (most outputs are mp3 or wav; we choose audio/mpeg)
+    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 form 'file' or raw bytes
+    try:
+        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
+        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")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/presence", methods=["POST"])
+def route_presence():
+    data = request.get_json(force=True, silent=True) or {}
+    note = (data.get("note") or "Có người đến gần").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 TTS asynchronously (pre-warm HF model) so ESP32 can call /tts if it wants
+    def gen_greeting():
+        try:
+            _ = hf_tts_bytes(greeting_vi)
+        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_greeting, daemon=True).start()
+    # notify telegram
+    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[-8:], "conv_len": len(CONV)})
+
+# ---------- Simple Web UI with browser STT & TTS (for testing) ----------
+INDEX_HTML = r"""
+<!doctype html>
+<html lang="vi">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <title>KC Robot AI V5.2</title>
+  <style>
+    body{font-family:Arial,Helvetica,sans-serif;background:#0f1720;color:#e6eef6;margin:12px}
+    .wrap{max-width:980px;margin:auto}
+    h1{color:#7ee787}
+    #chat{background:#08111a;border-radius:8px;padding:10px;height:420px;overflow:auto;border:1px solid #223344}
+    .user{color:#bfe7ff; text-align:right}
+    .bot{color:#dfffdc; text-align:left}
+    .controls{display:flex;gap:8px;margin-top:8px}
+    input[type=text]{flex:1;padding:10px;border-radius:8px;border:1px solid #223344;background:#021427;color:#e6eef6}
+    button{padding:10px 12px;border-radius:8px;border:none;background:#0ea5a4;color:#fff;cursor:pointer}
+    audio{width:100%;margin-top:8px}
+    .small{font-size:12px;color:#99a0b0}
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <h1>🤖 KC Robot AI V5.2 — Full</h1>
+    <div id="chat"></div>
+    <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="greetBtn">▶ Chào</button>
+    </div>
+    <audio id="player" controls></audio>
+    <p class="small">Cần HF_API_TOKEN trong Secrets để STT/TTS/LLM hoạt động.</p>
+  </div>
+
 <script>
 let mediaRecorder, audioChunks=[];
-const chat=document.getElementById('chat'), player=document.getElementById('player');
+const chat = document.getElementById('chat');
+const player = document.getElementById('player');
 
-function appendUser(t){ chat.innerHTML += '<div class="user"><b>You:</b> '+escapeHtml(t)+'</div>'; chat.scrollTop = chat.scrollHeight; }
-function appendBot(t){ chat.innerHTML += '<div class="bot"><b>Robot:</b> '+escapeHtml(t)+'</div>'; chat.scrollTop = chat.scrollHeight; }
+function appendUser(t){ chat.innerHTML += `<div class="user"><b>You:</b> ${escapeHtml(t)}</div>`; chat.scrollTop = chat.scrollHeight; }
+function appendBot(t){ chat.innerHTML += `<div class="bot"><b>Robot:</b> ${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;
+  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);
-  if(j.audio_base64){
-    const blob = base64ToBlob(j.audio_base64, j.mime || 'audio/mpeg');
-    const url = URL.createObjectURL(blob); player.src = url; player.play();
+  // play TTS of answer
+  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('greetBtn').onclick = async ()=>{
-  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();
-  appendBot(j.greeting || j.error || '');
-  if(j.audio_base64){ const blob = base64ToBlob(j.audio_base64, j.mime||'audio/mpeg'); player.src = URL.createObjectURL(blob); player.play(); }
-  else if(j.music_url){ player.src = j.music_url; player.play(); }
-};
-
-document.getElementById('historyBtn').onclick = async ()=>{
-  const r = await fetch('/history'); const j = await r.json(); chat.innerHTML=''; j.forEach(it=>{ appendUser(it.user); appendBot(it.bot); });
-};
-
 document.getElementById('recBtn').onclick = async ()=>{
   if(mediaRecorder && mediaRecorder.state === 'recording'){ mediaRecorder.stop(); return; }
-  if(!navigator.mediaDevices) return alert('No mic support');
+  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=[];
+    audioChunks = [];
     mediaRecorder.ondataavailable = e => audioChunks.push(e.data);
-    mediaRecorder.onstop = async ()=>{
+    mediaRecorder.onstop = async () => {
       const blob = new Blob(audioChunks, {type:'audio/webm'});
       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);
+        // auto ask
         const res = await fetch('/ask',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text: j.text})});
         const aj = await res.json(); const ans = aj.answer || aj.error || 'No answer';
         appendBot(ans);
-        if(aj.audio_base64){ const blob2 = base64ToBlob(aj.audio_base64, aj.mime||'audio/mpeg'); player.src = URL.createObjectURL(blob2); player.play();}
-      } else { appendBot('[STT error] '+JSON.stringify(j)); }
+        const tts = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text:ans})});
+        if(tts.ok){ const b = await tts.blob(); const url = URL.createObjectURL(b); player.src = url; player.play(); }
+      } else {
+        appendBot('[STT lỗi] ' + JSON.stringify(j));
+      }
     };
-    mediaRecorder.start(); document.getElementById('recBtn').textContent='■ Dừng';
-  } catch(e){ alert('Mic error: '+e); }
+    mediaRecorder.start();
+    document.getElementById('recBtn').textContent = '■ Dừng';
+  } catch(err){
+    alert('Không thể truy cập microphone: ' + err);
+  }
 };
 
-function base64ToBlob(b64, mime){ const bytes = atob(b64); let len = bytes.length; const buf = new Uint8Array(len); for(let i=0;i<len;i++) buf[i]=bytes.charCodeAt(i); return new Blob([buf], {type:mime}); }
+document.getElementById('greetBtn').onclick = async ()=>{
+  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 text = j.greeting || '';
+  appendBot(text);
+  // play tts
+  const tts = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text:text})});
+  if(tts.ok){ const b = await tts.blob(); const url = URL.createObjectURL(b); player.src = url; player.play(); }
+};
 </script>
-</body></html>
+</body>
+</html>
 """
 
-# ---------------- Endpoints ----------------
 @app.route("/", methods=["GET"])
 def index():
     return render_template_string(INDEX_HTML)
 
-@app.route("/config", methods=["GET"])
-def get_config():
-    return jsonify({
-        "hf_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)
-    })
-
-@app.route("/ask", methods=["POST"])
-def ask_route():
-    data = request.get_json(force=True, silent=True) or {}
-    text = (data.get("text") or "").strip()
-    if not text:
-        return jsonify({"error":"no text"}), 400
-    lang = detect_lang(text)
-    if lang == "vi":
-        prompt = f"Bạn là trợ lý thông minh, trả lời bằng tiếng Việt, rõ ràng và ngắn gọn:\\n\\n{text}"
-    else:
-        prompt = f"You are a helpful assistant. Answer in clear English:\\n\\n{text}"
-    try:
-        answer = hf_text_generate(prompt)
-    except Exception as e:
-        logger.exception("hf_text_generate error")
-        return jsonify({"error": str(e)}), 500
-    append_history(text, answer)
-    # prepare audio
-    tts = tts_get_audio_for_text(answer, detected_lang=lang)
-    result = {"answer": answer}
-    result.update(tts)
-    return jsonify(result)
-
-@app.route("/tts", methods=["POST"])
-def tts_route():
-    data = request.get_json(force=True, silent=True) or {}
-    text = (data.get("text") or "").strip()
-    if not text:
-        return jsonify({"error":"no text"}), 400
-    lang = detect_lang(text)
-    return jsonify(tts_get_audio_for_text(text, detected_lang=lang))
-
-@app.route("/stt", methods=["POST"])
-def stt_route():
-    try:
-        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
+# ---------- startup: warm models + greeting ----------
+def startup_actions():
+    logger.info("KC Robot AI V5.2 starting up.")
+    greeting_vi = "Xin chào chủ nhân! KC Robot đã sẵn sàng."
+    greeting_en = "Hello master! KC Robot is ready."
+    push_display("SYSTEM: Robot online")
+    # warm up: request TTS generation asynchronously (not blocking)
+    def gen():
         try:
-            txt = hf_stt_from_bytes(audio_bytes)
-        except Exception as e:
-            logger.exception("hf_stt failed")
-            return jsonify({"error": str(e)}), 500
-        return jsonify({"text": txt})
-    except Exception:
-        logger.exception("stt_route")
-        return jsonify({"error":"stt internal error"}), 500
-
-@app.route("/presence", methods=["POST"])
-def presence_route():
-    data = request.get_json(force=True, silent=True) or {}
-    note = (data.get("note") or "Có người đến gần robot").strip()
-    greeting_vi = f"Xin chào! {note}"
-    greeting_en = "Hello! Someone is near the robot."
-    combined = f"{greeting_vi}\\n{greeting_en}"
-    append_history("__presence__", combined)
-    # prepare greeting audio
-    tts = tts_get_audio_for_text(greeting_vi, detected_lang="vi")
-    # telegram notify
-    if TELEGRAM_TOKEN and TELEGRAM_CHATID:
-        try:
-            send_telegram_message("⚠️ Robot phát hiện: " + note)
+            if HF_API_TOKEN:
+                _ = hf_tts_bytes(greeting_vi)
+                _ = hf_tts_bytes(greeting_en)
         except Exception:
-            logger.exception("telegram notify failed")
-    resp = {"greeting": combined}
-    if tts.get("audio_base64"):
-        resp.update(tts)
-    else:
-        # if no TTS available, return a sample music url (client can play)
-        resp["music_url"] = os.getenv("HF_MUSIC_URL", "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3")
-    return jsonify(resp)
-
-@app.route("/history", methods=["GET"])
-def history_route():
-    return jsonify(read_history())
-
-@app.route("/clear_history", methods=["POST"])
-def clear_history_route():
-    clear_history()
-    return jsonify({"cleared": True})
-
-# startup warmup
-def warmup():
-    logger.info("Warmup: attempting lightweight calls (non-blocking)")
-    def _w():
+            logger.exception("warmup tts failed")
+    threading.Thread(target=gen, daemon=True).start()
+    # optional: notify telegram about startup
+    if TELEGRAM_TOKEN and TELEGRAM_CHATID:
         try:
-            if HF_API_TOKEN:
-                try:
-                    hf_text_generate("Xin chào. Hãy trả lời ngắn gọn: Xin chào!")
-                except Exception:
-                    pass
-                try:
-                    if HF_TTS_MODEL:
-                        hf_tts_bytes("Xin chào chủ nhân")
-                except Exception:
-                    pass
+            send_telegram_message("KC Robot brain is online.")
         except Exception:
-            logger.exception("warmup errors")
-    threading.Thread(target=_w, daemon=True).start()
+            logger.exception("telegram startup notify failed")
 
 @app.before_first_request
-def before_first():
-    warmup()
+def _before_first():
+    startup_actions()
 
+# ---------- run ----------
 if __name__ == "__main__":
-    logger.info("Starting KC Robot AI v5.5 FINAL")
-    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))
+    logger.info("Starting KC Robot AI V5.2 on port %s", PORT)
+    app.run(host="0.0.0.0", port=PORT)