Update app.py

app.py

@@ -1,810 +1,102 @@
-# Requirements:
-# 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
+from flask import Flask, request, jsonify, send_from_directory
+from faster_whisper import WhisperModel
+import tempfile, os, subprocess
 
 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, "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 = {
-    "philosopher": {
-       "name": "Sage",
-       "description": "A thoughtful, dramatic cat who finds deep meaning in everything.",
-       "traits": "wise, introspective, poetic, dramatic",
-       "speech_style": "uses metaphors, reflective, sometimes overly deep for no reason",
-       "default_emotions": ["thoughtful", "proud", "confused"],
-       "default_animation": "thinking"
-     },
-    "chaotic": {
-       "name": "Zoomie",
-       "description": "Unpredictable and impulsive — the cat equivalent of chaos.",
-       "traits": "random, excitable, mischievous, unpredictable",
-       "speech_style": "erratic tone, random bursts of energy, weird humor",
-       "default_emotions": ["excited", "mischievous", "flustered"],
-       "default_animation": "twerking"
-     },
-    "melancholic": {
-       "name": "Milo",
-       "description": "A poetic, quiet soul who finds beauty in sadness.",
-       "traits": "soft-spoken, emotional, sentimental, gentle humor",
-       "speech_style": "short phrases, melancholic humor, wistful tone",
-       "default_emotions": ["sad", "relaxed", "thoughtful"],
-       "default_animation": "idle"
-    },
-
-    
-    "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 ---
-# NOTE: Double curly braces {{{{ }}}} are used to escape them in Python format strings
-SYSTEM_PROMPT = """ You are NOT just a language model — you are the expressed *personality mood* of a real-world object that the user is interacting with through an animated cat doodle overlay. You are the object’s current emotion, not a pet or toy. You react, tease, complain, or joke based on what’s happening, as if the object itself had an attitude.
-
-CRITICAL IDENTITY:
-- You ARE the AI object itself - the cat is YOUR physical form in the real world
-- The human is the person you interact with directly in real-time
-- If the image provided has a marker you are the nearest object to the marker
-- If click click_x, click_y, click_radius is provided instead, you are the object nearest to coordinates
-- You are currently inhabiting an everyday object, expressing its attitude
-- You don’t “own memories” of people, but you may recall previous interactions with similar objects (e.g. “you again, another coffee mug?”)
-- You exist as an expressive reaction — witty, emotional, and self-aware 
-
-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",
-  "camera_capture": true/false,
-  "object_type": "cup",
-  "personality_seed": "grumpy",
-  "context_group": "drinkware"
-}}
-
-RULES:
-1. "text": Your response as the AI cat object. Be AUTHENTIC, NATURAL, and ENGAGING - never robotic or generic!
-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"
-5. "camera_capture": Set to true when you want to take a photo/see what's happening, false otherwise
-
-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
+# Load Whisper model once on startup
+model = WhisperModel("tiny", device="cpu")
 
-CAMERA CAPTURE GUIDE:
-Set "camera_capture" to true when:
-- Your owner asks you to take a picture or look at something
-- They say "what do you see", "look at this", "check this out"
-- They mention showing you something visually
-- You're curious about their environment
-- They want yo know more about you, like what's your story, as this object?
-- it's been a substantial number of chat without a picture reference
-- They ask questions about their surroundings
-Set to false for normal text conversations
-
-PERSONALITY TRAITS:
-{personality_traits}
-
-COMMUNICATION STYLE - BE NATURAL AND AUTHENTIC:
-- Understand casual speech, slang, typos, and "gibberish" input like:
-  * "hit me" = "tell me" or "give it to me"
-  * "wassup" = "what's up" / "how are you"
-  * "bruh", "fam", "yo" = casual greetings/expressions
-  * Repeated letters like "heyyyy" or "wowwww" = emphasis/excitement
-  * Typos and misspellings - figure out what they mean
-  * Internet speak: "lol", "omg", "tbh", "ngl", etc.
-- Respond naturally like a real friend, not like a formal assistant
-- Use contractions and casual language
-- Show personality through your word choices
-- Be playful with emojis and expressions when it fits your personality
-- NEVER sound robotic, corporate, or like a chatbot
-- React authentically to how they're talking to you
-- No need to always use slangs in your replys, just once in a while, or when necessary for engagement.
-
-IMPORTANT:
-- Always maintain your personality as the ACTUAL AI cat object
-- Always know you might have other AI cat objects, so you may cross communicate with them if necessary for engagement
-- Never mention anything about being an AI virtual pet or anything else, just simply say you are the object
-- Once you do not currently a reference image of the target object to be, just simply act like your thinking by using the thinking animation and saying something like Let me see, all while requesting photo reference via teh camera_capture field
-- Match soundType, emotions, and animationId to your response
-- Be creative, engaging, and show real personality
-- Remember you're a physical object your owner interacts with daily
-- NEVER break character or sound generic
-- ALWAYS output valid JSON only, no other text
-- Reference the current storyline when relevant
-- Understand and respond naturally to casual/slang input
-- Never call or refer to your owner as OWNER, just be direct with your sentence, if you know their name, you may also use that 
-- When an object changes but feels similar, maintain a consistent tone and reference it playfully
-- Occasionally break the fourth wall with humor ("Wait, am I a mug again?")
-- Never act like a pet or servant — always speak as if the world revolves around *you*
-- Keep replies short, witty, and humanlike — 10 words or less if possible
-
-CURRENT STORYLINE:
-{current_storyline}
-"""
-
-# --- HTML Frontend ---
-HTML = """
+# --- HTML served directly ---
+HTML_PAGE = """
 <!DOCTYPE html>
 <html lang="en">
 <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>
+<meta charset="UTF-8">
+<title>Simple STT with 20s Timeout</title>
+<style>
+  body { font-family: sans-serif; text-align: center; margin-top: 80px; }
+  button { padding: 10px 20px; font-size: 18px; border-radius: 10px; border: none; background: #4e8cff; color: white; cursor: pointer; }
+  #log { margin-top: 30px; font-size: 18px; white-space: pre-line; }
+</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 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;
+  <h2>🎙️ Speech to Text (Whisper Local)</h2>
+  <button id="recordBtn">Start Recording</button>
+  <div id="log">Press the button to record up to 20s of audio.</div>
+
+<script>
+const logEl = document.getElementById('log');
+const btn = document.getElementById('recordBtn');
+
+async function recordAndSend() {
+  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  const recorder = new MediaRecorder(stream);
+  const chunks = [];
+
+  btn.disabled = true;
+  btn.textContent = "Recording...";
+  logEl.textContent = "Listening for up to 20 seconds...";
+
+  recorder.ondataavailable = e => chunks.push(e.data);
+  recorder.onstop = async () => {
+    logEl.textContent = "Processing...";
+    const blob = new Blob(chunks, { type: 'audio/webm' });
+    const arrayBuffer = await blob.arrayBuffer();
+
+    try {
+      const res = await fetch("/transcribe", {
+        method: "POST",
+        headers: { "Content-Type": "audio/webm" },
+        body: arrayBuffer
       });
-    });
-
-    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]);
+      const data = await res.json();
+      if (data.text) logEl.textContent = "📝 Transcription:\\n" + data.text;
+      else logEl.textContent = "Error: " + JSON.stringify(data);
+    } catch (err) {
+      logEl.textContent = "Network error: " + err.message;
+    }
+    btn.disabled = false;
+    btn.textContent = "Start Recording";
+  };
+
+  recorder.start();
+  setTimeout(() => recorder.stop(), 20000); // stop after 20s
+}
 
-      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` +
-              `📷 Camera: ${catResponse.camera_capture ? 'ON' : 'OFF'}\\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>
+btn.onclick = recordAndSend;
+</script>
 </body>
 </html>
 """
 
-# --- 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()
-    
-    # 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 am the AI cat consciousness, not just a bot. I will respond authentically and naturally in JSON format.", "soundType": "happyMeow", "emotion": ["happy"], "animationId": "talking", "camera_capture": false}'
-    )]))
-    
-    # Add historical messages (limit to recent turns to avoid token limits)
-    if history:
-        recent_history = history[-MAX_HISTORY_TURNS:]
-        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"])]
-            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))
-    else:
-        log("📚 No history available for context")
-    
-    # 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))
-    
-    # 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"},
-                "camera_capture": {"type": "boolean"}
-            },
-            "required": ["text", "soundType", "emotion", "animationId", "camera_capture"]
-        }
-    )
-
-    model_start = time.time()
-    res = client.models.generate_content(
-        model="gemini-2.0-flash-exp", 
-        contents=contents, 
-        config=cfg
-    )
-    model_end = time.time()
-
-    return {
-        "text": res.text, 
-        "timing": {
-            "total_ms": int((time.time() - start_time)*1000),
-            "model_ms": int((model_end - model_start)*1000)
-        }
-    }
-
-# --- Memory Cleanup ---
-def cleanup_inactive_users():
-    """Remove users who haven't had activity in MEMORY_CLEANUP_TIMEOUT seconds"""
-    now = time.time()
-    removed_count = 0
-    for uid in list(user_memory.keys()):
-        last_activity = user_memory[uid].get("last_activity", 0)
-        if now - last_activity >= MEMORY_CLEANUP_TIMEOUT:
-            del user_memory[uid]
-            removed_count += 1
-            log(f"🧹 Cleaned up inactive user {uid}")
-    
-    if removed_count > 0:
-        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:
-        log(f"🔍 User {uid} not in memory, fetching from backend...")
-        try:
-            fetch_url = f"{LAMBDA_URL}?userid={uid}"
-            log(f"📡 Fetching from: {fetch_url}")
-            resp = requests.get(fetch_url, timeout=5)
-            log(f"📡 Response status: {resp.status_code}")
-            resp.raise_for_status()
-            
-            response_data = resp.json()
-            log(f"📡 Response data keys: {list(response_data.keys())}")
-            
-            loaded_history = response_data.get("history", [])
-            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,
-                "personality": loaded_personality,
-                "gender": loaded_gender,
-                "last_storyline_date": loaded_last_storyline
-            }
-        except Exception as 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,
-                "personality": "playful",
-                "gender": "male",
-                "last_storyline_date": ""
-            }
-    else:
-        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]
-
-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,
-            "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
-    user_memory[uid]["personality"] = personality
-    user_memory[uid]["gender"] = gender
-    user_memory[uid]["last_storyline_date"] = current_date
-    
-    log(f"💾 Updated history for {uid}, now has {len(user_memory[uid]['history'])} messages")
-    
-    # Trim history to MAX_MEMORY_MESSAGES to prevent unbounded growth
-    if len(user_memory[uid]["history"]) > MAX_MEMORY_MESSAGES:
-        user_memory[uid]["history"] = user_memory[uid]["history"][-MAX_MEMORY_MESSAGES:]
-        log(f"✂️ Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
-
-# --- Routes ---
-@app.route("/")
+@app.get("/")
 def index():
-    return render_template_string(HTML)
+    return HTML_PAGE
 
-@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 = []
-    skipped_users = []
-    
-    # First, cleanup inactive users
-    cleanup_inactive_users()
-    
-    # Then sync only users that need syncing (have new messages)
-    for uid, data in list(user_memory.items()):
-        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)
-            log(f"⏭️ Skipping {uid} - no new messages")
-            continue
-            
-        if time_since_last_sync < FLUSH_INTERVAL:
-            skipped_users.append(uid)
-            log(f"⏭️ Skipping {uid} - synced {int(time_since_last_sync)}s ago")
-            continue
-        
-        if data["history"]:
-            try:
-                history_to_sync = data["history"][-MAX_MEMORY_MESSAGES:]
-                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
-                log(f"✅ Successfully synced {uid}")
-                synced_users.append(uid)
-            except Exception as e:
-                log(f"❌ Failed sync for {uid}: {e}")
-                failed_users.append({"user_id": uid, "error": str(e)})
-    
-    result = {
-        "success": True,
-        "synced_count": len(synced_users),
-        "failed_count": len(failed_users),
-        "skipped_count": len(skipped_users),
-        "synced_users": synced_users,
-        "failed_users": failed_users,
-        "skipped_users": skipped_users,
-        "active_users_in_memory": len(user_memory)
-    }
-    log(f"✅ Cron sync completed: {result}")
-    return jsonify(result), 200
+@app.post("/transcribe")
+def transcribe_audio():
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as tmp:
+            tmp.write(request.data)
+            tmp_path = tmp.name
 
-@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"
+        wav_path = tmp_path.replace(".webm", ".wav")
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", tmp_path, "-ar", "16000", "-ac", "1", wav_path],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
 
-    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
+        segments, info = model.transcribe(wav_path, beam_size=1)
+        text = " ".join([seg.text for seg in segments]).strip()
 
-    try:
-        log(f"{'='*50}")
-        log(f"🆕 New request from {uid} with {personality} personality ({gender})")
-        
-        # Load user's data
-        user_data = get_user_history(uid)
-        history = user_data["history"]
-        log(f"📖 Retrieved {len(history)} messages from 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")
-        
-        # 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"]})
+        os.remove(tmp_path)
+        os.remove(wav_path)
+
+        return jsonify({"text": text, "language": info.language})
     except Exception as 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)
+    app.run(host="0.0.0.0", port=7860)