Update

app.py

@@ -1,75 +1,53 @@
 
-# app.py
-# KC Robot AI — V4 FINAL (Gradio + REST API /api/* + Telegram)
-# Upload this file to a Hugging Face Space (SDK = Gradio).
-# Put your secrets in Space Settings:
-#   HF_API_TOKEN (required)
-#   TELEGRAM_TOKEN (optional)
-#   TELEGRAM_CHATID (optional)
-# Optional overrides:
-#   HF_MODEL, HF_STT_MODEL, HF_TTS_MODEL
+# app.py -- KC Robot AI V4.0 (Cloud Brain)
+# Flask server: Chat (HF), TTS, STT, Telegram poller, REST API cho ESP32
+# Setup: set env HF_API_TOKEN, (optional) HF_MODEL, HF_TTS_MODEL, HF_STT_MODEL, TELEGRAM_TOKEN
+# requirements: see requirements.txt
 
 import os
 import io
 import time
+import json
 import threading
 import logging
-from typing import Optional, Any, List, Tuple
+from typing import Optional, List, Tuple
 
 import requests
-import gradio as gr
-from langdetect import detect, DetectorFactory
-from gtts import gTTS
+from flask import Flask, request, jsonify, send_file, render_template_string
 
-# Ensure deterministic detection
-DetectorFactory.seed = 0
-
-# Logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("kcrobot.v4")
 
-# ====== Config from Secrets / env ======
-HF_API_TOKEN = os.getenv("HF_API_TOKEN", "").strip()
+app = Flask(__name__)
+
+# ====== Config from env / Secrets ======
+HF_API_TOKEN = os.getenv("HF_API_TOKEN", "")
 HF_MODEL = os.getenv("HF_MODEL", "google/flan-t5-large")
+HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "facebook/tts_transformer-es-css10")
 HF_STT_MODEL = os.getenv("HF_STT_MODEL", "openai/whisper-small")
-HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "")  # optional, if empty use gTTS
-TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "").strip()
-TELEGRAM_CHATID = os.getenv("TELEGRAM_CHATID", "").strip()
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "")
+PORT = int(os.getenv("PORT", os.getenv("SERVER_PORT", 7860)))
 
 if not HF_API_TOKEN:
-    logger.warning("HF_API_TOKEN not set — put it into Space Secrets for HF inference calls to work.")
+    logger.warning("HF_API_TOKEN not set. Put HF_API_TOKEN in Secrets.")
 
 HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
 
-# ====== In-memory state ======
-CONVERSATION: List[Tuple[str, str]] = []
-DISPLAY_BUFFER: List[str] = []
-DISPLAY_LIMIT = 6
-
-def push_display(line: str):
-    DISPLAY_BUFFER.append(line)
-    if len(DISPLAY_BUFFER) > DISPLAY_LIMIT:
-        del DISPLAY_BUFFER[0]
+# ====== In-memory storage (simple) ======
+# conversation: list of (user, bot) pairs
+CONV: List[Tuple[str,str]] = []
+# display_lines for ESP32 OLED (last few lines)
+DISPLAY_LINES: List[str] = []
 
-# ====== Hugging Face helpers ======
-def _parse_hf_text_response(data: Any) -> str:
-    try:
-        if isinstance(data, list) and data and isinstance(data[0], dict):
-            return data[0].get("generated_text", "") or str(data[0])
-        if isinstance(data, dict) and "generated_text" in data:
-            return data["generated_text"]
-        if isinstance(data, dict) and "text" in data:
-            return data["text"]
-        if isinstance(data, dict) and "choices" in data and isinstance(data["choices"], list):
-            c0 = data["choices"][0]
-            return c0.get("text") or c0.get("message", {}).get("content", "") or str(c0)
-        return str(data)
-    except Exception:
-        return str(data)
+# helper to maintain display buffer
+def push_display(line: str, limit=6):
+    global DISPLAY_LINES
+    DISPLAY_LINES.append(line)
+    if len(DISPLAY_LINES) > limit:
+        DISPLAY_LINES = DISPLAY_LINES[-limit:]
 
+# ====== HuggingFace helpers (REST inference) ======
 def hf_text_generate(prompt: str, model: Optional[str] = None, max_new_tokens: int = 256, temperature: float = 0.7) -> str:
-    if not HF_API_TOKEN:
-        raise RuntimeError("HF_API_TOKEN not configured in environment")
     model = model or HF_MODEL
     url = f"https://api-inference.huggingface.co/models/{model}"
     payload = {
@@ -77,268 +55,317 @@ def hf_text_generate(prompt: str, model: Optional[str] = None, max_new_tokens: i
         "parameters": {"max_new_tokens": int(max_new_tokens), "temperature": float(temperature)},
         "options": {"wait_for_model": True}
     }
-    logger.info("HF text gen -> model=%s prompt_len=%d", model, len(prompt))
     r = requests.post(url, headers=HF_HEADERS, json=payload, timeout=120)
     if r.status_code != 200:
-        logger.error("HF text gen error %s: %s", r.status_code, r.text[:300])
-        raise RuntimeError(f"HF text gen failed: {r.status_code}: {r.text}")
-    return _parse_hf_text_response(r.json())
+        logger.error("HF text gen error %s: %s", r.status_code, r.text[:200])
+        raise RuntimeError(f"HF text generation failed: {r.status_code}: {r.text}")
+    data = r.json()
+    # parse common shapes
+    if isinstance(data, list) and len(data) and isinstance(data[0], dict):
+        return data[0].get("generated_text", "") or str(data[0])
+    if isinstance(data, dict) and "generated_text" in data:
+        return data.get("generated_text", "")
+    return str(data)
+
+def hf_tts_get_mp3(text: str, model: Optional[str] = None) -> bytes:
+    model = model or HF_TTS_MODEL
+    url = f"https://api-inference.huggingface.co/models/{model}"
+    payload = {"inputs": text}
+    headers = dict(HF_HEADERS)
+    headers["Content-Type"] = "application/json"
+    r = requests.post(url, headers=headers, json=payload, stream=True, timeout=120)
+    if r.status_code != 200:
+        logger.error("HF TTS error %s: %s", r.status_code, r.text[:200])
+        raise RuntimeError(f"HF TTS failed: {r.status_code}: {r.text}")
+    return r.content
 
 def hf_stt_from_bytes(audio_bytes: bytes, model: Optional[str] = None) -> str:
-    if not HF_API_TOKEN:
-        raise RuntimeError("HF_API_TOKEN not configured")
     model = model or HF_STT_MODEL
     url = f"https://api-inference.huggingface.co/models/{model}"
     headers = dict(HF_HEADERS)
     headers["Content-Type"] = "application/octet-stream"
-    logger.info("HF STT -> model=%s bytes=%d", model, len(audio_bytes) if audio_bytes else 0)
     r = requests.post(url, headers=headers, data=audio_bytes, timeout=180)
     if r.status_code != 200:
-        logger.error("HF STT error %s: %s", r.status_code, r.text[:300])
+        logger.error("HF STT error %s: %s", r.status_code, r.text[:200])
         raise RuntimeError(f"HF STT failed: {r.status_code}: {r.text}")
     j = r.json()
+    # common: {"text":"..."}
     if isinstance(j, dict) and "text" in j:
         return j["text"]
-    return _parse_hf_text_response(j)
+    # fallback
+    return str(j)
 
-# ====== TTS: prefer gTTS (free). If HF_TTS_MODEL provided you can implement HF TTS similarly. ======
-def tts_gtts_bytes(text: str) -> bytes:
+# ====== Core endpoints for ESP32 ======
+@app.route("/ask", methods=["POST"])
+def api_ask():
+    """ESP32 or web call: JSON {text, lang (opt)} -> returns {"answer": "..."}"""
+    data = request.get_json(force=True)
+    text = data.get("text","").strip()
+    lang = data.get("lang","auto")
     if not text:
-        raise RuntimeError("Empty text for TTS")
-    # detect language (vi/en) to choose voice
+        return jsonify({"error":"no text"}), 400
+    # build instructive prompt to encourage clear Vietnamese/English responses
+    if lang == "vi":
+        prompt = "Bạn là trợ lý thông minh, trả lời bằng tiếng Việt, rõ ràng và ngắn gọn:\n\n" + text
+    elif lang == "en":
+        prompt = "You are a helpful assistant. Answer in clear English, concise:\n\n" + text
+    else:
+        # auto: simple system instruction bilingual
+        prompt = "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
     try:
-        lang = detect(text)
-    except Exception:
-        lang = "vi"
-    # select language code: prefer Vietnamese if detect says 'vi'
-    tts_lang = "vi" if lang.startswith("vi") else "en"
-    logger.info("gTTS generating audio lang=%s len=%d", tts_lang, len(text))
-    tts = gTTS(text=text, lang=tts_lang)
-    bio = io.BytesIO()
-    tts.write_to_fp(bio)
-    bio.seek(0)
-    return bio.read()
+        ans = hf_text_generate(prompt)
+    except Exception as e:
+        logger.exception("ask failed")
+        return jsonify({"error": str(e)}), 500
+    # store conversation and display
+    CONV.append((text, ans))
+    push_display("YOU: " + (text[:40]))
+    push_display("BOT: " + (ans[:40]))
+    return jsonify({"answer": ans})
+
+@app.route("/tts", methods=["POST"])
+def api_tts():
+    """POST JSON {text: "..."} -> return audio/mpeg bytes (mp3 or wav)"""
+    data = request.get_json(force=True)
+    text = data.get("text","").strip()
+    if not text:
+        return jsonify({"error":"no text"}), 400
+    try:
+        audio = hf_tts_get_mp3(text)
+    except Exception as e:
+        logger.exception("tts failed")
+        return jsonify({"error": str(e)}), 500
+    return send_file(
+        io.BytesIO(audio),
+        mimetype="audio/mpeg",
+        as_attachment=False,
+        download_name="tts.mp3"
+    )
+
+@app.route("/stt", methods=["POST"])
+def api_stt():
+    """
+    Accepts raw audio bytes in body OR multipart 'file'.
+    Returns JSON {"text": "..."}
+    """
+    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"}), 400
+    try:
+        text = hf_stt_from_bytes(audio_bytes)
+    except Exception as e:
+        logger.exception("stt failed")
+        return jsonify({"error": str(e)}), 500
+    # push to display
+    push_display("UserAudio: " + (text[:40]))
+    return jsonify({"text": text})
+
+@app.route("/presence", methods=["POST"])
+def api_presence():
+    """
+    ESP32 radar -> POST JSON {"event":"presence","note": "..."}.
+    Server: will announce greeting (call TTS) and send Telegram alert.
+    """
+    data = request.get_json(force=True)
+    note = data.get("note","Có người tới")
+    # create greeting text
+    greeting = f"Xin chào! {note}"
+    # store
+    CONV.append(("__presence__", greeting))
+    push_display("RADAR: " + note[:40])
+    # Telegram notify
+    if TELEGRAM_TOKEN:
+        try:
+            send_telegram_message(f"⚠️ Robot: Phát hiện người - {note}")
+        except Exception:
+            logger.exception("telegram notify failed")
+    # Return greeting so ESP can call /tts to download and play (or include mp3 directly)
+    return jsonify({"greeting": greeting})
+
+@app.route("/display", methods=["GET"])
+def api_display():
+    """ESP32 GET -> returns last display lines to show on OLED."""
+    return jsonify({"lines": DISPLAY_LINES, "conv_len": len(CONV)})
+
+# ====== Web UI (simple mobile-friendly) ======
+INDEX_HTML = """
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>KC Robot AI V4.0</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body{font-family:Arial,Helvetica;color:#111;margin:10px;padding:0}
+    .box{max-width:900px;margin:auto}
+    textarea{width:100%;height:80px;padding:8px;font-size:16px}
+    button{padding:10px 16px;margin-top:6px;font-size:16px}
+    #chat{border:1px solid #ddd;padding:8px;height:320px;overflow:auto;background:#f9f9f9}
+    .msg-user{color:#006; margin:6px 0}
+    .msg-bot{color:#080; margin:6px 0}
+  </style>
+</head>
+<body>
+  <div class="box">
+    <h2>🤖 KC Robot AI V4.0 — Cloud Brain</h2>
+    <div id="chat"></div>
+    <textarea id="txt" placeholder="Nhập tiếng Việt hoặc English..."></textarea><br>
+    <button onclick="send()">Gửi (Ask)</button>
+    <button onclick="playLastTTS()">Phát TTS trả lời</button>
+    <hr/>
+    <input type="file" id="audiofile" accept="audio/*"><button onclick="uploadAudio()">Upload audio → STT</button>
+    <hr/>
+    <h4>Logs</h4><div id="log"></div>
+  </div>
+<script>
+async function send(){
+  const txt = document.getElementById('txt').value;
+  if(!txt) return;
+  appendUser(txt);
+  document.getElementById('txt').value='';
+  const res = await fetch('/ask',{method:'POST',headers:{'Content-Type':'application/json'}, body: JSON.stringify({text: txt})});
+  const j = await res.json();
+  if(j.answer){
+    appendBot(j.answer);
+    // cache last answer for TTS
+    window._lastAnswer = j.answer;
+  } else {
+    appendBot('[Error] '+JSON.stringify(j));
+  }
+}
+function appendUser(t){document.getElementById('chat').innerHTML += '<div class="msg-user"><b>You:</b> '+escapeHtml(t)+'</div>'; scrollChat();}
+function appendBot(t){document.getElementById('chat').innerHTML += '<div class="msg-bot"><b>Robot:</b> '+escapeHtml(t)+'</div>'; scrollChat();}
+function scrollChat(){let c=document.getElementById('chat'); c.scrollTop = c.scrollHeight;}
+function escapeHtml(s){ return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');}
+async function playLastTTS(){
+  const txt = window._lastAnswer || '';
+  if(!txt){ alert('Chưa có câu trả lời để phát'); return; }
+  const r = await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body: JSON.stringify({text:txt})});
+  if(r.ok){
+    const blob = await r.blob();
+    const url = URL.createObjectURL(blob);
+    const a = new Audio(url);
+    a.play();
+  } else {
+    alert('TTS lỗi');
+  }
+}
+async function uploadAudio(){
+  const f = document.getElementById('audiofile').files[0];
+  if(!f){ alert('Chọn file audio'); return; }
+  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); window._lastSTT = j.text; }
+  else appendUser('[stt error] '+JSON.stringify(j));
+}
+// simple logger
+function log(msg){ document.getElementById('log').innerText += '\\n'+msg; }
+</script>
+</body>
+</html>
+"""
 
-# ====== Telegram helpers (optional) ======
-def send_telegram(text: str):
-    if not TELEGRAM_TOKEN or not TELEGRAM_CHATID:
-        logger.debug("Telegram not configured or missing chat id")
+@app.route("/", methods=["GET"])
+def index():
+    return render_template_string(INDEX_HTML)
+
+# ====== Telegram integration (polling minimal) ======
+def send_telegram_message(text: str):
+    if not TELEGRAM_TOKEN:
+        logger.warning("Telegram token not set")
         return
-    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
+    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+    payload = {"chat_id": os.getenv("TELEGRAM_CHATID", ""), "text": text}
     try:
-        requests.post(base + "/sendMessage", json={"chat_id": TELEGRAM_CHATID, "text": text}, timeout=10)
+        r = requests.post(url, json=payload, timeout=10)
+        if not r.ok:
+            logger.warning("Telegram send failed: %s %s", r.status_code, r.text)
     except Exception:
-        logger.exception("send_telegram failed")
+        logger.exception("send_telegram_message error")
 
-def telegram_poller():
+def telegram_poll_loop(server_url: str):
     if not TELEGRAM_TOKEN:
-        logger.info("Telegram poller disabled")
+        logger.info("No TELEGRAM_TOKEN -> telegram disabled")
         return
-    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
+    logger.info("Starting Telegram poller")
     offset = None
-    logger.info("Telegram poller started")
+    base = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}"
     while True:
         try:
             params = {"timeout": 30}
-            if offset: params["offset"] = offset
+            if offset:
+                params["offset"] = offset
             r = requests.get(base + "/getUpdates", params=params, timeout=35)
             if r.status_code != 200:
                 time.sleep(2); continue
-            data = r.json()
-            for upd in data.get("result", []):
-                offset = upd.get("update_id", 0) + 1
-                msg = upd.get("message") or {}
+            j = r.json()
+            for u in j.get("result", []):
+                offset = u["update_id"] + 1
+                msg = u.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", text)
+                logger.info("TG msg %s: %s", chat_id, text)
+                # commands: /ask , /say, /status
                 if text.lower().startswith("/ask "):
                     q = text[5:].strip()
                     try:
                         ans = hf_text_generate(q)
                     except Exception as e:
                         ans = f"[HF error] {e}"
+                    # reply
                     try:
                         requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": ans}, timeout=10)
                     except Exception:
                         logger.exception("tg reply failed")
                 elif text.lower().startswith("/say "):
-                    phrase = text[5:].strip()
+                    tts_text = text[5:].strip()
+                    # get mp3 and send as audio
                     try:
-                        audio = tts_gtts_bytes(phrase)
-                        files = {"audio": ("reply.mp3", audio, "audio/mpeg")}
+                        mp3 = hf_tts_get_mp3(tts_text)
+                        files = {"audio": ("reply.mp3", mp3, "audio/mpeg")}
                         requests.post(base + "/sendAudio", files=files, data={"chat_id": chat_id}, timeout=30)
                     except Exception:
                         logger.exception("tg say failed")
                 elif text.lower().startswith("/status"):
                     try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "KC Robot brain running"}, timeout=10)
+                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "Robot brain running"}, timeout=10)
                     except Exception:
                         pass
                 else:
+                    # default help
                     try:
                         requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "Commands: /ask <q> | /say <text> | /status"}, timeout=10)
                     except Exception:
                         pass
         except Exception:
-            logger.exception("telegram poller exception")
+            logger.exception("telegram poll loop exception")
             time.sleep(3)
 
-if TELEGRAM_TOKEN:
-    t = threading.Thread(target=telegram_poller, daemon=True)
-    t.start()
-
-# ====== Gradio UI (chat + TTS + STT) ======
-with gr.Blocks(title="KC Robot AI - Cloud Brain V4") as demo:
-    gr.Markdown("## 🤖 KC Robot AI — Cloud Brain (Hugging Face Inference)")
-    with gr.Row():
-        with gr.Column(scale=2):
-            chatbot = gr.Chatbot([], elem_id="chatbot").style(height=480)
-            txt = gr.Textbox(lines=2, placeholder="Nhập câu hỏi (VN/EN) hoặc tiếng Anh...", label="Your message")
-            send = gr.Button("Gửi")
-            with gr.Row():
-                temp = gr.Slider(0.0, 1.0, value=0.7, label="Temperature")
-                tokens = gr.Slider(16, 1024, value=256, step=16, label="Max tokens")
-            model_override = gr.Textbox(label="Override HF model (optional)")
-        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)
-            gr.Markdown("Upload audio for STT")
-            up = gr.Audio(source="upload", type="filepath", label="Upload audio")
-            stt_btn = gr.Button("Transcribe")
-            stt_out = gr.Textbox(label="Transcription")
-
-    def chat_fn(message, history, temperature, max_tokens, model_override_val):
-        if not message or not message.strip(): 
-            return history or [], ""
-        system = "You are KC Robot AI, bilingual (Vietnamese & English). Answer in the same language as the user. Be clear and helpful."
-        prompt = f"{system}\n\nUser: {message}\nAssistant:"
-        model = model_override_val.strip() if model_override_val else HF_MODEL
-        try:
-            ans = hf_text_generate(prompt, model=model, max_new_tokens=int(max_tokens), temperature=float(temperature))
-        except Exception as e:
-            ans = f"[HF error] {e}"
-        history = history or []
-        history.append(("You", message))
-        history.append(("Bot", ans))
-        push_display(f"YOU: {message[:40]}")
-        push_display(f"BOT: {ans[:40]}")
-        return history, ""
-
-    def tts_fn(text, model_override_val):
-        if not text or not text.strip():
-            return None
-        # prefer gTTS (free)
-        try:
-            audio = tts_gtts_bytes(text)
-            return (audio, "audio/mpeg")
-        except Exception as e:
-            raise gr.Error(f"TTS failed: {e}")
-
-    def stt_fn(local_path, model_override_val):
-        if not local_path:
-            return ""
-        with open(local_path, "rb") as f:
-            b = f.read()
-        try:
-            text = hf_stt_from_bytes(b)
-        except Exception as e:
-            raise gr.Error(f"STT failed: {e}")
-        push_display(f"Voice: {text[:40]}")
-        return text
-
-    send.click(chat_fn, inputs=[txt, chatbot, temp, tokens, model_override], outputs=[chatbot, txt])
-    tts_btn.click(tts_fn, inputs=[tts_in, model_override], outputs=[tts_audio])
-    stt_btn.click(stt_fn, inputs=[up, model_override], outputs=[stt_out])
-
-# ====== Expose REST endpoints under same server (Gradio uses FastAPI) ======
-app = demo.app  # FastAPI app
-
-from fastapi import Request, UploadFile, File
-from starlette.responses import JSONResponse, Response
-
-@app.post("/api/ask")
-async def api_ask(request: Request):
-    try:
-        j = await request.json()
-    except Exception:
-        return JSONResponse({"error":"invalid json"}, status_code=400)
-    text = (j.get("text","") or "").strip()
-    lang = (j.get("lang","auto") or "auto").strip().lower()
-    if not text:
-        return JSONResponse({"error":"no text"}, status_code=400)
-    if lang == "vi":
-        prompt = "Bạn là trợ lý thông minh. Trả lời bằng tiếng Việt, rõ ràng:\n\n" + text
-    elif lang == "en":
-        prompt = "You are a helpful assistant. Answer in English:\n\n" + text
+# ====== Background threads startup ======
+def start_background():
+    # Start telegram thread if token exists
+    if TELEGRAM_TOKEN:
+        t = threading.Thread(target=telegram_poll_loop, args=(f"http://127.0.0.1:{PORT}",), daemon=True)
+        t.start()
+        logger.info("Telegram poller started.")
     else:
-        prompt = "You are bilingual assistant (Vietnamese/English). Answer in the language of the question.\n\n" + text
-    try:
-        ans = hf_text_generate(prompt)
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-    CONVERSATION.append((text, ans))
-    push_display(f"YOU: {text[:40]}")
-    push_display(f"BOT: {ans[:40]}")
-    return {"answer": ans}
-
-@app.post("/api/tts")
-async def api_tts(request: Request):
-    try:
-        j = await request.json()
-    except Exception:
-        return JSONResponse({"error":"invalid json"}, status_code=400)
-    text = (j.get("text","") or "").strip()
-    if not text:
-        return JSONResponse({"error":"no text"}, status_code=400)
-    # use gTTS (free)
-    try:
-        mp3 = tts_gtts_bytes(text)
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-    return Response(content=mp3, media_type="audio/mpeg")
-
-@app.post("/api/stt")
-async def api_stt(file: UploadFile = File(...)):
-    try:
-        content = await file.read()
-    except Exception:
-        return JSONResponse({"error":"file read error"}, status_code=400)
-    if not content:
-        return JSONResponse({"error":"no audio content"}, status_code=400)
-    try:
-        text = hf_stt_from_bytes(content)
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-    push_display(f"Voice: {text[:40]}")
-    CONVERSATION.append((f"[voice] {text}", ""))
-    return {"text": text}
-
-@app.post("/api/presence")
-async def api_presence(request: Request):
-    try:
-        j = await request.json()
-    except Exception:
-        return JSONResponse({"error":"invalid json"}, status_code=400)
-    note = (j.get("note","Có người phía trước") or "").strip()
-    greeting = f"Xin chào! {note}"
-    push_display(f"RADAR: {note[:40]}")
-    CONVERSATION.append(("__presence__", greeting))
-    if TELEGRAM_TOKEN and TELEGRAM_CHATID:
-        try:
-            send_telegram(f"⚠️ Robot: Phát hiện người - {note}")
-        except Exception:
-            logger.exception("telegram notify failed")
-    return {"greeting": greeting}
+        logger.info("Telegram not configured.")
 
-@app.get("/api/display")
-async def api_display():
-    return {"lines": DISPLAY_BUFFER.copy(), "conv_len": len(CONVERSATION)}
+# start background when app runs
+@app.before_first_request
+def _startup():
+    start_background()
 
-# ====== Launch app ======
+# ====== run ======
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+    start_background()
+    logger.info(f"Starting server on port {PORT}")
+    app.run(host="0.0.0.0", port=PORT)