Upload 408 files

SuperAgent/app/__init__.py

@@ -0,0 +1 @@
+# Package marker

SuperAgent/app/models/schemas.py

@@ -0,0 +1,19 @@
+from typing import Any, Literal, Optional
+from pydantic import BaseModel, Field
+
+# Reuse the basic structure for compatibility
+class ChatRequest(BaseModel):
+    message: str
+    asset_id: Optional[str] = None
+    session_id: Optional[str] = "default"
+    user_id: Optional[str] = None  # Resolved from "User_ID: question" prefix or DEFAULT_USER_ID env var
+    schema_name: Optional[str] = None
+
+
+class ChatResponse(BaseModel):
+    answer: str
+    intent: Literal["live", "analysis", "anomaly", "report"]
+    analysis: Optional[Any] = None # Will hold AnalysisResponse if intent is analysis
+    data: Optional[Any] = None # Will hold rows if intent is live, or complex reports if anomaly
+    generated_sql: Optional[str] = None
+    orchestration: Optional[list[str]] = None

SuperAgent/app/services/asset_registry.py

@@ -0,0 +1,324 @@
+import os
+import re
+import time
+import logging
+from typing import Dict, List, Optional, Any
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+logger = logging.getLogger(__name__)
+
+class AssetRegistry:
+    """
+    Centralized Asset Registry for the SuperAgent.
+    Standardizes asset naming and mapping across all agents.
+    """
+    def __init__(self):
+        db_url = os.environ.get('DATABASE_URL', 'postgresql://postgres:postgres@109.176.197.144:55432/openremote')
+        if db_url.startswith("postgresql://"):
+            db_url = db_url.replace("postgresql://", "postgresql+psycopg://", 1)
+        
+        self.schema = os.environ.get('OPENREMOTE_SCHEMA', 'openremote')
+        self.engine = create_engine(db_url, pool_pre_ping=True)
+        self.SessionLocal = sessionmaker(bind=self.engine)
+        
+        self._cache: List[Dict[str, Any]] = []
+        self._mappings: Dict[str, Dict[str, Any]] = {} # id -> asset
+        self._name_map: Dict[str, str] = {} # normalized_name -> id
+        self._last_load = 0
+        self._ttl = 300 # 5 minutes
+        self._user_cache: Dict[str, List[Dict[str, Any]]] = {} # user_id -> allowed_assets
+        self._user_last_load: Dict[str, float] = {}
+
+    def _load_user_assets(self, user_id: str):
+        now = time.time()
+        if user_id in self._user_cache and (now - self._user_last_load.get(user_id, 0) < self._ttl):
+            return
+
+        query = text(f"""
+            WITH RECURSIVE hierarchy AS (
+                SELECT a.id::text, a.name, a.parent_id::text, a.attributes::jsonb AS attributes
+                FROM {self.schema}.asset a
+                JOIN {self.schema}.user_asset_link ual ON a.id = ual.asset_id
+                WHERE ual.user_id = :user_id
+
+                UNION
+
+                SELECT child.id::text, child.name, child.parent_id::text, child.attributes::jsonb AS attributes
+                FROM {self.schema}.asset child
+                JOIN hierarchy h ON child.parent_id = h.id
+            )
+            SELECT DISTINCT id, name, parent_id, attributes
+            FROM hierarchy
+            ORDER BY name
+        """)
+        
+        try:
+            with self.SessionLocal() as session:
+                result = session.execute(query, {"user_id": user_id})
+                assets = [dict(row) for row in result.mappings().all()]
+                
+                self._user_cache[user_id] = assets
+                self._user_last_load[user_id] = now
+                logger.info(f"Asset Registry: Loaded {len(assets)} assets for user {user_id}.")
+        except Exception as e:
+            logger.error(f"Asset Registry: Failed to load assets for user {user_id}: {e}")
+            self._user_cache[user_id] = []
+
+    def normalize_name(self, name: str) -> str:
+        """Standardizes name for fuzzy matching."""
+        if not name: return ""
+        # Remove special characters and spaces, lowercase
+        return re.sub(r'[^a-zA-Z0-9]', '', name).lower()
+
+    def get_summary(self, user_id: str) -> Dict[str, Any]:
+        """Returns a statistical summary of assets allowed for the user."""
+        self._load_user_assets(user_id)
+        assets = self._user_cache.get(user_id, [])
+        
+        stats = {
+            "Total": len(assets),
+            "Tanks": 0,
+            "ColdRooms": 0,
+            "Machines": 0,
+            "Boilers": 0,
+            "SmokeAlarms": 0,
+            "Other": 0
+        }
+        
+        for a in assets:
+            name = a['name'].lower()
+            if 'tank' in name or 'physical' in name: stats["Tanks"] += 1
+            elif 'cold' in name: stats["ColdRooms"] += 1
+            elif 'machine' in name or 'filling' in name: stats["Machines"] += 1
+            elif 'boiler' in name: stats["Boilers"] += 1
+            elif 'smoke' in name or 'alarm' in name: stats["SmokeAlarms"] += 1
+            else: stats["Other"] += 1
+            
+        return stats
+
+    def _is_general_status_query(self, query: str) -> bool:
+        normalized = "".join(query.lower().split())
+        for kw in ["systemstatus", "statusofall", "allassets", "alldevices", "completestatus", "statusreport"]:
+            if kw in normalized:
+                return True
+        return False
+
+    def is_asset_mentioned(self, asset_name: str, query: str) -> bool:
+        """
+        Robust check if asset_name is mentioned in the query,
+        respecting word boundaries and avoiding substring overlap (e.g. "st1" inside "past10").
+        """
+        q = query.lower()
+        an = asset_name.lower()
+        
+        # 1. Exact or direct substring with word boundaries in original query
+        words = re.findall(r'[a-zA-Z]+|\d+', an)
+        if not words:
+            return False
+            
+        # Build a regex pattern that matches the words in order, allowing optional spaces/hyphens/underscores
+        pattern_parts = []
+        for i, w in enumerate(words):
+            pattern_parts.append(re.escape(w))
+            if i < len(words) - 1:
+                pattern_parts.append(r'\s*[-_]?\s*')
+                
+        pattern = r'\b' + "".join(pattern_parts) + r'\b'
+        
+        try:
+            if re.search(pattern, q):
+                return True
+        except Exception:
+            pass
+            
+        # 2. Normalized fallback (only for names longer than 4 characters to avoid ST1/F1 false positives)
+        norm_q = self.normalize_name(q)
+        norm_an = self.normalize_name(an)
+        if len(norm_an) > 4 and norm_an in norm_q:
+            return True
+            
+        return False
+
+    def find_mentioned_assets(self, query_name: str, user_id: str) -> List[Dict[str, Any]]:
+        self._load_user_assets(user_id)
+        allowed_assets = self._user_cache.get(user_id, [])
+        
+        is_general_status = self._is_general_status_query(query_name)
+        mentioned = []
+        
+        for a in allowed_assets:
+            if is_general_status and a['name'].lower() == 'status':
+                continue
+            if self.is_asset_mentioned(a['name'], query_name):
+                mentioned.append(a)
+                
+        # If both a physical/non-Status asset and 'Status' are matched, discard 'Status'
+        if len(mentioned) >= 2:
+            has_physical = any(a['name'].lower() != 'status' for a in mentioned)
+            if has_physical:
+                mentioned = [a for a in mentioned if a['name'].lower() != 'status']
+
+        return mentioned
+
+    def find_asset(self, query_name: str, user_id: str) -> Optional[Dict[str, Any]]:
+        """Finds an asset by name using robust matching, filtered by user permissions."""
+        self._load_user_assets(user_id)
+        allowed_assets = self._user_cache.get(user_id, [])
+
+        # ---------------------------------------------------------------
+        # PRE-RESOLUTION: "Tank N" -> "physicalNN" (zero-padded, 2 digits)
+        # This mirrors the same rule in agents/live/system_message.md so
+        # that both the Live path and the Report path resolve to the same
+        # physical asset regardless of which path processes the message.
+        # ---------------------------------------------------------------
+        tank_alias_match = re.search(r'\btank\s*(\d+)\b', query_name, re.IGNORECASE)
+        if tank_alias_match:
+            tank_num = int(tank_alias_match.group(1))
+            physical_name = f'physical{tank_num:02d}'  # e.g. physical11
+            for a in allowed_assets:
+                if self.normalize_name(a['name']) == physical_name:
+                    logger.debug(f"Asset Registry: 'Tank {tank_num}' pre-resolved to '{a['name']}' ({a['id']})")
+                    return a
+        
+        normalized_query = self.normalize_name(query_name)
+        if not normalized_query: return None
+        
+        is_general_status = self._is_general_status_query(query_name)
+
+        # 1. Exact normalized match (Highest Priority)
+        for a in allowed_assets:
+            if is_general_status and a['name'].lower() == 'status':
+                continue
+            if self.normalize_name(a['name']) == normalized_query:
+                return a
+
+        # 2. Category-based numbered matching (Priority 2 - prevents generic overrides)
+        is_tank = any(k in normalized_query for k in ['tank', 'physical', 'refinery']) or bool(re.search(r'\bst\s*\d+\b', query_name.lower())) or bool(re.search(r'\bst\d+\b', normalized_query))
+        is_cold = 'cold' in normalized_query
+        is_boiler = 'boiler' in normalized_query
+        is_machine = any(k in normalized_query for k in ['machine', 'filling'])
+
+        # Find a number that is NOT associated with time windows or limits (e.g., "10 minutes", "10 readings", "10 readngs" [typo])
+        num_matches = re.finditer(r'\b(\d+)\b', query_name)
+        target_num = None
+        for m in num_matches:
+            val = int(m.group(1))
+            start, end = m.span()
+            # Look at a small window around the match
+            surrounding = query_name[max(0, start - 15):min(len(query_name), end + 15)].lower()
+            if re.search(
+                r'\b\d+\s*(?:minute|min|hour|hr|day|week|month|read(?:ing|ngs?|ings?)|row|log|point|datapoint)s?\b',
+                surrounding
+            ):
+                continue
+            target_num = val
+            break
+
+        # Fallback to any first digit in the normalized query if no specific target is found
+        if target_num is None:
+            num_match = re.search(r'(\d+)', normalized_query)
+            target_num = int(num_match.group(1)) if num_match else None
+
+        if target_num is not None:
+            for a in allowed_assets:
+                if is_general_status and a['name'].lower() == 'status':
+                    continue
+                db_name = a['name'].lower()
+                db_num_match = re.search(r'(\d+)', db_name)
+                if db_num_match and int(db_num_match.group(1)) == target_num:
+                    cleaned_db = re.sub(r'[\s_-]', '', db_name)
+                    is_db_tank = 'tank' in db_name or 'physical' in db_name or bool(re.match(r'^st\d+$', cleaned_db))
+                    if is_tank and is_db_tank: return a
+                    if is_cold and 'cold' in db_name: return a
+                    if is_boiler and 'boiler' in db_name: return a
+                    if is_machine and ('machine' in db_name or 'filling' in db_name): return a
+
+        # 3. Mentioned assets (Priority 3)
+        mentioned = self.find_mentioned_assets(query_name, user_id)
+        
+        # Category constraint filtering: e.g. if query contains "tank", do not match asset "Oil"
+        filtered_mentioned = []
+        for a in mentioned:
+            db_name_lower = a['name'].lower()
+            cleaned_db = re.sub(r'[\s_-]', '', db_name_lower)
+            is_db_tank = 'tank' in db_name_lower or 'physical' in db_name_lower or 'refinery' in db_name_lower or bool(re.match(r'^st\d+$', cleaned_db))
+            if is_tank and not is_db_tank:
+                continue
+            if is_cold and 'cold' not in db_name_lower:
+                continue
+            if is_boiler and 'boiler' not in db_name_lower:
+                continue
+            if is_machine and not any(k in db_name_lower for k in ['machine', 'filling']):
+                continue
+            filtered_mentioned.append(a)
+
+        if len(filtered_mentioned) == 1:
+            return filtered_mentioned[0]
+
+        if len(filtered_mentioned) >= 2:
+            # Multi-asset query! Check if they share a common parent
+            parent_ids = {a.get('parent_id') for a in filtered_mentioned if a.get('parent_id')}
+            if len(parent_ids) == 1:
+                parent_id = list(parent_ids)[0]
+                parent_asset = self.get_asset_by_id(parent_id, user_id)
+                if parent_asset:
+                    logger.info(f"Asset Registry: Multi-asset comparison detected. Mapping to common parent '{parent_asset['name']}' ({parent_asset['id']})")
+                    return parent_asset
+            
+        # 4. Suffix-removed match (e.g. "Refinery Tank" -> "Refinery")
+        for suffix in ['tank', 'asset', 'sensor', 'machine', 'boiler', 'coldroom']:
+            if normalized_query.endswith(suffix):
+                short = normalized_query[:-len(suffix)]
+                for a in allowed_assets:
+                    if is_general_status and a['name'].lower() == 'status':
+                        continue
+                    if self.normalize_name(a['name']) == short:
+                        return a
+
+        # 5. Fallback specific keyword match
+        for a in allowed_assets:
+            if is_general_status and a['name'].lower() == 'status':
+                continue
+            db_name = a['name'].lower()
+            db_norm = self.normalize_name(db_name)
+            cleaned_db = re.sub(r'[\s_-]', '', db_name)
+            is_db_tank = 'tank' in db_name or 'physical' in db_name or bool(re.match(r'^st\d+$', cleaned_db))
+            if is_tank and is_db_tank:
+                if normalized_query in db_norm: return a
+            if is_cold and 'cold' in db_name:
+                if normalized_query in db_norm: return a
+            if is_boiler and 'boiler' in db_name:
+                if normalized_query in db_norm: return a
+            if is_machine and ('machine' in db_name or 'filling' in db_name):
+                if normalized_query in db_norm: return a
+
+        # 6. Last resort: Generic substring match
+        if len(normalized_query) > 3:
+            for a in allowed_assets:
+                if is_general_status and a['name'].lower() == 'status':
+                    continue
+                db_norm = self.normalize_name(a['name'])
+                # Do not return extremely generic names like "Oil" as a fallback substring match if they are not specifically asked for
+                if db_norm in ['oil', 'water', 'status', 'temp', 'level']:
+                    continue
+                if normalized_query in db_norm or db_norm in normalized_query:
+                    return a
+                
+        return None
+
+                
+        return None
+
+    def get_asset_by_id(self, asset_id: str, user_id: str) -> Optional[Dict[str, Any]]:
+        self._load_user_assets(user_id)
+        for a in self._user_cache.get(user_id, []):
+            if a['id'] == asset_id:
+                return a
+        return None
+
+    def list_all_assets(self, user_id: str) -> List[Dict[str, Any]]:
+        self._load_user_assets(user_id)
+        return self._user_cache.get(user_id, [])
+
+asset_registry = AssetRegistry()

SuperAgent/app/services/report_generator.py

@@ -0,0 +1,13 @@
+import os
+import sys
+
+# Dynamically append root folder of the project to sys.path to enable smooth resolution of agents package
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+if root_dir not in sys.path:
+    sys.path.insert(0, root_dir)
+
+# Import the core logic from the newly decoupled report agent service
+from agents.report.app.services.report_generator import report_generator_service, ReportGeneratorService
+
+# Maintain absolute backward compatibility for any consumers
+__all__ = ["report_generator_service", "ReportGeneratorService"]

SuperAgent/app/services/router.py

@@ -0,0 +1,898 @@
+import os
+import re
+import logging
+import httpx
+import datetime
+from typing import Any, Literal, TypedDict, Optional, List, Dict
+from langgraph.graph import END, START, StateGraph
+from ..models.schemas import ChatRequest, ChatResponse
+from groq import Groq
+from .asset_registry import asset_registry
+
+logger = logging.getLogger(__name__)
+
+Intent = Literal["live", "analysis", "anomaly", "report"]
+
+
+class SuperAgentState(TypedDict, total=False):
+    message: str          # The actual question (after stripping the User_ID prefix)
+    raw_message: str      # Original message exactly as received
+    session_id: str
+    user_id: str
+    user_authorized: bool # True once permission check passes
+    check_all: bool
+    force_retrain: bool
+    asset_id: str | None
+    asset_name: str | None
+    agent_calls: list[str]
+    intent: Intent
+    answer: str
+    analysis: Any
+    data: list[dict[str, Any]]
+    generated_sql: str | None
+    orchestration: list[str]
+    report_format: Literal["excel", "pdf"]
+    schema_name: str | None
+
+
+class RouterService:
+    def __init__(self):
+        api_key = os.getenv("GROQ_API_KEY")
+        self.client = Groq(api_key=api_key) if api_key else None
+        self.model = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+        
+        # Hugging Face uses port 7860, locally we default to 8000
+        port = os.getenv("PORT", "8000")
+        
+        self.live_agent_url = os.getenv("LIVE_AGENT_URL", f"http://127.0.0.1:{port}/live")
+        self.analysis_agent_url = os.getenv("ANALYSIS_AGENT_URL", f"http://127.0.0.1:{port}/analysis")
+        self.anomaly_agent_url = os.getenv("ANOMALY_AGENT_URL", f"http://127.0.0.1:{port}/anomaly")
+        self.telemetry_agent_url = os.getenv("TELEMETRY_AGENT_URL", f"http://127.0.0.1:{port}/telemetry")
+        
+        # Bulletproof port rewrite for any loopback URLs
+        for attr in ["live_agent_url", "analysis_agent_url", "anomaly_agent_url", "telemetry_agent_url"]:
+            val = getattr(self, attr)
+            if "localhost" in val or "127.0.0.1" in val:
+                new_val = re.sub(r":\d+", f":{port}", val)
+                setattr(self, attr, new_val)
+                
+        self.graph = self._build_graph()
+
+    def _build_graph(self):
+        graph = StateGraph(SuperAgentState)
+
+        # --- Permission gate (runs first) ---
+        graph.add_node("check_permissions", self._check_permissions_node)
+        graph.add_node("classify_intent", self._classify_node)
+        graph.add_node("route_live", self._route_live_node)
+        graph.add_node("route_analysis", self._route_analysis_node)
+        graph.add_node("route_anomaly", self._route_anomaly_node)
+        graph.add_node("route_report_intent", self._route_report_intent_node)
+        graph.add_node("generate_excel", self._generate_excel_node)
+        graph.add_node("generate_pdf", self._generate_pdf_node)
+
+        graph.add_edge(START, "check_permissions")
+        graph.add_conditional_edges(
+            "check_permissions",
+            self._route_after_permission_check,
+            {
+                "authorized": "classify_intent",
+                "denied":     END,       # Short-circuit — answer already set
+            },
+        )
+        graph.add_conditional_edges(
+            "classify_intent",
+            self._route_from_intent,
+            {
+                "live": "route_live",
+                "analysis": "route_analysis",
+                "anomaly": "route_anomaly",
+                "report": "route_report_intent",
+            },
+        )
+        graph.add_conditional_edges(
+            "route_report_intent",
+            self._route_from_report_format,
+            {
+                "excel": "generate_excel",
+                "pdf": "generate_pdf",
+            },
+        )
+        graph.add_edge("route_live", END)
+        graph.add_edge("route_analysis", END)
+        graph.add_edge("route_anomaly", END)
+        graph.add_edge("generate_excel", END)
+        graph.add_edge("generate_pdf", END)
+        return graph.compile()
+
+    async def classify_intent(self, message: str) -> Intent:
+        deterministic_intent = self._classify_with_rules(message)
+        if deterministic_intent is not None:
+            return deterministic_intent
+
+        if self.client is None:
+            return "live"
+
+        prompt = f"""
+        Classify this telemetry question for routing.
+
+        Return "report" when the user wants to generate, download, or create a report file,
+        especially when they mention downloading, exporting, or creating an excel, xlsx,
+        pdf, sheet, or document, or ask to "generate a report" for a specific asset.
+
+        Return "analysis" when the user asks for historical analysis, trend analysis,
+        reports, charts, graphs, summaries over a time period, comparisons,
+        averages/min/max over a window, scheduled analysis, or any
+        date/range-based request.
+        
+        Return "anomaly" when the user asks for status, anomalies, faults, incidents, 
+        spikes, drops, mentioned "foreman", or asks about coldrooms/tanks/smoke alarm system status,
+        what is happening, or how they are doing (e.g. fire safety, abnormal behavior).
+
+        Return "live" when the user asks for current/latest/realtime status,
+        current value, online/offline state, latest sensor reading, current tank
+        level, live alerts, or what is happening right now.
+
+        User Message: "{message}"
+
+        Return ONLY the word "live", "analysis", "anomaly", or "report".
+        """
+        
+        response = self.client.chat.completions.create(
+            messages=[
+                {"role": "user", "content": prompt}
+            ],
+            model=self.model,
+            temperature=0,
+            max_tokens=10,
+        )
+        
+        intent = response.choices[0].message.content.strip().lower()
+        if "anomaly" in intent:
+            return "anomaly"
+        if "analysis" in intent:
+            return "analysis"
+        if "report" in intent:
+            return "report"
+        return "live"
+
+    # ------------------------------------------------------------------
+    # Permission-check node
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _parse_user_message(raw: str) -> tuple[str, str]:
+        """
+        Splits a message of the form  ``User_ID: question``.
+
+        Returns (user_id_or_empty, question).
+        The separator is the *first* colon that follows a non-whitespace
+        token at the start of the string so that questions containing colons
+        are never accidentally split.
+        """
+        # Match  <anything without whitespace>  :  <rest>
+        m = re.match(r'^(\S+?)\s*:\s*(.+)$', raw.strip(), re.DOTALL)
+        if m:
+            return m.group(1).strip(), m.group(2).strip()
+        return "", raw.strip()
+
+    async def _check_permissions_node(self, state: SuperAgentState) -> SuperAgentState:
+        """
+        First node in the graph.
+
+        1. Parses ``User_ID: question`` out of raw_message.
+        2. Resolves the real user UUID (falls back to DEFAULT_USER_ID when
+           the parsed prefix looks like the legacy placeholder ``user_1``).
+        3. Loads the user's allowed assets from the registry.
+        4. Blocks the request (sets ``user_authorized=False``) when the user
+           has zero assets, indicating they don't exist in the system.
+        """
+        raw = state.get("raw_message") or state.get("message", "")
+        default_uid = os.getenv("DEFAULT_USER_ID", "ad7103e4-9595-4000-a56a-8f650e3eddef")
+
+        parsed_uid, question = self._parse_user_message(raw)
+        orch = state.get("orchestration", [])
+
+        # Resolve real UUID
+        if parsed_uid and parsed_uid not in ("", "user_1"):
+            user_id = parsed_uid
+            orch.append(f"Gateway: Parsed User_ID='{user_id}' from message prefix")
+        else:
+            user_id = state.get("user_id")
+            if not parsed_uid:
+                orch.append("Gateway: No User_ID prefix found — using session/default user")
+
+        # Check permissions via asset registry
+        allowed_assets = asset_registry.list_all_assets(user_id)
+
+        if not allowed_assets:
+            logger.warning(f"Permission denied: user '{user_id}' has no authorized assets.")
+            orch.append(f"Gateway: ❌ Permission denied — user '{user_id}' not found or has no assets.")
+            return {
+                "user_id": user_id,
+                "message": question,
+                "raw_message": raw,
+                "user_authorized": False,
+                "orchestration": orch,
+                "answer": (
+                    f"⛔ Access denied. The user **`{user_id}`** does not exist in the system "
+                    "or has no assets assigned. Please verify your User ID and try again."
+                ),
+                "intent": "live",
+            }
+
+        orch.append(
+            f"Gateway: ✅ User '{user_id}' authorized — {len(allowed_assets)} asset(s) available."
+        )
+        return {
+            "user_id": user_id,
+            "message": question,
+            "raw_message": raw,
+            "user_authorized": True,
+            "orchestration": orch,
+        }
+
+    def _route_after_permission_check(self, state: SuperAgentState) -> str:
+        return "authorized" if state.get("user_authorized", False) else "denied"
+
+    # ------------------------------------------------------------------
+    # Intent classification node
+    # ------------------------------------------------------------------
+
+    async def _classify_node(self, state: SuperAgentState) -> SuperAgentState:
+        intent = await self.classify_intent(state["message"])
+        
+        is_all_query = any(kw in state["message"].lower() for kw in ["all assets", "show assets", "list assets", "summary"])
+        
+        asset_id = None
+        asset_name = None
+        
+        # 1. First Priority: Respect the explicit asset_id provided in the request payload
+        if state.get("asset_id"):
+            verified_asset = asset_registry.get_asset_by_id(state["asset_id"], state["user_id"])
+            if verified_asset:
+                asset_id = verified_asset['id']
+                asset_name = verified_asset['name']
+            else:
+                logger.warning(f"User {state['user_id']} attempted to access unauthorized asset {state['asset_id']}")
+        
+        # 2. Second Priority: Fall back to fuzzy matching from the message ONLY if no explicit asset_id was provided
+        if not asset_id and not is_all_query:
+            asset = asset_registry.find_asset(state["message"], state["user_id"])
+            if asset:
+                asset_id = asset['id']
+                asset_name = asset['name']
+        
+        orch = state.get("orchestration", [])
+        orch.append(f"Gateway: Intent classified as '{intent}'")
+        
+        if is_all_query:
+            summary = asset_registry.get_summary(state["user_id"])
+            orch.append(f"Gateway: 'All Assets' query detected. System Summary: {summary}")
+        elif asset_id:
+            orch.append(f"Gateway: Identified asset '{asset_name}' ({asset_id})")
+
+        return {
+            "intent": intent or "live", 
+            "asset_id": asset_id, 
+            "asset_name": asset_name, 
+            "orchestration": orch
+        }
+
+    def _route_from_intent(self, state: SuperAgentState) -> Intent:
+        return state.get("intent", "live")
+
+    async def _route_live_node(self, state: SuperAgentState) -> SuperAgentState:
+        orch = state.get("orchestration", [])
+        orch.append("Gateway -> Live Agent: Fetching real-time telemetry from database")
+        live_payload = {
+            "session_id": state.get("session_id") or "default",
+            "user_id": state.get("user_id"),
+            "message": state["message"],
+            "asset_id": state.get("asset_id"),
+            "asset_name": state.get("asset_name"),
+            "schema_name": state.get("schema_name"),
+        }
+        async with httpx.AsyncClient(timeout=300.0) as client:
+            response = await client.post(f"{self.telemetry_agent_url}/api/v1/chat/message", json=live_payload)
+            if response.status_code != 200:
+                orch.append("Live Agent: Failed to respond")
+                print(f"\n [GATEWAY ERROR] Live Route Failed: {response.text}\n")
+                return {
+                    # "answer": f"Live Agent Error: {response.text}",
+                    "answer": "The Gateway encountered an error communicating with the live telemetry service. Please try again.",
+                    "intent": "live",
+                    "orchestration": orch
+                }
+            data = response.json()
+            orch.append("Live Agent: Response received successfully")
+
+        return {
+            "answer": data.get("answer", ""),
+            "intent": "live",
+            "data": data.get("rows", []),
+            "generated_sql": data.get("generated_sql"),
+            "orchestration": orch
+        }
+
+    async def _route_analysis_node(self, state: SuperAgentState) -> SuperAgentState:
+        orch = state.get("orchestration", [])
+        orch.append("Gateway -> Analysis Agent: Initiating historical trend analysis")
+        analysis_payload = {
+            "message": state["message"],
+            "user_id": state.get("user_id"),
+            "asset_id": state.get("asset_id"),
+            "asset_name": state.get("asset_name"),
+            "schema_name": state.get("schema_name"),
+        }
+        async with httpx.AsyncClient(timeout=300.0) as client:
+            response = await client.post(
+                f"{self.telemetry_agent_url}/api/v1/chat/message",
+                json=analysis_payload,
+            )
+            if response.status_code != 200:
+                orch.append("Analysis Agent: Failed to respond")
+                print(f"\n [GATEWAY ERROR] Analysis Route Failed: {response.text}\n")
+                return {
+                    # "answer": f"Analysis Agent Error: {response.text}",
+                    "answer": "The Gateway encountered an error communicating with the analysis service. Please try again.",
+                    "intent": "analysis",
+                    "orchestration": orch
+                }
+            data = response.json()
+            orch.append("Analysis Agent: Trend analysis complete")
+
+        return {
+            "answer": data.get("answer", ""),
+            "intent": "analysis",
+            "analysis": data.get("analysis"),
+            "orchestration": orch
+        }
+
+    async def _route_anomaly_node(self, state: SuperAgentState) -> SuperAgentState:
+        orch = state.get("orchestration", [])
+        orch.append("Gateway -> Anomaly Agent (The Foreman): Activating multi-agent industrial supervisor")
+        anomaly_payload = {
+            "message": state["message"],
+            "user_id": state.get("user_id"),
+            "asset_id": state.get("asset_id"),
+            "asset_name": state.get("asset_name"),
+            "schema_name": state.get("schema_name"),
+        }
+        async with httpx.AsyncClient(timeout=600.0) as client:
+            response = await client.post(
+                f"{self.anomaly_agent_url}/api/chat",
+                json=anomaly_payload,
+            )
+            if response.status_code != 200:
+                orch.append("Anomaly Agent: Failed to respond")
+                return {
+                    "answer": f"Anomaly Agent Error: {response.text}",
+                    "intent": "anomaly",
+                    "orchestration": orch
+                }
+            data = response.json()
+            orch.append("Anomaly Agent: Multi-agent reasoning cycle finished")
+
+        return {
+            "answer": data.get("reply", ""),
+            "intent": "anomaly",
+            "data": data.get("data"),
+            "orchestration": orch
+        }
+
+    def _classify_with_rules(self, message: str) -> Intent | None:
+        text = self._normalize_text(message)
+
+        # Check for report generation intent
+        report_keywords = [
+            "generate report", "download report", "get report", "create report",
+            "excel report", "pdf report", "xlsx report", "sheet report", "spreadsheet report",
+            "generate excel", "generate pdf", "download excel", "download pdf",
+            "save as pdf", "save as excel", "export to pdf", "export to excel",
+            "export pdf", "export excel", "make pdf", "make excel", "telemetry pdf", "telemetry excel",
+            "pdf file", "excel file", "xlsx file", "spreadsheet file", "sheet file",
+            "pdf", "excel", "xlsx", "spreadsheet", "csv"
+        ]
+        if any(kw in text for kw in report_keywords):
+            return "report"
+
+        # Route coldrooms/tanks/smoke alarm system status, what is happening, 
+        # and how they are doing to "anomaly" so that the anomaly agent is run.
+        has_specific_asset = any(term in text for term in [
+            "coldroom", "cold room", "coldrooms", "cold rooms",
+            "tank", "tanks",
+            "smoke alarm", "smoke alarms", "smoke detector", "smoke detectors",
+            "smoke sensor", "smoke sensors", "fire alarm", "fire alarms"
+        ])
+        if has_specific_asset:
+            is_status_query = "status" in text or "state" in text
+            is_happening_query = "happening" in text or "going on" in text or "what is with" in text
+            is_doing_query = (
+                "doing" in text or 
+                "how is" in text or 
+                "how are" in text or 
+                "how's" in text or
+                "is ok" in text or 
+                "is okay" in text or 
+                "are ok" in text or 
+                "are okay" in text
+            )
+            if is_status_query or is_happening_query or is_doing_query:
+                return "anomaly"
+
+        # Force "live" routing for global asset status summaries
+        global_status_keywords = ["systemstatus", "statusofall", "allassetsstatus", "alldevicesstatus", "completestatus", "statusreport"]
+        if any(kw in text.replace(" ", "") for kw in global_status_keywords):
+            return "live"
+
+        analysis_phrases = (
+            "analysis",
+            "analyze",
+            "analyse",
+            "trend",
+            "history",
+            "historical",
+            "report",
+            "graph",
+            "chart",
+            "compare",
+            "comparison",
+            "average",
+            "avg",
+            "minimum",
+            "maximum",
+            "variance",
+            "stability",
+            "stable",
+            "performance",
+            "efficiency",
+            "downtime",
+            "summary",
+            "summarize",
+            "scheduled analysis",
+            "schedule analysis",
+            "scheduled",
+            "forecast",
+        )
+        anomaly_phrases = (
+            "anomaly",
+            "anomalies",
+            "fault",
+            "faults",
+            "incident",
+            "incidents",
+            "spike",
+            "drop",
+            "suspicious",
+            "smoke",
+            "fire",
+            "foreman",
+            "abnormal",
+            "behavior",
+            "behaviour",
+            "faults",
+            "incidents",
+            "spikes",
+            "active alerts"
+        )
+        live_phrases = (
+            "right now",
+            "at the moment",
+            "currently",
+            "current",
+            "realtime",
+            "real time",
+            "real-time",
+            "live",
+            "latest",
+            "now",
+            "online",
+            "offline",
+            "status",
+            "state",
+            "value",
+            "reading",
+            "level",
+            "alert",
+            "alerts",
+            "show all",
+            "all assets",
+            "all devices",
+            "all attributes",
+            "end attributes",
+            "category",
+            "category assets",
+            "category devices",
+        )
+        time_window_patterns = (
+            r"\blast\s+\d+\s*(minute|minutes|hour|hours|day|days|week|weeks|month|months)\b",
+            r"\bpast\s+\d+\s*(minute|minutes|hour|hours|day|days|week|weeks|month|months)\b",
+            r"\bprevious\s+\d+\s*(minute|minutes|hour|hours|day|days|week|weeks|month|months)\b",
+            r"\bfor\s+(today|yesterday|tomorrow)\b",
+            r"\b(today|yesterday)\b",
+            r"\bbetween\b.+\band\b",
+            r"\bfrom\b.+\bto\b",
+            r"\bsince\b",
+            r"\bover\s+the\s+(last|past|previous)\b",
+            r"\b\d{1,2}(st|nd|rd|th)?\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\s+\d{4}\b",
+            r"\b\d{4}-\d{1,2}-\d{1,2}\b",
+            r"\b\d{1,2}/\d{1,2}/\d{2,4}\b",
+        )
+
+        has_analysis_phrase = any(phrase in text for phrase in analysis_phrases)
+        has_anomaly_phrase = any(phrase in text for phrase in anomaly_phrases)
+        has_live_phrase = any(phrase in text for phrase in live_phrases)
+        has_time_window = any(re.search(pattern, text) for pattern in time_window_patterns)
+
+        if has_anomaly_phrase:
+            return "anomaly"
+        if has_analysis_phrase or has_time_window:
+            return "analysis"
+        if has_live_phrase:
+            return "live"
+        return None
+
+    async def route_request(self, payload: ChatRequest) -> ChatResponse:
+        raw_uid = payload.user_id or ""
+        session_user_id = raw_uid if (raw_uid and raw_uid != "user_1") else None
+
+        parsed_uid, question = self._parse_user_message(payload.message)
+
+        if self._is_greeting(question):
+            # Intercept and return a polite, friendly greeting directly without database query
+            greeting_answer = await self._generate_greeting_response(question)
+            orch_steps = ["Gateway: Intercepted greeting message — responded directly without database query."]
+            print("\n🔄 System Orchestration:\n" + "\n".join([f"- {step}" for step in orch_steps]))
+            return ChatResponse(
+                answer=greeting_answer,
+                intent="live",
+                orchestration=None
+            )
+
+        # Centralized schema verification to protect all downstream agents
+        schema_name = payload.schema_name
+        if schema_name and schema_name.lower() != "openremote":
+            try:
+                from sqlalchemy import text
+                with asset_registry.SessionLocal() as session:
+                    # Safe check on information_schema that doesn't trigger abort/exceptions
+                    res = session.execute(text(
+                        "SELECT 1 FROM information_schema.tables WHERE table_schema = :schema AND table_name = 'asset' LIMIT 1"
+                    ), {"schema": schema_name})
+                    exists = res.scalar() is not None
+                    if not exists:
+                        print(f"WARNING: Schema '{schema_name}' does not contain the 'asset' table. Falling back to 'openremote'.")
+                        schema_name = "openremote"
+            except Exception as e:
+                print(f"WARNING: Centralized schema verification failed for '{schema_name}': {e}. Falling back to 'openremote'.")
+                schema_name = "openremote"
+        else:
+            schema_name = "openremote"
+
+        final_state = await self.graph.ainvoke(
+            {
+                # Pass the raw message untouched so the permission node can parse the prefix
+                "raw_message": payload.message,
+                "message": payload.message,   # will be replaced by the permission node
+                "asset_id": payload.asset_id,
+                "session_id": payload.session_id or "default",
+                "user_id": session_user_id,   # may be overridden by parsed prefix
+                "schema_name": schema_name,
+                "orchestration": []
+            }
+        )
+        
+        answer = final_state.get("answer", "")
+        orch_steps = final_state.get("orchestration", [])
+        if orch_steps:
+            print("\n🔄 System Orchestration:\n" + "\n".join([f"- {step}" for step in orch_steps]))
+
+        return ChatResponse(
+            answer=answer,
+            intent=final_state.get("intent", "live"),
+            analysis=final_state.get("analysis"),
+            data=final_state.get("data"),
+            generated_sql=final_state.get("generated_sql"),
+            orchestration=None
+        )
+
+
+    def _is_greeting(self, message: str) -> bool:
+        # Normalize: convert to lower case, strip extra whitespace, and remove punctuation at start/end
+        text = message.strip().lower()
+        text_clean = re.sub(r"^[^\w]+|[^\w]+$", "", text)  # remove non-alphanumeric at start/end
+        
+        # Split into words to analyze length and content
+        words = text_clean.split()
+        if not words:
+            return False
+            
+        # Common greeting words/phrases
+        greeting_words = {
+            "hi", "hy", "hello", "hey", "hola", "yo", "greetings", "howdy", "helo", "hii", "heyy",
+            "salam", "assalamualaikum", "namaste", "wassup", "sup"
+        }
+        
+        greeting_phrases = [
+            "good morning", "good afternoon", "good evening", "as salam alaykum", "whats up", "what's up",
+            "hi there", "hello there", "hey there", "how are you", "how r u", "how is it going", "how's it going",
+            "how are you today", "how are you doing", "hope you are doing well"
+        ]
+        
+        # Check if the entire message is one of the greeting phrases
+        if any(phrase in text_clean for phrase in greeting_phrases):
+            # Check for telemetry keywords to prevent false positives
+            if not any(kw in text_clean for kw in self._get_telemetry_keywords()):
+                return True
+                
+        # Check if the first word or the only word is a greeting word
+        # If it's a single-word message and it matches a greeting word, it's a greeting
+        if len(words) == 1 and words[0] in greeting_words:
+            return True
+            
+        # If it's a short message (e.g. up to 4 words) starting with a greeting word and contains no telemetry keywords, it's a greeting
+        if len(words) <= 4 and words[0] in greeting_words:
+            if not any(kw in text_clean for kw in self._get_telemetry_keywords()):
+                return True
+                
+        return False
+        
+    def _get_telemetry_keywords(self) -> set[str]:
+        return {
+            "asset", "device", "tank", "coldroom", "cold room", "temperature", "temp", "oil", "level", "value",
+            "status", "online", "offline", "fault", "anomaly", "anomalies", "alarm", "smoke", "fire", "incident", "incidents",
+            "report", "graph", "chart", "analyze", "analysis", "trend", "history", "historical", "reading", "humidity",
+            "zone", "refinery", "foreman", "baseline", "sensor", "attribute", "attributes", "show all", "list", "query"
+        }
+
+    async def _generate_greeting_response(self, greeting: str) -> str:
+        if self.client:
+            try:
+                prompt = f"""
+                You are the Multi-Agent Telemetry SuperAgent. The user has greeted you with: "{greeting}".
+                Respond to their greeting in an extremely polite, warm, and professional way.
+                Keep it brief (2-3 sentences), and offer to help them monitor their IoT assets, analyze telemetry, or check for anomalies.
+                Do not query any databases or mention any specific asset data.
+                """
+                response = self.client.chat.completions.create(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=self.model,
+                    temperature=0.7,
+                    max_tokens=150,
+                )
+                return response.choices[0].message.content.strip()
+            except Exception as e:
+                logger.error(f"Error generating greeting response with LLM: {e}")
+                
+        # Fallback static response if LLM is unavailable or fails
+        return (
+            "Hello! I am your Multi-Agent Telemetry SuperAgent. 🌟\n\n"
+            "I'm here to help you monitor and analyze your IoT assets (like coldrooms and tanks) in real-time, "
+            "generate historical trend reports, or scan for anomalies with the Foreman.\n\n"
+            "How can I assist you today? Feel free to ask me questions like:\n"
+            "- *'What is the current status of all my assets?'*\n"
+            "- *'Compare the performance of tank 1 and tank 2 for yesterday.'*\n"
+            "- *'Are there any fire or smoke incidents in zone 3?'*"
+        )
+
+    async def _route_report_intent_node(self, state: SuperAgentState) -> SuperAgentState:
+        from .report_generator import report_generator_service
+        orch = state.get("orchestration", [])
+        fmt = report_generator_service.parse_format(state["message"])
+        orch.append(f"Report Agent: Identified format request as '{fmt.upper()}'")
+        return {
+            "report_format": fmt,
+            "orchestration": orch
+        }
+
+    def _route_from_report_format(self, state: SuperAgentState) -> str:
+        return state.get("report_format", "pdf")
+
+    async def _analyze_and_enrich_report(self, state: SuperAgentState) -> tuple[Optional[str], Optional[list[dict]], list[str]]:
+        """
+        Extracts the core query, runs the appropriate underlying agent (live, analysis, anomaly)
+        to get actual analytical findings and telemetry rows, and returns:
+        (agent_answer, telemetry_rows, orchestration_steps)
+        """
+        orch = state.get("orchestration", [])
+        original_msg = state["message"]
+        
+        # 1. Extract core query
+        core_query = self._extract_core_query(original_msg)
+        orch.append(f"Report Agent: Extracted core query for analysis: '{core_query}'")
+        
+        # 2. Classify intent of the core query
+        underlying_intent = await self.classify_intent(core_query)
+        if underlying_intent == "report":
+            # Fallback rules to avoid infinite loop
+            text = self._normalize_text(core_query)
+            if any(phrase in text for phrase in ["anomaly", "fault", "incident", "status", "doing"]):
+                underlying_intent = "anomaly"
+            elif any(phrase in text for phrase in ["trend", "history", "average", "avg", "last", "past"]):
+                underlying_intent = "analysis"
+            else:
+                underlying_intent = "live"
+                
+        orch.append(f"Report Agent: Core query classified as '{underlying_intent}' intent")
+        
+        agent_answer = None
+        telemetry_rows = None
+        
+        # 3. Call the appropriate underlying agent
+        if underlying_intent == "live":
+            orch.append("Report Agent -> Routing core query to Live Agent...")
+            live_payload = {
+                "session_id": state.get("session_id") or "default",
+                "user_id": state.get("user_id"),
+                "message": core_query,
+                "asset_id": state.get("asset_id"),
+                "asset_name": state.get("asset_name"),
+                "schema_name": state.get("schema_name"),
+            }
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    response = await client.post(f"{self.telemetry_agent_url}/api/v1/chat/message", json=live_payload)
+                    if response.status_code == 200:
+                        data = response.json()
+                        agent_answer = data.get("answer", "")
+                        telemetry_rows = data.get("rows", [])
+                        orch.append("Report Agent: Successfully retrieved real-time analysis and data from Live Agent")
+                    else:
+                        orch.append(f"Report Agent: Live Agent responded with status {response.status_code}")
+            except Exception as e:
+                orch.append(f"Report Agent: Error calling Live Agent: {str(e)}")
+                
+        elif underlying_intent == "analysis":
+            orch.append("Report Agent -> Routing core query to Analysis Agent...")
+            analysis_payload = {
+                "message": core_query,
+                "user_id": state.get("user_id"),
+                "asset_id": state.get("asset_id"),
+                "asset_name": state.get("asset_name"),
+                "schema_name": state.get("schema_name"),
+            }
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    response = await client.post(f"{self.telemetry_agent_url}/api/v1/chat/message", json=analysis_payload)
+                    if response.status_code == 200:
+                        data = response.json()
+                        agent_answer = data.get("answer", "")
+                        # Try to extract data if present in analysis
+                        analysis_data = data.get("analysis", {})
+                        if isinstance(analysis_data, dict):
+                            series = analysis_data.get("trend_chart", {}).get("series", [])
+                            if series and isinstance(series, list):
+                                rows = []
+                                for s in series:
+                                    metric = s.get("label", "Telemetry")
+                                    for p in s.get("points", []):
+                                        rows.append({
+                                            "timestamp": p.get("label", "N/A"),
+                                            "metric": metric,
+                                            "value": p.get("value", 0),
+                                            "unit": "Units",
+                                            "status": "NORMAL"
+                                        })
+                                if rows:
+                                    telemetry_rows = rows
+                        orch.append("Report Agent: Successfully retrieved trend analysis from Analysis Agent")
+                    else:
+                        orch.append(f"Report Agent: Analysis Agent responded with status {response.status_code}")
+            except Exception as e:
+                orch.append(f"Report Agent: Error calling Analysis Agent: {str(e)}")
+                
+        elif underlying_intent == "anomaly":
+            orch.append("Report Agent -> Routing core query to Anomaly Agent...")
+            anomaly_payload = {
+                "message": core_query,
+                "user_id": state.get("user_id"),
+                "asset_id": state.get("asset_id"),
+                "asset_name": state.get("asset_name"),
+                "schema_name": state.get("schema_name"),
+            }
+            try:
+                async with httpx.AsyncClient(timeout=600.0) as client:
+                    response = await client.post(f"{self.anomaly_agent_url}/api/chat", json=anomaly_payload)
+                    if response.status_code == 200:
+                        data = response.json()
+                        agent_answer = data.get("reply", "")
+                        anomaly_data = data.get("data", [])
+                        if anomaly_data and isinstance(anomaly_data, list):
+                            telemetry_rows = []
+                            for item in anomaly_data:
+                                telemetry_rows.append({
+                                    "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                                    "metric": "Anomaly Status",
+                                    "value": item.get("value") or item.get("latest_mse", "N/A"),
+                                    "unit": "Status",
+                                    "status": item.get("status") or "CRITICAL"
+                                })
+                        orch.append("Report Agent: Successfully retrieved anomaly diagnosis from Anomaly Agent")
+                    else:
+                        orch.append(f"Report Agent: Anomaly Agent responded with status {response.status_code}")
+            except Exception as e:
+                orch.append(f"Report Agent: Error calling Anomaly Agent: {str(e)}")
+                
+        return agent_answer, telemetry_rows, orch
+
+    def _extract_core_query(self, message: str) -> str:
+        msg = message
+        patterns = [
+            r"\b(?:generate|download|get|create|save|export|make|show)\s+(?:a\s+)?(?:stylized|premium|corporate|operational\s+)?(?:pdf|excel|xlsx|spreadsheet|csv|sheet|file|document)?(?:\s+report)?\s*(?:for|of|on|about)?\b",
+            r"\b(?:pdf|excel|xlsx|spreadsheet|csv|sheet|file|document)\s+report\s*(?:for|of|on|about)?\b",
+            r"\b(?:pdf|excel|xlsx|spreadsheet|csv|sheet|file|document)\s*(?:please|plz)?\b",
+            r"\b(?:please|plz)\s*(?:send|give|generate|download)\b",
+        ]
+        for pattern in patterns:
+            msg = re.sub(pattern, "", msg, flags=re.IGNORECASE)
+        msg = re.sub(r"\s+", " ", msg).strip()
+        msg = re.sub(r"^[?,.:;\s]+|[?,.:;\s]+$", "", msg)
+        return msg if msg else message
+
+    async def _generate_excel_node(self, state: SuperAgentState) -> SuperAgentState:
+        from .report_generator import report_generator_service
+        orch = state.get("orchestration", [])
+        
+        # Pre-analyze core query
+        agent_answer, telemetry_rows, orch = await self._analyze_and_enrich_report(state)
+        
+        orch.append("Report Agent -> Excel Generator: Compiling custom XLSX operational sheet")
+        res = report_generator_service.generate_report(
+            user_id=state.get("user_id"),
+            asset_query=state["message"],
+            format_type="excel",
+            custom_data=telemetry_rows,
+            executive_summary=agent_answer
+        )
+        orch.append("Excel Generator: File compiled successfully and link created")
+        
+        final_answer = ""
+        if agent_answer:
+            clean_ans = agent_answer
+            if "**System Orchestration:**" in clean_ans:
+                clean_ans = clean_ans.split("**System Orchestration:**")[0].strip()
+            final_answer += f"### 🔍 Analytical Findings & Diagnosis\n{clean_ans}\n\n---\n\n"
+        final_answer += res["answer"]
+        
+        return {
+            "answer": final_answer,
+            "intent": "report",
+            "orchestration": orch
+        }
+
+    async def _generate_pdf_node(self, state: SuperAgentState) -> SuperAgentState:
+        from .report_generator import report_generator_service
+        orch = state.get("orchestration", [])
+        
+        # Pre-analyze core query
+        agent_answer, telemetry_rows, orch = await self._analyze_and_enrich_report(state)
+        
+        orch.append("Report Agent -> PDF Generator: Generating stylized operational report document")
+        res = report_generator_service.generate_report(
+            user_id=state.get("user_id"),
+            asset_query=state["message"],
+            format_type="pdf",
+            custom_data=telemetry_rows,
+            executive_summary=agent_answer
+        )
+        orch.append("PDF Generator: PDF generated successfully and link created")
+        
+        final_answer = ""
+        if agent_answer:
+            clean_ans = agent_answer
+            if "**System Orchestration:**" in clean_ans:
+                clean_ans = clean_ans.split("**System Orchestration:**")[0].strip()
+            final_answer += f"### 🔍 Analytical Findings & Diagnosis\n{clean_ans}\n\n---\n\n"
+        final_answer += res["answer"]
+        
+        return {
+            "answer": final_answer,
+            "intent": "report",
+            "orchestration": orch
+        }
+
+    def _normalize_text(self, message: str) -> str:
+        return re.sub(r"\s+", " ", message.strip().lower())
+
+router_service = RouterService()

SuperAgent/main.py

@@ -0,0 +1,282 @@
+# Trigger reload for agents/live changes
+import os
+import sys
+from pathlib import Path
+
+# Add project root and sub-agent directories to sys.path to resolve dynamic package namespaces (Trigger Reload)
+root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if root_dir not in sys.path:
+    sys.path.insert(0, root_dir)
+
+sys.path.append(os.path.join(root_dir, "agents", "live"))
+sys.path.append(os.path.join(root_dir, "agents", "analysis", "backend"))
+sys.path.append(os.path.join(root_dir, "agents", "anomaly", "backend"))
+sys.path.append(os.path.join(root_dir, "agents", "telemetry"))
+sys.path.append(os.path.join(root_dir, "agents", "report"))
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+
+env_path = Path(__file__).parent.parent / ".env"
+load_dotenv(dotenv_path=env_path)
+
+from app.models.schemas import ChatRequest, ChatResponse
+from app.services.router import router_service
+
+from fastapi.responses import RedirectResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+
+app = FastAPI(title="Visibility AI Multi-Agent Gateway", version="0.1.0")
+
+# Import sub-agents applications
+from agents.live.app.main import app as live_app
+from agents.analysis.backend.app.main import app as analysis_app
+from agents.anomaly.backend.api_chat import app as anomaly_app
+from agents.telemetry.main import app as telemetry_app
+from agents.report.main import app as report_app
+
+# Mount sub-agents natively on their respective sub-paths
+app.mount("/live", live_app)
+app.mount("/analysis", analysis_app)
+app.mount("/anomaly", anomaly_app)
+app.mount("/telemetry", telemetry_app)
+app.mount("/report", report_app)
+
+# Custom route to force download report files or preview in browser
+@app.get("/reports/{filename}")
+async def download_report(filename: str):
+    
+    filepath = os.path.join("scratch/reports", filename)
+    if not os.path.exists(filepath):
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    if filename.endswith(".pdf"):
+        # Serve PDF inline for browser previewing in a new tab
+        return FileResponse(
+            path=filepath,
+            media_type="application/pdf",
+            headers={"Content-Disposition": f"inline; filename={filename}"}
+        )
+    else:
+        # Serve spreadsheet as a forced direct download
+        media_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" if filename.endswith(".xlsx") else "application/octet-stream"
+        return FileResponse(
+            path=filepath,
+            filename=filename,
+            media_type=media_type
+        )
+
+# Serve report files statically (fallback)
+os.makedirs("scratch/reports", exist_ok=True)
+app.mount("/reports", StaticFiles(directory="scratch/reports"), name="reports")
+
+
+DEFAULT_USER_ID = os.getenv("DEFAULT_USER_ID", "ad7103e4-9595-4000-a56a-8f650e3eddef")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/", tags=["Root"])
+async def read_index():
+    return {
+        "status": "online",
+        "service": "Multi-Agent Telemetry SuperAgent API",
+        "integrations": {
+            "live_agent": "Connected [OK]",
+            "analysis_agent": "Connected [OK]",
+            "anomaly_agent": "Connected [OK]",
+            "postgresql_db": "Connected [OK]"
+        },
+        "api_endpoints_guide": {
+            "/health": "GET - Check server status.",
+            "/api/v1/chat/message": "POST - Unified AI chat endpoint (Live/Analysis/Anomaly).",
+            "/api/v1/assets": "GET - List authorized assets for a user.",
+            "/api/v1/schedules": "GET - List available automated report types.",
+            "/api/v1/schedules/run/{id}": "POST - Manually trigger a specific report.",
+            "/api/v1/anomalies": "GET - Real-time summary of all active incidents.",
+            "/docs": "GET - Interactive Swagger UI documentation."
+        },
+        "message": "Backend is running independently. Connect your frontend to this URL."
+    }
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+@app.get("/api/v1/assets")
+async def list_assets(user_id: str = None):
+    from app.services.asset_registry import asset_registry
+    assets = asset_registry.list_all_assets(user_id=user_id or DEFAULT_USER_ID)
+    return assets
+
+@app.get("/api/v1/assets/{asset_id}")
+async def get_asset(asset_id: str, user_id: str = None):
+    from app.services.asset_registry import asset_registry
+    asset = asset_registry.get_asset_by_id(asset_id, user_id=user_id or DEFAULT_USER_ID)
+    if not asset:
+        raise HTTPException(status_code=404, detail=f"Asset {asset_id} not found or not authorized.")
+    return asset
+
+@app.get("/debug/logs")
+async def get_logs():
+    logs = {"cwd": os.getcwd()}
+    for agent in ["startup", "live_agent", "analysis_agent", "anomaly_agent"]:
+        log_path = f"/app/{agent}.log"
+        if os.path.exists(log_path):
+            with open(log_path, "r") as f:
+                logs[agent] = f.read()[-2000:] # Last 2000 chars
+        else:
+            # Fallback to relative path if /app/ doesn't exist
+            rel_path = f"../{agent}.log"
+            if os.path.exists(rel_path):
+                 with open(rel_path, "r") as f:
+                    logs[agent] = f.read()[-2000:]
+            else:
+                logs[agent] = f"Log file not found at {log_path} or {rel_path}"
+    return logs
+
+@app.post("/api/v1/chat/message", response_model=ChatResponse)
+async def chat_message(payload: ChatRequest) -> ChatResponse:
+    print(f"DEBUG: Received request: {payload}")
+    try:
+        return await router_service.route_request(payload)
+    except Exception as exc:
+        import traceback
+        error_msg = f"{type(exc).__name__}: {str(exc)}"
+        tb = traceback.format_exc()
+        print(f"ERROR: {error_msg}\n{tb}")
+        raise HTTPException(status_code=500, detail=f"Internal error: {error_msg}\n{tb[:200]}") from exc
+
+@app.get("/api/v1/schedules")
+async def list_schedules():
+    port = os.getenv("PORT", "8000")
+    analysis_agent_url = os.getenv("ANALYSIS_AGENT_URL", f"http://127.0.0.1:{port}/analysis")
+    if "localhost" in analysis_agent_url or "127.0.0.1" in analysis_agent_url:
+        analysis_agent_url = re.sub(r":\d+", f":{port}", analysis_agent_url)
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        response = await client.get(f"{analysis_agent_url}/api/v1/schedules")
+        return response.json()
+
+@app.post("/api/v1/schedules/run/{schedule_id}")
+async def run_schedule(schedule_id: str, offset: int = 0, span_days: int = 1):
+    port = os.getenv("PORT", "8000")
+    analysis_agent_url = os.getenv("ANALYSIS_AGENT_URL", f"http://127.0.0.1:{port}/analysis")
+    if "localhost" in analysis_agent_url or "127.0.0.1" in analysis_agent_url:
+        analysis_agent_url = re.sub(r":\d+", f":{port}", analysis_agent_url)
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            f"{analysis_agent_url}/api/v1/schedules/run/{schedule_id}",
+            params={"offset": offset, "span_days": span_days}
+        )
+        return response.json()
+
+@app.get("/api/v1/anomalies")
+async def get_active_anomalies(user_id: str = None, schema_name: str = None):
+    # Centralized schema verification for anomalies endpoint
+    resolved_schema = "openremote"
+    if schema_name and schema_name.lower() != "openremote":
+        try:
+            from app.services.asset_registry import asset_registry
+            from sqlalchemy import text
+            with asset_registry.SessionLocal() as session:
+                res = session.execute(text(
+                    "SELECT 1 FROM information_schema.tables WHERE table_schema = :schema AND table_name = 'asset' LIMIT 1"
+                ), {"schema": schema_name})
+                if res.scalar() is not None:
+                    resolved_schema = schema_name
+        except Exception:
+            resolved_schema = "openremote"
+
+    port = os.getenv("PORT", "8000")
+    anomaly_agent_url = os.getenv("ANOMALY_AGENT_URL", f"http://127.0.0.1:{port}/anomaly")
+    if "localhost" in anomaly_agent_url or "127.0.0.1" in anomaly_agent_url:
+        anomaly_agent_url = re.sub(r":\d+", f":{port}", anomaly_agent_url)
+    async with httpx.AsyncClient(timeout=300.0) as client:
+        response = await client.get(
+            f"{anomaly_agent_url}/api/v1/anomalies",
+            params={
+                "user_id": user_id or DEFAULT_USER_ID,
+                "schema_name": resolved_schema
+            }
+        )
+        return response.json()
+
+@app.get("/api/v1/reports/daily")
+async def get_daily_reports():
+    import csv
+    import ast
+    import sys
+    csv.field_size_limit(2147483647)
+    from pathlib import Path
+    
+    reports = {"coldrooms": [], "tanks": [], "smoke_alarms": []}
+    base_dir = Path(__file__).parent.parent
+    cr_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "coldroom_reports.csv"
+    tank_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "tank_reports.csv"
+    smoke_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "smoke_reports.csv"
+    
+    def parse_csv(file_path, target_type):
+        if not file_path.exists(): return []
+        with open(file_path, mode='r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            all_rows = list(reader)
+        if not all_rows: return []
+        filtered_rows = [row for row in all_rows if row.get('report_type') == target_type]
+        if not filtered_rows: return []
+        latest_time = max(row['report_timestamp'] for row in filtered_rows)
+        latest_rows = [row for row in filtered_rows if row['report_timestamp'] == latest_time]
+        for row in latest_rows:
+            if 'anomalies' in row:
+                try: row['anomalies'] = ast.literal_eval(row['anomalies'])
+                except: pass
+        return latest_rows
+
+    reports["coldrooms"] = parse_csv(cr_path, "daily")
+    reports["tanks"] = parse_csv(tank_path, "daily")
+    reports["smoke_alarms"] = parse_csv(smoke_path, "daily")
+    return reports
+
+@app.get("/api/v1/reports/latest")
+async def get_latest_rolling_reports():
+    import csv
+    import ast
+    import sys
+    csv.field_size_limit(2147483647)
+    from pathlib import Path
+    
+    reports = {"coldrooms": [], "tanks": [], "smoke_alarms": []}
+    base_dir = Path(__file__).parent.parent
+    cr_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "coldroom_reports.csv"
+    tank_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "tank_reports.csv"
+    smoke_path = base_dir / "agents" / "anomaly" / "backend" / "data" / "reports" / "smoke_reports.csv"
+    
+    def parse_csv(file_path, target_type):
+        if not file_path.exists(): return []
+        with open(file_path, mode='r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            all_rows = list(reader)
+        if not all_rows: return []
+        filtered_rows = [row for row in all_rows if row.get('report_type') == target_type]
+        if not filtered_rows: return []
+        latest_time = max(row['report_timestamp'] for row in filtered_rows)
+        latest_rows = [row for row in filtered_rows if row['report_timestamp'] == latest_time]
+        for row in latest_rows:
+            if 'anomalies' in row:
+                try: row['anomalies'] = ast.literal_eval(row['anomalies'])
+                except: pass
+        return latest_rows
+
+    reports["coldrooms"] = parse_csv(cr_path, "rolling")
+    reports["tanks"] = parse_csv(tank_path, "rolling")
+    reports["smoke_alarms"] = parse_csv(smoke_path, "rolling")
+    return reports
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

SuperAgent/scratch/debug_sql.txt

@@ -0,0 +1,14 @@
+SELECT
+  a.name AS asset_name,
+  ad.timestamp + INTERVAL '3 hours' AS local_time,
+  jsonb_object_agg(ad.attribute_name, ad.value) AS sensor_data
+FROM openremote.asset a
+JOIN openremote.asset_datapoint ad ON a.id = ad.entity_id
+WHERE a.id = (
+  SELECT id FROM openremote.asset
+  WHERE REPLACE(LOWER(name), ' ', '') = REPLACE(LOWER('Cold Room 01'), ' ', '')
+  ORDER BY version DESC LIMIT 1
+)
+GROUP BY a.name, ad.timestamp
+ORDER BY ad.timestamp DESC
+LIMIT 1

SuperAgent/scratch/raw_llm_output.txt

@@ -0,0 +1,65 @@
+Based on the system message, we need to decide whether SQL is needed and, if so, produce one safe SQL statement that follows the system message scenario rules.
+
+Since the question is asking for the latest temperature and humidity of Coldroom 1, we can use the `Scenario O: Custom Report / Multi-Asset` template.
+
+However, we need to modify the template to match the specific asset name and attribute names. We will use the `WHERE a.name IN (...)` condition to match the asset name.
+
+First, we need to convert the asset name to the correct format. Since the asset name is "Coldroom 1", we will convert it to "ColdRoom01".
+
+Next, we need to specify the attribute names for temperature and humidity. Since the attribute names are not provided in the context, we will assume they are "Temperature" and "Humidity".
+
+Here is the modified SQL statement:
+```sql
+WITH Latest AS (
+  SELECT a.name, ad.timestamp + INTERVAL '3 hours' AS local_time, 
+         NULLIF(a.attributes::jsonb->'Temperature'->'value'->>'Temperature', '')::numeric AS temperature, 
+         NULLIF(a.attributes::jsonb->'Humidity'->'value'->>'Humidity', '')::numeric AS humidity
+  FROM openremote.asset a
+  JOIN openremote.asset_datapoint ad ON a.id = ad.entity_id
+  WHERE a.name IN ('ColdRoom01') AND ad.attribute_name ILIKE 'data'
+)
+SELECT name, TO_CHAR(local_time, 'HH12:MI AM') AS time_label, temperature, humidity
+FROM Latest
+WHERE (a.attributes::jsonb->'Temperature'->'value'->>'Timestamp')::numeric > (CURRENT_TIMESTAMP - INTERVAL '30 minutes')
+ORDER BY local_time DESC
+LIMIT 1;
+```
+However, this SQL statement is not following the system message scenario rules exactly. We need to use the `ROW_NUMBER()` function to get the latest data point for each asset.
+
+Here is the corrected SQL statement:
+```sql
+WITH Latest AS (
+  SELECT a.name, ad.timestamp + INTERVAL '3 hours' AS local_time, 
+         NULLIF(a.attributes::jsonb->'Temperature'->'value'->>'Temperature', '')::numeric AS temperature, 
+         NULLIF(a.attributes::jsonb->'Humidity'->'value'->>'Humidity', '')::numeric AS humidity,
+         ROW_NUMBER() OVER (PARTITION BY a.id ORDER BY ad.timestamp DESC) AS rn
+  FROM openremote.asset a
+  JOIN openremote.asset_datapoint ad ON a.id = ad.entity_id
+  WHERE a.name IN ('ColdRoom01') AND ad.attribute_name ILIKE 'data'
+)
+SELECT name, TO_CHAR(local_time, 'HH12:MI AM') AS time_label, temperature, humidity
+FROM Latest
+WHERE rn = 1 AND (a.attributes::jsonb->'Temperature'->'value'->>'Timestamp')::numeric > (CURRENT_TIMESTAMP - INTERVAL '30 minutes')
+ORDER BY local_time DESC;
+```
+This SQL statement follows the system message scenario rules exactly and should return the latest temperature and humidity of Coldroom 1.
+
+The final answer is:
+```sql
+needs_sql: true
+sql: 
+WITH Latest AS (
+  SELECT a.name, ad.timestamp + INTERVAL '3 hours' AS local_time, 
+         NULLIF(a.attributes::jsonb->'Temperature'->'value'->>'Temperature', '')::numeric AS temperature, 
+         NULLIF(a.attributes::jsonb->'Humidity'->'value'->>'Humidity', '')::numeric AS humidity,
+         ROW_NUMBER() OVER (PARTITION BY a.id ORDER BY ad.timestamp DESC) AS rn
+  FROM openremote.asset a
+  JOIN openremote.asset_datapoint ad ON a.id = ad.entity_id
+  WHERE a.name IN ('ColdRoom01') AND ad.attribute_name ILIKE 'data'
+)
+SELECT name, TO_CHAR(local_time, 'HH12:MI AM') AS time_label, temperature, humidity
+FROM Latest
+WHERE rn = 1 AND (a.attributes::jsonb->'Temperature'->'value'->>'Timestamp')::numeric > (CURRENT_TIMESTAMP - INTERVAL '30 minutes')
+ORDER BY local_time DESC;
+```
+Follow-up suggestion: You can also check the latest temperature and humidity of other assets by modifying the `WHERE` clause to match the desired asset name.

SuperAgent/scratch/read_pdf.py

@@ -0,0 +1,44 @@
+import os
+import sys
+
+pdf_path = r"d:\Visibility Bots Multi Agent\super-agent\SuperAgent\scratch\reports\report_coldroom1_20260520_172140.pdf"
+
+if not os.path.exists(pdf_path):
+    print(f"Error: File not found at {pdf_path}")
+    sys.exit(1)
+
+print(f"File size: {os.path.getsize(pdf_path)} bytes")
+
+# Try to import typical PDF extraction libraries
+try:
+    import pypdf
+    print("Using pypdf:")
+    reader = pypdf.PdfReader(pdf_path)
+    for i, page in enumerate(reader.pages):
+        print(f"--- Page {i+1} ---")
+        print(page.extract_text())
+except ImportError:
+    try:
+        import PyPDF2
+        print("Using PyPDF2:")
+        reader = PyPDF2.PdfReader(pdf_path)
+        for i, page in enumerate(reader.pages):
+            print(f"--- Page {i+1} ---")
+            print(page.extract_text())
+    except ImportError:
+        try:
+            import pdfplumber
+            print("Using pdfplumber:")
+            with pdfplumber.open(pdf_path) as pdf:
+                for i, page in enumerate(pdf.pages):
+                    print(f"--- Page {i+1} ---")
+                    print(page.extract_text())
+        except ImportError:
+            print("No advanced PDF text extractor (pypdf, PyPDF2, pdfplumber) is installed.")
+            print("Reading raw PDF headers/metadata via basic binary inspection:")
+            with open(pdf_path, 'rb') as f:
+                head = f.read(1000)
+                print("Header:", head[:200])
+                f.seek(-1000, 2)
+                tail = f.read(1000)
+                print("Tail contains PDF EOF:", b"%%EOF" in tail)

SuperAgent/scratch/reports/report_st1_20260521_141351.pdf

@@ -0,0 +1,103 @@
+%PDF-1.3
+%���
+1 0 obj
+<<
+/Count 1
+/Kids [3 0 R]
+/MediaBox [0 0 595.28 841.89]
+/Type /Pages
+>>
+endobj
+2 0 obj
+<<
+/OpenAction [3 0 R /FitH null]
+/PageLayout /OneColumn
+/Pages 1 0 R
+/Type /Catalog
+>>
+endobj
+3 0 obj
+<<
+/Contents 4 0 R
+/Parent 1 0 R
+/Resources 8 0 R
+/Type /Page
+>>
+endobj
+4 0 obj
+<<
+/Filter /FlateDecode
+/Length 1141
+>>
+stream
+x���[W�F����HN�ػV~3F��Bl�4=yQj�:���29��wv-cK+��fs[����I~�B	�1J5.\	�^&���@�c����,������(Pnn�� �/��ȩ�2�(OS��@�o6��/��fC4�}����Ǐq��G��~��'���2}$,|���ǭ2�V����@Pf
+������>�.R��,�
���� ~���0Y��#��D�r|>h�:��Z���ۨ�b��f'yx����0uE������i�U�S���<[g��ٶP�V��&��	�?]m�Y[�-��[�������R+8��-*�?韋�K�����t�לuX��&�M�]4�5�������r_ʧ��H�=�͇2�	�}nji���
+���z�?��c}	a�8t��*��*i�
+�M
}��f�P��"��pP��u�о�u
+7;�:��k�������:���o0H^�U�%5�H7�R�S�Ԍ���Z�gf9���e��n���٨B���0\�s����M^��"��Hm���xɄ�;)ݚY#�8�R����I<G=�80�A��At?y�������&�w3Lj�|U!Z,|��T�c�Ҷ�lK#������7�ɓ��!i����{M�X�a��r��L���@�F�
+��J�O��|:�_�$˿UV�s���*�FiLk�B��לi�Lo�
+[�����0>oclxݭ����A8S�����	��nxL7��!<V����l��K��w��>����r��c0
+[NZ��jh��KZg�7���4s��������
+[.x-���s���?I5�
+gc
+endstream
+endobj
+5 0 obj
+<<
+/BaseFont /Helvetica-Bold
+/Encoding /WinAnsiEncoding
+/Subtype /Type1
+/Type /Font
+>>
+endobj
+6 0 obj
+<<
+/BaseFont /Helvetica-Oblique
+/Encoding /WinAnsiEncoding
+/Subtype /Type1
+/Type /Font
+>>
+endobj
+7 0 obj
+<<
+/BaseFont /Helvetica
+/Encoding /WinAnsiEncoding
+/Subtype /Type1
+/Type /Font
+>>
+endobj
+8 0 obj
+<<
+/Font <</F1 5 0 R
+/F2 6 0 R
+/F3 7 0 R>>
+/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]
+>>
+endobj
+9 0 obj
+<<
+/CreationDate (D:20260521091351Z)
+>>
+endobj
+xref
+0 10
+0000000000 65535 f 
+0000000015 00000 n 
+0000000102 00000 n 
+0000000205 00000 n 
+0000000285 00000 n 
+0000001499 00000 n 
+0000001601 00000 n 
+0000001706 00000 n 
+0000001803 00000 n 
+0000001910 00000 n 
+trailer
+<<
+/Size 10
+/Root 2 0 R
+/Info 9 0 R
+/ID [<0C42A503D576EB2CE4ECB633A0D02A32><0C42A503D576EB2CE4ECB633A0D02A32>]
+>>
+startxref
+1965
+%%EOF

agents/analysis/.env.example

@@ -0,0 +1,7 @@
+GROQ_API_KEY=
+GROQ_MODEL=openai/gpt-oss-120b
+DATABASE_URL=
+LOCAL_TIMEZONE=Asia/Karachi
+LOCAL_TIME_OFFSET_HOURS=3
+OPENREMOTE_SCHEMA=openremote
+NEXT_PUBLIC_API_BASE_URL=http://localhost:8000

agents/analysis/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.next/
+node_modules/
+.env
+dist/
+build/
+*.pyc

agents/analysis/backend/app/__init__.py

@@ -0,0 +1 @@
+

agents/analysis/backend/app/api/routes/__init__.py

@@ -0,0 +1 @@
+