update

app.py

@@ -1,468 +1,398 @@
 #!/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
+# KC ROBOT AI - app.py (Tâm hồn) v3.0MAX PRO
+# - Accepts audio uploads (/api/audio) or text (/api/chat)
+# - STT via SpeechRecognition (Google Web Speech) for short WAV
+# - Calls Gemini (if API key provided) to generate reply
+# - Cleans reply (remove punctuation/emoji) before TTS
+# - Synthesizes MP3 via gTTS and serves via /tts-file/<id>
+# - device command queue: /device/commands (ESP32 polls)
+# - forwards sensor events to Telegram via /api/sensor or /api/forward-telegram
 import os
-import io
-import json
-import time
-import logging
-import pathlib
+import re
+import uuid
+import shutil
+import traceback
 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
+from pathlib import Path
+from flask import Flask, request, jsonify, send_file, abort
+from dotenv import load_dotenv
 
 # TTS
 from gtts import gTTS
-
-# Optional Google Generative AI SDK (newer)
-GENAI_IMPORTED = False
-GENAI_CLIENT = None
+# STT
+import speech_recognition as sr
+# AI client (optional)
 try:
-    # try new google-genai
     from google import genai
-    GENAI_IMPORTED = True
-    # we will create client lazily with key
 except Exception:
-    try:
-        # try older google.generativeai for fallback
-        import google.generativeai as genai_old
-        GENAI_IMPORTED = True
-    except Exception:
-        GENAI_IMPORTED = False
+    genai = None
 
 # HTTP
 import requests
 
-# 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 path.exists():
-            return json.loads(path.read_text(encoding="utf-8"))
-    except Exception:
-        logger.exception("load_json_safe failed for %s", path)
-    return default
+load_dotenv()
+
+# Config
+GEMINI_API_KEY_ENV = os.getenv("GEMINI_API_KEY", "")
+GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
+TELEGRAM_TOKEN_ENV = os.getenv("TELEGRAM_TOKEN", "")
+TELEGRAM_CHAT_ID_ENV = os.getenv("TELEGRAM_CHAT_ID", "")
+PORT = int(os.getenv("PORT", "8080"))
 
-def save_json_safe(path: pathlib.Path, data) -> bool:
+TMP_DIR = Path("/tmp/kcrobot_audio")
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+
+app = Flask(__name__)
+
+# Initialize Gemini client if available
+gemini_client = None
+if GEMINI_API_KEY_ENV and genai is not None:
     try:
-        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-        return True
-    except Exception:
-        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
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY_ENV)
+    except Exception as e:
+        print("Gemini init error:", e)
+        gemini_client = None
+
+# In-memory commands queue per device_id (simple)
+DEVICE_COMMANDS = {}  # device_id -> [ {cmd}, ... ]
+
+# Regex / utils for cleaning text (remove punctuation/emoji/digits)
+_EMOJI_RE = re.compile(
+    "[" 
+    "\U0001F600-\U0001F64F"
+    "\U0001F300-\U0001F5FF"
+    "\U0001F680-\U0001F6FF"
+    "\U00002600-\U000026FF"
+    "\U00002700-\U000027BF"
+    "\U0001F1E6-\U0001F1FF"
+    "]+", flags=re.UNICODE
 )
-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"
-
-# -------------------------
-# 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
+
+_PUNCT_WORDS = [
+    r"\bdấu\s*chấm\b", r"\bchấm\b",
+    r"\bdấu\s*phẩy\b", r"\bphẩy\b", r"\bphay\b",
+    r"\bdấu\s*sao\b", r"\bsao\b",
+    r"\bdấu\s*hỏi\b", r"\bhỏi\b",
+    r"\bdấu\s*hai\s*chấm\b", r"\bcomma\b", r"\bdot\b", r"\bperiod\b"
+]
+
+def clean_text_keep_letters(text: str) -> str:
+    if not text:
+        return ""
+    t = str(text)
+    for p in _PUNCT_WORDS:
+        t = re.sub(p, " ", t, flags=re.IGNORECASE)
+    t = _EMOJI_RE.sub(" ", t)
+    # keep letters (including Vietnamese range) and spaces
+    t = re.sub(r"[^A-Za-zÀ-ỹ\s]", " ", t)
+    t = re.sub(r"\s+", " ", t).strip()
+    return t
+
+def detect_language(text: str) -> str:
     try:
-        # new style
-        try:
-            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:
-            pass
-        # older google.generativeai style
+        # use simple heuristic: if contains Vietnamese diacritics -> vi
+        if re.search(r"[àáảãạăắằẳẵặâầấẩẫậđèéẻẽẹêềếểễệìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹỵ]", text, flags=re.IGNORECASE):
+            return "vi"
+        # fallback to langdetect if installed
         try:
-            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
+            from langdetect import detect
+            return detect(text)
         except Exception:
-            pass
+            return "en"
     except Exception:
-        logger.exception("ensure_genai_client failed")
-    return None
-
-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:
+        return "en"
+
+def call_gemini(prompt: str, api_key_override: str = None) -> str:
+    """
+    Call Gemini to generate reply. If no Gemini client available, return fallback message.
+    """
+    client = None
+    if api_key_override and genai is not None:
         try:
-            # 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:
-                    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:
-                    pass
-        except Exception:
-            logger.exception("Gemini SDK call failed; will try REST fallback.")
-    # REST fallback (v1beta)
-    try:
-        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]:
+            client = genai.Client(api_key=api_key_override)
+        except Exception as e:
+            print("Gemini override init error:", e)
+            client = None
+    elif gemini_client:
+        client = gemini_client
+
+    if client is None:
+        # fallback: simple echo or canned responses
+        # Keep it useful: return acknowledgement and simple help
+        return "Xin chào! Mình là KCrobot. (Gemini chưa cấu hình trên server.)"
+
     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)
+        response = client.models.generate_content(model=GEMINI_MODEL, contents=prompt)
+        if hasattr(response, "text"):
+            return response.text.strip()
+        if isinstance(response, dict) and "text" in response:
+            return response["text"].strip()
+        return str(response)
     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
+        traceback.print_exc()
+        return f"⚠️ Gemini error: {e}"
+
+def synthesize_to_mp3_file(text: str, lang_hint: str = None) -> Path:
+    cleaned = clean_text_keep_letters(text)
+    if not cleaned:
+        raise ValueError("No text to synthesize after cleaning.")
+    # detect lang
+    lang = "en"
     try:
-        url = f"https://api.telegram.org/bot{token}/sendMessage"
-        requests.post(url, json={"chat_id": cid, "text": text}, timeout=8)
-        return True
+        if lang_hint:
+            lang = lang_hint
+        else:
+            lg = detect_language(cleaned)
+            lang = "vi" if lg.startswith("vi") else "en"
     except Exception:
-        logger.exception("send_telegram_message failed")
-        return False
+        lang = "en"
+    file_path = TMP_DIR / f"{uuid.uuid4().hex}.mp3"
+    tts = gTTS(text=cleaned, lang=lang)
+    tts.save(str(file_path))
+    return file_path
 
-# -------------------------
-# Flask app & UI
-# -------------------------
-app = Flask(__name__)
+def transcribe_wav_file(path: Path) -> str:
+    r = sr.Recognizer()
+    with sr.AudioFile(str(path)) as source:
+        audio = r.record(source)
+    try:
+        # Use Google's free web speech API (requires internet, short audio)
+        text = r.recognize_google(audio, language="vi-VN") if detect_language(source= None) == "vi" else r.recognize_google(audio)
+        # Note: language param detection is heuristic above, but recognize_google fallback works reasonably
+        return text
+    except sr.UnknownValueError:
+        return ""
+    except Exception as e:
+        print("STT error:", e)
+        return ""
 
-INDEX_HTML = """
-<!doctype html>
-<html>
-<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="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>
-async function send(){
-  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();
-  }
-}
-</script>
-</div>
-</body>
-</html>
-"""
+# Utility to save uploaded file bytes to temp wav path
+def save_upload_to_tempwav(file_storage) -> Path:
+    tmp = TMP_DIR / f"{uuid.uuid4().hex}.wav"
+    file_storage.save(str(tmp))
+    return tmp
 
+# endpoint: health
 @app.route("/", methods=["GET"])
-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 "❌"))
+def index():
+    return {"status":"KCrobot AI mind running", "gemini_configured": bool(gemini_client is not None)}
+
+# endpoint: receive raw audio file from ESP32 (multipart/form-data name="file")
+# server will STT -> call Gemini -> synthesize TTS -> return reply & audio_url
+@app.route("/api/audio", methods=["POST"])
+def api_audio():
+    try:
+        if 'file' not in request.files:
+            return jsonify({"error":"missing file field"}), 400
+        f = request.files['file']
+        # save to temp
+        wav_path = save_upload_to_tempwav(f)
+        # optionally convert with pydub if not proper format (here assume WAV 16k/16bit)
+        # transcribe
+        transcript = ""
+        try:
+            r = sr.Recognizer()
+            with sr.AudioFile(str(wav_path)) as source:
+                audio = r.record(source)
+            # try Vietnamese first, then english
+            try:
+                transcript = r.recognize_google(audio, language="vi-VN")
+            except Exception:
+                try:
+                    transcript = r.recognize_google(audio, language="en-US")
+                except Exception:
+                    transcript = ""
+        except Exception as e:
+            print("STT pipeline error:", e)
+            transcript = ""
+
+        # choose msg for Gemini: if no transcript, fallback to asking generic
+        if not transcript:
+            return jsonify({"error":"could not transcribe audio"}), 200
+
+        # optional: gemini key may be passed in payload
+        gemini_key = request.form.get("gemini_api_key") or request.json.get("gemini_api_key") if request.is_json else None
 
+        reply = call_gemini(transcript, api_key_override=gemini_key)
+        # parse relay commands from reply (simple)
+        commands = parse_relay_commands(reply)
+
+        # synthesize tts and return audio_url
+        try:
+            tts_file = synthesize_to_mp3_file(reply)
+            file_id = tts_file.stem
+            base = request.url_root.rstrip("/")
+            audio_url = f"{base}/tts-file/{file_id}"
+        except Exception as e:
+            print("TTS error:", e)
+            audio_url = ""
+
+        # cleanup uploaded wav
+        try:
+            wav_path.unlink()
+        except Exception:
+            pass
+
+        # if any device commands detected, push to DEVICE_COMMANDS queue
+        if commands:
+            device_id = request.form.get("device_id") or "esp32_default"
+            DEVICE_COMMANDS.setdefault(device_id, []).extend(commands)
+
+        return jsonify({"reply": reply, "clean_text": clean_text_keep_letters(reply), "audio_url": audio_url, "commands": commands}), 200
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+# endpoint: accept text and return reply + audio_url
 @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:
-        # 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","")
+        data = request.get_json(force=True, silent=True) or {}
+        msg = data.get("message", "") or ""
+        if not msg:
+            return jsonify({"error":"missing message"}), 400
+        gemini_key = data.get("gemini_api_key") or None
+        reply = call_gemini(msg, api_key_override=gemini_key)
+        commands = parse_relay_commands(reply)
+        if commands:
+            device_id = data.get("device_id") or "esp32_default"
+            DEVICE_COMMANDS.setdefault(device_id, []).extend(commands)
+        # synthesize
+        try:
+            mp3path = synthesize_to_mp3_file(reply)
+            audio_url = request.url_root.rstrip("/") + f"/tts-file/{mp3path.stem}"
+        except Exception as e:
+            print("TTS fail:", e)
+            audio_url = ""
+        return jsonify({"reply": reply, "clean_text": clean_text_keep_letters(reply), "audio_url": audio_url, "commands": commands})
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+# serve mp3
+@app.route("/tts-file/<file_id>", methods=["GET"])
+def tts_file(file_id):
+    target = None
+    for f in TMP_DIR.iterdir():
+        if f.is_file() and f.stem == file_id:
+            target = f
+            break
+    if not target:
+        return abort(404)
+    return send_file(str(target), mimetype="audio/mpeg")
+
+# sensor forwarding -> telegram
+@app.route("/api/sensor", methods=["POST"])
+def api_sensor():
     try:
-        import threading
-        threading.Thread(target=send_telegram_message, args=(f"[Robot Notify] {event}: {msg}",)).start()
-    except Exception:
-        pass
-    return jsonify({"sent": True})
+        data = request.get_json(force=True, silent=True) or {}
+        text = data.get("text") or f"Sensor event: {data}"
+        token = data.get("telegram_token") or TELEGRAM_TOKEN_ENV
+        chat = data.get("telegram_chat_id") or TELEGRAM_CHAT_ID_ENV
+        if token and chat:
+            try:
+                requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
+                              json={"chat_id": chat, "text": text}, timeout=6)
+            except Exception as e:
+                print("Telegram send error:", e)
+        return jsonify({"status":"ok"})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# forward telegram (ESP32 can call to avoid exposing token)
+@app.route("/api/forward-telegram", methods=["POST"])
+def api_forward_telegram():
+    try:
+        payload = request.get_json(force=True, silent=True) or {}
+        token = payload.get("token") or TELEGRAM_TOKEN_ENV
+        chat = payload.get("chat_id") or TELEGRAM_CHAT_ID_ENV
+        text = payload.get("text", "")
+        if not token or not chat or not text:
+            return jsonify({"error":"missing token/chat/text"}), 400
+        r = requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
+                          json={"chat_id": chat, "text": text}, timeout=6)
+        return jsonify({"ok": r.ok, "resp": r.text})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# device polls for commands (ESP32 calls periodically)
+@app.route("/device/commands", methods=["GET"])
+def device_commands_get():
+    device_id = request.args.get("device_id", "esp32_default")
+    cmds = DEVICE_COMMANDS.get(device_id, [])
+    # return and clear queue
+    DEVICE_COMMANDS[device_id] = []
+    return jsonify({"commands": cmds})
 
-@app.route("/history", methods=["GET"])
-def history():
-    h = load_json_safe(HISTORY_FILE, [])
-    return jsonify(h)
+# simple admin endpoint to add a command to device queue (for testing)
+@app.route("/device/commands", methods=["POST"])
+def device_commands_post():
+    data = request.get_json(force=True, silent=True) or {}
+    device_id = data.get("device_id", "esp32_default")
+    cmd = data.get("command")
+    if not cmd:
+        return jsonify({"error":"missing command"}), 400
+    DEVICE_COMMANDS.setdefault(device_id, []).append(cmd)
+    return jsonify({"status":"queued", "device_id": device_id, "command": cmd})
+
+# utility: parse relay commands from text (basic heuristic)
+def parse_relay_commands(text: str):
+    """
+    Return list of commands like {"type":"relay","relay":1,"action":"on"}
+    Supports Vietnamese and English simple phrases:
+      - 'bật đèn 1', 'tắt đèn 2'
+      - 'turn on relay 1', 'turn off relay2'
+    """
+    cmds = []
+    t = text.lower()
+    # vietnamese on/off
+    m_on = re.findall(r"\b(bật|mở)\s+(?:đèn|relay)?\s*(\d+)", t)
+    m_off = re.findall(r"\b(tắt|đóng)\s+(?:đèn|relay)?\s*(\d+)", t)
+    for m in m_on:
+        try:
+            rnum = int(m[1])
+            cmds.append({"type":"relay","relay": rnum, "action":"on"})
+        except:
+            pass
+    for m in m_off:
+        try:
+            rnum = int(m[1])
+            cmds.append({"type":"relay","relay": rnum, "action":"off"})
+        except:
+            pass
+    # english
+    mon = re.findall(r"\bturn\s+on\s+(?:relay|light)?\s*(\d+)", t)
+    moff = re.findall(r"\bturn\s+off\s+(?:relay|light)?\s*(\d+)", t)
+    for m in mon:
+        try:
+            rnum = int(m)
+            cmds.append({"type":"relay","relay": rnum, "action":"on"})
+        except:
+            pass
+    for m in moff:
+        try:
+            rnum = int(m)
+            cmds.append({"type":"relay","relay": rnum, "action":"off"})
+        except:
+            pass
+    return cmds
 
-@app.route("/health", methods=["GET"])
-def health():
-    return jsonify({"status":"ok","time":time.time(),"model":CFG.get("GEMINI_MODEL","n/a")})
+# cleanup temp files older than TTL seconds
+@app.route("/_cleanup_tmp", methods=["POST"])
+def cleanup_tmp():
+    data = request.get_json(force=True, silent=True) or {}
+    ttl = int(data.get("ttl", 3600))
+    now = __import__('time').time()
+    removed = 0
+    for f in TMP_DIR.iterdir():
+        try:
+            if f.is_file() and (f.stat().st_mtime + ttl) < now:
+                f.unlink()
+                removed += 1
+        except Exception:
+            pass
+    return {"removed": removed}
 
-# -------------------------
-# 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)))
+    app.run(host="0.0.0.0", port=PORT)