Update app.py

app.py

@@ -1,4 +1,5 @@
-# server_gemini_seg.py
+# Update the backend to send a title that's within our array of categories for good filtration on frontend and nice classification instead of the generic top or unknown it gives most times, you can see the categories array in the frontend code, now update this backend: # server_gemini_seg.py
+
 import os
 import io
 import json
@@ -6,7 +7,6 @@ import base64
 import logging
 import uuid
 import time
-import re
 from typing import List, Dict, Any, Tuple, Optional
 
 from flask import Flask, request, jsonify
@@ -15,713 +15,591 @@ from PIL import Image, ImageOps
 import numpy as np
 import cv2
 
-# genai client
+genai client
+
 from google import genai
 from google.genai import types
 
-# Firebase Admin (in-memory JSON init)
+Firebase Admin (in-memory JSON init)
+
 try:
-    import firebase_admin
-    from firebase_admin import credentials as fb_credentials, storage as fb_storage
-    FIREBASE_ADMIN_AVAILABLE = True
+import firebase_admin
+from firebase_admin import credentials as fb_credentials, storage as fb_storage
+FIREBASE_ADMIN_AVAILABLE = True
 except Exception:
-    firebase_admin = None
-    fb_credentials = None
-    fb_storage = None
-    FIREBASE_ADMIN_AVAILABLE = False
+firebase_admin = None
+fb_credentials = None
+fb_storage = None
+FIREBASE_ADMIN_AVAILABLE = False
 
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger("wardrobe-server")
 
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
 if not GEMINI_API_KEY:
-    log.warning("GEMINI_API_KEY not set — gemini calls will fail (but fallback still works).")
+log.warning("GEMINI_API_KEY not set — gemini calls will fail (but fallback still works).")
 
 client = genai.Client(api_key=GEMINI_API_KEY) if GEMINI_API_KEY else None
 
-# Firebase config (read service account JSON from env)
+Firebase config (read service account JSON from env)
+
 FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
 FIREBASE_STORAGE_BUCKET = os.getenv("FIREBASE_STORAGE_BUCKET", "").strip()  # optional override
 
 if FIREBASE_ADMIN_JSON and not FIREBASE_ADMIN_AVAILABLE:
-    log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK is not installed. Install firebase-admin.")
+log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK is not installed. Install firebase-admin.")
 
-app = Flask(__name__)
+app = Flask(name)
 CORS(app)
 
-# ---------- Category mapping (must match frontend) ----------
-# These values intentionally match the CATEGORY_OPTIONS array on the frontend.
-CATEGORIES = [
-    "Heels",
-    "Sneakers",
-    "Loafers",
-    "Boots",
-    "Dress",
-    "Jeans",
-    "Skirt",
-    "Jacket",
-    "Blazer",
-    "T-Shirt",
-    "Coat",
-    "Shorts",
-]
+---------- Firebase init helpers ----------
 
-# simple synonyms / keyword -> category mapping (lowercase keys)
-SYNONYMS: Dict[str, str] = {
-    "heel": "Heels",
-    "heels": "Heels",
-    "sneaker": "Sneakers",
-    "sneakers": "Sneakers",
-    "trainer": "Sneakers",
-    "trainers": "Sneakers",
-    "loafer": "Loafers",
-    "loafers": "Loafers",
-    "boot": "Boots",
-    "boots": "Boots",
-    "dress": "Dress",
-    "gown": "Dress",
-    "jean": "Jeans",
-    "jeans": "Jeans",
-    "denim": "Jeans",
-    "skirt": "Skirt",
-    "jacket": "Jacket",
-    "coat": "Coat",
-    "blazer": "Blazer",
-    "t-shirt": "T-Shirt",
-    "t shirt": "T-Shirt",
-    "tee": "T-Shirt",
-    "shirt": "T-Shirt",
-    "top": "T-Shirt",
-    "short": "Shorts",
-    "shorts": "Shorts",
-    "shoe": "Sneakers",  # generic shoe -> map to Sneakers as fallback
-    "shoes": "Sneakers",
-    "sandal": "Heels",  # if ambiguous, map sandals to Heels bucket (you can adjust)
-    "sandals": "Heels",
-}
-
-def normalize_text(s: str) -> str:
-    return re.sub(r'[^a-z0-9\s\-]', ' ', s.lower()).strip()
-
-def choose_category_from_candidates(*candidates: Optional[str], tags: Optional[List[str]] = None) -> str:
-    """
-    Given a list of candidate strings (analysis.type, label, summary, etc.) and optional tags,
-    attempt to pick a category from CATEGORIES. Returns a category string guaranteed to be in CATEGORIES.
-    Falls back to "T-Shirt" if nothing matches.
-    """
-    # try tags first (explicit tag likely to indicate category)
-    if tags:
-        for t in tags:
-            if not t: 
-                continue
-            tok = normalize_text(str(t))
-            # direct synonym match
-            if tok in SYNONYMS:
-                return SYNONYMS[tok]
-            # partial substring match
-            for key, cat in SYNONYMS.items():
-                if key in tok:
-                    return cat
-            # try direct category name match
-            for cat in CATEGORIES:
-                if tok == cat.lower() or cat.lower() in tok:
-                    return cat
-
-    # iterate through candidate strings in order provided
-    for c in candidates:
-        if not c:
-            continue
-        s = normalize_text(str(c))
-        # exact category match
-        for cat in CATEGORIES:
-            if s == cat.lower() or cat.lower() in s:
-                return cat
-        # check synonyms dictionary words
-        words = s.split()
-        for w in words:
-            if w in SYNONYMS:
-                return SYNONYMS[w]
-        # check substrings (e.g., "sneaker" inside longer text)
-        for key, cat in SYNONYMS.items():
-            if key in s:
-                return cat
-
-    # If nothing found, return a safe default present in CATEGORIES
-    return "T-Shirt"
-
-# ---------- Firebase init helpers ----------
 _firebase_app = None
 
 def init_firebase_admin_if_needed():
-    global _firebase_app
-    if _firebase_app is not None:
-        return _firebase_app
-    if not FIREBASE_ADMIN_JSON:
-        log.info("No FIREBASE_ADMIN_JSON env var set; skipping Firebase admin init.")
-        return None
-    if not FIREBASE_ADMIN_AVAILABLE:
-        raise RuntimeError("firebase-admin not installed (pip install firebase-admin)")
-    try:
-        sa_obj = json.loads(FIREBASE_ADMIN_JSON)
-    except Exception as e:
-        log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
-        raise
-    bucket_name = FIREBASE_STORAGE_BUCKET or (sa_obj.get("project_id") and f"{sa_obj.get('project_id')}.appspot.com")
-    if not bucket_name:
-        raise RuntimeError("Could not determine storage bucket. Set FIREBASE_STORAGE_BUCKET or include project_id in service account JSON.")
-    try:
-        cred = fb_credentials.Certificate(sa_obj)
-        _firebase_app = firebase_admin.initialize_app(cred, {"storageBucket": bucket_name})
-        log.info("Initialized firebase admin with bucket: %s", bucket_name)
-        return _firebase_app
-    except Exception as e:
-        log.exception("Failed to initialize firebase admin: %s", e)
-        raise
+global _firebase_app
+if _firebase_app is not None:
+return _firebase_app
+if not FIREBASE_ADMIN_JSON:
+log.info("No FIREBASE_ADMIN_JSON env var set; skipping Firebase admin init.")
+return None
+if not FIREBASE_ADMIN_AVAILABLE:
+raise RuntimeError("firebase-admin not installed (pip install firebase-admin)")
+try:
+sa_obj = json.loads(FIREBASE_ADMIN_JSON)
+except Exception as e:
+log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
+raise
+bucket_name = FIREBASE_STORAGE_BUCKET or (sa_obj.get("project_id") and f"{sa_obj.get('project_id')}.appspot.com")
+if not bucket_name:
+raise RuntimeError("Could not determine storage bucket. Set FIREBASE_STORAGE_BUCKET or include project_id in service account JSON.")
+try:
+cred = fb_credentials.Certificate(sa_obj)
+_firebase_app = firebase_admin.initialize_app(cred, {"storageBucket": bucket_name})
+log.info("Initialized firebase admin with bucket: %s", bucket_name)
+return _firebase_app
+except Exception as e:
+log.exception("Failed to initialize firebase admin: %s", e)
+raise
 
 def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg", metadata: dict = None) -> str:
-    """
-    Upload base64 string to Firebase Storage at `path`.
-    Optionally attach metadata dict (custom metadata).
-    Returns a public URL when possible, otherwise returns gs://<bucket>/<path>.
-    """
-    if not FIREBASE_ADMIN_JSON:
-        raise RuntimeError("FIREBASE_ADMIN_JSON not set")
-    init_firebase_admin_if_needed()
-    if not FIREBASE_ADMIN_AVAILABLE:
-        raise RuntimeError("firebase-admin not available")
-
-    raw = base64_str
-    if raw.startswith("data:"):
-        raw = raw.split(",", 1)[1]
-    raw = raw.replace("\n", "").replace("\r", "")
-    data = base64.b64decode(raw)
-
-    try:
-        bucket = fb_storage.bucket()
-        blob = bucket.blob(path)
-        blob.upload_from_string(data, content_type=content_type)
-        # attach metadata if provided (values must be strings)
-        if metadata:
-            try:
-                blob.metadata = {k: (json.dumps(v) if not isinstance(v, str) else v) for k, v in metadata.items()}
-                blob.patch()
-            except Exception as me:
-                log.warning("Failed to patch metadata for %s: %s", path, me)
-        try:
-            blob.make_public()
-            return blob.public_url
-        except Exception as e:
-            log.warning("Could not make blob public: %s", e)
-            return f"gs://{bucket.name}/{path}"
-    except Exception as e:
-        log.exception("Firebase upload error for path %s: %s", path, e)
-        raise
-
-# ---------- Image helpers (with EXIF transpose) ----------
+"""
+Upload base64 string to Firebase Storage at path.
+Optionally attach metadata dict (custom metadata).
+Returns a public URL when possible, otherwise returns gs://<bucket>/<path>.
+"""
+if not FIREBASE_ADMIN_JSON:
+raise RuntimeError("FIREBASE_ADMIN_JSON not set")
+init_firebase_admin_if_needed()
+if not FIREBASE_ADMIN_AVAILABLE:
+raise RuntimeError("firebase-admin not available")
+
+raw = base64_str  
+if raw.startswith("data:"):  
+    raw = raw.split(",", 1)[1]  
+raw = raw.replace("\n", "").replace("\r", "")  
+data = base64.b64decode(raw)  
+
+try:  
+    bucket = fb_storage.bucket()  
+    blob = bucket.blob(path)  
+    blob.upload_from_string(data, content_type=content_type)  
+    # attach metadata if provided (values must be strings)  
+    if metadata:  
+        try:  
+            blob.metadata = {k: (json.dumps(v) if not isinstance(v, str) else v) for k, v in metadata.items()}  
+            blob.patch()  
+        except Exception as me:  
+            log.warning("Failed to patch metadata for %s: %s", path, me)  
+    try:  
+        blob.make_public()  
+        return blob.public_url  
+    except Exception as e:  
+        log.warning("Could not make blob public: %s", e)  
+        return f"gs://{bucket.name}/{path}"  
+except Exception as e:  
+    log.exception("Firebase upload error for path %s: %s", path, e)  
+    raise
+
+---------- Image helpers (with EXIF transpose) ----------
+
 def read_image_bytes(file_storage) -> Tuple[np.ndarray, int, int, bytes]:
-    """
-    Read bytes, apply EXIF orientation, return BGR numpy, width, height and raw bytes.
-    """
-    data = file_storage.read()
-    img = Image.open(io.BytesIO(data))
-    # apply EXIF orientation so photos from phones are upright
-    try:
-        img = ImageOps.exif_transpose(img)
-    except Exception:
-        pass
-    img = img.convert("RGB")
-    w, h = img.size
-    arr = np.array(img)[:, :, ::-1]  # RGB -> BGR for OpenCV
-    return arr, w, h, data
+"""
+Read bytes, apply EXIF orientation, return BGR numpy, width, height and raw bytes.
+"""
+data = file_storage.read()
+img = Image.open(io.BytesIO(data))
+# apply EXIF orientation so photos from phones are upright
+try:
+img = ImageOps.exif_transpose(img)
+except Exception:
+pass
+img = img.convert("RGB")
+w, h = img.size
+arr = np.array(img)[:, :, ::-1]  # RGB -> BGR for OpenCV
+return arr, w, h, data
 
 def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=512) -> str:
-    h_img, w_img = bgr_img.shape[:2]
-    x = max(0, int(x)); y = max(0, int(y))
-    x2 = min(w_img, int(x + w)); y2 = min(h_img, int(y + h))
-    crop = bgr_img[y:y2, x:x2]
-    if crop.size == 0:
-        return ""
-    max_dim = max(crop.shape[0], crop.shape[1])
-    if max_dim > max_side:
-        scale = max_side / max_dim
-        crop = cv2.resize(crop, (int(crop.shape[1] * scale), int(crop.shape[0] * scale)), interpolation=cv2.INTER_AREA)
-    _, jpeg = cv2.imencode(".jpg", crop, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
-    return base64.b64encode(jpeg.tobytes()).decode("ascii")
+h_img, w_img = bgr_img.shape[:2]
+x = max(0, int(x)); y = max(0, int(y))
+x2 = min(w_img, int(x + w)); y2 = min(h_img, int(y + h))
+crop = bgr_img[y:y2, x:x2]
+if crop.size == 0:
+return ""
+max_dim = max(crop.shape[0], crop.shape[1])
+if max_dim > max_side:
+scale = max_side / max_dim
+crop = cv2.resize(crop, (int(crop.shape[1] * scale), int(crop.shape[0] * scale)), interpolation=cv2.INTER_AREA)
+_, jpeg = cv2.imencode(".jpg", crop, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
+return base64.b64encode(jpeg.tobytes()).decode("ascii")
 
 def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
-    gray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
-    blur = cv2.GaussianBlur(gray, (7,7), 0)
-    thresh = cv2.adaptiveThreshold(blur,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,15,6)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9,9))
-    closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
-    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    h_img, w_img = bgr_img.shape[:2]
-    min_area = (w_img*h_img) * 0.005
-    items = []
-    for cnt in sorted(contours, key=cv2.contourArea, reverse=True):
-        if len(items) >= max_items:
-            break
-        area = cv2.contourArea(cnt)
-        if area < min_area:
-            continue
-        x,y,w,h = cv2.boundingRect(cnt)
-        pad_x, pad_y = int(w*0.07), int(h*0.07)
-        x = max(0, x - pad_x); y = max(0, y - pad_y)
-        w = min(w_img - x, w + pad_x*2); h = min(h_img - y, h + pad_y*2)
-        b64 = crop_and_b64(bgr_img, x, y, w, h)
-        if not b64:
-            continue
-        items.append({
-            "id": str(uuid.uuid4()),
-            "label": "unknown",
-            "confidence": min(0.95, max(0.25, area/(w_img*h_img))),
-            "bbox": {"x": x, "y": y, "w": w, "h": h},
-            "thumbnail_b64": b64,
-            "source": "fallback"
-        })
-    if not items:
-        h_half, w_half = h_img//2, w_img//2
-        rects = [
-            (0,0,w_half,h_half), (w_half,0,w_half,h_half),
-            (0,h_half,w_half,h_half), (w_half,h_half,w_half,h_half)
-        ]
-        for r in rects:
-            b64 = crop_and_b64(bgr_img, r[0], r[1], r[2], r[3])
-            if b64:
-                items.append({
-                    "id": str(uuid.uuid4()),
-                    "label": "unknown",
-                    "confidence": 0.3,
-                    "bbox": {"x": r[0], "y": r[1], "w": r[2], "h": r[3]},
-                    "thumbnail_b64": b64,
-                    "source": "fallback-grid"
-                })
-    return items
-
-# ---------- AI analysis helper ----------
+gray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
+blur = cv2.GaussianBlur(gray, (7,7), 0)
+thresh = cv2.adaptiveThreshold(blur,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,15,6)
+kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9,9))
+closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+h_img, w_img = bgr_img.shape[:2]
+min_area = (w_imgh_img) * 0.005
+items = []
+for cnt in sorted(contours, key=cv2.contourArea, reverse=True):
+if len(items) >= max_items:
+break
+area = cv2.contourArea(cnt)
+if area < min_area:
+continue
+x,y,w,h = cv2.boundingRect(cnt)
+pad_x, pad_y = int(w0.07), int(h0.07)
+x = max(0, x - pad_x); y = max(0, y - pad_y)
+w = min(w_img - x, w + pad_x2); h = min(h_img - y, h + pad_y2)
+b64 = crop_and_b64(bgr_img, x, y, w, h)
+if not b64:
+continue
+items.append({
+"id": str(uuid.uuid4()),
+"label": "unknown",
+"confidence": min(0.95, max(0.25, area/(w_imgh_img))),
+"bbox": {"x": x, "y": y, "w": w, "h": h},
+"thumbnail_b64": b64,
+"source": "fallback"
+})
+if not items:
+h_half, w_half = h_img//2, w_img//2
+rects = [
+(0,0,w_half,h_half), (w_half,0,w_half,h_half),
+(0,h_half,w_half,h_half), (w_half,h_half,w_half,h_half)
+]
+for r in rects:
+b64 = crop_and_b64(bgr_img, r[0], r[1], r[2], r[3])
+if b64:
+items.append({
+"id": str(uuid.uuid4()),
+"label": "unknown",
+"confidence": 0.3,
+"bbox": {"x": r[0], "y": r[1], "w": r[2], "h": r[3]},
+"thumbnail_b64": b64,
+"source": "fallback-grid"
+})
+return items
+
+---------- AI analysis helper ----------
+
 def analyze_crop_with_gemini(jpeg_b64: str) -> Dict[str, Any]:
-    """
-    Run Gemini on the cropped image bytes to extract:
-      type (one-word category like 'shoe', 'jacket', 'dress'),
-      summary (single-line description),
-      brand (string or empty),
-      tags (array of short descriptors)
-    Returns dict, falls back to empty/defaults on error or missing key.
-    """
-    if not client:
-        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
-    try:
-        # prepare prompt
-        prompt = (
-            "You are an assistant that identifies clothing item characteristics from an image. "
-            "Return only a JSON object with keys: type (single word like 'shoe','top','jacket'), "
-            "summary (a single short sentence, one line), brand (brand name if visible else empty string), "
-            "tags (an array of short single-word tags describing visible attributes, e.g. ['striped','leather','white']). "
-            "Keep values short and concise."
-        )
-
-        contents = [
-            types.Content(role="user", parts=[types.Part.from_text(text=prompt)])
-        ]
-
-        # attach the image bytes
-        image_bytes = base64.b64decode(jpeg_b64)
-        contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")]))
-
-        schema = {
-            "type": "object",
-            "properties": {
-                "type": {"type": "string"},
-                "summary": {"type": "string"},
-                "brand": {"type": "string"},
-                "tags": {"type": "array", "items": {"type": "string"}}
-            },
-            "required": ["type", "summary"]
-        }
-        cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
-
-        # call model (use the same model family you used before)
-        resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)
-        text = resp.text or ""
-        parsed = {}
-        try:
-            parsed = json.loads(text)
-            # coerce expected shapes
-            parsed["type"] = str(parsed.get("type", "")).strip()
-            parsed["summary"] = str(parsed.get("summary", "")).strip()
-            parsed["brand"] = str(parsed.get("brand", "")).strip()
-            tags = parsed.get("tags", [])
-            if not isinstance(tags, list):
-                tags = []
-            parsed["tags"] = [str(t).strip() for t in tags if str(t).strip()]
-        except Exception as e:
-            log.warning("Failed parsing Gemini analysis JSON: %s — raw: %s", e, (text[:300] if text else ""))
-            parsed = {"type": "unknown", "summary": "", "brand": "", "tags": []}
-        return {
-            "type": parsed.get("type", "unknown") or "unknown",
-            "summary": parsed.get("summary", "") or "",
-            "brand": parsed.get("brand", "") or "",
-            "tags": parsed.get("tags", []) or []
-        }
-    except Exception as e:
-        log.exception("analyze_crop_with_gemini failure: %s", e)
-        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
-
-# ---------- Main / processing ----------
+"""
+Run Gemini on the cropped image bytes to extract:
+type (one-word category like 'shoe', 'jacket', 'dress'),
+summary (single-line description),
+brand (string or empty),
+tags (array of short descriptors)
+Returns dict, falls back to empty/defaults on error or missing key.
+"""
+if not client:
+return {"type": "unknown", "summary": "", "brand": "", "tags": []}
+try:
+# prepare prompt
+prompt = (
+"You are an assistant that identifies clothing item characteristics from an image. "
+"Return only a JSON object with keys: type (single word like 'shoe','top','jacket'), "
+"summary (a single short sentence, one line), brand (brand name if visible else empty string), "
+"tags (an array of short single-word tags describing visible attributes, e.g. ['striped','leather','white']). "
+"Keep values short and concise."
+)
+
+contents = [  
+        types.Content(role="user", parts=[types.Part.from_text(text=prompt)])  
+    ]  
+
+    # attach the image bytes  
+    image_bytes = base64.b64decode(jpeg_b64)  
+    contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")]))  
+
+    schema = {  
+        "type": "object",  
+        "properties": {  
+            "type": {"type": "string"},  
+            "summary": {"type": "string"},  
+            "brand": {"type": "string"},  
+            "tags": {"type": "array", "items": {"type": "string"}}  
+        },  
+        "required": ["type", "summary"]  
+    }  
+    cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)  
+
+    # call model (use the same model family you used before)  
+    resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)  
+    text = resp.text or ""  
+    parsed = {}  
+    try:  
+        parsed = json.loads(text)  
+        # coerce expected shapes  
+        parsed["type"] = str(parsed.get("type", "")).strip()  
+        parsed["summary"] = str(parsed.get("summary", "")).strip()  
+        parsed["brand"] = str(parsed.get("brand", "")).strip()  
+        tags = parsed.get("tags", [])  
+        if not isinstance(tags, list):  
+            tags = []  
+        parsed["tags"] = [str(t).strip() for t in tags if str(t).strip()]  
+    except Exception as e:  
+        log.warning("Failed parsing Gemini analysis JSON: %s — raw: %s", e, (text[:300] if text else ""))  
+        parsed = {"type": "unknown", "summary": "", "brand": "", "tags": []}  
+    return {  
+        "type": parsed.get("type", "unknown") or "unknown",  
+        "summary": parsed.get("summary", "") or "",  
+        "brand": parsed.get("brand", "") or "",  
+        "tags": parsed.get("tags", []) or []  
+    }  
+except Exception as e:  
+    log.exception("analyze_crop_with_gemini failure: %s", e)  
+    return {"type": "unknown", "summary": "", "brand": "", "tags": []}
+
+---------- Main / processing ----------
+
 @app.route("/process", methods=["POST"])
 def process_image():
-    if "photo" not in request.files:
-        return jsonify({"error": "missing photo"}), 400
-    file = request.files["photo"]
-
-    uid = (request.form.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-
-    try:
-        bgr_img, img_w, img_h, raw_bytes = read_image_bytes(file)
-    except Exception as e:
-        log.error("invalid image: %s", e)
-        return jsonify({"error": "invalid image"}), 400
-
-    session_id = str(uuid.uuid4())
-
-    # Detection prompt (same as before)
-    user_prompt = (
-        "You are an assistant that extracts clothing detections from a single image. "
-        "Return a JSON object with a single key 'items' which is an array. Each item must have: "
-        "label (string, short like 'top','skirt','sneakers'), "
-        "bbox with normalized coordinates between 0 and 1: {x, y, w, h} where x,y are top-left relative to width/height, "
-        "confidence (0-1). Example output: {\"items\":[{\"label\":\"top\",\"bbox\":{\"x\":0.1,\"y\":0.2,\"w\":0.3,\"h\":0.4},\"confidence\":0.95}]} "
-        "Output ONLY valid JSON. If you cannot detect any clothing confidently, return {\"items\":[]}."
-    )
-
-    try:
-        contents = [
-            types.Content(role="user", parts=[types.Part.from_text(text=user_prompt)])
-        ]
-        contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=raw_bytes, mime_type="image/jpeg")]))
-
-        schema = {
-            "type": "object",
-            "properties": {
-                "items": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "label": {"type": "string"},
-                            "bbox": {
-                                "type": "object",
-                                "properties": {
-                                    "x": {"type": "number"},
-                                    "y": {"type": "number"},
-                                    "w": {"type": "number"},
-                                    "h": {"type": "number"}
-                                },
-                                "required": ["x","y","w","h"]
-                            },
-                            "confidence": {"type": "number"}
-                        },
-                        "required": ["label","bbox","confidence"]
-                    }
-                }
-            },
-            "required": ["items"]
-        }
-
-        cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
-
-        log.info("Calling Gemini model for detection (gemini-2.5-flash-lite)...")
-        model_resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg) if client else None
-        raw_text = (model_resp.text or "") if model_resp else ""
-        log.info("Gemini raw response length: %d", len(raw_text))
-
-        parsed = None
-        try:
-            parsed = json.loads(raw_text) if raw_text else None
-        except Exception as e:
-            log.warning("Could not parse Gemini JSON: %s", e)
-            parsed = None
-
-        items_out: List[Dict[str, Any]] = []
-        if parsed and isinstance(parsed.get("items"), list) and len(parsed["items"])>0:
-            for it in parsed["items"]:
-                try:
-                    label = str(it.get("label","unknown"))[:48]
-                    bbox = it.get("bbox",{})
-                    nx = float(bbox.get("x",0))
-                    ny = float(bbox.get("y",0))
-                    nw = float(bbox.get("w",0))
-                    nh = float(bbox.get("h",0))
-                    nx = max(0.0, min(1.0, nx)); ny = max(0.0,min(1.0,ny))
-                    nw = max(0.0, min(1.0, nw)); nh = max(0.0, min(1.0, nh))
-                    px = int(nx * img_w); py = int(ny * img_h)
-                    pw = int(nw * img_w); ph = int(nh * img_h)
-                    if pw <= 8 or ph <= 8:
-                        continue
-                    b64 = crop_and_b64(bgr_img, px, py, pw, ph)
-                    if not b64:
-                        continue
-                    items_out.append({
-                        "id": str(uuid.uuid4()),
-                        "label": label,
-                        "confidence": float(it.get("confidence", 0.5)),
-                        "bbox": {"x": px, "y": py, "w": pw, "h": ph},
-                        "thumbnail_b64": b64,
-                        "source": "gemini"
-                    })
-                except Exception as e:
-                    log.warning("skipping item due to error: %s", e)
-        else:
-            log.info("Gemini returned no items or parse failed — using fallback contour crops.")
-            items_out = fallback_contour_crops(bgr_img, max_items=8)
-
-        # Perform AI analysis per crop (if possible) and auto-upload to firebase with metadata (tmp + session)
-        if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:
-            try:
-                init_firebase_admin_if_needed()
-                bucket = fb_storage.bucket()
-            except Exception as e:
-                log.exception("Firebase admin init for upload failed: %s", e)
-                bucket = None
-
-            safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-            for itm in items_out:
-                b64 = itm.get("thumbnail_b64")
-                if not b64:
-                    continue
-                # analyze
-                try:
-                    analysis = analyze_crop_with_gemini(b64) if client else {"type":"unknown","summary":"","brand":"","tags":[]}
-                except Exception as ae:
-                    log.warning("analysis failed: %s", ae)
-                    analysis = {"type":"unknown","summary":"","brand":"","tags":[]}
-
-                itm["analysis"] = analysis
-
-                # choose a frontend-category-compatible title
-                # prefer analysis.type, then label, then tags, then summary
-                title = choose_category_from_candidates(
-                    analysis.get("type", ""),
-                    itm.get("label", ""),
-                    ' '.join(analysis.get("tags", [])),
-                    tags=analysis.get("tags", [])
-                )
-                itm["title"] = title
-
-                item_id = itm.get("id") or str(uuid.uuid4())
-                path = f"detected/{safe_uid}/{item_id}.jpg"
-                try:
-                    metadata = {
-                        "tmp": "true",
-                        "session_id": session_id,
-                        "uploaded_by": safe_uid,
-                        "uploaded_at": str(int(time.time())),
-                        # store AI fields as JSON strings for later inspection
-                        "ai_type": analysis.get("type",""),
-                        "ai_brand": analysis.get("brand",""),
-                        "ai_summary": analysis.get("summary",""),
-                        "ai_tags": json.dumps(analysis.get("tags", [])),
-                        "title": title,
-                    }
-                    url = upload_b64_to_firebase(b64, path, content_type="image/jpeg", metadata=metadata)
-                    itm["thumbnail_url"] = url
-                    itm["thumbnail_path"] = path
-                    itm.pop("thumbnail_b64", None)
-                    itm["_session_id"] = session_id
-                    log.debug("Auto-uploaded thumbnail for %s -> %s (session=%s) title=%s", item_id, url, session_id, title)
-                except Exception as up_e:
-                    log.warning("Auto-upload failed for %s: %s", item_id, up_e)
-                    # keep thumbnail_b64 and analysis for client fallback
-        else:
-            if not FIREBASE_ADMIN_JSON:
-                log.info("FIREBASE_ADMIN_JSON not set; skipping server-side thumbnail upload.")
-            else:
-                log.info("Firebase admin SDK not available; skipping server-side thumbnail upload.")
-            # For non-upload path, still add a title derived from label/unknown so frontend has it
-            for itm in items_out:
-                if "title" not in itm:
-                    analysis = itm.get("analysis") or {"type":"unknown","tags":[]}
-                    title = choose_category_from_candidates(analysis.get("type",""), itm.get("label",""), tags=analysis.get("tags", []))
-                    itm["title"] = title
-
-        return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"raw_model_text": (raw_text or "")[:1600]}}), 200
-
-    except Exception as ex:
-        log.exception("Processing error: %s", ex)
-        try:
-            items_out = fallback_contour_crops(bgr_img, max_items=8)
-            # give fallback items a default title so frontend can filter
-            for itm in items_out:
-                if "title" not in itm:
-                    itm["title"] = choose_category_from_candidates(itm.get("label","unknown"))
-            return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"error": str(ex)}}), 200
-        except Exception as e2:
-            log.exception("Fallback also failed: %s", e2)
-            return jsonify({"error": "internal failure", "detail": str(e2)}), 500
-
-# ---------- Finalize endpoint: keep selected and delete only session's temp files ----------
+if "photo" not in request.files:
+return jsonify({"error": "missing photo"}), 400
+file = request.files["photo"]
+
+uid = (request.form.get("uid") or request.args.get("uid") or "anon").strip() or "anon"  
+
+try:  
+    bgr_img, img_w, img_h, raw_bytes = read_image_bytes(file)  
+except Exception as e:  
+    log.error("invalid image: %s", e)  
+    return jsonify({"error": "invalid image"}), 400  
+
+session_id = str(uuid.uuid4())  
+
+# Detection prompt (same as before)  
+user_prompt = (  
+    "You are an assistant that extracts clothing detections from a single image. "  
+    "Return a JSON object with a single key 'items' which is an array. Each item must have: "  
+    "label (string, short like 'top','skirt','sneakers'), "  
+    "bbox with normalized coordinates between 0 and 1: {x, y, w, h} where x,y are top-left relative to width/height, "  
+    "confidence (0-1). Example output: {\"items\":[{\"label\":\"top\",\"bbox\":{\"x\":0.1,\"y\":0.2,\"w\":0.3,\"h\":0.4},\"confidence\":0.95}]} "  
+    "Output ONLY valid JSON. If you cannot detect any clothing confidently, return {\"items\":[]}."  
+)  
+
+try:  
+    contents = [  
+        types.Content(role="user", parts=[types.Part.from_text(text=user_prompt)])  
+    ]  
+    contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=raw_bytes, mime_type="image/jpeg")]))  
+
+    schema = {  
+        "type": "object",  
+        "properties": {  
+            "items": {  
+                "type": "array",  
+                "items": {  
+                    "type": "object",  
+                    "properties": {  
+                        "label": {"type": "string"},  
+                        "bbox": {  
+                            "type": "object",  
+                            "properties": {  
+                                "x": {"type": "number"},  
+                                "y": {"type": "number"},  
+                                "w": {"type": "number"},  
+                                "h": {"type": "number"}  
+                            },  
+                            "required": ["x","y","w","h"]  
+                        },  
+                        "confidence": {"type": "number"}  
+                    },  
+                    "required": ["label","bbox","confidence"]  
+                }  
+            }  
+        },  
+        "required": ["items"]  
+    }  
+
+    cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)  
+
+    log.info("Calling Gemini model for detection (gemini-2.5-flash-lite)...")  
+    model_resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg) if client else None  
+    raw_text = (model_resp.text or "") if model_resp else ""  
+    log.info("Gemini raw response length: %d", len(raw_text))  
+
+    parsed = None  
+    try:  
+        parsed = json.loads(raw_text) if raw_text else None  
+    except Exception as e:  
+        log.warning("Could not parse Gemini JSON: %s", e)  
+        parsed = None  
+
+    items_out: List[Dict[str, Any]] = []  
+    if parsed and isinstance(parsed.get("items"), list) and len(parsed["items"])>0:  
+        for it in parsed["items"]:  
+            try:  
+                label = str(it.get("label","unknown"))[:48]  
+                bbox = it.get("bbox",{})  
+                nx = float(bbox.get("x",0))  
+                ny = float(bbox.get("y",0))  
+                nw = float(bbox.get("w",0))  
+                nh = float(bbox.get("h",0))  
+                nx = max(0.0, min(1.0, nx)); ny = max(0.0,min(1.0,ny))  
+                nw = max(0.0, min(1.0, nw)); nh = max(0.0, min(1.0, nh))  
+                px = int(nx * img_w); py = int(ny * img_h)  
+                pw = int(nw * img_w); ph = int(nh * img_h)  
+                if pw <= 8 or ph <= 8:  
+                    continue  
+                b64 = crop_and_b64(bgr_img, px, py, pw, ph)  
+                if not b64:  
+                    continue  
+                items_out.append({  
+                    "id": str(uuid.uuid4()),  
+                    "label": label,  
+                    "confidence": float(it.get("confidence", 0.5)),  
+                    "bbox": {"x": px, "y": py, "w": pw, "h": ph},  
+                    "thumbnail_b64": b64,  
+                    "source": "gemini"  
+                })  
+            except Exception as e:  
+                log.warning("skipping item due to error: %s", e)  
+    else:  
+        log.info("Gemini returned no items or parse failed — using fallback contour crops.")  
+        items_out = fallback_contour_crops(bgr_img, max_items=8)  
+
+    # Perform AI analysis per crop (if possible) and auto-upload to firebase with metadata (tmp + session)  
+    if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:  
+        try:  
+            init_firebase_admin_if_needed()  
+            bucket = fb_storage.bucket()  
+        except Exception as e:  
+            log.exception("Firebase admin init for upload failed: %s", e)  
+            bucket = None  
+
+        safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"  
+        for itm in items_out:  
+            b64 = itm.get("thumbnail_b64")  
+            if not b64:  
+                continue  
+            # analyze  
+            try:  
+                analysis = analyze_crop_with_gemini(b64) if client else {"type":"unknown","summary":"","brand":"","tags":[]}  
+            except Exception as ae:  
+                log.warning("analysis failed: %s", ae)  
+                analysis = {"type":"unknown","summary":"","brand":"","tags":[]}  
+
+            itm["analysis"] = analysis  
+
+            item_id = itm.get("id") or str(uuid.uuid4())  
+            path = f"detected/{safe_uid}/{item_id}.jpg"  
+            try:  
+                metadata = {  
+                    "tmp": "true",  
+                    "session_id": session_id,  
+                    "uploaded_by": safe_uid,  
+                    "uploaded_at": str(int(time.time())),  
+                    # store AI fields as JSON strings for later inspection  
+                    "ai_type": analysis.get("type",""),  
+                    "ai_brand": analysis.get("brand",""),  
+                    "ai_summary": analysis.get("summary",""),  
+                    "ai_tags": json.dumps(analysis.get("tags", [])),  
+                }  
+                url = upload_b64_to_firebase(b64, path, content_type="image/jpeg", metadata=metadata)  
+                itm["thumbnail_url"] = url  
+                itm["thumbnail_path"] = path  
+                itm.pop("thumbnail_b64", None)  
+                itm["_session_id"] = session_id  
+                log.debug("Auto-uploaded thumbnail for %s -> %s (session=%s)", item_id, url, session_id)  
+            except Exception as up_e:  
+                log.warning("Auto-upload failed for %s: %s", item_id, up_e)  
+                # keep thumbnail_b64 and analysis for client fallback  
+    else:  
+        if not FIREBASE_ADMIN_JSON:  
+            log.info("FIREBASE_ADMIN_JSON not set; skipping server-side thumbnail upload.")  
+        else:  
+            log.info("Firebase admin SDK not available; skipping server-side thumbnail upload.")  
+
+    return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"raw_model_text": (raw_text or "")[:1600]}}), 200  
+
+except Exception as ex:  
+    log.exception("Processing error: %s", ex)  
+    try:  
+        items_out = fallback_contour_crops(bgr_img, max_items=8)  
+        return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"error": str(ex)}}), 200  
+    except Exception as e2:  
+        log.exception("Fallback also failed: %s", e2)  
+        return jsonify({"error": "internal failure", "detail": str(e2)}), 500
+
+---------- Finalize endpoint: keep selected and delete only session's temp files ----------
+
 @app.route("/finalize_detections", methods=["POST"])
 def finalize_detections():
-    """
-    Body JSON:
-    { "uid": "user123", "keep_ids": ["id1","id2",...], "session_id": "<session id from /process>" }
-
-    Server will delete only detected/<uid>/* files whose:
-      - metadata.tmp == "true"
-      - metadata.session_id == session_id
-      - item_id NOT in keep_ids
-
-    Returns:
-      { ok: True, kept: [...], deleted: [...], errors: [...] }
-    """
-    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"
-    keep_ids = set(body.get("keep_ids") or [])
-    session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()
-
-    if not session_id:
-        return jsonify({"error": "session_id required for finalize to avoid unsafe deletes"}), 400
-
-    if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:
-        return jsonify({"error": "firebase admin not configured"}), 500
-
-    try:
-        init_firebase_admin_if_needed()
-        bucket = fb_storage.bucket()
-    except Exception as e:
-        log.exception("Firebase init error in finalize: %s", e)
-        return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500
-
-    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-    prefix = f"detected/{safe_uid}/"
-
-    kept = []
-    deleted = []
-    errors = []
-
-    try:
-        blobs = list(bucket.list_blobs(prefix=prefix))
-        for blob in blobs:
-            try:
-                name = blob.name
-                fname = name.split("/")[-1]
-                if "." not in fname:
-                    continue
-                item_id = fname.rsplit(".", 1)[0]
-
-                md = blob.metadata or {}
-                # only consider temporary files matching this session id
-                if str(md.get("session_id", "")) != session_id or str(md.get("tmp", "")).lower() not in ("true", "1", "yes"):
-                    continue
-
-                if item_id in keep_ids:
-                    # ensure public URL available if possible
-                    try:
-                        blob.make_public()
-                        url = blob.public_url
-                    except Exception:
-                        url = f"gs://{bucket.name}/{name}"
-
-                    # extract AI metadata (if present)
-                    ai_type = md.get("ai_type") or ""
-                    ai_brand = md.get("ai_brand") or ""
-                    ai_summary = md.get("ai_summary") or ""
-                    ai_tags_raw = md.get("ai_tags") or "[]"
-                    title_meta = md.get("title") or ""
-                    try:
-                        ai_tags = json.loads(ai_tags_raw) if isinstance(ai_tags_raw, str) else ai_tags_raw
-                    except Exception:
-                        ai_tags = []
-                    # derive title: prefer stored metadata title, then ai_type/tags/summary
-                    title = None
-                    if title_meta:
-                        try:
-                            title = json.loads(title_meta) if (title_meta.startswith('[') or title_meta.startswith('{')) else str(title_meta)
-                        except Exception:
-                            title = str(title_meta)
-                    if not title:
-                        title = choose_category_from_candidates(ai_type, ai_summary, tags=ai_tags)
-                    kept.append({
-                        "id": item_id,
-                        "thumbnail_url": url,
-                        "thumbnail_path": name,
-                        "analysis": {
-                          "type": ai_type,
-                          "brand": ai_brand,
-                          "summary": ai_summary,
-                          "tags": ai_tags
-                        },
-                        "title": title
-                    })
-                else:
-                    try:
-                        blob.delete()
-                        deleted.append(item_id)
-                    except Exception as de:
-                        errors.append({"id": item_id, "error": str(de)})
-            except Exception as e:
-                errors.append({"blob": getattr(blob, "name", None), "error": str(e)})
-        return jsonify({"ok": True, "kept": kept, "deleted": deleted, "errors": errors}), 200
-    except Exception as e:
-        log.exception("finalize_detections error: %s", e)
-        return jsonify({"error": "internal", "detail": str(e)}), 500
-
-# ---------- Clear session: delete all temporary files for a session ----------
+"""
+Body JSON:
+{ "uid": "user123", "keep_ids": ["id1","id2",...], "session_id": "<session id from /process>" }
+
+Server will delete only detected/<uid>/* files whose:  
+  - metadata.tmp == "true"  
+  - metadata.session_id == session_id  
+  - item_id NOT in keep_ids  
+
+Returns:  
+  { ok: True, kept: [...], deleted: [...], errors: [...] }  
+"""  
+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"  
+keep_ids = set(body.get("keep_ids") or [])  
+session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()  
+
+if not session_id:  
+    return jsonify({"error": "session_id required for finalize to avoid unsafe deletes"}), 400  
+
+if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:  
+    return jsonify({"error": "firebase admin not configured"}), 500  
+
+try:  
+    init_firebase_admin_if_needed()  
+    bucket = fb_storage.bucket()  
+except Exception as e:  
+    log.exception("Firebase init error in finalize: %s", e)  
+    return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500  
+
+safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"  
+prefix = f"detected/{safe_uid}/"  
+
+kept = []  
+deleted = []  
+errors = []  
+
+try:  
+    blobs = list(bucket.list_blobs(prefix=prefix))  
+    for blob in blobs:  
+        try:  
+            name = blob.name  
+            fname = name.split("/")[-1]  
+            if "." not in fname:  
+                continue  
+            item_id = fname.rsplit(".", 1)[0]  
+
+            md = blob.metadata or {}  
+            # only consider temporary files matching this session id  
+            if str(md.get("session_id", "")) != session_id or str(md.get("tmp", "")).lower() not in ("true", "1", "yes"):  
+                continue  
+
+            if item_id in keep_ids:  
+                # ensure public URL available if possible  
+                try:  
+                    blob.make_public()  
+                    url = blob.public_url  
+                except Exception:  
+                    url = f"gs://{bucket.name}/{name}"  
+
+                # extract AI metadata (if present)  
+                ai_type = md.get("ai_type") or ""  
+                ai_brand = md.get("ai_brand") or ""  
+                ai_summary = md.get("ai_summary") or ""  
+                ai_tags_raw = md.get("ai_tags") or "[]"  
+                try:  
+                    ai_tags = json.loads(ai_tags_raw) if isinstance(ai_tags_raw, str) else ai_tags_raw  
+                except Exception:  
+                    ai_tags = []  
+                kept.append({  
+                    "id": item_id,  
+                    "thumbnail_url": url,  
+                    "thumbnail_path": name,  
+                    "analysis": {  
+                      "type": ai_type,  
+                      "brand": ai_brand,  
+                      "summary": ai_summary,  
+                      "tags": ai_tags  
+                    }  
+                })  
+            else:  
+                try:  
+                    blob.delete()  
+                    deleted.append(item_id)  
+                except Exception as de:  
+                    errors.append({"id": item_id, "error": str(de)})  
+        except Exception as e:  
+            errors.append({"blob": getattr(blob, "name", None), "error": str(e)})  
+    return jsonify({"ok": True, "kept": kept, "deleted": deleted, "errors": errors}), 200  
+except Exception as e:  
+    log.exception("finalize_detections error: %s", e)  
+    return jsonify({"error": "internal", "detail": str(e)}), 500
+
+---------- Clear session: delete all temporary files for a session ----------
+
 @app.route("/clear_session", methods=["POST"])
 def clear_session():
-    """
-    Body JSON: { "session_id": "<id>", "uid": "<optional uid>" }
-    Deletes all detected/<uid>/* blobs where metadata.session_id == session_id and metadata.tmp == "true".
-    """
-    try:
-        body = request.get_json(force=True)
-    except Exception:
-        return jsonify({"error": "invalid json"}), 400
-
-    session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()
-    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-
-    if not session_id:
-        return jsonify({"error": "session_id required"}), 400
-
-    if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:
-        return jsonify({"error": "firebase admin not configured"}), 500
-
-    try:
-        init_firebase_admin_if_needed()
-        bucket = fb_storage.bucket()
-    except Exception as e:
-        log.exception("Firebase init error in clear_session: %s", e)
-        return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500
-
-    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-    prefix = f"detected/{safe_uid}/"
-
-    deleted = []
-    errors = []
-    try:
-        blobs = list(bucket.list_blobs(prefix=prefix))
-        for blob in blobs:
-            try:
-                md = blob.metadata or {}
-                if str(md.get("session_id", "")) == session_id and str(md.get("tmp", "")).lower() in ("true", "1", "yes"):
-                    try:
-                        blob.delete()
-                        deleted.append(blob.name.split("/")[-1].rsplit(".", 1)[0])
-                    except Exception as de:
-                        errors.append({"blob": blob.name, "error": str(de)})
-            except Exception as e:
-                errors.append({"blob": getattr(blob, "name", None), "error": str(e)})
-        return jsonify({"ok": True, "deleted": deleted, "errors": errors}), 200
-    except Exception as e:
-        log.exception("clear_session error: %s", e)
-        return jsonify({"error": "internal", "detail": str(e)}), 500
-
-if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))
-    log.info("Starting server on 0.0.0.0:%d", port)
-    app.run(host="0.0.0.0", port=port, debug=True)
+"""
+Body JSON: { "session_id": "<id>", "uid": "<optional uid>" }
+Deletes all detected/<uid>/* blobs where metadata.session_id == session_id and metadata.tmp == "true".
+"""
+try:
+body = request.get_json(force=True)
+except Exception:
+return jsonify({"error": "invalid json"}), 400
+
+session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()  
+uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"  
+
+if not session_id:  
+    return jsonify({"error": "session_id required"}), 400  
+
+if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:  
+    return jsonify({"error": "firebase admin not configured"}), 500  
+
+try:  
+    init_firebase_admin_if_needed()  
+    bucket = fb_storage.bucket()  
+except Exception as e:  
+    log.exception("Firebase init error in clear_session: %s", e)  
+    return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500  
+
+safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"  
+prefix = f"detected/{safe_uid}/"  
+
+deleted = []  
+errors = []  
+try:  
+    blobs = list(bucket.list_blobs(prefix=prefix))  
+    for blob in blobs:  
+        try:  
+            md = blob.metadata or {}  
+            if str(md.get("session_id", "")) == session_id and str(md.get("tmp", "")).lower() in ("true", "1", "yes"):  
+                try:  
+                    blob.delete()  
+                    deleted.append(blob.name.split("/")[-1].rsplit(".", 1)[0])  
+                except Exception as de:  
+                    errors.append({"blob": blob.name, "error": str(de)})  
+        except Exception as e:  
+            errors.append({"blob": getattr(blob, "name", None), "error": str(e)})  
+    return jsonify({"ok": True, "deleted": deleted, "errors": errors}), 200  
+except Exception as e:  
+    log.exception("clear_session error: %s", e)  
+    return jsonify({"error": "internal", "detail": str(e)}), 500
+
+if name == "main":
+port = int(os.getenv("PORT", 7860))
+log.info("Starting server on 0.0.0.0:%d", port)
+app.run(host="0.0.0.0", port=port, debug=True)
+