feat: upload document feat (#19)

<img width="1512" height="908" alt="Screenshot 2026-03-02 at 7 54 53 PM"
src="https://github.com/user-attachments/assets/8d3e1fcd-291f-4c99-8d3c-9b46148d6405"
/>

Author: Tincho44

app/agents/faq.py

@@ -15,7 +15,7 @@
 import numpy as np
 import yaml
 from jinja2 import Environment, FileSystemLoader
-from langchain_core.messages import AIMessage, SystemMessage
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
 from langchain_openai import ChatOpenAI
 from langgraph.prebuilt import ToolNode
 from langsmith import traceable
@@ -103,24 +103,36 @@ async def __call__(self, state: ConversationState) -> ConversationState:
         logger.debug("[FAQ] __call__ invoked (tool-calling pattern)")
 
         try:
-            messages = list(state.get("messages", []))
-            raw_last = [m.content for m in messages if m.type == "human"]
-            user_message = raw_last[-1] if raw_last else ""
-            if isinstance(user_message, list):
-                text_parts = [
-                    p.get("text", "") for p in user_message
-                    if isinstance(p, dict) and p.get("type") == "text"
-                ]
-                user_message = " ".join(text_parts).strip() or ""
-            else:
-                user_message = (user_message or "").strip() if isinstance(user_message, str) else ""
+            raw_messages = list(state.get("messages", []))
+            messages = self._sanitize_messages(raw_messages)
 
+            user_message = next(
+                (m.content for m in reversed(messages) if isinstance(m, HumanMessage)),
+                "",
+            )
+
+            # Respuesta predefinida para la burbuja "Preguntas frecuentes"
             if _is_preguntas_frecuentes_intent(user_message):
                 logger.info("[FAQ] Respuesta predefinida para 'Preguntas frecuentes'")
                 response = RESPUESTA_PREGUNTAS_FRECUENTES
             else:
+                # Inyectar contenido del documento adjunto si existe
+                doc_context = state.get("document_context")
+                if doc_context:
+                    doc_filename = state.get("document_filename", "documento")
+                    cap = 12_000
+                    snippet = doc_context[:cap] + ("..." if len(doc_context) > cap else "")
+                    for i in range(len(messages) - 1, -1, -1):
+                        if isinstance(messages[i], HumanMessage):
+                            prev = messages[i].content or ""
+                            messages[i] = HumanMessage(
+                                content=f"{prev}\n\n[Documento adjunto: {doc_filename}]\n{snippet}"
+                            )
+                            break
+
                 if not any(isinstance(m, SystemMessage) for m in messages):
                     messages = [self.system_message] + messages
+
                 response = await self._tool_calling_loop(messages)
 
             conv_id = state.get("conversation_id")
@@ -129,7 +141,7 @@ async def __call__(self, state: ConversationState) -> ConversationState:
                     conv_id = await conversation_service.get_or_create_conversation(
                         session, conv_id
                     )
-                    await conversation_service.save_message(session, conv_id, "user", user_message)
+                    await conversation_service.save_message(session, conv_id, "user", user_message or "")
                     await conversation_service.save_message(session, conv_id, "assistant", response)
                     await session.commit()
                 except Exception as db_err:
@@ -169,6 +181,35 @@ async def __call__(self, state: ConversationState) -> ConversationState:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _sanitize_messages(messages: list) -> list:
+        """Ensure every message has ``content`` as a plain string.
+
+        The LangGraph checkpointer (``add_messages``) may replay old
+        ``HumanMessage`` objects whose ``content`` is a list of
+        multimodal parts from before the WS-layer extraction fix.
+        OpenAI rejects these, so we flatten them here.
+        """
+        clean: list = []
+        for m in messages:
+            content = getattr(m, "content", None)
+            if isinstance(content, list):
+                text_parts = [
+                    p.get("text", "")
+                    for p in content
+                    if isinstance(p, dict) and p.get("type") == "text"
+                ]
+                flat = " ".join(t.strip() for t in text_parts).strip() or ""
+                if getattr(m, "type", None) == "ai":
+                    clean.append(AIMessage(content=flat))
+                elif isinstance(m, SystemMessage):
+                    clean.append(SystemMessage(content=flat))
+                else:
+                    clean.append(HumanMessage(content=flat))
+            else:
+                clean.append(m)
+        return clean
+
     @traceable(run_type="chain")
     async def _tool_calling_loop(
         self,

app/agents/supervisor.py

@@ -21,6 +21,7 @@
     ROUTABLE_AGENTS,
 )
 from ..graph.state import ConversationState
+from ..graph.document_extractor import extract_text_from_message
 
 logger = logging.getLogger(__name__)
 
@@ -57,15 +58,21 @@ async def route_message(self, state: ConversationState) -> ConversationState:
         """Analiza el mensaje del usuario y decide el routing."""
 
         messages = state.get("messages", [])
-        chat_history = [m.content for m in messages if m.type == "human"]
-        user_message = chat_history[-1].strip()
-
-        logger.debug("=" * 60)
-        logger.debug("[SUPERVISOR] route_message called")
-        logger.debug(f"[SUPERVISOR] User message: {user_message!r}")
-        logger.debug(f"[SUPERVISOR] Total messages in state: {len(messages)}")
-        for i, m in enumerate(messages):
-            logger.debug(f"[SUPERVISOR]   msg[{i}] type={m.type} content={m.content[:100]!r}...")
+        human_messages = [m for m in messages if m.type == "human"]
+
+        user_message = (
+            extract_text_from_message(human_messages[-1]).strip()
+            if human_messages
+            else ""
+        )
+
+        has_doc = bool(state.get("document_context"))
+        logger.info(
+            "[SUPERVISOR] route_message: user=%r has_doc=%s doc_file=%r",
+            user_message[:80],
+            has_doc,
+            state.get("document_filename"),
+        )
 
         # 1. Estado: si hay wizard activo, mantenerlo sin llamar al LLM
         wizard_state_obj = state.get("wizard_state")
@@ -82,7 +89,11 @@ async def route_message(self, state: ConversationState) -> ConversationState:
                 return self._route_to(state, "wizard")
 
         # 2. Routing basado 100% en LLM usando contexto conversacional completo
-        intention = await self._route_by_descriptions(user_message, messages)
+        intention = await self._route_by_descriptions(
+            user_message,
+            messages,
+            state=state,
+        )
 
         state["supervisor_decision"] = intention
         state["current_agent"] = intention
@@ -106,7 +117,13 @@ def decide_next_agent(self, state: ConversationState) -> str:
     # ------------------------------------------------------------------
 
     @traceable(run_type="llm")
-    async def _route_by_descriptions(self, message: str, messages: list) -> str:
+    async def _route_by_descriptions(
+        self,
+        message: str,
+        messages: list,
+        *,
+        state: ConversationState | None = None,
+    ) -> str:
         """Usa el LLM para elegir el agente cuya descripción mejor
         coincide con la intención del usuario."""
 
@@ -116,17 +133,31 @@ async def _route_by_descriptions(self, message: str, messages: list) -> str:
                 f'- "{name}": {description}'
                 for name, description in ROUTABLE_AGENTS
             )
-            valid_names = ", ".join(
-                f'"{name}"' for name, _ in ROUTABLE_AGENTS
-            )
+            valid_names = ", ".join(f'"{name}"' for name, _ in ROUTABLE_AGENTS)
 
-            # Contexto conversacional completo (últimos turnos user/assistant)
-            context = ""
+            # Contexto conversacional (últimos turnos + documento si existe)
+            context_lines = []
             if messages:
-                context = "\n".join(
-                    f"- {'Usuario' if msg.type == 'human' else 'Asistente'}: {msg.content}"
-                    for msg in messages[-6:]
+                for msg in messages[-6:]:
+                    role = "Usuario" if msg.type == "human" else "Asistente"
+                    text = extract_text_from_message(msg)
+                    context_lines.append(f"- {role}: {text}")
+
+            if state and state.get("document_context"):
+                filename = state.get("document_filename", "documento")
+                doc_len = len(state.get("document_context") or "")
+                context_lines.append(
+                    f"- [Sistema]: El usuario ha adjuntado el documento: {filename!r}"
                 )
+                logger.info(
+                    "[SUPERVISOR] Documento inyectado en contexto de routing: file=%r, %d chars",
+                    filename,
+                    doc_len,
+                )
+            else:
+                logger.info("[SUPERVISOR] No hay document_context en state, no se inyecta documento.")
+
+            context = "\n".join(context_lines)
 
             system_prompt = _prompts.get_template("supervisor_system.j2").render()
             prompt = _prompts.get_template("supervisor_route.j2").render(

app/api/v1/agui_ws.py

@@ -25,6 +25,45 @@ def _agui_event(event_type: str, **fields) -> str:
     return json.dumps({"type": event_type, **fields})
 
 
+def _extract_text_and_attachment(
+    raw_message,
+) -> tuple[str, dict | None]:
+    """Split a raw WS message into (text, attachment_dict|None).
+
+    ``raw_message`` can be:
+    - ``str`` – plain text, no attachment.
+    - ``list`` – multimodal parts from the frontend
+      (``{type:"text", text:"…"}``, ``{type:"file", filename:"…", data:"…", media_type:"…"}``).
+    """
+    if isinstance(raw_message, str):
+        return raw_message.strip(), None
+
+    if not isinstance(raw_message, list) or not raw_message:
+        return "", None
+
+    text_parts: list[str] = []
+    attachment: dict | None = None
+
+    for part in raw_message:
+        if not isinstance(part, dict):
+            continue
+        ptype = part.get("type", "")
+        if ptype == "text":
+            text_parts.append(part.get("text", ""))
+        elif ptype in ("file", "document") and attachment is None:
+            attachment = {
+                "filename": part.get("filename") or part.get("name") or "document",
+                "data": part.get("data") or part.get("source") or "",
+                "media_type": part.get("media_type", "application/octet-stream"),
+            }
+
+    text = " ".join(t.strip() for t in text_parts).strip()
+    if not text and attachment:
+        text = f"[Documento adjunto: {attachment['filename']}]"
+
+    return text, attachment
+
+
 @router.websocket("/ws")
 async def agui_websocket(
     websocket: WebSocket,
@@ -46,8 +85,17 @@ async def agui_websocket(
                 )
                 continue
 
-            user_message = data.get("message", "").strip()
-            if not user_message:
+            raw_message = data.get("message")
+            user_message, attachment = _extract_text_and_attachment(raw_message)
+
+            logger.info(
+                "[AG-UI] Incoming message type=%s, text_len=%d, has_attachment=%s",
+                type(raw_message).__name__,
+                len(user_message),
+                attachment is not None,
+            )
+
+            if not user_message and not attachment:
                 await websocket.send_text(
                     _agui_event("RUN_ERROR", message="Empty message", code="BAD_REQUEST")
                 )
@@ -66,6 +114,7 @@ async def agui_websocket(
                     message=user_message,
                     conversation_id=conversation_id,
                     wizard_state=wizard_state,
+                    attachment=attachment,
                 )
 
                 response_text = result.get("response", "")