Upd namer and namer session js

helpers/namer.py

@@ -35,6 +35,12 @@ async def auto_name_session(
         Generated session name or None if failed
     """
     try:
+        logger.info(f"[NAMER] Starting auto-naming for session {session_id}")
+        logger.info(f"[NAMER] User: {user_id}, Project: {project_id}")
+        logger.info(f"[NAMER] First query: {first_query[:100]}...")
+        logger.info(f"[NAMER] NVIDIA rotator available: {nvidia_rotator is not None}")
+        logger.info(f"[NAMER] Database available: {rag_db is not None}")
+        
         if not nvidia_rotator:
             logger.warning("[NAMER] NVIDIA rotator not available")
             return None
@@ -64,6 +70,10 @@ Return only the session name, nothing else."""
             from utils.api.router import generate_answer_with_model
             selection = {"provider": "nvidia", "model": "meta/llama-3.1-8b-instruct"}
             
+            logger.info(f"[NAMER] Calling NVIDIA API with model: {selection['model']}")
+            logger.info(f"[NAMER] System prompt length: {len(sys_prompt)}")
+            logger.info(f"[NAMER] User prompt: {user_prompt}")
+            
             response = await generate_answer_with_model(
                 selection=selection,
                 system_prompt=sys_prompt,
@@ -72,41 +82,58 @@ Return only the session name, nothing else."""
                 nvidia_rotator=nvidia_rotator
             )
             
+            logger.info(f"[NAMER] Raw API response: {response}")
+            
             # Clean up the response
             session_name = response.strip()
+            logger.info(f"[NAMER] Initial session name: '{session_name}'")
+            
             # Remove quotes if present
             if session_name.startswith('"') and session_name.endswith('"'):
                 session_name = session_name[1:-1]
+                logger.info(f"[NAMER] Removed double quotes: '{session_name}'")
             if session_name.startswith("'") and session_name.endswith("'"):
                 session_name = session_name[1:-1]
+                logger.info(f"[NAMER] Removed single quotes: '{session_name}'")
             
             # Truncate if too long (safety measure)
             if len(session_name) > 50:
                 session_name = session_name[:47] + "..."
+                logger.info(f"[NAMER] Truncated long name: '{session_name}'")
+            
+            logger.info(f"[NAMER] Final session name: '{session_name}'")
             
             # Update the session with the auto-generated name in database
             if rag_db:
+                logger.info(f"[NAMER] Updating database for session {session_id}")
+                logger.info(f"[NAMER] Query: user_id={user_id}, project_id={project_id}, session_id={session_id}")
+                
                 result = rag_db["chat_sessions"].update_many(
                     {"user_id": user_id, "project_id": project_id, "session_id": session_id},
                     {"$set": {"session_name": session_name, "is_auto_named": True}}
                 )
                 
+                logger.info(f"[NAMER] Database update result: matched={result.matched_count}, modified={result.modified_count}")
+                
                 if result.modified_count > 0:
-                    logger.info(f"[NAMER] Auto-named session '{session_id}' to '{session_name}'")
+                    logger.info(f"[NAMER] ✅ Successfully auto-named session '{session_id}' to '{session_name}'")
                     return session_name
                 else:
-                    logger.warning(f"[NAMER] Session not found for auto-naming: {session_id}")
+                    logger.warning(f"[NAMER] ❌ Session not found for auto-naming: {session_id}")
+                    logger.warning(f"[NAMER] This might mean the session doesn't exist in the database yet")
                     return None
             else:
-                logger.warning("[NAMER] Database connection not provided")
+                logger.warning("[NAMER] ❌ Database connection not provided")
                 return session_name
                 
         except Exception as e:
-            logger.warning(f"[NAMER] Auto-naming failed: {e}")
+            logger.error(f"[NAMER] ❌ Auto-naming API call failed: {e}")
+            logger.error(f"[NAMER] Exception type: {type(e).__name__}")
             return None
             
     except Exception as e:
-        logger.error(f"[NAMER] Failed to auto-name session: {e}")
+        logger.error(f"[NAMER] ❌ Failed to auto-name session: {e}")
+        logger.error(f"[NAMER] Exception type: {type(e).__name__}")
         return None
 
 

routes/chats.py

@@ -321,6 +321,10 @@ async def chat(
         # Check if this is the first message in the session for auto-naming
         session_name = None
         if session_id:
+            logger.info(f"[CHAT] 🔍 Checking auto-naming for session {session_id}")
+            logger.info(f"[CHAT] User: {user_id}, Project: {project_id}")
+            logger.info(f"[CHAT] Question: {question[:100]}...")
+            
             # Check if session record exists (not just messages)
             existing_session = rag.db["chat_sessions"].find_one({
                 "user_id": user_id, 
@@ -337,8 +341,11 @@ async def chat(
                 "role": "user"  # Only count user messages
             })
             
+            logger.info(f"[CHAT] Session {session_id}: existing_session={existing_session is not None}, existing_messages={existing_messages}")
+            
             # If session doesn't exist, create it
             if not existing_session:
+                logger.info(f"[CHAT] Creating new session record for {session_id}")
                 session_data = {
                     "user_id": user_id,
                     "project_id": project_id,
@@ -349,14 +356,16 @@ async def chat(
                     "timestamp": time.time()
                 }
                 rag.db["chat_sessions"].insert_one(session_data)
-                logger.info(f"[CHAT] Created session record for {session_id}")
+                logger.info(f"[CHAT] ✅ Created session record for {session_id}")
             
             # If this is the first user message, trigger auto-naming with short timeout, then fall back to background
             if existing_messages == 0:
+                logger.info(f"[CHAT] 🚀 First message detected - triggering auto-naming for session {session_id}")
                 try:
                     from helpers.namer import auto_name_session_immediate
                     import asyncio as _asyncio_name
                     try:
+                        logger.info(f"[CHAT] Attempting immediate auto-naming with 2s timeout...")
                         session_name = await _asyncio_name.wait_for(
                             auto_name_session_immediate(
                                 user_id, project_id, session_id, question, nvidia_rotator, rag.db
@@ -364,20 +373,28 @@ async def chat(
                             timeout=2.0
                         )
                         if session_name:
-                            logger.info(f"[CHAT] Auto-named session {session_id} to '{session_name}' (inline)")
+                            logger.info(f"[CHAT] ✅ Auto-named session {session_id} to '{session_name}' (inline)")
+                        else:
+                            logger.warning(f"[CHAT] ❌ Auto-naming returned None (inline)")
                     except _asyncio_name.TimeoutError:
+                        logger.info(f"[CHAT] ⏰ Auto-naming timed out, running in background...")
                         async def _do_name():
                             try:
+                                logger.info(f"[CHAT] Background auto-naming starting...")
                                 _name = await auto_name_session_immediate(
                                     user_id, project_id, session_id, question, nvidia_rotator, rag.db
                                 )
                                 if _name:
-                                    logger.info(f"[CHAT] Auto-named session {session_id} to '{_name}' (background)")
+                                    logger.info(f"[CHAT] ✅ Auto-named session {session_id} to '{_name}' (background)")
+                                else:
+                                    logger.warning(f"[CHAT] ❌ Auto-naming returned None (background)")
                             except Exception as _e:
-                                logger.warning(f"[CHAT] Auto-naming failed: {_e}")
+                                logger.error(f"[CHAT] ❌ Background auto-naming failed: {_e}")
                         _asyncio_name.create_task(_do_name())
                 except Exception as e:
-                    logger.warning(f"[CHAT] Auto-naming scheduling failed: {e}")
+                    logger.error(f"[CHAT] ❌ Auto-naming scheduling failed: {e}")
+            else:
+                logger.info(f"[CHAT] Not first message (count={existing_messages}), skipping auto-naming")
         
         # Get the chat response
         chat_response = await asyncio.wait_for(_chat_impl(user_id, project_id, question, k, use_web=use_web, max_web=max_web, session_id=session_id), timeout=120.0)

static/script.js

@@ -586,10 +586,16 @@
           
           // Handle session auto-naming if returned
           if (data.session_name && data.session_id) {
+            console.log(`[FRONTEND] 🎯 Auto-naming received: session_id=${data.session_id}, name='${data.session_name}'`);
             // Update the session name in the UI immediately
             if (window.__sb_update_session_name) {
+              console.log(`[FRONTEND] 🔄 Calling updateSessionName function...`);
               window.__sb_update_session_name(data.session_id, data.session_name);
+            } else {
+              console.warn(`[FRONTEND] ❌ updateSessionName function not available`);
             }
+          } else {
+            console.log(`[FRONTEND] ℹ️ No auto-naming data received:`, { session_name: data.session_name, session_id: data.session_id });
           }
           
           await saveChatMessage(

static/sessions.js

@@ -98,6 +98,9 @@
   }
   
   function updateSessionDropdown() {
+    console.log(`[SESSIONS] 🔄 updateSessionDropdown called with ${sessions.length} sessions`);
+    console.log(`[SESSIONS] Sessions:`, sessions.map(s => ({ id: s.session_id, name: s.name, auto: s.is_auto_named })));
+    
     sessionDropdown.innerHTML = '<option value="">Select Session</option>';
     
     sessions.forEach(session => {
@@ -108,6 +111,7 @@
         option.textContent += ' (Auto)';
       }
       sessionDropdown.appendChild(option);
+      console.log(`[SESSIONS] Added option: ${option.value} = ${option.textContent}`);
     });
     
     // Add create new session option
@@ -118,6 +122,8 @@
     
     // Update session actions visibility
     updateSessionActions();
+    
+    console.log(`[SESSIONS] ✅ Dropdown updated with ${sessionDropdown.children.length} options`);
   }
   
   function updateSessionActions() {
@@ -361,21 +367,32 @@
   
   // Function to update session name in UI immediately
   function updateSessionName(sessionId, newName) {
+    console.log(`[SESSIONS] 🔄 updateSessionName called: sessionId=${sessionId}, newName='${newName}'`);
+    console.log(`[SESSIONS] Current sessions:`, sessions.map(s => ({ id: s.session_id, name: s.name })));
+    
     // Update the session in our local sessions array
     const sessionIndex = sessions.findIndex(s => s.session_id === sessionId);
+    console.log(`[SESSIONS] Session index found: ${sessionIndex}`);
+    
     if (sessionIndex !== -1) {
+      console.log(`[SESSIONS] 📝 Updating session at index ${sessionIndex}: '${sessions[sessionIndex].name}' -> '${newName}'`);
       sessions[sessionIndex].name = newName;
       sessions[sessionIndex].is_auto_named = false;
       
       // Update the dropdown to reflect the new name
+      console.log(`[SESSIONS] 🔄 Updating dropdown...`);
       updateSessionDropdown();
       
       // If this is the currently selected session, update the dropdown value
       if (currentSessionId === sessionId) {
+        console.log(`[SESSIONS] 🎯 This is the current session, updating dropdown selection`);
         sessionDropdown.value = sessionId;
       }
       
-      console.log(`[SESSIONS] Updated session name to: ${newName}`);
+      console.log(`[SESSIONS] ✅ Updated session name to: ${newName}`);
+    } else {
+      console.warn(`[SESSIONS] ❌ Session not found in local array: ${sessionId}`);
+      console.warn(`[SESSIONS] Available sessions:`, sessions.map(s => s.session_id));
     }
   }