Update app_server.py

app_server.py

@@ -1,15 +1,7 @@
 # app_server.py — BubbleGuard API + Dating-style Web Chat (Static UI)
-# Version: 1.7.0 (HF Drive-ready + repo-root UI support)
-# Author: Amir
-
-import io
-import os
-import re
-import uuid
-import pathlib
-import tempfile
-import subprocess
-import unicodedata
+# Version: 1.7.1 (/api/* routes + repo-root UI support)
+
+import io, os, re, uuid, pathlib, tempfile, subprocess, unicodedata
 from typing import Dict, Optional
 
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
@@ -17,9 +9,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import PlainTextResponse
 
-import torch
-import joblib
-import torchvision
+import torch, joblib, torchvision
 from torchvision import transforms
 from transformers import RobertaTokenizerFast, AutoModelForSequenceClassification
 from PIL import Image
@@ -28,52 +18,39 @@ from faster_whisper import WhisperModel
 # -------------------------- Paths & Config --------------------------
 BASE = pathlib.Path(__file__).resolve().parent
 TEXT_DIR = BASE / "Text"
-IMG_DIR = BASE / "Image"
-AUD_DIR = BASE / "Audio"
+IMG_DIR  = BASE / "Image"
+AUD_DIR  = BASE / "Audio"
 STATIC_DIR = BASE / "static"
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Image thresholds / mapping
-IMG_UNSAFE_THR = float(os.getenv("IMG_UNSAFE_THR", "0.5"))
+IMG_UNSAFE_THR   = float(os.getenv("IMG_UNSAFE_THR", "0.5"))
 IMG_UNSAFE_INDEX = int(os.getenv("IMG_UNSAFE_INDEX", "1"))
 
-# Whisper model selection
-WHISPER_MODEL_NAME = os.getenv("WHISPER_MODEL", "base")  # large-v2 | medium | small | base | tiny
+WHISPER_MODEL_NAME = os.getenv("WHISPER_MODEL", "base")
 
-# Text thresholds and heuristics
-TEXT_UNSAFE_THR = float(os.getenv("TEXT_UNSAFE_THR", "0.60"))
-SHORT_MSG_MAX_TOKENS = int(os.getenv("SHORT_MSG_MAX_TOKENS", "6"))
-SHORT_MSG_UNSAFE_THR = float(os.getenv("SHORT_MSG_UNSAFE_THR", "0.90"))
+TEXT_UNSAFE_THR        = float(os.getenv("TEXT_UNSAFE_THR", "0.60"))
+SHORT_MSG_MAX_TOKENS   = int(os.getenv("SHORT_MSG_MAX_TOKENS", "6"))
+SHORT_MSG_UNSAFE_THR   = float(os.getenv("SHORT_MSG_UNSAFE_THR", "0.90"))
 
-# Audio mapping/threshold (can differ from text)
 AUDIO_UNSAFE_INDEX = int(os.getenv("AUDIO_UNSAFE_INDEX", "1"))
-AUDIO_UNSAFE_THR = float(os.getenv("AUDIO_UNSAFE_THR", "0.50"))
+AUDIO_UNSAFE_THR   = float(os.getenv("AUDIO_UNSAFE_THR", "0.50"))
 
-app = FastAPI(title="BubbleGuard API", version="1.7.0")
+app = FastAPI(title="BubbleGuard API", version="1.7.1")
 
-# CORS open for demo; restrict in production
 app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
+    CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]
 )
 
 # -------------------------- Text Classifier -------------------------
 if not TEXT_DIR.exists():
-    raise RuntimeError(f"Text model dir not found: {TEXT_DIR}. Make sure download_assets ran.")
-
-try:
-    tok = RobertaTokenizerFast.from_pretrained(TEXT_DIR, local_files_only=True)
-    txtM = AutoModelForSequenceClassification.from_pretrained(
-        TEXT_DIR, local_files_only=True
-    ).to(DEVICE).eval()
-except Exception as e:
-    raise RuntimeError(f"Failed to load text model from {TEXT_DIR}: {e}")
-
-# ------------------------ Label mapping (robust) --------------------
-SAFE_LABEL_HINTS = {"safe", "ok", "clean", "benign", "non-toxic", "non_toxic", "non toxic"}
+    raise RuntimeError(f"Text model dir not found: {TEXT_DIR}. Run download_assets first.")
+
+tok = RobertaTokenizerFast.from_pretrained(TEXT_DIR, local_files_only=True)
+txtM = AutoModelForSequenceClassification.from_pretrained(TEXT_DIR, local_files_only=True).to(DEVICE).eval()
+
+# -------- Label mapping (robust) --------
+SAFE_LABEL_HINTS   = {"safe", "ok", "clean", "benign", "non-toxic", "non_toxic", "non toxic"}
 UNSAFE_LABEL_HINTS = {"unsafe", "toxic", "abuse", "harm", "offense", "nsfw", "not_safe", "not safe"}
 
 def _infer_ids_by_name(model) -> (Optional[int], Optional[int]):
@@ -91,18 +68,13 @@ def _infer_ids_by_name(model) -> (Optional[int], Optional[int]):
                 except Exception:
                     continue
             norm[ki] = str(v).lower()
-        safe_idx = None
-        unsafe_idx = None
+        s = u = None
         for i, name in norm.items():
-            if any(h in name for h in SAFE_LABEL_HINTS):
-                safe_idx = i
-            if any(h in name for h in UNSAFE_LABEL_HINTS):
-                unsafe_idx = i
-        if safe_idx is not None and unsafe_idx is None:
-            unsafe_idx = 1 - safe_idx
-        if unsafe_idx is not None and safe_idx is None:
-            safe_idx = 1 - unsafe_idx
-        return safe_idx, unsafe_idx
+            if any(h in name for h in SAFE_LABEL_HINTS):   s = i
+            if any(h in name for h in UNSAFE_LABEL_HINTS): u = i
+        if s is not None and u is None: u = 1 - s
+        if u is not None and s is None: s = 1 - u
+        return s, u
     except Exception:
         return None, None
 
@@ -111,10 +83,8 @@ def _infer_ids_by_probe(model, tok, device) -> (int, int):
     samples = ["hi", "hello", "how are you", "nice to meet you", "thanks"]
     enc = tok(samples, return_tensors="pt", truncation=True, padding=True, max_length=64)
     enc = {k: v.to(device) for k, v in enc.items()}
-    logits = model(**enc).logits  # [B, 2]
-    probs = torch.softmax(logits, dim=-1).mean(0)  # [2]
-    safe_idx = int(torch.argmax(probs).item())
-    unsafe_idx = 1 - safe_idx
+    probs = torch.softmax(model(**enc).logits, dim=-1).mean(0)
+    safe_idx = int(torch.argmax(probs).item()); unsafe_idx = 1 - safe_idx
     return safe_idx, unsafe_idx
 
 def _resolve_safe_unsafe_ids(model, tok, device) -> (int, int):
@@ -129,116 +99,63 @@ def _resolve_safe_unsafe_ids(model, tok, device) -> (int, int):
 SAFE_ID, UNSAFE_ID = _resolve_safe_unsafe_ids(txtM, tok, DEVICE)
 print(f"[BubbleGuard] SAFE_ID={SAFE_ID}  UNSAFE_ID={UNSAFE_ID}  id2label={getattr(txtM.config, 'id2label', None)}")
 
-# ------------------------ Normalization utils -----------------------
+# ------------------------ Text utils ------------------------
 def normalize(text: str) -> str:
-    if not isinstance(text, str):
-        return ""
+    if not isinstance(text, str): return ""
     t = unicodedata.normalize("NFKC", text)
-    t = t.replace("’", "'").replace("‘", "'").replace("“", '"').replace("”", '"')
-    t = t.lower()
-    t = re.sub(r"[^a-z0-9\s']", " ", t)
-    t = re.sub(r"\s+", " ", t).strip()
-    return t
-
-SAFE_PHRASES = [
-    r"^i don'?t$",
-    r"^i do not$",
-    r"^don'?t$",
-    r"^no$",
-    r"^not really$",
-    r"^i wouldn'?t$",
-    r"^i woulde?n'?t$",
-    r"^i don'?t like$",
-]
+    t = t.replace("’","'").replace("‘","'").replace("“",'"').replace("”",'"')
+    t = re.sub(r"[^a-z0-9\s']", " ", t.lower())
+    return re.sub(r"\s+", " ", t).strip()
+
+SAFE_PHRASES = [r"^i don'?t$", r"^i do not$", r"^don'?t$", r"^no$", r"^not really$", r"^i woulde?n'?t$", r"^i don'?t like$"]
 SAFE_RE = re.compile("|".join(SAFE_PHRASES))
 NEGATION_ONLY = re.compile(r"^(?:i\s+)?(?:do\s+not|don'?t|no|not)$")
 NEUTRAL_DISLIKE = re.compile(r"^i don'?t like(?:\s+to)?\b")
 
-SENSITIVE_TERMS = {
-    "people", "you", "him", "her", "them", "men", "women", "girls", "boys",
-    "muslim", "christian", "jew", "jews", "black", "white", "asian",
-    "gay", "lesbian", "trans", "transgender", "disabled",
-    "immigrants", "refugees", "poor", "old", "elderly", "fat", "skinny"
-}
-PROFANITY_TERMS = {"fuck", "shit", "bitch", "pussy", "dick", "cunt", "slut", "whore"}
-
-GREETINGS = [
-    r"^hi$",
-    r"^hello$",
-    r"^hey(?: there)?$",
-    r"^how are (?:you|u)\b.*$",
-    r"^good (?:morning|afternoon|evening)\b.*$",
-    r"^what'?s up\b.*$",
-    r"^how'?s it going\b.*$",
-]
+SENSITIVE_TERMS = {"people","you","him","her","them","men","women","girls","boys",
+                   "muslim","christian","jew","jews","black","white","asian",
+                   "gay","lesbian","trans","transgender","disabled",
+                   "immigrants","refugees","poor","old","elderly","fat","skinny"}
+PROFANITY_TERMS = {"fuck","shit","bitch","pussy","dick","cunt","slut","whore"}
+
+GREETINGS = [r"^hi$", r"^hello$", r"^hey(?: there)?$", r"^how are (?:you|u)\b.*$",
+             r"^good (?:morning|afternoon|evening)\b.*$", r"^what'?s up\b.*$", r"^how'?s it going\b.*$"]
 GREETING_RE = re.compile("|".join(GREETINGS))
 
 @torch.no_grad()
 def text_safe_payload(text: str) -> Dict:
-    clean = normalize(text)
-    toks = clean.split()
+    clean = normalize(text); toks = clean.split()
 
-    # A) single-word profanity → UNSAFE
     if len(toks) == 1 and toks[0] in PROFANITY_TERMS:
-        probs = [0.0, 0.0]; probs[UNSAFE_ID] = 1.0
-        return {"safe": False, "unsafe_prob": 1.0, "label": "UNSAFE", "probs": probs,
-                "tokens": 1, "reason": "profanity_single_word",
-                "params": {"TEXT_UNSAFE_THR": TEXT_UNSAFE_THR, "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS, "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR}}
+        p = [0.0,0.0]; p[UNSAFE_ID]=1.0
+        return {"safe":False,"unsafe_prob":1.0,"label":"UNSAFE","probs":p,"tokens":1,"reason":"profanity_single_word"}
 
-    # B) short text with any profanity → UNSAFE
     if len(toks) <= SHORT_MSG_MAX_TOKENS and any(t in PROFANITY_TERMS for t in toks):
-        probs = [0.0, 0.0]; probs[UNSAFE_ID] = 1.0
-        return {"safe": False, "unsafe_prob": 1.0, "label": "UNSAFE", "probs": probs,
-                "tokens": len(toks), "reason": "profanity_short_text",
-                "params": {"TEXT_UNSAFE_THR": TEXT_UNSAFE_THR, "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS, "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR}}
+        p = [0.0,0.0]; p[UNSAFE_ID]=1.0
+        return {"safe":False,"unsafe_prob":1.0,"label":"UNSAFE","probs":p,"tokens":len(toks),"reason":"profanity_short_text"}
 
-    # Allow-lists
     if SAFE_RE.match(clean) or NEGATION_ONLY.match(clean) or GREETING_RE.match(clean):
-        probs = [0.0, 0.0]; probs[SAFE_ID] = 1.0
-        reason = "greeting_allow" if GREETING_RE.match(clean) else "allow_list"
-        return {"safe": True, "unsafe_prob": 0.0, "label": "SAFE", "probs": probs,
-                "tokens": len(toks), "reason": reason,
-                "params": {"TEXT_UNSAFE_THR": TEXT_UNSAFE_THR, "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS, "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR}}
+        p=[0.0,0.0]; p[SAFE_ID]=1.0
+        return {"safe":True,"unsafe_prob":0.0,"label":"SAFE","probs":p,"tokens":len(toks),"reason":"allow_or_greeting"}
 
-    # Neutral dislike relax
     if NEUTRAL_DISLIKE.match(clean):
-        has_sensitive = any(term in clean for term in SENSITIVE_TERMS)
-        has_profanity = any(term in clean for term in PROFANITY_TERMS)
-        if not has_sensitive and not has_profanity:
+        if not any(t in clean for t in SENSITIVE_TERMS) and not any(t in clean for t in PROFANITY_TERMS):
             enc = tok(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
             enc = {k: v.to(DEVICE) for k, v in enc.items()}
-            logits = txtM(**enc).logits[0]
-            probs = torch.softmax(logits, dim=-1).detach().cpu().tolist()
-            unsafe_prob = float(probs[UNSAFE_ID])
-            is_safe = unsafe_prob < 0.98
-            return {"safe": bool(is_safe), "unsafe_prob": unsafe_prob,
-                    "label": "SAFE" if is_safe else "UNSAFE",
-                    "probs": probs, "tokens": int(enc["input_ids"].shape[1]),
-                    "reason": "neutral_dislike_relaxed",
-                    "params": {"TEXT_UNSAFE_THR": TEXT_UNSAFE_THR, "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS, "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR}}
-
-    # Normal model path
+            probs = torch.softmax(txtM(**enc).logits[0], dim=-1).cpu().tolist()
+            up = float(probs[UNSAFE_ID]); safe = up < 0.98
+            return {"safe":bool(safe),"unsafe_prob":up,"label":"SAFE" if safe else "UNSAFE",
+                    "probs":probs,"tokens":int(enc["input_ids"].shape[1]),"reason":"neutral_dislike_relaxed"}
+
     enc = tok(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
     enc = {k: v.to(DEVICE) for k, v in enc.items()}
     logits = txtM(**enc).logits[0]
-    probs = torch.softmax(logits, dim=-1).detach().cpu().tolist()
-    unsafe_prob = float(probs[UNSAFE_ID])
-    pred_idx = int(torch.argmax(logits))
-    num_tokens = int(enc["input_ids"].shape[1])
+    probs = torch.softmax(logits, dim=-1).cpu().tolist()
+    up = float(probs[UNSAFE_ID]); toks = int(enc["input_ids"].shape[1])
 
-    if num_tokens <= SHORT_MSG_MAX_TOKENS:
-        is_safe = unsafe_prob < SHORT_MSG_UNSAFE_THR
-        reason = "short_msg_threshold"
-    else:
-        is_safe = unsafe_prob < TEXT_UNSAFE_THR
-        reason = "global_threshold"
-
-    label = (txtM.config.id2label.get(pred_idx)
-             if isinstance(getattr(txtM.config, "id2label", None), dict) else None) or str(pred_idx)
-
-    return {"safe": bool(is_safe), "unsafe_prob": unsafe_prob, "label": label,
-            "probs": probs, "tokens": num_tokens, "reason": reason,
-            "params": {"TEXT_UNSAFE_THR": TEXT_UNSAFE_THR, "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS, "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR}}
+    safe = up < (SHORT_MSG_UNSAFE_THR if toks <= SHORT_MSG_MAX_TOKENS else TEXT_UNSAFE_THR)
+    return {"safe":bool(safe),"unsafe_prob":up,"label":str(int(torch.argmax(logits))),
+            "probs":probs,"tokens":toks,"reason":"short_msg_threshold" if toks<=SHORT_MSG_MAX_TOKENS else "global_threshold"}
 
 # -------------------------- Image Classifier ------------------------
 class SafetyResNet(torch.nn.Module):
@@ -248,28 +165,18 @@ class SafetyResNet(torch.nn.Module):
         self.feature_extractor = torch.nn.Sequential(*list(base.children())[:8])
         self.pool = torch.nn.AdaptiveAvgPool2d(1)
         self.classifier = torch.nn.Sequential(
-            torch.nn.Linear(2048, 512),
-            torch.nn.ReLU(True),
-            torch.nn.Dropout(0.30),
-            torch.nn.Linear(512, 2),
+            torch.nn.Linear(2048, 512), torch.nn.ReLU(True), torch.nn.Dropout(0.30), torch.nn.Linear(512, 2)
         )
-
     def forward(self, x):
         x = self.pool(self.feature_extractor(x))
         return self.classifier(torch.flatten(x, 1))
 
 if not IMG_DIR.exists():
-    raise RuntimeError(f"Image model dir not found: {IMG_DIR}. Make sure download_assets ran.")
-
-try:
-    imgM = SafetyResNet().to(DEVICE)
-    imgM.load_state_dict(
-        torch.load(IMG_DIR / "resnet_safety_classifier.pth", map_location=DEVICE),
-        strict=True
-    )
-    imgM.eval()
-except Exception as e:
-    raise RuntimeError(f"Failed to load image model weights from {IMG_DIR}: {e}")
+    raise RuntimeError(f"Image model dir not found: {IMG_DIR}. Run download_assets first.")
+
+imgM = SafetyResNet().to(DEVICE)
+imgM.load_state_dict(torch.load(IMG_DIR / "resnet_safety_classifier.pth", map_location=DEVICE), strict=True)
+imgM.eval()
 
 img_tf = transforms.Compose([
     transforms.Resize(256, interpolation=transforms.InterpolationMode.BILINEAR),
@@ -279,68 +186,56 @@ img_tf = transforms.Compose([
 ])
 
 @torch.no_grad()
-def image_safe_payload(pil_img: Image.Image) -> Dict:
-    x = img_tf(pil_img.convert("RGB")).unsqueeze(0).to(DEVICE)
-    logits = imgM(x)[0]
-    probs = torch.softmax(logits, dim=0).detach().cpu().tolist()  # [2]
-    unsafe_p = float(probs[IMG_UNSAFE_INDEX])
-    return {"safe": unsafe_p < IMG_UNSAFE_THR, "unsafe_prob": unsafe_p, "probs": probs}
+def image_safe_payload(pil: Image.Image) -> Dict:
+    x = img_tf(pil.convert("RGB")).unsqueeze(0).to(DEVICE)
+    probs = torch.softmax(imgM(x)[0], dim=0).cpu().tolist()
+    up = float(probs[IMG_UNSAFE_INDEX])
+    return {"safe": up < IMG_UNSAFE_THR, "unsafe_prob": up, "probs": probs}
 
 # -------------------------- Audio (ASR -> NLP) ----------------------
 compute_type = "float16" if DEVICE == "cuda" else "int8"
-
-try:
-    asr = WhisperModel(WHISPER_MODEL_NAME, device=DEVICE, compute_type=compute_type)
-except Exception as e:
-    raise RuntimeError(
-        f"Failed to load Whisper model '{WHISPER_MODEL_NAME}': {e}. "
-        f"Tip: ensure ffmpeg is installed (Dockerfile/apt.txt)."
-    )
+asr = WhisperModel(WHISPER_MODEL_NAME, device=DEVICE, compute_type=compute_type)
 
 if not AUD_DIR.exists():
-    raise RuntimeError(f"Audio pipeline dir not found: {AUD_DIR}. Make sure download_assets ran.")
-
-try:
-    text_clf = joblib.load(AUD_DIR / "text_pipeline_balanced.joblib")
-except Exception as e:
-    raise RuntimeError(f"Failed to load audio text pipeline from {AUD_DIR}: {e}")
+    raise RuntimeError(f"Audio pipeline dir not found: {AUD_DIR}. Run download_assets first.")
+text_clf = joblib.load(AUD_DIR / "text_pipeline_balanced.joblib")
 
 def _ffmpeg_to_wav(src_bytes: bytes) -> bytes:
     with tempfile.TemporaryDirectory() as td:
         in_path = pathlib.Path(td) / f"in-{uuid.uuid4().hex}.bin"
         out_path = pathlib.Path(td) / "out.wav"
         in_path.write_bytes(src_bytes)
-        cmd = ["ffmpeg", "-y", "-i", str(in_path), "-ac", "1", "-ar", "16000", str(out_path)]
+        cmd = ["ffmpeg","-y","-i",str(in_path),"-ac","1","-ar","16000",str(out_path)]
         try:
             subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
             return out_path.read_bytes()
         except FileNotFoundError as e:
-            raise RuntimeError("FFmpeg not found. Install it and ensure 'ffmpeg' is on PATH.") from e
+            raise RuntimeError("FFmpeg not found on PATH.") from e
         except subprocess.CalledProcessError:
             return src_bytes
 
 def _transcribe_wav_bytes(wav_bytes: bytes) -> str:
     td = tempfile.mkdtemp()
-    path = pathlib.Path(td) / "in.wav"
+    p = pathlib.Path(td) / "in.wav"
     try:
-        path.write_bytes(wav_bytes)
-        segments, _ = asr.transcribe(str(path), beam_size=5, language="en")
+        p.write_bytes(wav_bytes)
+        segments, _ = asr.transcribe(str(p), beam_size=5, language="en")
         return " ".join(s.text for s in segments).strip()
     finally:
-        try: path.unlink(missing_ok=True)
+        try: p.unlink(missing_ok=True)
         except Exception: pass
         try: pathlib.Path(td).rmdir()
         except Exception: pass
 
-def audio_safe_from_bytes(raw_bytes: bytes) -> Dict:
-    wav = _ffmpeg_to_wav(raw_bytes)
+def audio_safe_from_bytes(raw: bytes) -> Dict:
+    wav = _ffmpeg_to_wav(raw)
     text = _transcribe_wav_bytes(wav)
     proba = text_clf.predict_proba([text])[0].tolist()
-    unsafe_p = float(proba[AUDIO_UNSAFE_INDEX])
-    return {"safe": unsafe_p < AUDIO_UNSAFE_THR, "unsafe_prob": unsafe_p, "text": text, "probs": proba}
+    up = float(proba[AUDIO_UNSAFE_INDEX])
+    return {"safe": up < AUDIO_UNSAFE_THR, "unsafe_prob": up, "text": text, "probs": proba}
 
-# ------------------------------ Routes ------------------------------
-@app.get("/health")
+# ------------------------------ Routes (under /api) ------------------------------
+@app.get("/api/health")
 def health():
     return {
         "ok": True,
@@ -356,7 +251,7 @@ def health():
         "safe_unsafe_indices(text_model)": {"SAFE_ID": SAFE_ID, "UNSAFE_ID": UNSAFE_ID},
     }
 
-@app.post("/check_text")
+@app.post("/api/check_text")
 def check_text(text: str = Form(...)):
     if not text or not text.strip():
         raise HTTPException(400, "Empty text")
@@ -365,7 +260,7 @@ def check_text(text: str = Form(...)):
     except Exception as e:
         raise HTTPException(500, f"Text screening error: {e}")
 
-@app.post("/check_image")
+@app.post("/api/check_image")
 async def check_image(file: UploadFile = File(...)):
     data = await file.read()
     if not data:
@@ -379,7 +274,7 @@ async def check_image(file: UploadFile = File(...)):
     except Exception as e:
         raise HTTPException(500, f"Image screening error: {e}")
 
-@app.post("/check_audio")
+@app.post("/api/check_audio")
 async def check_audio(file: UploadFile = File(...)):
     raw = await file.read()
     if not raw:
@@ -392,7 +287,7 @@ async def check_audio(file: UploadFile = File(...)):
         raise HTTPException(500, f"Audio processing error: {e}")
 
 # --------------------------- Static Mount ---------------------------
-# Serve web UI from /static if it exists; otherwise serve from repo root.
+# Serve UI from /static if present; otherwise from repo root (index.html at root).
 static_dir = BASE / "static"
 root_index = BASE / "index.html"