add document auth

multi_llm_chatbot_backend/app/api/routes/chat.py

@@ -49,11 +49,13 @@ async def switch_to_chat(
     current_user: User = Depends(get_current_active_user)
 ):
     """
-    Switch to an existing chat session and load its context
-    FIXED VERSION - Returns messages in correct frontend format
+    Switch to an existing chat session and load its context - FIXED VERSION
+    Ensures documents are accessible after switching
     """
     try:
-        # Load the chat session into memory context
+        logger.info(f"Switching to chat session: {request.chat_session_id}")
+        
+        # Load the chat session into memory context with consistent session ID
         memory_session_id = await get_or_create_session_for_request_async(
             req, 
             chat_session_id=request.chat_session_id,
@@ -63,9 +65,15 @@ async def switch_to_chat(
         if not memory_session_id:
             raise HTTPException(status_code=404, detail="Chat session not found")
         
+        logger.info(f"Loaded chat into memory session: {memory_session_id}")
+        
         # Get the loaded session
         session = session_manager.get_session(memory_session_id)
         
+        # Verify document access after loading
+        rag_stats = session.get_rag_stats()
+        logger.info(f"After switch - Session {memory_session_id} has {rag_stats.get('total_documents', 0)} documents")
+        
         # Get the original MongoDB chat session to retrieve messages in proper format
         db = get_database()
         chat_session = await db.chat_sessions.find_one({
@@ -80,7 +88,7 @@ async def switch_to_chat(
         # Return the messages in the original frontend format from MongoDB
         original_messages = chat_session.get("messages", [])
         
-        logger.info(f"Switching to chat {request.chat_session_id} with {len(original_messages)} messages")
+        logger.info(f"Switch successful - {len(original_messages)} messages, {rag_stats.get('total_documents', 0)} documents")
         
         return {
             "status": "success",
@@ -89,14 +97,28 @@ async def switch_to_chat(
             "message_count": len(original_messages),
             "context": {
                 "messages": original_messages,  # Return original format messages
-                "rag_info": session.get_rag_stats()
+                "rag_info": rag_stats
+            },
+            # Include document access verification
+            "document_access": {
+                "total_documents": rag_stats.get('total_documents', 0),
+                "total_chunks": rag_stats.get('total_chunks', 0),
+                "documents": rag_stats.get('documents', []),
+                "uploaded_files": session.uploaded_files
+            },
+            "debug_info": {
+                "memory_session_format": memory_session_id,
+                "documents_accessible": rag_stats.get('total_documents', 0) > 0,
+                "session_loaded": memory_session_id in session_manager.sessions
             }
         }
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error switching to chat: {e}")
+        logger.error(f"Error switching to chat {request.chat_session_id}: {e}")
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         raise HTTPException(status_code=500, detail="Failed to switch to chat")
 
 @router.post("/new-chat")
@@ -133,35 +155,40 @@ async def create_new_chat(
 @router.post("/chat-sequential")
 async def chat_sequential_enhanced(message: ChatMessage, request: Request):
     """
-    Enhanced sequential chat with proper session management
+    Enhanced sequential chat with proper session management and document access
     """
     try:
-        # Determine session ID based on whether this is an existing chat or new
+        # Ensure consistent session ID for document retrieval
         if message.chat_session_id:
-            # This is an existing chat - we should have already loaded it via switch-chat
-            # Use the memory session ID format
+            # 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}")
             
-            # Verify the session exists in memory
+            # Ensure session exists in memory (load if needed)
             if session_id not in session_manager.sessions:
-                # If not in memory, this means switch-chat wasn't called
-                # We should load it now (but log a warning)
                 logger.warning(f"Chat session {message.chat_session_id} not in memory, loading now")
-                session_id = await get_or_create_session_for_request_async(
+                # Load the session using the async utility function
+                memory_session_id = await get_or_create_session_for_request_async(
                     request,
                     chat_session_id=message.chat_session_id,
-                    user_id="anonymous"  # We don't have user context here
+                    user_id="system"  # This might need proper user ID from auth
                 )
+                session_id = memory_session_id
         else:
             # This is a new chat or no specific chat session
             session_id = await get_or_create_session_for_request_async(
                 request, 
                 session_id_override=message.session_id
             )
+            logger.info(f"Using new/existing session: {session_id}")
         
         # Get the session
         session = session_manager.get_session(session_id)
         
+        # Debug document access
+        rag_stats = session.get_rag_stats()
+        logger.info(f"Session {session_id} has {rag_stats.get('total_documents', 0)} documents available")
+        
         # Debug logging
         user_messages_count = len([msg for msg in session.messages if msg.get('role') == 'user'])
         logger.info(f"Session {session_id} has {user_messages_count} user messages before processing")
@@ -185,7 +212,8 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                 "type": "clarification_needed",
                 "message": clarification_question,
                 "suggestions": chat_orchestrator._get_clarification_suggestions(),
-                "session_id": session_id
+                "session_id": session_id,
+                "chat_session_id": message.chat_session_id  # Include for frontend
             }
         
         # No clarification needed - proceed with intelligent persona ordering
@@ -201,11 +229,14 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
         
         for persona_id in top_personas:
             try:
+                # Pass the consistent session_id for document retrieval
+                logger.info(f"Generating response for {persona_id} with session {session_id}")
+                
                 # Generate response from this persona
                 persona_result = await chat_orchestrator.chat_with_persona(
                     user_input=message.user_input,
                     persona_id=persona_id,
-                    session_id=session_id,
+                    session_id=session_id,  # This ensures document access
                     response_length=message.response_length or "medium"
                 )
                 
@@ -213,13 +244,17 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                     responses.append({
                         "persona": persona_result["persona_name"],
                         "persona_id": persona_result["persona_id"],
-                        "response": persona_result["response"]
+                        "response": persona_result["response"],
+                        "used_documents": persona_result.get("used_documents", False),
+                        "document_chunks_used": persona_result.get("document_chunks_used", 0)
                     })
                 else:
                     responses.append({
                         "persona": chat_orchestrator.personas[persona_id].name,
                         "persona_id": persona_id,
-                        "response": "I'm having trouble processing your question right now. Please try again."
+                        "response": "I'm having trouble processing your question right now. Please try again.",
+                        "used_documents": False,
+                        "document_chunks_used": 0
                     })
                     
             except Exception as e:
@@ -227,13 +262,22 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                 responses.append({
                     "persona": chat_orchestrator.personas[persona_id].name,
                     "persona_id": persona_id,
-                    "response": "I encountered an error while processing your question. Please try again."
+                    "response": "I encountered an error while processing your question. Please try again.",
+                    "used_documents": False,
+                    "document_chunks_used": 0
                 })
         
+        # Include document access info in response
         return {
             "type": "sequential_responses",
             "responses": responses,
-            "session_id": session_id  # Include session ID in response
+            "session_id": session_id,
+            "chat_session_id": message.chat_session_id,
+            "document_info": {
+                "total_documents": rag_stats.get('total_documents', 0),
+                "total_chunks": rag_stats.get('total_chunks', 0),
+                "documents": rag_stats.get('documents', [])
+            }
         }
 
     except Exception as e:
@@ -242,12 +286,14 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
             "type": "error", 
             "responses": [{
                 "persona": "System",
-                "response": "I'm having trouble processing your request. Could you please try again?"
+                "response": "I'm having trouble processing your request. Could you please try again?",
+                "used_documents": False,
+                "document_chunks_used": 0
             }],
-            "session_id": session_id if 'session_id' in locals() else None
+            "session_id": session_id if 'session_id' in locals() else None,
+            "chat_session_id": message.chat_session_id if hasattr(message, 'chat_session_id') else None
         }
 
-# Keep existing endpoints but update them to use async session management
 
 @router.post("/chat/{persona_id}")
 async def chat_with_specific_advisor(persona_id: str, input: UserInput, request: Request):

multi_llm_chatbot_backend/app/api/routes/documents.py

@@ -155,9 +155,21 @@ def convert_messages_for_export(messages):
 
 
 @router.post("/upload-document")
-async def upload_document(file: UploadFile = File(...), request: Request = None):
+async def upload_document(
+    file: UploadFile = File(...), 
+    request: Request = None,
+    chat_session_id: str = Query(None, description="Chat session ID if uploading to specific chat")
+):
     try:
-        session_id = get_or_create_session_for_request(request)
+        if chat_session_id:
+            # If uploading to a specific chat, use chat_{id} format
+            session_id = f"chat_{chat_session_id}"
+            logger.info(f"Uploading document to specific chat session: {session_id}")
+        else:
+            # For new/temporary chats, use regular session management
+            session_id = get_or_create_session_for_request(request)
+            logger.info(f"Uploading document to new session: {session_id}")
+        
         session = session_manager.get_session(session_id)
 
         MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
@@ -177,10 +189,12 @@ async def upload_document(file: UploadFile = File(...), request: Request = None)
         }
         file_type = file_type_map.get(file.content_type, "unknown")
 
+        # Pass the consistent session_id to RAG manager
+        logger.info(f"Adding document {file.filename} to session {session_id}")
         rag_result = rag_manager.add_document(
             content=content,
             filename=file.filename,
-            session_id=session_id,
+            session_id=session_id,  # This now uses the consistent format
             file_type=file_type
         )
 
@@ -198,6 +212,7 @@ async def upload_document(file: UploadFile = File(...), request: Request = None)
             f"Document uploaded: '{doc_title}' ({file.filename}) - {rag_result['chunks_created']} sections processed, ~{rag_result['total_tokens']} tokens analyzed. You can now ask questions about this document by referencing it by name."
         )
 
+        # Return session info for frontend tracking
         return {
             "message": f"Document '{file.filename}' uploaded and processed successfully.",
             "filename": file.filename,
@@ -205,7 +220,9 @@ async def upload_document(file: UploadFile = File(...), request: Request = None)
             "chunks_created": rag_result['chunks_created'],
             "total_tokens": rag_result['total_tokens'],
             "file_type": file_type,
-            "can_reference_by_name": True
+            "can_reference_by_name": True,
+            "session_id": session_id,  # Include session ID for debugging
+            "chat_session_id": chat_session_id  # Include original chat session ID
         }
 
     except HTTPException:

multi_llm_chatbot_backend/app/api/routes/sessions.py

@@ -23,28 +23,48 @@ async def get_context(
     current_user: User = Depends(get_current_active_user)
 ):
     """
-    Get context for current session - ENHANCED
-    Now properly handles different chat sessions
+    Get context for current session - ENHANCED with document access fix
+    Now properly handles different chat sessions and ensures document access
     """
     try:
-        # Determine which session to get context for
+        # Determine which session to get context for with consistent session ID format
         if chat_session_id:
-            # Getting context for a specific chat session
-            session_id = await get_or_create_session_for_request_async(
-                request,
-                chat_session_id=chat_session_id,
-                user_id=str(current_user.id)
-            )
+            # Getting context for a specific chat session - use consistent format
+            session_id = f"chat_{chat_session_id}"
+            logger.info(f"Getting context for specific chat session: {session_id}")
+            
+            # Ensure session is loaded in memory
+            if session_id not in session_manager.sessions:
+                logger.info(f"Chat session {session_id} not in memory, loading from database")
+                loaded_session_id = await get_or_create_session_for_request_async(
+                    request,
+                    chat_session_id=chat_session_id,
+                    user_id=str(current_user.id)
+                )
+                session_id = loaded_session_id
+                logger.info(f"Loaded session ID: {session_id}")
         else:
             # Getting context for current session
             session_id = await get_or_create_session_for_request_async(request)
+            logger.info(f"Getting context for current session: {session_id}")
         
         session = session_manager.get_session(session_id)
         rag_stats = session.get_rag_stats()
         
-        logger.info(f"Retrieved context for session {session_id}: {len(session.messages)} messages")
+        #  Enhanced logging for document access debugging
+        logger.info(f"Retrieved context for session {session_id}:")
+        logger.info(f"  - Messages: {len(session.messages)}")
+        logger.info(f"  - Documents: {rag_stats.get('total_documents', 0)}")
+        logger.info(f"  - Chunks: {rag_stats.get('total_chunks', 0)}")
+        logger.info(f"  - Uploaded files: {len(session.uploaded_files)}")
         
-        return {
+        # Log document details if available
+        if rag_stats.get('documents'):
+            for doc in rag_stats['documents']:
+                logger.info(f"  - Available document: {doc.get('filename', 'unknown')} ({doc.get('chunks', 0)} chunks)")
+        
+        # Include session debugging info in response
+        context_response = {
             "session_id": session_id,
             "chat_session_id": chat_session_id,
             "messages": session.messages,
@@ -60,16 +80,39 @@ async def get_context(
                 "total_upload_size": session.total_upload_size,
                 "created_at": session.created_at.isoformat(),
                 "last_accessed": session.last_accessed.isoformat()
+            },
+            # Add debugging info
+            "debug_info": {
+                "session_format": "chat_session" if chat_session_id else "new_session",
+                "session_in_memory": session_id in session_manager.sessions,
+                "document_access_working": rag_stats.get("total_documents", 0) > 0
             }
         }
         
+        return context_response
+        
     except Exception as e:
-        logger.error(f"Error getting context: {str(e)}")
+        logger.error(f"Error getting context for session_id {session_id if 'session_id' in locals() else 'unknown'}: {str(e)}")
+        logger.error(f"Chat session ID: {chat_session_id}")
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        
         return {
-            "session_id": None,
+            "session_id": session_id if 'session_id' in locals() else None,
+            "chat_session_id": chat_session_id,
             "messages": [], 
-            "rag_info": {"total_documents": 0, "total_chunks": 0},
-            "error": str(e)
+            "rag_info": {"total_documents": 0, "total_chunks": 0, "documents": []},
+            "context_stats": {
+                "message_count": 0,
+                "user_messages": 0,
+                "uploaded_files": [],
+                "total_upload_size": 0
+            },
+            "error": str(e),
+            "debug_info": {
+                "error_occurred": True,
+                "error_type": type(e).__name__
+            }
         }
 
 @router.post("/reset-session")

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -297,15 +297,51 @@ class ImprovedChatOrchestrator:
         Enhanced document retrieval with document awareness and better attribution
         """
         try:
+            # Add comprehensive logging to track session ID usage
+            logger.info(f"Retrieving documents for session_id: {session_id}")
+            logger.info(f"User input: {user_input[:100]}...")
+            
             rag_manager = get_rag_manager()
             
+            # Check what documents are available for this session with detailed logging
+            doc_stats = rag_manager.get_document_stats(session_id)
+            logger.info(f"Available documents for {session_id}: {doc_stats.get('total_documents', 0)} documents, {doc_stats.get('total_chunks', 0)} chunks")
+            
+            # Log document details for debugging
+            if doc_stats.get('documents'):
+                for doc in doc_stats['documents']:
+                    logger.info(f"  - Document: {doc.get('filename', 'unknown')} ({doc.get('chunks', 0)} chunks)")
+            
+            # If no documents found and this looks like a chat session, log warning
+            if doc_stats.get('total_documents', 0) == 0:
+                if session_id.startswith('chat_'):
+                    logger.warning(f"No documents found for chat session {session_id} - this may indicate session ID mismatch during upload")
+                    
+                    # Try alternative session ID formats for debugging
+                    alternative_formats = [
+                        session_id.replace('chat_', ''),  # Remove chat_ prefix
+                        session_id,  # Keep as is
+                    ]
+                    
+                    for alt_session_id in alternative_formats:
+                        if alt_session_id != session_id:
+                            alt_stats = rag_manager.get_document_stats(alt_session_id)
+                            if alt_stats.get('total_documents', 0) > 0:
+                                logger.warning(f"Found documents under alternative session ID {alt_session_id}: {alt_stats}")
+                else:
+                    logger.info(f"No documents found for new session {session_id} - this is normal for new chats")
+                
+                return ""  # No documents available
+            
             # Extract document hints from user query
             document_hint = self._extract_document_hint_from_query(user_input)
+            logger.info(f"Document hint extracted from query: {document_hint}")
             
             # Get persona-specific context for better retrieval
             persona_context = self._get_enhanced_persona_context_keywords(persona_id)
             
             # Search for relevant chunks with document awareness
+            logger.info(f"Searching with persona context: {persona_context[:100]}...")
             relevant_chunks = rag_manager.search_documents_with_context(
                 query=user_input,
                 session_id=session_id,
@@ -316,15 +352,31 @@ class ImprovedChatOrchestrator:
             
             logger.info(f"Retrieved {len(relevant_chunks)} chunks for {persona_id}")
             
+            # Log relevance scores for debugging
+            if relevant_chunks:
+                for i, chunk in enumerate(relevant_chunks):
+                    relevance = chunk.get("relevance_score", 0)
+                    doc_source = chunk.get("document_source", {})
+                    filename = doc_source.get("filename", "unknown")
+                    logger.info(f"  Chunk {i+1}: {filename} (relevance: {relevance:.3f})")
+            
             if not relevant_chunks:
-                logger.info(f"No relevant documents found for query: {user_input[:50]}...")
+                logger.info(f"No relevant document chunks found for query: {user_input[:50]}...")
                 return ""
             
             # Format retrieved content with enhanced attribution
-            return self._format_document_context_with_attribution(relevant_chunks, persona_id)
+            formatted_context = self._format_document_context_with_attribution(relevant_chunks, persona_id)
+            
+            # Log final context length
+            logger.info(f"Final document context length: {len(formatted_context)} characters")
+            
+            return formatted_context
             
         except Exception as e:
-            logger.error(f"Error retrieving documents for {persona_id}: {str(e)}")
+            logger.error(f"Error retrieving documents for {persona_id} in session {session_id}: {str(e)}")
+            logger.error(f"Error type: {type(e).__name__}")
+            import traceback
+            logger.error(f"Full traceback: {traceback.format_exc()}")
             return ""
 
     def _extract_document_hint_from_query(self, query: str) -> Optional[str]:
@@ -579,34 +631,73 @@ When analyzing the document context:
         """
         return self._get_enhanced_persona_context_keywords(persona_id)
     
-    async def chat_with_persona(self, persona_id: str, user_input: str, session_id: str, response_length: str = "medium") -> Dict[str, Any]:
+    async def chat_with_persona(self, user_input: str, persona_id: str, session_id: str, response_length: str = "medium") -> Dict[str, Any]:
         """
-        Chat with a specific persona directly
+        Chat with a specific persona directly - FIXED for consistent document access
         """
         try:
             persona = self.get_persona(persona_id)
             if not persona:
                 return {
                     "error": f"Persona {persona_id} not found",
-                    "available_personas": list(self.personas.keys())
+                    "available_personas": list(self.personas.keys()),
+                    "persona_id": persona_id,
+                    "persona_name": "Unknown"
                 }
             
+            # Ensure session exists and log session info
             session = self.session_manager.get_session(session_id)
+            logger.info(f"Chat with {persona_id} using session {session_id}")
+            
+            # Add user message to session
             session.append_message("user", user_input)
             
-            # Generate response from single persona
+            # Use the same session_id for document retrieval
+            logger.info(f"Generating response for {persona_id} with session {session_id}")
+            
+            # Generate response from single persona using consistent session ID
             response_data = await self._generate_single_persona_response(session, persona, response_length)
             
             # Add response to session
             session.append_message(persona_id, response_data["response"])
             
-            return response_data
+            # Ensure response data includes all necessary fields
+            return {
+                "persona_id": persona_id,
+                "persona_name": persona.name,
+                "response": response_data.get("response", "I'm having trouble generating a response."),
+                "used_documents": response_data.get("used_documents", False),
+                "document_chunks_used": response_data.get("document_chunks_used", 0),
+                "response_length": response_length,
+                "context_quality": response_data.get("context_quality", "unknown"),
+                "session_id": session_id,
+                "type": "single_persona_response",
+                "persona": {
+                    "persona_id": persona_id,
+                    "persona_name": persona.name,
+                    "response": response_data.get("response", "I'm having trouble generating a response."),
+                    "used_documents": response_data.get("used_documents", False),
+                    "document_chunks_used": response_data.get("document_chunks_used", 0)
+                }
+            }
             
         except Exception as e:
-            logger.error(f"Error in chat_with_persona: {str(e)}")
+            logger.error(f"Error in chat_with_persona for {persona_id}: {str(e)}")
+            logger.error(f"Session ID: {session_id}")
+            import traceback
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            
             return {
                 "error": f"Error processing request: {str(e)}",
-                "persona_id": persona_id
+                "persona_id": persona_id,
+                "persona_name": self.personas.get(persona_id, {}).name if persona_id in self.personas else "Unknown",
+                "response": "I encountered an error while processing your request. Please try again.",
+                "used_documents": False,
+                "document_chunks_used": 0,
+                "response_length": response_length,
+                "context_quality": "error",
+                "session_id": session_id,
+                "type": "error"
             }
         
 

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

@@ -6,7 +6,9 @@ const EnhancedChatInput = ({
   onSendMessage, 
   onFileUploaded,
   uploadedDocuments = [],
-  isLoading, 
+  isLoading,
+  currentChatSessionId,
+  authToken, 
   placeholder = "Ask your advisors anything about your PhD journey..." 
 }) => {
   const [inputMessage, setInputMessage] = useState('');
@@ -98,8 +100,10 @@ const EnhancedChatInput = ({
       {showUpload && (
         <div className="floating-upload-section">
           <FileUpload 
-            onFileUploaded={handleFileUploaded}
-            isUploading={isUploading}
+            onFileUploaded={onFileUploaded}
+            isUploading={isLoading}
+            currentChatSessionId={currentChatSessionId}  
+            authToken={authToken}
             onUploadStart={handleUploadStart}
           />
         </div>

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

@@ -3,7 +3,7 @@ import { Upload, FileText, File, X, CheckCircle, AlertCircle } from 'lucide-reac
 import { useTheme } from '../contexts/ThemeContext';
 import '../styles/FileUpload.css'
 
-const FileUpload = ({ onFileUploaded, isUploading, onUploadStart }) => {
+const FileUpload = ({ onFileUploaded, isUploading, onUploadStart, currentChatSessionId = null, authToken = null  }) => {
   const [dragActive, setDragActive] = useState(false);
   const [uploadStatus, setUploadStatus] = useState(null); // 'success', 'error', null
   const [uploadMessage, setUploadMessage] = useState('');
@@ -44,8 +44,24 @@ const FileUpload = ({ onFileUploaded, isUploading, onUploadStart }) => {
     formData.append('file', file);
 
     try {
-      const response = await fetch('http://localhost:8000/upload-document', {
+      // FIXED: Build URL with chat_session_id parameter if available
+      let uploadUrl = 'http://localhost:8000/upload-document';
+      if (currentChatSessionId) {
+        uploadUrl += `?chat_session_id=${currentChatSessionId}`;
+        console.log(`Uploading to specific chat session: ${currentChatSessionId}`);
+      } else {
+        console.log('Uploading to new/current session');
+      }
+
+      // FIXED: Include auth token in headers if available
+      const headers = {};
+      if (authToken) {
+        headers['Authorization'] = `Bearer ${authToken}`;
+      }
+
+      const response = await fetch(uploadUrl, {
         method: 'POST',
+        headers: headers, // Add auth headers
         body: formData,
       });
 
@@ -55,6 +71,14 @@ const FileUpload = ({ onFileUploaded, isUploading, onUploadStart }) => {
         setUploadMessage(`${file.name} uploaded successfully and added to context.`);
         onFileUploaded && onFileUploaded(file, data);
         
+        // FIXED: Log upload result for debugging
+        console.log('Document upload result:', {
+          filename: data.filename,
+          session_id: data.session_id,
+          chat_session_id: data.chat_session_id,
+          chunks_created: data.chunks_created
+        });
+        
         // Auto-clear success message after 5 seconds
         setTimeout(() => {
           setUploadStatus(null);

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

@@ -326,22 +326,32 @@ const handleNewChat = async (sessionId = null) => {
 
   
 
-  const handleFileUploaded = async (fileInfo) => {
-  const documentMessage = {
-    id: generateMessageId(),
-    type: 'document_upload',
-    content: `Document uploaded: ${fileInfo.name}`,
-    timestamp: new Date()
+  const handleFileUploaded = async (file, uploadResult) => {
+    // FIXED: Use the upload result data for better messaging
+    const documentMessage = {
+      id: generateMessageId(),
+      type: 'document_upload',
+      content: `Document uploaded: ${uploadResult.filename || file.name} (${uploadResult.chunks_created || 0} sections processed)`,
+      timestamp: new Date()
+    };
+    
+    setMessages(prev => [...prev, documentMessage]);
+    setUploadedDocuments(prev => [...prev, file]);
+    
+    // FIXED: Log document access info
+    console.log('File uploaded to session:', {
+      filename: uploadResult.filename,
+      session_id: uploadResult.session_id,
+      chat_session_id: uploadResult.chat_session_id,
+      current_session_id: currentSessionId
+    });
+    
+    // Save document upload message to database if we have a current session
+    if (currentSessionId) {
+      await saveMessageToSession(documentMessage);
+    }
   };
-  
-  setMessages(prev => [...prev, documentMessage]);
-  setUploadedDocuments(prev => [...prev, fileInfo]);
-  
-  // Save document upload message to database if we have a current session
-  if (currentSessionId) {
-    await saveMessageToSession(documentMessage);
-  }
-};
+
 
   const handleSendMessage = async (inputMessage) => {
     if (!inputMessage.trim()) return;
@@ -914,6 +924,8 @@ const handleNewChat = async (sessionId = null) => {
               onFileUploaded={handleFileUploaded}
               uploadedDocuments={uploadedDocuments}
               isLoading={isLoading}
+              currentSessionId={currentSessionId}
+              authToken={authToken}
               placeholder={
                 replyingTo 
                   ? `Reply to ${replyingTo.advisorName}...`