Update main.py

main.py

@@ -1,15 +1,16 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 import json
+from datetime import datetime
+from typing import Optional, Dict, Any
 
 from firestore_client import get_firestore_client
 from openai_client import ask_gpt
 from prompt_instructions import build_system_message
-from role_access import get_allowed_collections
+from role_access import get_allowed_collections  # (currently unused but kept)
 from data_fetcher import fetch_data_from_firestore
 from data_planner import determine_data_requirements  # 🧠 Gemini planner
 from resolver import resolve_user_context
-from typing import Optional, Dict, Any
 from schema_utils import has_field, resolve_field
 
 app = Flask(__name__)
@@ -17,6 +18,28 @@ CORS(app)
 
 db = get_firestore_client()
 
+# -- helpers --------------------------------------------------------------
+
+def to_jsonable(obj):
+    """Recursively convert Firestore types (e.g., DatetimeWithNanoseconds) to JSON-safe values."""
+    # Firestore timestamp types come through as DatetimeWithNanoseconds (duck-type datetime)
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+
+    # Some Firestore SDKs expose Timestamp-like objects without subclassing datetime.
+    # Fallback: detect presence of isoformat()
+    if hasattr(obj, "isoformat") and callable(getattr(obj, "isoformat")):
+        try:
+            return obj.isoformat()
+        except Exception:
+            pass
+
+    if isinstance(obj, dict):
+        return {k: to_jsonable(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [to_jsonable(v) for v in obj]
+    return obj
+
 # 🔧 Normalize Gemini plan into proper Firestore fetch format
 def normalize_plan(plan: dict, token_map: Optional[Dict[str, Any]] = None) -> dict:
     token_map = token_map or {}
@@ -24,29 +47,34 @@ def normalize_plan(plan: dict, token_map: Optional[Dict[str, Any]] = None) -> di
     planned_cols = plan.get("collections", []) or []
 
     def canonical_value(key, val):
+        # replace tokens like {{participantId}}
         if isinstance(val, str) and val in token_map:
-            val = token_map[val]                      # 🔁 replace {{participantId}} etc.
+            val = token_map[val]
+        # special-case status normalization
         if key == "status" and val == "running":
             return "active"
         return val
 
     collections_out = []
     for col in planned_cols:
+        # Allow both strings ("participants") and objects ({"name":"participants","fields":[...]}).
         name = col["name"] if isinstance(col, dict) else col
         col_filters = []
         for k, v in filters.items():
             canon_key = resolve_field(name, k)
+            # only add filters that exist for this collection (schema-aware)
             if has_field(name, canon_key):
                 col_filters.append({
                     "field": canon_key,
                     "op": "==",
-                    "value": canonical_value(k, v)
+                    "value": canonical_value(k, v),
                 })
             # else: skip invalid field for this collection
         collections_out.append({"name": name, "filters": col_filters, "limit": 50})
 
     return {"collections": collections_out}
 
+# -- route ---------------------------------------------------------------
 
 @app.route('/chat', methods=['POST'])
 def chat():
@@ -59,7 +87,7 @@ def chat():
     if not role or not user_input or not company_code or not user_id:
         return jsonify({"error": "Missing role, message, companyCode, or userId"}), 400
 
-    # 🔎 Resolve current user's email + participantId
+    # 🔎 Resolve current user's email + participantId (participants has no companyCode; resolve via applications)
     ctx = resolve_user_context(user_id, company_code)
     token_map = {
         "{{participantId}}": ctx.get("participantId"),
@@ -76,22 +104,26 @@ def chat():
     if "error" in planning_result:
         return jsonify({"reply": f"⚠️ Planning error: {planning_result['error']}"})
 
-    # 🛠️ Normalize & replace tokens
+    # 🛠️ Normalize & replace tokens (schema-aware)
     normalized_plan = normalize_plan(planning_result, token_map)
 
     # 📥 Fetch
     firestore_data = fetch_data_from_firestore(normalized_plan)
 
-    # 🧩 Add current-user context to the model explicitly (helps answering)
+    # 🧩 Build messages — convert Firestore payload to JSON-safe types
     system_msg = build_system_message(company_code)
+    safe_ctx = to_jsonable(ctx)
+    safe_data = to_jsonable(firestore_data)
+
     data_msg = {
         "role": "system",
         "content": (
-          f"CurrentUserContext: {json.dumps(ctx)}\n"
-          f"Here is the data from Firestore:\n{json.dumps(firestore_data)}"
+            f"CurrentUserContext: {json.dumps(safe_ctx)}\n"
+            f"Here is the data from Firestore:\n{json.dumps(safe_data)}"
         )
     }
     user_msg = {"role": "user", "content": user_input}
+
     final_response = ask_gpt([system_msg, data_msg, user_msg])
     return jsonify({"reply": final_response})