initial commit

app.py

@@ -1,479 +1,444 @@
-"""
-RobotAI v9.8 — Gemini Brain + gTTS + Telegram (Hugging Face ready)
-
-Features:
-- Keep original Gemini AI logic (uses google-generativeai)
-- Web UI: auto language detect (vi/en), clean punctuation for TTS
-- Only play the newest audio on the web (stop previous audio)
-- Telegram integration (polling): replies with text and sends audio file if possible
-- Audio caching and cleanup
-"""
+# 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 re
-import time
 import logging
 import threading
-from flask import Flask, request, jsonify, render_template_string, send_file, redirect, url_for
-
-# Gemini SDK
-import google.generativeai as genai
+from typing import Optional, List, Tuple
+from pathlib import Path
 
-# gTTS for TTS (female-like voice)
-from gtts import gTTS
+import requests
+from flask import Flask, request, jsonify, send_file, render_template_string, abort
 
-# Telegram support (try modern v20, fallback v13)
-try:
-    from telegram import Bot
-    from telegram.ext import ApplicationBuilder, MessageHandler, CommandHandler, filters
-    TELEGRAM_LIB = "v20"
-except Exception:
-    try:
-        from telegram import Bot
-        from telegram.ext import Updater, MessageHandler, Filters, CommandHandler
-        TELEGRAM_LIB = "v13"
-    except Exception:
-        TELEGRAM_LIB = None
-
-# ---------------- Config ----------------
-CONFIG_FILE = "config.json"
-AUDIO_DIR = "audio_cache"
-os.makedirs(AUDIO_DIR, exist_ok=True)
+# ----------------- Config & Logging -----------------
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("kcrobot.v4")
 
 app = Flask(__name__)
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("RobotAI")
-
-DEFAULT_MODEL = "gemini-2.5-flash"
-USE_GEMINI = False
-
-# ----------------- config helpers -----------------
-def load_config():
-    cfg = {
-        "GEMINI_API_KEY": os.environ.get("GEMINI_API_KEY", ""),
-        "GEMINI_MODEL": os.environ.get("GEMINI_MODEL", DEFAULT_MODEL),
-        "TELEGRAM_TOKEN": os.environ.get("TELEGRAM_TOKEN", ""),
-        "TELEGRAM_CHAT_ID": os.environ.get("TELEGRAM_CHAT_ID", "")
-    }
-    if os.path.exists(CONFIG_FILE):
-        try:
-            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                cfg.update(data)
-        except Exception as e:
-            logger.exception("Load config error")
-    return cfg
-
-def save_config(cfg):
+
+# 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.")
+
+HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
+
+# ----------------- In-memory buffers -----------------
+CONV: List[Tuple[str, str]] = []         # list of (user, bot)
+DISPLAY_LINES: List[str] = []            # lines for OLED display
+
+def push_display(line: str, limit: int = 6):
+    """Keep last `limit` lines for display."""
+    global DISPLAY_LINES
+    DISPLAY_LINES.append(line)
+    if len(DISPLAY_LINES) > limit:
+        DISPLAY_LINES = DISPLAY_LINES[-limit:]
+
+# ----------------- Helper: Hugging Face inference -----------------
+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)
+    if not r.ok:
+        logger.error("HF POST JSON error %s: %s", r.status_code, r.text[:400])
+        r.raise_for_status()
     try:
-        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
-            json.dump(cfg, f, ensure_ascii=False, indent=2)
-        return True
+        return r.json()
     except Exception:
-        logger.exception("Save config failed")
-        return False
-
-# ----------------- Gemini init + wrapper -----------------
-def init_gemini():
-    global USE_GEMINI
-    cfg = load_config()
-    key = cfg.get("GEMINI_API_KEY") or ""
-    if not key:
-        logger.warning("Gemini API key missing.")
-        USE_GEMINI = False
-        return
+        return r.text
+
+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}"
+    headers = dict(HF_HEADERS)
+    headers["Content-Type"] = content_type
+    r = requests.post(url, headers=headers, data=data, timeout=timeout)
+    if not r.ok:
+        logger.error("HF POST bytes error %s: %s", r.status_code, r.text[:400])
+        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)
+    # 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, dict):
+        for k in ("generated_text", "text", "summary_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
+    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)
+    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": "..."}
     try:
-        genai.configure(api_key=key)
-        USE_GEMINI = True
-        logger.info("✅ Gemini connected OK.")
+        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:
-        USE_GEMINI = False
-        logger.exception("Gemini init error")
-
-init_gemini()
-
-def gemini_answer(prompt: str) -> str:
+        return r.text if hasattr(r, "text") else ""
+
+# ----------------- Endpoints for ESP32 / Web -----------------
+@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),
+    })
+
+@app.route("/ask", methods=["POST"])
+def route_ask():
     """
-    Call Gemini. Keep simple: use GenerativeModel if present (matches your v9.2).
+    POST JSON: { "text": "...", "lang": "vi"|"en"|"auto" (optional) }
+    Returns: { "answer": "..." }
     """
-    cfg = load_config()
-    model = cfg.get("GEMINI_MODEL", DEFAULT_MODEL)
     try:
-        if hasattr(genai, "GenerativeModel"):
-            try:
-                m = genai.GenerativeModel(model)
-                resp = m.generate_content(prompt)
-                if hasattr(resp, "text"):
-                    return resp.text
-                return str(resp)
-            except Exception:
-                logger.debug("GenerativeModel failed, trying responses.generate", exc_info=True)
-        # fallback: try responses.create (newer)
-        if hasattr(genai, "responses") and hasattr(genai.responses, "create"):
-            r = genai.responses.create(model=model, input=prompt)
-            if hasattr(r, "output_text"):
-                return r.output_text
-            return str(r)
-    except Exception:
-        logger.exception("Gemini call error")
-    return "⚠️ Gemini không phản hồi — kiểm tra API key / library."
-
-# ----------------- Language detection & TTS cleaning -----------------
-VIET_CHARS = "ăâđêôơưáàảãạắằẳẵặấầẩẫậéèẻẽẹíìỉĩịóòỏõọốồổỗộớờởỡợúùủũụưứừửữựýỳỷỹỵ"
-
-def detect_lang(text: str) -> str:
-    return "vi" if any(ch in VIET_CHARS for ch in text.lower()) else "en"
-
-# Clean punctuation but keep letters & numbers and basic punctuation replacement -> single spaces.
-# We must not return empty string; fallback to short phrase.
-def clean_text_for_tts(text: str) -> str:
-    if not text:
-        return "Xin chào"
-    # replace typical punctuation with space
-    cleaned = re.sub(r"[.,!?;:()\"'“”‘’\[\]{}<>\/\\\|@#\$%\^&\*\+=~`–—\-]", " ", text)
-    cleaned = re.sub(r"\s+", " ", cleaned).strip()
-    if not cleaned:
-        return "Xin chào"
-    return cleaned
-
-def speak_text(text: str, lang: str = "vi") -> str:
+        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})
+    except Exception as e:
+        logger.exception("route_ask failed")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/tts", methods=["POST"])
+def route_tts():
     """
-    Generate mp3 via gTTS, return local path or None.
+    POST JSON: { "text":"..." }
+    Returns: audio bytes (audio/mpeg) - HF TTS output (mp3/wav)
     """
     try:
-        tts_text = clean_text_for_tts(text)
-        fname = f"tts_{uuid.uuid4().hex[:8]}.mp3"
-        path = os.path.join(AUDIO_DIR, fname)
-        tts = gTTS(text=tts_text, lang=lang, slow=False)
-        tts.save(path)
-        logger.info("gTTS saved %s", path)
-        return path
-    except Exception:
-        logger.exception("TTS generation failed")
-        return None
-
-# ----------------- Audio cleanup -----------------
-def cleanup_audio_older_than(seconds: int = 3600):
-    now = time.time()
-    for f in os.listdir(AUDIO_DIR):
-        p = os.path.join(AUDIO_DIR, f)
-        try:
-            if os.path.isfile(p) and (now - os.path.getmtime(p) > seconds):
-                os.remove(p)
-                logger.info("Removed old audio: %s", p)
-        except Exception:
-            logger.exception("cleanup failed for %s", p)
-
-# ----------------- Web UI templates (client-side ensures only newest audio plays) -----------------
-INDEX_HTML = """<!doctype html><html><head>
-<meta charset="utf-8"><title>RobotAI v9.8</title>
-<style>
-body{font-family:Arial;background:#f5faff;padding:12px}
-#chat{background:#fff;border:1px solid #ddd;padding:12px;min-height:260px;border-radius:8px;overflow:auto}
-.you{color:#0b66c3;margin:6px 0}
-.bot{color:#0b8a5f;margin:6px 0}
-.button{background:#0b66c3;color:white;border:none;padding:8px 12px;border-radius:6px;cursor:pointer}
-.audio-controls{margin-top:6px}
-</style>
-</head><body>
-<h2>🤖 RobotAI v9.8 — Gemini Brain + Voice + Telegram</h2>
-<div>Gemini: <b>{{ gemini_status }}</b> | Model: <b>{{ model }}</b> | <a href="/config">Config</a></div>
-<hr>
-<textarea id="text" rows="4" style="width:100%;padding:8px;border-radius:6px;border:1px solid #ccc"></textarea><br><br>
-<button class="button" onclick="send()">Gửi</button> <button class="button" onclick="clearChat()">Xóa</button>
-<div id="chat" style="margin-top:12px"></div>
-
-<script>
-let currentAudio = null;
-
-function append(cls, txt){
-  const c = document.getElementById('chat');
-  c.innerHTML += '<div class="'+cls+'">'+txt+'</div>';
-  c.scrollTop = c.scrollHeight;
-}
-
-function stopCurrentAudio(){
-  if(currentAudio){
-    try{ currentAudio.pause(); currentAudio.currentTime = 0; }catch(e){}
-    currentAudio = null;
-  }
-}
-
-function clearChat(){
-  document.getElementById('chat').innerHTML = '';
-  stopCurrentAudio();
-}
-
-async function send(){
-  let txt = document.getElementById('text').value.trim();
-  if(!txt) return;
-  append('you', 'Bạn: ' + txt);
-  document.getElementById('text').value = '';
-
-  // stop previous audio (so we only play the newest)
-  stopCurrentAudio();
-
-  try{
-    const res = await fetch('/api/chat', {
-      method: 'POST',
-      headers: {'Content-Type':'application/json'},
-      body: JSON.stringify({text: txt})
-    });
-    const j = await res.json();
-    append('bot', '🤖: ' + (j.reply || '(no reply)'));
-    if(j.tts_url){
-      currentAudio = new Audio(j.tts_url);
-      currentAudio.autoplay = true;
-      currentAudio.controls = false;
-      // optional: show an audio control for manual replay
-      const audioEl = document.createElement('audio');
-      audioEl.src = j.tts_url;
-      audioEl.controls = true;
-      audioEl.className = 'audio-controls';
-      document.getElementById('chat').appendChild(audioEl);
-      // play newest
-      try{ currentAudio.play(); }catch(e){}
-    }
-  }catch(e){
-    append('bot', '[Lỗi mạng] ' + e);
-  }
-}
-</script>
-</body></html>
-"""
-
-CONFIG_HTML = """<!doctype html><html><head><meta charset="utf-8"><title>Config</title></head>
-<body style="font-family:Arial;padding:12px">
-<h3>⚙️ Config RobotAI</h3>
-<form method="post" action="/config">
-Gemini API Key:<br><textarea name="GEMINI_API_KEY" rows="2" cols="80">{{ GEMINI_API_KEY }}</textarea><br><br>
-Gemini Model:<br><input name="GEMINI_MODEL" value="{{ GEMINI_MODEL }}" size="50"><br><br>
-Telegram Token:<br><input name="TELEGRAM_TOKEN" value="{{ TELEGRAM_TOKEN }}" size="60"><br><br>
-Telegram Chat ID (optional):<br><input name="TELEGRAM_CHAT_ID" value="{{ TELEGRAM_CHAT_ID }}" size="30"><br><br>
-<button type="submit">Lưu</button>
-</form>
-<p><a href="/">⬅ Trở về</a></p>
-</body></html>
-"""
-
-# ----------------- Flask routes -----------------
-@app.route("/")
-def home():
-    cfg = load_config()
-    return render_template_string(INDEX_HTML,
-                                  gemini_status="✅ Kết nối" if USE_GEMINI else "❌ Chưa kết nối",
-                                  model=cfg.get("GEMINI_MODEL"))
-
-@app.route("/config", methods=["GET","POST"])
-def config_page():
-    if request.method == "POST":
-        data = {
-            "GEMINI_API_KEY": request.form.get("GEMINI_API_KEY","").strip(),
-            "GEMINI_MODEL": request.form.get("GEMINI_MODEL", DEFAULT_MODEL).strip(),
-            "TELEGRAM_TOKEN": request.form.get("TELEGRAM_TOKEN","").strip(),
-            "TELEGRAM_CHAT_ID": request.form.get("TELEGRAM_CHAT_ID","").strip()
-        }
-        save_config(data)
-        init_gemini()
-        # restart telegram thread if token provided
-        try:
-            start_telegram_bot_thread()
-        except Exception:
-            logger.exception("start telegram thread failed")
-        return redirect(url_for("config_page"))
-    return render_template_string(CONFIG_HTML, **load_config())
-
-@app.route("/api/chat", methods=["POST"])
-def api_chat():
-    payload = request.get_json(force=True)
-    text = (payload.get("text") or "").strip()
-    if not text:
-        return jsonify({"error":"empty"}), 400
-
-    lang = detect_lang(text)
+        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")
+    except Exception as e:
+        logger.exception("route_tts failed")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/stt", methods=["POST"])
+def route_stt():
+    """
+    Accepts multipart 'file' or raw audio bytes in body.
+    Returns JSON: { "text": "recognized text" }
+    """
     try:
-        if USE_GEMINI:
-            prefix = "Trả lời bằng tiếng Việt:" if lang == "vi" else "Answer in English:"
-            reply = gemini_answer(prefix + "\n" + text)
+        if "file" in request.files:
+            f = request.files["file"]
+            audio_bytes = f.read()
         else:
-            reply = "⚠️ Chưa kết nối Gemini. Kiểm tra API Key."
-    except Exception:
-        logger.exception("gemini call")
-        reply = "⚠️ Lỗi khi gọi Gemini."
-
-    tts_path = None
-    try:
-        if reply:
-            tts_path = speak_text(reply, lang)
-    except Exception:
-        logger.exception("tts generation failed")
-
-    tts_url = f"/api/tts/{os.path.basename(tts_path)}" if tts_path else None
-
-    # send to telegram (background) if configured
-    try:
-        cfg = load_config()
-        token = cfg.get("TELEGRAM_TOKEN","")
-        chat_id = cfg.get("TELEGRAM_CHAT_ID","")
-        if token and chat_id:
-            threading.Thread(target=send_to_telegram_sync, args=(token, chat_id, reply, tts_path), daemon=True).start()
-    except Exception:
-        logger.exception("telegram dispatch failed")
-
-    # cleanup audio in background
-    try:
-        threading.Thread(target=cleanup_audio_older_than, kwargs={"seconds":3600}, daemon=True).start()
-    except Exception:
-        pass
-
-    return jsonify({"reply": reply, "tts_url": tts_url})
-
-@app.route("/api/tts/<fname>")
-def get_tts(fname):
-    path = os.path.join(AUDIO_DIR, fname)
-    if not os.path.exists(path):
-        return jsonify({"error":"not found"}), 404
-    return send_file(path, mimetype="audio/mpeg")
-
-# ----------------- Telegram integration -----------------
-TG_THREAD = None
-
-def send_to_telegram_sync(token: str, chat_id: str, text: str, tts_path: str = None):
+            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})
+    except Exception as e:
+        logger.exception("route_stt failed")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/presence", methods=["POST"])
+def route_presence():
     """
-    Send text and (optionally) audio to Telegram chat.
+    ESP32 radar posts: JSON {"note": "..." }
+    Server responds with greeting, and optionally sends Telegram alert.
     """
     try:
-        bot = Bot(token=token)
-        try:
-            bot.send_message(chat_id=chat_id, text=text)
-        except Exception:
-            logger.exception("telegram send_message failed")
-        if tts_path and os.path.exists(tts_path):
+        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:
-                with open(tts_path, "rb") as fh:
-                    bot.send_audio(chat_id=chat_id, audio=fh)
+                send_telegram_message(f"⚠️ Robot: Phát hiện: {note}")
             except Exception:
-                logger.exception("telegram send_audio failed")
+                logger.exception("Telegram notify failed")
+        return jsonify({"greeting": greeting})
+    except Exception as e:
+        logger.exception("route_presence failed")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/display", methods=["GET"])
+def route_display():
+    return jsonify({"lines": DISPLAY_LINES[-6:], "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 -----------------
+INDEX_HTML = """
+<!doctype html>
+<html>
+<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>
+</head>
+<body>
+  <h2>KC Robot AI V4.1 — Cloud Brain (FPT female)</h2>
+  <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});
+      const j = await r.json();
+      if(j.text) appendUser('[voice] '+j.text);
+      else appendUser('[stt error] '+JSON.stringify(j));
+    }
+  </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("telegram overall send failed")
-
-def start_telegram_bot_thread():
-    global TG_THREAD
-    cfg = load_config()
-    token = cfg.get("TELEGRAM_TOKEN","")
-    if not token:
-        logger.info("Telegram token not configured; skipping")
-        return
+        logger.exception("send_telegram_message exception")
+        return False
 
-    if TG_THREAD and TG_THREAD.is_alive():
-        logger.info("Telegram thread already running.")
+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
-
-    def _runner_v20(token):
+    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
+    offset = None
+    logger.info("telegram_poll_loop: starting.")
+    while True:
         try:
-            app_builder = ApplicationBuilder().token(token).build()
-
-            async def start_cmd(update, context):
-                await update.message.reply_text("RobotAI is running. Send me text and I'll reply with Gemini + TTS.")
-
-            async def handle_msg(update, context):
-                text = update.message.text or ""
-                if not text.strip():
-                    await update.message.reply_text("Không nhận được nội dung.")
-                    return
-                lang = detect_lang(text)
-                if USE_GEMINI:
-                    prefix = "Trả lời bằng tiếng Việt:" if lang == "vi" else "Answer in English:"
-                    reply = gemini_answer(prefix + "\n" + text)
-                else:
-                    reply = "⚠️ Chưa kết nối Gemini."
-
-                # generate tts using same cleaning logic
-                tts_path = None
-                try:
-                    if reply:
-                        tts_path = speak_text(reply, lang)
-                except Exception:
-                    logger.exception("tts for telegram failed")
-
-                await update.message.reply_text(reply)
-                if tts_path and os.path.exists(tts_path):
+            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:
-                        with open(tts_path, "rb") as fh:
-                            await context.bot.send_audio(chat_id=update.effective_chat.id, audio=fh)
+                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": ans}, timeout=10)
                     except Exception:
-                        logger.exception("send audio to telegram (v20) failed")
-
-            app_builder.add_handler(CommandHandler("start", start_cmd))
-            app_builder.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_msg))
-            logger.info("Starting Telegram polling (v20)...")
-            app_builder.run_polling()
-        except Exception:
-            logger.exception("telegram v20 runner exception")
-
-    def _runner_v13(token):
-        try:
-            updater = Updater(token=token, use_context=True)
-            dp = updater.dispatcher
-
-            def start_cmd(update, context):
-                update.message.reply_text("RobotAI is running. Send me text and I'll reply with Gemini + TTS.")
-
-            def handle_msg(update, context):
-                text = update.message.text or ""
-                if not text.strip():
-                    update.message.reply_text("Không nhận được nội dung.")
-                    return
-                lang = detect_lang(text)
-                if USE_GEMINI:
-                    prefix = "Trả lời bằng tiếng Việt:" if lang == "vi" else "Answer in English:"
-                    reply = gemini_answer(prefix + "\n" + text)
+                        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:
-                    reply = "⚠️ Chưa kết nối Gemini."
-
-                tts_path = None
-                try:
-                    if reply:
-                        tts_path = speak_text(reply, lang)
-                except Exception:
-                    logger.exception("tts for telegram failed")
-
-                update.message.reply_text(reply)
-                if tts_path and os.path.exists(tts_path):
                     try:
-                        context.bot.send_audio(chat_id=update.effective_chat.id, audio=open(tts_path, "rb"))
+                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "Commands: /ask <q> | /say <text> | /status"}, timeout=10)
                     except Exception:
-                        logger.exception("send audio to telegram (v13) failed")
-
-            dp.add_handler(CommandHandler("start", start_cmd))
-            dp.add_handler(MessageHandler(Filters.text & (~Filters.command), handle_msg))
-            updater.start_polling()
-            updater.idle()
+                        pass
         except Exception:
-            logger.exception("telegram v13 runner exception")
-
-    def runner():
-        if TELEGRAM_LIB == "v20":
-            _runner_v20(token)
-        elif TELEGRAM_LIB == "v13":
-            _runner_v13(token)
-        else:
-            logger.warning("python-telegram-bot not available; skipping telegram polling")
-
-    TG_THREAD = threading.Thread(target=runner, daemon=True)
-    TG_THREAD.start()
-    logger.info("Telegram thread launched (if configured).")
-
-# start telegram thread at startup if token present
-try:
-    start_telegram_bot_thread()
-except Exception:
-    logger.exception("Starting telegram thread failed")
+            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.")
+
+@app.before_first_request
+def _startup():
+    start_background_tasks()
 
 # ----------------- Run -----------------
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    logger.info("Starting RobotAI v9.8 on 0.0.0.0:%s", port)
-    app.run(host="0.0.0.0", port=port)
+    logger.info("Starting KC Robot AI V4.1 (FPT female TTS).")
+    start_background_tasks()
+    app.run(host="0.0.0.0", port=PORT)
+
+