Update app.py

app.py

@@ -9,21 +9,57 @@ 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"
-# Usamos 0.0.0.0 para evitar restricciones de interfaz local
-SERVER_URL = "http://0.0.0.0:8080" 
+SERVER_URL = "http://0.0.0.0:8080" # Usamos 0.0.0.0 para estabilidad
 
 server_process = None
 
+# --- SYSTEM PROMPT (ClarityGuard v4.4 completo) ---
+CLARITYGUARD_PROMPT = """# CLARITYGUARD ASSISTANT — NEURO-INCLUSIVE EDITION v4.4
+**Language policy:** Reply in the same language the user uses.
+**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.
+---
+## 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"""
+
+# --- FUNCIONES DEL SERVIDOR ---
 def download_models():
     from huggingface_hub import hf_hub_download
     os.makedirs(MODEL_DIR, exist_ok=True)
-    print("[DEBUG] Verificando modelos...")
+    print("[DEBUG] Verificando/Descargando modelos...")
     m = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE, local_dir=MODEL_DIR)
     mm = hf_hub_download(repo_id=MODEL_REPO, filename=MMPROJ_FILE, local_dir=MODEL_DIR)
     return m, mm
@@ -33,113 +69,172 @@ def start_server():
     if server_process is not None and server_process.poll() is None:
         return True
 
-    print("[DEBUG] Iniciando Llama Server...")
     m_path, mm_path = download_models()
-
-    # CRÍTICO: Configurar las rutas de las librerías .so que el Docker copió
-    env = os.environ.copy()
-    env["LD_LIBRARY_PATH"] = f"/usr/local/lib:/usr/lib/x86_64-linux-gnu:{env.get('LD_LIBRARY_PATH', '')}"
     
+    # LD_LIBRARY_PATH es vital para que encuentre las librerías compiladas .so
+    env = os.environ.copy()
+    env["LD_LIBRARY_PATH"] = f"/usr/local/lib:/usr/local/cuda/lib64:/opt/llama-cpp:{env.get('LD_LIBRARY_PATH', '')}"
+
     cmd = [
         LLAMA_SERVER,
         "-m", m_path,
         "--mmproj", mm_path,
         "--host", "0.0.0.0",
         "--port", "8080",
-        "-c", "8192",      # Bajamos un poco el contexto para asegurar estabilidad inicial
+        "-c", "8192",
         "-ngl", "99",
         "--jinja"
     ]
 
-    # Capturamos stdout y stderr para ver el error real en los logs
+    print("[DEBUG] Lanzando Llama Server...")
     server_process = subprocess.Popen(
-        cmd, 
-        env=env,
-        stdout=subprocess.PIPE, 
-        stderr=subprocess.STDOUT,
-        text=True,
-        bufsize=1 # Line buffered
+        cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1
     )
 
-    # Hilo para imprimir los logs del servidor de IA en la consola de Gradio
+    # Hilo para ver qué dice el servidor en los logs
     def log_reader():
         for line in iter(server_process.stdout.readline, ""):
-            print(f"[LLAMA-SERVER] {line.strip()}")
-    
+            print(f"[IA-LOG] {line.strip()}")
     threading.Thread(target=log_reader, daemon=True).start()
 
-    # Verificación de conexión
-    for i in range(30):
-        if server_process.poll() is not None:
-            print("[ERROR] El servidor de IA se cerró inmediatamente. Revisa los logs arriba.")
-            return False
+    # Esperar conexión
+    for i in range(45):
+        if server_process.poll() is not None: return False
         try:
             if requests.get(f"{SERVER_URL}/health", timeout=2).status_code == 200:
-                print("[DEBUG] Servidor conectado exitosamente.")
+                print("[DEBUG] Servidor de IA conectado en puerto 8080.")
                 return True
         except:
-            if i % 5 == 0: print(f"[DEBUG] Esperando al servidor... (intento {i})")
-            time.sleep(3)
+            time.sleep(2)
     return False
 
+def image_to_base64(image_path: str) -> str:
+    with Image.open(image_path) as img:
+        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")
+
 # --- LÓGICA DE RESPUESTA ---
-def respond(message, image, history):
+def respond(message: str, image_path, history: list):
     if not start_server():
-        yield "⚠️ Error: El servidor de IA no pudo arrancar. Mira la consola para ver el fallo de librería (.so)."
+        yield "⚠️ Error: El servidor de IA no responde. Revisa los logs de la consola."
         return
 
-    # Formato Gradio 6 (lista de dicts)
-    messages = [{"role": "system", "content": "You are ClarityGuard."}]
-    for m in history:
-        messages.append({"role": m["role"], "content": m["content"]})
-
-    # ... (Aquí va tu lógica de procesar imagen a base64 si existe) ...
+    messages = [{"role": "system", "content": CLARITYGUARD_PROMPT}]
     
+    # Historial en formato Gradio 6 (lista de dicts)
+    for msg in history:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
+    # Contenido multimodal
+    if image_path:
+        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 esta imagen."}
+            ]
+        except Exception as e:
+            user_content = message + f"\n[Error de imagen: {e}]"
+    else:
+        user_content = message
+
+    messages.append({"role": "user", "content": user_content})
+
     try:
         r = requests.post(
             f"{SERVER_URL}/v1/chat/completions",
-            json={"messages": messages, "stream": True},
-            stream=True
+            json={"messages": messages, "stream": True, "temperature": 0.7},
+            stream=True, timeout=120
         )
         full_res = ""
         for line in r.iter_lines():
             if line:
-                decoded = line.decode("utf-8")[6:]
-                if decoded.strip() == "[DONE]": break
-                try:
-                    data = json.loads(decoded)
-                    content = data["choices"][0].get("delta", {}).get("content", "")
-                    full_res += content
-                    yield full_res
-                except: continue
+                chunk = line.decode("utf-8")
+                if chunk.startswith("data: "):
+                    content = chunk[6:]
+                    if content.strip() == "[DONE]": break
+                    try:
+                        data = json.loads(content)
+                        full_res += data["choices"][0].get("delta", {}).get("content", "")
+                        yield full_res
+                    except: continue
     except Exception as e:
         yield f"⚠️ Error de conexión: {str(e)}"
 
-# --- INTERFAZ ---
+# --- INTERFAZ GRADIO 6 ---
 with gr.Blocks(title="ClarityGuard v4.4") as demo:
     gr.Markdown("# 🔍 ClarityGuard v4.4")
-    chatbot = gr.Chatbot(height=500, label="Historial")
+    gr.Markdown("Análisis neuro-inclusivo. Captura de pantalla o texto.")
+
+    chatbot = gr.Chatbot(height=520, label="ClarityGuard")
+
     with gr.Row():
-        msg = gr.Textbox(placeholder="Mensaje...", scale=4)
-        img = gr.Image(type="filepath", scale=1)
-    
-    def user_fn(m, i, h):
-        h = h or []
-        h.append({"role": "user", "content": m or "[Imagen]"})
-        return "", None, h
-
-    def bot_fn(m, i, h):
-        h.append({"role": "assistant", "content": ""})
-        # Pasamos el historial excluyendo el último vacío
-        for chunk in respond(m, i, h[:-1]):
-            h[-1]["content"] = chunk
-            yield h
-
-    msg.submit(user_fn, [msg, img, chatbot], [msg, img, chatbot]).then(
-        bot_fn, [msg, img, chatbot], [chatbot]
+        msg_input = gr.Textbox(label="Mensaje", placeholder="Escribe aquí...", lines=3, scale=4)
+        image_input = gr.Image(label="📎 Captura", type="filepath", sources=["upload", "clipboard"], scale=1, height=120)
+
+    with gr.Row():
+        submit_btn = gr.Button("🔍 Analizar", variant="primary", scale=3)
+        clear_btn = gr.Button("🗑️ Limpiar", scale=1)
+
+    # RE-AGREGADOS: Los ejemplos que se habían perdido
+    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):
+        if history is None: history = []
+        display_text = message or ""
+        if image:
+            display_text = (display_text + " [📎 imagen adjunta]").strip()
+        history.append({"role": "user", "content": display_text})
+        return history
+
+    def bot_action(message, image, history):
+        real_msg = message or ""
+        if not real_msg.strip() and image:
+            real_msg = "Analiza este mensaje de la imagen."
+
+        # Limpiar historial de tags visuales para la IA
+        clean_history = []
+        for m in history[:-1]:
+            content = m["content"].replace(" [📎 imagen adjunta]", "")
+            clean_history.append({"role": m["role"], "content": content})
+
+        history.append({"role": "assistant", "content": ""})
+        for chunk in respond(real_msg, image, clean_history):
+            history[-1]["content"] = chunk
+            yield history
+
+    def clear_inputs():
+        return "", None
+
+    # Flujo: Usuario -> Bot -> Limpiar cajas
+    submit_btn.click(user_action, [msg_input, image_input, chatbot], [chatbot]).then(
+        bot_action, [msg_input, image_input, chatbot], [chatbot]
+    ).then(
+        clear_inputs, outputs=[msg_input, image_input]
+    )
+
+    msg_input.submit(user_action, [msg_input, image_input, chatbot], [chatbot]).then(
+        bot_action, [msg_input, image_input, chatbot], [chatbot]
+    ).then(
+        clear_inputs, outputs=[msg_input, image_input]
+    )
+
+    clear_btn.click(lambda: ([], "", None), outputs=[chatbot, msg_input, image_input])
+
 if __name__ == "__main__":
-    # Importante: No arrancar el servidor en un hilo aparte aquí, 
-    # dejar que la primera petición o el arranque de Gradio lo haga para ver errores.
-    demo.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        theme=gr.themes.Soft()
+    )