initial commit

app.py

@@ -1,88 +1,57 @@
 
 # app.py — KC Robot AI V7.4 MAX FINAL
-# 2025 — Final build for ESP32 robot brain (Hugging Face inference + Telegram + Flask UI)
-#
-# REQUIRED Secrets / Environment variables:
-#   HF_TOKEN         -> Hugging Face API token (read/write ideally)
-#   HF_MODEL         -> Model id (e.g. kcrobot40/kc40ai or mistralai/Mistral-7B-Instruct-v0.3)
-#   TELEGRAM_TOKEN   -> Telegram bot token (optional but recommended)
-#   TELEGRAM_CHAT_ID -> Telegram chat id (optional)
+# Flask + Hugging Face inference + gTTS fallback + Telegram poller + ESP32 endpoints
+# Secrets expected (in HF Space Settings -> Secrets):
+#   HF_TOKEN, HF_MODEL, TELEGRAM_TOKEN (optional), TELEGRAM_CHAT_ID (optional)
 # Optional:
-#   HF_TTS_MODEL     -> HF TTS model id (if available)
-#   HF_STT_MODEL     -> HF STT model id (default openai/whisper-small)
-#
-# Endpoints:
-#   GET  /                -> UI
-#   GET  /health          -> status
-#   POST /ask             -> JSON {text, lang?} -> {"answer": "..."}
-#   POST /tts             -> JSON {text} -> audio/mp3
-#   POST /stt             -> multipart/form-data file or raw bytes -> {"text": "..."}
-#   POST /presence        -> JSON {note?} -> greeting (and audio if TTS available)
-#   GET  /display         -> JSON lines for OLED/HUB75
-#   GET  /model_check     -> check HF token & model (help debug 403/404)
-#
-# Notes:
-# - This file aims to be robust: good error messages for 403/404/400 and helpful logs.
-# - TTS fallback uses gTTS when HF TTS isn't configured or fails.
-# - Telegram integration uses direct requests to Telegram API (no extra dependency).
-# - Saves conversation to conversation_log.jsonl for future analysis.
-#
-# Author: KC Robot helper (assistant)
-# Version: v7.4-max-final
+#   HF_TTS_MODEL, HF_STT_MODEL
 
 import os
 import io
 import sys
-import json
 import time
+import json
 import uuid
-import queue
 import logging
 import threading
-from typing import Any, Dict, List, Tuple, Optional
+from typing import Any, List, Tuple, Optional
 from pathlib import Path
 
 import requests
-from flask import Flask, request, jsonify, render_template_string, Response, send_file
+from flask import Flask, request, jsonify, Response, render_template_string, send_file
 
-# Optional TTS fallback
+# Optional tts fallback
 try:
     from gtts import gTTS
     _HAS_GTTS = True
 except Exception:
     _HAS_GTTS = False
 
-# Optional Gradio (we won't force it)
-try:
-    import gradio as gr  # noqa: F401
-    _HAS_GRADIO = True
-except Exception:
-    _HAS_GRADIO = False
-
 # Logging
-logging.basicConfig(stream=sys.stdout, level=logging.INFO,
+logging.basicConfig(stream=sys.stdout,
+                    level=logging.INFO,
                     format="%(asctime)s %(levelname)s %(name)s: %(message)s")
 logger = logging.getLogger("kcrobot.v7.4")
 
-# ===== Environment / secrets =====
+# Environment / Secrets
 HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
-HF_MODEL = os.getenv("HF_MODEL", "").strip()
-HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "").strip()  # optional
+HF_MODEL = os.getenv("HF_MODEL", "").strip()                # required
+HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "").strip()        # optional
 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
+
 HF_HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
 
-# tmp dir and conversation log
+# tmp dir & logs
 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 buffers =====
+# in-memory buffers
 CONVERSATION: List[Tuple[str, str]] = []
 DISPLAY_BUFFER: List[str] = []
 DISPLAY_LIMIT = 6
@@ -93,241 +62,190 @@ def push_display(line: str):
     if len(DISPLAY_BUFFER) > DISPLAY_LIMIT:
         DISPLAY_BUFFER = DISPLAY_BUFFER[-DISPLAY_LIMIT:]
 
-def save_conversation(user: str, bot: str):
+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")
     except Exception:
-        logger.exception("Failed to write conversation log")
+        logger.exception("save_conv failed")
 
-# ===== language detection & cleaning =====
-VI_CHARS = set("ăâđêôơưáàảãạắằẳẵặấầẩẫậéèẻẽẹíìỉĩịóòỏõọúùủũụứừửữựýỳỷỹỵ")
-
-def detect_language(text: str) -> str:
-    """Simple heuristic: returns 'vi' or 'en'."""
-    if not text:
-        return "en"
-    for ch in text.lower():
-        if ch in VI_CHARS:
-            return "vi"
-    return "en"
-
-import re
-
-def clean_input_text(text: str) -> str:
-    """Normalize whitespace and remove control chars; keep punctuation."""
+# small text helpers
+def clean_text(text: str) -> str:
     if not isinstance(text, str):
         text = str(text)
-    # remove undesirable control characters
+    # remove control chars except usual punctuation, normalize spaces
+    import re
     text = re.sub(r'[\x00-\x08\x0b-\x0c\x0e-\x1f]+', ' ', text)
-    # normalize whitespace
     text = re.sub(r'\s+', ' ', text).strip()
     return text
 
-def tts_postprocess_text_for_prosody(text: str) -> str:
-    """
-    Improve TTS naturalness for gTTS fallback by inserting small pauses:
-    - ensure sentences end with a period/exclamation/question
-    - add commas in long sentences to encourage small pauses
-    This is a lightweight heuristic; HF TTS models may produce better prosody.
-    """
-    text = text.strip()
-    if not text:
-        return text
-    # ensure terminal punctuation
-    if text[-1] not in ".!?":
-        text = text + "."
-    # insert commas for long stretches (every ~12-16 words) to help gTTS
-    words = text.split()
-    if len(words) > 16:
-        chunks = []
-        for i in range(0, len(words), 12):
-            chunks.append(" ".join(words[i:i+12]))
-        text = ", ".join(chunks)
-        if text[-1] not in ".!?":
-            text = text + "."
-    return text
+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"
 
-# ===== Hugging Face helpers =====
+# ---------------- Hugging Face 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")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
     headers = dict(HF_HEADERS)
     headers["Content-Type"] = "application/json"
-    logger.debug("HF POST JSON -> %s payload keys: %s", model_id, list(payload.keys()))
-    r = requests.post(url, headers=headers, json=payload, timeout=timeout)
-    return r
-
-def hf_try_models_json(models: List[str], payload: dict, timeout: int = 90) -> Tuple[str, Any]:
-    """Try each model in models; return (model_used, parsed_json_or_bytes)."""
-    last_err = None
-    for m in models:
-        try:
-            r = hf_post_json(m, payload, timeout=timeout)
-        except Exception as e:
-            last_err = f"network error for {m}: {e}"
-            logger.warning(last_err)
-            continue
-        logger.debug("HF status for %s = %s", m, r.status_code)
-        if r.status_code == 200:
-            try:
-                return m, r.json()
-            except Exception:
-                return m, r.content
-        else:
-            last_err = f"HTTP {r.status_code} for {m}: {r.text[:300]}"
-            logger.warning(last_err)
-            # continue to next model
-    raise RuntimeError(f"All HF attempts failed. Last error: {last_err}")
+    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 = 120) -> requests.Response:
+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")
     url = f"https://api-inference.huggingface.co/models/{model_id}"
     headers = dict(HF_HEADERS)
     headers["Content-Type"] = content_type
-    r = requests.post(url, headers=headers, data=data, timeout=timeout)
-    return r
-
-def hf_try_models_bytes(models: List[str], data: bytes, content_type: str = "application/octet-stream", timeout: int = 120) -> Tuple[str, requests.Response]:
-    last_err = None
-    for m in models:
-        try:
-            r = hf_post_bytes(m, data, content_type=content_type, timeout=timeout)
-        except Exception as e:
-            last_err = f"network error for {m}: {e}"
-            logger.warning(last_err)
-            continue
-        if r.status_code == 200:
-            return m, r
-        else:
-            last_err = f"HTTP {r.status_code} for {m}: {r.text[:300]}"
-            logger.warning(last_err)
-    raise RuntimeError(f"All HF byte-post attempts failed. Last error: {last_err}")
+    return requests.post(url, headers=headers, data=data, timeout=timeout)
 
 def parse_hf_text_output(obj: Any) -> str:
-    """Normalize HF text output shapes."""
     try:
         if isinstance(obj, dict):
             if "generated_text" in obj:
-                return obj.get("generated_text", "")
+                return obj.get("generated_text","")
             if "text" in obj:
-                return obj.get("text", "")
+                return obj.get("text","")
             if "choices" in obj and isinstance(obj["choices"], list) and obj["choices"]:
                 c = obj["choices"][0]
-                return c.get("text") or c.get("message", {}).get("content", "") or str(c)
-            # fallback
+                return c.get("text") or c.get("message",{}).get("content","") or str(c)
             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"):
+                for k in ("generated_text","text"):
                     if k in first:
-                        return first.get(k, "")
+                        return first.get(k,"")
             return str(first)
         return str(obj)
     except Exception:
-        logger.exception("parse_hf_text_output error")
+        logger.exception("parse_hf_text_output")
         return str(obj)
 
-# High-level wrappers
 def hf_text_generate(prompt: str, model_override: Optional[str] = None, max_new_tokens: int = 256, temperature: float = 0.7) -> str:
-    models = []
-    if model_override:
-        models.append(model_override)
-    elif HF_MODEL:
-        models.append(HF_MODEL)
-    else:
+    model = model_override or HF_MODEL
+    if not model:
         raise RuntimeError("HF_MODEL not configured")
     payload = {
         "inputs": prompt,
         "parameters": {"max_new_tokens": int(max_new_tokens), "temperature": float(temperature)},
         "options": {"wait_for_model": True}
     }
-    model_used, out = hf_try_models_json(models, payload, timeout=120)
-    return parse_hf_text_output(out)
-
-def hf_stt_from_bytes(bytes_data: bytes, model_override: Optional[str] = None) -> str:
-    models = [model_override] if model_override else ([HF_STT_MODEL] if HF_STT_MODEL else [])
-    if not models:
-        raise RuntimeError("STT model not configured")
-    model_used, resp = hf_try_models_bytes(models, bytes_data, content_type="application/octet-stream", timeout=180)
-    try:
-        j = resp.json()
-        if isinstance(j, dict) and "text" in j:
-            return j["text"]
-        return parse_hf_text_output(j)
-    except Exception:
-        return resp.text or ""
-
-def hf_tts_get_bytes(text: str, model_list: Optional[List[str]] = None) -> bytes:
-    """Try HF TTS models (if set) then fallback to gTTS."""
-    txt = text.strip()
-    if not txt:
-        raise RuntimeError("Empty text for TTS")
-    models = model_list if model_list else ([HF_TTS_MODEL] if HF_TTS_MODEL else [])
-    if models:
-        payload = {"inputs": txt}
+    r = hf_post_json(model, payload, timeout=120)
+    if r.status_code == 200:
         try:
-            model_used, resp = hf_try_models_json(models, payload, timeout=120)
-            # some HF TTS returns binary audio directly; requests gives .content
-            if isinstance(resp, (bytes, bytearray)):
-                return bytes(resp)
-            # if json with base64? unlikely; try to detect
-            if isinstance(resp, dict) and "error" in resp:
-                raise RuntimeError(f"HF TTS model error: {resp.get('error')}")
-            # if response is binary streamed we would have returned earlier; fallback:
-        except Exception as e:
-            logger.warning("HF TTS failed: %s", e)
+            return parse_hf_text_output(r.json())
+        except Exception:
+            return r.text
+    elif r.status_code == 403:
+        raise RuntimeError("HF returned 403 — token may lack access rights.")
+    elif r.status_code == 404:
+        raise RuntimeError("HF returned 404 — model not found (check HF_MODEL).")
+    else:
+        raise RuntimeError(f"HF 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:
+        try:
+            j = r.json()
+            if isinstance(j, dict) and "text" in j:
+                return j["text"]
+            return parse_hf_text_output(j)
+        except Exception:
+            return r.text
+    else:
+        raise RuntimeError(f"HF STT returned {r.status_code}: {r.text[:300]}")
+
+def hf_tts_get_bytes(text: str, model_override: Optional[str] = None) -> bytes:
+    """
+    Try HF TTS model if configured, fallback to gTTS if available.
+    Returns raw mp3 bytes.
+    """
+    text = text.strip()
+    if not text:
+        raise RuntimeError("TTS text empty")
+    # try HF TTS if provided
+    model = model_override or HF_TTS_MODEL
+    if model:
+        payload = {"inputs": text}
+        r = hf_post_json(model, payload, timeout=120)
+        if r.status_code == 200:
+            # Some TTS models might return audio bytes (rare) or JSON response with base64 or url.
+            # We attempt to return raw content if present (requests .content)
+            if r.content:
+                return r.content
+            try:
+                j = r.json()
+                # if model returned something textual, parse
+                return parse_hf_text_output(j).encode("utf-8")
+            except Exception:
+                return r.content
+        else:
+            logger.warning("HF TTS model returned %s: %s", r.status_code, r.text[:300])
     # fallback gTTS
     if _HAS_GTTS:
         try:
-            prosody = tts_postprocess_text_for_prosody(txt)
-            tts = gTTS(text=prosody, lang="vi" if detect_language(txt) == "vi" else "en")
+            lang = "vi" if detect_language(text) == "vi" else "en"
+            prosody = text
+            # simple prosody improvement
+            if len(prosody.split()) > 18:
+                # add slight pauses: break into pieces
+                parts = []
+                w = prosody.split()
+                for i in range(0, len(w), 12):
+                    parts.append(" ".join(w[i:i+12]))
+                prosody = ", ".join(parts)
+            tts = gTTS(text=prosody, lang=lang)
             bio = io.BytesIO()
             tts.write_to_fp(bio)
             bio.seek(0)
             return bio.read()
-        except Exception as e:
+        except Exception:
             logger.exception("gTTS fallback failed")
-            raise RuntimeError(f"TTS fallback failed: {e}")
+            raise RuntimeError("gTTS fallback failed")
     raise RuntimeError("No TTS available (no HF_TTS_MODEL and gTTS not installed)")
 
-# ===== Telegram helpers (simple requests) =====
+# ---------------- Telegram helpers (simple HTTP API) ----------------
 def telegram_send_message(chat_id: str, text: str) -> bool:
     if not TELEGRAM_TOKEN or not chat_id:
-        logger.debug("telegram not configured")
         return False
-    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
     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 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:
-        logger.debug("telegram not configured")
         return False
-    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendAudio"
-    files = {"audio": (filename, io.BytesIO(audio_bytes), "audio/mpeg")}
-    data = {"chat_id": chat_id}
     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
         return True
     except Exception:
-        logger.exception("telegram_send_audio exception")
+        logger.exception("telegram_send_audio")
         return False
 
-# Telegram poller (long-polling)
+# Telegram poller thread
 def telegram_poller_loop():
     if not TELEGRAM_TOKEN:
         logger.info("Telegram token not set; poller disabled")
@@ -359,11 +277,11 @@ def telegram_poller_loop():
                 if lower.startswith("/ask "):
                     q = text[5:].strip()
                     try:
-                        ans = hf_text_generate(q)
+                        answer = hf_text_generate(q)
                     except Exception as e:
-                        ans = f"[HF error] {e}"
+                        answer = f"[HF error] {e}"
                     try:
-                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": ans}, timeout=10)
+                        requests.post(base + "/sendMessage", json={"chat_id": chat_id, "text": answer}, timeout=10)
                     except Exception:
                         logger.exception("tg reply failed")
                 elif lower.startswith("/say "):
@@ -384,21 +302,19 @@ def telegram_poller_loop():
                     except Exception:
                         pass
         except Exception:
-            logger.exception("telegram poller loop crashed, sleeping 3s")
+            logger.exception("telegram poller crashed, sleeping 3s")
             time.sleep(3)
 
-# Start telegram thread if token exists
 if TELEGRAM_TOKEN:
     try:
         t = threading.Thread(target=telegram_poller_loop, daemon=True)
         t.start()
     except Exception:
-        logger.exception("Failed to start telegram poller thread")
+        logger.exception("start telegram thread failed")
 
-# ===== Flask app & routes =====
+# ---------------- Flask app ----------------
 app = Flask(__name__)
 
-# Simple responsive UI (mobile friendly) - shows model & buttons
 INDEX_HTML = """
 <!doctype html>
 <html>
@@ -409,7 +325,7 @@ INDEX_HTML = """
   <style>
     body{font-family:Arial,Helvetica,sans-serif;margin:12px;color:#111}
     .box{max-width:900px;margin:auto}
-    textarea{width:100%;height:80px;padding:10px;font-size:16px;border-radius:8px;border:1px solid #ddd}
+    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:320px;overflow:auto;background:#fafafa;border-radius:8px}
     .you{color:#0b63d6;margin:6px 0}
@@ -494,7 +410,7 @@ def health():
 def route_ask():
     try:
         j = request.get_json(force=True) or {}
-        text = clean_input_text(j.get("text","") or "")
+        text = clean_text(j.get("text","") or "")
         lang = (j.get("lang","auto") or "auto")
         if not text:
             return jsonify({"error":"no text"}), 400
@@ -510,10 +426,10 @@ def route_ask():
             logger.exception("hf_text_generate failed")
             return jsonify({"error": str(e)}), 500
         CONVERSATION.append((text, ans))
-        save_conversation(text, ans)
+        save_conv(text, ans)
         push_display("YOU: " + (text[:60]))
         push_display("BOT: " + (ans[:60] if isinstance(ans,str) else str(ans)[:60]))
-        # send short notification to telegram optionally (not full conv)
+        # notify telegram
         if TELEGRAM_TOKEN and TELEGRAM_CHAT_ID:
             try:
                 telegram_send_message(TELEGRAM_CHAT_ID, f"You: {text}\nBot: {ans[:300]}")
@@ -528,14 +444,13 @@ def route_ask():
 def route_tts():
     try:
         j = request.get_json(force=True) or {}
-        text = clean_input_text(j.get("text","") or "")
+        text = clean_text(j.get("text","") or "")
         if not text:
             return jsonify({"error":"no text"}), 400
         try:
-            models = [HF_TTS_MODEL] if HF_TTS_MODEL else None
-            audio_bytes = hf_tts_get_bytes(text, model_list=models)
+            audio_bytes = hf_tts_get_bytes(text)
         except Exception as e:
-            logger.warning("TTS error, returning textual error: %s", e)
+            logger.exception("tts generation failed")
             return jsonify({"error": str(e)}), 500
         return Response(audio_bytes, mimetype="audio/mpeg")
     except Exception as e:
@@ -558,7 +473,7 @@ def route_stt():
             logger.exception("STT failed")
             return jsonify({"error": str(e)}), 500
         CONVERSATION.append((f"[voice] {txt}", ""))
-        save_conversation(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:
@@ -567,25 +482,27 @@ def route_stt():
 
 @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_input_text(j.get("note","Có người phía trước") or "Có người phía trước")
+        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_conversation("__presence__", greeting)
+        save_conv("__presence__", greeting)
         push_display("RADAR: " + note[:60])
-        # Telegram notify
         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")
-        # return greeting audio if possible
         try:
-            audio_bytes = hf_tts_get_bytes(greeting, model_list=[HF_TTS_MODEL] if HF_TTS_MODEL else None)
+            audio_bytes = hf_tts_get_bytes(greeting)
             return Response(audio_bytes, mimetype="audio/mpeg")
         except Exception:
-            # fallback: return text greeting
             return jsonify({"greeting": greeting})
     except Exception as e:
         logger.exception("route_presence exception")
@@ -596,110 +513,54 @@ def route_display():
     return jsonify({"lines": DISPLAY_BUFFER.copy(), "conv_len": len(CONVERSATION)})
 
 @app.route("/model_check", methods=["GET"])
-def route_model_check():
-    """Quick check for HF_TOKEN + HF_MODEL: calls model with a tiny ping prompt."""
+def model_check():
+    """
+    Quick check of HF token + model. Returns HF response (or error).
+    Useful to debug 403/404.
+    """
     if not HF_TOKEN:
         return jsonify({"ok": False, "error": "HF_TOKEN not set"}), 400
     if not HF_MODEL:
         return jsonify({"ok": False, "error": "HF_MODEL not set"}), 400
-    test_prompt = "Hello model. Respond with 'OK' only."
+    ping = "Please reply 'OK' only."
+    payload = {"inputs": ping, "parameters": {"max_new_tokens": 6}, "options": {"wait_for_model": True}}
     try:
-        payload = {"inputs": test_prompt, "parameters": {"max_new_tokens": 8}, "options": {"wait_for_model": True}}
-        r = requests.post(f"https://api-inference.huggingface.co/models/{HF_MODEL}", headers={**HF_HEADERS, "Content-Type": "application/json"}, json=payload, timeout=30)
-        if r.status_code == 200:
-            try:
-                j = r.json()
-                txt = parse_hf_text_output(j)
-            except Exception:
-                txt = r.text[:400]
-            return jsonify({"ok": True, "model": HF_MODEL, "response_preview": txt})
-        else:
-            return jsonify({"ok": False, "status_code": r.status_code, "text": r.text[:800]}), 500
+        r = requests.post(f"https://api-inference.huggingface.co/models/{HF_MODEL}",
+                          headers={**HF_HEADERS, "Content-Type": "application/json"},
+                          json=payload, timeout=30)
+        return jsonify({"status_code": r.status_code, "text": r.text})
     except Exception as e:
         logger.exception("model_check failed")
         return jsonify({"ok": False, "error": str(e)}), 500
 
-# ===== Optional: start a Gradio UI in background to give extra interface (if installed) =====
-def start_gradio_thread():
-    if not _HAS_GRADIO:
-        logger.info("Gradio not installed; skipping Gradio UI")
-        return
+@app.route("/config", methods=["GET","POST"])
+def config():
+    """
+    GET returns current simple config.
+    POST JSON can change runtime values (temporary).
+    Example POST: {"hf_model":"...", "hf_tts_model":"..."}
+    """
+    global HF_MODEL, HF_TTS_MODEL, HF_STT_MODEL
+    if request.method == "GET":
+        return jsonify({"hf_model": HF_MODEL, "hf_tts_model": HF_TTS_MODEL, "hf_stt_model": HF_STT_MODEL})
     try:
-        import gradio as gr
-        def gr_chat(audio, text, temp, max_tokens, model_override):
-            user_text = (text or "").strip()
-            if audio:
-                # audio is path to file
-                try:
-                    with open(audio, "rb") as f:
-                        b = f.read()
-                    stt = hf_stt_from_bytes(b)
-                    if stt and not stt.startswith("[ERROR]"):
-                        user_text = stt
-                except Exception:
-                    logger.exception("gradio stt failed")
-            if not user_text:
-                return None, ""
-            prompt = f"You are KC Robot AI, bilingual assistant. Answer in same language. User: {user_text}\nAssistant:"
-            model = model_override.strip() if model_override else HF_MODEL
-            try:
-                ans = hf_text_generate(prompt, model_override=model, max_new_tokens=int(max_tokens), temperature=float(temp))
-            except Exception as e:
-                ans = f"[LLM error] {e}"
-            # tts preview
-            try:
-                audio_bytes = hf_tts_get_bytes(ans, model_list=[HF_TTS_MODEL] if HF_TTS_MODEL else None)
-            except Exception:
-                audio_bytes = None
-            history = [("You", user_text), ("Bot", ans)]
-            return history, (audio_bytes, "audio/mpeg") if audio_bytes else None
-
-        with gr.Blocks(title="KC Robot AI v7.4 Gradio UI") as demo:
-            gr.Markdown("## KC Robot AI v7.4 — Gradio")
-            with gr.Row():
-                with gr.Column():
-                    chatbot = gr.Chatbot([], elem_id="chatbot").style(height=420)
-                    txt = gr.Textbox(lines=2, placeholder="Nhập câu (VN/EN)...")
-                    mic = gr.Audio(source="microphone", type="filepath")
-                    btn = gr.Button("Send")
-                    with gr.Row():
-                        temp = gr.Slider(0.0, 1.0, value=0.7, label="Temperature")
-                        tokens = gr.Slider(32, 1024, value=256, step=16, label="Max tokens")
-                    model_override = gr.Textbox(label="Model override (optional)", placeholder=HF_MODEL)
-                with gr.Column():
-                    gr.Markdown("### TTS / STT")
-                    tts_in = gr.Textbox(lines=2, label="Text → TTS")
-                    tts_btn = gr.Button("Create TTS")
-                    tts_audio = gr.Audio(label="TTS audio", interactive=False)
-                    up = gr.Audio(source="upload", type="filepath")
-                    stt_btn = gr.Button("Transcribe")
-                    stt_out = gr.Textbox(label="Transcription")
-            def send_click(audio_file, typed, temp_v, max_toks, model_o, chat_history):
-                result = gr_chat(audio_file, typed, temp_v, max_toks, model_o)
-                if result is None:
-                    return chat_history or [], ""
-                chat_hist, audio_blob = result
-                history = chat_history or []
-                for it in chat_hist:
-                    history.append(it)
-                return history, ""
-            btn.click(send_click, inputs=[mic, txt, temp, tokens, model_override, chatbot], outputs=[chatbot, txt])
-            tts_btn.click(lambda t: hf_tts_get_bytes(t) if t else None, inputs=[tts_in], outputs=[tts_audio])
-
-        def _run():
-            try:
-                demo.launch(server_name="0.0.0.0", server_port=7861, share=False, prevent_thread_lock=True)
-            except Exception:
-                logger.exception("Gradio launch failed")
-        t = threading.Thread(target=_run, daemon=True)
-        t.start()
-        logger.info("Gradio UI started on port 7861")
-    except Exception:
-        logger.exception("start_gradio_thread failed")
-
-start_gradio_thread()
+        j = request.get_json(force=True) or {}
+        changed = {}
+        if "hf_model" in j:
+            HF_MODEL = j["hf_model"]
+            changed["hf_model"] = HF_MODEL
+        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
 
-# ===== main =====
+# --------------- run ---------------
 if __name__ == "__main__":
     logger.info("KC Robot AI v7.4 starting. HF_MODEL=%s HF_TTS=%s HF_STT=%s Telegram=%s",
                 HF_MODEL or "(not set)", HF_TTS_MODEL or "(not set)", HF_STT_MODEL or "(not set)", bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID))
@@ -707,5 +568,5 @@ if __name__ == "__main__":
         logger.warning("HF_TOKEN not set — set Secret HF_TOKEN to use Hugging Face inference.")
     if not HF_MODEL:
         logger.warning("HF_MODEL not set — set Secret HF_MODEL to a model id.")
-    # run Flask
+    # start Flask
     app.run(host="0.0.0.0", port=PORT)