Update main.py

main.py

@@ -24,14 +24,8 @@ logger = logging.getLogger(__name__)
 FLOW_API_URL = os.getenv("FLOW_API_URL")
 if FLOW_API_URL is None:
     raise RuntimeError("❌ FLOW_API_URL no está definido. Agregalo en los Secrets de Hugging Face.")
-logger.info(f"✅ FLOW_API_URL configurado: {FLOW_API_URL[:30]}...")
 
-# -------------------------------
-# CARGA DEL LANGFLOW_API_KEY DESDE SECRETS
-# -------------------------------
-LANGFLOW_API_KEY = os.getenv("LANGFLOW_API_KEY")
-if LANGFLOW_API_KEY is None:
-    raise RuntimeError("❌ LANGFLOW_API_KEY no está definido. Agregalo en los Secrets de Hugging Face.")
+logger.info(f"✅ FLOW_API_URL configurado: {FLOW_API_URL[:30]}...")
 
 # -------------------------------
 # INICIALIZACIÓN DE LA APP
@@ -63,9 +57,12 @@ async def serve_logo():
     logo_path = "static/te.png"
     if os.path.exists(logo_path):
         return FileResponse(logo_path)
-    svg_content = '''<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
+    else:
+        svg_content = '''<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
+  <!-- Fondo circular -->
   <circle cx="20" cy="20" r="18" fill="#f6ae2d"/>
-  <g transform="translate(20,20)">
+  <!-- Ojo estilizado -->
+  <g transform="translate(20, 20)">
     <path d="M -12 0 Q -6 -6 0 -6 Q 6 -6 12 0 Q 6 6 0 6 Q -6 6 -12 0" fill="#420909" stroke="none"/>
     <circle cx="0" cy="0" r="5" fill="#f6ae2d"/>
     <circle cx="0" cy="0" r="3" fill="#420909"/>
@@ -74,11 +71,11 @@ async def serve_logo():
   <text x="20" y="35" font-family="Arial, sans-serif" font-size="8" font-weight="bold"
         text-anchor="middle" fill="#420909">TE</text>
 </svg>'''
-    return Response(content=svg_content, media_type="image/svg+xml",
-                    headers={"Cache-Control": "public, max-age=3600"})
+        return Response(content=svg_content, media_type="image/svg+xml",
+                        headers={"Cache-Control": "public, max-age=3600"})
 
 # -------------------------------
-# MODELO DE ENTRADA/SALIDA
+# MODELO DE ENTRADA / SALIDA
 # -------------------------------
 class AnalyzeRequest(BaseModel):
     url: str
@@ -94,19 +91,20 @@ class AnalyzeResponse(BaseModel):
 @app.post("/analyze", response_model=AnalyzeResponse)
 async def analyze(request: AnalyzeRequest):
     logger.info(f"📥 Recibida solicitud de análisis para URL: {request.url}")
-    payload = {
-        "input_value": request.url,
-        "output_type": "chat",
-        "input_type": "chat",
-        "tweaks": {}
-    }
-    headers = {
-        "Content-Type": "application/json",
-        "User-Agent": "TrueEye-HuggingFace-Space/1.0",
-        "x-api-key": LANGFLOW_API_KEY
-    }
     try:
-        logger.info("📤 Enviando petición a Langflow…")
+        payload = {
+            "input_value": request.url,
+            "output_type": "chat",
+            "input_type": "chat",
+            "tweaks": {}
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "TrueEye-HuggingFace-Space/1.0"
+        }
+        logger.info("📤 Enviando petición a Langflow...")
+        logger.debug(f"Payload: {payload}")
+
         response = requests.post(
             FLOW_API_URL,
             json=payload,
@@ -115,9 +113,11 @@ async def analyze(request: AnalyzeRequest):
         )
         logger.info(f"📨 Respuesta recibida. Status: {response.status_code}")
         response.raise_for_status()
+
         data = response.json()
+        logger.debug(f"Respuesta JSON: {data}")
 
-        # Extraer texto de la respuesta
+        # Extracción de texto
         result_text = None
         if isinstance(data, dict) and "result" in data:
             result_text = data["result"]
@@ -125,16 +125,13 @@ async def analyze(request: AnalyzeRequest):
             outputs = data["outputs"]
             if outputs and isinstance(outputs, list):
                 for node in outputs[0].get("outputs", []):
-                    msg = node.get("message")
-                    if isinstance(msg, dict):
-                        result_text = msg.get("text", "")
-                    else:
-                        result_text = str(msg)
-                    if result_text:
+                    if "message" in node:
+                        msg = node["message"]
+                        result_text = msg.get("text") if isinstance(msg, dict) else str(msg)
                         break
         if not result_text:
             result_text = _extract_text_from_response(data) or \
-                "⚠️ No se pudo extraer el resultado. Respuesta: " + str(data)[:200]
+                          "⚠️ Se procesó la solicitud pero no se pudo extraer el resultado."
 
         logger.info("✅ Análisis completado exitosamente")
         return AnalyzeResponse(result=result_text)
@@ -142,50 +139,54 @@ async def analyze(request: AnalyzeRequest):
     except requests.exceptions.Timeout:
         logger.error("⏱️ Timeout en la petición a Langflow")
         return AnalyzeResponse(
-            result="❌ Error: Timeout en el análisis.",
-            success=False, error="timeout"
+            result="❌ Error: La solicitud tardó demasiado tiempo.",
+            success=False,
+            error="timeout"
         )
+
     except requests.exceptions.ConnectionError as e:
         logger.error(f"🔌 Error de conexión: {e}")
         return AnalyzeResponse(
-            result="❌ Error: No se pudo conectar al servicio de análisis.",
-            success=False, error="connection"
+            result="❌ Error: No se pudo conectar con el servicio de análisis.",
+            success=False,
+            error="connection"
         )
+
     except requests.exceptions.HTTPError as e:
-        logger.error(f"🚫 Error HTTP: {e}; {e.response.text if e.response else ''}")
+        # <-- Aquí mejora el logging para capturar el body del 500 interno
+        status = e.response.status_code if e.response else "unknown"
+        body   = e.response.text        if e.response else ""
+        logger.error(f"🚫 Error HTTP {status} al llamar al Flow. Body de error:\n{body}")
         return AnalyzeResponse(
-            result=f"❌ Error del servidor: {e}",
-            success=False, error=f"http_{e.response.status_code if e.response else 'unknown'}"
+            result=f"❌ Error del servidor (HTTP {status}). Revisa los logs internos.",
+            success=False,
+            error=f"http_{status}"
         )
+
     except Exception as e:
         logger.exception(f"💥 Error inesperado: {e}")
         return AnalyzeResponse(
-            result=f"❌ Error inesperado: {e}",
-            success=False, error="unknown"
+            result=f"❌ Error inesperado: {str(e)}",
+            success=False,
+            error="unknown"
         )
 
 def _extract_text_from_response(data):
     if isinstance(data, str):
         return data
     if isinstance(data, dict):
-        for key in ['text','message','result','output','content']:
-            v = data.get(key)
-            if isinstance(v, str):
-                return v
-            elif isinstance(v, (dict, list)):
-                r = _extract_text_from_response(v)
-                if r:
-                    return r
-        for v in data.values():
-            if isinstance(v, (dict, list)):
-                r = _extract_text_from_response(v)
-                if r:
-                    return r
+        for key in ['text', 'message', 'result', 'output', 'content']:
+            if key in data:
+                return _extract_text_from_response(data[key]) if isinstance(data[key], (dict, list)) else data[key]
+        for value in data.values():
+            txt = _extract_text_from_response(value)
+            if txt:
+                return txt
     if isinstance(data, list):
         for item in data:
-            r = _extract_text_from_response(item)
-            if r:
-                return r
+            txt = _extract_text_from_response(item)
+            if txt:
+                return txt
     return None
 
 # -------------------------------