Update main.py

main.py

@@ -9,7 +9,7 @@ main.py — Pricelyst Shopping Advisor (Jessica Edition)
 ✅ Call briefing (Zim Essentials Injection)
 ✅ Post-call Shopping Plan Generation (PDF-ready)
 
-ENV VARS YOU NEED
+ENV VARS YOU NEED:
 - GOOGLE_API_KEY=...
 - FIREBASE='{"type":"service_account", ...}'   # full JSON string
 - PRICE_API_BASE=https://api.pricelyst.co.zw   # optional
@@ -33,15 +33,18 @@ import pandas as pd
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
-# ---------- Logging ----------
+# ––––– Logging –––––
+
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s | %(levelname)s | %(message)s"
 )
 logger = logging.getLogger("pricelyst-advisor")
 
-# ---------- Gemini (NEW SDK) ----------
+# ––––– Gemini (NEW SDK) –––––
+
 # pip install google-genai
+
 try:
     from google import genai
     from google.genai import types
@@ -60,36 +63,53 @@ if genai and GOOGLE_API_KEY:
     except Exception as e:
         logger.error("Failed to init Gemini client: %s", e)
 
-# ---------- Firebase Admin ----------
+# ––––– Firebase Admin –––––
+
 # pip install firebase-admin
+
 import firebase_admin
 from firebase_admin import credentials, firestore
 
 FIREBASE_ENV = os.environ.get("FIREBASE", "")
 
 def init_firestore_from_env() -> firestore.Client:
+    # 1. Check if already initialized
     if firebase_admin._apps:
         return firestore.client()
 
+    # 2. Check for Creds
     if not FIREBASE_ENV:
+        logger.critical("FIREBASE env var missing. Persistence will fail.")
         raise RuntimeError("FIREBASE env var missing. Provide full service account JSON string.")
 
-    sa_info = json.loads(FIREBASE_ENV)
-    cred = credentials.Certificate(sa_info)
-    firebase_admin.initialize_app(cred)
-    return firestore.client()
+    try:
+        sa_info = json.loads(FIREBASE_ENV)
+        cred = credentials.Certificate(sa_info)
+        firebase_admin.initialize_app(cred)
+        logger.info("Firebase initialized successfully.")
+        return firestore.client()
+    except Exception as e:
+        logger.critical("Failed to initialize Firebase: %s", e)
+        raise e
+
+try:
+    db = init_firestore_from_env()
+except Exception as e:
+    logger.error("DB Init failed: %s", e)
+    db = None
 
-db = init_firestore_from_env()
+# ––––– External API (Pricelyst) –––––
 
-# ---------- External API (Pricelyst) ----------
 PRICE_API_BASE = os.environ.get("PRICE_API_BASE", "https://api.pricelyst.co.zw").rstrip("/")
 HTTP_TIMEOUT = 20
 
-# ---------- Flask ----------
+# ––––– Flask –––––
+
 app = Flask(__name__)
 CORS(app)
 
-# ---------- In-memory product cache ----------
+# ––––– In-memory product cache –––––
+
 PRODUCT_CACHE_TTL_SEC = 60 * 10  # 10 minutes
 _product_cache: Dict[str, Any] = {
     "ts": 0,
@@ -97,8 +117,8 @@ _product_cache: Dict[str, Any] = {
     "raw_count": 0,
 }
 
-# ---------- Static Data (New Feature) ----------
-# Injected into Voice Context & used for Text Fallback
+# ––––– Static Data (New Feature) –––––
+
 ZIM_ESSENTIALS = {
     "fuel_petrol": "$1.58/L (Blend)",
     "fuel_diesel": "$1.65/L (Diesel 50)",
@@ -110,6 +130,7 @@ ZIM_ESSENTIALS = {
 # =========================
 # Helpers: time / strings
 # =========================
+
 def now_utc_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
@@ -141,59 +162,88 @@ def _safe_json_loads(s: str, fallback: Any):
 # =========================
 # Firestore profile storage
 # =========================
+
 def profile_ref(profile_id: str):
+    if not db: return None
     return db.collection("pricelyst_profiles").document(profile_id)
 
 def get_profile(profile_id: str) -> Dict[str, Any]:
-    ref = profile_ref(profile_id)
-    doc = ref.get()
-    if doc.exists:
-        return doc.to_dict() or {}
-    # create default
-    data = {
-        "profile_id": profile_id,
-        "created_at": now_utc_iso(),
-        "updated_at": now_utc_iso(),
-        "username": None,
-        "memory_summary": "",
-        "preferences": {},
-        "last_actions": [],
-        "counters": {
-            "chats": 0,
-            "calls": 0,
+    if not db:
+        return {}
+    try:
+        ref = profile_ref(profile_id)
+        doc = ref.get()
+        if doc.exists:
+            return doc.to_dict() or {}
+        # create default
+        data = {
+            "profile_id": profile_id,
+            "created_at": now_utc_iso(),
+            "updated_at": now_utc_iso(),
+            "username": None,
+            "memory_summary": "",
+            "preferences": {},
+            "last_actions": [],
+            "counters": {
+                "chats": 0,
+                "calls": 0,
+            }
         }
-    }
-    ref.set(data)
-    return data
+        ref.set(data)
+        return data
+    except Exception as e:
+        logger.error("get_profile error for %s: %s", profile_id, e)
+        return {}
 
 def update_profile(profile_id: str, patch: Dict[str, Any]) -> None:
-    patch = dict(patch or {})
-    patch["updated_at"] = now_utc_iso()
-    profile_ref(profile_id).set(patch, merge=True)
+    if not db: return
+    try:
+        patch = dict(patch or {})
+        patch["updated_at"] = now_utc_iso()
+        profile_ref(profile_id).set(patch, merge=True)
+    except Exception as e:
+        logger.error("update_profile error: %s", e)
 
 def log_chat(profile_id: str, payload: Dict[str, Any]) -> None:
-    db.collection("pricelyst_profiles").document(profile_id).collection("chat_logs").add({
-        **payload,
-        "ts": now_utc_iso()
-    })
+    if not db:
+        logger.warning("DB not connected, skipping log_chat")
+        return
+    try:
+        logger.info("Logging chat for %s. Type: %s", profile_id, payload.get("response_type"))
+        db.collection("pricelyst_profiles").document(profile_id).collection("chat_logs").add({
+            **payload,
+            "ts": now_utc_iso()
+        })
+    except Exception as e:
+        logger.error("Failed to log chat: %s", e)
 
 def log_call(profile_id: str, payload: Dict[str, Any]) -> str:
-    doc_ref = db.collection("pricelyst_profiles").document(profile_id).collection("call_logs").document()
-    doc_ref.set({
-        **payload,
-        "ts": now_utc_iso()
-    })
-    return doc_ref.id
+    if not db:
+        logger.warning("DB not connected, skipping log_call")
+        return ""
+    try:
+        logger.info("Logging call for %s. Transcript len: %s", profile_id, len(payload.get("transcript", "")))
+        doc_ref = db.collection("pricelyst_profiles").document(profile_id).collection("call_logs").document()
+        doc_ref.set({
+            **payload,
+            "ts": now_utc_iso()
+        })
+        logger.info("Call logged successfully. ID: %s", doc_ref.id)
+        return doc_ref.id
+    except Exception as e:
+        logger.error("Failed to log call: %s", e)
+        return ""
 
 # =========================
 # Multimodal image handling
 # =========================
+
 def parse_images(images: List[str]) -> List[Dict[str, Any]]:
     """
     Accepts:
-      - data URLs: data:image/png;base64,....
-      - raw base64 strings
-      - http(s) URLs
+    - data URLs: data:image/png;base64,....
+    - raw base64 strings
+    - http(s) URLs
     Returns: list of { "mime": "...", "bytes": b"..." } or { "url": "..." }
     """
     out = []
@@ -201,7 +251,7 @@ def parse_images(images: List[str]) -> List[Dict[str, Any]]:
         if not item:
             continue
         item = item.strip()
-
+        
         # URL
         if item.startswith("http://") or item.startswith("https://"):
             out.append({"url": item})
@@ -217,18 +267,19 @@ def parse_images(images: List[str]) -> List[Dict[str, Any]]:
             except Exception:
                 continue
             continue
-
+        
         # raw base64
         try:
             out.append({"mime": "image/png", "bytes": base64.b64decode(item)})
         except Exception:
             continue
-
+            
     return out
 
 # =========================
 # Product fetching + offers DF
 # =========================
+
 def fetch_products_page(page: int, per_page: int = 50) -> Dict[str, Any]:
     url = f"{PRICE_API_BASE}/api/v1/products"
     params = {"page": page, "perPage": per_page}
@@ -237,10 +288,6 @@ def fetch_products_page(page: int, per_page: int = 50) -> Dict[str, Any]:
     return r.json()
 
 def fetch_products(max_pages: int = 6, per_page: int = 50) -> List[Dict[str, Any]]:
-    """
-    Pull a reasonable slice (you can increase pages later).
-    API shape (common): {status, message, data, totalItemCount, currentPage, totalPages}
-    """
     products: List[Dict[str, Any]] = []
     for p in range(1, max_pages + 1):
         payload = fetch_products_page(p, per_page=per_page)
@@ -255,17 +302,13 @@ def fetch_products(max_pages: int = 6, per_page: int = 50) -> List[Dict[str, Any
     return products
 
 def products_to_offers_df(products: List[Dict[str, Any]]) -> pd.DataFrame:
-    """
-    Each row = one product + one retailer offer.
-    Your product object can include `prices[]` with nested `retailer`.
-    """
     rows = []
     for p in products or []:
         try:
             product_id = p.get("id")
             name = p.get("name") or ""
             clean_name = _norm_str(name)
-
+            
             brand_name = ((p.get("brand") or {}).get("brand_name")) if isinstance(p.get("brand"), dict) else None
             categories = p.get("categories") or []
             cat_names = []
@@ -273,22 +316,22 @@ def products_to_offers_df(products: List[Dict[str, Any]]) -> pd.DataFrame:
                 if isinstance(c, dict) and c.get("name"):
                     cat_names.append(c.get("name"))
             primary_category = cat_names[0] if cat_names else None
-
+            
             stock_status = p.get("stock_status")
             on_promo = bool(p.get("on_promotion"))
             promo_badge = p.get("promo_badge")
             promo_name = p.get("promo_name")
             promo_price = _coerce_float(p.get("promo_price"))
             original_price = _coerce_float(p.get("original_price"))
-
+            
             recommended_price = _coerce_float(p.get("recommended_price"))
             base_price = _coerce_float(p.get("price"))
             bulk_price = _coerce_float(p.get("bulk_price"))
             bulk_unit = p.get("bulk_unit")
-
+            
             image = p.get("image")
             thumb = p.get("thumbnail")
-
+            
             offers = p.get("prices") or []
             if not offers:
                 rows.append({
@@ -353,7 +396,7 @@ def products_to_offers_df(products: List[Dict[str, Any]]) -> pd.DataFrame:
     df = pd.DataFrame(rows)
     if df.empty:
         return df
-
+        
     df["offer_price"] = df["offer_price"].apply(_coerce_float)
     df["clean_name"] = df["clean_name"].fillna("").astype(str)
     df["product_name"] = df["product_name"].fillna("").astype(str)
@@ -383,6 +426,7 @@ def get_offers_df(force_refresh: bool = False) -> pd.DataFrame:
 # =========================
 # Gemini wrappers
 # =========================
+
 def gemini_generate_text(system: str, user: str, temperature: float = 0.4) -> str:
     if not _gemini_client:
         return ""
@@ -426,15 +470,15 @@ def gemini_generate_json(system: str, user: str, images: List = None) -> Dict[st
 def gemini_generate_multimodal(system: str, user: str, images: List[Dict[str, Any]]) -> str:
     """
     Uses Gemini multimodal:
-      - if we have bytes -> inline_data
-      - if we have url -> just paste the URL (server-side fetch is unreliable w/o whitelisting),
-        so we prefer bytes from the client.
+    - if we have bytes -> inline_data
+    - if we have url -> just paste the URL (server-side fetch is unreliable w/o whitelisting),
+      so we prefer bytes from the client.
     """
     if not _gemini_client:
         return ""
 
     parts: List[Dict[str, Any]] = [{"text": system.strip() + "\n\n" + user.strip()}]
-
+    
     for img in images or []:
         if "bytes" in img and img.get("mime"):
             b64 = base64.b64encode(img["bytes"]).decode("utf-8")
@@ -465,14 +509,15 @@ def gemini_generate_multimodal(system: str, user: str, images: List[Dict[str, An
 # =========================
 # Intent + actionability
 # =========================
+
 INTENT_SYSTEM = """
 You are Pricelyst AI. Your job: understand whether the user is asking for actionable shopping help.
 Return STRICT JSON only.
 
 Output schema:
 {
-  "actionable": true|false,
-  "intent": one of [
+"actionable": true|false,
+"intent": one of [
     "store_recommendation",
     "price_lookup",
     "price_compare",
@@ -483,10 +528,10 @@ Output schema:
     "chit_chat",
     "lifestyle_lookup",
     "other"
-  ],
-  "items": [{"name": "...", "quantity": 1}],
-  "constraints": {"budget": number|null, "location": "... "|null, "time_context": "mid-month|month-end|weekend|today|unknown"},
-  "notes": "short reasoning"
+],
+"items": [{"name": "...", "quantity": 1}],
+"constraints": {"budget": number|null, "location": "... "|null, "time_context": "mid-month|month-end|weekend|today|unknown"},
+"notes": "short reasoning"
 }
 
 Rules:
@@ -504,11 +549,11 @@ def detect_intent(message: str, images_present: bool, context: Dict[str, Any]) -
         clean_k = k.split('_')[-1] # fuel_petrol -> petrol
         if clean_k in msg_lower and "price" in msg_lower:
             return {"actionable": True, "intent": "lifestyle_lookup", "items": [{"name": k}]}
-            
+
     # 2. Gemini Detection
     ctx_str = json.dumps(context or {}, ensure_ascii=False)
     user = f"Message: {message}\nImagesPresent: {images_present}\nContext: {ctx_str}"
-    
+
     # Try using the strict JSON helper first for better reliability
     try:
         data = gemini_generate_json(INTENT_SYSTEM, user)
@@ -517,7 +562,7 @@ def detect_intent(message: str, images_present: bool, context: Dict[str, Any]) -
         # Fallback to text parsing if JSON mode fails (Backward Compat)
         out = gemini_generate_text(INTENT_SYSTEM, user, temperature=0.1)
         data = _safe_json_loads(out, fallback={})
-
+    
     if not isinstance(data, dict):
         return {"actionable": False, "intent": "other", "items": [], "constraints": {}, "notes": "bad_json"}
     # normalize
@@ -530,17 +575,18 @@ def detect_intent(message: str, images_present: bool, context: Dict[str, Any]) -
 # =========================
 # Shopping Plan Generator (NEW)
 # =========================
+
 PLAN_SYSTEM_PROMPT = """
 You are Jessica, the Pricelyst Shopping Advisor. Analyze the conversation transcript.
 If the user discussed a shopping list, budget plan, or event needs, create a structured plan.
 
 OUTPUT JSON SCHEMA:
 {
-  "is_actionable": boolean,
-  "title": "Short title (e.g. 'Weekend Braai List')",
-  "summary": "1 sentence summary",
-  "items": [{"name": "string", "qty": "string", "est_price": number|null}],
-  "markdown_content": "A clean Markdown report for a PDF. Include headers (#), bullet points, and a budget summary table if applicable. Keep it professional."
+"is_actionable": boolean,
+"title": "Short title (e.g. 'Weekend Braai List')",
+"summary": "1 sentence summary",
+"items": [{"name": "string", "qty": "string", "est_price": number|null}],
+"markdown_content": "A clean Markdown report for a PDF. Include headers (#), bullet points, and a budget summary table if applicable. Keep it professional."
 }
 
 If no shopping/planning occurred, set is_actionable=false.
@@ -554,6 +600,7 @@ def generate_shopping_plan(transcript: str) -> Dict[str, Any]:
 # =========================
 # Matching + analytics
 # =========================
+
 def search_products(df: pd.DataFrame, query: str, limit: int = 10) -> pd.DataFrame:
     """
     Simple search: contains on clean_name + fallback token overlap scoring.
@@ -564,17 +611,17 @@ def search_products(df: pd.DataFrame, query: str, limit: int = 10) -> pd.DataFra
     q = _norm_str(query)
     if not q:
         return df.head(0)
-
+    
     # direct contains
     hit = df[df["clean_name"].str.contains(re.escape(q), na=False)]
     if len(hit) >= limit:
         return hit.head(limit)
-
+    
     # token overlap (cheap scoring)
     q_tokens = set(q.split())
     if not q_tokens:
         return hit.head(limit)
-
+        
     tmp = df.copy()
     tmp["score"] = tmp["clean_name"].apply(lambda s: len(q_tokens.intersection(set(str(s).split()))))
     tmp = tmp[tmp["score"] > 0].sort_values(["score"], ascending=False)
@@ -585,18 +632,18 @@ def summarize_offers(df_hits: pd.DataFrame) -> Dict[str, Any]:
     """
     For one product name, there can be multiple retailers (offers).
     We return:
-      - cheapest offer
-      - price range
-      - top offers
+    - cheapest offer
+    - price range
+    - top offers
     """
     if df_hits.empty:
         return {}
-
+    
     # group by product_id (best is highest offer coverage)
     grp = df_hits.groupby("product_id").size().sort_values(ascending=False)
     best_pid = int(grp.index[0])
     prod_rows = df_hits[df_hits["product_id"] == best_pid].copy()
-
+    
     prod_name = prod_rows["product_name"].iloc[0]
     brand = prod_rows["brand_name"].iloc[0]
     category = prod_rows["primary_category"].iloc[0]
@@ -604,10 +651,10 @@ def summarize_offers(df_hits: pd.DataFrame) -> Dict[str, Any]:
     on_promo = bool(prod_rows["on_promotion"].iloc[0])
     promo_badge = prod_rows["promo_badge"].iloc[0]
     image = prod_rows["thumbnail"].iloc[0] or prod_rows["image"].iloc[0]
-
+    
     offers = prod_rows[prod_rows["offer_price"].notna()].copy()
     offers = offers.sort_values("offer_price", ascending=True)
-
+    
     if offers.empty:
         return {
             "product_id": best_pid,
@@ -630,7 +677,7 @@ def summarize_offers(df_hits: pd.DataFrame) -> Dict[str, Any]:
     }
     lo = float(offers["offer_price"].min())
     hi = float(offers["offer_price"].max())
-
+    
     top_offers = []
     for _, r in offers.head(5).iterrows():
         top_offers.append({
@@ -638,7 +685,7 @@ def summarize_offers(df_hits: pd.DataFrame) -> Dict[str, Any]:
             "price": float(r["offer_price"]),
             "retailer_logo": r["retailer_logo"],
         })
-
+        
     return {
         "product_id": best_pid,
         "name": prod_name,
@@ -656,15 +703,15 @@ def summarize_offers(df_hits: pd.DataFrame) -> Dict[str, Any]:
 def basket_store_choice(df: pd.DataFrame, items: List[Dict[str, Any]]) -> Dict[str, Any]:
     """
     Given items, pick:
-      - best single store to cover most items and minimize total
+    - best single store to cover most items and minimize total
     Very pragmatic MVP: for each item, match the best product and take cheapest offer.
     """
     if df.empty or not items:
         return {"items": [], "best_store": None, "missing": []}
-
+    
     results = []
     missing = []
-
+    
     for it in items:
         name = it.get("name") or ""
         qty = int(it.get("quantity") or 1)
@@ -685,10 +732,10 @@ def basket_store_choice(df: pd.DataFrame, items: List[Dict[str, Any]]) -> Dict[s
             "offers": summary.get("offers", []),
             "image": summary.get("image"),
         })
-
+        
     if not results:
         return {"items": [], "best_store": None, "missing": missing}
-
+        
     # compute totals by retailer for "all cheapest per item"
     retailer_totals: Dict[str, float] = {}
     retailer_counts: Dict[str, int] = {}
@@ -696,7 +743,7 @@ def basket_store_choice(df: pd.DataFrame, items: List[Dict[str, Any]]) -> Dict[s
         k = r["cheapest_retailer"]
         retailer_totals[k] = retailer_totals.get(k, 0.0) + float(r["line_total"])
         retailer_counts[k] = retailer_counts.get(k, 0) + 1
-
+        
     # Score: cover_count desc, then total asc
     best = sorted(retailer_totals.keys(), key=lambda k: (-retailer_counts.get(k, 0), retailer_totals.get(k, 0.0)))[0]
     return {
@@ -713,6 +760,7 @@ def basket_store_choice(df: pd.DataFrame, items: List[Dict[str, Any]]) -> Dict[s
 # =========================
 # Response rendering (informative)
 # =========================
+
 def render_price_answer(summary: Dict[str, Any]) -> Dict[str, Any]:
     """
     Returns structured payload for frontend to render nicely.
@@ -733,7 +781,7 @@ def render_price_answer(summary: Dict[str, Any]) -> Dict[str, Any]:
     image = summary.get("image")
     cheapest = summary.get("cheapest")
     pr = summary.get("price_range")
-
+    
     lines = []
     if cheapest:
         lines.append(f"Cheapest right now: {cheapest['retailer']} — ${cheapest['price']:.2f}")
@@ -741,7 +789,7 @@ def render_price_answer(summary: Dict[str, Any]) -> Dict[str, Any]:
         lines.append(f"Price range: ${pr['min']:.2f} → ${pr['max']:.2f} (spread ${pr['spread']:.2f})")
     if on_promo:
         lines.append(f"Promo: {promo_badge or 'On promotion'}")
-
+        
     return {
         "type": "product_price",
         "title": name,
@@ -768,28 +816,29 @@ def render_basket_answer(basket: Dict[str, Any]) -> Dict[str, Any]:
         "best_store": best,
         "items": basket["items"],
         "missing": missing,
-        "notes": "If you want, tell me your budget and I’ll suggest cheaper substitutes.",
+        "notes": "If you want, tell me your budget and I'll suggest cheaper substitutes.",
     }
 
 # =========================
 # Multimodal extraction (lists / receipts)
 # =========================
+
 VISION_SYSTEM = """
 You are an expert shopping assistant. Extract actionable items and quantities from the user's image(s).
 Return STRICT JSON only.
 
 Output schema:
 {
-  "actionable": true|false,
-  "items": [{"name":"...", "quantity": 1}],
-  "notes": "short"
+"actionable": true|false,
+"items": [{"name":"...", "quantity": 1}],
+"notes": "short"
 }
 
 Rules:
 - If it looks like a handwritten shopping list, extract items.
 - If it looks like a receipt, extract the purchased items (best-effort).
-- If it’s random (selfie, meme, etc), actionable=false and items=[].
-- Keep it conservative: only include items you’re confident about.
+- If it's random (selfie, meme, etc), actionable=false and items=[].
+- Keep it conservative: only include items you're confident about.
 """
 
 def extract_items_from_images(images: List[Dict[str, Any]]) -> Dict[str, Any]:
@@ -807,12 +856,14 @@ def extract_items_from_images(images: List[Dict[str, Any]]) -> Dict[str, Any]:
 # =========================
 # Routes
 # =========================
+
 @app.get("/health")
 def health():
     return jsonify({
         "ok": True,
         "ts": now_utc_iso(),
         "gemini": bool(_gemini_client),
+        "firestore": bool(db),
         "products_cached_rows": int(len(_product_cache["df_offers"])) if isinstance(_product_cache["df_offers"], pd.DataFrame) else 0,
         "products_raw_count": int(_product_cache.get("raw_count", 0)),
     })
@@ -868,7 +919,7 @@ def chat():
 
     # 4) Actionable: execute
     df = get_offers_df(force_refresh=False)
-
+    
     response_payload: Dict[str, Any] = {"type": "unknown", "message": "No result."}
 
     # --- NEW: Check for Lifestyle/Essentials (Fuel/ZESA) ---
@@ -923,7 +974,7 @@ def chat():
                 hits = search_products(df, it.get("name") or "", limit=60)
                 summary = summarize_offers(hits)
                 comparisons.append(summary)
-
+            
             # compute cheapest for each
             rows = []
             for s in comparisons:
@@ -968,7 +1019,7 @@ def call_briefing():
 
     username = body.get("username")
     prof = get_profile(profile_id)
-
+    
     if username and not prof.get("username"):
         update_profile(profile_id, {"username": username})
         prof["username"] = username
@@ -976,21 +1027,24 @@ def call_briefing():
     # Build lightweight "shopping intelligence" variables for ElevenLabs agent
     prefs = prof.get("preferences") or {}
     last_store = (prefs.get("last_best_store") or "").strip() or None
-
+    
     # quick stats from recent chats (last 25)
-    logs = db.collection("pricelyst_profiles").document(profile_id).collection("chat_logs") \
-        .order_by("ts", direction=firestore.Query.DESCENDING).limit(25).stream()
-
-    intents = []
-    for d in logs:
-        dd = d.to_dict() or {}
-        ii = (dd.get("intent") or {}).get("intent")
-        if ii:
-            intents.append(ii)
-
     intent_counts: Dict[str, int] = {}
-    for ii in intents:
-        intent_counts[ii] = intent_counts.get(ii, 0) + 1
+    try:
+        logs = db.collection("pricelyst_profiles").document(profile_id).collection("chat_logs") \
+            .order_by("ts", direction=firestore.Query.DESCENDING).limit(25).stream()
+        
+        intents = []
+        for d in logs:
+            dd = d.to_dict() or {}
+            ii = (dd.get("intent") or {}).get("intent")
+            if ii:
+                intents.append(ii)
+        
+        for ii in intents:
+            intent_counts[ii] = intent_counts.get(ii, 0) + 1
+    except Exception as e:
+        logger.error("Error fetching call briefing chat history: %s", e)
 
     # --- KPI Snapshot Logic ---
     # We construct a dictionary that the React client will pass as a JSON string
@@ -1023,23 +1077,36 @@ def log_call_usage():
     started_at = body.get("started_at") or None
     ended_at = body.get("ended_at") or None
     stats = body.get("stats") or {}
+    
+    logger.info("Received call usage for %s. Transcript len: %d", profile_id, len(transcript))
 
     prof = get_profile(profile_id)
 
     # --- UPGRADE: Use Shopping Plan Generator (JSON + Markdown) ---
-    plan_data = generate_shopping_plan(transcript)
     plan_id = None
     report_md = ""
+    plan_data = {}
 
-    if plan_data.get("is_actionable"):
-        # Save structured plan
-        plan_ref = db.collection("pricelyst_profiles").document(profile_id).collection("shopping_plans").document()
-        plan_data["id"] = plan_ref.id
-        plan_data["call_id"] = call_id
-        plan_data["created_at"] = now_utc_iso()
-        plan_ref.set(plan_data)
-        plan_id = plan_ref.id
-        report_md = plan_data.get("markdown_content", "")
+    try:
+        if transcript:
+            logger.info("Generating shopping plan via Gemini...")
+            plan_data = generate_shopping_plan(transcript)
+            logger.info("Plan generated. actionable=%s, title=%s", plan_data.get("is_actionable"), plan_data.get("title"))
+
+            if plan_data.get("is_actionable"):
+                # Save structured plan
+                plan_ref = db.collection("pricelyst_profiles").document(profile_id).collection("shopping_plans").document()
+                plan_data["id"] = plan_ref.id
+                plan_data["call_id"] = call_id
+                plan_data["created_at"] = now_utc_iso()
+                plan_ref.set(plan_data)
+                plan_id = plan_ref.id
+                report_md = plan_data.get("markdown_content", "")
+                logger.info("Shopping plan stored. ID=%s", plan_id)
+            else:
+                logger.info("No actionable shopping plan found in call.")
+    except Exception as e:
+        logger.error("Error generating/storing shopping plan: %s", e)
 
     # Log the call (link the plan_id)
     doc_id = log_call(profile_id, {
@@ -1051,10 +1118,13 @@ def log_call_usage():
         "generated_plan_id": plan_id,
         "report_markdown": report_md, 
     })
-
+    
     # update counters
-    counters = prof.get("counters") or {}
-    update_profile(profile_id, {"counters": {"calls": int(counters.get("calls", 0)) + 1}})
+    try:
+        counters = prof.get("counters") or {}
+        update_profile(profile_id, {"counters": {"calls": int(counters.get("calls", 0)) + 1}})
+    except Exception as e:
+        logger.error("Error updating profile counters: %s", e)
 
     return jsonify({
         "ok": True,
@@ -1062,37 +1132,46 @@ def log_call_usage():
         "shopping_plan": plan_data if plan_id else None # Frontend uses this for PDF
     })
 
-# --- NEW: Shopping Plans CRUD ---
+# — NEW: Shopping Plans CRUD —
+
 @app.get("/api/shopping-plans")
 def list_plans():
     pid = request.args.get("profile_id")
     if not pid: return jsonify({"ok": False}), 400
     try:
-        docs = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans")\
-                 .order_by("created_at", direction=firestore.Query.DESCENDING).limit(20).stream()
+        docs = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans") \
+            .order_by("created_at", direction=firestore.Query.DESCENDING).limit(20).stream()
         plans = [{"id": d.id, **d.to_dict()} for d in docs]
         return jsonify({"ok": True, "plans": plans})
     except Exception as e:
+        logger.error("list_plans error: %s", e)
         return jsonify({"ok": False, "error": str(e)}), 500
 
 @app.get("/api/shopping-plans/<plan_id>")
 def get_plan(plan_id):
     pid = request.args.get("profile_id")
     if not pid: return jsonify({"ok": False}), 400
-    doc = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document(plan_id).get()
-    if not doc.exists: return jsonify({"ok": False, "error": "Not found"}), 404
-    return jsonify({"ok": True, "plan": doc.to_dict()})
+    try:
+        doc = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document(plan_id).get()
+        if not doc.exists: return jsonify({"ok": False, "error": "Not found"}), 404
+        return jsonify({"ok": True, "plan": doc.to_dict()})
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)}), 500
 
 @app.delete("/api/shopping-plans/<plan_id>")
 def delete_plan(plan_id):
     pid = request.args.get("profile_id")
     if not pid: return jsonify({"ok": False}), 400
-    db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document(plan_id).delete()
-    return jsonify({"ok": True})
+    try:
+        db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document(plan_id).delete()
+        return jsonify({"ok": True})
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)}), 500
 
 # =========================
 # Run
 # =========================
+
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", "7860"))
     app.run(host="0.0.0.0", port=port, debug=True)