Update app.py

app.py

@@ -20,34 +20,28 @@ MAX_HISTORY_TURNS = 10  # Maximum conversation turns to keep in context
 client = genai.Client(api_key=GEMINI_KEY)
 user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp } }
 
-# --- Helper: sync single user's history ---
-def sync_user(uid):
-    try:
-        data = user_memory.get(uid)
-        if not data:
-            return
-        history_to_sync = data["history"][-MAX_HISTORY_TURNS:]
-        payload = {"user_id": uid, "history": history_to_sync}
-        resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
-        resp.raise_for_status()
-        user_memory[uid]["last_sync"] = time.time()
-        app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} turns)")
-    except Exception as e:
-        app.logger.warning(f"Failed sync for {uid}: {e}")
-
 # --- Background thread for periodic flush ---
 def flush_loop():
     while True:
+        time.sleep(5)
         now = time.time()
         for uid, data in list(user_memory.items()):
-            if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data.get("history"):
-                threading.Thread(target=sync_user, args=(uid,), daemon=True).start()
-        time.sleep(5)
-
-def start_flush_thread_once():
-    t = threading.Thread(target=flush_loop, daemon=True)
-    t.start()
-    app.logger.info("Started flush background thread")
+            if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data["history"]:
+                try:
+                    # Only sync the most recent MAX_HISTORY_TURNS entries
+                    history_to_sync = data["history"][-MAX_HISTORY_TURNS:]
+                    payload = {"user_id": uid, "history": history_to_sync}
+                    print(f"🔄 Attempting to sync {uid} to {LAMBDA_URL}")
+                    resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
+                    resp.raise_for_status()
+                    user_memory[uid]["last_sync"] = now
+                    app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} turns)")
+                    print(f"✅ Successfully synced memory for {uid} ({len(history_to_sync)} turns)")
+                except Exception as e:
+                    app.logger.warning(f"Failed sync for {uid}: {e}")
+                    print(f"❌ Failed sync for {uid}: {e}")
+
+threading.Thread(target=flush_loop, daemon=True).start()
 
 # --- HTML Frontend ---
 HTML = """
@@ -102,21 +96,29 @@ HTML = """
 # --- Gemini Generation with History ---
 def generate_from_gemini(prompt, image_bytes=None, history=None):
     start_time = time.time()
+    
+    # Build contents list with history
     contents = []
-
+    
+    # Add historical messages (limit to recent turns to avoid token limits)
     if history:
         recent_history = history[-MAX_HISTORY_TURNS:]
         for entry in recent_history:
+            # Add user message
             user_parts = [types.Part.from_text(text=entry["prompt"])]
             contents.append(types.Content(role="user", parts=user_parts))
+            
+            # Add model response
             model_parts = [types.Part.from_text(text=entry["response"])]
             contents.append(types.Content(role="model", parts=model_parts))
     
+    # Add current user message
     current_parts = []
     if prompt: 
         current_parts.append(types.Part.from_text(text=prompt))
     if image_bytes: 
         current_parts.append(types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg"))
+    
     contents.append(types.Content(role="user", parts=current_parts))
     
     cfg = types.GenerateContentConfig(response_mime_type="text/plain")
@@ -144,23 +146,28 @@ def get_user_history(uid):
             resp = requests.get(f"{LAMBDA_URL}?user_id={uid}", timeout=5)
             resp.raise_for_status()
             loaded_history = resp.json().get("history", [])
+            # Only keep the most recent MAX_HISTORY_TURNS when loading
             user_memory[uid] = {
                 "history": loaded_history[-MAX_HISTORY_TURNS:], 
-                "last_sync": 0
+                "last_sync": time.time()
             }
             app.logger.info(f"Loaded history for {uid} ({len(user_memory[uid]['history'])} turns)")
         except Exception as e:
             app.logger.warning(f"Failed to load history for {uid}: {e}")
-            user_memory[uid] = {"history": [], "last_sync": 0}
+            user_memory[uid] = {"history": [], "last_sync": time.time()}
     return user_memory[uid]["history"]
 
 def update_user_history(uid, prompt, response):
     entry = {"prompt": prompt, "response": response, "timestamp": time.time()}
-    user_memory.setdefault(uid, {"history": [], "last_sync": 0})["history"].append(entry)
+    if uid not in user_memory:
+        user_memory[uid] = {"history": [], "last_sync": time.time()}
+    
+    user_memory[uid]["history"].append(entry)
+    
+    # Trim history to MAX_HISTORY_TURNS to prevent unbounded growth
     if len(user_memory[uid]["history"]) > MAX_HISTORY_TURNS:
         user_memory[uid]["history"] = user_memory[uid]["history"][-MAX_HISTORY_TURNS:]
         app.logger.debug(f"Trimmed history for {uid} to {MAX_HISTORY_TURNS} turns")
-    threading.Thread(target=sync_user, args=(uid,), daemon=True).start()
 
 # --- Routes ---
 @app.route("/")
@@ -180,18 +187,20 @@ def gen():
         return jsonify({"error": "No prompt or image provided"}), 400
 
     try:
+        # Load user's conversation history
         history = get_user_history(uid)
+        
+        # Generate response with history context
         result = generate_from_gemini(prompt, img_bytes, history=history)
+        
+        # Update history with new exchange
         update_user_history(uid, prompt, result["text"])
+        
         return jsonify({"result": result["text"], "timing": result["timing"]})
     except Exception as e:
         app.logger.exception("Generation failed")
         return jsonify({"error": str(e)}), 500
 
-# Flask 3.x compatible event
-@app.before_serving
-def _start_background_tasks():
-    start_flush_thread_once()
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))