Refactor new namer agent

helpers/models.py

@@ -43,6 +43,8 @@ class ChatAnswerResponse(BaseModel):
     answer: str
     sources: List[Dict[str, Any]]
     relevant_files: Optional[List[str]] = None
+    session_name: Optional[str] = None
+    session_id: Optional[str] = None
 
 class HealthResponse(BaseModel):
     ok: bool

helpers/namer.py

@@ -0,0 +1,152 @@
+"""
+Session Auto-Naming Module
+
+This module handles automatic naming of chat sessions based on the first user query.
+Uses NVIDIA_SMALL API to generate concise, descriptive session names.
+"""
+
+import asyncio
+from typing import Optional
+from utils.logger import get_logger
+
+logger = get_logger("SESSION_NAMER", __name__)
+
+
+async def auto_name_session(
+    user_id: str, 
+    project_id: str, 
+    session_id: str, 
+    first_query: str,
+    nvidia_rotator=None,
+    rag_db=None
+) -> Optional[str]:
+    """
+    Automatically name a session based on the first query using NVIDIA_SMALL API.
+    
+    Args:
+        user_id: User identifier
+        project_id: Project identifier  
+        session_id: Session identifier
+        first_query: The first user query in the session
+        nvidia_rotator: NVIDIA API rotator instance
+        rag_db: Database connection
+        
+    Returns:
+        Generated session name or None if failed
+    """
+    try:
+        if not nvidia_rotator:
+            logger.warning("[NAMER] NVIDIA rotator not available")
+            return None
+        
+        # Use NVIDIA_SMALL to generate a 2-3 word session name
+        sys_prompt = """You are an expert at creating concise, descriptive session names.
+
+Given a user's first query in a chat session, create a 2-3 word session name that captures the main topic or intent.
+
+Rules:
+- Use 2-3 words maximum
+- Be descriptive but concise
+- Use title case (capitalize first letter of each word)
+- Focus on the main topic or question type
+- Avoid generic terms like "Question" or "Chat"
+
+Examples:
+- "Machine Learning Basics" for "What is machine learning?"
+- "Python Functions" for "How do I create functions in Python?"
+- "Data Analysis" for "Can you help me analyze this dataset?"
+
+Return only the session name, nothing else."""
+
+        user_prompt = f"First query: {first_query}\n\nCreate a 2-3 word session name:"
+        
+        try:
+            from utils.api.router import generate_answer_with_model
+            selection = {"provider": "nvidia", "model": "meta/llama-3.1-8b-instruct"}
+            
+            response = await generate_answer_with_model(
+                selection=selection,
+                system_prompt=sys_prompt,
+                user_prompt=user_prompt,
+                gemini_rotator=None,
+                nvidia_rotator=nvidia_rotator
+            )
+            
+            # Clean up the response
+            session_name = response.strip()
+            # Remove quotes if present
+            if session_name.startswith('"') and session_name.endswith('"'):
+                session_name = session_name[1:-1]
+            if session_name.startswith("'") and session_name.endswith("'"):
+                session_name = session_name[1:-1]
+            
+            # Truncate if too long (safety measure)
+            if len(session_name) > 50:
+                session_name = session_name[:47] + "..."
+            
+            # Update the session with the auto-generated name in database
+            if rag_db:
+                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}}
+                )
+                
+                if result.modified_count > 0:
+                    logger.info(f"[NAMER] Auto-named session '{session_id}' to '{session_name}'")
+                    return session_name
+                else:
+                    logger.warning(f"[NAMER] Session not found for auto-naming: {session_id}")
+                    return None
+            else:
+                logger.warning("[NAMER] Database connection not provided")
+                return session_name
+                
+        except Exception as e:
+            logger.warning(f"[NAMER] Auto-naming failed: {e}")
+            return None
+            
+    except Exception as e:
+        logger.error(f"[NAMER] Failed to auto-name session: {e}")
+        return None
+
+
+async def auto_name_session_immediate(
+    user_id: str, 
+    project_id: str, 
+    session_id: str, 
+    first_query: str,
+    nvidia_rotator=None,
+    rag_db=None
+) -> Optional[str]:
+    """
+    Immediately auto-name a session and return the name for UI update.
+    This function is designed to be called synchronously during chat processing.
+    
+    Args:
+        user_id: User identifier
+        project_id: Project identifier  
+        session_id: Session identifier
+        first_query: The first user query in the session
+        nvidia_rotator: NVIDIA API rotator instance
+        rag_db: Database connection
+        
+    Returns:
+        Generated session name or None if failed
+    """
+    try:
+        # Run auto-naming in a separate task to avoid blocking
+        task = asyncio.create_task(
+            auto_name_session(user_id, project_id, session_id, first_query, nvidia_rotator, rag_db)
+        )
+        
+        # Wait for completion with a timeout
+        try:
+            session_name = await asyncio.wait_for(task, timeout=10.0)
+            return session_name
+        except asyncio.TimeoutError:
+            logger.warning(f"[NAMER] Auto-naming timed out for session {session_id}")
+            return None
+            
+    except Exception as e:
+        logger.error(f"[NAMER] Immediate auto-naming failed: {e}")
+        return None

routes/chats.py

@@ -316,6 +316,7 @@ async def chat(
     
     try:
         # Check if this is the first message in the session for auto-naming
+        session_name = None
         if session_id:
             existing_messages = rag.db["chat_sessions"].count_documents({
                 "user_id": user_id, 
@@ -323,7 +324,7 @@ async def chat(
                 "session_id": session_id
             })
             
-            # If this is the first user message, create session and trigger auto-naming
+            # If this is the first user message, create session and trigger immediate auto-naming
             if existing_messages == 0:
                 # Create session record first
                 session_data = {
@@ -331,20 +332,34 @@ async def chat(
                     "project_id": project_id,
                     "session_id": session_id,
                     "session_name": "New Chat",
-                    "is_auto_named": True,
+                    "is_auto_named": False,  # Will be updated by auto-naming
                     "created_at": datetime.now(timezone.utc),
                     "timestamp": time.time()
                 }
                 rag.db["chat_sessions"].insert_one(session_data)
                 
-                # Now trigger auto-naming
+                # Trigger immediate auto-naming
                 try:
-                    await _auto_name_session(user_id, project_id, session_id, question)
-                    logger.info(f"[CHAT] Auto-named session {session_id}")
+                    from helpers.namer import auto_name_session_immediate
+                    session_name = await auto_name_session_immediate(
+                        user_id, project_id, session_id, question, nvidia_rotator, rag.db
+                    )
+                    if session_name:
+                        logger.info(f"[CHAT] Auto-named session {session_id} to '{session_name}'")
+                    else:
+                        logger.warning(f"[CHAT] Auto-naming failed for session {session_id}")
                 except Exception as e:
                     logger.warning(f"[CHAT] Auto-naming failed: {e}")
         
-        return 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)
+        # 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)
+        
+        # Add session information to the response if auto-naming occurred
+        if session_name:
+            chat_response.session_name = session_name
+            chat_response.session_id = session_id
+        
+        return chat_response
     except asyncio.TimeoutError:
         logger.error("[CHAT] Chat request timed out after 120 seconds")
         update_chat_status(session_id, "error", "Request timed out", 0)
@@ -830,64 +845,3 @@ async def chat_with_search(
     return ChatAnswerResponse(answer=answer, sources=merged_sources, relevant_files=merged_files)
 
 
-async def _auto_name_session(user_id: str, project_id: str, session_id: str, first_query: str):
-    """Helper function to auto-name a session based on the first query"""
-    try:
-        if not nvidia_rotator:
-            return
-        
-        # Use NVIDIA_SMALL to generate a 2-3 word session name
-        sys_prompt = """You are an expert at creating concise, descriptive session names.
-
-Given a user's first query in a chat session, create a 2-3 word session name that captures the main topic or intent.
-
-Rules:
-- Use 2-3 words maximum
-- Be descriptive but concise
-- Use title case (capitalize first letter of each word)
-- Focus on the main topic or question type
-- Avoid generic terms like "Question" or "Chat"
-
-Examples:
-- "Machine Learning Basics" for "What is machine learning?"
-- "Python Functions" for "How do I create functions in Python?"
-- "Data Analysis" for "Can you help me analyze this dataset?"
-
-Return only the session name, nothing else."""
-
-        user_prompt = f"First query: {first_query}\n\nCreate a 2-3 word session name:"
-        
-        from utils.api.router import generate_answer_with_model
-        selection = {"provider": "nvidia", "model": "meta/llama-3.1-8b-instruct"}
-        
-        response = await generate_answer_with_model(
-            selection=selection,
-            system_prompt=sys_prompt,
-            user_prompt=user_prompt,
-            gemini_rotator=None,
-            nvidia_rotator=nvidia_rotator
-        )
-        
-        # Clean up the response
-        session_name = response.strip()
-        # Remove quotes if present
-        if session_name.startswith('"') and session_name.endswith('"'):
-            session_name = session_name[1:-1]
-        if session_name.startswith("'") and session_name.endswith("'"):
-            session_name = session_name[1:-1]
-        
-        # Truncate if too long (safety measure)
-        if len(session_name) > 50:
-            session_name = session_name[:47] + "..."
-        
-        # Update the session with the auto-generated name
-        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"[CHAT] Auto-named session '{session_id}' to '{session_name}'")
-        
-    except Exception as e:
-        logger.warning(f"[CHAT] Auto-naming failed: {e}")
-        # Don't raise the exception to avoid breaking the chat flow

routes/sessions.py

@@ -157,67 +157,15 @@ async def auto_name_session(
 ):
     """Automatically name a session based on the first query using NVIDIA_SMALL API"""
     try:
-        if not nvidia_rotator:
-            return MessageResponse(message="Auto-naming not available")
+        from helpers.namer import auto_name_session_immediate
         
-        # Use NVIDIA_SMALL to generate a 2-3 word session name
-        sys_prompt = """You are an expert at creating concise, descriptive session names.
-
-Given a user's first query in a chat session, create a 2-3 word session name that captures the main topic or intent.
-
-Rules:
-- Use 2-3 words maximum
-- Be descriptive but concise
-- Use title case (capitalize first letter of each word)
-- Focus on the main topic or question type
-- Avoid generic terms like "Question" or "Chat"
-
-Examples:
-- "Machine Learning Basics" for "What is machine learning?"
-- "Python Functions" for "How do I create functions in Python?"
-- "Data Analysis" for "Can you help me analyze this dataset?"
-
-Return only the session name, nothing else."""
-
-        user_prompt = f"First query: {first_query}\n\nCreate a 2-3 word session name:"
+        session_name = await auto_name_session_immediate(
+            user_id, project_id, session_id, first_query, nvidia_rotator, rag.db
+        )
         
-        try:
-            from utils.api.router import generate_answer_with_model
-            selection = {"provider": "nvidia", "model": "meta/llama-3.1-8b-instruct"}
-            
-            response = await generate_answer_with_model(
-                selection=selection,
-                system_prompt=sys_prompt,
-                user_prompt=user_prompt,
-                gemini_rotator=None,
-                nvidia_rotator=nvidia_rotator
-            )
-            
-            # Clean up the response
-            session_name = response.strip()
-            # Remove quotes if present
-            if session_name.startswith('"') and session_name.endswith('"'):
-                session_name = session_name[1:-1]
-            if session_name.startswith("'") and session_name.endswith("'"):
-                session_name = session_name[1:-1]
-            
-            # Truncate if too long (safety measure)
-            if len(session_name) > 50:
-                session_name = session_name[:47] + "..."
-            
-            # Update the session with the auto-generated name
-            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}}
-            )
-            
-            if result.modified_count > 0:
-                return MessageResponse(message=f"Session auto-named: {session_name}")
-            else:
-                return MessageResponse(message="Session not found for auto-naming")
-                
-        except Exception as e:
-            logger.warning(f"[SESSIONS] Auto-naming failed: {e}")
+        if session_name:
+            return MessageResponse(message=f"Session auto-named: {session_name}")
+        else:
             return MessageResponse(message="Auto-naming failed, keeping default name")
             
     except Exception as e:

static/script.js

@@ -583,6 +583,15 @@
           if (data.sources && data.sources.length > 0) {
             appendSources(data.sources);
           }
+          
+          // Handle session auto-naming if returned
+          if (data.session_name && data.session_id) {
+            // Update the session name in the UI immediately
+            if (window.__sb_update_session_name) {
+              window.__sb_update_session_name(data.session_id, data.session_name);
+            }
+          }
+          
           await saveChatMessage(
             user.user_id,
             currentProject.project_id,

static/sessions.js

@@ -331,11 +331,32 @@
     messages.scrollTop = messages.scrollHeight;
   }
   
+  // Function to update session name in UI immediately
+  function updateSessionName(sessionId, newName) {
+    // Update the session in our local sessions array
+    const sessionIndex = sessions.findIndex(s => s.session_id === sessionId);
+    if (sessionIndex !== -1) {
+      sessions[sessionIndex].name = newName;
+      sessions[sessionIndex].is_auto_named = true;
+      
+      // Update the dropdown to reflect the new name
+      updateSessionDropdown();
+      
+      // If this is the currently selected session, update the dropdown value
+      if (currentSessionId === sessionId) {
+        sessionDropdown.value = sessionId;
+      }
+      
+      console.log(`[SESSIONS] Updated session name to: ${newName}`);
+    }
+  }
+  
   // Expose functions for external use
   window.__sb_get_current_session = () => currentSessionId;
   window.__sb_set_current_session = (sessionId) => selectSession(sessionId);
   window.__sb_append_message = appendMessage;
   window.__sb_load_sessions = loadSessions;
+  window.__sb_update_session_name = updateSessionName;
   
   // Initialize when DOM is ready
   if (document.readyState === 'loading') {