Update app.py

app.py

@@ -1,22 +1,23 @@
-#!/usr/bin/env python3
+# single_suggest_server.py
 """
-single_suggest_server_v2.py
+Single-endpoint suggestion server using Google Gemini (genai) exclusively.
 
-Improved single-endpoint suggestion server for the Walkthrough frontend.
+Environment variables:
+ - GEMINI_API_KEY (optional)       : API key for Google genai SDK
+ - FIREBASE_ADMIN_JSON (optional)  : service account JSON (string) to initialize firebase-admin
+ - PORT (optional)                 : port to run (default 7860)
 
-Endpoints:
- - POST /suggest  -> accepts JSON or multipart/form-data
-      - body fields: uid (optional), wardrobe_items (optional, array), user_inputs (required), max_candidates (optional)
-      - files: optional 'audio' multipart file
- - GET  /health   -> quick health check (Gemini + Firestore availability)
- - GET  /wardrobe/:uid (optional) -> fetches wardrobe from Firestore (for debugging)
+Behavior:
+ - If GEMINI_API_KEY & genai SDK present: uses Gemini for candidate generation and final notes.
+ - Otherwise falls back to deterministic naive generator (no placeholders).
+ - Firestore persistence if FIREBASE_ADMIN_JSON provided.
 """
 
 import os
 import io
 import json
-import time
 import uuid
+import time
 import logging
 import difflib
 from typing import List, Dict, Any, Optional
@@ -24,7 +25,10 @@ from typing import List, Dict, Any, Optional
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
-# Optional Gemini client (Google GenAI)
+# HTTP helper for generic fetches if needed
+import requests
+
+# Try to import Google GenAI SDK
 try:
     from google import genai
     from google.genai import types
@@ -34,7 +38,18 @@ except Exception:
     types = None
     GENAI_AVAILABLE = False
 
-# Firebase Admin
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
+if GEMINI_API_KEY and GENAI_AVAILABLE:
+    client = genai.Client(api_key=GEMINI_API_KEY)
+    logging.info("Gemini client configured.")
+else:
+    client = None
+    if GEMINI_API_KEY and not GENAI_AVAILABLE:
+        logging.warning("GEMINI_API_KEY provided but genai SDK not installed; Gemini disabled.")
+    else:
+        logging.info("GEMINI_API_KEY not provided; using deterministic fallback generator.")
+
+# Firestore admin
 try:
     import firebase_admin
     from firebase_admin import credentials as fb_credentials
@@ -46,79 +61,48 @@ except Exception:
     fb_firestore_module = None
     FIREBASE_AVAILABLE = False
 
-# logging
-logging.basicConfig(level=logging.INFO)
-log = logging.getLogger("single-suggest-v2")
-
-# config from env
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
-FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()  # stringified JSON expected
-MAX_CANDIDATES_DEFAULT = int(os.getenv("MAX_CANDIDATES_DEFAULT", "6"))
-
-# initialize optional Gemini client
-client = None
-if GEMINI_API_KEY and GENAI_AVAILABLE:
-    try:
-        client = genai.Client(api_key=GEMINI_API_KEY)
-        log.info("Gemini client configured.")
-    except Exception as e:
-        log.exception("Failed to init Gemini client: %s", e)
-        client = None
-else:
-    if GEMINI_API_KEY:
-        log.warning("GEMINI_API_KEY provided but genai SDK not available; skipping Gemini.")
-    else:
-        log.info("No GEMINI_API_KEY provided; using deterministic generator.")
-
-# Firestore: lazy init
+FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
 _firestore_client = None
 _firebase_app = None
 
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger("single-suggest-gemini-server")
 
 def init_firestore_if_needed():
     global _firestore_client, _firebase_app
     if _firestore_client is not None:
         return _firestore_client
+    if not FIREBASE_ADMIN_JSON:
+        log.info("No FIREBASE_ADMIN_JSON set; Firestore not initialized.")
+        return None
     if not FIREBASE_AVAILABLE:
-        log.warning("firebase_admin not installed; Firestore unavailable.")
+        log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK not available; skip Firestore init.")
+        return None
+    try:
+        sa_obj = json.loads(FIREBASE_ADMIN_JSON)
+    except Exception as e:
+        log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
         return None
-    # prefer explicit env-provided service account JSON
-    if FIREBASE_ADMIN_JSON:
-        try:
-            sa = json.loads(FIREBASE_ADMIN_JSON)
-            cred = fb_credentials.Certificate(sa)
-            try:
-                _firebase_app = firebase_admin.get_app()
-            except Exception:
-                _firebase_app = firebase_admin.initialize_app(cred)
-            _firestore_client = fb_firestore_module.client()
-            log.info("Initialized Firestore from FIREBASE_ADMIN_JSON.")
-            return _firestore_client
-        except Exception as e:
-            log.exception("Failed to init Firestore with FIREBASE_ADMIN_JSON: %s", e)
-            # fallback to default app
-    # fallback: try default application credentials
     try:
+        cred = fb_credentials.Certificate(sa_obj)
         try:
             _firebase_app = firebase_admin.get_app()
         except Exception:
-            _firebase_app = firebase_admin.initialize_app()
+            _firebase_app = firebase_admin.initialize_app(cred)
         _firestore_client = fb_firestore_module.client()
-        log.info("Initialized Firestore via default credentials.")
+        log.info("Initialized Firestore client.")
         return _firestore_client
     except Exception as e:
-        log.exception("Firestore initialization failed: %s", e)
+        log.exception("Failed to init Firestore: %s", e)
         return None
 
-
-# ---------- Category / mapping utilities ----------
+# ---------- categories / heuristics ----------
 CATEGORIES = [
     "top", "shirt", "blouse", "tshirt", "sweater", "jacket", "coat", "dress", "skirt",
     "pants", "trousers", "shorts", "jeans", "shoe", "heels", "sneaker", "boot", "sandals",
     "bag", "belt", "hat", "accessory", "others",
 ]
 
-
 def map_type_to_category(item_type: str) -> str:
     if not item_type:
         return "others"
@@ -136,7 +120,6 @@ def map_type_to_category(item_type: str) -> str:
             return token
     return "others"
 
-
 def _safe_item_brand(itm: Dict[str, Any]) -> str:
     analysis = itm.get("analysis") or {}
     brand = analysis.get("brand") if isinstance(analysis, dict) else None
@@ -144,15 +127,11 @@ def _safe_item_brand(itm: Dict[str, Any]) -> str:
         brand = itm.get("brand") or ""
     return str(brand).strip()
 
+TOP_LIKE_CATEGORIES = {"top", "shirt", "tshirt", "blouse", "sweater"}
 
 def _item_title_for_map(it: Dict[str, Any]) -> str:
     return str((it.get("title") or (it.get("analysis") or {}).get("type") or it.get("label") or "")).strip().lower()
 
-
-# prioritize top-like items first (for note consistency)
-TOP_LIKE_CATEGORIES = {"top", "shirt", "tshirt", "blouse", "sweater"}
-
-
 def prioritize_top_item(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     if not items:
         return items
@@ -171,7 +150,6 @@ def prioritize_top_item(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         item = new_items.pop(top_idx)
         new_items.insert(0, item)
         return new_items
-    # fallback to highest confidence
     try:
         best_idx = max(range(len(items)), key=lambda i: float(items[i].get("confidence", 0.5)))
         if best_idx != 0:
@@ -183,8 +161,7 @@ def prioritize_top_item(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         pass
     return items
 
-
-# ---------- Candidate generation (naive) ----------
+# ---------- deterministic naive generator (real) ----------
 def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
                               user_inputs: Dict[str, Any],
                               user_profile: Dict[str, Any],
@@ -254,8 +231,7 @@ def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
     candidates.sort(key=lambda c: c.get("score", 0), reverse=True)
     return candidates
 
-
-# If Gemini enabled, use it to generate candidates (best-effort). If it fails, fall back to naive.
+# ---------- Gemini helpers ----------
 def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
                                     user_inputs: Dict[str, Any],
                                     user_profile: Dict[str, Any],
@@ -275,8 +251,10 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
                 "summary": (a.get("summary") or "")[:180],
                 "brand": (a.get("brand") or "")[:80],
                 "tags": a.get("tags") or [],
-                "thumbnailUrl": it.get("thumbnailUrl") or it.get("thumbnail_url") or "",
+                "thumbnailUrl": it.get("thumbnailUrl") or it.get("thumbnail_url") or ""
             })
+
+        # Compose a prompt asking for JSON candidates
         prompt = (
             "You are a stylist assistant. Given WARDROBE array (id,type,summary,brand,tags,thumbnailUrl),\n"
             "USER_INPUT (moods, appearances, events, activity, preferred/excluded colors, keyBrands, etc.),\n"
@@ -284,6 +262,7 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
             "Return only valid JSON: {\"candidates\": [ {\"id\": \"..\", \"item_ids\": [..], \"score\": 0-1, \"notes\": \"one-line\", \"short_reason\": \"phrase\"}, ... ]}\n\n"
             "WARDROBE = {wardrobe}\nUSER_INPUT = {u}\nPAST_WEEK = {p}\n".format(max=max_candidates, wardrobe=json.dumps(summarized), u=json.dumps(user_inputs), p=json.dumps([p.get("id") for p in (past_week_items or [])]))
         )
+
         contents = [types.Content(role="user", parts=[types.Part.from_text(text=prompt)])]
         schema = {
             "type": "object",
@@ -306,12 +285,16 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
             "required": ["candidates"],
         }
         cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
-        resp = client.models.generate_content(model="gemini-2.5-flash", contents=contents, config=cfg)
+        resp = client.models.generate_content(
+            model="gemini-2.5-flash",  # choose an appropriate Gemini model
+            contents=contents,
+            config=cfg
+        )
         raw = resp.text or ""
-        parsed = json.loads(raw)
+        parsed = json.loads(raw) if raw else None
         id_map = {str(it.get("id")): it for it in wardrobe_items}
         out = []
-        for c in parsed.get("candidates", [])[:max_candidates]:
+        for c in (parsed.get("candidates", []) if parsed else [])[:max_candidates]:
             items = []
             for iid in c.get("item_ids", []):
                 itm = id_map.get(str(iid))
@@ -328,7 +311,7 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
                 "notes": (c.get("notes") or "")[:300],
             })
         if not out:
-            log.warning("Gemini returned no candidates; falling back.")
+            log.warning("Gemini returned no candidates; fallback to naive generator.")
             return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
         out.sort(key=lambda x: x.get("score", 0), reverse=True)
         return out[:max_candidates]
@@ -336,86 +319,26 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
         log.exception("Gemini candidate generation failed: %s", e)
         return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
 
-
-# ---------- Refinement ----------
-def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
-                                       wardrobe_items: List[Dict[str, Any]],
-                                       constraints: Dict[str, Any]) -> Dict[str, Any]:
-    require_brands = set([b.lower() for b in (constraints.get("require_brands") or []) if b])
-    reject_brands = set([b.lower() for b in (constraints.get("reject_brands") or []) if b])
-    past_ids = set([x.get("id") for x in (constraints.get("past_week_items") or []) if x.get("id")])
-    allow_rerun = bool(constraints.get("allow_rerun", False))
-
-    id_map = {str(it.get("id")): it for it in wardrobe_items}
-    refined = []
-    removed = []
-
-    for cand in candidates:
-        items = cand.get("items") or []
-        resolved = []
-        for i in items:
-            iid = str(i.get("id"))
-            full = id_map.get(iid)
-            if full:
-                resolved.append(full)
-            else:
-                resolved.append(i)
-        if require_brands:
-            if not any((_safe_item_brand(it).lower() in require_brands) for it in resolved):
-                removed.append({"id": cand.get("id"), "reason": "missing required brand"})
-                continue
-        if reject_brands:
-            if any((_safe_item_brand(it).lower() in reject_brands) for it in resolved):
-                removed.append({"id": cand.get("id"), "reason": "contains rejected brand"})
-                continue
-        if past_ids and any((it.get("id") in past_ids) for it in resolved):
-            if not allow_rerun:
-                removed.append({"id": cand.get("id"), "reason": "uses recent items"})
-                continue
-            else:
-                cand["_conflict_with_schedule"] = True
-        cand["items"] = [
-            {
-                "id": it.get("id"),
-                "label": it.get("label"),
-                "title": it.get("title"),
-                "thumbnailUrl": it.get("thumbnailUrl") if it.get("thumbnailUrl") is not None else it.get("thumbnail_url"),
-                "analysis": it.get("analysis", {}),
-                "confidence": it.get("confidence", 0.5),
-            } for it in resolved
-        ]
-        refined.append(cand)
-
-    if not refined:
-        hint = "All candidates filtered out. Consider loosening constraints or allow rerun."
-        return {"refined": [], "rerun_required": True, "rerun_hint": hint, "removed": removed}
-    refined.sort(key=lambda c: c.get("score", 0), reverse=True)
-    return {"refined": refined, "rerun_required": False, "rerun_hint": "", "removed": removed}
-
-
-# ---------- Final note (Gemini optional) ----------
 def finalize_suggestion_note_with_gemini(candidate: Dict[str, Any], user_inputs: Dict[str, Any], user_profile: Dict[str, Any]) -> str:
     if not client:
-        # basic heuristic note
+        # heuristic fallback
         moods = user_inputs.get("moods") or []
         events = user_inputs.get("events") or []
-        return f"Because you chose {', '.join(moods[:2]) or 'your mood'} for {', '.join(events[:1]) or 'your event'} — practical and stylish."
+        mood = moods[0] if moods else "your mood"
+        ev = events[0] if events else "your event"
+        return f"A curated outfit selected for {mood} at {ev} — stylish and practical."
     try:
-        prompt = (
-            "You are a concise stylist. Given CANDIDATE_ITEMS (list of short item descriptions) and USER_INPUT, "
-            "write a single short friendly sentence (<=18 words) explaining why this outfit was chosen. Return plain text.\n\n"
-        )
         candidate_items = []
         for it in candidate.get("items", []):
             desc = (it.get("analysis") or {}).get("summary") or it.get("label") or it.get("title") or ""
             brand = (it.get("analysis") or {}).get("brand") or ""
             candidate_items.append({"id": it.get("id"), "desc": desc[:160], "brand": brand[:60]})
-        contents = [
-            types.Content(role="user", parts=[types.Part.from_text(text=prompt)]),
-            types.Content(role="user", parts=[types.Part.from_text(text="CANDIDATE_ITEMS: " + json.dumps(candidate_items))]),
-            types.Content(role="user", parts=[types.Part.from_text(text="USER_INPUT: " + json.dumps(user_inputs or {}))]),
-            types.Content(role="user", parts=[types.Part.from_text(text="Return only a single short sentence.")]),
-        ]
+        prompt = (
+            "You are a concise stylist. Given CANDIDATE_ITEMS (list of short item descriptions) and USER_INPUT, "
+            "write a single short friendly sentence (<=18 words) explaining why this outfit was chosen. Return plain text.\n\n"
+            f"CANDIDATE_ITEMS: {json.dumps(candidate_items)}\nUSER_INPUT: {json.dumps(user_inputs or {})}\nReturn only a single short sentence."
+        )
+        contents = [types.Content(role="user", parts=[types.Part.from_text(text=prompt)])]
         resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents)
         text = (resp.text or "").strip()
         return text.splitlines()[0] if text else "A curated outfit chosen for your preferences."
@@ -423,69 +346,18 @@ def finalize_suggestion_note_with_gemini(candidate: Dict[str, Any], user_inputs:
         log.exception("Gemini finalize note failed: %s", e)
         moods = user_inputs.get("moods") or []
         events = user_inputs.get("events") or []
-        return f"Because you chose {', '.join(moods[:2]) or 'your mood'} for {', '.join(events[:1]) or 'your event'} — practical and stylish."
-
-
-# ---------- Firestore helpers ----------
-def get_or_create_user_summary(uid: str, fallback_from_inputs: Dict[str, Any]) -> str:
-    fs = init_firestore_if_needed()
-    gen_summary = None
-    try:
-        if not fs:
-            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
-            return gen_summary
-        doc_ref = fs.collection("users").document(uid)
-        doc = doc_ref.get()
-        if doc.exists:
-            data = doc.to_dict() or {}
-            summary = data.get("summary")
-            if summary:
-                return summary
-            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
-            try:
-                doc_ref.set({"summary": gen_summary, "updatedAt": int(time.time())}, merge=True)
-            except Exception:
-                pass
-            return gen_summary
-        else:
-            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
-            try:
-                doc_ref.set({"summary": gen_summary, "createdAt": int(time.time())})
-            except Exception:
-                pass
-            return gen_summary
-    except Exception as e:
-        log.exception("Error fetching/creating user summary: %s", e)
-        return gen_summary or _heuristic_summary_from_inputs(fallback_from_inputs)
-
-
-def fetch_recent_suggestions(uid: str, days: int = 7) -> List[Dict[str, Any]]:
-    fs = init_firestore_if_needed()
-    if not fs:
-        return []
-    try:
-        cutoff = int(time.time()) - days * 86400
-        q = fs.collection("suggestions").where("uid", "==", uid).where("createdAtTs", ">=", cutoff).limit(50)
-        docs = q.get()
-        items = []
-        for d in docs:
-            dd = d.to_dict() or {}
-            for it in dd.get("items", []) or []:
-                items.append({"id": it.get("id"), "label": it.get("label")})
-        return items
-    except Exception as e:
-        log.warning("Failed to fetch recent suggestions: %s", e)
-        return []
-
+        mood = moods[0] if moods else "your mood"
+        ev = events[0] if events else "your event"
+        return f"A curated outfit selected for {mood} at {ev} — stylish and practical."
 
+# ---------- Firestore fetching ----------
 def fetch_wardrobe_from_firestore(uid: str) -> List[Dict[str, Any]]:
     fs = init_firestore_if_needed()
     if not fs:
         return []
     try:
-        # try users/{uid}/wardrobe subcollection first
-        subcol_ref = fs.collection("users").document(uid).collection("wardrobe")
-        docs = subcol_ref.limit(200).get()
+        subcol = fs.collection("users").document(uid).collection("wardrobe")
+        docs = subcol.limit(1000).get()
         items = []
         for d in docs:
             dd = d.to_dict() or {}
@@ -501,10 +373,9 @@ def fetch_wardrobe_from_firestore(uid: str) -> List[Dict[str, Any]]:
         if items:
             return items
     except Exception as e:
-        log.warning("users/{uid}/wardrobe read failed: %s", e)
+        log.warning("users/{uid}/wardrobe subcollection read failed: %s", e)
 
     try:
-        # fallback to global collection 'wardrobe' (docs with uid field)
         q = fs.collection("wardrobe").where("uid", "==", uid).limit(500)
         docs = q.get()
         items = []
@@ -521,88 +392,101 @@ def fetch_wardrobe_from_firestore(uid: str) -> List[Dict[str, Any]]:
             })
         return items
     except Exception as e:
-        log.warning("wardrobe collection read failed: %s", e)
+        log.warning("wardrobe collection query failed: %s", e)
         return []
 
+# ---------- refinement ----------
+def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
+                                       wardrobe_items: List[Dict[str, Any]],
+                                       constraints: Dict[str, Any]) -> Dict[str, Any]:
+    require_brands = set([b.lower() for b in (constraints.get("require_brands") or []) if b])
+    reject_brands = set([b.lower() for b in (constraints.get("reject_brands") or []) if b])
+    past_ids = set([x.get("id") for x in (constraints.get("past_week_items") or []) if x.get("id")])
+    allow_rerun = bool(constraints.get("allow_rerun", False))
+
+    id_map = {str(it.get("id")): it for it in wardrobe_items}
+    refined = []
+    removed = []
 
-def _heuristic_summary_from_inputs(user_inputs: Dict[str, Any]) -> str:
-    moods = user_inputs.get("moods") or []
-    brands = user_inputs.get("keyBrands") or []
-    events = user_inputs.get("events") or []
-    parts = []
-    if moods:
-        parts.append("moods: " + ", ".join(moods[:3]))
-    if brands:
-        parts.append("likes brands: " + ", ".join(brands[:3]))
-    if events:
-        parts.append("often for: " + ", ".join(events[:2]))
-    if not parts:
-        return "A user who likes simple, practical outfits."
-    return " & ".join(parts)
+    for cand in candidates:
+        items = cand.get("items") or []
+        resolved = []
+        for i in items:
+            iid = str(i.get("id"))
+            full = id_map.get(iid)
+            if full:
+                resolved.append(full)
+            else:
+                resolved.append(i)
+        if require_brands:
+            if not any((_safe_item_brand(it).lower() in require_brands) for it in resolved):
+                removed.append({"id": cand.get("id"), "reason": "missing required brand"})
+                continue
+        if reject_brands:
+            if any((_safe_item_brand(it).lower() in reject_brands) for it in resolved):
+                removed.append({"id": cand.get("id"), "reason": "contains rejected brand"})
+                continue
+        if past_ids and any((it.get("id") in past_ids) for it in resolved):
+            if not allow_rerun:
+                removed.append({"id": cand.get("id"), "reason": "uses recent items"})
+                continue
+            else:
+                cand["_conflict_with_schedule"] = True
+        cand["items"] = [
+            {
+                "id": it.get("id"),
+                "label": it.get("label"),
+                "title": it.get("title"),
+                "thumbnailUrl": it.get("thumbnailUrl") if it.get("thumbnailUrl") is not None else it.get("thumbnail_url"),
+                "analysis": it.get("analysis", {}),
+                "confidence": it.get("confidence", 0.5),
+            } for it in resolved
+        ]
+        refined.append(cand)
 
+    if not refined:
+        hint = "All candidates filtered out. Consider loosening constraints or allow rerun."
+        return {"refined": [], "rerun_required": True, "rerun_hint": hint, "removed": removed}
+    refined.sort(key=lambda c: c.get("score", 0), reverse=True)
+    return {"refined": refined, "rerun_required": False, "rerun_hint": "", "removed": removed}
 
 # ---------- Flask app ----------
 app = Flask(__name__)
 CORS(app)
 
-
 @app.route("/suggest", methods=["POST"])
 def suggest_all():
-    """
-    Main endpoint. Accepts multipart/form-data or JSON.
-    Required: user_inputs (object)
-    Optional: wardrobe_items (array) — if absent server will try to fetch from Firestore for uid
-              audio file (multipart field 'audio') or audio_b64 (json)
-    """
     is_multipart = request.content_type and request.content_type.startswith("multipart/form-data")
     try:
         if is_multipart:
             form = request.form
             files = request.files
             uid = (form.get("uid") or form.get("user_id") or "anon").strip() or "anon"
-            user_inputs = {}
-            try:
-                ui_raw = form.get("user_inputs")
-                if ui_raw:
-                    user_inputs = json.loads(ui_raw)
-                else:
-                    user_inputs = {}
-            except Exception:
-                user_inputs = {}
-            max_c = int(form.get("max_candidates") or MAX_CANDIDATES_DEFAULT)
-            wardrobe_items = []
-            w_raw = form.get("wardrobe_items")
-            if w_raw:
-                try:
-                    wardrobe_items = json.loads(w_raw)
-                except Exception:
-                    wardrobe_items = []
+            user_inputs_raw = form.get("user_inputs")
+            user_inputs = json.loads(user_inputs_raw) if user_inputs_raw else {}
+            max_c = int(form.get("max_candidates") or 6)
+            wardrobe_items_raw = form.get("wardrobe_items")
+            wardrobe_items = json.loads(wardrobe_items_raw) if wardrobe_items_raw else []
             audio_file = files.get("audio")
             audio_b64 = None
             if audio_file:
-                try:
-                    audio_bytes = audio_file.read()
-                    import base64
-                    audio_b64 = base64.b64encode(audio_bytes).decode("ascii")
-                except Exception:
-                    audio_b64 = None
+                audio_bytes = audio_file.read()
+                import base64
+                audio_b64 = base64.b64encode(audio_bytes).decode("ascii")
         else:
             body = request.get_json(force=True)
             uid = (body.get("uid") or body.get("user_id") or "anon").strip() or "anon"
             user_inputs = body.get("user_inputs") or {}
-            max_c = int(body.get("max_candidates") or MAX_CANDIDATES_DEFAULT)
+            max_c = int(body.get("max_candidates") or 6)
             wardrobe_items = body.get("wardrobe_items") or []
             audio_b64 = body.get("audio_b64")
     except Exception as e:
         log.exception("Invalid request payload: %s", e)
         return jsonify({"error": "invalid request payload"}), 400
 
-    if not isinstance(user_inputs, dict):
-        return jsonify({"error": "user_inputs must be an object"}), 400
-
-    # Normalize wardrobe items (ensure thumbnailUrl field present)
-    normalized_items = []
+    # normalize wardrobe items -> ensure thumbnailUrl exists
     try:
+        normalized_items = []
         for it in wardrobe_items or []:
             if not isinstance(it, dict):
                 normalized_items.append(it)
@@ -615,33 +499,75 @@ def suggest_all():
     except Exception:
         pass
 
-    # If no wardrobe provided, try fetching from Firestore
+    # Try fetching from Firestore if wardrobe empty
     if not wardrobe_items:
         try:
-            wardrobe_items = fetch_wardrobe_from_firestore(uid)
+            wardrobe_items = fetch_wardrobe_from_firestore(uid) or []
             log.info("Fetched %d wardrobe items for uid=%s from Firestore", len(wardrobe_items), uid)
         except Exception as e:
-            log.warning("Failed fetching wardrobe from Firestore: %s", e)
+            log.warning("Failed to fetch wardrobe from Firestore: %s", e)
             wardrobe_items = []
 
+    if not isinstance(user_inputs, dict):
+        return jsonify({"error": "user_inputs must be an object"}), 400
     if not wardrobe_items:
         return jsonify({"error": "no wardrobe_items provided and none found in Firestore"}), 400
 
-    # Step 0: user summary / past week items
-    user_summary = get_or_create_user_summary(uid, user_inputs)
+    # build user summary (try Firestore, else heuristic)
     try:
-        past_week_items = fetch_recent_suggestions(uid, days=7) or []
-    except Exception:
-        past_week_items = []
+        fs = init_firestore_if_needed()
+        user_summary = None
+        if fs:
+            try:
+                doc_ref = fs.collection("users").document(uid)
+                doc = doc_ref.get()
+                if doc.exists:
+                    data = doc.to_dict() or {}
+                    user_summary = data.get("summary")
+            except Exception:
+                pass
+        if not user_summary:
+            moods = user_inputs.get("moods") or []
+            brands = user_inputs.get("keyBrands") or []
+            events = user_inputs.get("events") or []
+            parts = []
+            if moods:
+                parts.append("moods: " + ", ".join(moods[:3]))
+            if brands:
+                parts.append("likes brands: " + ", ".join(brands[:3]))
+            if events:
+                parts.append("often for: " + ", ".join(events[:2]))
+            user_summary = " & ".join(parts) if parts else "A user who likes practical, simple outfits."
+    except Exception as e:
+        log.exception("user summary build failed: %s", e)
+        user_summary = "A user who likes practical, simple outfits."
 
-    # Step 1: generate candidates
+    # fetch recent suggestions for penalization
+    past_week_items = []
     try:
-        candidates = generate_candidates_with_gemini(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
+        fs = init_firestore_if_needed()
+        if fs:
+            cutoff = int(time.time()) - 7 * 86400
+            q = fs.collection("suggestions").where("uid", "==", uid).where("createdAtTs", ">=", cutoff).limit(200)
+            docs = q.get()
+            for d in docs:
+                dd = d.to_dict() or {}
+                for it in dd.get("items", []) or []:
+                    past_week_items.append({"id": it.get("id"), "label": it.get("label")})
     except Exception as e:
-        log.exception("Candidate generation failed, falling back to naive: %s", e)
+        log.warning("Failed to fetch recent suggestions: %s", e)
+
+    # candidate generation
+    try:
+        if client:
+            candidates = generate_candidates_with_gemini(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
+        else:
+            candidates = naive_generate_candidates(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
+    except Exception as e:
+        log.exception("candidate generation failed: %s", e)
         candidates = naive_generate_candidates(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
 
-    # Step 2: refine candidates using constraints derived from user_inputs
+    # refine
     constraints = {
         "require_brands": user_inputs.get("keyBrands") or [],
         "reject_brands": user_inputs.get("reject_brands") or user_inputs.get("excluded_brands") or [],
@@ -650,29 +576,28 @@ def suggest_all():
     }
     refine_result = refine_candidates_with_constraints(candidates, wardrobe_items, constraints)
 
-    # If refinement removed everything and rerun allowed, do looser run
     if refine_result.get("rerun_required") and constraints.get("allow_rerun"):
-        log.info("Refine requested rerun; performing broader naive generation.")
-        try:
-            alt_candidates = naive_generate_candidates(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max(8, max_c * 2))
-            refine_result = refine_candidates_with_constraints(alt_candidates, wardrobe_items, constraints)
-        except Exception as e:
-            log.exception("Rerun generation failed: %s", e)
+        log.info("Refine requested rerun; performing deterministic rerun.")
+        alt_candidates = naive_generate_candidates(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max(8, max_c * 2))
+        refine_result = refine_candidates_with_constraints(alt_candidates, wardrobe_items, constraints)
 
     refined = refine_result.get("refined", [])
 
-    # Step 3: finalize suggestions, produce single-line notes for each (Gemini optional)
+    # finalize suggestion notes and build suggestion objects
     suggestions = []
     for cand in refined:
         try:
             cand_items = cand.get("items", []) or []
             cand_items = prioritize_top_item(cand_items)
             cand["items"] = cand_items
-            note = finalize_suggestion_note_with_gemini(cand, user_inputs, {"summary": user_summary})
+
+            note = finalize_suggestion_note_with_gemini(cand, user_inputs, {"summary": user_summary}) if client else finalize_suggestion_note_with_gemini(cand, user_inputs, {"summary": user_summary})
         except Exception as e:
-            log.warning("Failed to produce note for candidate %s: %s", cand.get("id"), e)
+            log.warning("Failed to produce final note for candidate %s: %s", cand.get("id"), e)
             note = cand.get("notes") or cand.get("reason") or "A curated outfit."
+
         thumb_urls = [it.get("thumbnailUrl") for it in cand.get("items", []) if it.get("thumbnailUrl")]
+
         suggestion = {
             "id": cand.get("id") or str(uuid.uuid4()),
             "items": cand.get("items", []),
@@ -682,7 +607,7 @@ def suggest_all():
             "score": cand.get("score"),
             "meta": {
                 "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-                "source": "single_suggest_pipeline_v2",
+                "source": "single_suggest_pipeline_gemini" if client else "single_suggest_pipeline_naive",
                 "user_inputs": user_inputs,
             },
             "uid": uid,
@@ -690,9 +615,9 @@ def suggest_all():
         }
         suggestions.append(suggestion)
 
-    # Persist suggestions to Firestore (best-effort)
+    # persist suggestions to Firestore (best-effort)
+    persisted_ids = []
     fs = init_firestore_if_needed()
-    persisted = []
     if fs and suggestions:
         try:
             col = fs.collection("suggestions")
@@ -700,42 +625,31 @@ def suggest_all():
                 try:
                     doc_id = s["id"]
                     col.document(doc_id).set(s)
-                    persisted.append(doc_id)
+                    persisted_ids.append(doc_id)
                 except Exception as se:
                     log.warning("Failed to persist suggestion %s: %s", s.get("id"), se)
         except Exception as e:
-            log.warning("Failed to persist suggestions to Firestore: %s", e)
+            log.warning("Failed to persist suggestions collection: %s", e)
 
     debug = {
         "candidates_count": len(candidates),
         "refined_count": len(refined),
-        "persisted_count": len(persisted),
-        "persisted_ids": persisted,
-        "rerun_hint": refine_result.get("rerun_hint", "")
+        "persisted": persisted_ids,
+        "rerun_hint": refine_result.get("rerun_hint", ""),
     }
 
-    # Return results (frontend expects a vertical array; we respect ordering)
     return jsonify({"ok": True, "user_summary": user_summary, "suggestions": suggestions, "debug": debug}), 200
 
-
 @app.route("/health", methods=["GET"])
 def health():
-    fs_ok = bool(init_firestore_if_needed())
-    gem_ok = bool(client)
-    return jsonify({"ok": True, "time": int(time.time()), "gemini": gem_ok, "firestore": fs_ok}), 200
-
-
-@app.route("/wardrobe/<uid>", methods=["GET"])
-def get_wardrobe(uid):
-    try:
-        items = fetch_wardrobe_from_firestore(uid)
-        return jsonify({"ok": True, "count": len(items), "items": items}), 200
-    except Exception as e:
-        log.exception("wardrobe read failed: %s", e)
-        return jsonify({"ok": False, "error": str(e)}), 500
-
+    return jsonify({
+        "ok": True,
+        "time": int(time.time()),
+        "gemini": bool(client),
+        "firestore": bool(init_firestore_if_needed())
+    }), 200
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", "7860"))
-    log.info("Starting single-suggest-server-v2 on 0.0.0.0:%s", port)
-    app.run(host="0.0.0.0", port=port, debug=True)
+    port = int(os.getenv("PORT", 7860))
+    log.info("Starting single-suggest server on 0.0.0.0:%d", port)
+    app.run(host="0.0.0.0", port=port, debug=False)