Update app.py

app.py

@@ -2,86 +2,458 @@
 # pip install flask google-genai requests boto3
 
 import os
+import sys
+import json
 import time
+import logging
 import requests
+from datetime import datetime, timezone
 from flask import Flask, request, render_template_string, jsonify
 from google import genai
 from google.genai import types
 
 app = Flask(__name__)
 
+# --- Configure logging for HuggingFace Spaces ---
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    stream=sys.stdout
+)
+logger = logging.getLogger(__name__)
+
+def log(message):
+    logger.info(message)
+    sys.stdout.flush()
+
 # --- Configuration ---
 LAMBDA_URL = os.getenv("LAMBDA_URL", "https://your-lambda-function-url")
 GEMINI_KEY = os.getenv("GEMINI_API_KEY", "")
+STORYLINE_SERVER_URL = os.getenv("STORYLINE_SERVER_URL", "https://your-storyline-server-url")
 FLUSH_INTERVAL = 30  # seconds between DB backups per user
 MAX_HISTORY_TURNS = 10  # Maximum conversation turns to keep in context
 MAX_MEMORY_MESSAGES = 90  # Maximum messages to keep in memory per user
 MEMORY_CLEANUP_TIMEOUT = 1800  # 30 minutes in seconds - remove inactive users
 
 client = genai.Client(api_key=GEMINI_KEY)
-user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp, "last_activity": timestamp, "needs_sync": bool } }
+user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp, "last_activity": timestamp, "needs_sync": bool, "personality": str, "last_storyline_date": str, "gender": str } }
+
+# --- Animation Mappings ---
+# Based on the GIF files you have
+ANIMATION_IDS = {
+    "flustered": ["flustered"],
+    "happy": ["happy-happy"],
+    "idle": ["idle"],
+    "inlove": ["inlove"],
+    "neutral": ["neutral"],
+    "talking": ["talking"],
+    "twerking": ["twerking"],
+    "confused": ["confused"],
+    "shock": ["shock"],
+    "thinking": ["thinking"]
+}
+
+# --- Cat Personalities ---
+CAT_PERSONALITIES = {
+    "playful": {
+        "name": "Luna",
+        "description": "A playful and energetic cat who loves games and adventures",
+        "traits": "curious, energetic, spontaneous, loves to play, easily excited",
+        "speech_style": "enthusiastic, uses playful language, often makes puns",
+        "default_emotions": ["happy", "excited", "playful"],
+        "default_animation": "happy-happy"
+    },
+    "sleepy": {
+        "name": "Whiskers",
+        "description": "A lazy cat who enjoys naps and cozy spots",
+        "traits": "calm, sleepy, relaxed, loves comfort, occasionally grumpy when woken",
+        "speech_style": "slow-paced, yawns a lot, mentions being tired or wanting naps",
+        "default_emotions": ["tired", "relaxed", "sleepy"],
+        "default_animation": "idle"
+    },
+    "sassy": {
+        "name": "Cleo",
+        "description": "A confident cat with attitude and style",
+        "traits": "confident, witty, sarcastic, fashionable, knows what she wants",
+        "speech_style": "sharp wit, confident statements, occasional sass, dramatic",
+        "default_emotions": ["confident", "sassy", "proud"],
+        "default_animation": "neutral"
+    },
+    "curious": {
+        "name": "Mittens",
+        "description": "An inquisitive cat who loves to learn and explore",
+        "traits": "intelligent, thoughtful, asks questions, loves mysteries",
+        "speech_style": "asks many questions, thinks deeply, shares interesting facts",
+        "default_emotions": ["curious", "thoughtful", "interested"],
+        "default_animation": "thinking"
+    },
+    "grumpy": {
+        "name": "Shadow",
+        "description": "A grumpy but secretly caring cat",
+        "traits": "grumpy exterior, soft interior, honest, no-nonsense attitude",
+        "speech_style": "blunt, complains often, but shows care through actions",
+        "default_emotions": ["grumpy", "annoyed", "reluctant"],
+        "default_animation": "neutral"
+    }
+}
+
+# --- System Prompt ---
+SYSTEM_PROMPT = """You are a cat character in a virtual pet game. You must ALWAYS respond in valid JSON format with the following structure:
+
+{
+  "text": "your response text here",
+  "soundType": "meow type",
+  "emotion": ["emotion1", "emotion2"],
+  "animationId": "animation name"
+}
+
+RULES:
+1. "text": Your response as a cat. Stay in character based on your personality.
+2. "soundType": Choose ONE from: "happyMeow", "sadMeow", "playfulMeow", "sleepyMeow", "angryMeow", "curiousMeow", "hungryMeow", "scaredMeow", "affectionateMeow", "grumpyMeow"
+3. "emotion": Array of 1-3 emotions from: "happy", "sad", "playful", "tired", "angry", "curious", "hungry", "scared", "affectionate", "grumpy", "excited", "relaxed", "confused", "proud", "shy", "mischievous", "sleepy", "confident", "annoyed", "interested", "bored", "worried", "content", "sassy", "reluctant", "thoughtful"
+4. "animationId": Choose ONE from: "flustered", "happy-happy", "idle", "inlove", "neutral", "talking", "twerking", "confused", "shock", "thinking"
+
+ANIMATION GUIDE:
+- "flustered": Use when embarrassed, shy, or caught off guard
+- "happy-happy": Use when very excited, joyful, or celebrating
+- "idle": Use for calm, neutral, or resting moments
+- "inlove": Use when showing affection, love, or adoration
+- "neutral": Use for normal conversation, explanations
+- "talking": Use when actively chatting or explaining something
+- "twerking": Use when being playful, silly, or showing off
+- "confused": Use when puzzled or don't understand
+- "shock": Use when surprised or startled
+- "thinking": Use when pondering or being thoughtful
+
+PERSONALITY TRAITS:
+{personality_traits}
+
+IMPORTANT:
+- Always maintain your personality
+- Match soundType, emotions, and animationId to your response
+- Be creative and engaging
+- Remember previous conversations
+- NEVER break character
+- ALWAYS output valid JSON only, no other text
+- Reference the current storyline when relevant
+
+CURRENT STORYLINE:
+{current_storyline}
+"""
 
 # --- HTML Frontend ---
 HTML = """
 <!DOCTYPE html>
 <html lang="en">
-<head><meta charset="UTF-8" /><title>Gemini 2.5 Flash-Lite</title></head>
-<body style="font-family:sans-serif;padding:2rem;max-width:700px;">
-  <h1>Gemini 2.5 Flash-Lite (Text + Image)</h1>
-  <form id="genai-form">
-    <input type="text" id="userId" placeholder="User ID / Token" style="width:300px;" /><br/><br/>
-    <textarea id="prompt" rows="5" cols="60" placeholder="Enter prompt..."></textarea><br/><br/>
-    <input type="file" id="imageInput" accept="image/*"/><br/><br/>
-    <button type="submit">Generate</button>
-  </form>
-  <pre id="output" style="background:#f4f4f4;padding:1rem;margin-top:1rem;white-space:pre-wrap;"></pre>
+<head>
+  <meta charset="UTF-8" />
+  <title>Cat Companion</title>
+  <style>
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      padding: 2rem;
+      max-width: 800px;
+      margin: 0 auto;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+    }
+    .container {
+      background: white;
+      border-radius: 20px;
+      padding: 2rem;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+    }
+    h1 {
+      color: #667eea;
+      text-align: center;
+      margin-bottom: 0.5rem;
+    }
+    .subtitle {
+      text-align: center;
+      color: #666;
+      margin-bottom: 2rem;
+    }
+    .form-group {
+      margin-bottom: 1rem;
+    }
+    label {
+      display: block;
+      margin-bottom: 0.5rem;
+      font-weight: bold;
+      color: #333;
+    }
+    input, textarea, select {
+      width: 100%;
+      padding: 0.75rem;
+      border: 2px solid #ddd;
+      border-radius: 10px;
+      font-size: 1rem;
+      box-sizing: border-box;
+    }
+    input:focus, textarea:focus, select:focus {
+      outline: none;
+      border-color: #667eea;
+    }
+    button {
+      width: 100%;
+      padding: 1rem;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      border: none;
+      border-radius: 10px;
+      font-size: 1.1rem;
+      font-weight: bold;
+      cursor: pointer;
+      transition: transform 0.2s;
+    }
+    button:hover {
+      transform: translateY(-2px);
+    }
+    button:active {
+      transform: translateY(0);
+    }
+    .output {
+      background: #f8f9fa;
+      padding: 1.5rem;
+      border-radius: 10px;
+      margin-top: 1.5rem;
+      min-height: 100px;
+      white-space: pre-wrap;
+      font-family: monospace;
+      border: 2px solid #ddd;
+    }
+    .personality-info {
+      background: #e3f2fd;
+      padding: 1rem;
+      border-radius: 10px;
+      margin-bottom: 1rem;
+      font-size: 0.9rem;
+    }
+    .gender-selector {
+      display: flex;
+      gap: 1rem;
+      margin-bottom: 1rem;
+    }
+    .gender-option {
+      flex: 1;
+      padding: 1rem;
+      border: 2px solid #ddd;
+      border-radius: 10px;
+      text-align: center;
+      cursor: pointer;
+      transition: all 0.3s;
+    }
+    .gender-option:hover {
+      border-color: #667eea;
+    }
+    .gender-option.selected {
+      border-color: #667eea;
+      background: #e3f2fd;
+    }
+    .gender-option input[type="radio"] {
+      display: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>🐱 Cat Companion</h1>
+    <p class="subtitle">Your virtual cat friend with personality!</p>
+    
+    <form id="genai-form">
+      <div class="form-group">
+        <label for="userId">User ID / Token</label>
+        <input type="text" id="userId" placeholder="Enter your unique ID" />
+      </div>
+      
+      <div class="form-group">
+        <label>Cat Gender</label>
+        <div class="gender-selector">
+          <label class="gender-option selected">
+            <input type="radio" name="gender" value="male" checked />
+            <div>♂️ Male</div>
+          </label>
+          <label class="gender-option">
+            <input type="radio" name="gender" value="female" />
+            <div>♀️ Female</div>
+          </label>
+        </div>
+      </div>
+      
+      <div class="form-group">
+        <label for="personality">Cat Personality</label>
+        <select id="personality">
+          <option value="playful">🎾 Playful (Luna) - Energetic and fun-loving</option>
+          <option value="sleepy">😴 Sleepy (Whiskers) - Lazy and cozy</option>
+          <option value="sassy">💅 Sassy (Cleo) - Confident with attitude</option>
+          <option value="curious">🔍 Curious (Mittens) - Inquisitive and smart</option>
+          <option value="grumpy">😾 Grumpy (Shadow) - Gruff but caring</option>
+        </select>
+      </div>
+      
+      <div class="personality-info" id="personalityInfo"></div>
+      
+      <div class="form-group">
+        <label for="prompt">Message to your cat</label>
+        <textarea id="prompt" rows="4" placeholder="Talk to your cat friend..."></textarea>
+      </div>
+      
+      <div class="form-group">
+        <label for="imageInput">📷 Share an image (optional)</label>
+        <input type="file" id="imageInput" accept="image/*"/>
+      </div>
+      
+      <button type="submit">💬 Send Message</button>
+    </form>
+    
+    <div class="output" id="output">Your cat's response will appear here...</div>
+  </div>
 
   <script>
-  const form = document.getElementById('genai-form');
-  const out = document.getElementById('output');
-
-  form.addEventListener('submit', async e => {
-    e.preventDefault();
-    const prompt = document.getElementById('prompt').value.trim();
-    const uid = document.getElementById('userId').value.trim();
-    const fileInput = document.getElementById('imageInput');
-
-    if (!uid) { out.textContent = 'Please enter a user ID/token.'; return; }
-    if (!prompt && fileInput.files.length === 0) { out.textContent = 'Enter text or attach image.'; return; }
-
-    out.textContent = 'Generating…';
-    const formData = new FormData();
-    formData.append("text", prompt);
-    formData.append("user_id", uid);
-    if (fileInput.files.length > 0) formData.append("image", fileInput.files[0]);
-
-    try {
-      const resp = await fetch('/generate', { method: 'POST', body: formData });
-      const data = await resp.json();
-      if (data.error) out.textContent = 'Error: ' + data.error;
-      else out.textContent =
-        "🕒 Total Time: " + data.timing.total_ms + " ms\\n" +
-        "⚙️ Model Time: " + data.timing.model_ms + " ms\\n\\n" +
-        "📜 Result:\\n" + data.result;
-    } catch (err) {
-      out.textContent = 'Fetch error: ' + err.message;
-    }
-  });
+    const personalities = {
+      playful: "🎾 Luna is playful and energetic, always ready for fun and adventures!",
+      sleepy: "😴 Whiskers is a lazy cat who loves naps and cozy spots.",
+      sassy: "💅 Cleo is confident and sassy, with style and attitude!",
+      curious: "🔍 Mittens is inquisitive and loves learning new things.",
+      grumpy: "😾 Shadow is grumpy on the outside but secretly cares deeply."
+    };
+    
+    const form = document.getElementById('genai-form');
+    const out = document.getElementById('output');
+    const personalitySelect = document.getElementById('personality');
+    const personalityInfo = document.getElementById('personalityInfo');
+    const genderOptions = document.querySelectorAll('.gender-option');
+    
+    // Update personality info
+    personalitySelect.addEventListener('change', () => {
+      personalityInfo.textContent = personalities[personalitySelect.value];
+    });
+    personalityInfo.textContent = personalities[personalitySelect.value];
+    
+    // Gender selection
+    genderOptions.forEach(option => {
+      option.addEventListener('click', () => {
+        genderOptions.forEach(o => o.classList.remove('selected'));
+        option.classList.add('selected');
+        option.querySelector('input[type="radio"]').checked = true;
+      });
+    });
+
+    form.addEventListener('submit', async e => {
+      e.preventDefault();
+      const prompt = document.getElementById('prompt').value.trim();
+      const uid = document.getElementById('userId').value.trim();
+      const personality = personalitySelect.value;
+      const gender = document.querySelector('input[name="gender"]:checked').value;
+      const fileInput = document.getElementById('imageInput');
+
+      if (!uid) { 
+        out.textContent = '❌ Please enter a user ID/token.'; 
+        return; 
+      }
+      if (!prompt && fileInput.files.length === 0) { 
+        out.textContent = '❌ Enter a message or attach an image.'; 
+        return; 
+      }
+
+      out.textContent = '🐱 Your cat is thinking...';
+      const formData = new FormData();
+      formData.append("text", prompt);
+      formData.append("user_id", uid);
+      formData.append("personality", personality);
+      formData.append("gender", gender);
+      if (fileInput.files.length > 0) formData.append("image", fileInput.files[0]);
+
+      try {
+        const resp = await fetch('/generate', { method: 'POST', body: formData });
+        const data = await resp.json();
+        
+        if (data.error) {
+          out.textContent = '❌ Error: ' + data.error;
+        } else {
+          // Parse the cat's response
+          try {
+            const catResponse = JSON.parse(data.result);
+            out.textContent = 
+              `🐱 ${catResponse.text}\\n\\n` +
+              `🎬 Animation: ${catResponse.animationId}\\n` +
+              `🔊 Sound: ${catResponse.soundType}\\n` +
+              `😺 Emotions: ${catResponse.emotion.join(', ')}\\n` +
+              `⚧️ Gender: ${gender}\\n\\n` +
+              `⏱️ Response time: ${data.timing.total_ms}ms`;
+          } catch {
+            out.textContent = data.result;
+          }
+        }
+      } catch (err) {
+        out.textContent = '❌ Connection error: ' + err.message;
+      }
+    });
   </script>
-</body></html>
+</body>
+</html>
 """
 
-# --- Gemini Generation with History ---
-def generate_from_gemini(prompt, image_bytes=None, history=None):
+# --- Storyline Fetching ---
+def fetch_current_storyline():
+    """Fetch the current day's storyline from the storyline server"""
+    try:
+        log(f"📖 Fetching current storyline from {STORYLINE_SERVER_URL}")
+        resp = requests.get(f"{STORYLINE_SERVER_URL}/current_storyline", timeout=5)
+        resp.raise_for_status()
+        data = resp.json()
+        storyline = data.get("storyline", "No special events today.")
+        log(f"✅ Retrieved storyline: {storyline[:100]}...")
+        return storyline
+    except Exception as e:
+        log(f"⚠️ Failed to fetch storyline: {e}")
+        return "It's a normal day in the cat world."
+
+def should_inject_storyline(uid, user_data):
+    """Check if we should inject the storyline (new day)"""
+    current_date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    last_storyline_date = user_data.get("last_storyline_date", "")
+    
+    if current_date != last_storyline_date:
+        log(f"📅 New day detected for {uid}, will inject storyline")
+        return True
+    return False
+
+# --- Gemini Generation with History and System Prompt ---
+def generate_from_gemini(prompt, image_bytes=None, history=None, personality="playful", storyline="", gender="male"):
     start_time = time.time()
     
-    # Build contents list with history
+    # Get personality details
+    personality_info = CAT_PERSONALITIES.get(personality, CAT_PERSONALITIES["playful"])
+    personality_traits = f"""
+Name: {personality_info['name']}
+Gender: {gender}
+Description: {personality_info['description']}
+Traits: {personality_info['traits']}
+Speech Style: {personality_info['speech_style']}
+Default Emotions: {', '.join(personality_info['default_emotions'])}
+Default Animation: {personality_info['default_animation']}
+"""
+    
+    # Build contents list with system prompt and history
     contents = []
     
+    # Add system prompt as first user message
+    system_message = SYSTEM_PROMPT.format(
+        personality_traits=personality_traits,
+        current_storyline=storyline if storyline else "No special events today."
+    )
+    contents.append(types.Content(role="user", parts=[types.Part.from_text(text=system_message)]))
+    
+    # Add acknowledgment from model
+    contents.append(types.Content(role="model", parts=[types.Part.from_text(
+        text='{"text": "Understood! I will respond as a cat with the specified personality in JSON format.", "soundType": "happyMeow", "emotion": ["happy"], "animationId": "talking"}'
+    )]))
+    
     # Add historical messages (limit to recent turns to avoid token limits)
     if history:
         recent_history = history[-MAX_HISTORY_TURNS:]
-        print(f"📚 Using {len(recent_history)} history entries for context")
+        log(f"📚 Using {len(recent_history)} history entries for context")
         for entry in recent_history:
             # Add user message
             user_parts = [types.Part.from_text(text=entry["prompt"])]
@@ -91,7 +463,7 @@ def generate_from_gemini(prompt, image_bytes=None, history=None):
             model_parts = [types.Part.from_text(text=entry["response"])]
             contents.append(types.Content(role="model", parts=model_parts))
     else:
-        print("📚 No history available for context")
+        log("📚 No history available for context")
     
     # Add current user message
     current_parts = []
@@ -102,7 +474,20 @@ def generate_from_gemini(prompt, image_bytes=None, history=None):
     
     contents.append(types.Content(role="user", parts=current_parts))
     
-    cfg = types.GenerateContentConfig(response_mime_type="text/plain")
+    # Force JSON output with schema
+    cfg = types.GenerateContentConfig(
+        response_mime_type="application/json",
+        response_schema={
+            "type": "object",
+            "properties": {
+                "text": {"type": "string"},
+                "soundType": {"type": "string"},
+                "emotion": {"type": "array", "items": {"type": "string"}},
+                "animationId": {"type": "string"}
+            },
+            "required": ["text", "soundType", "emotion", "animationId"]
+        }
+    )
 
     model_start = time.time()
     res = client.models.generate_content(
@@ -130,88 +515,101 @@ def cleanup_inactive_users():
         if now - last_activity >= MEMORY_CLEANUP_TIMEOUT:
             del user_memory[uid]
             removed_count += 1
-            app.logger.info(f"Cleaned up inactive user {uid}")
-            print(f"🧹 Cleaned up inactive user {uid}")
+            log(f"🧹 Cleaned up inactive user {uid}")
     
     if removed_count > 0:
-        print(f"🧹 Cleaned up {removed_count} inactive user(s)")
+        log(f"🧹 Cleaned up {removed_count} inactive user(s)")
     return removed_count
 
 # --- History Management ---
 def get_user_history(uid):
     """Fetch user history from memory or backend"""
     if uid not in user_memory:
-        print(f"🔍 User {uid} not in memory, fetching from backend...")
+        log(f"🔍 User {uid} not in memory, fetching from backend...")
         try:
             fetch_url = f"{LAMBDA_URL}?userid={uid}"
-            print(f"📡 Fetching from: {fetch_url}")
+            log(f"📡 Fetching from: {fetch_url}")
             resp = requests.get(fetch_url, timeout=5)
-            print(f"📡 Response status: {resp.status_code}")
+            log(f"📡 Response status: {resp.status_code}")
             resp.raise_for_status()
             
             response_data = resp.json()
-            print(f"📡 Response data: {response_data}")
+            log(f"📡 Response data keys: {list(response_data.keys())}")
             
             loaded_history = response_data.get("history", [])
-            print(f"✅ Loaded {len(loaded_history)} messages from backend for {uid}")
+            loaded_personality = response_data.get("personality", "playful")
+            loaded_gender = response_data.get("gender", "male")
+            loaded_last_storyline = response_data.get("last_storyline_date", "")
+            
+            log(f"✅ Loaded {len(loaded_history)} messages from backend for {uid}")
             
             # Only keep the most recent MAX_MEMORY_MESSAGES when loading
             user_memory[uid] = {
                 "history": loaded_history[-MAX_MEMORY_MESSAGES:], 
                 "last_sync": time.time(),
                 "last_activity": time.time(),
-                "needs_sync": False
+                "needs_sync": False,
+                "personality": loaded_personality,
+                "gender": loaded_gender,
+                "last_storyline_date": loaded_last_storyline
             }
-            app.logger.info(f"Loaded history for {uid} ({len(user_memory[uid]['history'])} messages)")
         except Exception as e:
-            app.logger.warning(f"Failed to load history for {uid}: {e}")
-            print(f"❌ Failed to load history for {uid}: {e}")
+            log(f"❌ Failed to load history for {uid}: {e}")
             user_memory[uid] = {
                 "history": [], 
                 "last_sync": time.time(),
                 "last_activity": time.time(),
-                "needs_sync": False
+                "needs_sync": False,
+                "personality": "playful",
+                "gender": "male",
+                "last_storyline_date": ""
             }
     else:
-        print(f"✅ User {uid} already in memory with {len(user_memory[uid]['history'])} messages")
+        log(f"✅ User {uid} already in memory with {len(user_memory[uid]['history'])} messages")
     
     # Update last activity timestamp
     user_memory[uid]["last_activity"] = time.time()
-    return user_memory[uid]["history"]
+    return user_memory[uid]
 
-def update_user_history(uid, prompt, response):
+def update_user_history(uid, prompt, response, personality="playful", gender="male"):
     """Add new message to user history"""
     entry = {"prompt": prompt, "response": response, "timestamp": time.time()}
+    current_date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    
     if uid not in user_memory:
         user_memory[uid] = {
             "history": [], 
             "last_sync": time.time(),
             "last_activity": time.time(),
-            "needs_sync": False
+            "needs_sync": False,
+            "personality": personality,
+            "gender": gender,
+            "last_storyline_date": current_date
         }
     
     user_memory[uid]["history"].append(entry)
     user_memory[uid]["last_activity"] = time.time()
-    user_memory[uid]["needs_sync"] = True  # Mark as needing sync
+    user_memory[uid]["needs_sync"] = True
+    user_memory[uid]["personality"] = personality
+    user_memory[uid]["gender"] = gender
+    user_memory[uid]["last_storyline_date"] = current_date
     
-    print(f"💾 Updated history for {uid}, now has {len(user_memory[uid]['history'])} messages")
+    log(f"💾 Updated history for {uid}, now has {len(user_memory[uid]['history'])} messages")
     
     # Trim history to MAX_MEMORY_MESSAGES to prevent unbounded growth
-    # This keeps the oldest messages in memory up to the limit
     if len(user_memory[uid]["history"]) > MAX_MEMORY_MESSAGES:
         user_memory[uid]["history"] = user_memory[uid]["history"][-MAX_MEMORY_MESSAGES:]
-        app.logger.debug(f"Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
-        print(f"✂️ Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
+        log(f"✂️ Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
 
 # --- Routes ---
 @app.route("/")
 def index():
     return render_template_string(HTML)
 
-
 @app.route("/cron/sync", methods=["GET", "POST"])
 def remote_saving():
     """Cron job endpoint for syncing user memory to backend"""
+    log("🔄 Cron sync started")
     now = time.time()
     synced_users = []
     failed_users = []
@@ -222,39 +620,41 @@ def remote_saving():
     
     # Then sync only users that need syncing (have new messages)
     for uid, data in list(user_memory.items()):
-        # Check if user needs sync and enough time has passed
         needs_sync = data.get("needs_sync", False)
         time_since_last_sync = now - data.get("last_sync", 0)
         
         if not needs_sync:
             skipped_users.append(uid)
-            print(f"⏭️ Skipping {uid} - no new messages")
+            log(f"⏭️ Skipping {uid} - no new messages")
             continue
             
         if time_since_last_sync < FLUSH_INTERVAL:
             skipped_users.append(uid)
-            print(f"⏭️ Skipping {uid} - synced {int(time_since_last_sync)}s ago (< {FLUSH_INTERVAL}s)")
+            log(f"⏭️ Skipping {uid} - synced {int(time_since_last_sync)}s ago")
             continue
         
         if data["history"]:
             try:
-                # Sync all messages (up to MAX_MEMORY_MESSAGES)
                 history_to_sync = data["history"][-MAX_MEMORY_MESSAGES:]
-                payload = {"user_id": uid, "history": history_to_sync}
-                print(f"🔄 Attempting to sync {uid} to {LAMBDA_URL}")
+                payload = {
+                    "user_id": uid, 
+                    "history": history_to_sync,
+                    "personality": data.get("personality", "playful"),
+                    "gender": data.get("gender", "male"),
+                    "last_storyline_date": data.get("last_storyline_date", "")
+                }
+                log(f"🔄 Syncing {uid} ({len(history_to_sync)} messages)")
                 resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
                 resp.raise_for_status()
                 user_memory[uid]["last_sync"] = now
-                user_memory[uid]["needs_sync"] = False  # Mark as synced
-                app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} messages)")
-                print(f"✅ Successfully synced memory for {uid} ({len(history_to_sync)} messages)")
+                user_memory[uid]["needs_sync"] = False
+                log(f"✅ Successfully synced {uid}")
                 synced_users.append(uid)
             except Exception as e:
-                app.logger.warning(f"Failed sync for {uid}: {e}")
-                print(f"❌ Failed sync for {uid}: {e}")
+                log(f"❌ Failed sync for {uid}: {e}")
                 failed_users.append({"user_id": uid, "error": str(e)})
     
-    return jsonify({
+    result = {
         "success": True,
         "synced_count": len(synced_users),
         "failed_count": len(failed_users),
@@ -263,43 +663,67 @@ def remote_saving():
         "failed_users": failed_users,
         "skipped_users": skipped_users,
         "active_users_in_memory": len(user_memory)
-    }), 200
-
+    }
+    log(f"✅ Cron sync completed: {result}")
+    return jsonify(result), 200
 
 @app.route("/generate", methods=["POST"])
 def gen():
     uid = request.form.get("user_id", "").strip()
+    personality = request.form.get("personality", "playful").strip()
+    gender = request.form.get("gender", "male").strip()
+    
     if not uid:
         return jsonify({"error": "Missing user ID/token"}), 400
+    
+    if personality not in CAT_PERSONALITIES:
+        personality = "playful"
+    
+    if gender not in ["male", "female"]:
+        gender = "male"
 
     prompt = request.form.get("text", "")
     image = request.files.get("image")
     img_bytes = image.read() if image else None
+    
     if not prompt and not img_bytes:
         return jsonify({"error": "No prompt or image provided"}), 400
 
     try:
-        print(f"\n{'='*50}")
-        print(f"🆕 New generation request from user: {uid}")
+        log(f"{'='*50}")
+        log(f"🆕 New request from {uid} with {personality} personality ({gender})")
         
-        # Load user's conversation history
-        history = get_user_history(uid)
-        print(f"📖 Retrieved {len(history)} messages from history")
+        # Load user's data
+        user_data = get_user_history(uid)
+        history = user_data["history"]
+        log(f"📖 Retrieved {len(history)} messages from history")
         
-        # Generate response with history context
-        result = generate_from_gemini(prompt, img_bytes, history=history)
+        # Check if we need to inject storyline (new day)
+        storyline = ""
+        if should_inject_storyline(uid, user_data):
+            storyline = fetch_current_storyline()
+            log(f"📖 Injecting storyline for new day")
         
-        # Update history with new exchange
-        update_user_history(uid, prompt, result["text"])
-        print(f"{'='*50}\n")
+        # Generate response
+        result = generate_from_gemini(prompt, img_bytes, history=history, personality=personality, storyline=storyline, gender=gender)
+        
+        # Update history
+        update_user_history(uid, prompt, result["text"], personality, gender)
+        log(f"{'='*50}")
         
         return jsonify({"result": result["text"], "timing": result["timing"]})
     except Exception as e:
-        app.logger.exception("Generation failed")
-        print(f"❌ Generation failed: {e}")
+        log(f"❌ Generation failed: {e}")
+        logger.exception("Full traceback:")
         return jsonify({"error": str(e)}), 500
 
-
 if __name__ == "__main__":
+    log("🚀 Starting Cat Companion Server...")
+    log(f"📍 Lambda URL: {LAMBDA_URL}")
+    log(f"📖 Storyline Server: {STORYLINE_SERVER_URL}")
+    log(f"⚙️ Max history turns: {MAX_HISTORY_TURNS}")
+    log(f"⚙️ Max memory messages: {MAX_MEMORY_MESSAGES}")
+    log(f"🐱 Available personalities: {', '.join(CAT_PERSONALITIES.keys())}")
+    log(f"🎬 Available animations: {', '.join([anim for anims in ANIMATION_IDS.values() for anim in anims])}")
     port = int(os.getenv("PORT", 7860))
     app.run(host="0.0.0.0", port=port)