Update main.py

main.py

@@ -1,4 +1,4 @@
-# app.py
+# app.py  —  Drop-in refactor to contain PandasAI errors and guarantee analyst fallback
 from langchain_google_genai import ChatGoogleGenerativeAI
 import pandas as pd
 import os
@@ -9,7 +9,6 @@ import logging
 from dotenv import load_dotenv
 from pandasai import SmartDataframe
 from pandasai.responses.response_parser import ResponseParser
-from datetime import datetime, timedelta, timezone
 import matplotlib.pyplot as plt
 import google.generativeai as genai
 import uuid
@@ -19,22 +18,29 @@ import urllib.parse
 import json
 import re
 
+# -----------------------------------------------------------------------------
+# Init
+# -----------------------------------------------------------------------------
 load_dotenv()
-
 app = Flask(__name__)
 CORS(app)
 
-# --- Logging Configuration (Preserved) ---
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
-# --- PRESERVED RESPONSE PARSER ---
-# Your original FlaskResponse class, ensuring no regressions in PandasAI functionality.
+# -----------------------------------------------------------------------------
+# Response parser (preserved)
+# -----------------------------------------------------------------------------
 class FlaskResponse(ResponseParser):
     def __init__(self, context):
         super().__init__(context)
+
     def format_dataframe(self, result):
         return result["value"].to_html()
+
     def format_plot(self, result):
         val = result["value"]
         if hasattr(val, "savefig"):
@@ -46,24 +52,193 @@ class FlaskResponse(ResponseParser):
             with open(os.path.join(val), "rb") as file:
                 return f"data:image/png;base64,{base64.b64encode(file.read()).decode('utf-8')}"
         return str(val)
+
     def format_other(self, result):
         return str(result["value"])
 
-# --- AI Model Initialization (Preserved) ---
+# -----------------------------------------------------------------------------
+# AI model init (preserved)
+# -----------------------------------------------------------------------------
 logger.info("Initializing models...")
-gemini_api_key = os.getenv('Gemini')
-if not gemini_api_key: raise ValueError("Gemini API key is required.")
-llm = ChatGoogleGenerativeAI(api_key=gemini_api_key, model='gemini-2.0-flash', temperature=0.1)
+gemini_api_key = os.getenv("Gemini")
+if not gemini_api_key:
+    raise ValueError("Gemini API key is required.")
+
+llm = ChatGoogleGenerativeAI(
+    api_key=gemini_api_key,
+    model="gemini-2.0-flash",
+    temperature=0.1
+)
+
 genai.configure(api_key=gemini_api_key)
 generation_config = {"temperature": 0.2, "top_p": 0.95, "max_output_tokens": 5000}
-model = genai.GenerativeModel(model_name="gemini-2.0-flash-lite-001", generation_config=generation_config)
+model = genai.GenerativeModel(
+    model_name="gemini-2.0-flash-lite-001",
+    generation_config=generation_config,
+)
 logger.info("AI Models initialized.")
 
 user_defined_path = os.path.join("/exports/charts", str(uuid.uuid4()))
 logger.info(f"Chart export path set to: {user_defined_path}")
 
+# -----------------------------------------------------------------------------
+# Utilities: Temporal awareness + PandasAI response guards
+# -----------------------------------------------------------------------------
+TZ = "Africa/Harare"  # single source of truth for business dates
+
+def now_harare() -> pd.Timestamp:
+    # Use pandas Timestamp to avoid datetime collisions entirely
+    return pd.Timestamp.now(tz=TZ)
+
+def week_bounds_from(ts: pd.Timestamp):
+    # Monday..Sunday window containing ts
+    monday = ts.normalize() - pd.Timedelta(days=ts.weekday())
+    sunday = monday + pd.Timedelta(days=6)
+    return monday, sunday
+
+def next_week_bounds(ts: pd.Timestamp):
+    this_mon, _ = week_bounds_from(ts)
+    next_mon = this_mon + pd.Timedelta(days=7)
+    next_sun = next_mon + pd.Timedelta(days=6)
+    return next_mon, next_sun
+
+def last_month_bounds(ts: pd.Timestamp):
+    first_this = ts.normalize().replace(day=1)
+    last_month_end = first_this - pd.Timedelta(days=1)
+    first_last = last_month_end.replace(day=1)
+    return first_last, last_month_end
+
+def this_month_bounds(ts: pd.Timestamp):
+    first_this = ts.normalize().replace(day=1)
+    # next month first
+    if first_this.month == 12:
+        first_next = first_this.replace(year=first_this.year + 1, month=1)
+    else:
+        first_next = first_this.replace(month=first_this.month + 1)
+    last_this = first_next - pd.Timedelta(days=1)
+    return first_this, last_this
+
+def quarter_bounds(ts: pd.Timestamp):
+    q = (ts.month - 1) // 3 + 1
+    first_month = 3*(q-1) + 1
+    first = ts.normalize().replace(month=first_month, day=1)
+    if first_month == 10:
+        first_next = first.replace(year=first.year+1, month=1)
+    else:
+        first_next = first.replace(month=first_month+3)
+    last = first_next - pd.Timedelta(days=1)
+    return first, last
+
+_TEMP_WINDOWS = [
+    ("next week", lambda base: next_week_bounds(base)),
+    ("this week", lambda base: week_bounds_from(base)),
+    ("last week", lambda base: (week_bounds_from(base - pd.Timedelta(days=7))[0],
+                                week_bounds_from(base - pd.Timedelta(days=7))[1])),
+    ("yesterday", lambda base: (base.normalize() - pd.Timedelta(days=1),
+                                base.normalize() - pd.Timedelta(seconds=1))),
+    ("tomorrow", lambda base: (base.normalize() + pd.Timedelta(days=1),
+                               base.normalize() + pd.Timedelta(days=1, hours=23, minutes=59, seconds=59))),
+    ("this month", lambda base: this_month_bounds(base)),
+    ("last month", lambda base: last_month_bounds(base)),
+    ("this quarter", lambda base: quarter_bounds(base)),
+]
+
+def extract_numeric_window(question: str):
+    """Detect 'last N days' / 'past N days' → (start, end)"""
+    m = re.search(r"(last|past)\s+(\d{1,3})\s+days", question.lower())
+    if m:
+        n = int(m.group(2))
+        end = now_harare()
+        start = end - pd.Timedelta(days=n)
+        return start, end
+    return None
+
+def temporal_hints(question: str) -> str:
+    """
+    Build a short natural-language preface with explicit date windows.
+    Example: "next week" => '2025-09-29 to 2025-10-05'
+    """
+    base = now_harare()
+    hints = {}
+    ql = question.lower()
+
+    # Pre-defined windows
+    for key, fn in _TEMP_WINDOWS:
+        if key in ql:
+            s, e = fn(base)
+            hints[key] = (s.date().isoformat(), e.date().isoformat())
+
+    # Numeric windows
+    rng = extract_numeric_window(question)
+    if rng:
+        s, e = rng
+        hints[f"last {int((e - s).days)} days"] = (s.date().isoformat(), e.date().isoformat())
+
+    if not hints:
+        return (
+            f"Temporal context: Today is {base.date().isoformat()} ({TZ}). "
+            f"Week is Monday–Sunday. Use pd.Timestamp.now(tz='{TZ}') and pd.Timedelta."
+        )
 
-# --- TIER 2: COMPREHENSIVE KPI ENGINE (For Intelligent Fallback) ---
+    parts = [f"Temporal context: Today is {base.date().isoformat()} ({TZ})."]
+    for k, (s, e) in hints.items():
+        parts.append(f"Interpret \"{k}\" as {s} to {e}.")
+    parts.append(f"Always prefer pd.Timestamp.now(tz='{TZ}') + pd.Timedelta over 'datetime'.")
+    return " ".join(parts)
+
+_ERROR_PATTERNS = [
+    "traceback", "exception", "keyerror", "nameerror", "syntaxerror",
+    "modulenotfounderror", "importerror", "pipeline failed", "execution failed",
+    "__import__", "failed with error", "attributeerror", "method_descriptor"
+]
+
+def looks_like_error(ans) -> bool:
+    """
+    Heuristics to detect PandasAI bad outputs that shouldn't reach users.
+    """
+    if ans is None:
+        return True
+    if isinstance(ans, (pd.DataFrame, plt.Figure)):
+        return False
+    s = str(ans).strip()
+    if not s:
+        return True
+    sl = s.lower()
+    if any(p in sl for p in _ERROR_PATTERNS):
+        return True
+    # crude detection of stack trace text
+    if "file \"" in sl and "line " in sl and "error" in sl:
+        return True
+    return False
+
+def sanitize_answer(ans) -> str:
+    """
+    Strip code-fences / raw logs; return plain, user-safe content.
+    """
+    s = str(ans)
+    # Remove common code fences to avoid dumping code unintentionally
+    s = re.sub(r"```+(\w+)?", "", s)
+    # Truncate any accidental traceback after the first line if present
+    if "Traceback (most recent call last):" in s:
+        s = s.split("Traceback (most recent call last):")[0].strip()
+    return s.strip()
+
+def guardrails_preamble() -> str:
+    """
+    Instruction prefix to reduce PandasAI failure rates around datetime.
+    """
+    return (
+        "Rules for code you generate:\n"
+        "1) DO NOT use 'from datetime import datetime' or 'datetime.date.today()'.\n"
+        "2) Use pandas time APIs only: pd.Timestamp.now(tz='Africa/Harare'), pd.Timedelta, dt.floor/ceil.\n"
+        "3) If a 'Time' column exists, combine Date + Time and localize to 'Africa/Harare'.\n"
+        "4) Ensure numeric conversion with errors='coerce' for amounts.\n"
+        "5) Never print stack traces; always return a concise answer or a plot/dataframe."
+    )
+
+# -----------------------------------------------------------------------------
+# Analyst KPI layer (preserved with small safety tweaks)
+# -----------------------------------------------------------------------------
 class IrisReportEngine:
     def __init__(self, transactions_data: list, llm_instance):
         self.llm = llm_instance
@@ -71,227 +246,254 @@ class IrisReportEngine:
         self.currency = self._get_primary_currency()
 
     def _load_and_prepare_data(self, transactions: list) -> pd.DataFrame:
-        if not transactions: return pd.DataFrame()
+        if not transactions:
+            return pd.DataFrame()
         df = pd.DataFrame(transactions)
-        numeric_cols = ['Units_Sold', 'Unit_Cost_Price', 'Amount']
+
+        numeric_cols = ["Units_Sold", "Unit_Cost_Price", "Amount"]
         for col in numeric_cols:
-            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
-        df['datetime'] = pd.to_datetime(df['Date'] + ' ' + df['Time'], errors='coerce', utc=True)
-        df.dropna(subset=['datetime'], inplace=True)
-        df['DayOfWeek'] = df['datetime'].dt.day_name()
-        df['HourOfDay'] = df['datetime'].dt.hour
-        sales_df = df[df['Transaction_Type'].str.lower() == 'sale'].copy()
-        sales_df['Revenue'] = sales_df['Amount']
-        sales_df['CostOfGoods'] = sales_df['Unit_Cost_Price'] * sales_df['Units_Sold']
-        sales_df['GrossProfit'] = sales_df['Revenue'] - sales_df['CostOfGoods']
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0)
+
+        # Build datetime safely and localize
+        if "Time" in df.columns:
+            dt_series = pd.to_datetime(
+                df["Date"].astype(str) + " " + df["Time"].astype(str),
+                errors="coerce"
+            )
+        else:
+            dt_series = pd.to_datetime(df.get("Date"), errors="coerce")
+
+        try:
+            if getattr(dt_series.dt, "tz", None) is None:
+                dt_series = dt_series.dt.tz_localize(TZ, nonexistent="shift_forward", ambiguous="NaT")
+            else:
+                dt_series = dt_series.dt.tz_convert(TZ)
+        except Exception:
+            # keep naive if localization fails
+            pass
+
+        df["datetime"] = dt_series
+        df.dropna(subset=["datetime"], inplace=True)
+
+        df["DayOfWeek"] = df["datetime"].dt.day_name()
+        df["HourOfDay"] = df["datetime"].dt.hour
+
+        # sales-only view & basic profitability
+        if "Transaction_Type" in df.columns:
+            sales_df = df[df["Transaction_Type"].astype(str).str.lower() == "sale"].copy()
+        else:
+            sales_df = df.copy()
+
+        sales_df["Revenue"] = sales_df.get("Amount", 0)
+        if "Unit_Cost_Price" in sales_df.columns and "Units_Sold" in sales_df.columns:
+            sales_df["CostOfGoods"] = sales_df["Unit_Cost_Price"] * sales_df["Units_Sold"]
+        else:
+            sales_df["CostOfGoods"] = 0
+        sales_df["GrossProfit"] = sales_df["Revenue"] - sales_df["CostOfGoods"]
+
         return sales_df
 
     def _get_primary_currency(self) -> str:
-        return self.df['Currency'].mode()[0] if not self.df.empty and 'Currency' in self.df.columns and not self.df['Currency'].mode().empty else "USD"
-
-    def _get_comparison_timeframes(self) -> tuple[pd.DataFrame, pd.DataFrame, str]:
-        """Returns data for current week, previous week, and a label."""
-        now = datetime.now(timezone.utc)
-        end_of_current_week = now.replace(hour=23, minute=59, second=59)
-        start_of_current_week = (end_of_current_week - timedelta(days=now.weekday())).replace(hour=0, minute=0, second=0)
-        end_of_previous_week = start_of_current_week - timedelta(seconds=1)
-        start_of_previous_week = (end_of_previous_week - timedelta(days=6)).replace(hour=0, minute=0, second=0)
-        
-        current_period_df = self.df[(self.df['datetime'] >= start_of_current_week) & (self.df['datetime'] <= end_of_current_week)]
-        previous_period_df = self.df[(self.df['datetime'] >= start_of_previous_week) & (self.df['datetime'] <= end_of_previous_week)]
-        
-        return current_period_df, previous_period_df, "This Week vs. Last Week"
+        try:
+            if not self.df.empty and "Currency" in self.df.columns and not self.df["Currency"].mode().empty:
+                return str(self.df["Currency"].mode()[0])
+        except Exception:
+            pass
+        return "USD"
+
+    def _get_comparison_timeframes(self):
+        now = now_harare()
+        end_of_current_week = now.normalize() + pd.Timedelta(hours=23, minutes=59, seconds=59)
+        start_of_current_week = end_of_current_week - pd.Timedelta(days=end_of_current_week.weekday())
+        end_of_previous_week = start_of_current_week - pd.Timedelta(seconds=1)
+        start_of_previous_week = (end_of_previous_week - pd.Timedelta(days=6)).replace(hour=0, minute=0, second=0)
+        current_df = self.df[(self.df["datetime"] >= start_of_current_week) & (self.df["datetime"] <= end_of_current_week)]
+        previous_df = self.df[(self.df["datetime"] >= start_of_previous_week) & (self.df["datetime"] <= end_of_previous_week)]
+        return current_df, previous_df, "This Week vs. Last Week"
 
     def _calculate_headline_kpis(self, current_df, previous_df):
-        current_revenue = current_df['Revenue'].sum()
-        previous_revenue = previous_df['Revenue'].sum()
-        current_profit = current_df['GrossProfit'].sum()
-        previous_profit = previous_df['GrossProfit'].sum()
+        current_revenue = float(current_df["Revenue"].sum())
+        previous_revenue = float(previous_df["Revenue"].sum())
+        current_profit = float(current_df["GrossProfit"].sum())
+        previous_profit = float(previous_df["GrossProfit"].sum())
+
+        def pct_change(cur, prev):
+            if prev == 0:
+                return "+100%" if cur > 0 else "0.0%"
+            return f"{((cur - prev) / prev) * 100:+.1f}%"
 
-        def calc_change(current, previous):
-            if previous == 0: return "+100%" if current > 0 else "0.0%"
-            change = ((current - previous) / previous) * 100
-            return f"{change:+.1f}%"
+        tx_now = int(current_df.get("Invoice_Number", pd.Series()).nunique()) if "Invoice_Number" in current_df.columns else int(len(current_df))
+        tx_prev = int(previous_df.get("Invoice_Number", pd.Series()).nunique()) if "Invoice_Number" in previous_df.columns else int(len(previous_df))
 
         return {
-            "Total Revenue": f"{self.currency} {current_revenue:,.2f} ({calc_change(current_revenue, previous_revenue)})",
-            "Gross Profit": f"{self.currency} {current_profit:,.2f} ({calc_change(current_profit, previous_profit)})",
-            "Transactions": f"{current_df['Invoice_Number'].nunique()} ({calc_change(current_df['Invoice_Number'].nunique(), previous_df['Invoice_Number'].nunique())})"
+            "Total Revenue": f"{self.currency} {current_revenue:,.2f} ({pct_change(current_revenue, previous_revenue)})",
+            "Gross Profit": f"{self.currency} {current_profit:,.2f} ({pct_change(current_profit, previous_profit)})",
+            "Transactions": f"{tx_now} ({pct_change(tx_now, tx_prev)})"
         }
 
     def get_business_intelligence_briefing(self) -> dict:
-        if self.df.empty: return {"Status": "No sales data available to generate a briefing."}
-        
+        if self.df.empty:
+            return {"Status": "No sales data available to generate a briefing."}
+
         current_df, previous_df, summary_period = self._get_comparison_timeframes()
-        if current_df.empty: return {"Status": f"No sales data was found for the current period ({summary_period})."}
-
-        # --- KPI Calculations ---
-        headline_kpis = self._calculate_headline_kpis(current_df, previous_df)
-        
-        baskets = current_df.groupby('Invoice_Number').agg(BasketProfit=('GrossProfit', 'sum'), ItemsPerBasket=('Units_Sold', 'sum'))
-        
-        products_by_profit = current_df.groupby('Product')['GrossProfit'].sum()
-        products_by_units = current_df.groupby('Product')['Units_Sold'].sum()
-        
-        tellers_by_profit = current_df.groupby('Teller_Username')['GrossProfit'].sum()
-        
-        profit_by_hour = current_df.groupby('HourOfDay')['GrossProfit'].sum()
-
-        # --- BUG FIX: Handle single-entity cases ---
-        product_intelligence = {}
+        if current_df.empty:
+            return {"Status": f"No sales data was found for the current period ({summary_period})."}
+
+        headline = self._calculate_headline_kpis(current_df, previous_df)
+
+        baskets = current_df.groupby('Invoice_Number', dropna=True).agg(
+            BasketProfit=('GrossProfit', 'sum'),
+            ItemsPerBasket=('Units_Sold', 'sum')
+        ) if 'Invoice_Number' in current_df.columns else pd.DataFrame()
+
+        products_by_profit = current_df.groupby('Product')['GrossProfit'].sum() if 'Product' in current_df.columns else pd.Series(dtype=float)
+        products_by_units = current_df.groupby('Product')['Units_Sold'].sum() if 'Product' in current_df.columns and 'Units_Sold' in current_df.columns else pd.Series(dtype=float)
+        tellers_by_profit = current_df.groupby('Teller_Username')['GrossProfit'].sum() if 'Teller_Username' in current_df.columns else pd.Series(dtype=float)
+        profit_by_hour = current_df.groupby('HourOfDay')['GrossProfit'].sum() if 'HourOfDay' in current_df.columns else pd.Series(dtype=float)
+
+        product_intel = {}
         if len(products_by_profit) > 1:
-            product_intelligence = {
+            product_intel = {
                 "Best in Class (Most Profitable)": products_by_profit.idxmax(),
-                "Workhorse (Most Units Sold)": products_by_units.idxmax(),
-                "Underperformer (Least Profitable)": products_by_profit[products_by_profit > 0].idxmin() if not products_by_profit[products_by_profit > 0].empty else "N/A"
+                "Workhorse (Most Units Sold)": products_by_units.idxmax() if len(products_by_units) else "N/A",
+                "Underperformer (Least Profitable > 0)": (
+                    products_by_profit[products_by_profit > 0].idxmin()
+                    if not products_by_profit[products_by_profit > 0].empty else "N/A"
+                ),
             }
         elif not products_by_profit.empty:
-            product_intelligence = {"Only Product Sold": products_by_profit.index[0]}
-            
-        staff_intelligence = {}
+            product_intel = {"Only Product Sold": products_by_profit.index[0]}
+
+        staff_intel = {}
         if len(tellers_by_profit) > 1:
-            staff_intelligence = {"Top Performing Teller (by Profit)": tellers_by_profit.idxmax()}
+            staff_intel = {"Top Performing Teller (by Profit)": tellers_by_profit.idxmax()}
         elif not tellers_by_profit.empty:
-            staff_intelligence = {"Only Teller": tellers_by_profit.index[0]}
-
+            staff_intel = {"Only Teller": tellers_by_profit.index[0]}
 
         return {
             "Summary Period": summary_period,
-            "Performance Snapshot (vs. Prior Period)": headline_kpis,
+            "Performance Snapshot (vs. Prior Period)": headline,
             "Basket Analysis": {
-                "Average Profit per Basket": f"{self.currency} {baskets['BasketProfit'].mean():,.2f}",
-                "Average Items per Basket": f"{baskets['ItemsPerBasket'].mean():,.1f}"
+                "Average Profit per Basket": f"{self.currency} {float(baskets['BasketProfit'].mean()):,.2f}" if not baskets.empty else "N/A",
+                "Average Items per Basket": f"{float(baskets['ItemsPerBasket'].mean()):,.1f}" if not baskets.empty else "N/A",
             },
-            "Product Intelligence": product_intelligence,
+            "Product Intelligence": product_intel,
             "Staff & Operations": {
-                **staff_intelligence,
-                "Most Profitable Hour": f"{profit_by_hour.idxmax()}:00" if not profit_by_hour.empty else "N/A"
-            }
+                **staff_intel,
+                "Most Profitable Hour": (f"{int(profit_by_hour.idxmax())}:00" if not profit_by_hour.empty else "N/A"),
+            },
         }
 
     def synthesize_fallback_response(self, briefing: dict, user_question: str) -> str:
         fallback_prompt = f"""
-        You are Iris, an expert business data analyst. Answer the user's question using the comprehensive business data below.
-        
-        If their question is specific (like "sales yesterday", "top product", etc.), directly answer it using the data.
-        If you cannot find the specific information requested, provide a helpful business intelligence briefing instead.
-        
-        Structure your response with clear markdown headings and focus on actionable insights.
-        Always interpret percentage changes as business trends and provide context.
-        
-        User's Question: "{user_question}"
-        Business Data: {json.dumps(briefing, indent=2, ensure_ascii=False)}
-        """
-        response = self.llm.invoke(fallback_prompt)
-        return response.content if hasattr(response, 'content') else str(response)
+You are Iris, an expert business data analyst. Answer the user's question using the business data below.
 
-# REMOVED: No error detection function needed - Trust PandasAI completely, catch ALL exceptions silently
+If their question is specific (e.g., “sales yesterday”, “top product”), answer directly. 
+If the request can't be answered precisely, provide a helpful business briefing.
 
-# --- REFACTORED /chat Endpoint with Enhanced Error Detection ---
+Use clear markdown with short headings and bullets. Keep it concise.
+
+User Question: \"{user_question}\"
+Business Data: {json.dumps(briefing, indent=2, ensure_ascii=False)}
+"""
+        response = self.llm.invoke(fallback_prompt)
+        return response.content if hasattr(response, "content") else str(response)
+
+# -----------------------------------------------------------------------------
+# /chat — robust: never leak errors; always fallback
+# -----------------------------------------------------------------------------
 @app.route("/chat", methods=["POST"])
 @cross_origin()
 def bot():
     logger.info("=== Starting /chat endpoint ===")
     try:
-        # 1. Request Validation and Data Fetching
-        request_json = request.get_json()
-        profile_id = request_json.get("profile_id")
-        user_question = request_json.get("user_question")
-        if not profile_id or not user_question: return jsonify({"error": "Missing 'profile_id' or 'user_question'."}), 400
+        payload = request.get_json() or {}
+        profile_id = payload.get("profile_id")
+        user_question = payload.get("user_question")
+        if not profile_id or not user_question:
+            return jsonify({"answer": "Missing 'profile_id' or 'user_question'."})
 
+        # Fetch transactions
         API_URL = "https://irisplustech.com/public/api/business/profile/user/get-recent-transactions-v2"
-        response = requests.post(API_URL, data={'profile_id': urllib.parse.quote_plus(str(profile_id))}, timeout=30)
-        response.raise_for_status()
-        transactions = response.json().get("transactions")
-        if not transactions: return jsonify({"answer": "No transaction data was found for this profile."})
+        try:
+            resp = requests.post(
+                API_URL,
+                data={"profile_id": urllib.parse.quote_plus(str(profile_id))},
+                timeout=30
+            )
+            resp.raise_for_status()
+            transactions = (resp.json() or {}).get("transactions") or []
+        except Exception as e:
+            logger.exception("Transaction API error")
+            # Contained message (no stack to user)
+            return jsonify({"answer": "I couldn't reach the transactions service. Please try again shortly."})
+
+        if not transactions:
+            return jsonify({"answer": "No transaction data was found for this profile."})
 
-        # --- TIER 1 (DEFAULT): PANDASAI FIRST - WITH COMPREHENSIVE RESPONSE VALIDATION ---
+        # Tier 1 — PandasAI attempt (fully guarded)
         try:
-            logger.info("Attempting to answer with Tier 1 (PandasAI) - Full Trust Mode...")
+            logger.info("Attempting Tier 1 (PandasAI)...")
             df = pd.DataFrame(transactions)
-            
-            # FULL TRUST PANDASAI CONFIGURATION
+
+            # PandasAI config; ResponseParser ensures plots/dfs are serialized safely
             pandas_agent = SmartDataframe(df, config={
-                "llm": llm, 
+                "llm": llm,
                 "response_parser": FlaskResponse,
-                "custom_whitelisted_dependencies": [
-                    "os", "io", "sys", "chr", "glob", "b64decoder", "collections", 
-                    "geopy", "geopandas", "wordcloud", "builtins", "datetime", 
-                    "timedelta", "date", "pandas", "numpy", "math", "statistics",
-                    "matplotlib", "seaborn", "plotly", "json", "re", "warnings"
-                ],
+                # keep your settings; security = "none" as you had
                 "security": "none",
-                "save_charts_path": user_defined_path, 
-                "save_charts": False, 
-                "enable_cache": False, 
+                "save_charts_path": user_defined_path,
+                "save_charts": False,
+                "enable_cache": False,
                 "conversational": True,
-                "enable_logging": False
+                "enable_logging": False,
+                # keep deps list; we'll still hard-guard with prompt + fallback
+                "custom_whitelisted_dependencies": [
+                    "os","io","sys","chr","glob","b64decoder","collections",
+                    "geopy","geopandas","wordcloud","builtins","datetime",
+                    "timedelta","date","pandas","numpy","math","statistics",
+                    "matplotlib","seaborn","plotly","json","re","warnings"
+                ],
             })
-            
-            answer = pandas_agent.chat(user_question)
-            
-            # COMPREHENSIVE RESPONSE VALIDATION - Check if PandasAI actually succeeded
-            # PandasAI doesn't raise exceptions, it returns responses that may contain errors
-            is_valid_response = True
-            
-            # Check 1: Answer exists and is not empty
-            if answer is None or (isinstance(answer, str) and not answer.strip()):
-                is_valid_response = False
-            
-            # Check 2: Answer doesn't contain error indicators (PandasAI returns these as strings)
-            elif isinstance(answer, str):
-                error_patterns = [
-                    'keyerror', 'traceback', 'exception', 'error occurred', 
-                    'failed', 'unable to', 'cannot', '__import__', 'importerror',
-                    'modulenotfounderror', 'nameerror', 'syntaxerror',
-                    'pipeline failed', 'execution failed'
-                ]
-                answer_lower = answer.lower()
-                if any(pattern in answer_lower for pattern in error_patterns):
-                    is_valid_response = False
-                    
-                # Also check for stack traces or error messages that slip through
-                if 'file "<string>"' in answer_lower or 'line ' in answer_lower and 'error' in answer_lower:
-                    is_valid_response = False
-            
-            # Check 3: For specific error objects that might be returned
-            elif hasattr(answer, '__class__') and 'error' in str(type(answer)).lower():
-                is_valid_response = False
-            
-            if is_valid_response:
-                logger.info("Successfully answered with Tier 1 (PandasAI).")
-                formatted_answer = str(answer)
-                if isinstance(answer, pd.DataFrame): 
-                    formatted_answer = answer.to_html()
-                elif isinstance(answer, plt.Figure):
-                    buf = io.BytesIO()
-                    answer.savefig(buf, format="png")
-                    formatted_answer = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode('utf-8')}"
-                return jsonify({"answer": formatted_answer})
-            else:
-                logger.info("PandasAI response contains error indicators, using analyst layer")
-        
+
+            # Prepend guardrails + temporal hints
+            combined_prompt = f"{guardrails_preamble()}\n\n{temporal_hints(user_question)}\n\nQuestion: {user_question}"
+            answer = pandas_agent.chat(combined_prompt)
+
+            if looks_like_error(answer):
+                logger.warning("PandasAI returned an invalid/errored answer; activating analyst fallback.")
+                raise RuntimeError("PandasAI invalid answer")
+
+            # Successful Tier 1
+            if isinstance(answer, pd.DataFrame):
+                return jsonify({"answer": answer.to_html(), "meta": {"source": "pandasai"}})
+            if isinstance(answer, plt.Figure):
+                buf = io.BytesIO()
+                answer.savefig(buf, format="png")
+                data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode('utf-8')}"
+                return jsonify({"answer": data_uri, "meta": {"source": "pandasai"}})
+
+            return jsonify({"answer": sanitize_answer(answer), "meta": {"source": "pandasai"}})
+
         except Exception as e:
-            # This catches any actual exceptions that might escape PandasAI
-            logger.info(f"PandasAI raised exception, seamlessly switching to analyst layer: {type(e).__name__}")
-            pass
-        
-        # --- TIER 2 (SEAMLESS FALLBACK): COMPREHENSIVE KPI ANALYST ---
-        logger.info("Seamlessly providing intelligence via IrisReportEngine analyst layer.")
+            # Log *everything*, return nothing noisy to user
+            logger.exception("Tier 1 (PandasAI) failed; moving to analyst layer.")
+
+        # Tier 2 — Analyst KPI fallback (guaranteed)
         engine = IrisReportEngine(transactions_data=transactions, llm_instance=llm)
         briefing = engine.get_business_intelligence_briefing()
         fallback_answer = engine.synthesize_fallback_response(briefing, user_question)
-        return jsonify({"answer": fallback_answer})
+        return jsonify({"answer": sanitize_answer(fallback_answer), "meta": {"source": "analyst_fallback"}})
 
-    except requests.exceptions.RequestException as e:
-        logger.error(f"API connection error: {e}")
-        return jsonify({"error": "Could not connect to the transaction API.", "details": str(e)}), 503
-    except Exception as e:
-        # TIER 3 (FINAL SAFETY NET)
-        logger.exception("A critical unexpected error occurred in /chat endpoint")
-        return jsonify({"error": "An unexpected server error occurred.", "details": str(e)}), 500
+    except Exception:
+        logger.exception("Critical unexpected error in /chat")
+        # Final safety message (no tracebacks to user)
+        return jsonify({"answer": "Something went wrong on our side. Please try again."})
 
-# --- UNCHANGED ENDPOINTS ---
+# -----------------------------------------------------------------------------
+# Other endpoints (unchanged)
+# -----------------------------------------------------------------------------
 @app.route("/report", methods=["POST"])
 @cross_origin()
 def busines_report():
@@ -299,7 +501,12 @@ def busines_report():
     try:
         request_json = request.get_json()
         json_data = request_json.get("json_data") if request_json else None
-        prompt = "You are Quantilytix business analyst. Analyze the following data and generate a comprehensive and insightful business report, including appropriate key perfomance indicators and recommendations Use markdown formatting and tables where necessary. only return the report and nothing else.\ndata:\n" + str(json_data)
+        prompt = (
+            "You are Quantilytix business analyst. Analyze the following data and generate a "
+            "comprehensive and insightful business report, including appropriate key perfomance "
+            "indicators and recommendations Use markdown formatting and tables where necessary. "
+            "only return the report and nothing else.\ndata:\n" + str(json_data)
+        )
         response = model.generate_content(prompt)
         return jsonify(str(response.text))
     except Exception as e:
@@ -313,7 +520,10 @@ def marketing():
     try:
         request_json = request.get_json()
         json_data = request_json.get("json_data") if request_json else None
-        prompt = "You are an Quantilytix Marketing Specialist. Analyze the following data and generate a comprehensive marketing strategy, Only return the marketing strategy. be very creative:\n" + str(json_data)
+        prompt = (
+            "You are an Quantilytix Marketing Specialist. Analyze the following data and generate "
+            "a comprehensive marketing strategy, Only return the marketing strategy. be very creative:\n" + str(json_data)
+        )
         response = model.generate_content(prompt)
         return jsonify(str(response.text))
     except Exception as e:
@@ -327,7 +537,10 @@ def notifications():
     try:
         request_json = request.get_json()
         json_data = request_json.get("json_data") if request_json else None
-        prompt = "You are Quantilytix business analyst. Write a very brief analysis and marketing tips using this business data. your output should be suitable for a notification dashboard so no quips.\n" + str(json_data)
+        prompt = (
+            "You are Quantilytix business analyst. Write a very brief analysis and marketing tips "
+            "using this business data. your output should be suitable for a notification dashboard so no quips.\n" + str(json_data)
+        )
         response = model.generate_content(prompt)
         return jsonify(str(response.text))
     except Exception as e: