initial commit

app.py

@@ -1,664 +1,468 @@
-
-
-# app.py — KC Robot AI v7.5 FINAL (auto-model-select, bilingual, TTS fallback, Telegram, ESP32 endpoints)
-# Secrets expected (HF Space -> Settings -> Secrets):
-#   HF_TOKEN (required)
-#   HF_MODEL (optional preferred model id like "mistralai/Mistral-7B-Instruct-v0.3")
-#   TELEGRAM_TOKEN (optional)
-#   TELEGRAM_CHAT_ID (optional)
-# Optional:
-#   HF_TTS_MODEL, HF_STT_MODEL
-#
-# Minimal deps: flask, requests, gTTS, python-multipart
-# Keep requirements.txt consistent with these packages.
-
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+KCrobot AI — app.py v2.0 MAX FINAL
+- Run on Cloud Run / HuggingFace / local
+- Use Gemini cloud as brain (GEMINI_API_KEY, GEMINI_MODEL)
+- TTS: ElevenLabs -> gTTS fallback
+- Endpoints for ESP32: /api/chat, /api/chat_audio, /play_latest, /notify
+- Save history & usage in data/
+"""
+from __future__ import annotations
 import os
 import io
-import sys
-import time
 import json
-import uuid
+import time
 import logging
-import threading
-from typing import Any, List, Tuple, Optional
-from pathlib import Path
-
-import requests
-from flask import Flask, request, jsonify, Response, render_template_string
-
-# gTTS fallback
+import pathlib
+import tempfile
+import base64
+from typing import Tuple, Optional, Dict, Any
+from datetime import datetime
+from flask import Flask, request, jsonify, send_file, render_template_string
+
+# TTS
+from gtts import gTTS
+
+# Optional Google Generative AI SDK (newer)
+GENAI_IMPORTED = False
+GENAI_CLIENT = None
 try:
-    from gtts import gTTS
-    _HAS_GTTS = True
+    # try new google-genai
+    from google import genai
+    GENAI_IMPORTED = True
+    # we will create client lazily with key
 except Exception:
-    _HAS_GTTS = False
-
-# ---------------- logging ----------------
-logging.basicConfig(stream=sys.stdout, level=logging.INFO,
-                    format="%(asctime)s %(levelname)s %(name)s: %(message)s")
-logger = logging.getLogger("kcrobot.v7.5")
-
-# ---------------- env / secrets ----------------
-HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
-HF_MODEL = os.getenv("HF_MODEL", "auto").strip()           # preferred model (may be empty)
-HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "").strip()   # optional HF 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()
-PORT = int(os.getenv("PORT", 7860))
-
-HF_HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
-
-# ---------------- tmp dir ----------------
-TMPDIR = Path("/tmp/kcrobot") if os.name != "nt" else Path.cwd() / "tmp_kcrobot"
-TMPDIR.mkdir(parents=True, exist_ok=True)
-CONV_LOG = TMPDIR / "conversation_log.jsonl"
-
-# ---------------- in-memory ----------------
-CONVERSATION: List[Tuple[str, str]] = []
-DISPLAY_BUFFER: List[str] = []
-DISPLAY_LIMIT = 6
-
-def push_display(line: str):
-    global DISPLAY_BUFFER
-    DISPLAY_BUFFER.append(line)
-    if len(DISPLAY_BUFFER) > DISPLAY_LIMIT:
-        DISPLAY_BUFFER = DISPLAY_BUFFER[-DISPLAY_LIMIT:]
-
-def save_conv(user: str, bot: str):
     try:
-        with open(CONV_LOG, "a", encoding="utf-8") as f:
-            f.write(json.dumps({"time": time.time(), "user": user, "bot": bot}, ensure_ascii=False) + "\n")
+        # try older google.generativeai for fallback
+        import google.generativeai as genai_old
+        GENAI_IMPORTED = True
     except Exception:
-        logger.exception("save_conv failed")
-
-# ---------------- small helpers ----------------
-def clean_text(text: Any) -> str:
-    if text is None:
-        return ""
-    s = str(text)
-    import re
-    s = re.sub(r'[\x00-\x08\x0b-\x0c\x0e-\x1f]+', ' ', s)
-    s = re.sub(r'\s+', ' ', s).strip()
-    return s
-
-VI_CHARS = set("ăâđêôơưáàảãạắằẳẵặấầẩẫậéèẻẽẹíìỉĩịóòỏõọúùủũụứừửữựýỳỷỹỵ")
-def detect_language(text: str) -> str:
-    t = (text or "").lower()
-    for ch in t:
-        if ch in VI_CHARS:
-            return "vi"
-    return "en"
+        GENAI_IMPORTED = False
 
-# ---------------- Hugging Face HTTP helpers ----------------
-def hf_post_json(model_id: str, payload: dict, timeout: int = 90) -> requests.Response:
-    if not HF_TOKEN:
-        raise RuntimeError("HF_TOKEN not configured in Secrets")
-    url = f"https://api-inference.huggingface.co/models/{model_id}"
-    headers = dict(HF_HEADERS)
-    headers["Content-Type"] = "application/json"
-    return requests.post(url, headers=headers, json=payload, timeout=timeout)
-
-def hf_post_bytes(model_id: str, data: bytes, content_type: str = "application/octet-stream", timeout: int = 180) -> requests.Response:
-    if not HF_TOKEN:
-        raise RuntimeError("HF_TOKEN not configured in Secrets")
-    url = f"https://api-inference.huggingface.co/models/{model_id}"
-    headers = dict(HF_HEADERS)
-    headers["Content-Type"] = content_type
-    return requests.post(url, headers=headers, data=data, timeout=timeout)
+# HTTP
+import requests
 
-def parse_hf_text_output(obj: Any) -> str:
+# Logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("kcrobot_v2")
+
+# -------------------------
+# CONFIG (via ENV / secrets)
+# -------------------------
+ADMIN_TOKEN = os.getenv("ADMIN_TOKEN", "")  # optional: protect admin endpoints if used
+CFG = {
+    "GEMINI_API_KEY": os.getenv("GEMINI_API_KEY", "").strip(),
+    "GEMINI_MODEL": os.getenv("GEMINI_MODEL", "models/gemini-2.5-flash").strip(),
+    "TELEGRAM_TOKEN": os.getenv("TELEGRAM_TOKEN", "").strip(),
+    "TELEGRAM_CHAT_ID": os.getenv("TELEGRAM_CHAT_ID", "").strip(),
+    "ELEVEN_API_KEY": os.getenv("ELEVEN_API_KEY", "").strip(),
+    "ELEVEN_VOICE_ID": os.getenv("ELEVEN_VOICE_ID", "").strip(),
+}
+# Server settings
+PORT = int(os.getenv("PORT", 7860))
+HOST = os.getenv("HOST", "0.0.0.0")
+
+# -------------------------
+# STORAGE & FILES
+# -------------------------
+BASE = pathlib.Path.cwd()
+DATA_DIR = BASE / "data"
+DATA_DIR.mkdir(exist_ok=True)
+HISTORY_FILE = DATA_DIR / "history.json"
+USAGE_FILE = DATA_DIR / "usage.json"
+LATEST_MP3 = DATA_DIR / "latest_reply.mp3"
+
+# -------------------------
+# Helpers: JSON safe
+# -------------------------
+def load_json_safe(path: pathlib.Path, default):
     try:
-        if isinstance(obj, dict):
-            for k in ("generated_text","text","answer"):
-                if k in obj:
-                    return obj.get(k,"")
-            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)
-            return json.dumps(obj, ensure_ascii=False)
-        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)
-        return str(obj)
+        if path.exists():
+            return json.loads(path.read_text(encoding="utf-8"))
     except Exception:
-        logger.exception("parse_hf_text_output")
-        return str(obj)
-
-# ---------------- Auto model finder ----------------
-# Candidate fallback list — you can extend
-DEFAULT_MODEL_CANDIDATES = [
-    "mistralai/Mistral-7B-Instruct-v0.3",
-    "google/gemma-2b-it",
-    "databricks/dolly-v2-3b",
-    "tiiuae/falcon-7b-instruct",     # may be private at times
-    "facebook/blenderbot-400M-distill",
-    # Vietnamese candidates (if public)
-    "vinai/PhoGPT-4B",
-]
+        logger.exception("load_json_safe failed for %s", path)
+    return default
 
-def test_model_working(model_id: str, sample_prompt: str = "Xin chào, bạn khỏe không?") -> Tuple[bool, dict]:
-    """
-    Return (ok, response_short_info)
-    ok True if got status 200 and some textual output parseable
-    """
+def save_json_safe(path: pathlib.Path, data) -> bool:
     try:
-        payload = {"inputs": sample_prompt, "parameters": {"max_new_tokens": 20}, "options": {"wait_for_model": True}}
-        r = hf_post_json(model_id, payload, timeout=30)
-        info = {"status": r.status_code, "text": (r.text[:500] if r.text else "")}
-        if r.status_code == 200:
-            # try parse
-            try:
-                j = r.json()
-                out = parse_hf_text_output(j)
-                if out and len(out.strip())>0:
-                    info["result"] = out
-                    return True, info
-            except Exception:
-                # maybe non-json; if text length present, accept minimally
-                if r.text and len(r.text.strip())>0:
-                    info["result"] = r.text
-                    return True, info
-        return False, info
-    except requests.exceptions.RequestException as e:
-        logger.warning("test_model_working request exception for %s: %s", model_id, e)
-        return False, {"error": str(e)}
+        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        return True
     except Exception:
-        logger.exception("test_model_working unexpected")
-        return False, {"error": "unexpected"}
-
-def auto_select_model(preferred: Optional[str] = None) -> Optional[str]:
-    """
-    Try preferred model first. If fail, iterate DEFAULT_MODEL_CANDIDATES
-    Returns selected model id or None.
-    """
-    tried = []
-    if preferred:
-        logger.info("Auto-check preferred model: %s", preferred)
-        ok, info = test_model_working(preferred)
-        tried.append((preferred, ok, info))
-        if ok:
-            logger.info("Preferred model OK: %s", preferred)
-            return preferred
-    logger.info("Preferred model not usable or not provided, scanning candidates...")
-    for m in DEFAULT_MODEL_CANDIDATES:
-        if m == preferred: 
-            continue
-        logger.info("Testing candidate: %s", m)
-        ok, info = test_model_working(m)
-        tried.append((m, ok, info))
-        if ok:
-            logger.info("Selected fallback model: %s", m)
-            return m
-    # nothing found
-    logger.warning("Auto-select model found none usable. Tried: %s", [(t[0], t[1]) for t in tried])
-    return None
-
-# initial selected model (will be mutated at runtime)
-SELECTED_MODEL = HF_MODEL if HF_MODEL else None
+        logger.exception("save_json_safe failed for %s", path)
+    return False
+
+# -------------------------
+# USAGE & HISTORY
+# -------------------------
+def today_str() -> str:
+    return datetime.utcnow().strftime("%Y-%m-%d")
+
+def load_usage():
+    default = {"date": today_str(), "requests_today": 0, "tokens_month": 0}
+    return load_json_safe(USAGE_FILE, default)
+
+def save_usage(u):
+    return save_json_safe(USAGE_FILE, u)
+
+def increment_usage(tokens=1):
+    u = load_usage()
+    if u.get("date") != today_str():
+        u = {"date": today_str(), "requests_today": 0, "tokens_month": u.get("tokens_month", 0)}
+    u["requests_today"] = u.get("requests_today", 0) + 1
+    u["tokens_month"] = u.get("tokens_month", 0) + int(tokens)
+    save_usage(u)
+
+def append_history(entry: dict):
+    h = load_json_safe(HISTORY_FILE, [])
+    h.append(entry)
+    if len(h) > 1000:
+        h = h[-1000:]
+    save_json_safe(HISTORY_FILE, h)
+
+# -------------------------
+# Language detection (simple)
+# -------------------------
+VIET_CHAR_RE = __import__("re").compile(
+    r"[àáạảãâầấậẩẫăằắặẳẵđèéẹẻẽêềếệểễìíịỉĩòóọỏõôồốộổỗơờớợởỡùúụủũưừứựửữỳýỵỷỹ]",
+    __import__("re").I
+)
+def detect_lang(text: str) -> str:
+    if not text or not isinstance(text, str):
+        return "en"
+    if VIET_CHAR_RE.search(text):
+        return "vi"
+    low = text.lower()
+    en_signs = ["hello", "what", "how", "please", "thank", "today", "weather"]
+    for w in en_signs:
+        if w in low:
+            return "en"
+    return "en"
 
-# ---------------- HF text / stt / tts wrappers using SELECTED_MODEL ----------------
-def hf_text_generate(prompt: str, model_override: Optional[str] = None, max_new_tokens: int = 256, temperature: float = 0.7) -> str:
-    model = model_override or SELECTED_MODEL
-    if not model:
-        raise RuntimeError("No HF model selected")
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": int(max_new_tokens), "temperature": float(temperature)}, "options": {"wait_for_model": True}}
-    r = hf_post_json(model, payload, timeout=120)
-    if r.status_code == 200:
+# -------------------------
+# Gemini wrapper (new client preferred)
+# -------------------------
+def ensure_genai_client():
+    global GENAI_CLIENT
+    if GENAI_CLIENT:
+        return GENAI_CLIENT
+    key = CFG.get("GEMINI_API_KEY") or ""
+    if not key:
+        logger.warning("No GEMINI key configured.")
+        return None
+    try:
+        # new style
         try:
-            j = r.json()
-            return parse_hf_text_output(j)
+            from google import genai as genai_new
+            GENAI_CLIENT = genai_new.Client(api_key=key)
+            logger.info("Gemini client (new) configured.")
+            return GENAI_CLIENT
         except Exception:
-            return r.text
-    elif r.status_code == 403:
-        raise RuntimeError("HF returned 403 (forbidden) — token or access rights issue")
-    elif r.status_code == 404:
-        raise RuntimeError("HF returned 404 (model not found) — check HF_MODEL or model access")
-    else:
-        raise RuntimeError(f"HF text gen returned {r.status_code}: {r.text[:300]}")
-
-def hf_stt_from_bytes(audio_bytes: bytes, model_override: Optional[str] = None) -> str:
-    model = model_override or HF_STT_MODEL
-    if not model:
-        raise RuntimeError("HF_STT_MODEL not configured")
-    r = hf_post_bytes(model, audio_bytes, content_type="application/octet-stream", timeout=180)
-    if r.status_code == 200:
+            pass
+        # older google.generativeai style
         try:
-            j = r.json()
-            if isinstance(j, dict) and "text" in j:
-                return j["text"]
-            return parse_hf_text_output(j)
+            import google.generativeai as genai_old
+            genai_old.configure(api_key=key)
+            GENAI_CLIENT = genai_old
+            logger.info("Gemini client (old) configured.")
+            return GENAI_CLIENT
         except Exception:
-            return r.text
-    else:
-        raise RuntimeError(f"HF STT returned {r.status_code}: {r.text[:300]}")
+            pass
+    except Exception:
+        logger.exception("ensure_genai_client failed")
+    return None
 
-def hf_tts_get_bytes(text: str, model_override: Optional[str] = None) -> bytes:
-    text = text.strip()
-    if not text:
-        raise RuntimeError("TTS text empty")
-    model = model_override or HF_TTS_MODEL
-    if model:
-        # Try HF TTS model first
+def call_gemini(prompt: str, temperature: float = 0.2, max_tokens: int = 512) -> Dict[str, Any]:
+    key = CFG.get("GEMINI_API_KEY") or ""
+    model = CFG.get("GEMINI_MODEL") or "models/gemini-2.5-flash"
+    if not key:
+        return {"ok": False, "error": "Gemini API key not configured"}
+    client = ensure_genai_client()
+    # try SDK client first
+    if client:
         try:
-            payload = {"inputs": text}
-            r = hf_post_json(model, payload, timeout=120)
-            if r.status_code == 200 and r.content:
-                return r.content
-            # fallback to content or parse
-            if r.status_code == 200:
+            # new Client API (genai.Client)
+            if hasattr(client, "models") and hasattr(client.models, "generate_content"):
+                resp = client.models.generate_content(model=model, contents=prompt)
+                # Response may have text attribute
+                text = getattr(resp, "text", None)
+                if text:
+                    return {"ok": True, "text": text}
+                # fallback: try output field
+                if isinstance(resp, dict):
+                    return {"ok": True, "text": json.dumps(resp)[:2000]}
+                return {"ok": True, "text": str(resp)}
+            # older google.generativeai
+            if hasattr(client, "generate_text") or hasattr(client, "generate"):
+                # try older generate_text
                 try:
-                    j = r.json()
-                    return parse_hf_text_output(j).encode("utf-8")
+                    resp = client.generate_text(model=model, prompt=prompt, temperature=temperature)
+                    text = getattr(resp, "text", None) or resp.get("candidates", [{}])[0].get("content", "")
+                    return {"ok": True, "text": text}
                 except Exception:
-                    return r.content
-            logger.warning("HF TTS returned %s: %s", r.status_code, r.text[:200])
-        except Exception:
-            logger.exception("HF TTS call failed")
-    # fallback to gTTS if present
-    if _HAS_GTTS:
-        try:
-            lang = "vi" if detect_language(text) == "vi" else "en"
-            tts = gTTS(text=text, lang=lang)
-            bio = io.BytesIO()
-            tts.write_to_fp(bio)
-            bio.seek(0)
-            return bio.read()
+                    pass
         except Exception:
-            logger.exception("gTTS fallback failed")
-            raise RuntimeError("gTTS fallback failed")
-    raise RuntimeError("No TTS available (no HF_TTS_MODEL and gTTS not installed)")
-
-# ---------------- Telegram helpers ----------------
-def telegram_send_message(chat_id: str, text: str) -> bool:
-    if not TELEGRAM_TOKEN or not chat_id:
-        return False
+            logger.exception("Gemini SDK call failed; will try REST fallback.")
+    # REST fallback (v1beta)
     try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
-        r = requests.post(url, json={"chat_id": chat_id, "text": text}, timeout=8)
-        if r.status_code != 200:
-            logger.warning("Telegram sendMessage failed %s: %s", r.status_code, r.text[:300])
-            return False
-        return True
-    except Exception:
-        logger.exception("telegram_send_message")
-        return False
-
-def telegram_send_audio(chat_id: str, audio_bytes: bytes, filename: str = "reply.mp3") -> bool:
-    if not TELEGRAM_TOKEN or not chat_id:
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generate"
+        headers = {"Content-Type": "application/json"}
+        payload = {
+            "prompt": {
+                "messages": [
+                    {"author": "system", "content": {"text": "You are a helpful assistant."}},
+                    {"author": "user", "content": {"text": prompt}}
+                ]
+            },
+            "maxOutputTokens": max_tokens,
+            "temperature": temperature
+        }
+        r = requests.post(url, params={"key": key}, json=payload, headers=headers, timeout=30)
+        if r.status_code >= 400:
+            return {"ok": False, "error": f"HTTP {r.status_code}: {r.text}"}
+        j = r.json()
+        # parse candidate content
+        cand = j.get("candidates")
+        if cand and isinstance(cand, list):
+            c0 = cand[0]
+            content = c0.get("content")
+            if isinstance(content, list):
+                parts = []
+                for c in content:
+                    if isinstance(c, dict) and "text" in c:
+                        parts.append(c["text"])
+                if parts:
+                    return {"ok": True, "text": "".join(parts)}
+        # fallback to output field
+        output = j.get("output")
+        if isinstance(output, str):
+            return {"ok": True, "text": output}
+        # else return truncated json
+        return {"ok": True, "text": json.dumps(j)[:2000]}
+    except Exception as e:
+        logger.exception("Gemini REST error")
+        return {"ok": False, "error": str(e)}
+
+# -------------------------
+# TTS (ElevenLabs -> gTTS fallback)
+# -------------------------
+def tts_elevenlabs_bytes(text: str, voice_id: str, api_key: str) -> bytes:
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    headers = {"xi-api-key": api_key, "Content-Type": "application/json"}
+    payload = {"text": text, "voice_settings": {"stability": 0.6, "similarity_boost": 0.75}}
+    r = requests.post(url, json=payload, headers=headers, timeout=30)
+    r.raise_for_status()
+    return r.content
+
+def tts_gtts_bytes(text: str, lang: str = "vi") -> bytes:
+    tts = gTTS(text=text, lang=lang)
+    bio = io.BytesIO()
+    tts.write_to_fp(bio)
+    bio.seek(0)
+    return bio.read()
+
+def synthesize_and_save(answer: str, lang_hint: str = "vi") -> Tuple[bool, str]:
+    try:
+        mp3_bytes = None
+        if CFG.get("ELEVEN_API_KEY") and CFG.get("ELEVEN_VOICE_ID"):
+            try:
+                mp3_bytes = tts_elevenlabs_bytes(answer, CFG["ELEVEN_VOICE_ID"], CFG["ELEVEN_API_KEY"])
+                logger.info("TTS: used ElevenLabs")
+            except Exception:
+                logger.exception("ElevenLabs failed -> fallback gTTS")
+                mp3_bytes = None
+        if mp3_bytes is None:
+            lang_code = "vi" if lang_hint.startswith("vi") else "en"
+            mp3_bytes = tts_gtts_bytes(answer, lang=lang_code)
+            logger.info("TTS: used gTTS")
+        with open(LATEST_MP3, "wb") as f:
+            f.write(mp3_bytes)
+        return True, str(LATEST_MP3)
+    except Exception as e:
+        logger.exception("synthesize_and_save failed")
+        return False, f"TTS error: {e}"
+
+# -------------------------
+# Telegram notify
+# -------------------------
+def send_telegram_message(text: str) -> bool:
+    token = CFG.get("TELEGRAM_TOKEN") or ""
+    cid = CFG.get("TELEGRAM_CHAT_ID") or ""
+    if not token or not cid:
+        logger.info("Telegram not configured.")
         return False
     try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendAudio"
-        files = {"audio": (filename, io.BytesIO(audio_bytes), "audio/mpeg")}
-        data = {"chat_id": chat_id}
-        r = requests.post(url, files=files, data=data, timeout=30)
-        if r.status_code != 200:
-            logger.warning("Telegram sendAudio failed %s: %s", r.status_code, r.text[:300])
-            return False
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        requests.post(url, json={"chat_id": cid, "text": text}, timeout=8)
         return True
     except Exception:
-        logger.exception("telegram_send_audio")
+        logger.exception("send_telegram_message failed")
         return False
 
-# ---------------- Telegram poller (background) ----------------
-def telegram_poller_loop():
-    if not TELEGRAM_TOKEN:
-        logger.info("Telegram token not set; poller 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 = str(chat.get("id"))
-                text = (msg.get("text") or "").strip()
-                if not text: continue
-                logger.info("TG msg %s: %s", chat_id, text[:200])
-                lower = text.lower()
-                if lower.startswith("/ask "):
-                    q = text[5:].strip()
-                    try:
-                        ans = hf_text_generate(q)
-                    except Exception as e:
-                        ans = f"[HF error] {e}"
-                    try:
-                        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 = hf_tts_get_bytes(phrase)
-                        telegram_send_audio(chat_id, audio, filename="say.mp3")
-                    except Exception:
-                        logger.exception("tg say failed")
-                elif lower.startswith("/status"):
-                    try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": "KC Robot v7.5 running"}, timeout=10)
-                    except Exception:
-                        pass
-                else:
-                    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 crashed, sleeping 3s")
-            time.sleep(3)
-
-if TELEGRAM_TOKEN:
-    try:
-        t = threading.Thread(target=telegram_poller_loop, daemon=True)
-        t.start()
-    except Exception:
-        logger.exception("start telegram thread failed")
-
-# ---------------- Flask app & endpoints ----------------
+# -------------------------
+# Flask app & UI
+# -------------------------
 app = Flask(__name__)
 
 INDEX_HTML = """
 <!doctype html>
 <html>
-<head>
-  <meta charset="utf-8">
-  <title>KC Robot AI v7.5</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style>
-    body{font-family:Arial,Helvetica,sans-serif;margin:12px;color:#111}
-    .box{max-width:960px;margin:auto}
-    textarea{width:100%;height:90px;padding:10px;font-size:16px;border-radius:8px;border:1px solid #ddd}
-    button{padding:10px 14px;margin:6px 4px;border-radius:8px;background:#0b74de;color:white;border:none;cursor:pointer;font-weight:700}
-    #chat{border:1px solid #eee;padding:10px;height:360px;overflow:auto;background:#fafafa;border-radius:8px}
-    .you{color:#0b63d6;margin:6px 0}
-    .bot{color:#0b8a3f;margin:6px 0}
-    .small{font-size:13px;color:#666}
-  </style>
+<head><meta charset="utf-8"><title>KCrobot AI V2 Max</title>
+<style>
+body{font-family:Arial;background:#071225;color:#fff;padding:20px}
+.container{max-width:900px;margin:0 auto}
+textarea{width:100%;padding:10px;border-radius:8px;background:#0b1221;color:#fff;border:1px solid #134}
+button{padding:10px 14px;border-radius:8px;background:#0ea5ff;color:#012;border:none;cursor:pointer}
+#resp{white-space:pre-wrap;margin-top:12px;background:#071025;padding:10px;border-radius:6px}
+audio{margin-top:12px}
+.small{font-size:0.9rem;color:#9fb3c8}
+</style>
 </head>
 <body>
-  <div class="box">
-    <h2>🤖 KC Robot AI v7.5 — Final (Auto-model)</h2>
-    <div class="small">Model: <span id="modelName">loading...</span> | Telegram: <span id="tgstatus">checking...</span></div>
-    <textarea id="userText" placeholder="Nhập tiếng Việt hoặc English..."></textarea>
-    <div>
-      <select id="lang"><option value="auto">Auto</option><option value="vi">Vietnamese</option><option value="en">English</option></select>
-      <button onclick="send()">Gửi</button>
-      <button onclick="playLast()">Phát âm</button>
-      <button onclick="clearChat()">Xóa</button>
-    </div>
-    <div id="chat"></div>
-    <div style="margin-top:10px">
-      <input type="file" id="afile" accept="audio/*"><button onclick="uploadAudio()">Upload → STT</button>
-    </div>
-    <hr>
-    <div class="small">Diagnostics: <button onclick="modelCheck()">Kiểm tra model</button><span id="diag"></span></div>
-  </div>
+<div class="container">
+<h1>🤖 KCrobot AI — V2 MAX</h1>
+<p class="small">Model: {{model}} — Gemini Key: {{gemini}} — Telegram: {{tg}}</p>
+<textarea id="q" rows="4" placeholder="Nhập tiếng Việt / English..."></textarea>
+<p>
+<label><input id="voice" type="checkbox" checked> Voice ON</label>
+<button onclick="send()">Gửi & Nghe</button>
+</p>
+<div id="resp"></div>
+<audio id="audio" controls style="display:none"></audio>
 <script>
-let lastAnswer = "";
-async function loadStatus(){ try{ let r=await fetch('/health'); let j=await r.json(); document.getElementById('modelName').innerText=j.hf_model||'(not set)'; document.getElementById('tgstatus').innerText=j.telegram ? 'enabled' : 'disabled'; }catch(e){ console.log(e); } }
-function escapeHtml(s){ return (s+'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
-function appendYou(t){ document.getElementById('chat').innerHTML += '<div class="you"><b>You:</b> '+escapeHtml(t)+'</div>'; scroll(); }
-function appendBot(t){ document.getElementById('chat').innerHTML += '<div class="bot"><b>Robot:</b> '+escapeHtml(t)+'</div>'; scroll(); }
-function scroll(){ let c=document.getElementById('chat'); c.scrollTop = c.scrollHeight; }
 async function send(){
-  let t=document.getElementById('userText').value.trim(); if(!t) return; appendYou(t); document.getElementById('userText').value='';
-  let lang=document.getElementById('lang').value;
-  try{
-    let r=await fetch('/ask',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({text:t,lang:lang})});
-    let j=await r.json();
-    if(j.answer){ lastAnswer=j.answer; appendBot(j.answer); } else appendBot('[error] '+JSON.stringify(j));
-  }catch(e){ appendBot('[network error] '+e); }
+  const q = document.getElementById('q').value;
+  const voice = document.getElementById('voice').checked;
+  if(!q){ alert('Nhập nội dung'); return; }
+  document.getElementById('resp').innerText = '⏳ Đang xử lý...';
+  const res = await fetch('/api/chat', {
+    method: 'POST', headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({q: q, voice: voice})
+  });
+  const j = await res.json();
+  if(j.error){ document.getElementById('resp').innerText = 'Error: ' + j.error; return; }
+  document.getElementById('resp').innerText = j.answer;
+  if(j.play_url){
+    const audio = document.getElementById('audio');
+    audio.src = j.play_url + '?t=' + Date.now();
+    audio.style.display='block';
+    audio.play();
+  }
 }
-async function playLast(){
-  if(!lastAnswer) return alert('Chưa có câu trả lời');
-  try{
-    let r=await fetch('/tts',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({text:lastAnswer})});
-    if(!r.ok){ alert('TTS lỗi'); return; }
-    const blob = await r.blob();
-    const url=URL.createObjectURL(blob);
-    const audio=new Audio(url); audio.play();
-  }catch(e){ alert('Play error: '+e); }
-}
-async function uploadAudio(){
-  const f=document.getElementById('afile').files[0]; if(!f) return alert('Chọn file audio');
-  const fd=new FormData(); fd.append('file', f);
-  const r=await fetch('/stt',{method:'POST', body: fd});
-  const j=await r.json();
-  if(j.text){ appendYou('[voice] '+j.text); } else appendYou('[stt error] '+JSON.stringify(j));
-}
-function clearChat(){ document.getElementById('chat').innerHTML=''; lastAnswer=''; }
-async function modelCheck(){
-  document.getElementById('diag').innerText=' checking...';
-  try{
-    let r=await fetch('/model_check');
-    let j=await r.json();
-    document.getElementById('diag').innerText = ' ' + JSON.stringify(j).slice(0,200);
-    loadStatus();
-  }catch(e){ document.getElementById('diag').innerText=' error'; }
-}
-loadStatus();
 </script>
+</div>
 </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": SELECTED_MODEL or HF_MODEL or "",
-        "hf_tts_model": HF_TTS_MODEL,
-        "hf_stt_model": HF_STT_MODEL,
-        "telegram": bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID),
-        "conv_len": len(CONVERSATION),
-        "display_len": len(DISPLAY_BUFFER)
-    })
-
-@app.route("/ask", methods=["POST"])
-def route_ask():
-    try:
-        j = request.get_json(force=True) or {}
-        text = clean_text(j.get("text","") or "")
-        lang = (j.get("lang","auto") or "auto")
-        if not text:
-            return jsonify({"error":"no text"}), 400
-        if lang == "vi":
-            prompt = f"Bạn là trợ lý thông minh, trả lời bằng tiếng Việt, rõ ràng và ngắn gọn:\n\n{text}"
-        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 (Vietnamese/English). Answer in the same language as the user, clearly and concisely:\n\n{text}"
-        try:
-            ans = hf_text_generate(prompt)
-        except Exception as e:
-            logger.exception("hf_text_generate failed")
-            return jsonify({"error": str(e)}), 500
-        CONVERSATION.append((text, ans))
-        save_conv(text, ans)
-        push_display("YOU: " + (text[:60]))
-        push_display("BOT: " + (ans[:60] if isinstance(ans,str) else str(ans)[:60]))
-        # notify telegram
-        if TELEGRAM_TOKEN and TELEGRAM_CHAT_ID:
-            try:
-                telegram_send_message(TELEGRAM_CHAT_ID, 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 exception")
-        return jsonify({"error": str(e)}), 500
-
-@app.route("/tts", methods=["POST"])
-def route_tts():
-    try:
-        j = request.get_json(force=True) or {}
-        text = clean_text(j.get("text","") or "")
-        if not text:
-            return jsonify({"error":"no text"}), 400
-        try:
-            audio_bytes = hf_tts_get_bytes(text)
-        except Exception as e:
-            logger.exception("tts generation failed")
-            return jsonify({"error": str(e)}), 500
-        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 = hf_stt_from_bytes(audio_bytes)
-        except Exception as e:
-            logger.exception("STT failed")
-            return jsonify({"error": str(e)}), 500
-        CONVERSATION.append((f"[voice] {txt}", ""))
-        save_conv(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():
-    """
-    ESP32 radar should POST JSON {"note":"..."}.
-    Server returns greeting audio (if TTS available) or JSON greeting.
-    Also sends telegram notification if configured.
-    """
-    try:
-        j = request.get_json(force=True) or {}
-        note = clean_text(j.get("note","Có người phía trước") or "Có người phía trước")
-        greeting = f"Xin chào! {note}"
-        CONVERSATION.append(("__presence__", greeting))
-        save_conv("__presence__", greeting)
-        push_display("RADAR: " + note[:60])
-        if TELEGRAM_TOKEN and TELEGRAM_CHAT_ID:
-            try:
-                telegram_send_message(TELEGRAM_CHAT_ID, f"⚠️ Robot: Phát hiện người - {note}")
-            except Exception:
-                logger.exception("telegram notify failed")
-        try:
-            audio_bytes = hf_tts_get_bytes(greeting)
-            return Response(audio_bytes, mimetype="audio/mpeg")
-        except Exception:
-            return jsonify({"greeting": greeting})
-    except Exception as e:
-        logger.exception("route_presence exception")
-        return jsonify({"error": str(e)}), 500
-
-@app.route("/display", methods=["GET"])
-def route_display():
-    return jsonify({"lines": DISPLAY_BUFFER.copy(), "conv_len": len(CONVERSATION)})
-
-@app.route("/model_check", methods=["GET"])
-def model_check():
-    """
-    Attempt to verify HF_MODEL / select fallback, returns diagnostic JSON.
-    """
-    global SELECTED_MODEL
-    # first try current HF_MODEL
-    results = {}
-    try:
-        # if SELECTED_MODEL already set and seems good, return
-        if SELECTED_MODEL:
-            results["selected_model"] = SELECTED_MODEL
-            ok, info = test_model_working(SELECTED_MODEL)
-            results["selected_ok"] = ok
-            results["selected_info"] = info
-            return jsonify(results)
-        # else try auto-select with preference HF_MODEL
-        chosen = auto_select_model(HF_MODEL if HF_MODEL else None)
-        if chosen:
-            SELECTED_MODEL = chosen
-            results["selected_model"] = chosen
-            results["note"] = "Model selected"
-            return jsonify(results)
-        else:
-            results["error"] = "No usable model found in candidates"
-            return jsonify(results), 404
-    except Exception as e:
-        logger.exception("model_check failed")
-        return jsonify({"error": str(e)}), 500
-
-@app.route("/config", methods=["GET","POST"])
-def config():
-    """
-    GET returns current config.
-    POST JSON can change HF_MODEL / HF_TTS_MODEL / HF_STT_MODEL at runtime (temporary).
-    Example: {"hf_model":"...", "hf_tts_model":"..."}
-    """
-    global HF_MODEL, HF_TTS_MODEL, HF_STT_MODEL, SELECTED_MODEL
-    if request.method == "GET":
-        return jsonify({"hf_model": HF_MODEL, "hf_tts_model": HF_TTS_MODEL, "hf_stt_model": HF_STT_MODEL, "selected_model": SELECTED_MODEL})
+def root():
+    model = CFG.get("GEMINI_MODEL","n/a")
+    gem = bool(CFG.get("GEMINI_API_KEY"))
+    tg = bool(CFG.get("TELEGRAM_TOKEN") and CFG.get("TELEGRAM_CHAT_ID"))
+    return render_template_string(INDEX_HTML, model=model, gemini=("✅" if gem else "❌"), tg=("✅" if tg else "❌"))
+
+@app.route("/api/chat", methods=["POST"])
+def api_chat():
+    data = request.get_json(silent=True) or {}
+    q = data.get("q") or data.get("question") or ""
+    voice_on = bool(data.get("voice", True))
+    if not q or not str(q).strip():
+        return jsonify({"error":"missing 'q'"}), 400
+    lang = detect_lang(q)
+    prompt = (f"Bạn là robot trợ lý, trả lời bằng tiếng Việt tự nhiên: {q}" if lang=="vi"
+              else f"You are a helpful assistant. Answer in natural English: {q}")
+    gem = call_gemini(prompt)
+    if not gem.get("ok"):
+        answer = f"[Gemini error] {gem.get('error')}"
+    else:
+        answer = gem.get("text","")
+    increment_usage(max(1, len(answer.split())))
+    append_history({"ts": time.time(), "q": q, "answer": answer, "lang": lang})
+    play_url = None
+    if voice_on:
+        ok, path_or_err = synthesize_and_save(answer, lang_hint=lang)
+        if ok:
+            play_url = "/play_latest"
+    # Telegram notify in background
     try:
-        j = request.get_json(force=True) or {}
-        changed = {}
-        if "hf_model" in j:
-            HF_MODEL = j["hf_model"]
-            changed["hf_model"] = HF_MODEL
-            SELECTED_MODEL = None  # force re-evaluation
-        if "hf_tts_model" in j:
-            HF_TTS_MODEL = j["hf_tts_model"]
-            changed["hf_tts_model"] = HF_TTS_MODEL
-        if "hf_stt_model" in j:
-            HF_STT_MODEL = j["hf_stt_model"]
-            changed["hf_stt_model"] = HF_STT_MODEL
-        return jsonify({"changed": changed})
-    except Exception as e:
-        logger.exception("config post failed")
-        return jsonify({"error": str(e)}), 500
-
-# ---------------- startup auto model selection ----------------
-def startup_model_check():
-    global SELECTED_MODEL
-    logger.info("Startup: checking/selecting model...")
+        # keep simple: send summary
+        if CFG.get("TELEGRAM_TOKEN") and CFG.get("TELEGRAM_CHAT_ID"):
+            # non-blocking
+            import threading
+            threading.Thread(target=send_telegram_message, args=(f"Q: {q}\nA: {answer}",)).start()
+    except Exception:
+        pass
+    resp = {"answer": answer}
+    if play_url:
+        resp["play_url"] = play_url
+    return jsonify(resp)
+
+@app.route("/api/chat_audio", methods=["POST"])
+def api_chat_audio():
+    # Accept wav upload as raw body or file named 'file'
+    wav_bytes = None
+    if 'file' in request.files:
+        wav_bytes = request.files['file'].read()
+    else:
+        wav_bytes = request.get_data()
+    if not wav_bytes:
+        return jsonify({"error":"no audio provided"}),400
+    # If client provides X-Text header (pre-transcribed text), use it
+    provided_text = request.headers.get("X-Text","")
+    if provided_text:
+        q = provided_text
+    else:
+        # Server STT not implemented in this build
+        return jsonify({"error":"STT not enabled on server. Please send text or add STT implementation."}), 501
+    lang = detect_lang(q)
+    prompt = (f"Bạn là robot trợ lý, trả lời bằng tiếng Việt tự nhiên: {q}" if lang=="vi"
+              else f"You are a helpful assistant. Answer in natural English: {q}")
+    gem = call_gemini(prompt)
+    if not gem.get("ok"):
+        answer = f"[Gemini error] {gem.get('error')}"
+    else:
+        answer = gem.get("text","")
+    append_history({"ts": time.time(), "q": q, "answer": answer, "lang": lang})
+    ok, path_or_err = synthesize_and_save(answer, lang_hint=lang)
+    if ok:
+        return jsonify({"question": q, "answer": answer, "play_url": "/play_latest"})
+    return jsonify({"error":"tts_failed", "details": path_or_err}), 500
+
+@app.route("/play_latest", methods=["GET"])
+def play_latest():
+    if not LATEST_MP3.exists():
+        return jsonify({"error":"no audio"}), 404
+    return send_file(str(LATEST_MP3), mimetype="audio/mpeg")
+
+@app.route("/notify", methods=["POST"])
+def notify():
+    data = request.get_json(silent=True) or {}
+    event = data.get("event","event")
+    msg = data.get("msg","")
     try:
-        chosen = auto_select_model(HF_MODEL if HF_MODEL else None)
-        if chosen:
-            SELECTED_MODEL = chosen
-            logger.info("Startup: selected model = %s", SELECTED_MODEL)
-        else:
-            logger.warning("Startup: no usable HF model found yet. Use /model_check or set HF_MODEL secret.")
+        import threading
+        threading.Thread(target=send_telegram_message, args=(f"[Robot Notify] {event}: {msg}",)).start()
     except Exception:
-        logger.exception("startup_model_check failed")
-
-# run startup check in a thread so Flask starts quickly
-t_start = threading.Thread(target=startup_model_check, daemon=True)
-t_start.start()
+        pass
+    return jsonify({"sent": True})
 
-# ---------------- run app ----------------
-if __name__ == "__main__":
-    logger.info("KC Robot AI v7.5 starting. PREF_HF_MODEL=%s HF_TTS=%s HF_STT=%s Telegram=%s",
-                HF_MODEL or "(none)", HF_TTS_MODEL or "(none)", HF_STT_MODEL or "(none)", bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID))
-    app.run(host="0.0.0.0", port=PORT)
+@app.route("/history", methods=["GET"])
+def history():
+    h = load_json_safe(HISTORY_FILE, [])
+    return jsonify(h)
 
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"status":"ok","time":time.time(),"model":CFG.get("GEMINI_MODEL","n/a")})
 
+# -------------------------
+# Startup
+# -------------------------
+if __name__ == "__main__":
+    # ensure history/usage exist
+    load_json_safe(HISTORY_FILE, [])
+    load_usage()
+    logger.info("KCrobot v2 starting. Gemini: %s, Eleven: %s, Telegram: %s",
+                bool(CFG.get("GEMINI_API_KEY")), bool(CFG.get("ELEVEN_API_KEY")), bool(CFG.get("TELEGRAM_TOKEN")))
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))