admin

app/ai/agent/brain.py

@@ -4,6 +4,7 @@ AIDA Agent Brain - The LLM that reasons and decides actions.
 This is the core of the true AI agent architecture.
 """
 
+import asyncio
 import json
 import re
 from typing import Dict, Any, Optional, List, Tuple, Literal
@@ -916,6 +917,22 @@ async def brain_decide(state: AgentState) -> BrainDecision:
             tier=tier,
         )
 
+        # Fire-and-forget: record token usage for cost analytics
+        _usage = result.get("usage") or {}
+        if _usage.get("total_tokens"):
+            from app.ai.token_tracker import record_token_event
+            asyncio.create_task(record_token_event(
+                model=result.get("model") or (
+                    "deepseek-v4-pro" if tier == "premium" else "deepseek-v4-flash"
+                ),
+                tokens_in=_usage.get("prompt_tokens", 0),
+                tokens_out=_usage.get("completion_tokens", 0),
+                feature="brain_decide",
+                agent=state.active_agent or "general",
+                user_id=getattr(state, "user_id", None),
+                session_id=getattr(state, "session_id", None),
+            ))
+
         tool_calls = result.get("tool_calls")
         content = (result.get("content") or "").strip()
 

app/ai/token_tracker.py

@@ -0,0 +1,80 @@
+# app/ai/token_tracker.py
+"""
+Fire-and-forget token usage recorder.
+
+Call record_token_event() after any LLM response that includes usage data.
+Writes to the `ai_token_events` collection for cost analytics.
+
+Schema per document:
+  user_id        str | None
+  session_id     str | None
+  agent          str             e.g. "general", "broker", "matcher"
+  feature        str             e.g. "brain_decide", "generate_response"
+  model          str             e.g. "deepseek-v4-flash"
+  tokens_in      int
+  tokens_out     int
+  tokens_total   int
+  cost_usd       float           estimated from MODEL_COSTS table
+  ts             datetime (UTC)
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+# Cost per million tokens (USD) — update when provider pricing changes
+MODEL_COSTS: dict[str, dict[str, float]] = {
+    "deepseek-v4-flash": {"input": 0.27,   "output": 1.10},
+    "deepseek-v4-pro":   {"input": 0.55,   "output": 2.19},
+    "gemini-2.5-pro":    {"input": 1.25,   "output": 5.00},
+    "gemini-pro":        {"input": 1.25,   "output": 5.00},
+    "gemini-2.5-flash":  {"input": 0.075,  "output": 0.30},
+    "gemini-flash":      {"input": 0.075,  "output": 0.30},
+    "mimo-v2-omni":      {"input": 0.50,   "output": 1.50},
+}
+_DEFAULT_COST = {"input": 0.50, "output": 1.50}
+
+
+def _estimate_cost(model: str, tokens_in: int, tokens_out: int) -> float:
+    rates = MODEL_COSTS.get(model) or MODEL_COSTS.get(model.split("/")[-1]) or _DEFAULT_COST
+    return round(
+        (tokens_in  / 1_000_000) * rates["input"] +
+        (tokens_out / 1_000_000) * rates["output"],
+        8,
+    )
+
+
+async def record_token_event(
+    *,
+    model: str,
+    tokens_in: int,
+    tokens_out: int,
+    feature: str = "unknown",
+    agent: str = "general",
+    user_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+) -> None:
+    """
+    Write one token-usage event to MongoDB. Non-critical — never raises.
+    Call with asyncio.create_task() so it never blocks the response path.
+    """
+    try:
+        from app.database import get_db
+        db = await get_db()
+        cost = _estimate_cost(model, tokens_in, tokens_out)
+        await db["ai_token_events"].insert_one({
+            "user_id":      user_id,
+            "session_id":   session_id,
+            "agent":        agent,
+            "feature":      feature,
+            "model":        model,
+            "tokens_in":    tokens_in,
+            "tokens_out":   tokens_out,
+            "tokens_total": tokens_in + tokens_out,
+            "cost_usd":     cost,
+            "ts":           datetime.now(timezone.utc),
+        })
+    except Exception as exc:
+        logger.warning("token_tracker: insert failed", error=str(exc)[:200])

app/core/error_store.py

@@ -0,0 +1,62 @@
+# app/core/error_store.py
+"""
+Fire-and-forget error log recorder.
+
+Call record_error() anywhere an exception is caught and you want full
+context stored in MongoDB for the admin dashboard error-log view.
+
+Schema per document:
+  error_type     str             exception class name
+  error_msg      str             str(exc)
+  stack_trace    str             full traceback
+  agent          str | None
+  tool           str | None
+  feature        str | None
+  user_id        str | None
+  session_id     str | None
+  input_preview  str | None      first 500 chars of the triggering input
+  resolved       bool            default False — admin can mark True
+  ts             datetime (UTC)
+"""
+
+import traceback
+from datetime import datetime, timezone
+from typing import Optional
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+async def record_error(
+    exc: Exception,
+    *,
+    agent: Optional[str] = None,
+    tool: Optional[str] = None,
+    feature: Optional[str] = None,
+    user_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    input_preview: Optional[str] = None,
+) -> None:
+    """
+    Write one error event to MongoDB. Non-critical — never raises.
+    Call with asyncio.create_task() so it never blocks the response path.
+    """
+    try:
+        from app.database import get_db
+        db = await get_db()
+        tb = traceback.format_exc() or ""
+        await db["error_logs"].insert_one({
+            "error_type":    type(exc).__name__,
+            "error_msg":     str(exc)[:1000],
+            "stack_trace":   tb[:5000],
+            "agent":         agent,
+            "tool":          tool,
+            "feature":       feature,
+            "user_id":       user_id,
+            "session_id":    session_id,
+            "input_preview": (input_preview or "")[:500] if input_preview else None,
+            "resolved":      False,
+            "ts":            datetime.now(timezone.utc),
+        })
+    except Exception as inner:
+        logger.warning("error_store: insert failed", error=str(inner)[:200])

app/core/mimo_client.py

@@ -398,6 +398,7 @@ class MiMoClient:
             "content": content,
             "tool_calls": tool_calls,
             "usage": usage,
+            "model": model,
             "finish_reason": choice.finish_reason,
         }
 

app/models/conversation.py

@@ -22,6 +22,7 @@ class Conversation:
         participants: list[str],
         listing_title: str,
         listing_image: str,
+        listing_type: str = None,
     ) -> dict:
         """Create conversation document for insertion"""
         now = datetime.utcnow()
@@ -29,9 +30,10 @@ class Conversation:
         # This enables proper unique indexing without multikey issues
         sorted_participants = sorted(participants)
         participants_key = "::".join(sorted_participants)
-        
+
         return {
             "listing_id": listing_id,
+            "listing_type": listing_type,          # stored for analytics — chat rate by type
             "participants": sorted_participants,  # Array of 2 user IDs (sorted)
             "participants_key": participants_key,  # Unique key for the pair
             "listing_title": listing_title,

app/routes/admin_metrics.py

@@ -11,6 +11,8 @@ Endpoints (all under /api/admin):
   GET /metrics/trust         Deactivated users, high-volume accounts, reports
   GET /metrics/system        AI engine health from aida_traces (live window)
   GET /metrics/summary       All high-level KPIs in one call (dashboard overview)
+  GET /metrics/ai/tokens     Token burn analytics: cost by model/feature/user, daily trend
+  GET /metrics/ai/errors     Error log browser: paginated, filterable, with stack traces
 
 All time-range endpoints accept ?days=N (default 30, max 365).
 Marketplace + listing endpoints accept ?city=<partial> for location filtering.
@@ -171,8 +173,15 @@ async def metrics_listings(
     admin: dict = Depends(require_admin),
 ):
     """
-    Listing engagement: city distribution, type breakdown, top viewed,
-    conversion rate (confirmed bookings / active listings), and daily trend.
+    Listing engagement: views, chat click rate, city/type breakdown, and funnels.
+
+    Key metrics:
+      - total_views: sum of view_count across all listings (incremented on each detail open)
+      - views_by_type: views broken down by listing_type
+      - chat_clicks_by_type: conversations started per listing_type
+      - chat_rate_by_type: chat_clicks / views per type  — the real conversion for long-term
+      - short_stay_booking_rate: bookings / views for short-stay only
+      - top_viewed: 10 most-opened listings
     """
     db = await get_db()
     since = _since(days)
@@ -180,13 +189,18 @@ async def metrics_listings(
     if city:
         base["location"] = {"$regex": city, "$options": "i"}
 
+    long_term_types = ["rent", "sale", "roommate"]
+    short_stay_type = "short-stay"
+
     (
         total,
         active_cnt,
         city_agg,
         type_agg,
         new_trend_agg,
-        confirmed_bookings,
+        views_by_type_agg,
+        chat_by_type_agg,
+        short_stay_bookings,
     ) = await asyncio.gather(
         db.listings.count_documents(base),
         db.listings.count_documents({**base, "status": "active"}),
@@ -208,29 +222,74 @@ async def metrics_listings(
                 "count": {"$sum": 1},
             }},
         ]).to_list(400),
+        # Total views per listing_type (sum of view_count field)
+        db.listings.aggregate([
+            {"$match": base},
+            {"$group": {
+                "_id": "$listing_type",
+                "total_views": {"$sum": {"$ifNull": ["$view_count", 0]}},
+                "listing_count": {"$sum": 1},
+                "avg_views": {"$avg": {"$ifNull": ["$view_count", 0]}},
+            }},
+        ]).to_list(10),
+        # Chat button clicks (conversations started) per listing_type in this period
+        # listing_type is stored on conversation since the model update
+        db.conversations.aggregate([
+            {"$match": {
+                "created_at": {"$gte": since},
+                "listing_id": {"$ne": "system"},
+                "listing_type": {"$exists": True, "$ne": None},
+            }},
+            {"$group": {"_id": "$listing_type", "count": {"$sum": 1}}},
+        ]).to_list(10),
+        # Short-stay bookings for booking rate
         db.bookings.count_documents({
             "status": {"$in": ["confirmed", "completed"]},
             "created_at": {"$gte": since},
         }),
     )
 
-    # Top viewed — graceful if view_count field absent
+    # Build views lookup by type
+    views_by_type = {d["_id"]: d for d in views_by_type_agg if d["_id"]}
+    chat_by_type = {(d["_id"] or "unknown"): d["count"] for d in chat_by_type_agg}
+
+    # Compute per-type chat rate
+    chat_rate_by_type = {}
+    for lt, vdata in views_by_type.items():
+        views = vdata["total_views"]
+        chats = chat_by_type.get(lt, 0)
+        chat_rate_by_type[lt] = round(chats / views * 100, 2) if views else 0.0
+
+    # Aggregate totals
+    total_views = sum(d["total_views"] for d in views_by_type.values())
+    total_chat_clicks = sum(chat_by_type.values())
+    overall_chat_rate = round(total_chat_clicks / total_views * 100, 2) if total_views else 0.0
+
+    # Long-term funnel (rent + sale + roommate): views → chats
+    lt_views = sum(views_by_type.get(t, {}).get("total_views", 0) for t in long_term_types)
+    lt_chats = sum(chat_by_type.get(t, 0) for t in long_term_types)
+
+    # Short-stay funnel: views → chats → bookings
+    ss_views = views_by_type.get(short_stay_type, {}).get("total_views", 0)
+    ss_chats = chat_by_type.get(short_stay_type, 0)
+
+    # Top viewed listings
     top_viewed = []
     try:
         cursor = db.listings.find(
-            {**base, "status": "active"},
-            {"title": 1, "location": 1, "view_count": 1, "listing_type": 1},
+            {**base, "view_count": {"$gt": 0}},
+            {"title": 1, "location": 1, "view_count": 1, "listing_type": 1, "status": 1},
         ).sort("view_count", -1).limit(10)
         async for doc in cursor:
-            vc = doc.get("view_count", 0) or 0
-            if vc > 0:
-                top_viewed.append({
-                    "id": str(doc["_id"]),
-                    "title": doc.get("title", "Untitled"),
-                    "location": doc.get("location"),
-                    "listing_type": doc.get("listing_type"),
-                    "view_count": vc,
-                })
+            top_viewed.append({
+                "id": str(doc["_id"]),
+                "title": doc.get("title", "Untitled"),
+                "location": doc.get("location"),
+                "listing_type": doc.get("listing_type"),
+                "status": doc.get("status"),
+                "view_count": doc.get("view_count", 0),
+                "chat_count": chat_by_type.get(doc.get("listing_type"), 0),
+            })
     except Exception:
         pass
 
@@ -239,14 +298,43 @@ async def metrics_listings(
         "data": {
             "total_listings": total,
             "active_listings": active_cnt,
-            "conversion_rate": round(confirmed_bookings / active_cnt * 100, 2) if active_cnt else 0.0,
-            "confirmed_bookings_period": confirmed_bookings,
+            # ── View metrics ──────────────────────────────────────────────
+            "total_views": total_views,
+            "total_chat_clicks": total_chat_clicks,
+            "overall_chat_rate": overall_chat_rate,
+            # ── Per-type breakdown ────────────────────────────────────────
+            "views_by_type": {
+                lt: {
+                    "views": d["total_views"],
+                    "listings": d["listing_count"],
+                    "avg_views_per_listing": round(d["avg_views"], 1),
+                    "chat_clicks": chat_by_type.get(lt, 0),
+                    "chat_rate": chat_rate_by_type.get(lt, 0.0),
+                }
+                for lt, d in views_by_type.items()
+            },
+            # ── Funnel by rental model ────────────────────────────────────
+            "long_term_funnel": {
+                "types": long_term_types,
+                "views": lt_views,
+                "chat_clicks": lt_chats,
+                "chat_rate": round(lt_chats / lt_views * 100, 2) if lt_views else 0.0,
+                "note": "Conversion = chat click. No booking step for long-term.",
+            },
+            "short_stay_funnel": {
+                "views": ss_views,
+                "chat_clicks": ss_chats,
+                "bookings": short_stay_bookings,
+                "chat_rate": round(ss_chats / ss_views * 100, 2) if ss_views else 0.0,
+                "booking_rate": round(short_stay_bookings / ss_views * 100, 2) if ss_views else 0.0,
+            },
+            # ── Lists ─────────────────────────────────────────────────────
+            "top_viewed": top_viewed,
             "top_cities": [
                 {"city": d["_id"] or "Unknown", "count": d["count"]}
                 for d in city_agg if d["_id"]
             ],
             "type_breakdown": {(d["_id"] or "unknown"): d["count"] for d in type_agg},
-            "top_viewed": top_viewed,
             "new_listings_trend": _daily_trend(new_trend_agg, days),
         },
     }
@@ -528,8 +616,13 @@ async def metrics_marketplace(
     admin: dict = Depends(require_admin),
 ):
     """
-    Marketplace health: conversation volume, viewing pipeline, booking
-    pipeline, conversion funnel, and top active cities.
+    Marketplace health with two separate funnels:
+
+    Long-term rentals (rent / sale / roommate):
+      Views → Chat clicks  ← this is the conversion, no booking step
+
+    Short-stay:
+      Views → Chat clicks → Bookings
     """
     db = await get_db()
     since = _since(days)
@@ -537,18 +630,30 @@ async def metrics_marketplace(
     if city:
         listing_base["location"] = {"$regex": city, "$options": "i"}
 
+    long_term_types = ["rent", "sale", "roommate"]
+
     (
-        total_chats,
+        chat_by_type_agg,
         chat_trend_agg,
         total_viewings,
         viewing_status_agg,
-        total_bookings,
         booking_status_agg,
         top_cities_agg,
+        views_by_type_agg,
     ) = await asyncio.gather(
-        db.conversations.count_documents({"created_at": {"$gte": since}}),
+        # Chat clicks (conversation starts) by listing_type
         db.conversations.aggregate([
-            {"$match": {"created_at": {"$gte": since}}},
+            {"$match": {
+                "created_at": {"$gte": since},
+                "listing_id": {"$ne": "system"},
+            }},
+            {"$group": {
+                "_id": "$listing_type",   # stored since model update; None for legacy rows
+                "count": {"$sum": 1},
+            }},
+        ]).to_list(10),
+        db.conversations.aggregate([
+            {"$match": {"created_at": {"$gte": since}, "listing_id": {"$ne": "system"}}},
             {"$group": {
                 "_id": {"$dateToString": {"format": "%Y-%m-%d", "date": "$created_at"}},
                 "count": {"$sum": 1},
@@ -559,7 +664,6 @@ async def metrics_marketplace(
             {"$match": {"created_at": {"$gte": since}}},
             {"$group": {"_id": "$status", "count": {"$sum": 1}}},
         ]).to_list(10),
-        db.bookings.count_documents({"created_at": {"$gte": since}}),
         db.bookings.aggregate([
             {"$match": {"created_at": {"$gte": since}}},
             {"$group": {"_id": "$status", "count": {"$sum": 1}}},
@@ -570,27 +674,60 @@ async def metrics_marketplace(
             {"$sort": {"count": -1}},
             {"$limit": 10},
         ]).to_list(10),
+        # Total views per listing_type (from view_count field)
+        db.listings.aggregate([
+            {"$match": {"view_count": {"$gt": 0}}},
+            {"$group": {
+                "_id": "$listing_type",
+                "total_views": {"$sum": "$view_count"},
+            }},
+        ]).to_list(10),
     )
 
+    chat_by_type = {(d["_id"] or "unknown"): d["count"] for d in chat_by_type_agg}
     viewing_map = {(d["_id"] or "unknown"): d["count"] for d in viewing_status_agg}
     booking_map = {(d["_id"] or "unknown"): d["count"] for d in booking_status_agg}
-    confirmed = booking_map.get("confirmed", 0) + booking_map.get("completed", 0)
+    views_by_type = {d["_id"]: d["total_views"] for d in views_by_type_agg if d["_id"]}
+
+    confirmed_bookings = booking_map.get("confirmed", 0) + booking_map.get("completed", 0)
     scheduled_viewings = viewing_map.get("scheduled", 0) + viewing_map.get("confirmed", 0)
 
+    # Long-term funnel: views → chat clicks (conversion = chat rate)
+    lt_views = sum(views_by_type.get(t, 0) for t in long_term_types)
+    lt_chats = sum(chat_by_type.get(t, 0) for t in long_term_types)
+
+    # Short-stay funnel: views → chat clicks → bookings
+    ss_views = views_by_type.get("short-stay", 0)
+    ss_chats = chat_by_type.get("short-stay", 0)
+
+    total_chats = sum(chat_by_type.values())
+    total_views = sum(views_by_type.values())
+
     return {
         "success": True,
         "data": {
-            "total_chats": total_chats,
+            "total_chat_clicks": total_chats,
+            "total_views": total_views,
             "total_viewings": total_viewings,
             "scheduled_viewings": scheduled_viewings,
-            "total_bookings": total_bookings,
-            "confirmed_bookings": confirmed,
-            "conversion_rate": round(confirmed / total_chats * 100, 2) if total_chats else 0.0,
-            "funnel": {
-                "chats": total_chats,
-                "viewings": total_viewings,
-                "bookings": confirmed,
+            "confirmed_bookings": confirmed_bookings,
+            # ── Funnels ───────────────────────────────────────────────────
+            "long_term_funnel": {
+                "label": "Long-term (Rent / Sale / Roommate)",
+                "views": lt_views,
+                "chat_clicks": lt_chats,
+                "chat_rate": round(lt_chats / lt_views * 100, 2) if lt_views else 0.0,
             },
+            "short_stay_funnel": {
+                "label": "Short-stay",
+                "views": ss_views,
+                "chat_clicks": ss_chats,
+                "bookings": confirmed_bookings,
+                "chat_rate": round(ss_chats / ss_views * 100, 2) if ss_views else 0.0,
+                "booking_rate": round(confirmed_bookings / ss_views * 100, 2) if ss_views else 0.0,
+            },
+            # ── Breakdowns ────────────────────────────────────────────────
+            "chat_by_type": chat_by_type,
             "viewing_by_status": viewing_map,
             "booking_by_status": booking_map,
             "top_cities": [
@@ -812,3 +949,304 @@ async def metrics_summary(
             },
         },
     }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# TOKEN & COST ANALYTICS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@router.get("/metrics/ai/tokens")
+async def metrics_ai_tokens(
+    days: int = Query(30, ge=1, le=365),
+    admin: dict = Depends(require_admin),
+):
+    """
+    Token burn analytics from ai_token_events collection.
+
+    Returns:
+    - Total tokens and cost for the period
+    - Daily cost trend (dense, gap-filled)
+    - Breakdown by model (tokens + cost)
+    - Breakdown by feature/action (cost ranking — shows what burns most)
+    - Top 10 users by spend
+    - Per-model cost rates reference
+    """
+    db = await get_db()
+    since = _since(days)
+    coll = db["ai_token_events"]
+
+    (
+        totals_agg,
+        by_model_agg,
+        by_feature_agg,
+        top_users_agg,
+        daily_cost_agg,
+        prev_total_agg,
+    ) = await asyncio.gather(
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id": None,
+                "tokens_in":    {"$sum": "$tokens_in"},
+                "tokens_out":   {"$sum": "$tokens_out"},
+                "tokens_total": {"$sum": "$tokens_total"},
+                "cost_usd":     {"$sum": "$cost_usd"},
+                "requests":     {"$sum": 1},
+            }},
+        ]).to_list(1),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id":          "$model",
+                "tokens_in":    {"$sum": "$tokens_in"},
+                "tokens_out":   {"$sum": "$tokens_out"},
+                "tokens_total": {"$sum": "$tokens_total"},
+                "cost_usd":     {"$sum": "$cost_usd"},
+                "requests":     {"$sum": 1},
+            }},
+            {"$sort": {"cost_usd": -1}},
+        ]).to_list(20),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id":          "$feature",
+                "tokens_total": {"$sum": "$tokens_total"},
+                "cost_usd":     {"$sum": "$cost_usd"},
+                "requests":     {"$sum": 1},
+                "avg_tokens":   {"$avg": "$tokens_total"},
+            }},
+            {"$sort": {"cost_usd": -1}},
+            {"$limit": 20},
+        ]).to_list(20),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}, "user_id": {"$ne": None}}},
+            {"$group": {
+                "_id":      "$user_id",
+                "cost_usd": {"$sum": "$cost_usd"},
+                "tokens":   {"$sum": "$tokens_total"},
+                "requests": {"$sum": 1},
+            }},
+            {"$sort": {"cost_usd": -1}},
+            {"$limit": 10},
+            {"$lookup": {
+                "from":         "users",
+                "let":          {"uid": "$_id"},
+                "pipeline": [
+                    {"$match": {"$expr": {"$eq": [{"$toString": "$_id"}, "$$uid"]}}},
+                    {"$project": {"display_name": 1, "email": 1}},
+                ],
+                "as": "user_info",
+            }},
+        ]).to_list(10),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id":      {"$dateToString": {"format": "%Y-%m-%d", "date": "$ts"}},
+                "cost_usd": {"$sum": "$cost_usd"},
+                "tokens":   {"$sum": "$tokens_total"},
+                "requests": {"$sum": 1},
+            }},
+        ]).to_list(400),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": _since(days * 2), "$lt": since}}},
+            {"$group": {"_id": None, "cost_usd": {"$sum": "$cost_usd"}}},
+        ]).to_list(1),
+    )
+
+    t = totals_agg[0] if totals_agg else {}
+    prev_cost = (prev_total_agg[0] or {}).get("cost_usd", 0) if prev_total_agg else 0
+    current_cost = t.get("cost_usd", 0) or 0
+    cost_growth_pct = (
+        round((current_cost - prev_cost) / prev_cost * 100, 1) if prev_cost else 0.0
+    )
+
+    # Build dense daily trend with both cost and token columns
+    now = datetime.now(timezone.utc)
+    daily_buckets: dict = {}
+    for i in range(days - 1, -1, -1):
+        day = (now - timedelta(days=i)).strftime("%Y-%m-%d")
+        daily_buckets[day] = {"date": day, "cost_usd": 0.0, "tokens": 0, "requests": 0}
+    for doc in daily_cost_agg:
+        day = doc.get("_id")
+        if day and day in daily_buckets:
+            daily_buckets[day]["cost_usd"] = round(doc.get("cost_usd", 0) or 0, 6)
+            daily_buckets[day]["tokens"] = int(doc.get("tokens", 0) or 0)
+            daily_buckets[day]["requests"] = int(doc.get("requests", 0) or 0)
+
+    # Top users: extract first user_info doc for name/email
+    top_users = []
+    for u in top_users_agg:
+        info = u.get("user_info", [{}])
+        info = info[0] if info else {}
+        top_users.append({
+            "user_id":    u["_id"],
+            "name":       info.get("display_name", "Unknown"),
+            "email":      info.get("email"),
+            "cost_usd":   round(u.get("cost_usd", 0) or 0, 6),
+            "tokens":     int(u.get("tokens", 0) or 0),
+            "requests":   int(u.get("requests", 0) or 0),
+        })
+
+    return {
+        "success": True,
+        "data": {
+            "period_days": days,
+            "totals": {
+                "tokens_in":    int(t.get("tokens_in", 0) or 0),
+                "tokens_out":   int(t.get("tokens_out", 0) or 0),
+                "tokens_total": int(t.get("tokens_total", 0) or 0),
+                "cost_usd":     round(current_cost, 4),
+                "requests":     int(t.get("requests", 0) or 0),
+                "cost_growth_pct": cost_growth_pct,
+            },
+            "by_model": [
+                {
+                    "model":        d.get("_id", "unknown"),
+                    "tokens_total": int(d.get("tokens_total", 0) or 0),
+                    "tokens_in":    int(d.get("tokens_in", 0) or 0),
+                    "tokens_out":   int(d.get("tokens_out", 0) or 0),
+                    "cost_usd":     round(d.get("cost_usd", 0) or 0, 4),
+                    "requests":     int(d.get("requests", 0) or 0),
+                }
+                for d in by_model_agg
+            ],
+            "by_feature": [
+                {
+                    "feature":      d.get("_id", "unknown"),
+                    "tokens_total": int(d.get("tokens_total", 0) or 0),
+                    "cost_usd":     round(d.get("cost_usd", 0) or 0, 4),
+                    "requests":     int(d.get("requests", 0) or 0),
+                    "avg_tokens":   int(d.get("avg_tokens", 0) or 0),
+                }
+                for d in by_feature_agg
+            ],
+            "top_users_by_spend": top_users,
+            "daily_trend": list(daily_buckets.values()),
+        },
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ERROR LOG ANALYTICS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@router.get("/metrics/ai/errors")
+async def metrics_ai_errors(
+    days: int = Query(7, ge=1, le=90),
+    page: int = Query(1, ge=1),
+    page_size: int = Query(50, ge=1, le=200),
+    error_type: Optional[str] = Query(None, description="Filter by exception class name"),
+    agent: Optional[str] = Query(None, description="Filter by agent name"),
+    resolved: Optional[bool] = Query(None, description="Filter by resolved status"),
+    admin: dict = Depends(require_admin),
+):
+    """
+    Error log browser with full context for debugging.
+
+    Returns:
+    - Paginated recent errors (with stack traces)
+    - Error type breakdown (frequency ranking)
+    - Affected users count
+    - Daily error trend
+    - Unresolved count
+    """
+    db = await get_db()
+    since = _since(days)
+    coll = db["error_logs"]
+
+    match: dict = {"ts": {"$gte": since}}
+    if error_type:
+        match["error_type"] = {"$regex": error_type, "$options": "i"}
+    if agent:
+        match["agent"] = {"$regex": agent, "$options": "i"}
+    if resolved is not None:
+        match["resolved"] = resolved
+
+    skip = (page - 1) * page_size
+
+    (
+        total_count,
+        unresolved_count,
+        by_type_agg,
+        affected_users,
+        daily_agg,
+        docs,
+    ) = await asyncio.gather(
+        coll.count_documents(match),
+        coll.count_documents({**match, "resolved": False}),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id":   "$error_type",
+                "count": {"$sum": 1},
+                "last_seen": {"$max": "$ts"},
+                "agents": {"$addToSet": "$agent"},
+            }},
+            {"$sort": {"count": -1}},
+            {"$limit": 20},
+        ]).to_list(20),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}, "user_id": {"$ne": None}}},
+            {"$group": {"_id": "$user_id"}},
+            {"$count": "total"},
+        ]).to_list(1),
+        coll.aggregate([
+            {"$match": {"ts": {"$gte": since}}},
+            {"$group": {
+                "_id":   {"$dateToString": {"format": "%Y-%m-%d", "date": "$ts"}},
+                "count": {"$sum": 1},
+            }},
+        ]).to_list(100),
+        coll.find(match)
+            .sort("ts", -1)
+            .skip(skip)
+            .limit(page_size)
+            .to_list(page_size),
+    )
+
+    # Serialize docs
+    error_list = []
+    for doc in docs:
+        error_list.append({
+            "id":            str(doc["_id"]),
+            "error_type":    doc.get("error_type"),
+            "error_msg":     doc.get("error_msg"),
+            "stack_trace":   doc.get("stack_trace"),
+            "agent":         doc.get("agent"),
+            "tool":          doc.get("tool"),
+            "feature":       doc.get("feature"),
+            "user_id":       doc.get("user_id"),
+            "session_id":    doc.get("session_id"),
+            "input_preview": doc.get("input_preview"),
+            "resolved":      doc.get("resolved", False),
+            "ts":            doc["ts"].isoformat() if hasattr(doc.get("ts"), "isoformat") else str(doc.get("ts")),
+        })
+
+    return {
+        "success": True,
+        "data": {
+            "period_days":     days,
+            "pagination": {
+                "page":       page,
+                "page_size":  page_size,
+                "total":      total_count,
+                "pages":      (total_count + page_size - 1) // page_size,
+            },
+            "summary": {
+                "total_errors":      total_count,
+                "unresolved":        unresolved_count,
+                "affected_users":    (affected_users[0] or {}).get("total", 0) if affected_users else 0,
+            },
+            "by_type": [
+                {
+                    "error_type": d.get("_id", "unknown"),
+                    "count":      d.get("count", 0),
+                    "last_seen":  d["last_seen"].isoformat() if hasattr(d.get("last_seen"), "isoformat") else None,
+                    "agents":     [a for a in (d.get("agents") or []) if a],
+                }
+                for d in by_type_agg
+            ],
+            "daily_trend": _daily_trend(daily_agg, days),
+            "errors":      error_list,
+        },
+    }

app/routes/listing.py

@@ -1,4 +1,5 @@
 # app/routes/listing.py
+import asyncio
 import logging
 from fastapi import APIRouter, Depends, Query, HTTPException
 from typing import Optional
@@ -11,6 +12,18 @@ from app.schemas.listing import ListingsListResponseDto, UserListingsResponseDto
 
 logger = logging.getLogger(__name__)
 
+
+async def _increment_view(listing_id: str) -> None:
+    """Fire-and-forget view counter. Never raises — a failed increment is non-critical."""
+    try:
+        db = await get_db()
+        await db.listings.update_one(
+            {"_id": ObjectId(listing_id)},
+            {"$inc": {"view_count": 1}},
+        )
+    except Exception:
+        pass
+
 router = APIRouter(tags=["Listings"])
 
 
@@ -119,13 +132,16 @@ async def get_listing_by_id(
     try:
         # Find the listing
         doc = await db.listings.find_one({"_id": ObjectId(listing_id)})
-        
+
         if not doc:
             raise HTTPException(
-                status_code=404, 
+                status_code=404,
                 detail="Listing not found. It may have been deleted."
             )
-        
+
+        # Track view — non-blocking, never delays the response
+        asyncio.create_task(_increment_view(listing_id))
+
         # Convert ObjectId to string
         doc["_id"] = str(doc["_id"])
         

app/services/conversation_parts/crud_mixin.py

@@ -139,6 +139,7 @@ class ConversationCRUDMixin:
             participants=participants,
             listing_title=listing.get("title", "Property"),
             listing_image=listing.get("images", [None])[0] if listing.get("images") else None,
+            listing_type=listing.get("listing_type"),  # stored for chat-rate-by-type analytics
         )
         
         result = await db.conversations.insert_one(conversation_doc)