initial commit

app.py

@@ -1,192 +1,698 @@
 
+# app.py — KC Robot AI V7.2 MAX FINAL
+# Flask main app + optional Gradio UI launched in background (for convenience).
+# Requires Secrets:
+#   HF_TOKEN, HF_MODEL, TELEGRAM_TOKEN (optional), TELEGRAM_CHAT_ID (optional)
+#
+# Endpoints:
+#  - GET  /                 -> main HTML UI (chat + audio play)
+#  - GET  /health           -> status json
+#  - POST /ask             -> {text, lang?} -> {"answer": "..."}
+#  - POST /tts             -> {text} -> audio/mp3
+#  - POST /stt             -> upload file or raw bytes -> {"text":"..."}
+#  - POST /presence        -> {note?} -> greets + notify telegram, returns mp3 if possible
+#  - GET  /display         -> display buffer (for ESP32)
+#  - POST /config          -> change runtime config (optional)
+#
+# How to use on HF Spaces:
+#  - Upload this file and requirements.txt
+#  - Set Secrets: HF_TOKEN, HF_MODEL, TELEGRAM_TOKEN (opt), TELEGRAM_CHAT_ID (opt)
+#  - Start Space (Flask runtime). Visit the Space URL to test.
+#
+# Notes:
+#  - Calls to Hugging Face inference API have robust fallback and clear error messages.
+#  - TTS: tries HF TTS model (HF_TTS_MODEL if set), otherwise fallback to gTTS.
+#  - STT: uses HF_STT_MODEL if set (default openai/whisper-small).
+#
+# Author: KC Robot helper (generated)
+# Version: v7.2-max-final
 
-# ==========================================================
-#  KC ROBOT AI - APP.PY (V2.0 MAX FINAL)
-#  Cloud AI Robot with Gemini 2.5 Flash + ESP32 + Telegram
-# ==========================================================
-
-from flask import Flask, request, jsonify, render_template_string
-from google import genai
-import requests
 import os
+import io
+import sys
 import time
-from gtts import gTTS
-from langdetect import detect
-import tempfile
-import base64
-
-# ==========================================================
-# CONFIGURATION
-# ==========================================================
-
-# Load environment variables from secrets (Cloud Run or Hugging Face)
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
-TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
-TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
-
-# Create Flask app
-app = Flask(__name__)
+import json
+import uuid
+import logging
+import threading
+from typing import List, Tuple, Optional, Any
+from pathlib import Path
 
-# ==========================================================
-# SETUP GEMINI CLIENT
-# ==========================================================
-if not GEMINI_API_KEY:
-    print("❌ ERROR: No Gemini API Key found. Please add GEMINI_API_KEY in Secrets.")
-    client = None
-else:
-    client = genai.Client(api_key=GEMINI_API_KEY)
-
-# ==========================================================
-# TELEGRAM UTILITIES
-# ==========================================================
-def send_telegram_message(text):
-    if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
-        print("⚠️ Telegram not configured.")
-        return
-    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
-    payload = {"chat_id": TELEGRAM_CHAT_ID, "text": text}
+import requests
+from flask import Flask, request, jsonify, send_file, render_template_string, abort, Response
+
+# Optional gTTS fallback
+try:
+    from gtts import gTTS
+    _HAS_GTTS = True
+except Exception:
+    _HAS_GTTS = False
+
+# Optional Gradio UI
+try:
+    import gradio as gr
+    _HAS_GRADIO = True
+except Exception:
+    _HAS_GRADIO = False
+
+# Logging config
+logging.basicConfig(stream=sys.stdout, level=logging.INFO,
+                    format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+logger = logging.getLogger("kcrobot.v7.2")
+
+# --------- Load env / secrets ----------
+HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
+HF_MODEL = os.getenv("HF_MODEL", "").strip()  # primary model id
+HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "").strip()  # optional TTS model
+HF_STT_MODEL = os.getenv("HF_STT_MODEL", "openai/whisper-small").strip()
+
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "").strip()
+TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "").strip()
+
+# server ports - HF spaces provides PORT env; default 7860
+PORT = int(os.environ.get("PORT", 7860))
+GRADIO_PORT = 7861  # gradio web ui runs here if enabled
+
+HF_HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+
+# Create data dir for tmp audio
+TMPDIR = Path("/tmp/kcrobot") if os.name != "nt" else Path.cwd() / "tmp_kcrobot"
+TMPDIR.mkdir(parents=True, exist_ok=True)
+
+# --------- in-memory state ----------
+CONV: List[Tuple[str, str]] = []  # (user, bot)
+DISPLAY_BUFFER: List[str] = []
+DISPLAY_LIMIT = 8
+
+def push_display(line: str):
+    global DISPLAY_BUFFER
+    DISPLAY_BUFFER.append(line)
+    if len(DISPLAY_BUFFER) > DISPLAY_LIMIT:
+        DISPLAY_BUFFER = DISPLAY_BUFFER[-DISPLAY_LIMIT:]
+
+# ---------- language detector ----------
+VI_CHARS = set("ăâđêôơưáàảãạắằẳẵặấầẩẫậéèẻẽẹíìỉĩịóòỏõọúùủũụứừửữựýỳỷỹỵ")
+def detect_vi_or_en(text: str) -> str:
+    for ch in text.lower():
+        if ch in VI_CHARS:
+            return "vi"
+    return "en"
+
+# ---------- HF helpers with robust fallback ----------
+def hf_post_json_single(model_id: str, payload: dict, timeout: int = 90) -> requests.Response:
+    """Post JSON to HF inference endpoint for a single model."""
+    if not HF_TOKEN:
+        raise RuntimeError("HF_TOKEN not configured in environment/secrets.")
+    url = f"https://api-inference.huggingface.co/models/{model_id}"
+    headers = dict(HF_HEADERS)
+    headers["Content-Type"] = "application/json"
+    logger.debug("HF JSON POST to %s payload keys: %s", model_id, list(payload.keys()))
+    r = requests.post(url, headers=headers, json=payload, timeout=timeout)
+    return r
+
+def hf_post_json_with_fallback(models: List[str], payload: dict, timeout: int = 90) -> Tuple[str, Any]:
+    """Try a list of models in order. Return (model_used, parsed_json_or_text)."""
+    last_err = None
+    for model in models:
+        try:
+            r = hf_post_json_single(model, payload, timeout=timeout)
+        except Exception as e:
+            last_err = f"network error for {model}: {e}"
+            logger.warning(last_err)
+            continue
+        if r.status_code == 200:
+            try:
+                j = r.json()
+                return model, j
+            except Exception:
+                return model, r.content
+        else:
+            last_err = f"HTTP {r.status_code} from {model}: {r.text[:300]}"
+            logger.warning(last_err)
+            # if auth error (401/403) or not found (404) skip to next
+            continue
+    raise RuntimeError(f"All HF attempts failed. Last error: {last_err}")
+
+def hf_post_bytes_with_fallback(models: List[str], data: bytes, content_type: str = "application/octet-stream", timeout: int = 120) -> Tuple[str, requests.Response]:
+    """Post bytes (STT or TTS) to HF; return model used and response object."""
+    if not HF_TOKEN:
+        raise RuntimeError("HF_TOKEN not configured.")
+    headers = dict(HF_HEADERS)
+    headers["Content-Type"] = content_type
+    last_err = None
+    for model in models:
+        url = f"https://api-inference.huggingface.co/models/{model}"
+        try:
+            r = requests.post(url, headers=headers, data=data, timeout=timeout)
+        except Exception as e:
+            last_err = f"network error {e} for {model}"
+            logger.warning(last_err)
+            continue
+        if r.status_code == 200:
+            return model, r
+        else:
+            last_err = f"HTTP {r.status_code} for {model}: {r.text[:300]}"
+            logger.warning(last_err)
+            continue
+    raise RuntimeError(f"All HF byte-post attempts failed. Last error: {last_err}")
+
+def parse_hf_text_resp(obj: Any) -> str:
+    """Normalize HF text outputs."""
     try:
-        requests.post(url, json=payload, timeout=5)
+        if isinstance(obj, dict):
+            # various shapes: {"generated_text": "..."} or {"choices":[...]}
+            if "generated_text" in obj:
+                return obj.get("generated_text","")
+            if "text" in obj:
+                return obj.get("text","")
+            if "choices" in obj and isinstance(obj["choices"], list) and obj["choices"]:
+                c0 = obj["choices"][0]
+                return c0.get("text") or c0.get("message",{}).get("content","") or str(c0)
+            # fallback - stringify
+            return json.dumps(obj)
+        if isinstance(obj, list) and obj:
+            first = obj[0]
+            if isinstance(first, dict):
+                for k in ("generated_text","text"):
+                    if k in first:
+                        return first.get(k,"")
+            return str(first)
+        if isinstance(obj, (bytes, bytearray)):
+            try:
+                return obj.decode('utf-8', errors='ignore')
+            except Exception:
+                return str(obj)
+        return str(obj)
     except Exception as e:
-        print("Telegram Error:", e)
+        logger.exception("parse_hf_text_resp error")
+        return f"[parse error] {e}"
+
+# ---------- High-level LLM / STT / TTS wrappers ----------
+def llm_generate(prompt: str, model_override: Optional[str] = None, max_new_tokens: int = 256, temperature: float = 0.7) -> str:
+    """Generate text from HF LLM. Use HF_MODEL by default; allow override."""
+    if model_override:
+        models = [model_override]
+    else:
+        if HF_MODEL:
+            models = [HF_MODEL]
+        else:
+            raise RuntimeError("HF_MODEL not configured.")
+    payload = {
+        "inputs": prompt,
+        "parameters": {"max_new_tokens": int(max_new_tokens), "temperature": float(temperature)},
+        "options": {"wait_for_model": True}
+    }
+    model_used, out = hf_post_json_with_fallback(models, payload, timeout=120)
+    res = parse_hf_text_resp(out)
+    logger.info("LLM used model=%s len=%d", model_used, len(res))
+    return res
 
-# ==========================================================
-# GEMINI AI RESPONSE
-# ==========================================================
-def ask_gemini(prompt: str):
-    if not client:
-        return "⚠️ Gemini API key missing. Please configure in Secrets."
+def tts_get_bytes_hf(text: str, model_list: Optional[List[str]] = None) -> bytes:
+    """Try to get TTS bytes from HF models listed, else fallback to gTTS if available."""
+    if not text:
+        raise RuntimeError("Empty text for TTS")
+    models = model_list or ([HF_TTS_MODEL] if HF_TTS_MODEL else [])
+    if models:
+        # HF TTS often expects JSON {"inputs":"..."} and returns audio bytes
+        payload = json.dumps({"inputs": text}).encode("utf-8")
+        try:
+            model_used, resp = hf_post_bytes_with_fallback(models, payload, content_type="application/json", timeout=120)
+            # return raw bytes
+            logger.info("HF TTS used %s return bytes len=%d", model_used, len(resp.content))
+            return resp.content
+        except Exception as e:
+            logger.warning("HF TTS attempts failed: %s", e)
+    # fallback to gTTS if available
+    if _HAS_GTTS:
+        try:
+            tts = gTTS(text=text, lang="vi" if detect_vi_or_en(text)=="vi" else "en")
+            bio = io.BytesIO()
+            tts.write_to_fp(bio)
+            bio.seek(0)
+            data = bio.read()
+            logger.info("gTTS fallback created bytes len=%d", len(data))
+            return data
+        except Exception as e:
+            logger.exception("gTTS fallback failed")
+            raise RuntimeError(f"TTS failed: {e}")
+    raise RuntimeError("No TTS method available (no HF_TTS_MODEL and gTTS missing).")
 
+def stt_from_bytes_hf(audio_bytes: bytes, model_list: Optional[List[str]] = None) -> str:
+    """Run STT via HF; returns recognized text."""
+    models = model_list or ([HF_STT_MODEL] if HF_STT_MODEL else [])
+    if not models:
+        raise RuntimeError("No STT model configured.")
+    model_used, resp = hf_post_bytes_with_fallback(models, audio_bytes, content_type="application/octet-stream", timeout=180)
+    # parse response
     try:
-        response = client.models.generate_content(
-            model=GEMINI_MODEL,
-            contents=prompt
-        )
-        if hasattr(response, "text"):
-            return response.text.strip()
-        elif "text" in response:
-            return response["text"].strip()
-        else:
-            return "⚠️ No response text from Gemini."
-    except Exception as e:
-        print("Gemini Error:", e)
-        return f"⚠️ Gemini Error: {e}"
+        j = resp.json()
+        if isinstance(j, dict) and "text" in j:
+            return j["text"]
+        return parse_hf_text_resp(j)
+    except Exception:
+        try:
+            return resp.text
+        except Exception:
+            return "[stt parse failed]"
 
-# ==========================================================
-# LANGUAGE DETECTION & TTS
-# ==========================================================
-def text_to_speech(text):
+# ---------- Telegram helpers ----------
+def send_telegram_message(text: str) -> bool:
+    if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
+        logger.debug("telegram not configured")
+        return False
     try:
-        lang = detect(text)
-        if lang not in ["vi", "en"]:
-            lang = "en"
-        tts = gTTS(text=text, lang=lang)
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-        tts.save(tmp.name)
-        with open(tmp.name, "rb") as f:
-            audio_b64 = base64.b64encode(f.read()).decode("utf-8")
-        os.unlink(tmp.name)
-        return audio_b64
-    except Exception as e:
-        print("TTS Error:", e)
-        return None
-
-# ==========================================================
-# SIMPLE HTML INTERFACE (for testing)
-# ==========================================================
-HTML_PAGE = """
-<!DOCTYPE html>
+        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+        r = requests.post(url, json={"chat_id": TELEGRAM_CHAT_ID, "text": text}, timeout=8)
+        if r.status_code == 200:
+            return True
+        logger.warning("Telegram send failed %s %s", r.status_code, r.text[:300])
+        return False
+    except Exception:
+        logger.exception("send_telegram_message exception")
+        return False
+
+def telegram_poll_loop():
+    """Background poller: respond to /ask, /say, /status commands"""
+    if not TELEGRAM_TOKEN:
+        logger.info("Telegram not configured - poll disabled")
+        return
+    logger.info("Starting Telegram poller")
+    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
+    offset = None
+    while True:
+        try:
+            params = {"timeout": 30}
+            if offset:
+                params["offset"] = offset
+            r = requests.get(base + "/getUpdates", params=params, timeout=35)
+            if r.status_code != 200:
+                logger.warning("Telegram getUpdates failed: %s", r.status_code)
+                time.sleep(2)
+                continue
+            j = r.json()
+            for upd in j.get("result", []):
+                offset = upd.get("update_id", 0) + 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 from %s: %s", chat_id, text[:120])
+                lower = text.lower()
+                if lower.startswith("/ask "):
+                    q = text[5:].strip()
+                    try:
+                        ans = llm_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 "):
+                    phrase = text[5:].strip()
+                    try:
+                        audio_bytes = tts_get_bytes_hf(phrase)
+                        files = {"audio": ("reply.mp3", audio_bytes, "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 brain running"}, timeout=10)
+                    except Exception:
+                        logger.exception("tg status failed")
+                else:
+                    try:
+                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "Commands: /ask <q> | /say <text> | /status"}, timeout=10)
+                    except Exception:
+                        logger.exception("tg help failed")
+        except Exception:
+            logger.exception("telegram poller exception")
+            time.sleep(3)
+
+# Start telegram poller thread if token present
+if TELEGRAM_TOKEN:
+    try:
+        t = threading.Thread(target=telegram_poll_loop, daemon=True)
+        t.start()
+    except Exception:
+        logger.exception("Failed to start telegram thread")
+
+# ---------- Flask app & routes ----------
+app = Flask(__name__)
+
+# Simple HTML UI (mobile friendly) - main page includes chatbox and audio play button
+INDEX_HTML = """
+<!doctype html>
 <html>
 <head>
-<title>KC Robot AI v2.0</title>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>KC Robot AI v7.2</title>
 <style>
-body { font-family: Arial; text-align: center; background-color: #101010; color: white; }
-input, button { padding: 10px; font-size: 16px; margin: 5px; }
-#chat { max-width: 700px; margin: auto; text-align: left; background: #202020; padding: 20px; border-radius: 10px; }
-.msg-user { color: #4af; }
-.msg-bot { color: #fa4; margin-left: 20px; }
-audio { margin-top: 10px; }
+body{font-family:Inter,Arial,Helvetica,sans-serif;margin:10px;color:#111}
+.container{max-width:900px;margin:auto}
+.header{display:flex;align-items:center;gap:12px}
+.h1{font-size:20px;font-weight:700}
+.controls{margin-top:8px}
+textarea{width:100%;min-height:70px;padding:10px;font-size:15px;border-radius:8px;border:1px solid #ddd}
+button{background:#0066cc;color:white;border:none;padding:10px 14px;border-radius:8px;font-weight:600;cursor:pointer}
+.chatbox{margin-top:12px;border:1px solid #eee;padding:8px;border-radius:8px;background:#fafafa;height:300px;overflow:auto}
+.msg-user{color:#0b63d6;margin:6px 0}
+.msg-bot{color:#0b8a3f;margin:6px 0}
+.small{font-size:13px;color:#666}
+.controls-row{display:flex;gap:8px;align-items:center}
+.select{padding:6px;border-radius:6px;border:1px solid #ddd}
 </style>
 </head>
 <body>
-<h1>🤖 KC Robot AI v2.0 MAX FINAL</h1>
-<div id="chat"></div>
-<br>
-<input id="user_input" placeholder="Nói gì đó..." style="width:60%">
-<button onclick="sendMessage()">Gửi</button>
+<div class="container">
+  <div class="header">
+    <div class="h1">🤖 KC Robot AI v7.2 — Final</div>
+  </div>
+  <div class="small">Model: <span id="modelName">loading...</span></div>
+  <div class="controls">
+    <textarea id="userText" placeholder="Nhập tiếng Việt hoặc English..."></textarea>
+    <div class="controls-row">
+      <select id="lang" class="select"><option value="auto">Auto</option><option value="vi">Vietnamese</option><option value="en">English</option></select>
+      <button onclick="sendMsg()">Gửi</button>
+      <button onclick="playLast()">Phát âm</button>
+      <button onclick="clearChat()">Xóa</button>
+    </div>
+  </div>
+  <div class="chatbox" id="chatbox"></div>
+  <div style="margin-top:12px">
+    <input type="file" id="audioFile" accept="audio/*"><button onclick="uploadAudio()">Upload → STT</button>
+  </div>
+  <div style="margin-top:12px" class="small">Kết nối Telegram: <span id="tgstatus">checking...</span></div>
+</div>
 
 <script>
-async function sendMessage() {
-  const input = document.getElementById("user_input").value;
-  if (!input) return;
-  const chat = document.getElementById("chat");
-  chat.innerHTML += `<div class='msg-user'><b>Bạn:</b> ${input}</div>`;
-  document.getElementById("user_input").value = "";
-  const res = await fetch("/api/chat", {
-    method: "POST",
-    headers: {"Content-Type": "application/json"},
-    body: JSON.stringify({message: input})
-  });
-  const data = await res.json();
-  chat.innerHTML += `<div class='msg-bot'><b>Robot:</b> ${data.reply}</div>`;
-  if (data.audio) {
-    const audio = document.createElement("audio");
-    audio.src = "data:audio/mp3;base64," + data.audio;
-    audio.controls = true;
-    chat.appendChild(audio);
+let lastAnswer = "";
+function appendUser(t){ const cb=document.getElementById('chatbox'); cb.innerHTML += '<div class="msg-user"><b>You:</b> '+escapeHtml(t)+'</div>'; cb.scrollTop = cb.scrollHeight; }
+function appendBot(t){ const cb=document.getElementById('chatbox'); cb.innerHTML += '<div class="msg-bot"><b>Robot:</b> '+escapeHtml(t)+'</div>'; cb.scrollTop = cb.scrollHeight; }
+function escapeHtml(s){ return (s+'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+async function sendMsg(){
+  let t=document.getElementById('userText').value.trim(); if(!t) return;
+  appendUser(t);
+  document.getElementById('userText').value='';
+  const lang=document.getElementById('lang').value;
+  try {
+    const res = await fetch('/ask', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({text: t, lang: lang})});
+    const j = await res.json();
+    if(j.answer){
+      lastAnswer = j.answer;
+      appendBot(j.answer);
+    } else {
+      appendBot("[Error] " + JSON.stringify(j));
+    }
+  } catch(e){
+    appendBot("[Network Error] " + e);
+  }
+}
+async function playLast(){
+  if(!lastAnswer) return alert('No answer to play');
+  try {
+    const r = await fetch('/tts', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({text: lastAnswer})});
+    if(!r.ok){ alert('TTS failed'); return; }
+    const blob = await r.blob();
+    const url = URL.createObjectURL(blob);
+    const a = new Audio(url);
+    a.play();
+  } catch(e){
+    alert('Play error: '+e);
   }
-  chat.scrollTop = chat.scrollHeight;
 }
+async function uploadAudio(){
+  const f = document.getElementById('audioFile').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); lastAnswer=''; }
+  else appendUser('[stt error] ' + JSON.stringify(j));
+}
+async function clearChat(){ document.getElementById('chatbox').innerHTML=''; lastAnswer=''; }
+async function loadStatus(){
+  try{
+    const r=await fetch('/health'); const j=await r.json();
+    document.getElementById('modelName').innerText = j.hf_model || '(not set)';
+    document.getElementById('tgstatus').innerText = j.telegram ? 'enabled' : 'disabled';
+  }catch(e){
+    document.getElementById('modelName').innerText='(error)';
+    document.getElementById('tgstatus').innerText='error';
+  }
+}
+loadStatus();
 </script>
 </body>
 </html>
 """
 
-@app.route("/")
-def home():
-    return render_template_string(HTML_PAGE)
-
-# ==========================================================
-# API ENDPOINTS
-# ==========================================================
-
-@app.route("/api/chat", methods=["POST"])
-def api_chat():
-    data = request.get_json()
-    if not data or "message" not in data:
-        return jsonify({"error": "Missing 'message'"}), 400
-
-    user_message = data["message"]
-    print(f"🧠 User said: {user_message}")
-    send_telegram_message(f"User: {user_message}")
-
-    ai_reply = ask_gemini(user_message)
-    send_telegram_message(f"Robot: {ai_reply}")
-
-    audio_b64 = text_to_speech(ai_reply)
-    return jsonify({"reply": ai_reply, "audio": audio_b64})
-
-# ESP32 sensor endpoint
-@app.route("/api/sensor", methods=["POST"])
-def sensor_data():
-    data = request.get_json()
-    if not data:
-        return jsonify({"error": "No data"}), 400
-    msg = f"👁️ ESP32 Sensor update: {data}"
-    send_telegram_message(msg)
-    return jsonify({"status": "received"})
-
-# Health check
-@app.route("/ping")
-def ping():
-    return jsonify({"status": "ok", "model": GEMINI_MODEL})
-
-# ==========================================================
-# MAIN ENTRY POINT
-# ==========================================================
-if __name__ == "__main__":
-    port = int(os.getenv("PORT", 8080))
-    print(f"🚀 KC Robot AI v2.0 running on port {port}")
-    app.run(host="0.0.0.0", port=port)
+@app.route("/", methods=["GET"])
+def index():
+    return render_template_string(INDEX_HTML)
+
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({
+        "ok": True,
+        "hf_token": bool(HF_TOKEN),
+        "hf_model": HF_MODEL,
+        "hf_tts_model": HF_TTS_MODEL,
+        "hf_stt_model": HF_STT_MODEL,
+        "telegram": bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID),
+        "conv_len": len(CONV),
+        "display_len": len(DISPLAY_BUFFER)
+    })
+
+@app.route("/ask", methods=["POST"])
+def route_ask():
+    try:
+        j = request.get_json(force=True) or {}
+        text = (j.get("text","") or "").strip()
+        lang = (j.get("lang","auto") or "auto")
+        if not text:
+            return jsonify({"error":"no text"}), 400
+        # prepare prompt instruct
+        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à lịch sự. Trả lời ngắn gọn:\n\n{text}"
+        elif lang == "en":
+            prompt = f"You are a helpful assistant. Answer in clear English, concise:\n\n{text}"
+        else:
+            prompt = f"You are a bilingual assistant. Answer in the same language as the user, clearly and concisely:\n\n{text}"
+        try:
+            ans = llm_generate(prompt)
+        except Exception as e:
+            logger.exception("LLM error")
+            return jsonify({"error": f"LLM error: {e}"}), 500
+        CONV.append((text, ans))
+        push_display("YOU: " + (text[:60]))
+        push_display("BOT: " + (ans[:60] if isinstance(ans, str) else str(ans)[:60]))
+        # notify telegram optionally (short)
+        if TELEGRAM_TOKEN and TELEGRAM_CHAT_ID:
+            try:
+                send_telegram_message(f"You: {text}\nBot: {ans[:300]}")
+            except Exception:
+                logger.exception("telegram notify failed")
+        return jsonify({"answer": ans})
+    except Exception as e:
+        logger.exception("route_ask failed")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/tts", methods=["POST"])
+def route_tts():
+    try:
+        j = request.get_json(force=True) or {}
+        text = (j.get("text","") or "").strip()
+        if not text:
+            return jsonify({"error":"no text"}), 400
+        # try HF TTS model first
+        try:
+            # prefer HF_TTS_MODEL if set
+            models = [HF_TTS_MODEL] if HF_TTS_MODEL else []
+            audio_bytes = tts_get_bytes_hf(text, model_list=models if models else None)
+        except Exception as e:
+            logger.warning("TTS HF failed: %s", e)
+            # fallback to gTTS if possible
+            if _HAS_GTTS:
+                try:
+                    audio_bytes = tts_get_bytes_hf(text, model_list=[])
+                except Exception as e2:
+                    logger.exception("gTTS fallback also failed")
+                    return jsonify({"error": f"TTS failed: {e2}"}), 500
+            else:
+                return jsonify({"error": f"TTS failed: {e}"}), 500
+        # return mp3
+        return Response(audio_bytes, mimetype="audio/mpeg")
+    except Exception as e:
+        logger.exception("route_tts exception")
+        return jsonify({"error": str(e)}), 500
 
+@app.route("/stt", methods=["POST"])
+def route_stt():
+    try:
+        if "file" in request.files:
+            f = request.files["file"]
+            audio_bytes = f.read()
+        else:
+            audio_bytes = request.get_data()
+        if not audio_bytes:
+            return jsonify({"error":"no audio provided"}), 400
+        try:
+            txt = stt_from_bytes_hf(audio_bytes)
+        except Exception as e:
+            logger.exception("STT failed")
+            return jsonify({"error": str(e)}), 500
+        CONV.append((f"[voice] {txt}", ""))
+        push_display("VOICE: " + (txt[:60] if isinstance(txt,str) else str(txt)))
+        return jsonify({"text": txt})
+    except Exception as e:
+        logger.exception("route_stt exception")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/presence", methods=["POST"])
+def route_presence():
+    try:
+        j = request.get_json(force=True) or {}
+        note = (j.get("note","Có người phía trước") or "Có người phía trước")
+        greeting = f"Xin chào! {note}"
+        CONV.append(("__presence__", greeting))
+        push_display("RADAR: " + note[:60])
+        # Telegram notify
+        if TELEGRAM_TOKEN and TELEGRAM_CHAT_ID:
+            try:
+                send_telegram_message(f"⚠️ Robot: Phát hiện người - {note}")
+            except Exception:
+                logger.exception("telegram notify error")
+        # Return greeting audio if possible
+        try:
+            audio_bytes = tts_get_bytes_hf(greeting, model_list=[HF_TTS_MODEL] if HF_TTS_MODEL else None)
+            return Response(audio_bytes, mimetype="audio/mpeg")
+        except Exception:
+            # fallback to text only
+            return jsonify({"greeting": greeting})
+    except Exception as e:
+        logger.exception("presence error")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/display", methods=["GET"])
+def route_display():
+    return jsonify({"lines": DISPLAY_BUFFER.copy(), "conv_len": len(CONV)})
+
+@app.route("/config", methods=["GET","POST"])
+def route_config():
+    # quick config view/change via JSON (NOT secure — for debug only)
+    if request.method == "GET":
+        return jsonify({
+            "hf_token_set": bool(HF_TOKEN),
+            "hf_model": HF_MODEL,
+            "hf_tts_model": HF_TTS_MODEL,
+            "hf_stt_model": HF_STT_MODEL,
+            "telegram": bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID)
+        })
+    else:
+        try:
+            j = request.get_json(force=True) or {}
+            # we cannot change secrets here; just accept display config changes
+            return jsonify({"ok": True, "received": j})
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+# ---------- Gradio UI (optional) ----------
+def start_gradio_in_thread():
+    if not _HAS_GRADIO:
+        logger.info("Gradio not installed - skipping Gradio UI")
+        return
+    try:
+        import gradio as gr
+        def gradio_chat(audio, text, temp, max_tokens, model_override):
+            user_text = (text or "").strip()
+            if audio:
+                # read path (gradio returns path)
+                try:
+                    with open(audio, "rb") as f:
+                        b = f.read()
+                    stt = stt_from_bytes_hf(b)
+                    if stt and not stt.startswith("[ERROR]"):
+                        user_text = stt
+                except Exception:
+                    logger.exception("gradio stt failed")
+            if not user_text:
+                return None, ""
+            prompt = f"You are KC Robot AI, bilingual assistant. Answer in the same language as the user.\\nUser: {user_text}\\nAssistant:"
+            model = model_override.strip() if model_override else HF_MODEL
+            try:
+                ans = llm_generate(prompt, model_override=model, max_new_tokens=int(max_tokens), temperature=float(temp))
+            except Exception as e:
+                ans = f"[LLM error] {e}"
+            # generate tts bytes for preview
+            try:
+                audio_bytes = tts_get_bytes_hf(ans, model_list=[HF_TTS_MODEL] if HF_TTS_MODEL else None)
+            except Exception:
+                audio_bytes = None
+            chat_history = [( "You", user_text ), ( "Bot", ans )]
+            if audio_bytes:
+                return (chat_history, (audio_bytes, "audio/mpeg"))
+            return (chat_history, None)
+
+        with gr.Blocks(title="KC Robot AI v7.2 (Gradio)") as demo:
+            gr.Markdown("## KC Robot AI v7.2 Gradio UI")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot([], elem_id="chatbot").style(height=420)
+                    txt = gr.Textbox(lines=2, placeholder="Nhập câu (VN/EN)...", label="Text input")
+                    mic = gr.Audio(source="microphone", type="filepath", label="Record voice")
+                    btn = gr.Button("Send")
+                    with gr.Row():
+                        temp = gr.Slider(0.0, 1.0, value=0.7, label="Temperature")
+                        tokens = gr.Slider(32, 1024, value=256, step=16, label="Max tokens")
+                    model_override = gr.Textbox(label="Model override (optional)", placeholder=HF_MODEL)
+                with gr.Column(scale=1):
+                    gr.Markdown("### TTS / STT")
+                    tts_in = gr.Textbox(lines=2, label="Text → TTS")
+                    tts_btn = gr.Button("Create TTS")
+                    tts_audio = gr.Audio(label="TTS audio", interactive=False)
+                    up = gr.Audio(source="upload", type="filepath", label="Upload audio")
+                    stt_btn = gr.Button("Transcribe")
+                    stt_out = gr.Textbox(label="Transcription")
+            def send_click(audio_file, typed, temp_v, max_toks, model_o, chat_history):
+                # reuse gradio_chat
+                result = gradio_chat(audio_file, typed, temp_v, max_toks, model_o)
+                if result is None:
+                    return chat_history or [], ""
+                (chat_hist, audio_blob) = result
+                history = chat_history or []
+                # append
+                for item in chat_hist:
+                    history.append(item)
+                return history, ""
+            btn.click(send_click, inputs=[mic, txt, temp, tokens, model_override, chatbot], outputs=[chatbot, txt])
+            tts_btn.click(lambda txt_in: tts_get_bytes_hf(txt_in) if txt_in else None, inputs=[tts_in], outputs=[tts_audio])
+
+        # Run gradio in new thread
+        def _run():
+            try:
+                demo.launch(server_name="0.0.0.0", server_port=GRADIO_PORT, share=False, prevent_thread_lock=True)
+            except Exception:
+                logger.exception("Gradio failed to launch")
+        t = threading.Thread(target=_run, daemon=True)
+        t.start()
+        logger.info("Gradio thread started on port %s", GRADIO_PORT)
+    except Exception:
+        logger.exception("start_gradio_in_thread failed")
+
+# start gradio if available
+start_gradio_in_thread()
+
+# ---------- Run app ----------
+if __name__ == "__main__":
+    logger.info("KC Robot AI v7.2 starting on port %s", PORT)
+    if not HF_TOKEN:
+        logger.warning("HF_TOKEN not set. Add HF_TOKEN to Space Secrets.")
+    if not HF_MODEL:
+        logger.warning("HF_MODEL not set. Add HF_MODEL to Space Secrets.")
+    # start flask
+    app.run(host="0.0.0.0", port=PORT)