Update app.py

app.py

@@ -1,25 +1,15 @@
-# server_suggestions.py
+# server_single_suggest.py
 """
-Suggestion-focused server for outfit recommendations.
-
-Endpoints:
- - POST /suggest_candidates  -> produce candidate outfits (Step 1)
- - POST /refine_candidates   -> refine candidates with constraints (Step 2)
- - POST /finalize_suggestion -> finalize a candidate and return the suggestion (Step 3)
- 
-This server intentionally omits image detection and upload endpoints — it expects
-the client to send pre-extracted wardrobe item summaries (id, analysis, title, thumbnail_url...).
-
-Features:
- - Optional Gemini integration (GEMINI_API_KEY)
- - Optional Firestore integration (FIREBASE_ADMIN_JSON) for:
-     * reading/writing user summary at users/{uid}
-     * reading recent suggestions in collection 'suggestions' for the past week
-   All Firestore operations are wrapped with graceful failures so the service still works
-   when Firestore isn't configured.
+Single-endpoint suggestion server.
+
+Endpoint:
+ - POST /suggest  -> accepts large form (wardrobe_items optional, user_inputs required, optional audio file)
+                    runs full pipeline: fetch user summary, fetch recent history, generate candidates,
+                    refine candidates, finalize suggestions (with one-line notes), persist suggestions.
 """
 
 import os
+import io
 import json
 import logging
 import uuid
@@ -30,7 +20,7 @@ from typing import List, Dict, Any, Set, Optional
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
-# optional genai client
+# Optional Gemini client
 try:
     from google import genai
     from google.genai import types
@@ -40,7 +30,7 @@ except Exception:
     types = None
     GENAI_AVAILABLE = False
 
-# optional firebase admin (Firestore)
+# Optional Firebase Admin (Firestore)
 try:
     import firebase_admin
     from firebase_admin import credentials as fb_credentials
@@ -53,7 +43,7 @@ except Exception:
     FIREBASE_AVAILABLE = False
 
 logging.basicConfig(level=logging.INFO)
-log = logging.getLogger("suggestion-server")
+log = logging.getLogger("suggestion-single-server")
 
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
 if GEMINI_API_KEY and GENAI_AVAILABLE:
@@ -66,24 +56,19 @@ else:
     else:
         log.info("GEMINI_API_KEY not provided; using fallback heuristics.")
 
-# Firestore service account JSON in env variable (stringified JSON)
+# Firestore service account JSON (stringified JSON expected)
 FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
 
-# Firestore runtime state
 _firestore_client = None
 _firebase_app = None
 
 
 def init_firestore_if_needed():
-    """
-    Initialize firebase admin and Firestore client if FIREBASE_ADMIN_JSON is set.
-    Returns Firestore client or None on failure/unconfigured.
-    """
     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 env var set; Firestore not initialized.")
+        log.info("No FIREBASE_ADMIN_JSON set; Firestore not initialized.")
         return None
     if not FIREBASE_AVAILABLE:
         log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK not installed; skip Firestore init.")
@@ -95,7 +80,6 @@ def init_firestore_if_needed():
         return None
     try:
         cred = fb_credentials.Certificate(sa_obj)
-        # If app already exists, avoid re-initializing
         try:
             _firebase_app = firebase_admin.get_app()
         except Exception:
@@ -104,35 +88,15 @@ def init_firestore_if_needed():
         log.info("Initialized Firestore client.")
         return _firestore_client
     except Exception as e:
-        log.exception("Failed to initialize Firestore: %s", e)
+        log.exception("Failed to init Firestore: %s", e)
         return None
 
 
-# ---------- Category mapping (kept small and deterministic) ----------
+# ---------- Category mapping ----------
 CATEGORIES = [
-    "top",
-    "shirt",
-    "blouse",
-    "tshirt",
-    "sweater",
-    "jacket",
-    "coat",
-    "dress",
-    "skirt",
-    "pants",
-    "trousers",
-    "shorts",
-    "jeans",
-    "shoe",
-    "heels",
-    "sneaker",
-    "boot",
-    "sandals",
-    "bag",
-    "belt",
-    "hat",
-    "accessory",
-    "others",
+    "top", "shirt", "blouse", "tshirt", "sweater", "jacket", "coat", "dress", "skirt",
+    "pants", "trousers", "shorts", "jeans", "shoe", "heels", "sneaker", "boot", "sandals",
+    "bag", "belt", "hat", "accessory", "others",
 ]
 
 
@@ -154,8 +118,7 @@ def map_type_to_category(item_type: str) -> str:
     return "others"
 
 
-# ---------- Lightweight helpers for brands and matching ----------
-
+# ---------- Brand helpers ----------
 def _safe_item_brand(itm: Dict[str, Any]) -> str:
     analysis = itm.get("analysis") or {}
     brand = analysis.get("brand") if isinstance(analysis, dict) else None
@@ -164,26 +127,12 @@ def _safe_item_brand(itm: Dict[str, Any]) -> str:
     return str(brand).strip()
 
 
-def _item_matches_brand_constraints(itm: Dict[str, Any], require_brands: Set[str], reject_brands: Set[str]) -> bool:
-    brand = _safe_item_brand(itm).lower()
-    if require_brands and brand and brand not in require_brands:
-        return False
-    if reject_brands and brand and brand in reject_brands:
-        return False
-    return True
-
-
-# ---------- Naive candidate generator (fallback) ----------
-
+# ---------- Simple local candidate generator ----------
 def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
                               user_inputs: Dict[str, Any],
                               user_profile: Dict[str, Any],
                               past_week_items: List[Dict[str, Any]],
                               max_candidates: int = 6) -> List[Dict[str, Any]]:
-    """
-    Simple combinatorial generator that groups items by category and composes outfits.
-    Returns a list of candidate dicts: { id, items: [...], score, reason, notes }.
-    """
     grouped = {}
     for itm in wardrobe_items:
         title = (itm.get("title") or (itm.get("analysis") or {}).get("type") or itm.get("label") or "")
@@ -200,7 +149,6 @@ def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
     outer = pick("jacket", 3) + pick("coat", 2)
     shoes = pick("shoe", 4) + pick("sneaker", 3) + pick("boot", 2) + pick("heels", 2)
     dresses = grouped.get("dress", [])[:4]
-    accessories = pick("accessory", 3) + pick("bag", 2)
 
     seeds = dresses + tops
     if not seeds:
@@ -216,7 +164,7 @@ def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
                 items = [seed]
                 if b and b.get("id") != seed.get("id"):
                     items.append(b)
-                if sh and sh.get("id") not in {seed.get("id"), b.get('id') if b else None}:
+                if sh and sh.get("id") not in {seed.get("id"), b.get("id") if b else None}:
                     items.append(sh)
                 ids = tuple(sorted([str(x.get("id")) for x in items if x.get("id")]))
                 if ids in used:
@@ -225,8 +173,8 @@ def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
                 score = sum(float(x.get("confidence", 0.5)) for x in items) / max(1, len(items))
                 if any(x.get("id") in past_ids for x in items if x.get("id")):
                     score -= 0.15
-                # add small randomization
-                score = max(0, min(1, score + (0.05 * (0.5 - (hash(ids) % 100) / 100.0))))
+                # small deterministic jitter
+                score = max(0, min(1, score + (0.02 * ((hash(ids) % 100) / 100.0))))
                 candidate = {
                     "id": str(uuid.uuid4()),
                     "items": [{"id": x.get("id"), "label": x.get("label"), "title": x.get("title"), "thumbnail_url": x.get("thumbnail_url"), "analysis": x.get("analysis", {})} for x in items],
@@ -246,18 +194,16 @@ def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
     return candidates
 
 
-# ---------- Gemini-backed candidate generator (optional) ----------
-
+# ---------- Gemini-backed generator (optional) ----------
 def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
                                     user_inputs: Dict[str, Any],
                                     user_profile: Dict[str, Any],
                                     past_week_items: List[Dict[str, Any]],
                                     max_candidates: int = 6) -> List[Dict[str, Any]]:
     if not client:
-        log.info("Gemini not configured; using naive generator.")
+        log.info("Gemini disabled; using naive generator.")
         return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
 
-    # create concise wardrobe entries for the prompt
     summarized = []
     for it in wardrobe_items:
         a = it.get("analysis") or {}
@@ -271,11 +217,10 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
         })
 
     prompt = (
-        "You are a stylist assistant. Given a user's WARDROBE array (id,type,summary,brand,tags),\n"
-        "and USER_INPUT object containing moods, appearances, events, activity, preferred/excluded colors, keyBrands, etc.,\n"
-        "and a list PAST_WEEK of recently used item ids, produce up to {max} candidate outfits.\n\n"
-        "Return only valid JSON: {\"candidates\": [ {\"id\": \"..\", \"item_ids\": [..], \"score\": 0-1, \"notes\": \"one-line explanation\", \"short_reason\": \"phrase\"}, ... ]}\n\n"
-        "Prefer diverse, practical combinations and avoid reusing PAST_WEEK item ids when possible.\n\n"
+        "You are a stylist assistant. Given WARDROBE array (id,type,summary,brand,tags),\n"
+        "USER_INPUT (moods, appearances, events, activity, preferred/excluded colors, keyBrands, etc.),\n"
+        "and PAST_WEEK (recent item ids), produce up to {max} candidate outfits.\n\n"
+        "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 [])]))
     )
 
@@ -330,15 +275,10 @@ def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
         return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
 
 
-# ---------- Refinement logic (Step 2) ----------
-
+# ---------- Refinement ----------
 def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
                                        wardrobe_items: List[Dict[str, Any]],
                                        constraints: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Apply brand constraints, schedule constraints and attach item metadata.
-    Returns dict with keys: refined, rerun_required (bool), rerun_hint, removed (list).
-    """
     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")])
@@ -350,33 +290,28 @@ def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
 
     for cand in candidates:
         items = cand.get("items") or []
-        # If items are lightweight (only id), resolve them
-        resolved_items = []
+        resolved = []
         for i in items:
             iid = str(i.get("id"))
             full = id_map.get(iid)
             if full:
-                resolved_items.append(full)
+                resolved.append(full)
             else:
-                resolved_items.append(i)
-        # Check brand constraints
+                resolved.append(i)
         if require_brands:
-            if not any((_safe_item_brand(it).lower() in require_brands) for it in resolved_items):
+            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_items):
+            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
-        # Check schedule conflict
-        if past_ids and any((it.get("id") in past_ids) for it in resolved_items):
+        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
-
-        # attach metadata
         cand["items"] = [
             {
                 "id": it.get("id"),
@@ -385,20 +320,18 @@ def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
                 "thumbnail_url": it.get("thumbnail_url"),
                 "analysis": it.get("analysis", {}),
                 "confidence": it.get("confidence", 0.5),
-            }
-            for it in resolved_items
+            } for it in resolved
         ]
         refined.append(cand)
 
     if not refined:
-        hint = "All candidates filtered out. Consider loosening brand/schedule constraints or allow rerun."
+        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 generation (Step 3) ----------
-
+# ---------- Final note ----------
 def finalize_suggestion_note_with_gemini(candidate: Dict[str, Any], user_inputs: Dict[str, Any], user_profile: Dict[str, Any]) -> str:
     if not client:
         moods = ", ".join(user_inputs.get("moods", [])[:2])
@@ -427,23 +360,15 @@ def finalize_suggestion_note_with_gemini(candidate: Dict[str, Any], user_inputs:
         log.exception("Gemini finalize note failed: %s", e)
         moods = ", ".join(user_inputs.get("moods", [])[:2])
         events = ", ".join(user_inputs.get("events", [])[:1])
-        return f"Because you chose {moods or 'your mood'}, for {events or 'your event'} — practical and stylish."
-
+        return f"Because you chose {moods or 'your mood'} for {events or 'your event'} — practical and stylish."
 
-# ---------- Firestore helpers for user summary & recent suggestions (graceful) ----------
 
+# ---------- Firestore helpers ----------
 def get_or_create_user_summary(uid: str, fallback_from_inputs: Dict[str, Any]) -> str:
-    """
-    Attempts to read users/{uid} document's 'summary' field.
-    If missing or Firestore not configured, creates a heuristic summary and writes it back (if possible).
-    Returns the summary string.
-    """
     fs = init_firestore_if_needed()
     gen_summary = None
     try:
         if not fs:
-            # Firestore not available
-            log.info("Firestore not available. Building local user summary.")
             gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
             return gen_summary
         doc_ref = fs.collection("users").document(uid)
@@ -453,22 +378,20 @@ def get_or_create_user_summary(uid: str, fallback_from_inputs: Dict[str, Any]) -
             summary = data.get("summary")
             if summary:
                 return summary
-            # if doc exists but no summary, create one
             gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
             try:
                 doc_ref.set({"summary": gen_summary, "updatedAt": int(time.time())}, merge=True)
                 log.info("Wrote generated summary into users/%s", uid)
             except Exception as e:
-                log.warning("Failed to write generated summary to Firestore: %s", e)
+                log.warning("Failed to write generated summary: %s", e)
             return gen_summary
         else:
-            # doc doesn't exist -> create with heuristic summary
             gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
             try:
                 doc_ref.set({"summary": gen_summary, "createdAt": int(time.time())})
                 log.info("Created users/%s with summary", uid)
             except Exception as e:
-                log.warning("Failed to create user doc in Firestore: %s", e)
+                log.warning("Failed to create user doc: %s", e)
             return gen_summary
     except Exception as e:
         log.exception("Error fetching/creating user summary: %s", e)
@@ -476,11 +399,6 @@ def get_or_create_user_summary(uid: str, fallback_from_inputs: Dict[str, Any]) -
 
 
 def fetch_recent_suggestions(uid: str, days: int = 7) -> List[Dict[str, Any]]:
-    """
-    Attempts to fetch recent suggestions from collection 'suggestions' for uid within `days`.
-    Returns a list of item dicts used recently (flattened items).
-    If Firestore not available or query fails, returns empty list.
-    """
     fs = init_firestore_if_needed()
     if not fs:
         return []
@@ -499,6 +417,58 @@ def fetch_recent_suggestions(uid: str, days: int = 7) -> List[Dict[str, Any]]:
         return []
 
 
+def fetch_wardrobe_from_firestore(uid: str) -> List[Dict[str, Any]]:
+    """
+    Try to fetch wardrobe items for uid from Firestore.
+    Tries:
+      - users/{uid}/wardrobe subcollection
+      - collection 'wardrobe' where field 'uid' == uid (documents representing items)
+    Returns list of items or empty list.
+    """
+    fs = init_firestore_if_needed()
+    if not fs:
+        return []
+    try:
+        # try subcollection first
+        subcol = fs.collection("users").document(uid).collection("wardrobe")
+        docs = subcol.limit(200).get()
+        items = []
+        for d in docs:
+            dd = d.to_dict() or {}
+            items.append({
+                "id": dd.get("id") or d.id,
+                "label": dd.get("label") or dd.get("title") or "item",
+                "title": dd.get("title") or dd.get("label") or "",
+                "thumbnail_url": dd.get("thumbnail_url"),
+                "analysis": dd.get("analysis", {}),
+                "confidence": dd.get("confidence", 0.8),
+            })
+        if items:
+            return items
+    except Exception as e:
+        log.warning("users/{uid}/wardrobe subcollection read failed: %s", e)
+
+    try:
+        # fallback: global 'wardrobe' collection where docs have uid field
+        q = fs.collection("wardrobe").where("uid", "==", uid).limit(500)
+        docs = q.get()
+        items = []
+        for d in docs:
+            dd = d.to_dict() or {}
+            items.append({
+                "id": dd.get("id") or d.id,
+                "label": dd.get("label") or dd.get("title") or "item",
+                "title": dd.get("title") or dd.get("label") or "",
+                "thumbnail_url": dd.get("thumbnail_url"),
+                "analysis": dd.get("analysis", {}),
+                "confidence": dd.get("confidence", 0.8),
+            })
+        return items
+    except Exception as e:
+        log.warning("wardrobe collection query failed: %s", e)
+        return []
+
+
 def _heuristic_summary_from_inputs(user_inputs: Dict[str, Any]) -> str:
     moods = user_inputs.get("moods") or []
     brands = user_inputs.get("keyBrands") or []
@@ -515,37 +485,85 @@ def _heuristic_summary_from_inputs(user_inputs: Dict[str, Any]) -> str:
     return " & ".join(parts)
 
 
-# ---------- Flask app and endpoints ----------
-
+# ---------- Flask app ----------
 app = Flask(__name__)
 CORS(app)
 
 
-@app.route("/suggest_candidates", methods=["POST"])
-def suggest_candidates():
+@app.route("/suggest", methods=["POST"])
+def suggest_all():
     """
-    Step 1: Accepts wardrobe items and user inputs, returns candidate outfits.
-    Body JSON:
-      - uid (optional)
-      - wardrobe_items: array of items { id, title, analysis: {type,summary,brand,tags}, thumbnail_url (optional), confidence (optional) }
-      - user_inputs: object
-      - max_candidates: optional int
-    Response: { ok: True, candidates: [...], user_summary: "...", debug: {...} }
+    Single endpoint to run full pipeline.
+    Accepts JSON or multipart/form-data.
+
+    Expected fields (JSON or form):
+      - uid (optional) -- string
+      - wardrobe_items (optional) -- JSON array (if absent we'll try Firestore)
+      - user_inputs (required) -- JSON object with moods, appearances, events, activity, preferred/excluded colors, keyBrands, comfortAttributes, include/exclude categories, allow_rerun flag optional
+      - max_candidates (optional) -- int
+      - audio file key 'audio' (optional) in multipart/form-data OR audio_b64 in JSON (optional)
     """
+    is_multipart = request.content_type and request.content_type.startswith("multipart/form-data")
     try:
-        body = request.get_json(force=True)
-    except Exception:
-        return jsonify({"error": "invalid json"}), 400
+        if is_multipart:
+            # access form fields and files
+            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:
+                    # collect obvious form fields into user_inputs if given
+                    user_inputs = {}
+            except Exception:
+                user_inputs = {}
+            max_c = int(form.get("max_candidates") or 6)
+            wardrobe_items = []
+            w_raw = form.get("wardrobe_items")
+            if w_raw:
+                try:
+                    wardrobe_items = json.loads(w_raw)
+                except Exception:
+                    wardrobe_items = []
+            # audio file
+            audio_file = files.get("audio")
+            audio_b64 = None
+            if audio_file:
+                try:
+                    audio_bytes = audio_file.read()
+                    audio_b64 = base64.b64encode(audio_bytes).decode("ascii")
+                except Exception:
+                    audio_b64 = None
+        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 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
 
-    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-    wardrobe_items = body.get("wardrobe_items") or []
-    user_inputs = body.get("user_inputs") or {}
-    max_c = int(body.get("max_candidates") or 6)
+    # if wardrobe_items empty, attempt to fetch from Firestore for uid
+    if not wardrobe_items:
+        try:
+            wardrobe_items = fetch_wardrobe_from_firestore(uid)
+            log.info("Fetched %d wardrobe items for uid=%s from Firestore", len(wardrobe_items), uid)
+        except Exception as e:
+            log.warning("Failed to fetch wardrobe from Firestore: %s", e)
+            wardrobe_items = []
 
-    if not isinstance(wardrobe_items, list) or not isinstance(user_inputs, dict):
-        return jsonify({"error": "wardrobe_items(list) and user_inputs(object) required"}), 400
+    if not isinstance(user_inputs, dict):
+        return jsonify({"error": "user_inputs must be an object"}), 400
+    if not wardrobe_items:
+        # no wardrobe info available -> cannot suggest
+        return jsonify({"error": "no wardrobe_items provided and none found in Firestore"}), 400
 
-    # attempt to fetch user summary and recent usage from Firestore (graceful)
+    # Step 0: fetch or create user summary and recent items
     try:
         user_summary = get_or_create_user_summary(uid, user_inputs)
     except Exception as e:
@@ -558,114 +576,88 @@ def suggest_candidates():
         log.warning("fetch_recent_suggestions failed: %s", e)
         past_week_items = []
 
-    # generate candidates (Gemini or naive)
+    # Step 1: generate candidates (Gemini or naive)
     try:
         candidates = generate_candidates_with_gemini(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)
 
-    # ensure thumbnails exist as None if missing
-    for c in candidates:
-        for it in c.get("items", []):
-            it.setdefault("thumbnail_url", it.get("thumbnail_url") or None)
-
-    return jsonify({"ok": True, "candidates": candidates, "user_summary": user_summary}), 200
-
-
-@app.route("/refine_candidates", methods=["POST"])
-def refine_candidates():
-    """
-    Step 2: Apply constraints and attach item metadata.
-    Body JSON:
-      - wardrobe_items: full items list
-      - candidates: candidates returned by /suggest_candidates
-      - constraints: { require_brands: [...], reject_brands: [...], past_week_items: [...], allow_rerun: bool }
-    Response: { ok: True, refined: [...], rerun_required: bool, rerun_hint: str, removed: [...] }
-    """
-    try:
-        body = request.get_json(force=True)
-    except Exception:
-        return jsonify({"error": "invalid json"}), 400
-
-    wardrobe_items = body.get("wardrobe_items") or []
-    candidates = body.get("candidates") or []
-    constraints = body.get("constraints") or {}
-
-    if not isinstance(wardrobe_items, list) or not isinstance(candidates, list):
-        return jsonify({"error": "wardrobe_items(list) and candidates(list) required"}), 400
-
-    try:
-        result = refine_candidates_with_constraints(candidates, wardrobe_items, constraints)
-        return jsonify({"ok": True, **result}), 200
-    except Exception as e:
-        log.exception("refine_candidates failed: %s", e)
-        return jsonify({"error": "internal", "detail": str(e)}), 500
+    # Step 2: refine candidates using constraints from user_inputs
+    # create constraints object heuristically from user_inputs
+    constraints = {
+        "require_brands": user_inputs.get("keyBrands") or [],
+        "reject_brands": user_inputs.get("reject_brands") or user_inputs.get("excluded_brands") or [],
+        "past_week_items": past_week_items,
+        "allow_rerun": bool(user_inputs.get("allow_rerun", True)),
+    }
+    refine_result = refine_candidates_with_constraints(candidates, wardrobe_items, constraints)
 
+    # If refine indicates rerun_required and allow_rerun, try a looser rerun
+    if refine_result.get("rerun_required") and constraints.get("allow_rerun"):
+        log.info("Refine required rerun; performing looser candidate generation and refine again.")
+        # generate more candidates (bigger pool) with naive generator (less strict)
+        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)
 
-@app.route("/finalize_suggestion", methods=["POST"])
-def finalize_suggestion():
-    """
-    Step 3: Finalize a candidate and return a suggestion object.
-    Body JSON:
-      - uid (optional)
-      - candidate (object) OR candidate_id + candidates (list)
-      - user_inputs (optional)
-      - user_profile (optional)
-    Response:
-      { ok: True, suggestion: { id, items, thumbnail_urls, note, createdAt, meta } }
-    """
-    try:
-        body = request.get_json(force=True)
-    except Exception:
-        return jsonify({"error": "invalid json"}), 400
-
-    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-    candidate = body.get("candidate")
-    if not candidate:
-        candidate_id = body.get("candidate_id")
-        candidates = body.get("candidates") or []
-        if candidate_id and isinstance(candidates, list):
-            candidate = next((c for c in candidates if c.get("id") == candidate_id), None)
-
-    if not candidate:
-        return jsonify({"error": "candidate required (object or candidate_id + candidates)"}), 400
-
-    user_inputs = body.get("user_inputs") or {}
-    user_profile = body.get("user_profile") or {}
-
-    # attach thumbnails list
-    thumb_urls = [it.get("thumbnail_url") for it in candidate.get("items", []) if it.get("thumbnail_url")]
-
-    # create final note (Gemini or heuristic)
-    note = finalize_suggestion_note_with_gemini(candidate, user_inputs, user_profile)
-
-    suggestion = {
-        "id": candidate.get("id") or str(uuid.uuid4()),
-        "items": candidate.get("items", []),
-        "thumbnail_urls": thumb_urls,
-        "note": note,
-        "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-        "createdAtTs": int(time.time()),
-        "meta": {"source": "server_pipeline", "user_inputs": user_inputs, "user_profile": user_profile},
-        "uid": uid,
-    }
+    refined = refine_result.get("refined", [])
 
-    # Try to persist suggestion into Firestore.collection("suggestions") if configured (graceful)
+    # Step 3: finalize suggestions (note per candidate)
+    suggestions = []
+    for cand in refined:
+        try:
+            note = finalize_suggestion_note_with_gemini(cand, user_inputs, {"summary": user_summary})
+        except Exception as 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("thumbnail_url") for it in cand.get("items", []) if it.get("thumbnail_url")]
+
+        suggestion = {
+            "id": cand.get("id") or str(uuid.uuid4()),
+            "items": cand.get("items", []),
+            "thumbnail_urls": thumb_urls,
+            "note": note,
+            "score": cand.get("score"),
+            "meta": {
+                "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "source": "single_suggest_pipeline",
+                "user_inputs": user_inputs,
+            },
+            "uid": uid,
+            "createdAtTs": int(time.time()),
+        }
+        suggestions.append(suggestion)
+
+    # persist suggestions to Firestore (best-effort)
     fs = init_firestore_if_needed()
-    if fs:
+    persisted_ids = []
+    if fs and suggestions:
         try:
             col = fs.collection("suggestions")
-            doc_id = suggestion["id"]
-            col.document(doc_id).set(suggestion)
-            log.info("Persisted suggestion %s for uid=%s", doc_id, uid)
+            for s in suggestions:
+                try:
+                    doc_id = s["id"]
+                    col.document(doc_id).set(s)
+                    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 suggestion to Firestore: %s", e)
+            log.warning("Failed to persist suggestions collection: %s", e)
+
+    debug = {
+        "candidates_count": len(candidates),
+        "refined_count": len(refined),
+        "persisted": persisted_ids,
+        "rerun_hint": refine_result.get("rerun_hint", ""),
+    }
 
-    return jsonify({"ok": True, "suggestion": suggestion}), 200
+    return jsonify({"ok": True, "user_summary": user_summary, "suggestions": suggestions, "debug": debug}), 200
 
 
-# Basic health endpoint
 @app.route("/health", methods=["GET"])
 def health():
     return jsonify({"ok": True, "time": int(time.time()), "gemini": bool(client), "firestore": bool(init_firestore_if_needed())}), 200
@@ -673,5 +665,5 @@ def health():
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
-    log.info("Starting suggestion server on 0.0.0.0:%d", port)
+    log.info("Starting single-suggest server on 0.0.0.0:%d", port)
     app.run(host="0.0.0.0", port=port, debug=True)