initial commit

app.py

@@ -1,698 +1,192 @@
 
-# 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
 
-import os
-import io
-import sys
-import time
-import json
-import uuid
-import logging
-import threading
-from typing import List, Tuple, Optional, Any
-from pathlib import Path
+# ==========================================================
+#  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
-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}")
+import os
+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__)
 
-def parse_hf_text_resp(obj: Any) -> str:
-    """Normalize HF text outputs."""
+# ==========================================================
+# 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}
     try:
-        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)
+        requests.post(url, json=payload, timeout=5)
     except Exception as 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
+        print("Telegram Error:", e)
 
-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).")
+# ==========================================================
+# GEMINI AI RESPONSE
+# ==========================================================
+def ask_gemini(prompt: str):
+    if not client:
+        return "⚠️ Gemini API key missing. Please configure in Secrets."
 
-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:
-        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]"
-
-# ---------- 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:
-        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)
+        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}"
 
-# Start telegram poller thread if token present
-if TELEGRAM_TOKEN:
+# ==========================================================
+# LANGUAGE DETECTION & TTS
+# ==========================================================
+def text_to_speech(text):
     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>
+        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>
 <html>
 <head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>KC Robot AI v7.2</title>
+<title>KC Robot AI v2.0</title>
 <style>
-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}
+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; }
 </style>
 </head>
 <body>
-<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>
+<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>
 
 <script>
-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);
+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);
   }
+  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("/", 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 ----------
+@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__":
-    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)
+    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)
+