Implement Gemini-based automatic chat name generation

- Replace Bedrock chat naming with Gemini model
- Add simple message detection (greetings use timestamp)
- Creative naming for meaningful messages using Gemini
- Auto-trigger after first user message
- Fallback to timestamp on Gemini API errors

api_routes_v2.py

@@ -353,80 +353,94 @@ def _record_model_attribution(
 
 ## helpers for presigned url chat name and some more updates
 
-def _resolve_bedrock_model_for_titles(session: Dict[str, Any]) -> str:
+def _is_simple_message(message: str) -> bool:
     """
-    CHANGE: NEW helper.
-    Use the same model as other tasks if available (session.proposed_pipeline._model).
-    Fallback to env, then a sane default.
+    Check if message is a simple greeting or test message that should use timestamp naming.
     """
-    try:
-        model = (session.get("proposed_pipeline") or {}).get("_model")
-    except Exception:
-        model = None
-    if not model:
-        model = os.getenv("BEDROCK_MODEL_ID") or os.getenv("BEDROCK_DEFAULT_MODEL") or "mistral.mistral-large-2402-v1:0"
-    return model
+    if not message or len(message.strip()) > 30:
+        return False
+    
+    simple_patterns = [
+        "hello", "hi", "hey", "test", "testing", "hola", "bonjour",
+        "namaste", "greetings", "good morning", "good afternoon", "good evening"
+    ]
+    
+    msg_lower = message.lower().strip()
+    return any(pattern in msg_lower for pattern in simple_patterns)
 
-def _bedrock_invoke_title(model_id: str, prompt_text: str) -> str:
+def _generate_chat_name_with_gemini(user_message: str, file_name: Optional[str] = None) -> str:
     """
-    CHANGE: NEW helper.
-    Minimal Bedrock invocation for Anthropic/Titan models to produce a short title.
-    If invocation fails, returns 'New Chat'.
+    Generate a creative chat name using Gemini model.
+    Returns generated name or falls back to timestamp on error.
     """
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+    GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.0-flash")
+    GEMINI_ENDPOINT = f"https://generativelanguage.googleapis.com/v1beta/models/{GEMINI_MODEL}:generateContent"
+    
+    if not GEMINI_API_KEY:
+        # Fallback to timestamp if no API key
+        return f"Chat - {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+    
+    # Build prompt
+    prompt = (
+        "Create a succinct, creative, and descriptive 3-6 word title for this chat session.\n"
+        "The title should capture the essence of what the user wants to do.\n"
+        "Return ONLY the title, without quotes or extra text.\n\n"
+        f"User's first message: {user_message}\n"
+    )
+    
+    if file_name:
+        prompt += f"File uploaded: {file_name}\n"
+    
     try:
-        bedrock_runtime = boto3.client("bedrock-runtime", region_name=AWS_REGION)
-        if model_id.startswith("anthropic."):
-            # Anthropic Messages on Bedrock
-            body = {
-                "anthropic_version": "bedrock-2023-05-31",
-                "max_tokens": 48,
-                "temperature": 0.2,
-                "messages": [{"role": "user", "content": [{"type": "text", "text": prompt_text}]}],
-            }
-            resp = bedrock_runtime.invoke_model(
-                modelId=model_id,
-                accept="application/json",
-                contentType="application/json",
-                body=json.dumps(body),
-            )
-            payload = json.loads(resp["body"].read())
-            text = ""
-            if isinstance(payload.get("content"), list) and payload["content"]:
-                part = payload["content"][0]
-                if isinstance(part, dict):
-                    text = part.get("text") or ""
-            return (text or "").strip().strip('"').strip() or "New Chat"
-        else:
-            # Titan text models (or similar)
-            body = {
-                "inputText": prompt_text,
-                "textGenerationConfig": {"maxTokenCount": 64, "temperature": 0.2, "stopSequences": []},
-            }
-            resp = bedrock_runtime.invoke_model(
-                modelId=model_id,
-                accept="application/json",
-                contentType="application/json",
-                body=json.dumps(body),
-            )
-            payload = json.loads(resp["body"].read())
-            results = payload.get("results") or []
-            if results:
-                return (results[0].get("outputText") or "").strip().strip('"').strip() or "New Chat"
-            return "New Chat"
-    except Exception:
-        return "New Chat"
+        import requests
+        response = requests.post(
+            f"{GEMINI_ENDPOINT}?key={GEMINI_API_KEY}",
+            headers={"Content-Type": "application/json"},
+            json={
+                "contents": [{"parts": [{"text": prompt}]}],
+                "generationConfig": {
+                    "temperature": 0.7,
+                    "maxOutputTokens": 50,
+                }
+            },
+            timeout=5,  # Short timeout to avoid blocking
+        )
+        
+        response.raise_for_status()
+        result = response.json()
+        
+        # Extract text from Gemini response
+        title = result["candidates"][0]["content"]["parts"][0]["text"]
+        title = title.strip().strip('"').strip("'").strip()
+        
+        # Validate title length (should be reasonable)
+        if len(title) > 100:
+            title = title[:100]
+        
+        return title or f"Chat - {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+        
+    except Exception as e:
+        print(f"Gemini chat name generation failed: {e}")
+        # Fallback to timestamp
+        return f"Chat - {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
 
 def _maybe_generate_chat_name(chat_id: str):
     """
-    CHANGE: NEW helper.
-    Auto-generate a succinct chat title after the first real user message (not the 'Uploaded file:' stub).
-    Uses the same Bedrock model as used elsewhere where possible.
+    Auto-generate a chat title after the first real user message.
+    Uses Gemini for creative naming, or timestamp for simple messages.
     """
     try:
         s = session_manager.get_session(chat_id) or {}
+        
+        # Skip if chat name already exists
         if s.get("chat_name"):
             return
-        msgs = list(s.get("messages", []))
+        
+        # Load messages from S3 (V3 architecture)
+        msgs = _load_conversation_from_s3(chat_id)
+        
+        # Find first real user message (not file upload)
         first_user = None
         for m in msgs:
             if (m.get("role") or "") == "user":
@@ -434,26 +448,38 @@ def _maybe_generate_chat_name(chat_id: str):
                 if not content.lower().startswith("uploaded file:"):
                     first_user = content
                     break
+        
         if not first_user:
             return
+        
+        # Get file name if available
         file_name = (s.get("file_metadata") or {}).get("file_name")
-        prompt = (
-            "Create a succinct, descriptive 3–6 word title for this chat session based on the first user message.\n"
-            "Return only the title, without quotes.\n\n"
-            f"First message: {first_user}\n"
-            f"File name (optional): {file_name or 'N/A'}"
-        )
-        model_id = _resolve_bedrock_model_for_titles(s)
-        title = _bedrock_invoke_title(model_id, prompt) or "New Chat"
+        
+        # Check if it's a simple message
+        if _is_simple_message(first_user):
+            # Use timestamp for simple greetings
+            title = f"Chat - {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+            model_used = "timestamp"
+        else:
+            # Use Gemini for creative naming
+            title = _generate_chat_name_with_gemini(first_user, file_name)
+            model_used = os.getenv("GEMINI_MODEL", "gemini-2.0-flash")
+        
+        # Update session with chat name
         session_manager.update_session(
             chat_id,
             {
                 "chat_name": title[:100],
                 "chat_name_generated_at": datetime.utcnow().isoformat() + "Z",
-                "chat_name_model": model_id,
+                "chat_name_model": model_used,
             },
         )
-    except Exception:
+        
+        print(f"✅ Generated chat name for {chat_id}: '{title}' (using {model_used})")
+        
+    except Exception as e:
+        print(f"Error generating chat name: {e}")
+        # Don't fail the request if chat naming fails
         pass
 
 def _generate_presigned_get_url(bucket: str, key: str, expires_in: int = 604800) -> Dict[str, str]:
@@ -585,6 +611,10 @@ def _add_and_mirror_message(chat_id: str, role: str, content: str, file_metadata
     
     # 3. Save to S3 (this updates MongoDB metadata too)
     _save_conversation_to_s3(chat_id, current_messages)
+    
+    # 4. Auto-generate chat name after first user message
+    if role == "user":
+        _maybe_generate_chat_name(chat_id)
 
 def _assistant_response_payload(
     chat_id: str,