Update app.py

app.py

@@ -9,54 +9,70 @@ import base64
 from PIL import Image
 import io
 
-# --- CONFIGURACIÓN ---
+# --- CONFIGURACIÓN DE MODELO Y RUTAS ---
 MODEL_REPO = "CharlieBonito/clarity-guard-gemma4-7b"
 MODEL_FILE = "Checkpoint-375-Ollama-Clean-7.5B-Q4_K_M.gguf"
 MMPROJ_FILE = "mmproj-Checkpoint-375-Ollama-Clean-BF16.gguf"
-
 LLAMA_SERVER = "/opt/llama-cpp/llama-server"
 MODEL_DIR = "/app/models"
-SERVER_URL = "http://127.0.0.1:8080"
-
 server_process = None
+SERVER_URL = "http://127.0.0.1:8080"
 
-# --- SYSTEM PROMPT ---
+# --- SYSTEM PROMPT (ClarityGuard v4.4) ---
 CLARITYGUARD_PROMPT = """# CLARITYGUARD ASSISTANT — NEURO-INCLUSIVE EDITION v4.4
 **Language policy:** Reply in the same language the user uses.
-Comienza siempre con: "Got it.", "Sure!", "Hi there!" o "Understood."
+**Response initialization:** Every response must begin with a natural opener: "Got it.", "Sure!", "Hi there!" or "Understood."
+---
+## IDENTITY AND PURPOSE
+You are **ClarityGuard**, specialized in clarity support for neurodivergent and autistic people in workplace and personal settings.
+**Core function:** Determine whether the user's confusion originates in the **structure of the message**—not in a "failure" of the user.
+**Foundational principle:** When a message lacks a clear subject, defined action, concrete date, or measurable criterion, confusion is the logical response to incomplete input. It is a **protocol mismatch**, not a cognitive error.
+---
+## ANALYSIS PROCESS (internal - never show to user)
+C: [0–10] | F: [0–10] | R: [0–10] | V: [0–10] | A: [0–10]
+TOTAL: [sum] / 50
+Response modes:
+- 0–10: Clear message. Confirm briefly.
+- 11–20: Name the ambiguous element, suggest one clarification question.
+- 21–30: Full analysis + clarification suggestion.
+- 31–50: Full 4-step response + cognitive protection.
+---
+## RESPONSE STRUCTURE (4 STEPS)
+### STEP 1 — ANALYSIS
+🔍 **[ClarityGuard] C.F.R.V.A. score: XX/50 → [level]**
+Explain what creates confusion using descriptive language about message structure.
+### STEP 2 — COGNITIVE PROTECTION (only if score ≥ 21)
+🔒 **Your confusion is not a failure. It is the correct response to an incomplete message.**
+### STEP 3 — CONCRETE ACTION (Read-Back)
+✍️ **Clarification suggestion:**
+Offer a concrete clarification question.
+### STEP 4 — FOLLOW-UP PLAN (only if score ≥ 31)
+⏰ If clarification is still abstract, apply adjective decomposition.
 ---
-**Version:** ClarityGuard v4.4"""
+## OPERATIONAL RULES
+1. If the message is clear, say so. 2. If ambiguous, name the missing element. 3. Protect against self-invalidation when score ≥ 21. 4. Never diagnose the sender. 5. Never attribute confusion to the user's cognitive profile. 6. Match length to channel. 7. Reply in the user's language. 8. Never output internal scoring.
+---
+**Version:** ClarityGuard v4.4 — Neuro-inclusive"""
 
 
-# --- DESCARGA DE MODELOS ---
 def download_models():
+    """Descarga los modelos desde el Hub de Hugging Face."""
     from huggingface_hub import hf_hub_download
-
     os.makedirs(MODEL_DIR, exist_ok=True)
+    print(f"[ClarityGuard] Descargando modelos en {MODEL_DIR}...")
+    m_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE, local_dir=MODEL_DIR)
+    mm_path = hf_hub_download(repo_id=MODEL_REPO, filename=MMPROJ_FILE, local_dir=MODEL_DIR)
+    print("[ClarityGuard] Modelos descargados.")
+    return m_path, mm_path
 
-    model_path = hf_hub_download(
-        repo_id=MODEL_REPO,
-        filename=MODEL_FILE,
-        local_dir=MODEL_DIR
-    )
-
-    mmproj_path = hf_hub_download(
-        repo_id=MODEL_REPO,
-        filename=MMPROJ_FILE,
-        local_dir=MODEL_DIR
-    )
-
-    return model_path, mmproj_path
 
-
-# --- INICIAR LLAMA SERVER ---
 def start_server():
+    """Inicia el binario llama-server con soporte CUDA y multimodal."""
     global server_process
-
     if server_process is not None and server_process.poll() is None:
-        return True
+        return server_process
 
-    model_path, mmproj_path = download_models()
+    m_path, mm_path = download_models()
 
     env = os.environ.copy()
     env["LD_LIBRARY_PATH"] = (
@@ -66,99 +82,75 @@ def start_server():
 
     cmd = [
         LLAMA_SERVER,
-        "-m", model_path,
-        "--mmproj", mmproj_path,
+        "-m", m_path,
+        "--mmproj", mm_path,
         "--host", "127.0.0.1",
         "--port", "8080",
-        "-c", "8192",
+        "-c", "16384",
         "-ngl", "99",
-        "--jinja"
+        "--jinja",
+        "--log-disable",
     ]
 
-    print("Iniciando llama-server...")
-    print(" ".join(cmd))
-
-    server_process = subprocess.Popen(
-        cmd,
-        env=env,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True
-    )
+    print(f"[ClarityGuard] Lanzando servidor: {' '.join(cmd)}")
+    server_process = subprocess.Popen(cmd, env=env)
 
-    def log_reader():
-        for line in iter(server_process.stdout.readline, ""):
-            print(f"[LLAMA] {line.strip()}")
-
-    threading.Thread(target=log_reader, daemon=True).start()
-
-    # Espera hasta 4 minutos porque en Space puede tardar cargando GGUF + mmproj
-    for _ in range(120):
+    for _ in range(45):
         try:
-            response = requests.get(f"{SERVER_URL}/health", timeout=2)
-            if response.status_code == 200:
-                print("llama-server iniciado correctamente.")
-                return True
+            if requests.get(f"{SERVER_URL}/health", timeout=1).status_code == 200:
+                print("[ClarityGuard] Servidor Llama-CPP listo.")
+                return server_process
         except Exception:
-            pass
-
-        time.sleep(2)
+            time.sleep(2)
 
-    print("Error: llama-server no respondió en /health.")
-    return False
+    print("[ClarityGuard] Advertencia: el servidor puede no estar listo.")
+    return server_process
 
 
-# --- IMAGEN A BASE64 ---
 def image_to_base64(image_path: str) -> str:
+    """Convierte una imagen a base64 para enviarla al servidor."""
     with Image.open(image_path) as img:
+        # Convertir a RGB si es necesario (por ejemplo, PNG con transparencia)
         if img.mode in ("RGBA", "P"):
             img = img.convert("RGB")
-
         buffer = io.BytesIO()
         img.save(buffer, format="JPEG", quality=85)
-
         return base64.b64encode(buffer.getvalue()).decode("utf-8")
 
 
-# --- RESPUESTA DEL MODELO ---
-def respond(message, image_path, history):
-    if not start_server():
-        yield "⚠️ Error: El servidor llama.cpp no inició. Revisa los logs de [LLAMA]."
-        return
+def respond(message: str, image_path, history: list):
+    """
+    Genera la respuesta del modelo.
+    history: lista de tuplas (user_msg, assistant_msg)
+    image_path: ruta a imagen opcional (str o None)
+    """
+    start_server()
 
     messages = [{"role": "system", "content": CLARITYGUARD_PROMPT}]
 
-    # Gradio 6 usa historial tipo messages: {"role": "...", "content": "..."}
-    for item in history or []:
-        if isinstance(item, dict) and "role" in item and "content" in item:
-            clean_content = str(item["content"]).replace(" [📎 imagen adjunta]", "")
-            messages.append({
-                "role": item["role"],
-                "content": clean_content
-            })
+    # Historial previo
+    for user_msg, assistant_msg in history:
+        if assistant_msg:
+            messages.append({"role": "user", "content": user_msg})
+            messages.append({"role": "assistant", "content": assistant_msg})
 
+    # Mensaje actual — con o sin imagen
     if image_path:
-        image_b64 = image_to_base64(image_path)
-
-        user_content = [
-            {
-                "type": "image_url",
-                "image_url": {
-                    "url": f"data:image/jpeg;base64,{image_b64}"
-                }
-            },
-            {
-                "type": "text",
-                "text": message or "Analiza esta imagen."
-            }
-        ]
+        try:
+            img_b64 = image_to_base64(image_path)
+            user_content = [
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"},
+                },
+                {"type": "text", "text": message if message.strip() else "Analiza este mensaje de la imagen."},
+            ]
+        except Exception as e:
+            user_content = message + f"\n[Error cargando imagen: {e}]"
     else:
-        user_content = message or ""
+        user_content = message
 
-    messages.append({
-        "role": "user",
-        "content": user_content
-    })
+    messages.append({"role": "user", "content": user_content})
 
     try:
         response = requests.post(
@@ -166,140 +158,131 @@ def respond(message, image_path, history):
             json={
                 "messages": messages,
                 "stream": True,
-                "temperature": 0.3,
-                "max_tokens": 1024
+                "temperature": 0.7,
+                "max_tokens": 2048,
             },
             stream=True,
-            timeout=300
+            timeout=120,
         )
 
-        if response.status_code != 200:
-            yield f"⚠️ Error del servidor llama.cpp: {response.status_code}\n\n{response.text}"
-            return
-
         full_response = ""
-
         for line in response.iter_lines():
-            if not line:
-                continue
-
-            decoded = line.decode("utf-8")
-
-            if not decoded.startswith("data: "):
-                continue
-
-            content = decoded[6:]
-
-            if content.strip() == "[DONE]":
-                break
-
-            try:
-                data = json.loads(content)
-                delta = data["choices"][0].get("delta", {})
-                token = delta.get("content", "")
-
-                if token:
-                    full_response += token
-                    yield full_response
-
-            except Exception:
-                continue
+            if line:
+                chunk_decoded = line.decode("utf-8")
+                if chunk_decoded.startswith("data: "):
+                    content = chunk_decoded[6:]
+                    if content.strip() == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(content)
+                        if "choices" in data:
+                            delta = data["choices"][0].get("delta", {}).get("content", "")
+                            full_response += delta
+                            yield full_response
+                    except Exception:
+                        continue
 
     except Exception as e:
-        yield f"⚠️ Error consultando llama.cpp: {str(e)}"
+        yield f"⚠️ Error de conexión con el servidor: {str(e)}"
 
 
-# --- INTERFAZ GRADIO 6 ---
+# --- INTERFAZ DE GRADIO ---
 with gr.Blocks(title="ClarityGuard v4.4") as demo:
-    gr.Markdown("# 🔍 ClarityGuard v4.4")
 
-    chatbot = gr.Chatbot(height=520)
+    gr.Markdown(
+        """# 🔍 ClarityGuard v4.4
+Análisis de comunicación neuro-inclusiva. Pega un mensaje, adjunta una captura de pantalla o ambos."""
+    )
+
+    # type="tuples" es obligatorio en Gradio 6 para usar listas de pares
+    chatbot = gr.Chatbot(height=520, type="tuples", label="ClarityGuard")
 
     with gr.Row():
         msg_input = gr.Textbox(
-            placeholder="Mensaje...",
-            scale=4
+            label="Mensaje a analizar",
+            placeholder="Pega aquí el texto que quieres analizar...",
+            lines=3,
+            scale=4,
         )
-
         image_input = gr.Image(
+            label="📎 Captura / Imagen",
             type="filepath",
-            scale=1
+            sources=["upload", "clipboard"],
+            scale=1,
+            height=120,
         )
 
     with gr.Row():
-        submit_btn = gr.Button("🔍 Analizar", variant="primary")
-        clear_btn = gr.Button("🗑️ Limpiar")
+        submit_btn = gr.Button("🔍 Analizar", variant="primary", scale=3)
+        clear_btn = gr.Button("🗑️ Limpiar", scale=1)
+
+    gr.Examples(
+        examples=[
+            ["\"Nos vemos el lunes por la tarde.\"", None],
+            ["\"Necesitamos arreglar esto ASAP.\"", None],
+            ["\"Sé más proactivo en las reuniones.\"", None],
+            ["\"Estaré de vuelta en 5 minutos.\"", None],
+        ],
+        inputs=[msg_input, image_input],
+    )
+
+    # --- Handlers ---
 
     def user_action(message, image, history):
+        """Agrega el turno del usuario al historial y limpia los inputs."""
         history = history or []
-
-        display = message or ""
-
+        display_msg = message or ""
         if image:
-            display += " [📎 imagen adjunta]"
-
-        history.append({
-            "role": "user",
-            "content": display
-        })
-
-        return "", None, history
+            display_msg = (display_msg + " [📎 imagen adjunta]").strip()
+        return "", None, history + [[display_msg, None]]
 
     def bot_action(message, image, history):
-        history = history or []
-
-        real_msg = message or ""
-
-        if not real_msg.strip() and image:
-            real_msg = "Analiza la imagen."
-
-        clean_history = []
-
-        for item in history[:-1]:
-            if isinstance(item, dict):
-                clean_history.append({
-                    "role": item["role"],
-                    "content": str(item["content"]).replace(" [📎 imagen adjunta]", "")
-                })
-
-        history.append({
-            "role": "assistant",
-            "content": ""
-        })
+        """Genera la respuesta del bot con streaming."""
+        # El mensaje real (sin el tag de imagen) para enviarlo al modelo
+        real_message = message or ""
+        if not real_message.strip() and image:
+            real_message = "Analiza este mensaje de la imagen."
+
+        history_pairs = [
+            [h[0].replace(" [📎 imagen adjunta]", ""), h[1]]
+            for h in history[:-1]
+            if h[1] is not None
+        ]
 
-        for chunk in respond(real_msg, image, clean_history):
-            history[-1]["content"] = chunk
+        history[-1][1] = ""
+        for chunk in respond(real_message, image, history_pairs):
+            history[-1][1] = chunk
             yield history
 
+    # Guardamos message e image antes de limpiarlos para usarlos en bot_action
     submit_btn.click(
         user_action,
         inputs=[msg_input, image_input, chatbot],
-        outputs=[msg_input, image_input, chatbot]
+        outputs=[msg_input, image_input, chatbot],
     ).then(
         bot_action,
         inputs=[msg_input, image_input, chatbot],
-        outputs=[chatbot]
+        outputs=[chatbot],
     )
 
     msg_input.submit(
         user_action,
         inputs=[msg_input, image_input, chatbot],
-        outputs=[msg_input, image_input, chatbot]
+        outputs=[msg_input, image_input, chatbot],
     ).then(
         bot_action,
         inputs=[msg_input, image_input, chatbot],
-        outputs=[chatbot]
+        outputs=[chatbot],
     )
 
-    clear_btn.click(
-        lambda: ([], "", None),
-        outputs=[chatbot, msg_input, image_input]
-    )
+    clear_btn.click(lambda: (None, [], None), outputs=[msg_input, chatbot, image_input], queue=False)
 
 
 if __name__ == "__main__":
+    threading.Thread(target=start_server, daemon=True).start()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        theme=gr.themes.Soft()
+        ssr_mode=False,
+        theme=gr.themes.Soft(),
     )