Update app.py

app.py

@@ -1,4 +1,4 @@
-# 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
+# server_gemini_seg.py
 
 import os
 import io
@@ -7,6 +7,7 @@ import base64
 import logging
 import uuid
 import time
+import difflib
 from typing import List, Dict, Any, Tuple, Optional
 
 from flask import Flask, request, jsonify
@@ -15,591 +16,671 @@ 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)
 
----------- Firebase init helpers ----------
+# ---------- Categories mapping (map model 'type' to frontend categories) ----------
+# NOTE: If frontend has a definitive categories array, replace this list with that array.
+# We use difflib.get_close_matches to pick the closest category from CATEGORIES.
+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:
+    """Map a model-produced type string to the closest category from CATEGORIES.
+    Falls back to 'unknown' if no reasonable match is found.
+    """
+    if not item_type:
+        return "unknown"
+    t = item_type.strip().lower()
+    # direct hit
+    if t in CATEGORIES:
+        return t
+    # try splitting or common plural handling
+    t_clean = t.rstrip("s")
+    if t_clean in CATEGORIES:
+        return t_clean
+    # fuzzy match
+    matches = difflib.get_close_matches(t, CATEGORIES, n=1, cutoff=0.6)
+    if matches:
+        return matches[0]
+    # attempt to match by token intersection
+    for token in t.replace("_", " ").split():
+        if token in CATEGORIES:
+            return token
+    return "unknown"
+
+
+# ---------- 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:///.
+    """
+    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)
+        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))
+    try:
+        img = ImageOps.exif_transpose(img)
+    except Exception:
+        pass
+    img = img.convert("RGB")
+    w, h = img.size
+    arr = np.array(img)[:, :, ::-1]  # RGB -> BGR
+    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_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 ----------
+    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 ----------
+
 
 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  
-
-            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 ----------
+    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
+                    item_obj = {
+                        "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",
+                    }
+                    # Add placeholder analysis/title; will be filled later if analysis runs
+                    item_obj["analysis"] = {"type": "unknown", "summary": "", "brand": "", "tags": []}
+                    item_obj["title"] = "unknown"
+                    items_out.append(item_obj)
+                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)
+            # ensure analysis/title placeholders
+            for itm in items_out:
+                itm.setdefault("analysis", {"type": "unknown", "summary": "", "brand": "", "tags": []})
+                itm.setdefault("title", "unknown")
+
+        # 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": []}
+
+                # attach analysis and map to frontend category/title
+                itm["analysis"] = analysis
+                mapped_title = map_type_to_category(analysis.get("type", "") or itm.get("label", ""))
+                itm["title"] = mapped_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", [])),
+                    }
+                    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.")
+            # For items without firebase upload, still attempt local analysis mapping
+            for itm in items_out:
+                if "analysis" not in itm or not itm["analysis"]:
+                    # attempt lightweight analysis mapping using label
+                    itm.setdefault("analysis", {"type": itm.get("label", "unknown"), "summary": "", "brand": "", "tags": []})
+                mapped_title = map_type_to_category(itm["analysis"].get("type", "") or itm.get("label", ""))
+                itm["title"] = mapped_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)
+            for itm in items_out:
+                itm.setdefault("analysis", {"type": "unknown", "summary": "", "brand": "", "tags": []})
+                itm["title"] = map_type_to_category(itm["analysis"].get("type", "") or itm.get("label", ""))
+            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 "[]"  
-                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 ----------
+    """
+    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": "", "uid": "" }
+    Deletes all detected//* 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)