Fix/dup first message (#44)

* fixed duplicate user message in chat history on first message sent.

* removed unused chat-sequential endpoint and updated references in docs to chat-stream.

* moved user message db storage from frontend to backend.

* small frontend update to refresh sidebar after message exchange.

README.md

@@ -310,7 +310,7 @@ curl -X POST "http://localhost:8000/switch-provider" \
 - `GET /auth/me` - Get current user profile
 
 ### Chat Endpoints
-- `POST /chat-sequential` - Get responses from all advisors
+- `POST /chat-stream` - Get streaming responses from all advisors (NDJSON)
 - `POST /chat/{persona_id}` - Chat with specific advisor
 - `POST /reply-to-advisor` - Reply to specific advisor message
 

multi_llm_chatbot_backend/README.md

@@ -15,7 +15,7 @@ A modular, extensible FastAPI backend for building an AI-powered research adviso
 ```text
 User Input
    ↓
-/chat-sequential → Orchestrator
+/chat-stream → Orchestrator
      ↓            ↙         ↘
   SessionManager   ContextManager   RAGManager
          ↓              ↓             ↓

multi_llm_chatbot_backend/app/api/README.md

@@ -39,7 +39,7 @@ Uses JWT-based Bearer token auth via FastAPI dependencies.
 
 | Endpoint | Method | Description |
 |----------|--------|-------------|
-| `/chat-sequential` | `POST` | Run a full advisor loop and return all persona responses |
+| `/chat-stream` | `POST` | Stream advisor responses as newline-delimited JSON |
 | `/reply-to-advisor` | `POST` | Ask a question to a specific advisor/persona |
 
 These routes handle:
@@ -166,7 +166,7 @@ JWT tokens are passed via the `Authorization: Bearer ...` header.
 ## High-Level Flow
 
 ```text
-Frontend → /chat-sequential → orchestrator → personas → RAG + LLM → response[]
+Frontend → /chat-stream → orchestrator → personas → RAG + LLM → response[]
         ↘ /upload-document → extractor → RAG chunks → indexed
         ↘ /context or /reset-session → session_manager
         ↘ /export-chat or /chat-summary → utils + formatter

multi_llm_chatbot_backend/app/api/routes/chat.py

@@ -9,6 +9,7 @@ from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 
+from app.api.routes.chat_sessions import persist_message
 from app.api.utils import get_or_create_session_for_request_async
 from app.core.auth import get_current_active_user
 from app.core.bootstrap import chat_orchestrator
@@ -68,7 +69,7 @@ async def chat_stream(
     current_user: User = Depends(get_current_active_user),
 ) -> StreamingResponse:
     """
-    Streaming variant of chat-sequential (newline-delimited JSON).
+    Streaming chat endpoint (newline-delimited JSON).
     @param message: ChatMessage containing user input and optional session/chat IDs
     @param request: FastAPI Request object for session management
     @param current_user: Authenticated user from dependency injection
@@ -77,6 +78,7 @@ async def chat_stream(
 
     async def _event_generator():
         try:
+            # Load or create the in-memory session
             if message.chat_session_id:
                 sid = f"chat_{message.chat_session_id}"
                 if sid not in session_manager.sessions:
@@ -90,15 +92,14 @@ async def chat_stream(
 
             session = session_manager.get_session(sid)
 
-            if (
-                len(session.messages) > 0 and
-                session.messages[-1].get("role") == "user" and
-                session.messages[-1].get("content") == message.user_input
-            ):
-                # TODO: This should be handled in the front-end input
-                logger.warning(f"Repeated user input: {message.user_input}")
-
+            # Append user message to in-memory session and persist to MongoDB
             session.append_message("user", message.user_input)
+            if message.chat_session_id:
+                await persist_message(message.chat_session_id, {
+                    "id": str(ObjectId()),
+                    "type": "user",
+                    "content": message.user_input,
+                })
 
             if chat_orchestrator.needs_clarification(session, message.user_input):
                 clar = await chat_orchestrator.generate_contextual_clarification(message.user_input)
@@ -313,199 +314,6 @@ async def create_new_chat(
         logger.error(f"Error creating new chat: {e}")
         raise HTTPException(status_code=500, detail="Failed to create new chat")
 
-@router.post("/chat-sequential")
-async def chat_sequential_enhanced(
-    message: ChatMessage, 
-    request: Request,
-    current_user: User = Depends(get_current_active_user)
-    ) -> Dict[str, Any]:
-    """
-    Enhanced sequential chat with proper session management, document access, and intelligent persona ordering
-    @param message: ChatMessage containing user input and optional session/chat IDs
-    @param request: FastAPI Request object for session management
-    @param current_user: Authenticated user from dependency injection
-    @return: Dict response with LLM responses if successful, else error details
-    """
-    try:
-        # Ensure consistent session ID for document retrieval
-        if message.chat_session_id:
-            # Use the memory session format that matches document storage
-            session_id = f"chat_{message.chat_session_id}"
-            logger.info(f"Using chat session: {session_id}")
-            
-            # FIXED: Ensure session exists in memory (load if needed)
-            if session_id not in session_manager.sessions:
-                logger.warning(f"Chat session {message.chat_session_id} not in memory, loading now")
-                
-                # FIXED: Pass the user_id parameter to properly load existing session
-                loaded_session_id = await get_or_create_session_for_request_async(
-                    request, 
-                    chat_session_id=message.chat_session_id,
-                    user_id=str(current_user.id)
-                )
-                
-                # Use the loaded session ID
-                session_id = loaded_session_id
-                logger.info(f"Loaded session from database: {session_id}")
-        else:
-            # No specific chat session, create/use ephemeral session
-            session_id = await get_or_create_session_for_request_async(request)
-            logger.info(f"Using ephemeral session: {session_id}")
-
-        # Get session from memory
-        session = session_manager.get_session(session_id)
-        
-        # Log session debugging info
-        rag_stats = session.get_rag_stats()
-        logger.info(f"Session {session_id} has {rag_stats.get('total_documents', 0)} documents available")
-        
-        # Warn if a repeated input message is received
-        if (
-            session.messages and
-            session.messages[-1].get('role') == 'user' and
-            session.messages[-1].get('content') == message.user_input
-            ):
-            # TODO: This should be handled in the front-end input
-            logger.warning(f"Repeated user input: {message.user_input}")
-        session.append_message("user", message.user_input)
-        
-        # Check if the user's message is vague and needs clarification
-        if chat_orchestrator.needs_clarification(session, message.user_input):
-            clarification = await chat_orchestrator.generate_contextual_clarification(
-                message.user_input
-            )
-            logger.info(f"Clarification triggered for input: {message.user_input!r}")
-            return {
-                "status": "clarification_needed",
-                "message": clarification["question"],
-                "suggestions": clarification["suggestions"],
-                "session_debug": {
-                    "session_id": session_id,
-                    "trigger": "vague_input"
-                }
-            }
-
-        # If an enabled tool can handle this query, return its response
-        # directly and skip persona generation.
-        tool_result = await chat_orchestrator.get_tool_response(message.user_input)
-        if tool_result.used_tool:
-            session.append_message("orchestrator", tool_result.text)
-            return {
-                "responses": [{
-                    "persona_id": "orchestrator",
-                    "persona_name": "Orchestrator",
-                    "content": tool_result.text,
-                    "used_documents": False,
-                    "document_chunks_used": 0,
-                }],
-                "session_debug": {
-                    "session_id": session_id,
-                    "tool_used": True,
-                }
-            }
-
-        # RESTORED: Get intelligently ordered personas based on context
-        top_personas = await chat_orchestrator.get_top_personas(
-            session_id=session_id, 
-            k=3  # Limit to top 3 most relevant personas
-        )
-        
-        logger.info(f"Intelligent persona order for session {session_id}: {top_personas}")
-        
-        # Generate responses from ONLY the top personas
-        responses = []
-        
-        for persona_id in top_personas:
-            try:
-                logger.info(f"Generating response for {persona_id} with session {session_id}")
-                
-                # Generate response from this specific persona
-                persona_result = await chat_orchestrator.chat_with_persona(
-                    user_input=message.user_input,
-                    persona_id=persona_id,
-                    session_id=session_id,  # This ensures document access
-                    response_length=message.response_length or "medium"
-                )
-                
-                # FIXED: Safe response processing with proper error handling
-                if isinstance(persona_result, dict):
-                    # Handle different response formats
-                    if "persona_name" in persona_result and "response" in persona_result:
-                        responses.append({
-                            "persona_id": persona_result["persona_id"],
-                            "persona_name": persona_result["persona_name"], 
-                            "content": persona_result["response"],
-                            "used_documents": persona_result.get("used_documents", False),
-                            "document_chunks_used": persona_result.get("document_chunks_used", 0)
-                        })
-                    elif persona_result.get("type") == "single_persona_response" and "persona" in persona_result:
-                        persona_data = persona_result["persona"]
-                        responses.append({
-                            "persona_id": persona_data["persona_id"],
-                            "persona_name": persona_data["persona_name"],
-                            "content": persona_data["response"],
-                            "used_documents": persona_data.get("used_documents", False),
-                            "document_chunks_used": persona_data.get("document_chunks_used", 0)
-                        })
-                    elif "error" in persona_result:
-                        # Handle error responses
-                        responses.append({
-                            "persona_id": persona_id,
-                            "persona_name": chat_orchestrator.personas[persona_id].name,
-                            "content": persona_result["response"],
-                            "used_documents": False,
-                            "document_chunks_used": 0
-                        })
-                    else:
-                        # Generic dict response
-                        content = persona_result.get("response") or persona_result.get("content", "")
-                        if content.strip():
-                            responses.append({
-                                "persona_id": persona_id,
-                                "persona_name": chat_orchestrator.personas[persona_id].name,
-                                "content": content,
-                                "used_documents": persona_result.get("used_documents", False),
-                                "document_chunks_used": persona_result.get("document_chunks_used", 0)
-                            })
-                else:
-                    # Fallback for non-dict responses
-                    responses.append({
-                        "persona_id": persona_id,
-                        "persona_name": chat_orchestrator.personas[persona_id].name,
-                        "content": "I'm having trouble processing your question right now. Please try again.",
-                        "used_documents": False,
-                        "document_chunks_used": 0
-                    })
-                    
-            except Exception as e:
-                logger.error(f"Error generating response for persona {persona_id}: {str(e)}")
-                responses.append({
-                    "persona_id": persona_id,
-                    "persona_name": chat_orchestrator.personas[persona_id].name,
-                    "content": "I encountered an error while processing your question. Please try again.",
-                    "used_documents": False,
-                    "document_chunks_used": 0
-                })
-        
-        return {
-            "responses": responses,
-            "session_debug": {
-                "session_id": session_id,
-                "documents_available": rag_stats.get('total_documents', 0),
-                "chunks_available": rag_stats.get('total_chunks', 0),
-                "valid_responses": len(responses),
-                "selected_personas": top_personas,
-                "total_personas_available": len(chat_orchestrator.personas)
-            }
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in chat_sequential_enhanced: {e}")
-        import traceback
-        logger.error(f"Full traceback: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Chat processing failed: {str(e)}")
-
-
 @router.post("/chat/{persona_id}")
 async def chat_with_specific_advisor(persona_id: str, input: UserInput, request: Request):
     """Chat with a specific advisor - UPDATED"""

multi_llm_chatbot_backend/app/api/routes/chat_sessions.py

@@ -23,6 +23,21 @@ class SaveMessageRequest(BaseModel):
     session_id: str
     message: dict
 
+async def persist_message(session_id: str, message: dict):
+    """Write a single message to a MongoDB chat session."""
+    db = get_database()
+    msg = message.copy()
+    if "timestamp" not in msg:
+        msg["timestamp"] = datetime.utcnow().isoformat()
+    await db.chat_sessions.update_one(
+        {"_id": ObjectId(session_id)},
+        {
+            "$push": {"messages": msg},
+            "$set": {"updated_at": datetime.utcnow()}
+        }
+    )
+
+
 @router.post("/chat-sessions", response_model=dict)
 async def create_chat_session(
     request: CreateChatSessionRequest,
@@ -58,6 +73,7 @@ async def create_chat_session(
             detail="Could not create chat session"
         )
 
+
 @router.get("/chat-sessions", response_model=List[ChatSessionResponse])
 async def get_user_chat_sessions(
     current_user: User = Depends(get_current_active_user),
@@ -227,18 +243,7 @@ async def save_message_to_session(
                 detail="Chat session not found"
             )
         
-        # Add timestamp to message if not present
-        message = request.message.copy()
-        if "timestamp" not in message:
-            message["timestamp"] = datetime.utcnow().isoformat()
-        
-        await db.chat_sessions.update_one(
-            {"_id": ObjectId(session_id)},
-            {
-                "$push": {"messages": message},
-                "$set": {"updated_at": datetime.utcnow()}
-            }
-        )
+        await persist_message(session_id, request.message)
         
         return {"message": "Message saved successfully"}
         

multi_llm_chatbot_backend/app/core/README.md

@@ -129,7 +129,7 @@ This is the main **message routing engine**.
 - Persona-specific fallback logic
 - Session reset/deletion
 
-Used by `/chat-sequential`, `/reply-to-advisor`, etc.
+Used by `/chat-stream`, `/reply-to-advisor`, etc.
 
 ---
 

phd-advisor-frontend/src/components/Sidebar.js

@@ -26,7 +26,8 @@ const Sidebar = ({
   onSidebarToggle,
   isMobileOpen = false,
   onMobileToggle,
-  onNavigateToCanvas
+  onNavigateToCanvas,
+  refreshTrigger
 }) => {
   const { config } = useAppConfig();
   const canvasLabel = config?.app?.title ? `${config.app.title} Canvas` : 'Canvas';
@@ -75,6 +76,13 @@ const Sidebar = ({
     }
   }, [currentSessionId, authToken]);
 
+  // Refresh session list when parent signals a message exchange completed
+  useEffect(() => {
+    if (refreshTrigger > 0 && authToken) {
+      fetchChatSessions();
+    }
+  }, [refreshTrigger]);
+
 
   const fetchChatSessions = async () => {
     try {

phd-advisor-frontend/src/pages/ChatPage.js

@@ -33,6 +33,7 @@ const ChatPage = ({ user, authToken, onNavigateToHome, onNavigateToCanvas, onSig
   const [isSavingSession, setIsSavingSession] = useState(false);
   const [isLoadingSession, setIsLoadingSession] = useState(false);
   const [isMobileMenuOpen, setIsMobileMenuOpen] = useState(false);
+  const [sidebarRefreshTrigger, setSidebarRefreshTrigger] = useState(0);
 
   
 
@@ -380,9 +381,6 @@ const handleNewChat = async (sessionId = null) => {
       }
     }
 
-    // Save user message to database
-    await saveMessageToSession(userMessage);
-
     // Update session title if this is the first message and title is generic
     if (messages.length === 0 && currentSessionTitle.includes('Chat ')) {
       const newTitle = inputMessage.length > 30 
@@ -490,6 +488,7 @@ const handleNewChat = async (sessionId = null) => {
     } finally {
       setIsLoading(false);
       setThinkingAdvisors([]);
+      setSidebarRefreshTrigger(prev => prev + 1);
     }
   };
 
@@ -753,6 +752,7 @@ const handleNewChat = async (sessionId = null) => {
         isMobileOpen={isMobileMenuOpen}
         onMobileToggle={setIsMobileMenuOpen}
         onNavigateToCanvas={onNavigateToCanvas}
+        refreshTrigger={sidebarRefreshTrigger}
       />
       
       <div className={`main-chat-area ${isSidebarCollapsed ? 'sidebar-collapsed' : ''}`}>