Delete agents

agents/analysis/.env.example

@@ -1,7 +0,0 @@
-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

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

agents/analysis/backend/app/__init__.py

@@ -1 +0,0 @@
-

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

@@ -1 +0,0 @@
-

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

@@ -1,12 +0,0 @@
-from fastapi import APIRouter
-
-from agents.analysis.backend.app.models.schemas import AnalysisRequest, AnalysisResponse
-from agents.analysis.backend.app.services.analysis_agent import analysis_agent_service
-
-
-router = APIRouter(tags=["analysis"])
-
-
-@router.post("/analysis/run", response_model=AnalysisResponse)
-async def run_analysis(payload: AnalysisRequest) -> AnalysisResponse:
-    return await analysis_agent_service.run_analysis(payload)

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

@@ -1,19 +0,0 @@
-from fastapi import APIRouter, HTTPException
-
-from agents.analysis.backend.app.services.live_asset_registry import live_asset_registry
-
-
-router = APIRouter(tags=["assets"])
-
-
-@router.get("/assets")
-async def list_assets(user_id: str = "user_1") -> list[dict]:
-    return [asset.model_dump() for asset in live_asset_registry.list_assets(user_id=user_id)]
-
-
-@router.get("/assets/{asset_id}")
-async def get_asset(asset_id: str, user_id: str = "user_1") -> dict:
-    asset = live_asset_registry.get_asset(asset_id, user_id=user_id)
-    if asset is None:
-        raise HTTPException(status_code=404, detail=f"Unknown asset: {asset_id}")
-    return asset.model_dump()

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

@@ -1,12 +0,0 @@
-from fastapi import APIRouter
-
-from agents.analysis.backend.app.models.schemas import ChatRequest, ChatResponse
-from agents.analysis.backend.app.services.analysis_agent import analysis_agent_service
-
-
-router = APIRouter(tags=["chat"])
-
-
-@router.post("/chat/message", response_model=ChatResponse)
-async def chat_message(payload: ChatRequest) -> ChatResponse:
-    return await analysis_agent_service.run_chat(payload)

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

@@ -1,42 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from typing import List, Optional
-from pydantic import BaseModel
-
-from agents.analysis.backend.app.models.schemas import ChatResponse
-from agents.analysis.backend.app.services.scheduling_agent import n8n_fast_path_service
-
-router = APIRouter(tags=["schedules"])
-
-class ScheduleInfo(BaseModel):
-    id: str
-    name: str
-    description: str
-    triggers: List[str]
-
-@router.get("/schedules", response_model=List[ScheduleInfo])
-async def list_schedules():
-    """List all available scheduled report types."""
-    return [
-        ScheduleInfo(
-            id="th_monitoring",
-            name="T & H Monitoring Report",
-            description="Generates a comprehensive Temperature and Humidity report for all coldrooms and labs.",
-            triggers=["Scheduled T&H Monitoring", "T&H Monitoring Schedule"]
-        ),
-        ScheduleInfo(
-            id="filling_machines",
-            name="Filling Machines Production Report",
-            description="Generates a production summary for all filling machines across shifts.",
-            triggers=["Schedule Filling Machines", "Scheduled Filling Machines"]
-        )
-    ]
-
-@router.post("/schedules/run/{schedule_id}", response_model=ChatResponse)
-async def run_schedule(schedule_id: str, offset: int = 0, span_days: int = 1):
-    """Manually trigger a scheduled report by its ID."""
-    if schedule_id == "th_monitoring":
-        return n8n_fast_path_service._handle_th(offset=offset, span_days=span_days)
-    elif schedule_id == "filling_machines":
-        return n8n_fast_path_service._handle_filling(offset=offset, span_days=span_days)
-    else:
-        raise HTTPException(status_code=404, detail=f"Schedule '{schedule_id}' not found.")

agents/analysis/backend/app/core/config.py

@@ -1,28 +0,0 @@
-from pathlib import Path
-from functools import lru_cache
-
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-ROOT_ENV_FILE = Path(__file__).resolve().parents[5] / ".env"
-
-
-class Settings(BaseSettings):
-    app_name: str = "VisBot Analysis"
-    groq_api_key: str = ""
-    groq_model: str = "lgpt-oss-120b"
-    database_url: str = "sqlite+pysqlite:///:memory:"
-    local_timezone: str = "Asia/Karachi"
-    local_time_offset_hours: int = 3
-    openremote_schema: str = "openremote"
-
-    model_config = SettingsConfigDict(
-        env_file=(str(ROOT_ENV_FILE), ".env"),
-        env_file_encoding="utf-8",
-        extra="ignore",
-    )
-
-
-@lru_cache
-def get_settings() -> Settings:
-    return Settings()

agents/analysis/backend/app/main.py

@@ -1,33 +0,0 @@
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from agents.analysis.backend.app.api.routes.analysis import router as analysis_router
-from agents.analysis.backend.app.api.routes.assets import router as assets_router
-from agents.analysis.backend.app.api.routes.chat import router as chat_router
-from agents.analysis.backend.app.api.routes.schedules import router as schedules_router
-
-
-app = FastAPI(
-    title="VisBot Analysis",
-    version="0.1.0",
-    description="Intelligent asset analysis agent powered by FastAPI, LangChain, and Groq.",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.get("/health")
-async def health() -> dict[str, str]:
-    return {"status": "ok"}
-
-
-app.include_router(assets_router, prefix="/api/v1")
-app.include_router(chat_router, prefix="/api/v1")
-app.include_router(analysis_router, prefix="/api/v1")
-app.include_router(schedules_router, prefix="/api/v1")

agents/analysis/backend/app/models/__init__.py

@@ -1 +0,0 @@
-

agents/analysis/backend/app/models/schemas.py

@@ -1,123 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Literal
-from uuid import uuid4
-
-from pydantic import BaseModel, Field
-
-
-AnalysisScope = Literal["live", "historical"]
-WindowUnit = Literal["minutes", "hours", "days", "weeks", "months"]
-
-
-class TimeWindow(BaseModel):
-    scope: AnalysisScope = "live"
-    value: int = 1
-    unit: WindowUnit = "hours"
-    label: str = "last 1 hour"
-    start_at: str | None = None
-    end_at: str | None = None
-
-
-class AssetProfile(BaseModel):
-    asset_id: str
-    name: str
-    asset_type: str
-    description: str
-    db_asset_id: str = ""
-    parent_name: str = ""
-    child_count: int = 0
-    is_device: bool = False
-    attribute_keys: list[str] = Field(default_factory=list)
-    has_live_data: bool = False
-    data_keys: list[str] = Field(default_factory=list)
-    supported_analyses: list[str] = Field(default_factory=list)
-    metrics: list[str] = Field(default_factory=list)
-    source_table: str = ""
-    analysis_instructions: str = ""
-    sql_notes: str = ""
-    lookup_names: list[str] = Field(default_factory=list)
-    temperature_keys: list[str] = Field(default_factory=list)
-    humidity_keys: list[str] = Field(default_factory=list)
-    level_keys: list[str] = Field(default_factory=list)
-    production_keys: list[str] = Field(default_factory=list)
-    nominal_range: dict[str, float] = Field(default_factory=dict)
-
-
-class AnalysisPlan(BaseModel):
-    analysis_name: str
-    reasoning: str
-    time_window: TimeWindow
-    query_started_at: str = ""
-    query_ended_at: str = ""
-    query_window_label: str = ""
-    planner_prompt: str = ""
-    sql_prompt: str = ""
-    analyst_prompt: str = ""
-    sql_query: str
-    chart_hints: list[str] = Field(default_factory=list)
-    warnings: list[str] = Field(default_factory=list)
-    total_tokens: int = 0
-    llm_raw_response: str = ""
-
-
-class AnalysisReport(BaseModel):
-    report_id: str = Field(default_factory=lambda: str(uuid4()))
-    title: str
-    summary: str
-    markdown: str
-    html: str
-    created_at: datetime = Field(default_factory=datetime.utcnow)
-
-
-class AnalysisRequest(BaseModel):
-    asset_id: str | None = None
-    question: str
-    analysis_name: str | None = None
-    time_window: TimeWindow | None = None
-    schema_name: str | None = None
-
-
-
-class TrendPoint(BaseModel):
-    label: str
-    value: float
-
-
-class TrendSeries(BaseModel):
-    key: str
-    label: str
-    color: str
-    points: list[TrendPoint] = Field(default_factory=list)
-
-
-class TrendChart(BaseModel):
-    title: str
-    chart_type: Literal["line", "bar"]
-    x_label: str
-    y_label: str
-    summary: str = ""
-    series: list[TrendSeries] = Field(default_factory=list)
-
-
-class AnalysisResponse(BaseModel):
-    asset: AssetProfile
-    plan: AnalysisPlan
-    report: AnalysisReport
-    trend_chart: TrendChart | None = None
-    trend_charts: list[TrendChart] = Field(default_factory=list)
-    rows: list[dict] = Field(default_factory=list)
-
-
-class ChatRequest(BaseModel):
-    message: str
-    user_id: str = "user_1"
-    asset_id: str | None = None
-    schema_name: str | None = None
-
-
-
-class ChatResponse(BaseModel):
-    answer: str
-    analysis: AnalysisResponse

agents/analysis/backend/app/prompts/analysis_planner.txt

@@ -1,24 +0,0 @@
-You are VisBot Analysis, an industrial asset analysis planner.
-
-Your job:
-- understand the user's asset analysis request
-- use the asset selected from the user's chat message
-- use the backend-provided asset analysis instructions
-- select the best analysis type
-- infer the time window
-- produce a safe SQL query plan
-
-Rules:
-- prefer deterministic analysis types from the asset profile
-- never invent unavailable metrics
-- keep SQL read-only
-- use the asset description to choose the correct analysis style
-- explain the result in simple user-friendly language
-- if the user asks for live data, prioritize the latest records
-- if the user asks for historical analysis, use the requested time window
-
-Return concise planning text that explains:
-1. chosen analysis
-2. why it matches the asset
-3. what time window should be used
-4. what metrics matter most

agents/analysis/backend/app/prompts/request_planner.txt

@@ -1,37 +0,0 @@
-You are VisBot Analysis.
-
-Your job is to read the user's message and produce a structured asset-analysis plan.
-
-You must:
-- detect the exact asset from the provided asset catalog
-- choose the most suitable analysis type
-- infer the time window from the user's wording
-- prefer historical analysis styles when the user asks for trends, patterns, previous windows, comparisons, changes, drops, rises, stability, or insights over time
-- keep the output strictly in JSON
-
-Rules:
-- do not invent assets that are not in the catalog
-- the provided asset catalog is a compact shortlist, so use the strongest name, alias, parent, and telemetry-key clues available
-- prefer exact asset name matches while ignoring spaces and case
-- pay attention to parent_name, child_count, has_live_data, and data_keys
-- if the matched item looks like a parent/group asset without direct data, you may still choose it if the user is asking about that system or area
-- use the asset description and analysis instructions to decide the analysis style
-- if the asset is unclear, return asset_id as an empty string and explain the issue briefly
-- if the user asks for "latest", treat it as a live or recent window
-- if the user asks for history, trend, previous hour/day/week/month, comparison, movement, or insight, choose a historical window and an analysis type that benefits from multiple returned rows
-- if the user asks for analysis but does not mention a time, date, range, or duration, use a historical window of the last 3 hours from the request time
-- for cold rooms under T & H Monitoring, prefer `consumption_analysis` for the requested time window even if the user simply asks for analysis or consumption
-- keep labels human-readable
-
-Return JSON with this exact shape:
-{{
-  "asset_id": "string",
-  "analysis_name": "string",
-  "time_window": {{
-    "scope": "live or historical",
-    "value": 1,
-    "unit": "minutes|hours|days|weeks|months",
-    "label": "string"
-  }},
-  "reasoning": "short string"
-}}

agents/analysis/backend/app/prompts/result_analyst.txt

@@ -1,34 +0,0 @@
-You are VisBot Analysis.
-
-You are given:
-- the user's original request
-- the matched asset and its analysis instructions
-- the SQL query that fetched data
-- deterministic findings
-- the returned database rows
-
-Write a clean end-user analysis in simple language.
-
-Rules:
-- be analytical, not generic
-- use the actual returned data
-- highlight the most important findings first
-- mention problems clearly if thresholds are crossed or data is stale
-- avoid raw JSON formatting in the main answer
-- keep the answer well structured and readable
-- keep the answer concise and precise (prefer 5-10 short lines total)
-- do not output empty bullet markers, standalone `*`, or markdown separators like `---`
-- prefer short headings, clean paragraphs, and real lists only when each bullet has content
-- if the selected asset is a parent/group with multiple child assets, summarize all child assets (not just one) and call out only the most critical outliers
-- when the request is historical, explicitly describe trend direction, range, highs, lows, movement, and stability using the returned rows
-- provide real insights from the historical series instead of restating a single latest point
-- for tanks, present the reported metric as percentage filled (e.g. 85%) whenever possible
-- for tanks, use `percentage_filled = ((MaxFt - TankOilLevelInFeet001) / MaxFt) * 100` whenever MaxFt is available
-- for tanks, do not explain or mention how you calculated the level or percentage, just report the final fill percentage and current depth
-- if deterministic findings confirm that MaxFt was found, prioritize the percentage filled in your summary
-- for temperature and humidity (T&H) monitoring, always report how much time the system was on or consuming power within the "6am-6am" day
-- for all day-based calculations, a 24-hour day is strictly considered from 6:00 AM to 6:00 AM the following day
-- for temperature monitoring, when the temperature starts to increase and goes above 20, consider the subsequent temperature dip (after it started to rise) as the indicator that the system turned off at that time
-- for temperature compliance, use only thresholds explicitly provided in the asset context or deterministic findings
-- do not use generic or assumed industry ranges (for example "usually 2-8C") unless the user explicitly asks for benchmark ranges
-- finish with one useful suggested next step

agents/analysis/backend/app/prompts/sql_generator.txt

@@ -1,46 +0,0 @@
-You are VisBot Analysis.
-
-Generate exactly one read-only PostgreSQL query for OpenRemote.
-
-Database rules:
-- all tables are under the openremote schema
-- the main telemetry tables are openremote.asset and openremote.asset_datapoint
-- join them using `ad.entity_id = a.id`
-- sensor telemetry is usually stored in asset_datapoint.value JSON
-- many telemetry rows use `attribute_name ILIKE 'data'`, but not all
-- multiple attributes can contain JSON sensor payloads
-- unless the user explicitly asks for a specific attribute, inspect all relevant JSON-carrying attributes that may hold telemetry for the chosen asset or group
-- history is stored in asset datapoints, so historical queries should read from those datapoints directly
-- do not use `ad.asset_id`; that column does not exist here
-- always match the chosen asset using:
-  REPLACE(LOWER(a.name), ' ', '') = REPLACE(LOWER('<asset name>'), ' ', '')
-- OpenRemote time is already aligned with local time here, so do not apply a synthetic timezone offset
-- keep the query to one statement only
-- never write INSERT, UPDATE, DELETE, DROP, ALTER, or TRUNCATE
-- return SQL only, no markdown fences and no explanation
-
-Use the asset context and the user request to decide:
-- which telemetry keys to read
-- whether the query should fetch latest rows or historical rows
-- which computed columns are useful for later analysis
-- whether the selected asset is a parent/group and therefore requires a recursive child-asset query using openremote.asset.parent_id
-- prefer capturing telemetry across multiple JSON-carrying attributes rather than assuming only one attribute name
-
-Classification rule:
-- an asset is a real device only when its attributes contain keys beyond notes and location
-- if it is only a category/group, do not expect direct sensor telemetry from it
-- for category/group questions, fetch the relevant child devices and their telemetry
-- categories can contain sub-categories and those can contain devices, so recursive hierarchy queries are allowed
-- if a recursive CTE is used, it must start with `WITH RECURSIVE`
-
-Tank rule:
-- for tank devices, actual tank level must be computed as MaxFt - TankOilLevelInFeet001
-- the two source values may come from different attributes, so inspect all JSON-bearing attributes for `MaxFt`, `TankOilLevelInFeet001`, or `Level`
-- if that computed level would be negative, clamp it to 0
-
-If the selected asset has no direct live data but has children:
-- use a recursive query or direct child query on openremote.asset.parent_id
-- then join the child assets to openremote.asset_datapoint via ad.entity_id = child_asset.id
-- summarize the relevant child assets for the user request
-
-The result should be accurate, safe, and directly executable.

agents/analysis/backend/app/services/__init__.py

@@ -1 +0,0 @@
-

agents/analysis/backend/app/services/analysis_agent.py

@@ -1,882 +0,0 @@
-from __future__ import annotations
-
-import json
-import math
-import re
-from datetime import date, datetime, timedelta
-from zoneinfo import ZoneInfo
-
-from fastapi import HTTPException
-
-from agents.analysis.backend.app.models.schemas import (
-    AnalysisPlan,
-    AnalysisRequest,
-    AnalysisResponse,
-    ChatRequest,
-    ChatResponse,
-    TimeWindow,
-)
-from agents.analysis.backend.app.services.asset_analysis_instructions import build_asset_llm_context
-from agents.analysis.backend.app.services.data_repository import DataQueryError, data_repository
-from agents.analysis.backend.app.services.deterministic_analysis import deterministic_analysis_service
-from agents.analysis.backend.app.services.live_asset_registry import live_asset_registry
-from agents.analysis.backend.app.services.llm_service import llm_service
-from agents.analysis.backend.app.services.nl_to_sql import nl_to_sql_service
-from agents.analysis.backend.app.services.report_builder import report_builder_service
-from agents.analysis.backend.app.services.sql_guard import validate_read_only_sql
-from agents.analysis.backend.app.services.trend_chart_service import trend_chart_service
-
-
-class AnalysisAgentService:
-    async def run_chat(self, payload: ChatRequest) -> ChatResponse:
-        from agents.analysis.backend.app.services.scheduling_agent import n8n_fast_path_service
-        
-        fast_path = n8n_fast_path_service.try_intercept(payload.message)
-        if fast_path:
-            return fast_path
-
-        analysis_request = AnalysisRequest(
-            asset_id=payload.asset_id,
-            question=payload.message,
-            schema_name=payload.schema_name,
-        )
-        analysis = await self.run_analysis(analysis_request, user_id=payload.user_id)
-        return ChatResponse(answer=analysis.report.summary, analysis=analysis)
-
-
-    async def run_analysis(self, payload: AnalysisRequest, user_id: str = "user_1") -> AnalysisResponse:
-        candidates = live_asset_registry.find_candidates(payload.question, user_id=user_id)
-        direct_match = live_asset_registry.best_direct_match(payload.question, user_id=user_id)
-        planner_result = self._default_planner_result()
-        if direct_match is not None:
-            planner_result["asset_id"] = direct_match.asset_id
-            planner_result["reasoning"] = "Direct asset match found from the user message."
-        elif payload.asset_id:
-            planner_result["asset_id"] = payload.asset_id
-            planner_result["reasoning"] = "Asset id was provided directly in request."
-        else:
-            planner_result = llm_service.plan_request(
-                user_question=payload.question,
-                asset_catalog_context=self._build_asset_catalog_context(candidates),
-            )
-            
-        asset = self._resolve_asset(payload.asset_id, planner_result, payload.question, candidates, user_id=user_id)
-        
-        # Guardrail: If user asked for 'coldroom' but we picked a 'tank', check if we have better candidates
-        if asset.asset_type == "tank" and "cold" in payload.question.lower() and "room" in payload.question.lower():
-            for c in candidates:
-                if c.asset_type == "cold_room":
-                    asset = c
-                    planner_result["reasoning"] = "User asked for coldrooms, overriding tank selection with a valid coldroom candidate."
-                    break
-
-        analysis_name = payload.analysis_name or planner_result.get("analysis_name") or "historical_variance"
-        time_window = payload.time_window or self._parse_time_window(planner_result.get("time_window"))
-        explicit_time_window = self._extract_explicit_time_range_window(payload.question)
-        if explicit_time_window is not None:
-            started_at, ended_at, label = explicit_time_window
-            duration_hours = max(
-                1,
-                int(math.ceil((ended_at - started_at).total_seconds() / 3600)),
-            )
-            time_window = TimeWindow(
-                scope="historical",
-                value=duration_hours,
-                unit="hours",
-                label=label,
-                start_at=started_at.isoformat(),
-                end_at=ended_at.isoformat(),
-            )
-        elif (relative_day_window := self._extract_relative_day_window(payload.question)) is not None:
-            started_at, ended_at, label = relative_day_window
-            duration_hours = max(
-                1,
-                int(math.ceil((ended_at - started_at).total_seconds() / 3600)),
-            )
-            time_window = TimeWindow(
-                scope="historical",
-                value=duration_hours,
-                unit="hours",
-                label=label,
-                start_at=started_at.isoformat(),
-                end_at=ended_at.isoformat(),
-            )
-        elif (relative_duration_window := self._extract_relative_duration_window(payload.question)) is not None:
-            time_window = relative_duration_window
-        if explicit_time_window is None and (specific_date_window := self._extract_specific_date_window(payload.question)) is not None:
-            started_at, ended_at, label = specific_date_window
-            time_window = TimeWindow(
-                scope="historical",
-                value=1,
-                unit="days",
-                label=label,
-                start_at=started_at.isoformat(),
-                end_at=ended_at.isoformat(),
-            )
-        if payload.time_window is None and not self._question_mentions_time_window(payload.question):
-            time_window = self._default_analysis_time_window()
-        asset_context = build_asset_llm_context(asset)
-        query_window = self._build_query_window(time_window)
-
-        use_deterministic_sql = (
-            asset.asset_type in {"tank", "cold_room", "smoke_alarm"}
-            or (not asset.is_device and asset.child_count > 0)
-        )
-        sql_result = {"sql_query": "", "total_tokens": 0, "raw_response": ""}
-        if use_deterministic_sql:
-            sql_query = nl_to_sql_service.build_query(
-                asset=asset,
-                question=payload.question,
-                analysis_name=analysis_name,
-                time_window=time_window,
-                schema_name=payload.schema_name,
-            ).query
-        else:
-            sql_result = llm_service.generate_sql(
-                user_question=payload.question,
-                asset_context=asset_context,
-                analysis_name=analysis_name,
-                time_window_label=time_window.label,
-            )
-            sql_query = nl_to_sql_service.normalize_generated_query(sql_result["sql_query"], asset)
-
-        warnings: list[str] = []
-        try:
-            validate_read_only_sql(sql_query)
-        except Exception:
-            fallback_sql = nl_to_sql_service.build_query(
-                asset=asset,
-                question=payload.question,
-                analysis_name=analysis_name,
-                time_window=time_window,
-                schema_name=payload.schema_name,
-            )
-            sql_query = fallback_sql.query
-            warnings.append("The LLM SQL was invalid, so a safe fallback SQL template was used.")
-
-        try:
-            rows = data_repository.execute_query(sql_query)
-        except DataQueryError as exc:
-            fallback_sql = nl_to_sql_service.build_query(
-                asset=asset,
-                question=payload.question,
-                analysis_name=analysis_name,
-                time_window=time_window,
-                schema_name=payload.schema_name,
-            )
-
-            sql_query = fallback_sql.query
-            warnings.append("The generated SQL failed at runtime, so a safe fallback query was used.")
-            try:
-                rows = data_repository.execute_query(sql_query)
-            except DataQueryError as retry_exc:
-                raise HTTPException(status_code=502, detail=str(retry_exc)) from retry_exc
-        rows = self._clip_rows_to_window(rows, time_window)
-        # Flatten rows to ensure nested sensor_data is usable by charting and deterministic tools
-        flattened_rows = []
-        for row in rows:
-            new_row = dict(row)
-            sd = row.get("sensor_data")
-            if isinstance(sd, dict):
-                for k, v in sd.items():
-                    if k not in new_row:
-                        new_row[k] = v
-            flattened_rows.append(new_row)
-        rows = flattened_rows
-
-        latest_row_time = self._latest_row_timestamp(rows)
-        query_window = self._apply_display_window_override(payload.question, time_window, query_window)
-
-        deterministic_summary = deterministic_analysis_service.summarize(asset, rows)
-        warnings.extend(list(deterministic_summary["warnings"]))
-        if latest_row_time is not None:
-            try:
-                request_end = datetime.fromisoformat(query_window["ended_at_iso"])
-                if latest_row_time.tzinfo is None and request_end.tzinfo is not None:
-                    latest_row_time = latest_row_time.replace(tzinfo=request_end.tzinfo)
-                if latest_row_time < request_end:
-                    diff = request_end - latest_row_time
-                    if diff.total_seconds() > 3600:
-                        hours = int(diff.total_seconds() // 3600)
-                        warnings.append(
-                            f"The data for {asset.name} appears to be stale ({hours} hours old). "
-                            f"Latest telemetry available is from {latest_row_time.strftime('%d %b %Y, %I:%M %p')} (Asia/Karachi)."
-                        )
-                    else:
-                        warnings.append(
-                            f"Latest telemetry available for {asset.name} in this window is {latest_row_time.strftime('%d %b %Y, %I:%M %p')} (Asia/Karachi)."
-                        )
-            except Exception:
-                pass
-
-        if asset.asset_type == "smoke_alarm":
-            final_analysis = {
-                "answer": self._build_smoke_alarm_answer(asset, time_window, deterministic_summary, rows),
-                "total_tokens": 0,
-                "raw_response": "",
-                "prompt_text": "",
-            }
-        else:
-            final_analysis = llm_service.analyze_result(
-                user_question=payload.question,
-                asset_context=asset_context,
-                sql_query=sql_query,
-                deterministic_findings=deterministic_summary,
-                rows=rows,
-            )
-
-        total_tokens = (
-            int(sql_result.get("total_tokens", 0))
-            + int(final_analysis.get("total_tokens", 0))
-        )
-
-        plan = AnalysisPlan(
-            analysis_name=analysis_name,
-            reasoning=planner_result.get("reasoning", ""),
-            time_window=time_window,
-            query_started_at=query_window["started_at_iso"],
-            query_ended_at=query_window["ended_at_iso"],
-            query_window_label=query_window["label"],
-            planner_prompt=planner_result.get("prompt_text", ""),
-            sql_prompt=sql_result.get("prompt_text", ""),
-            analyst_prompt=final_analysis.get("prompt_text", ""),
-            sql_query=sql_query,
-            chart_hints=self._chart_hints_for_analysis(analysis_name),
-            warnings=warnings,
-            total_tokens=total_tokens,
-            llm_raw_response=final_analysis.get("raw_response", ""),
-        )
-        report = report_builder_service.build(
-            asset=asset,
-            plan=plan,
-            rows=rows,
-            summary_override=final_analysis.get("answer", ""),
-        )
-        trend_chart = trend_chart_service.build(asset, analysis_name, time_window, rows)
-        trend_charts = [trend_chart] if trend_chart else []
-        return AnalysisResponse(
-            asset=asset,
-            plan=plan,
-            report=report,
-            trend_chart=trend_chart,
-            trend_charts=trend_charts,
-            rows=rows,
-        )
-
-    def _build_smoke_alarm_answer(
-        self,
-        asset,
-        time_window: TimeWindow,
-        deterministic_summary: dict[str, object],
-        rows: list[dict],
-    ) -> str:
-        findings = [str(item).strip() for item in deterministic_summary.get("findings", []) if str(item).strip()]
-        warnings = [str(item).strip() for item in deterministic_summary.get("warnings", []) if str(item).strip()]
-
-        if not rows:
-            lines = [
-                f"No smoke-alarm telemetry rows were found for {asset.name} in {time_window.label}.",
-            ]
-            if warnings:
-                lines.append("")
-                lines.extend(f"- {item}" for item in warnings[:4])
-            return "\n".join(lines)
-
-        headline = findings[0] if findings else f"{asset.name} smoke-alarm telemetry was analyzed for {time_window.label}."
-        latest_states = [item for item in findings[1:] if ": " in item][:6]
-        other_findings = [item for item in findings[1:] if item not in latest_states][:4]
-
-        lines = [headline]
-
-        if other_findings:
-            lines.append("")
-            lines.append("Key points")
-            lines.extend(f"- {item}" for item in other_findings)
-
-        if latest_states:
-            lines.append("")
-            lines.append("Latest device states")
-            lines.extend(f"- {item}" for item in latest_states)
-
-        if warnings:
-            lines.append("")
-            lines.append("Attention items")
-            lines.extend(f"- {item}" for item in warnings[:4])
-
-        return "\n".join(lines)
-
-    def _apply_display_window_override(
-        self,
-        question: str,
-        time_window: TimeWindow,
-        query_window: dict[str, str],
-    ) -> dict[str, str]:
-        text = question.lower()
-        # Keep window as-is unless user asked for "today".
-        if "today" not in text:
-            return query_window
-        if not time_window.start_at:
-            return query_window
-        start_at = self._parse_datetime(time_window.start_at)
-        if start_at is None:
-            return query_window
-        end_at = self._parse_datetime(query_window.get("ended_at_iso", ""))
-        if end_at is None:
-            return query_window
-
-        friendly_format = "%d %b %Y, %I:%M %p"
-        query_window["label"] = (
-            f"{start_at.strftime(friendly_format)} to "
-            f"{end_at.strftime(friendly_format)} "
-            f"(Asia/Karachi)"
-        )
-        return query_window
-
-    def _latest_row_timestamp(self, rows: list[dict]) -> datetime | None:
-        timestamp_keys = ("recorded_at", "timestamp", "local_time", "raw_time", "latest_time")
-        latest: datetime | None = None
-        for row in rows:
-            for key in timestamp_keys:
-                value = row.get(key)
-                if value is None:
-                    continue
-                parsed = self._parse_datetime(value)
-                if parsed is None:
-                    continue
-                if latest is None or parsed > latest:
-                    latest = parsed
-                break
-        return latest
-
-    def _resolve_asset(
-        self,
-        requested_asset_id: str | None,
-        planner_result: dict,
-        question: str,
-        candidates: list,
-        user_id: str = "user_1",
-    ) -> object:
-        if requested_asset_id:
-            asset = live_asset_registry.get_asset(requested_asset_id, user_id=user_id)
-            if asset is not None:
-                return asset
-
-        direct_match = live_asset_registry.best_direct_match(question, user_id=user_id)
-        if direct_match is not None:
-            return direct_match
-
-        planned_asset_id = planner_result.get("asset_id", "")
-        if planned_asset_id:
-            asset = live_asset_registry.get_asset(planned_asset_id, user_id=user_id)
-            if asset is not None:
-                return asset
-
-        available = list(dict.fromkeys(asset.name for asset in (candidates[:12] or live_asset_registry.list_assets(user_id)[:12])))
-        detail = "I could not identify the asset from your message."
-        if available:
-            detail += f" Available assets include: {', '.join(available)}."
-        raise HTTPException(status_code=422, detail=detail)
-
-    def _parse_time_window(self, raw_time_window: dict | None) -> TimeWindow:
-        if not raw_time_window:
-            return self._default_analysis_time_window()
-        try:
-            return TimeWindow(**raw_time_window)
-        except Exception:
-            return self._default_analysis_time_window()
-
-    def _default_analysis_time_window(self) -> TimeWindow:
-        return TimeWindow(scope="historical", value=3, unit="hours", label="last 3 hours")
-
-    def _question_mentions_time_window(self, question: str) -> bool:
-        text = question.lower()
-        if self._extract_explicit_time_range_window(question) is not None:
-            return True
-        if self._extract_relative_duration_window(question) is not None:
-            return True
-        if self._extract_relative_day_window(question) is not None:
-            return True
-        if self._extract_specific_date_window(question) is not None:
-            return True
-
-        time_words = (
-            "today",
-            "yesterday",
-            "tomorrow",
-            "last",
-            "past",
-            "previous",
-            "between",
-            "from",
-            "to",
-            "since",
-            "until",
-            "till",
-            "hour",
-            "hours",
-            "minute",
-            "minutes",
-            "day",
-            "days",
-            "week",
-            "weeks",
-            "month",
-            "months",
-        )
-        return any(word in text for word in time_words)
-
-    def _build_query_window(self, time_window: TimeWindow) -> dict[str, str]:
-        timezone = ZoneInfo("Asia/Karachi")
-        if time_window.start_at and time_window.end_at:
-            started_at = datetime.fromisoformat(time_window.start_at)
-            ended_at = datetime.fromisoformat(time_window.end_at)
-            friendly_format = "%d %b %Y, %I:%M %p"
-            return {
-                "started_at_iso": started_at.isoformat(),
-                "ended_at_iso": ended_at.isoformat(),
-                "label": (
-                    f"{started_at.strftime(friendly_format)} to "
-                    f"{ended_at.strftime(friendly_format)} (Asia/Karachi)"
-                ),
-            }
-
-        ended_at = datetime.now(timezone)
-
-        unit_to_delta = {
-            "minutes": timedelta(minutes=time_window.value),
-            "hours": timedelta(hours=time_window.value),
-            "days": timedelta(days=time_window.value),
-            "weeks": timedelta(weeks=time_window.value),
-            "months": timedelta(days=30 * time_window.value),
-        }
-        started_at = ended_at - unit_to_delta.get(time_window.unit, timedelta(hours=3))
-        friendly_format = "%d %b %Y, %I:%M %p"
-
-        return {
-            "started_at_iso": started_at.isoformat(),
-            "ended_at_iso": ended_at.isoformat(),
-            "label": (
-                f"{started_at.strftime(friendly_format)} to "
-                f"{ended_at.strftime(friendly_format)} (Asia/Karachi)"
-            ),
-        }
-
-    def _extract_specific_date_window(self, question: str) -> tuple[datetime, datetime, str] | None:
-        timezone = ZoneInfo("Asia/Karachi")
-        patterns = [
-            r"\b(\d{4})-(\d{1,2})-(\d{1,2})\b",
-            r"\b(\d{1,2})/(\d{1,2})/(\d{4})\b",
-            r"\b(\d{1,2})-(\d{1,2})-(\d{4})\b",
-        ]
-
-        for pattern in patterns:
-            match = re.search(pattern, question)
-            if not match:
-                continue
-            groups = match.groups()
-            try:
-                if pattern.startswith(r"\b(\d{4})"):
-                    year, month, day = int(groups[0]), int(groups[1]), int(groups[2])
-                else:
-                    day, month, year = int(groups[0]), int(groups[1]), int(groups[2])
-                anchor_date = datetime(year, month, day, 6, 0, 0, tzinfo=timezone)
-                end_date = anchor_date + timedelta(days=1)
-                label = (
-                    f"{anchor_date.strftime('%d %b %Y')} 06:00 AM to "
-                    f"{end_date.strftime('%d %b %Y')} 06:00 AM"
-                )
-                return anchor_date, end_date, label
-            except ValueError:
-                continue
-
-        month_name_patterns = [
-            r"\b(\d{1,2})(?:st|nd|rd|th)?\s+([A-Za-z]+)\s*,?\s*(\d{4})\b",
-            r"\b([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?\s*,?\s*(\d{4})\b",
-            r"\b(\d{1,2})(?:st|nd|rd|th)?\s+([A-Za-z]+)\b",
-            r"\b([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?\b",
-        ]
-        month_map = {
-            "jan": 1, "january": 1,
-            "feb": 2, "february": 2,
-            "mar": 3, "march": 3,
-            "apr": 4, "april": 4,
-            "may": 5,
-            "jun": 6, "june": 6,
-            "jul": 7, "july": 7,
-            "aug": 8, "august": 8,
-            "sep": 9, "sept": 9, "september": 9,
-            "oct": 10, "october": 10,
-            "nov": 11, "november": 11,
-            "dec": 12, "decebmber": 12, "december": 12,
-        }
-        now_local = datetime.now(timezone)
-        for pattern in month_name_patterns:
-            match = re.search(pattern, question, flags=re.IGNORECASE)
-            if not match:
-                continue
-            groups = match.groups()
-            try:
-                if pattern.startswith(r"\b(\d"):
-                    day = int(groups[0])
-                    month = month_map.get(groups[1].lower())
-                    year = int(groups[2]) if len(groups) > 2 and groups[2] else now_local.year
-                else:
-                    month = month_map.get(groups[0].lower())
-                    day = int(groups[1])
-                    year = int(groups[2]) if len(groups) > 2 and groups[2] else now_local.year
-                if month is None:
-                    continue
-                anchor_date = datetime(year, month, day, 6, 0, 0, tzinfo=timezone)
-                end_date = anchor_date + timedelta(days=1)
-                label = (
-                    f"{anchor_date.strftime('%d %b %Y')} 06:00 AM to "
-                    f"{end_date.strftime('%d %b %Y')} 06:00 AM"
-                )
-                return anchor_date, end_date, label
-            except ValueError:
-                continue
-
-        ordinal_only = re.search(r"\b(\d{1,2})(?:st|nd|rd|th)\b", question, flags=re.IGNORECASE)
-        if ordinal_only:
-            day = int(ordinal_only.group(1))
-            year = now_local.year
-            month = now_local.month
-            if day > now_local.day:
-                if month == 1:
-                    month = 12
-                    year -= 1
-                else:
-                    month -= 1
-            try:
-                anchor_date = datetime(year, month, day, 6, 0, 0, tzinfo=timezone)
-                end_date = anchor_date + timedelta(days=1)
-                label = (
-                    f"{anchor_date.strftime('%d %b %Y')} 06:00 AM to "
-                    f"{end_date.strftime('%d %b %Y')} 06:00 AM"
-                )
-                return anchor_date, end_date, label
-            except ValueError:
-                return None
-        return None
-
-    def _extract_relative_duration_window(self, question: str) -> TimeWindow | None:
-        lowered = question.lower()
-
-        unit_map = {
-            "h": "hours",
-            "hr": "hours",
-            "hrs": "hours",
-            "hour": "hours",
-            "hours": "hours",
-            "d": "days",
-            "day": "days",
-            "days": "days",
-            "w": "weeks",
-            "wk": "weeks",
-            "wks": "weeks",
-            "week": "weeks",
-            "weeks": "weeks",
-            "m": "months",
-            "mo": "months",
-            "mon": "months",
-            "month": "months",
-            "months": "months",
-            "min": "minutes",
-            "mins": "minutes",
-            "minute": "minutes",
-            "minutes": "minutes",
-        }
-
-        def build_window(value: int, raw_unit: str) -> TimeWindow | None:
-            unit = unit_map.get(raw_unit.lower())
-            if unit is None:
-                return None
-            return TimeWindow(
-                scope="historical",
-                value=value,
-                unit=unit,
-                label=f"last {value} {unit}",
-            )
-
-        pattern = r"\b(?:last|past|for|previous|in)\s+(\d+)\s*(h|hr|hrs?|hours?|d|days?|w|wk|wks|weeks?|m|mo|mon|months?|min|mins?|minutes?)\b"
-        match = re.search(pattern, lowered)
-        if match:
-            built = build_window(int(match.group(1)), match.group(2))
-            if built is not None:
-                return built
-
-        pattern_single = r"\b(?:last|past|for|previous|in)\s+(?:an?|1)\s+(h|hr|hrs?|hours?|d|days?|w|wk|wks|weeks?|m|mo|mon|months?|min|mins?|minutes?)\b"
-        match_single = re.search(pattern_single, lowered)
-        if match_single:
-            built = build_window(1, match_single.group(1))
-            if built is not None:
-                return built
-
-        pattern_bare = r"\b(\d+)\s*(h|hr|hrs?|hours?|d|days?|w|wk|wks|weeks?|m|mo|mon|months?|min|mins?|minutes?)\b"
-        match_bare = re.search(pattern_bare, lowered)
-        if match_bare:
-            built = build_window(int(match_bare.group(1)), match_bare.group(2))
-            if built is not None:
-                return built
-
-        return None
-
-    def _extract_explicit_time_range_window(self, question: str) -> tuple[datetime, datetime, str] | None:
-        timezone = ZoneInfo("Asia/Karachi")
-        lowered = question.lower()
-        range_match = re.search(
-            r"\b(?:from\s+)?(\d{1,2}(?::\d{2})?\s*(?:am|pm))\s*(?:to|-|till|until)\s*(\d{1,2}(?::\d{2})?\s*(?:am|pm))\b",
-            lowered,
-            flags=re.IGNORECASE,
-        )
-        if not range_match:
-            return None
-
-        start_hm = self._parse_clock_token(range_match.group(1))
-        end_hm = self._parse_clock_token(range_match.group(2))
-        if start_hm is None or end_hm is None:
-            return None
-
-        anchor = self._extract_anchor_date(question, timezone) or datetime.now(timezone).date()
-        started_at = datetime(anchor.year, anchor.month, anchor.day, start_hm[0], start_hm[1], tzinfo=timezone)
-        ended_at = datetime(anchor.year, anchor.month, anchor.day, end_hm[0], end_hm[1], tzinfo=timezone)
-        if ended_at <= started_at:
-            ended_at += timedelta(days=1)
-
-        friendly_format = "%d %b %Y, %I:%M %p"
-        label = f"{started_at.strftime(friendly_format)} to {ended_at.strftime(friendly_format)} (Asia/Karachi)"
-        return started_at, ended_at, label
-
-    def _parse_clock_token(self, token: str) -> tuple[int, int] | None:
-        match = re.match(r"^\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*$", token.strip(), flags=re.IGNORECASE)
-        if not match:
-            return None
-        hour = int(match.group(1))
-        minute = int(match.group(2) or "0")
-        meridian = match.group(3).lower()
-        if hour < 1 or hour > 12 or minute < 0 or minute > 59:
-            return None
-        if meridian == "am":
-            hour = 0 if hour == 12 else hour
-        else:
-            hour = 12 if hour == 12 else hour + 12
-        return hour, minute
-
-    def _extract_anchor_date(self, question: str, timezone: ZoneInfo) -> date | None:
-        patterns = [
-            r"\b(\d{4})-(\d{1,2})-(\d{1,2})\b",
-            r"\b(\d{1,2})/(\d{1,2})/(\d{4})\b",
-            r"\b(\d{1,2})-(\d{1,2})-(\d{4})\b",
-        ]
-
-        for pattern in patterns:
-            match = re.search(pattern, question)
-            if not match:
-                continue
-            groups = match.groups()
-            try:
-                if pattern.startswith(r"\b(\d{4})"):
-                    year, month, day = int(groups[0]), int(groups[1]), int(groups[2])
-                else:
-                    day, month, year = int(groups[0]), int(groups[1]), int(groups[2])
-                return date(year, month, day)
-            except ValueError:
-                continue
-
-        month_name_patterns = [
-            r"\b(\d{1,2})(?:st|nd|rd|th)?\s+([A-Za-z]+)\s*,?\s*(\d{4})\b",
-            r"\b([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?\s*,?\s*(\d{4})\b",
-            r"\b(\d{1,2})(?:st|nd|rd|th)?\s+([A-Za-z]+)\b",
-            r"\b([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?\b",
-        ]
-        month_map = {
-            "jan": 1, "january": 1,
-            "feb": 2, "february": 2,
-            "mar": 3, "march": 3,
-            "apr": 4, "april": 4,
-            "may": 5,
-            "jun": 6, "june": 6,
-            "jul": 7, "july": 7,
-            "aug": 8, "august": 8,
-            "sep": 9, "sept": 9, "september": 9,
-            "oct": 10, "october": 10,
-            "nov": 11, "november": 11,
-            "dec": 12, "decebmber": 12, "december": 12,
-        }
-        now_local = datetime.now(timezone)
-        for pattern in month_name_patterns:
-            match = re.search(pattern, question, flags=re.IGNORECASE)
-            if not match:
-                continue
-            groups = match.groups()
-            try:
-                if pattern.startswith(r"\b(\d"):
-                    day = int(groups[0])
-                    month = month_map.get(groups[1].lower())
-                    year = int(groups[2]) if len(groups) > 2 and groups[2] else now_local.year
-                else:
-                    month = month_map.get(groups[0].lower())
-                    day = int(groups[1])
-                    year = int(groups[2]) if len(groups) > 2 and groups[2] else now_local.year
-                if month is None:
-                    continue
-                return date(year, month, day)
-            except ValueError:
-                continue
-
-        ordinal_only = re.search(r"\b(\d{1,2})(?:st|nd|rd|th)\b", question, flags=re.IGNORECASE)
-        if ordinal_only:
-            day = int(ordinal_only.group(1))
-            year = now_local.year
-            month = now_local.month
-            if day > now_local.day:
-                if month == 1:
-                    month = 12
-                    year -= 1
-                else:
-                    month -= 1
-            try:
-                return date(year, month, day)
-            except ValueError:
-                return None
-        return None
-
-    def _extract_relative_day_window(self, question: str) -> tuple[datetime, datetime, str] | None:
-        text = question.lower()
-        timezone = ZoneInfo("Asia/Karachi")
-        now_local = datetime.now(timezone)
-
-        if "today" in text or "scheduled" in text:
-            shift_start = now_local.replace(hour=6, minute=0, second=0, microsecond=0)
-            if now_local < shift_start:
-                shift_start = shift_start - timedelta(days=1)
-            label = (
-                f"{shift_start.strftime('%d %b %Y')} 06:00 AM to "
-                f"{now_local.strftime('%d %b %Y %I:%M %p')}"
-            )
-            return shift_start, now_local, label
-
-        if "yesterday" in text:
-            today_shift_start = now_local.replace(hour=6, minute=0, second=0, microsecond=0)
-            if now_local < today_shift_start:
-                today_shift_start = today_shift_start - timedelta(days=1)
-            yesterday_shift_start = today_shift_start - timedelta(days=1)
-            label = (
-                f"{yesterday_shift_start.strftime('%d %b %Y')} 06:00 AM to "
-                f"{today_shift_start.strftime('%d %b %Y')} 06:00 AM"
-            )
-            return yesterday_shift_start, today_shift_start, label
-
-        return None
-
-    def _clip_rows_to_window(self, rows: list[dict], time_window: TimeWindow) -> list[dict]:
-        if not rows or not time_window.start_at or not time_window.end_at:
-            return rows
-        try:
-            start_dt = datetime.fromisoformat(time_window.start_at)
-            end_dt = datetime.fromisoformat(time_window.end_at)
-        except ValueError:
-            return rows
-
-        timestamp_keys = ("recorded_at", "timestamp", "local_time", "raw_time")
-        filtered: list[dict] = []
-        for row in rows:
-            row_ts = None
-            for key in timestamp_keys:
-                value = row.get(key)
-                if value is None:
-                    continue
-                row_ts = self._parse_datetime(value)
-                if row_ts is not None:
-                    break
-            if row_ts is None:
-                filtered.append(row)
-                continue
-
-            if row_ts.tzinfo is None and start_dt.tzinfo is not None:
-                row_ts = row_ts.replace(tzinfo=start_dt.tzinfo)
-            if start_dt <= row_ts < end_dt:
-                filtered.append(row)
-        return filtered
-
-    def _parse_datetime(self, value: object) -> datetime | None:
-        if isinstance(value, datetime):
-            return value
-        text = str(value).strip()
-        if not text:
-            return None
-        try:
-            return datetime.fromisoformat(text.replace("Z", "+00:00"))
-        except ValueError:
-            pass
-        for fmt in (
-            "%d %b %Y, %I:%M:%S %p",
-            "%d %b %Y, %I:%M %p",
-            "%d-%m-%Y %I:%M %p",
-            "%Y-%m-%d %H:%M:%S",
-            "%Y-%m-%d %H:%M",
-        ):
-            try:
-                return datetime.strptime(text, fmt)
-            except ValueError:
-                continue
-        return None
-
-    def _default_planner_result(self) -> dict:
-        return {
-            "asset_id": "",
-            "analysis_name": "live_status",
-            "time_window": {
-                "scope": "historical",
-                "value": 3,
-                "unit": "hours",
-                "label": "last 3 hours",
-            },
-            "reasoning": "Planner bypassed.",
-            "prompt_text": "[BYPASSED]",
-        }
-
-    def _build_asset_catalog_context(self, candidates: list) -> str:
-        shortlisted = candidates[:4] if candidates else live_asset_registry.list_assets()[:5]
-        entries: list[str] = []
-        total_chars = 0
-        max_chars = 2400
-        for asset in shortlisted:
-            aliases = [
-                alias for alias in asset.lookup_names
-                if alias and alias.lower() != asset.name.lower()
-            ][:2]
-            entry = json.dumps(
-                {
-                    "asset_id": asset.asset_id,
-                    "name": asset.name,
-                    "aliases": aliases,
-                    "type": asset.asset_type,
-                    "parent": asset.parent_name or "",
-                    "child_count": asset.child_count,
-                    "has_live_data": asset.has_live_data,
-                    "data_keys": asset.data_keys[:4],
-                    "supported_analyses": asset.supported_analyses[:3],
-                }
-            )
-            if total_chars + len(entry) > max_chars:
-                break
-            entries.append(entry)
-            total_chars += len(entry)
-        return "\n".join(entries)
-
-    def _chart_hints_for_analysis(self, analysis_name: str) -> list[str]:
-        mapping = {
-            "cooling_cycle_analysis": ["line_chart", "event_markers"],
-            "consumption_analysis": ["line_chart", "duration_summary", "event_markers"],
-            "live_status": ["stat_cards"],
-            "trend_analysis": ["line_chart"],
-            "historical_variance": ["line_chart", "box_plot"],
-            "throughput_utilization": ["bar_chart", "line_chart"],
-            "inventory_level_analysis": ["line_chart", "threshold_bands"],
-            "anomaly_detection": ["line_chart", "anomaly_table"],
-        }
-        return mapping.get(analysis_name, ["line_chart"])
-
-
-analysis_agent_service = AnalysisAgentService()

agents/analysis/backend/app/services/asset_analysis_instructions.py

@@ -1,178 +0,0 @@
-from __future__ import annotations
-
-from agents.analysis.backend.app.core.config import get_settings
-from agents.analysis.backend.app.models.schemas import AssetProfile
-
-
-ASSET_TYPE_ANALYSIS_GUIDANCE = {
-    "cold_room": """
-For cold rooms, prioritize:
-- live device health and payload freshness
-- current temperature and humidity
-- acceptable temperature band compliance
-- historical drift, highs, lows, and instability
-- cooling cycle estimation and repeated threshold breaches
-- consumption analysis from temperature history when the asset belongs to T & H Monitoring
-
-Preferred analysis choice:
-- if user asks about live/current/status -> live_status
-- if the asset is in T & H Monitoring and the user asks for a time window, prefer consumption_analysis
-- if user asks about temperature pattern, cooling, stability -> cooling_cycle_analysis
-- if user asks for previous day/week/month comparison -> historical_variance
-- if user asks about abnormal behavior -> anomaly_detection
-""".strip(),
-    "filling_machine": """
-For filling machines, prioritize:
-- current production counters
-- per-shift throughput
-- stale payload detection
-- production movement over the requested time window
-- identifying flat output, drops, or sudden spikes
-
-Preferred analysis choice:
-- if user asks about live/current/status -> live_status
-- if user asks about production, throughput, utilization -> throughput_utilization
-- if user asks about previous windows or comparisons -> historical_variance
-- if user asks about unusual behavior -> anomaly_detection
-""".strip(),
-    "tank": """
-For tanks, prioritize:
-- current level
-- short-term and long-term rate of change
-- refill and depletion pattern
-- sharp drops and low-level risk
-- stale payload detection
-
-Preferred analysis choice:
-- if user asks about live/current/status -> live_status
-- if user asks about level movement or stock behavior -> inventory_level_analysis
-- if user asks for historical movement -> trend_analysis
-- if user asks about unusual drops -> anomaly_detection
-""".strip(),
-    "smoke_alarm": """
-For smoke alarm systems, prioritize:
-- Enlisting ALL assets and ALL their attributes in a concise summary.
-- Use the 'static_attributes' JSON provided in the data rows to discover all configured attributes for an asset, even if they have no live telemetry.
-- If all are okay, keep the per-asset summary brief (one line per asset).
-- If smoke, fire, fault, or low-battery is detected, provide the detailed breakdown immediately for that specific asset.
-- Highlight smoke/fire detection events prominently.
-- Ensure health status, battery, temperature, and humidity are mentioned for every device.
-
-Preferred analysis choice:
-- if user asks about live/current/status -> live_status
-- if user asks whether smoke/fire happened -> anomaly_detection
-- if user asks about a category/group -> group_status
-""".strip(),
-    "energy_meter": """
-For energy meters, prioritize:
-- overall power and energy consumption
-- peak usage identification
-- breaking down consumption by child meters
-- power factor anomalies
-- voltage or current imbalances
-
-Preferred analysis choice:
-- if user asks about live/current/status -> live_status
-- if user asks about consumption, peak usage, or breakdown -> consumption_analysis
-- if user asks about historical trends -> trend_analysis
-- if user asks about a category/group -> group_status
-""".strip(),
-}
-
-
-ASSET_NAME_OVERRIDES = {
-    "Cold Room 1": """
-This cold room should be treated as a temperature-preservation asset.
-The final answer should clearly mention whether it is stable, outside band,
-or stale/offline, and whether temperature movement suggests a cooling issue.
-""".strip(),
-    "Filling Machine 1": """
-This machine should be treated as a throughput asset.
-The final answer should clearly mention total count movement, strongest shift,
-and whether the payload looks stale or flat.
-""".strip(),
-    "Oil Tank 1": """
-This tank should be treated as an inventory asset.
-The final answer should clearly mention current level, whether the trend is falling,
-and whether the level looks risky.
-""".strip(),
-}
-
-
-def build_asset_llm_context(asset: AssetProfile) -> str:
-    parts = [
-        f"Asset selected from chat: {asset.name}",
-        f"Asset type: {asset.asset_type}",
-        f"Is device with sensor data: {asset.is_device}",
-        f"Parent asset: {asset.parent_name or 'None'}",
-        f"Direct child count: {asset.child_count}",
-        f"Asset description: {asset.description}",
-        f"Lookup aliases: {', '.join(asset.lookup_names) if asset.lookup_names else asset.name}",
-        f"Supported analyses: {', '.join(asset.supported_analyses)}",
-        f"Important metrics: {', '.join(asset.metrics)}",
-        f"Attribute keys: {', '.join(asset.attribute_keys[:20]) if asset.attribute_keys else 'None'}",
-        (
-            "Exact telemetry keys: "
-            f"temperature={asset.temperature_keys}, "
-            f"humidity={asset.humidity_keys}, "
-            f"level={asset.level_keys}, "
-            f"production={asset.production_keys}"
-        ),
-        (
-            "OpenRemote SQL facts: "
-            "join openremote.asset_datapoint to openremote.asset using ad.entity_id = a.id, "
-            "telemetry is usually under ad.value JSON, "
-            "multiple attributes can contain JSON sensor payloads, "
-            "the analysis should inspect all relevant JSON-carrying attributes unless the user narrows the request, "
-            "historical data should be read from asset datapoints, "
-            f"and OpenRemote time should be adjusted to local time by adding the {get_settings().local_time_offset_hours}-hour offset (e.g. ad.timestamp + INTERVAL '{get_settings().local_time_offset_hours} hours')."
-        ),
-        (
-            "Device vs category rule: only assets whose attributes contain keys other than notes and location "
-            "should be treated as real sensor devices. Parent/group assets should be analyzed via their child assets."
-        ),
-        (
-            f"Nominal thresholds: {asset.nominal_range if asset.nominal_range else {'min_temperature': 5.0, 'max_temperature': 45.0}}. "
-            "Use these thresholds for compliance checks and avoid introducing any unstated default range."
-        ),
-    ]
-
-    if asset.asset_type == "tank":
-        parts.append(
-            "Tank rule: for tank-related devices, the actual physical liquid height is MaxFt - TankOilLevelInFeet001. "
-            "These values can come from two different attributes, so the analysis must combine them before drawing conclusions. "
-            "The final analysis should prioritize showing the percentage filled (e.g., 75% filled) rather than just the height, "
-            "using the formula (liquid height / MaxFt) * 100. "
-            "Do not explain how you calculated the level or percentage to the user."
-        )
-
-    if "t & h monitoring" in f"{asset.name} {asset.parent_name}".lower():
-        parts.append(
-            "T & H Monitoring consumption rule: determine cold-room ON/OFF state from temperature trend rather than a direct signal. "
-            "A cooling cycle starts at the last peak before temperature begins decreasing and later drops below 20C. "
-            "The cycle stays ON while temperature remains below 20C and ends at the valley before temperature rises back to 20C or above."
-            "Sum all such cycle durations across the requested window, clip any cycle that began before the shift to 6:00 AM, "
-            "and if a cycle is still active at the end of the data, count it up to the latest timestamp."
-        )
-
-    if asset.asset_type == "smoke_alarm":
-        parts.append(
-            "Smoke-alarm rule: inspect every relevant JSON-carrying attribute for each end device. "
-            "Treat warn='warn' as smoke/fire detected, warn='mute' as alarm was muted after detection, "
-            "warn='fault' as device fault, warn='remove' as device removed, warn='install' as device installed, "
-            "warn='low-vol' or warn='low-vol-test' as low battery/voltage, and warn='ok' as normal. "
-            "The answer must clearly state whether smoke/fire was detected and include the timestamps of those events."
-        )
-
-    type_guidance = ASSET_TYPE_ANALYSIS_GUIDANCE.get(asset.asset_type)
-    if type_guidance:
-        parts.append(type_guidance)
-
-    override = ASSET_NAME_OVERRIDES.get(asset.name)
-    if override:
-        parts.append(override)
-
-    if asset.analysis_instructions:
-        parts.append(f"Asset-specific rules: {asset.analysis_instructions}")
-
-    return "\n\n".join(parts)

agents/analysis/backend/app/services/asset_catalog.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import yaml
-
-from agents.analysis.backend.app.models.schemas import AssetProfile
-
-
-class AssetCatalogService:
-    def __init__(self) -> None:
-        self._catalog_path = Path(__file__).resolve().parents[2] / "data" / "asset_catalog.yaml"
-        self._cache: dict[str, AssetProfile] | None = None
-
-    def _load(self) -> dict[str, AssetProfile]:
-        raw = yaml.safe_load(self._catalog_path.read_text(encoding="utf-8"))
-        assets = raw.get("assets", [])
-        return {
-            asset["asset_id"]: AssetProfile(**asset)
-            for asset in assets
-        }
-
-    def list_assets(self) -> list[AssetProfile]:
-        self._cache = self._load()
-        return list(self._cache.values())
-
-    def get_asset(self, asset_id: str) -> AssetProfile | None:
-        self._cache = self._load()
-        return self._cache.get(asset_id)
-
-    def get_asset_by_name(self, name: str) -> AssetProfile | None:
-        normalized_name = self._normalize(name)
-        for asset in self.list_assets():
-            aliases = [asset.name, asset.asset_id, *asset.lookup_names]
-            if any(self._normalize(alias) == normalized_name for alias in aliases):
-                return asset
-        return None
-
-    def find_asset_by_message(self, message: str) -> AssetProfile | None:
-        normalized_message = self._normalize(message)
-        best_match: AssetProfile | None = None
-        best_length = -1
-
-        for asset in self.list_assets():
-            aliases = [asset.asset_id, asset.name, *asset.lookup_names]
-            for alias in aliases:
-                normalized_alias = self._normalize(alias)
-                if normalized_alias and normalized_alias in normalized_message:
-                    if len(normalized_alias) > best_length:
-                        best_match = asset
-                        best_length = len(normalized_alias)
-        return best_match
-
-    def list_asset_names(self) -> list[str]:
-        names: list[str] = []
-        for asset in self.list_assets():
-            names.append(asset.name)
-            names.extend(asset.lookup_names)
-        return sorted(set(names))
-
-    def _normalize(self, value: str) -> str:
-        return "".join(value.lower().split())
-
-
-asset_catalog_service = AssetCatalogService()

agents/analysis/backend/app/services/data_repository.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from datetime import date, datetime
-
-from sqlalchemy import create_engine, text
-from sqlalchemy.exc import SQLAlchemyError
-
-from agents.analysis.backend.app.core.config import get_settings
-
-
-class DataQueryError(RuntimeError):
-    pass
-
-
-class DataRepository:
-    def __init__(self) -> None:
-        self._settings = get_settings()
-        self._engine = create_engine(
-            self._normalize_database_url(self._settings.database_url),
-            future=True,
-            pool_pre_ping=True,
-        )
-
-    def execute_query(self, query: str, params: dict | None = None) -> list[dict]:
-        try:
-            with self._engine.connect() as connection:
-                result = connection.execute(text(query), params or {})
-                return [self._normalize_row(dict(row._mapping)) for row in result]
-        except SQLAlchemyError as exc:
-            raise DataQueryError(f"Database query failed: {exc.__class__.__name__}: {exc}") from exc
-
-    def _normalize_database_url(self, database_url: str) -> str:
-        if database_url.startswith("postgresql://"):
-            return database_url.replace("postgresql://", "postgresql+psycopg://", 1)
-        return database_url
-
-    def _normalize_row(self, row: dict) -> dict:
-        normalized: dict = {}
-        for key, value in row.items():
-            if isinstance(value, datetime):
-                normalized[key] = value.strftime("%d %b %Y, %I:%M:%S %p")
-            elif isinstance(value, date):
-                normalized[key] = value.strftime("%d %b %Y")
-            else:
-                normalized[key] = value
-        return normalized
-
-
-data_repository = DataRepository()

agents/analysis/backend/app/services/deterministic_analysis.py

@@ -1,638 +0,0 @@
-from __future__ import annotations
-
-from decimal import Decimal, InvalidOperation
-from datetime import datetime, time
-from statistics import mean
-from collections import defaultdict
-
-from agents.analysis.backend.app.models.schemas import AssetProfile
-
-
-class DeterministicAnalysisService:
-    def summarize(self, asset: AssetProfile, rows: list[dict]) -> dict[str, object]:
-        base = self._generic_summary(rows)
-        domain_summary = self._asset_specific_summary(asset, rows)
-        base["warnings"].extend(domain_summary["warnings"])
-        base["findings"] = domain_summary["findings"]
-        return base
-
-    def _generic_summary(self, rows: list[dict]) -> dict[str, object]:
-        if not rows:
-            return {
-                "numeric_metrics": {},
-                "warnings": ["No telemetry rows were returned for the requested window."],
-                "findings": [],
-            }
-
-        numeric_columns: dict[str, list[float]] = {}
-        for row in rows:
-            for key, value in row.items():
-                if isinstance(value, bool):
-                    continue
-                numeric_value = self._as_float(value)
-                if numeric_value is not None:
-                    numeric_columns.setdefault(key, []).append(numeric_value)
-
-        metric_summary: dict[str, dict[str, float]] = {}
-        warnings: list[str] = []
-
-        for column, values in numeric_columns.items():
-            if not values:
-                continue
-            avg = mean(values)
-            metric_summary[column] = {
-                "min": min(values),
-                "max": max(values),
-                "avg": round(avg, 3),
-                "latest": values[-1],
-            }
-
-            if len(values) > 1 and avg != 0:
-                spread = max(values) - min(values)
-                if spread > abs(avg) * 0.2:
-                    warnings.append(
-                        f"{column} changed noticeably across the requested window "
-                        f"(min={min(values):.2f}, max={max(values):.2f})."
-                    )
-
-        return {
-            "numeric_metrics": metric_summary,
-            "warnings": warnings,
-            "findings": self._generic_trend_findings(metric_summary),
-        }
-
-    def _asset_specific_summary(self, asset: AssetProfile, rows: list[dict]) -> dict[str, object]:
-        if asset.asset_type == "cold_room":
-            return self._cold_room_summary(asset, rows)
-        if asset.asset_type == "filling_machine":
-            return self._filling_machine_summary(rows)
-        if asset.asset_type == "tank":
-            return self._tank_summary(asset, rows)
-        if asset.asset_type == "smoke_alarm":
-            return self._smoke_alarm_summary(asset, rows)
-        return {"warnings": [], "findings": []}
-
-    def _smoke_alarm_summary(self, asset: AssetProfile, rows: list[dict]) -> dict[str, object]:
-        findings: list[str] = []
-        warnings: list[str] = []
-
-        per_asset: dict[str, list[dict]] = defaultdict(list)
-        for row in rows:
-            asset_name = str(row.get("asset_name") or asset.name or "Unknown")
-            per_asset[asset_name].append(row)
-
-        if not per_asset:
-            return {"warnings": ["No smoke-alarm telemetry rows were available for the requested window."], "findings": []}
-
-        smoke_events: list[tuple[str, datetime | None, str]] = []
-        muted_events: list[tuple[str, datetime | None, str]] = []
-        fault_events: list[tuple[str, datetime | None, str]] = []
-        remove_events: list[tuple[str, datetime | None, str]] = []
-        low_voltage_assets: set[str] = set()
-        unknown_assets: set[str] = set()
-        latest_states: list[str] = []
-
-        for asset_name, asset_rows in sorted(per_asset.items()):
-            ordered = sorted(asset_rows, key=lambda row: self._parse_datetime(row.get("recorded_at") or row.get("timestamp")) or datetime.min)
-            per_sensor: dict[str, list[dict]] = defaultdict(list)
-            for row in ordered:
-                sensor_name = str(row.get("attribute_name") or row.get("sensor_name") or "sensor")
-                per_sensor[sensor_name].append(row)
-
-            for row in ordered:
-                warn_type = self._normalize_warn_type(row.get("warn_type"))
-                event_time = self._parse_datetime(row.get("recorded_at") or row.get("timestamp"))
-                attribute_name = str(row.get("attribute_name") or row.get("sensor_name") or "sensor")
-                event_ref = (asset_name, event_time, attribute_name)
-                if warn_type == "warn":
-                    smoke_events.append(event_ref)
-                elif warn_type == "mute":
-                    muted_events.append(event_ref)
-                elif warn_type == "fault":
-                    fault_events.append(event_ref)
-                elif warn_type == "remove":
-                    remove_events.append(event_ref)
-                elif warn_type in {"low-vol", "low-vol-test"}:
-                    low_voltage_assets.add(asset_name)
-                elif warn_type == "unknown":
-                    unknown_assets.add(asset_name)
-
-            latest_sensor_summaries: list[str] = []
-            for sensor_name, sensor_rows in sorted(per_sensor.items()):
-                latest_row = sensor_rows[-1]
-                
-                # Strict smoke detection: only if warn_type is 'warn' 
-                is_actual_smoke = any(str(r.get("warn_type", "")).lower() == "warn" for r in sensor_rows)
-                latest_warn: str | None = "SMOKE DETECTED" if is_actual_smoke else self._normalize_warn_type(latest_row.get("warn_type"))
-                if is_actual_smoke:
-                    smoke_events.append((asset_name, self._parse_datetime(latest_row.get("recorded_at") or latest_row.get("timestamp")), sensor_name))
-                
-                latest_time = self._parse_datetime(latest_row.get("recorded_at") or latest_row.get("timestamp"))
-                latest_temp = self._as_float(latest_row.get("temperature"))
-                latest_humidity = self._as_float(latest_row.get("humidity"))
-                latest_battery = self._as_float(latest_row.get("bat_percent"))
-
-                raw_data = latest_row.get("sensor_data")
-                if raw_data is None and latest_warn is None:
-                    # Explicit handling for assets with no data in the window
-                    state_fragments = [f"{sensor_name}: No recent telemetry found (Offline)"]
-                    latest_sensor_summaries.append(" ".join(state_fragments))
-                    continue
-
-                state_fragments = [f"{sensor_name}: {latest_warn or 'ok'}"]
-                if latest_time is not None:
-                    state_fragments.append(f"at {latest_time.strftime('%d %b %Y, %I:%M %p')}")
-                
-                details: list[str] = []
-                if latest_temp is not None:
-                    details.append(f"{latest_temp:.1f}C")
-                if latest_humidity is not None:
-                    details.append(f"{latest_humidity:.1f}% RH")
-                if latest_battery is not None:
-                    details.append(f"battery {latest_battery:.0f}%")
-
-                if isinstance(raw_data, dict):
-                    skip_keys = {"warn", "temp", "humi", "bat_percent", "bat_voltage", "name", "timestamp"}
-                    for k, v in raw_data.items():
-                        if k.lower() in skip_keys:
-                            continue
-                        val = self._as_float(v)
-                        if val is not None:
-                            details.append(f"{k}: {val}")
-                        elif isinstance(v, str) and len(v) < 20:
-                            details.append(f"{k}: {v}")
-                else:
-                    # Strict smoke detection: only if warn_type is 'warn'
-                    warn_type = str(latest_row.get("warn_type", "")).lower()
-                    is_actual_smoke = (warn_type == "warn")
-                    
-                    if is_actual_smoke:
-                        smoke_events.append(latest_row)
-                        latest_warn = "SMOKE DETECTED"
-                    # If it's a simple value, include it directly
-                    val = self._as_float(raw_data)
-                    if val is not None:
-                        details.append(f"value: {val}")
-                    elif raw_data is not None:
-                        details.append(f"value: {raw_data}")
-
-                if details:
-                    state_fragments.append(f"({', '.join(details)})")
-                
-                # For 'ok' status, show sensor name and details but omit the word 'ok'.
-                if not latest_warn or latest_warn == 'ok':
-                    # state_fragments[0] is like "data: ok" — keep the sensor name prefix, drop 'ok'
-                    sensor_label = state_fragments[0].split(":")[0].strip() + ":"
-                    ok_parts = [sensor_label] + state_fragments[1:]  # sensor_name: <time> <details>
-                    latest_sensor_summaries.append(" ".join(ok_parts))
-                else:
-                    latest_sensor_summaries.append(" ".join(state_fragments))
-
-            if latest_sensor_summaries:
-                latest_states.append(f"{asset_name}: {'; '.join(latest_sensor_summaries)}")
-
-        if smoke_events:
-            preview = ", ".join(
-                f"{name} at {(event_time.strftime('%d %b %I:%M %p') if event_time else 'unknown time')}"
-                for name, event_time, _ in smoke_events[:6]
-            )
-            findings.append(f"Smoke/fire was detected in {len(smoke_events)} event(s): {preview}.")
-        else:
-            findings.append("No smoke/fire detection event was found in the returned telemetry window.")
-
-        if muted_events:
-            preview = ", ".join(
-                f"{name} at {(event_time.strftime('%d %b %I:%M %p') if event_time else 'unknown time')}"
-                for name, event_time, _ in muted_events[:6]
-            )
-            findings.append(f"Alarm mute events were recorded for {len(muted_events)} event(s): {preview}.")
-
-        if fault_events:
-            preview = ", ".join(
-                f"{name} at {(event_time.strftime('%d %b %I:%M %p') if event_time else 'unknown time')}"
-                for name, event_time, _ in fault_events[:6]
-            )
-            warnings.append(f"Fault events were detected on {len(fault_events)} row(s): {preview}.")
-
-        if remove_events:
-            preview = ", ".join(
-                f"{name} at {(event_time.strftime('%d %b %I:%M %p') if event_time else 'unknown time')}"
-                for name, event_time, _ in remove_events[:6]
-            )
-            warnings.append(f"Sensor removal events were detected: {preview}.")
-
-        if low_voltage_assets:
-            warnings.append(
-                f"Low-voltage/battery alerts appeared on {len(low_voltage_assets)} device(s): "
-                + ", ".join(sorted(low_voltage_assets)[:8])
-                + ("." if len(low_voltage_assets) <= 8 else " ...")
-            )
-
-        if unknown_assets:
-            warnings.append(
-                f"Unknown warn states were reported by {len(unknown_assets)} device(s): "
-                + ", ".join(sorted(unknown_assets))
-                + "."
-            )
-
-        findings.extend(latest_states)
-        return {"warnings": warnings, "findings": findings}
-
-    def _cold_room_summary(self, asset: AssetProfile, rows: list[dict]) -> dict[str, object]:
-        findings: list[str] = []
-        warnings: list[str] = []
-        def get_val(row, keys):
-            # Try direct columns first
-            for k in keys:
-                if (v := self._as_float(row.get(k))) is not None:
-                    return v
-            # Then try nested in sensor_data
-            sd = row.get("sensor_data")
-            if isinstance(sd, dict):
-                for k in keys:
-                    if (v := self._as_float(sd.get(k))) is not None:
-                        return v
-            return None
-
-        temp_keys = asset.temperature_keys or ["Temperature", "temperature", "temp", "t", "temp1"]
-        humi_keys = asset.humidity_keys or ["Humidity", "humidity", "humi", "h", "hum"]
-
-        temps = [v for row in rows if (v := get_val(row, temp_keys)) is not None]
-        humis = [v for row in rows if (v := get_val(row, humi_keys)) is not None]
-        
-        stale = any(bool(row.get("is_stale")) for row in rows)
-        min_ok = asset.nominal_range.get("min_temperature", 5.0)
-        max_ok = asset.nominal_range.get("max_temperature", 45.0)
-
-        if temps:
-            latest = temps[0]
-            earliest = temps[-1]
-            findings.append(f"Latest temperature is {latest:.2f}C.")
-            findings.append(f"Observed range is {min(temps):.2f}C to {max(temps):.2f}C.")
-            findings.append(
-                f"Temperature trend over the window is {self._describe_trend(latest - earliest, 'C')}."
-            )
-            
-            # Use 20.0 as hardcoded cycle threshold if not specified, 
-            # but don't use it for nominal range warnings.
-            cycle_threshold = max_ok if max_ok is not None else 20.0
-            cycles = self._estimate_cooling_cycles(temps, threshold=cycle_threshold)
-            findings.append(f"Estimated cooling cycle count in this window: {cycles}.")
-            
-            consumption_summary = self._cooling_consumption_summary(rows)
-            if consumption_summary:
-                findings.extend(consumption_summary["findings"])
-                warnings.extend(consumption_summary["warnings"])
-            
-            if min_ok is not None and max_ok is not None:
-                if latest < min_ok or latest > max_ok:
-                    warnings.append(
-                        f"Latest temperature {latest:.2f}C is outside the nominal range of {min_ok:.2f}C to {max_ok:.2f}C."
-                    )
-                if max(temps) > max_ok:
-                    warnings.append(f"Temperature crossed the upper threshold of {max_ok:.2f}C.")
-
-        if stale:
-            warnings.append("The most recent cold room payload appears stale.")
-
-        return {"warnings": warnings, "findings": findings}
-
-    def _filling_machine_summary(self, rows: list[dict]) -> dict[str, object]:
-        findings: list[str] = []
-        warnings: list[str] = []
-        totals = [
-            numeric
-            for row in rows
-            if (numeric := self._as_float(row.get("total_count"))) is not None
-        ]
-        stale = any(bool(row.get("is_stale")) for row in rows)
-
-        if totals:
-            latest = totals[0]
-            earliest = totals[-1]
-            findings.append(f"Latest total production count is {latest:.0f}.")
-            findings.append(f"Net production movement in this window is {latest - earliest:.0f}.")
-            findings.append(
-                f"Production trend over the window is {self._describe_trend(latest - earliest, 'units', precision=0)}."
-            )
-            if latest == earliest and len(totals) > 1:
-                warnings.append("Production total did not change during the requested window.")
-
-        shift_columns = ["shift_1_count", "shift_2_count", "shift_3_count"]
-        shift_values = {
-            column: numeric
-            for column in shift_columns
-            if rows and (numeric := self._as_float(rows[0].get(column))) is not None
-        }
-        if shift_values:
-            best_shift = max(shift_values, key=shift_values.get)
-            findings.append(f"The strongest current shift metric is {best_shift} at {shift_values[best_shift]:.0f}.")
-
-        if stale:
-            warnings.append("The filling machine payload timestamp appears stale.")
-
-        return {"warnings": warnings, "findings": findings}
-
-    def _tank_summary(self, asset: AssetProfile, rows: list[dict]) -> dict[str, object]:
-        findings: list[str] = []
-        warnings: list[str] = []
-        low_level_threshold = asset.nominal_range.get("low_level_threshold", 3.0)
-
-        per_asset_points: dict[str, list[tuple[datetime, float, float | None, float | None]]] = defaultdict(list)
-        for row in rows:
-            level = self._as_float(row.get("current_level_ft"))
-            if level is None:
-                continue
-            raw_asset_name = row.get("asset_name") or row.get("name") or "Unknown"
-            asset_name = str(raw_asset_name)
-            timestamp = (
-                self._parse_datetime(row.get("recorded_at"))
-                or self._parse_datetime(row.get("timestamp"))
-                or self._parse_datetime(row.get("latest_time"))
-                or datetime.min
-            )
-            pct = self._as_float(row.get("percentage_filled"))
-            max_ft = self._as_float(row.get("max_ft"))
-            per_asset_points[asset_name].append((timestamp, level, pct, max_ft))
-
-        if not per_asset_points:
-            return {"warnings": ["No valid tank level points were available for deterministic analysis."], "findings": []}
-
-        per_asset_stats: list[dict[str, float | str | None]] = []
-        missing_capacity_assets: set[str] = set()
-        for asset_name, points in per_asset_points.items():
-            ordered = sorted(points, key=lambda item: item[0])
-            start_level = ordered[0][1]
-            end_level = ordered[-1][1]
-            min_level = min(point[1] for point in ordered)
-            max_level = max(point[1] for point in ordered)
-            pct_candidates = [point[2] for point in ordered if point[2] is not None]
-            max_ft_candidates = [point[3] for point in ordered if point[3] is not None]
-            if not max_ft_candidates:
-                missing_capacity_assets.add(asset_name)
-            end_pct = pct_candidates[-1] if pct_candidates else None
-            per_asset_stats.append(
-                {
-                    "asset_name": asset_name,
-                    "start_level": start_level,
-                    "end_level": end_level,
-                    "min_level": min_level,
-                    "max_level": max_level,
-                    "net_change": end_level - start_level,
-                    "end_pct": end_pct,
-                }
-            )
-
-        per_asset_stats.sort(key=lambda item: str(item["asset_name"]))
-        tank_count = len(per_asset_stats)
-        low_assets = [item for item in per_asset_stats if float(item["end_level"]) <= low_level_threshold]
-        depleted_assets = [item for item in per_asset_stats if float(item["net_change"]) < 0]
-        refilled_assets = [item for item in per_asset_stats if float(item["net_change"]) > 0]
-
-        findings.append(f"Analyzed {tank_count} tank assets across the requested window.")
-        findings.append(
-            f"End-of-window levels range from {min(float(item['end_level']) for item in per_asset_stats):.2f} ft to "
-            f"{max(float(item['end_level']) for item in per_asset_stats):.2f} ft."
-        )
-
-        if low_assets:
-            preview = ", ".join(
-                f"{str(item['asset_name'])} ({float(item['end_level']):.2f} ft)"
-                for item in low_assets[:5]
-            )
-            extra = f" +{len(low_assets) - 5} more" if len(low_assets) > 5 else ""
-            findings.append(
-                f"{len(low_assets)} tank(s) ended at or below {low_level_threshold:.1f} ft: {preview}{extra}."
-            )
-        else:
-            findings.append(f"No tank ended below the {low_level_threshold:.1f} ft threshold.")
-
-        findings.append(
-            f"Net movement summary: {len(depleted_assets)} tank(s) depleted, {len(refilled_assets)} tank(s) increased."
-        )
-
-        # Keep warnings concise and actionable.
-        if low_assets:
-            warnings.append(
-                f"Low-level risk in {len(low_assets)} tank(s); prioritize refill planning for those assets."
-            )
-        if missing_capacity_assets:
-            warnings.append(
-                f"MaxFt missing for {len(missing_capacity_assets)} asset(s), percentage-filled may be incomplete."
-            )
-
-        # Include a short sample of per-asset outcomes for LLM grounding.
-        compact_asset_lines = []
-        for item in per_asset_stats[:10]:
-            pct_text = (
-                f", {float(item['end_pct']):.1f}%"
-                if item["end_pct"] is not None
-                else ""
-            )
-            compact_asset_lines.append(
-                f"{item['asset_name']}: start {float(item['start_level']):.2f} ft, "
-                f"end {float(item['end_level']):.2f} ft, "
-                f"min {float(item['min_level']):.2f} ft, max {float(item['max_level']):.2f} ft{pct_text}."
-            )
-        findings.extend(compact_asset_lines)
-
-        # Minimal window-level warning summary.
-        stale = any(bool(row.get("is_stale")) for row in rows)
-        if stale:
-            warnings.append("Some tank readings in the window were stale.")
-
-        large_drops = [
-            item for item in per_asset_stats
-            if float(item["net_change"]) <= -1.5
-        ]
-        if large_drops:
-            warnings.append(f"Sharp depletion detected in {len(large_drops)} tank(s).")
-
-        return {"warnings": warnings, "findings": findings}
-
-    def _as_float(self, value: object) -> float | None:
-        if isinstance(value, bool) or value is None:
-            return None
-        if isinstance(value, (int, float, Decimal)):
-            return float(value)
-        if isinstance(value, str):
-            stripped = value.strip()
-            if not stripped:
-                return None
-            try:
-                return float(Decimal(stripped))
-            except (InvalidOperation, ValueError):
-                return None
-        return None
-
-    def _estimate_cooling_cycles(self, temperatures: list[float], threshold: float) -> int:
-        cycles = 0
-        cooling = False
-        for temperature in reversed(temperatures):
-            if not cooling and temperature > threshold:
-                cooling = True
-            elif cooling and temperature <= threshold:
-                cycles += 1
-                cooling = False
-        return cycles
-
-    def _cooling_consumption_summary(self, rows: list[dict]) -> dict[str, list[str]]:
-        points: list[tuple[datetime, float]] = []
-        for row in rows:
-            timestamp = self._parse_datetime(row.get("recorded_at")) or self._parse_datetime(row.get("timestamp"))
-            temperature = self._as_float(row.get("temperature"))
-            if timestamp is None or temperature is None:
-                continue
-            points.append((timestamp, temperature))
-
-        if len(points) < 3:
-            return {"findings": [], "warnings": []}
-
-        points.sort(key=lambda item: item[0])
-        threshold = 20.0
-        last_peak_idx = 0
-        in_cycle = False
-        cycle_start_idx: int | None = None
-        valley_idx: int | None = None
-        cycles: list[tuple[datetime, datetime]] = []
-
-        for idx in range(1, len(points)):
-            prev_temp = points[idx - 1][1]
-            current_temp = points[idx][1]
-
-            if not in_cycle:
-                if current_temp >= prev_temp:
-                    last_peak_idx = idx
-                elif current_temp < prev_temp and current_temp < threshold:
-                    cycle_start_idx = last_peak_idx
-                    valley_idx = idx
-                    in_cycle = True
-            else:
-                if valley_idx is None or current_temp <= points[valley_idx][1]:
-                    valley_idx = idx
-                if current_temp >= threshold:
-                    start_time = points[cycle_start_idx or 0][0]
-                    end_time = points[valley_idx or idx][0]
-                    cycles.append((start_time, end_time))
-                    in_cycle = False
-                    cycle_start_idx = None
-                    valley_idx = None
-                    last_peak_idx = idx
-
-        if in_cycle and cycle_start_idx is not None:
-            cycles.append((points[cycle_start_idx][0], points[-1][0]))
-
-        if not cycles:
-            return {
-                "findings": ["No confirmed cooling cycle reached the ON threshold of 20C in the returned time window."],
-                "warnings": [],
-            }
-
-        shift_anchor = datetime.combine(points[0][0].date(), time(hour=6), tzinfo=points[0][0].tzinfo)
-        total_on_seconds = 0.0
-        clipped_cycles: list[tuple[datetime, datetime]] = []
-        for start_time, end_time in cycles:
-            adjusted_start = max(start_time, shift_anchor)
-            if end_time > adjusted_start:
-                total_on_seconds += (end_time - adjusted_start).total_seconds()
-                clipped_cycles.append((adjusted_start, end_time))
-
-        total_hours = total_on_seconds / 3600
-        findings = [
-            f"Inferred cooling cycle count for the requested window is {len(clipped_cycles)}.",
-            f"Total inferred ON time from temperature-driven cooling cycles is {total_hours:.2f} hours, clipped to the 6:00 AM shift start where needed.",
-        ]
-        if clipped_cycles and clipped_cycles[-1][1] == points[-1][0]:
-            findings.append("The latest cooling cycle appears to still be active, so ON time was counted up to the newest timestamp.")
-
-        return {"findings": findings, "warnings": []}
-
-    def _generic_trend_findings(self, metric_summary: dict[str, dict[str, float]]) -> list[str]:
-        findings: list[str] = []
-        priority_columns = [
-            "temperature",
-            "humidity",
-            "total_count",
-            "current_level_ft",
-            "level_change",
-        ]
-        emitted = 0
-        for column in priority_columns + [column for column in metric_summary if column not in priority_columns]:
-            summary = metric_summary.get(column)
-            if not summary:
-                continue
-            drift = summary["latest"] - summary["avg"]
-            findings.append(
-                f"{column} latest value is {summary['latest']:.2f}, with a window average of {summary['avg']:.2f} and range {summary['min']:.2f} to {summary['max']:.2f}."
-            )
-            if abs(drift) > 0:
-                findings.append(
-                    f"{column} is currently {self._describe_trend(drift, '', include_magnitude=False)} versus its window average."
-                )
-            emitted += 1
-            if emitted >= 2:
-                break
-        return findings
-
-    def _describe_trend(
-        self,
-        delta: float,
-        unit: str,
-        *,
-        precision: int = 2,
-        include_magnitude: bool = True,
-    ) -> str:
-        magnitude = f"{abs(delta):.{precision}f}"
-        unit_suffix = f" {unit}".rstrip() if unit else ""
-        if abs(delta) < 1e-9:
-            return "flat"
-        if delta > 0:
-            return f"up by {magnitude}{unit_suffix}" if include_magnitude else "above"
-        return f"down by {magnitude}{unit_suffix}" if include_magnitude else "below"
-
-    def _parse_datetime(self, value: object) -> datetime | None:
-        if isinstance(value, datetime):
-            return value
-        if not isinstance(value, str):
-            return None
-        for fmt in ("%d %b %Y, %I:%M:%S %p", "%d %b %Y, %I:%M %p", "%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S"):
-            try:
-                return datetime.strptime(value, fmt)
-            except ValueError:
-                continue
-        return None
-
-    def _normalize_warn_type(self, value: object) -> str:
-        text = str(value or "").strip().lower()
-        if not text:
-            return ""
-        mapping = {
-            "0x11": "warn",
-            "11": "warn",
-            "0x12": "mute",
-            "12": "mute",
-            "0x14": "low-vol",
-            "14": "low-vol",
-            "0x15": "fault",
-            "15": "fault",
-            "0x17": "ok",
-            "17": "ok",
-            "0x1a": "remove",
-            "1a": "remove",
-            "26": "remove",
-            "0x1b": "install",
-            "1b": "install",
-            "27": "install",
-            "0x1e": "ok-vol-test",
-            "1e": "ok-vol-test",
-            "30": "ok-vol-test",
-            "0x1f": "low-vol-test",
-            "1f": "low-vol-test",
-            "31": "low-vol-test",
-            "1": "warn",
-            "true": "warn",
-        }
-        return mapping.get(text, text)
-
-
-deterministic_analysis_service = DeterministicAnalysisService()

agents/analysis/backend/app/services/live_asset_registry.py

@@ -1,469 +0,0 @@
-from __future__ import annotations
-
-import time
-from collections import Counter
-
-from agents.analysis.backend.app.core.config import get_settings
-from agents.analysis.backend.app.models.schemas import AssetProfile
-from agents.analysis.backend.app.services.asset_catalog import asset_catalog_service
-from agents.analysis.backend.app.services.data_repository import DataQueryError, data_repository
-
-
-class LiveAssetRegistry:
-    def __init__(self) -> None:
-        self._settings = get_settings()
-        self._cache: dict[str, list[AssetProfile]] = {} # user_id -> assets
-        self._loaded_at: dict[str, float] = {}
-        self._ttl_seconds = 60.0
-
-    def list_assets(self, user_id: str = "user_1", force_refresh: bool = False) -> list[AssetProfile]:
-        now = time.time()
-        user_cache = self._cache.get(user_id, [])
-        user_loaded_at = self._loaded_at.get(user_id, 0.0)
-        
-        if force_refresh or not user_cache or now - user_loaded_at > self._ttl_seconds:
-            self._cache[user_id] = self._load_assets(user_id)
-            self._loaded_at[user_id] = now
-            
-        return self._cache[user_id]
-
-    def get_asset(self, asset_id: str, user_id: str = "user_1") -> AssetProfile | None:
-        for asset in self.list_assets(user_id):
-            aliases = [asset.asset_id, asset.db_asset_id, asset.name, *asset.lookup_names]
-            if asset_id in aliases:
-                return asset
-        return None
-
-    def find_candidates(self, message: str, user_id: str = "user_1", limit: int = 12) -> list[AssetProfile]:
-        normalized_message = self._normalize(message)
-        message_tokens = self._tokenize(message)
-        scored: list[tuple[int, int, int, int, int, str, AssetProfile]] = []
-
-        normalized_message_aggressive = "".join(char for char in normalized_message if char.isalnum())
-        singular_message_aggressive = normalized_message_aggressive.rstrip('s')
-
-        for asset in self.list_assets(user_id):
-            score = 0
-            aliases = [asset.name, asset.asset_id, *asset.lookup_names]
-            for alias in aliases:
-                normalized_alias = self._normalize(alias)
-                if not normalized_alias:
-                    continue
-                
-                normalized_alias_aggressive = "".join(char for char in normalized_alias if char.isalnum())
-                singular_alias_aggressive = normalized_alias_aggressive.rstrip('s')
-
-                # 1. Exact or substring match on aggressive normalization
-                if normalized_alias_aggressive == normalized_message_aggressive:
-                    score = max(score, 1000)
-                elif singular_alias_aggressive in singular_message_aggressive or singular_message_aggressive in singular_alias_aggressive:
-                    score = max(score, 850 + len(singular_alias_aggressive))
-                else:
-                    # 2. Token-level fuzzy match (partial word match)
-                    alias_tokens = self._tokenize(alias)
-                    singular_message_tokens = [t.rstrip('s') for t in message_tokens]
-                    
-                    # Check if any alias token is a substring of any message token (or vice versa)
-                    overlap_count = 0
-                    for t_alias in alias_tokens:
-                        t_alias_singular = t_alias.rstrip('s')
-                        if any(t_alias_singular in t_msg or t_msg in t_alias_singular for t_msg in singular_message_tokens):
-                            overlap_count += 1
-                    
-                    if overlap_count:
-                        score = max(score, 200 + overlap_count * 150)
-
-            # Bonus for asset type match
-            if asset.asset_type and asset.asset_type.replace('_', '').rstrip('s') in normalized_message_aggressive:
-                score += 300
-
-            if asset.parent_name:
-                parent_tokens = self._tokenize(asset.parent_name)
-                parent_overlap = any(pt.rstrip('s') in normalized_message_aggressive for pt in parent_tokens)
-                if parent_overlap:
-                    score += 100
-
-            if score:
-                scored.append((
-                    score,
-                    1 if asset.has_live_data else 0,
-                    asset.child_count,
-                    1 if asset.is_device else 0,
-                    len(asset.name),
-                    asset.db_asset_id or asset.asset_id,
-                    asset,
-                ))
-
-        scored.sort(key=lambda item: item[:-1], reverse=True)
-        return [asset for *_, asset in scored[:limit]]
-
-    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 find_mentioned_assets(self, message: str, user_id: str = "user_1") -> list[AssetProfile]:
-        normalized_message = self._normalize(message)
-        mentioned: list[AssetProfile] = []
-        
-        # Sort assets by name length descending to avoid substring overlapping (e.g. ColdRoom1 vs ColdRoom10)
-        sorted_assets = sorted(self.list_assets(user_id), key=lambda a: len(a.name), reverse=True)
-        
-        is_general_status = self._is_general_status_query(message)
-        temp_message = normalized_message
-        for asset in sorted_assets:
-            if is_general_status and asset.name.lower() == 'status':
-                continue
-            aliases = [asset.name, *asset.lookup_names]
-            matched = False
-            for alias in aliases:
-                norm_alias = self._normalize(alias)
-                if not norm_alias or len(norm_alias) < 3:
-                    continue
-                if norm_alias in temp_message:
-                    matched = True
-                    temp_message = temp_message.replace(norm_alias, " ")
-                    break
-            if matched:
-                mentioned.append(asset)
-                
-        # 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 best_direct_match(self, message: str, user_id: str = "user_1") -> AssetProfile | None:
-        # Check if multiple assets are mentioned and share a common parent
-        mentioned = self.find_mentioned_assets(message, user_id)
-        if len(mentioned) == 1:
-            return mentioned[0]
-
-        if len(mentioned) >= 2:
-            parent_names = {a.parent_name for a in mentioned if a.parent_name}
-            if len(parent_names) == 1:
-                common_parent_name = list(parent_names)[0]
-                parent_asset = self.get_asset(common_parent_name, user_id)
-                if parent_asset:
-                    return parent_asset
-
-        normalized_message = self._normalize(message)
-        best: tuple[int, int, int, int, int, str, AssetProfile] | None = None
-        
-        is_general_status = self._is_general_status_query(message)
-
-        for asset in self.list_assets(user_id):
-            if is_general_status and asset.name.lower() == 'status':
-                continue
-            aliases = [asset.name, *asset.lookup_names]
-            best_alias_score = 0
-            for alias in aliases:
-                normalized_alias = self._normalize(alias)
-                if not normalized_alias:
-                    continue
-                if normalized_alias == normalized_message:
-                    best_alias_score = max(best_alias_score, 5000 + len(normalized_alias) * 5)
-                elif normalized_alias in normalized_message:
-                    best_alias_score = max(best_alias_score, 3000 + len(normalized_alias) * 5)
-
-            if best_alias_score:
-                candidate = (
-                    best_alias_score,
-                    1 if asset.has_live_data else 0,
-                    asset.child_count,
-                    1 if asset.is_device else 0,
-                    len(asset.name),
-                    asset.db_asset_id or asset.asset_id,
-                    asset,
-                )
-                if best is None or candidate[:-1] > best[:-1]:
-                    best = candidate
-
-        return best[-1] if best else None
-
-    def _load_assets(self, user_id: str) -> list[AssetProfile]:
-        query = f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT a.id, a.name, a.parent_id, a.attributes::jsonb AS attributes
-    FROM {self._settings.openremote_schema}.asset a
-    JOIN {self._settings.openremote_schema}.user_asset_link ual ON a.id = ual.asset_id
-    WHERE ual.user_id = :user_id
-
-    UNION
-
-    SELECT child.id, child.name, child.parent_id, child.attributes::jsonb AS attributes
-    FROM {self._settings.openremote_schema}.asset child
-    JOIN hierarchy h ON child.parent_id = h.id
-),
-latest_data AS (
-    SELECT DISTINCT ON (ad.entity_id, ad.attribute_name)
-        ad.entity_id,
-        ad.attribute_name,
-        ad.value,
-        ad.timestamp
-    FROM {self._settings.openremote_schema}.asset_datapoint ad
-    JOIN hierarchy h ON ad.entity_id = h.id
-    WHERE jsonb_typeof(ad.value::jsonb) = 'object'
-    ORDER BY ad.entity_id, ad.attribute_name, ad.timestamp DESC
-),
-latest_entities AS (
-    SELECT DISTINCT entity_id
-    FROM latest_data
-),
-child_counts AS (
-    SELECT parent_id, COUNT(*) AS child_count
-    FROM {self._settings.openremote_schema}.asset
-    WHERE parent_id IN (SELECT id FROM hierarchy)
-    GROUP BY parent_id
-),
-asset_attributes AS (
-    SELECT
-        h.id,
-        CASE
-            WHEN h.attributes IS NULL OR jsonb_typeof(h.attributes::jsonb) != 'object' THEN ARRAY[]::text[]
-            ELSE ARRAY(
-                SELECT key
-                FROM jsonb_object_keys(h.attributes::jsonb) AS key
-                ORDER BY key
-            )
-        END AS attribute_keys,
-        CASE
-            WHEN h.attributes IS NULL OR jsonb_typeof(h.attributes::jsonb) != 'object' THEN FALSE
-            ELSE ((h.attributes::jsonb - 'notes' - 'location') != '{{}}'::jsonb)
-        END AS is_device
-    FROM hierarchy h
-)
-SELECT
-    a.id::text AS db_asset_id,
-    a.name,
-    COALESCE(parent.name, '') AS parent_name,
-    COALESCE(cc.child_count, 0) AS child_count,
-    COALESCE(aa.is_device, FALSE) AS is_device,
-    COALESCE(aa.attribute_keys, ARRAY[]::text[]) AS attribute_keys,
-    (ld.entity_id IS NOT NULL) AS has_live_data,
-    COALESCE(
-        (
-            SELECT array_agg(DISTINCT key ORDER BY key)
-            FROM latest_data ld2,
-            LATERAL jsonb_object_keys(
-                CASE
-                    WHEN jsonb_typeof(ld2.value::jsonb) = 'object' THEN ld2.value::jsonb
-                    ELSE '{{}}'::jsonb
-                END
-            ) AS key
-            WHERE ld2.entity_id = a.id
-        ),
-        ARRAY[]::text[]
-    ) AS data_keys
-FROM hierarchy a
-LEFT JOIN {self._settings.openremote_schema}.asset parent ON parent.id = a.parent_id
-LEFT JOIN child_counts cc ON cc.parent_id = a.id
-LEFT JOIN asset_attributes aa ON aa.id = a.id
-LEFT JOIN latest_entities ld ON ld.entity_id = a.id
-ORDER BY a.name;
-""".strip()
-        rows = data_repository.execute_query(query, {"user_id": user_id})
-        return [self._merge_with_override(row) for row in rows]
-
-    def _merge_with_override(self, row: dict) -> AssetProfile:
-        name = str(row.get("name", ""))
-        override = asset_catalog_service.get_asset_by_name(name)
-        inferred_type = self._infer_asset_type(name, str(row.get("parent_name", "")), row.get("data_keys") or [])
-        is_device = bool(row.get("is_device"))
-        default_supported = self._default_supported_analyses(
-            inferred_type,
-            bool(row.get("has_live_data")),
-            is_device,
-            int(row.get("child_count", 0) or 0),
-        )
-        data_keys = [str(item) for item in (row.get("data_keys") or [])]
-        attribute_keys = [str(item) for item in (row.get("attribute_keys") or [])]
-
-        base = AssetProfile(
-            asset_id=str(row.get("db_asset_id", name)),
-            db_asset_id=str(row.get("db_asset_id", "")),
-            name=name,
-            parent_name=str(row.get("parent_name", "")),
-            child_count=int(row.get("child_count", 0) or 0),
-            is_device=is_device,
-            attribute_keys=attribute_keys,
-            has_live_data=bool(row.get("has_live_data")),
-            data_keys=data_keys,
-            asset_type=inferred_type,
-            description=self._build_description(
-                name,
-                str(row.get("parent_name", "")),
-                data_keys,
-                bool(row.get("has_live_data")),
-                is_device,
-                attribute_keys,
-            ),
-            supported_analyses=default_supported,
-            metrics=data_keys[:12],
-            source_table=f"{self._settings.openremote_schema}.asset_datapoint",
-            analysis_instructions=self._build_analysis_instructions(
-                name,
-                str(row.get("parent_name", "")),
-                inferred_type,
-                data_keys,
-                bool(row.get("has_live_data")),
-                is_device,
-                int(row.get("child_count", 0) or 0),
-            ),
-            lookup_names=[name],
-        )
-
-        if override is None:
-            return base
-
-        # Automatic key discovery
-        auto_temp = [k for k in data_keys if k.lower() in ("temperature", "temp", "t", "temp1")]
-        auto_humi = [k for k in data_keys if k.lower() in ("humidity", "humi", "h", "hum")]
-        auto_level = [k for k in data_keys if k.lower() in ("level", "tankoillevelinfeet001", "current_level")]
-        auto_prod = [k for k in data_keys if k.lower().startswith("prod_") or k.lower() == "total_count"]
-
-        merged = base.model_copy(update={
-            "asset_id": override.asset_id if override and override.asset_id else base.asset_id,
-            "asset_type": override.asset_type if override and override.asset_type else base.asset_type,
-            "description": override.description if override and override.description else base.description,
-            "supported_analyses": override.supported_analyses if override and override.supported_analyses else base.supported_analyses,
-            "metrics": override.metrics if override and override.metrics else base.metrics,
-            "analysis_instructions": override.analysis_instructions if override and override.analysis_instructions else base.analysis_instructions,
-            "sql_notes": override.sql_notes if override and override.sql_notes else base.sql_notes,
-            "lookup_names": sorted(set([base.name, *base.lookup_names, *(override.lookup_names if override else [])])),
-            "temperature_keys": override.temperature_keys if override and override.temperature_keys else auto_temp,
-            "humidity_keys": override.humidity_keys if override and override.humidity_keys else auto_humi,
-            "level_keys": override.level_keys if override and override.level_keys else auto_level,
-            "production_keys": override.production_keys if override and override.production_keys else auto_prod,
-            "nominal_range": override.nominal_range if override and override.nominal_range else base.nominal_range,
-        })
-        return merged
-
-    def _infer_asset_type(self, name: str, parent_name: str, data_keys: list[str]) -> str:
-        lowered = f"{name} {parent_name}".lower()
-        key_counts = Counter(key.lower() for key in data_keys)
-        
-        # Prioritize tank detection to avoid "Water Tank" being called "cold_room"
-        if "tank" in lowered or {"tankoillevelinfeet001", "level"} & set(key_counts):
-            return "tank"
-            
-        smoke_keys = {"warn", "temp", "humi", "bat_percent", "bat_voltage"}
-        if "tank level monitoring" in lowered:
-            return "tank"
-        if "weather station" in lowered:
-            return "weather_station"
-        if "smoke alarm" in lowered or smoke_keys & set(key_counts):
-            return "smoke_alarm"
-        if "coldroom" in lowered or {"temperature", "humidity"} & set(key_counts):
-            return "cold_room"
-        if "machine" in lowered or any("prod_" in key for key in key_counts):
-            return "filling_machine"
-        if "boiler" in lowered:
-            return "boiler"
-        if "energy meter" in lowered or "power meter" in lowered or {"voltage", "current", "power", "energy"} & set(key_counts):
-            return "energy_meter"
-        return "generic_asset"
-
-    def _default_supported_analyses(self, asset_type: str, has_live_data: bool, is_device: bool, child_count: int) -> list[str]:
-        if not is_device and child_count > 0:
-            return ["hierarchy_summary", "group_status", "group_comparison"]
-        if asset_type == "cold_room":
-            return ["live_status", "consumption_analysis", "cooling_cycle_analysis", "historical_variance", "anomaly_detection"]
-        if asset_type == "filling_machine":
-            return ["live_status", "throughput_utilization", "historical_variance", "anomaly_detection"]
-        if asset_type == "tank":
-            return ["live_status", "inventory_level_analysis", "trend_analysis", "anomaly_detection"]
-        if asset_type == "weather_station":
-            return ["live_status", "trend_analysis", "anomaly_detection"]
-        if asset_type == "energy_meter":
-            return ["live_status", "trend_analysis", "group_status", "historical_variance", "consumption_analysis"]
-        if asset_type == "smoke_alarm":
-            return ["live_status", "anomaly_detection", "group_status"]
-        if asset_type == "boiler":
-            return ["live_status", "trend_analysis", "historical_variance", "anomaly_detection"]
-        return ["live_status", "trend_analysis"] if has_live_data else ["hierarchy_summary"]
-
-    def _build_description(
-        self,
-        name: str,
-        parent_name: str,
-        data_keys: list[str],
-        has_live_data: bool,
-        is_device: bool,
-        attribute_keys: list[str],
-    ) -> str:
-        role_text = "sensor device" if is_device else "category or grouping asset"
-        live_text = "has live telemetry data" if has_live_data else "does not appear to have direct live telemetry"
-        parent_text = f"under parent {parent_name}" if parent_name else "with no recorded parent in the current view"
-        attr_text = f"Attribute keys include: {', '.join(attribute_keys[:12])}." if attribute_keys else "No attribute keys were discovered."
-        keys_text = f"Available telemetry keys include: {', '.join(data_keys[:12])}." if data_keys else "No telemetry keys were discovered yet."
-        return f"{name} is an OpenRemote {role_text} {parent_text}. It {live_text}. {attr_text} {keys_text}"
-
-    def _build_analysis_instructions(
-        self,
-        name: str,
-        parent_name: str,
-        asset_type: str,
-        data_keys: list[str],
-        has_live_data: bool,
-        is_device: bool,
-        child_count: int,
-    ) -> str:
-        if not is_device and child_count > 0:
-            return (
-                f"{name} is a category/group asset. It should be analyzed through its child assets. "
-                "If the user asks about this asset, first discover the relevant child devices under the hierarchy "
-                "and summarize those instead of expecting direct telemetry on the category itself."
-            )
-        if asset_type == "tank":
-            return (
-                f"Analyze {name} as a tank-type device. "
-                "For tank devices, actual physical liquid height is MaxFt - TankOilLevelInFeet001, "
-                "even when those values come from different attributes such as Data and Maxcapacity. "
-                "Use that derived height in the final analysis whenever those fields are available."
-            )
-        if asset_type == "cold_room" and "t & h monitoring" in f"{name} {parent_name}".lower():
-            return (
-                f"Analyze {name} as a T & H Monitoring cold-room device. "
-                "Treat the safe temperature threshold as 5C to 45C unless the user explicitly provides a stricter range. "
-                "Always provide consumption analysis for the requested time window by inferring ON/OFF state from temperature history. "
-                "A cooling cycle starts at the last temperature peak before a drop that later goes below 20C, "
-                "stays ON while temperature remains below 20C, and ends at the valley before temperature rises back to 20C or above. "
-                "Sum those cycle durations and clip any carry-over cycle to the 6:00 AM shift start."
-            )
-        if asset_type == "smoke_alarm":
-            return (
-                f"Analyze {name} as a smoke-alarm sensor or smoke-alarm group. "
-                "Inspect all JSON telemetry attributes for warn, temp, humi, bat_percent, and bat_voltage values. "
-                "Treat warn='warn' as smoke/fire detected, warn='mute' as alarm muted after fire detection, "
-                "warn='fault' as sensor fault, warn='remove' as sensor removal, warn='install' as sensor install event, "
-                "warn='low-vol' or warn='low-vol-test' as low-battery/voltage conditions, and warn='ok' as normal. "
-                "If the user asks about a category, summarize all child devices together and list affected devices with timestamps."
-            )
-        return (
-            f"Analyze {name} using the returned telemetry keys {', '.join(data_keys[:12])}. "
-            "Use the user's requested time range and produce a practical end-user summary."
-        )
-
-    def _normalize(self, value: str) -> str:
-        return "".join(value.lower().split())
-
-    def _tokenize(self, value: str) -> list[str]:
-        # Split alpha and numeric parts (e.g. ColdRoom1 -> Cold Room 1)
-        import re
-        text = str(value)
-        text = re.sub(r'([a-zA-Z])(\d)', r'\1 \2', text)
-        text = re.sub(r'(\d)([a-zA-Z])', r'\1 \2', text)
-        cleaned = "".join(char if char.isalnum() else " " for char in text.lower())
-        return [token for token in cleaned.split() if token]
-
-    def _normalize_for_tokens(self, value: str) -> str:
-        # This is now handled inside _tokenize for better granularity
-        return " ".join(self._tokenize(value))
-
-
-live_asset_registry = LiveAssetRegistry()

agents/analysis/backend/app/services/llm_service.py

@@ -1,310 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-from collections import defaultdict
-from pathlib import Path
-from typing import Any
-
-from langchain_core.prompts import ChatPromptTemplate
-
-try:
-    from langchain_groq import ChatGroq
-except ImportError:  # pragma: no cover
-    ChatGroq = None
-
-from agents.analysis.backend.app.core.config import get_settings
-
-
-class LLMService:
-    def __init__(self) -> None:
-        self._settings = get_settings()
-        prompts_dir = Path(__file__).resolve().parents[1] / "prompts"
-        self._request_planner_path = prompts_dir / "request_planner.txt"
-        self._sql_generator_path = prompts_dir / "sql_generator.txt"
-        self._result_analyst_path = prompts_dir / "result_analyst.txt"
-
-    def plan_request(self, user_question: str, asset_catalog_context: str) -> dict[str, Any]:
-        fallback = {
-            "asset_id": "",
-            "analysis_name": "live_status",
-            "time_window": {
-                "scope": "historical",
-                "value": 1,
-                "unit": "hours",
-                "label": "last 1 hour",
-            },
-            "reasoning": "The planner could not run, so no asset was identified.",
-            "prompt_text": "",
-        }
-        system_prompt = self._request_planner_path.read_text(encoding="utf-8")
-        human_prompt = (
-            "User request:\n{user_question}\n\n"
-            "Asset catalog:\n{asset_catalog_context}\n"
-        )
-        variables = {
-            "user_question": user_question,
-            "asset_catalog_context": self._clip_text(asset_catalog_context, 2200),
-        }
-        result = self._invoke_json(
-            system_prompt=system_prompt,
-            human_prompt=human_prompt,
-            variables=variables,
-            fallback=fallback,
-        )
-        result["prompt_text"] = self._render_prompt_text(system_prompt, human_prompt, variables)
-        return result
-
-    def generate_sql(
-        self,
-        user_question: str,
-        asset_context: str,
-        analysis_name: str,
-        time_window_label: str,
-    ) -> dict[str, Any]:
-        system_prompt = self._sql_generator_path.read_text(encoding="utf-8")
-        human_prompt = (
-            "User request:\n{user_question}\n\n"
-            "Chosen analysis:\n{analysis_name}\n\n"
-            "Chosen time window:\n{time_window_label}\n\n"
-            "Asset context:\n{asset_context}\n"
-        )
-        variables = {
-            "user_question": user_question,
-            "analysis_name": analysis_name,
-            "time_window_label": time_window_label,
-            "asset_context": self._clip_text(asset_context, 2600),
-        }
-        raw_response, total_tokens = self._invoke_text(
-            system_prompt=system_prompt,
-            human_prompt=human_prompt,
-            variables=variables,
-        )
-        return {
-            "sql_query": self._strip_code_fences(raw_response),
-            "total_tokens": total_tokens,
-            "raw_response": raw_response,
-            "prompt_text": self._render_prompt_text(system_prompt, human_prompt, variables),
-        }
-
-    def analyze_result(
-        self,
-        user_question: str,
-        asset_context: str,
-        sql_query: str,
-        deterministic_findings: dict[str, Any],
-        rows: list[dict],
-    ) -> dict[str, Any]:
-        fallback = (
-            "I retrieved the requested data, but the final LLM analysis could not be generated. "
-            "Please review the SQL and database rows in the details panel."
-        )
-        system_prompt = self._result_analyst_path.read_text(encoding="utf-8")
-        human_prompt = (
-            "User request:\n{user_question}\n\n"
-            "Asset context:\n{asset_context}\n\n"
-            "SQL query used:\n{sql_query}\n\n"
-            "Deterministic findings:\n{deterministic_findings}\n\n"
-            "Returned rows:\n{rows}\n"
-        )
-        variables = {
-            "user_question": user_question,
-            "asset_context": self._clip_text(asset_context, 2400),
-            "sql_query": self._clip_text(sql_query, 2200),
-            "deterministic_findings": self._compact_findings(deterministic_findings),
-            "rows": self._compact_rows(rows),
-        }
-        raw_response, total_tokens = self._invoke_text(
-            system_prompt=system_prompt,
-            human_prompt=human_prompt,
-            variables=variables,
-        )
-        text = raw_response.strip() or fallback
-        return {
-            "answer": text,
-            "total_tokens": total_tokens,
-            "raw_response": raw_response,
-            "prompt_text": self._render_prompt_text(system_prompt, human_prompt, variables),
-        }
-
-    def _invoke_json(
-        self,
-        system_prompt: str,
-        human_prompt: str,
-        variables: dict[str, Any],
-        fallback: dict[str, Any],
-    ) -> dict[str, Any]:
-        raw_response, _ = self._invoke_text(system_prompt, human_prompt, variables)
-        try:
-            return json.loads(self._extract_json_object(raw_response))
-        except Exception:
-            return fallback
-
-    def _invoke_text(
-        self,
-        system_prompt: str,
-        human_prompt: str,
-        variables: dict[str, Any],
-    ) -> tuple[str, int]:
-        if not self._settings.groq_api_key or ChatGroq is None:
-            return "", 0
-
-        prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", system_prompt),
-                ("human", human_prompt),
-            ]
-        )
-
-        llm = ChatGroq(
-            api_key=self._settings.groq_api_key,
-            model=self._settings.groq_model,
-            temperature=0.1,
-        )
-        chain = prompt | llm
-        response = chain.invoke(variables)
-        raw_content = response.content if isinstance(response.content, str) else str(response.content)
-        return raw_content, self._extract_total_tokens(response)
-
-    def _extract_total_tokens(self, response: Any) -> int:
-        usage_metadata = getattr(response, "usage_metadata", None) or {}
-        response_metadata = getattr(response, "response_metadata", None) or {}
-        token_usage = response_metadata.get("token_usage", {})
-
-        if isinstance(usage_metadata, dict) and usage_metadata.get("total_tokens") is not None:
-            return int(usage_metadata.get("total_tokens") or 0)
-        if isinstance(token_usage, dict) and token_usage.get("total_tokens") is not None:
-            return int(token_usage.get("total_tokens") or 0)
-        return 0
-
-    def _extract_json_object(self, text: str) -> str:
-        fenced = re.search(r"```json\s*(\{.*\})\s*```", text, re.DOTALL)
-        if fenced:
-            return fenced.group(1)
-
-        direct = re.search(r"(\{.*\})", text, re.DOTALL)
-        if direct:
-            return direct.group(1)
-
-        raise ValueError("No JSON object found in LLM response.")
-
-    def _strip_code_fences(self, text: str) -> str:
-        cleaned = text.strip()
-        cleaned = re.sub(r"^```sql\s*", "", cleaned, flags=re.IGNORECASE)
-        cleaned = re.sub(r"^```\s*", "", cleaned)
-        cleaned = re.sub(r"\s*```$", "", cleaned)
-        return cleaned.strip()
-
-    def _render_prompt_text(
-        self,
-        system_prompt: str,
-        human_prompt: str,
-        variables: dict[str, Any],
-    ) -> str:
-        rendered_human = human_prompt.format(**variables)
-        return f"[System Prompt]\n{system_prompt}\n\n[Human Prompt]\n{rendered_human}"
-
-    def _clip_text(self, value: str, max_chars: int) -> str:
-        text = (value or "").strip()
-        if len(text) <= max_chars:
-            return text
-        return f"{text[:max_chars]} ...[truncated]"
-
-    def _compact_findings(self, findings: dict[str, Any]) -> str:
-        if not isinstance(findings, dict):
-            return self._clip_text(json.dumps(findings, default=str), 1200)
-        compact = {
-            "status": findings.get("status", ""),
-            "overview": findings.get("overview", ""),
-            "findings": findings.get("findings", [])[:12],
-            "warnings": findings.get("warnings", [])[:10],
-            "numeric_metrics": findings.get("numeric_metrics", {}),
-            "asset_specific": findings.get("asset_specific", {}),
-            "table_excerpt": self._clip_text(str(findings.get("table", "")), 600),
-        }
-        return self._clip_text(json.dumps(compact, default=str), 1800)
-
-    def _compact_rows(self, rows: list[dict[str, Any]]) -> str:
-        if not rows:
-            return "[]"
-
-        # Keep representative context across child assets instead of only first rows.
-        by_asset: dict[str, list[dict[str, Any]]] = defaultdict(list)
-        for row in rows:
-            asset_name = str(
-                row.get("asset_name")
-                or row.get("name")
-                or row.get("device_name")
-                or "unknown_asset"
-            )
-            by_asset[asset_name].append(row)
-
-        selected_rows: list[dict[str, Any]] = []
-        # Include latest row per asset first (group-wide visibility).
-        for asset_name in sorted(by_asset.keys()):
-            selected_rows.append(by_asset[asset_name][-1])
-
-        # Include start-of-window row per asset to capture full-day behavior.
-        for asset_name in sorted(by_asset.keys()):
-            selected_rows.append(by_asset[asset_name][0])
-
-        # Then include one midpoint row per asset when available.
-        for asset_name in sorted(by_asset.keys()):
-            entries = by_asset[asset_name]
-            if len(entries) >= 3:
-                selected_rows.append(entries[len(entries) // 2])
-            if len(selected_rows) >= 60:
-                break
-
-        compacted: list[dict[str, Any]] = []
-        important_keys = [
-            "asset_name",
-            "device_name",
-            "name",
-            "attribute_name",
-            "sensor_name",
-            "recorded_at",
-            "timestamp",
-            "latest_time",
-            "warn_type",
-            "current_level_ft",
-            "percentage_filled",
-            "tank_oil_level_in_feet_001",
-            "max_ft",
-            "temperature",
-            "humidity",
-            "bat_percent",
-            "bat_voltage",
-            "latest_temp",
-            "latest_humidity",
-            "lowest_temp",
-            "highest_temp",
-            "total_count",
-            "shift_1_count",
-            "shift_2_count",
-            "shift_3_count",
-            "status",
-            "is_stale",
-            "is_heartbeat_stale",
-            "is_payload_stale",
-            "level_change",
-            "cooling_on_minutes",
-        ]
-
-        for row in selected_rows[:60]:
-            compact_row: dict[str, Any] = {}
-            for key in important_keys:
-                if key not in row:
-                    continue
-                value = row.get(key)
-                if isinstance(value, (list, dict)):
-                    compact_row[key] = self._clip_text(json.dumps(value, default=str), 140)
-                else:
-                    compact_row[key] = self._clip_text(str(value), 140)
-            if compact_row:
-                compacted.append(compact_row)
-
-        return self._clip_text(json.dumps(compacted, default=str), 3600)
-
-
-llm_service = LLMService()

agents/analysis/backend/app/services/nl_to_sql.py

@@ -1,1553 +0,0 @@
-import contextvars
-from dataclasses import dataclass
-from datetime import datetime
-
-from agents.analysis.backend.app.core.config import get_settings
-from agents.analysis.backend.app.models.schemas import AssetProfile, TimeWindow
-from agents.analysis.backend.app.services.sql_guard import validate_read_only_sql
-
-_schema_context = contextvars.ContextVar("schema_context", default=None)
-
-
-@dataclass
-class SQLPlan:
-    query: str
-    explanation: str
-
-
-class NLToSQLService:
-    def __init__(self) -> None:
-        self._settings = get_settings()
-
-    def _get_schema(self) -> str:
-        ctx_val = _schema_context.get()
-        return ctx_val or self._settings.openremote_schema
-
-    def build_query(
-        self,
-        asset: AssetProfile,
-        question: str,
-        analysis_name: str,
-        time_window: TimeWindow,
-        schema_name: str | None = None,
-    ) -> SQLPlan:
-        token = _schema_context.set(schema_name)
-        try:
-            query = self._build_asset_query(asset=asset, analysis_name=analysis_name, time_window=time_window)
-            validate_read_only_sql(query)
-
-            explanation = (
-                f"Generated a read-only OpenRemote query for `{asset.name}` using "
-                f"`{analysis_name}` over {time_window.label}."
-            )
-            return SQLPlan(query=query, explanation=explanation)
-        finally:
-            _schema_context.reset(token)
-
-
-    def normalize_generated_query(self, query: str, asset: AssetProfile) -> str:
-        normalized = query
-        normalized = normalized.replace("ad.asset_id", "ad.entity_id")
-        normalized = normalized.replace("ad.AssetId", "ad.entity_id")
-        normalized = normalized.replace("asset_datapoint.asset_id", "asset_datapoint.entity_id")
-
-        if "JOIN openremote.asset_datapoint ad ON ad.entity_id = a.id" not in normalized:
-            normalized = normalized.replace(
-                "JOIN openremote.asset_datapoint ad ON a.id = ad.entity_id",
-                "JOIN openremote.asset_datapoint ad ON ad.entity_id = a.id",
-            )
-
-        stripped = normalized.lstrip()
-        if "descendants AS" in normalized and stripped.startswith("WITH ") and not stripped.startswith("WITH RECURSIVE "):
-            normalized = normalized.replace("WITH ", "WITH RECURSIVE ", 1)
-
-        return normalized
-
-    def _build_asset_query(self, asset: AssetProfile, analysis_name: str, time_window: TimeWindow) -> str:
-        if not asset.is_device and asset.child_count > 0:
-            if asset.asset_type == "tank":
-                return self._build_tank_group_query(asset, time_window)
-            if asset.asset_type == "smoke_alarm":
-                return self._build_smoke_group_query(asset, time_window)
-            if asset.asset_type == "energy_meter":
-                return self._build_energy_group_query(asset, time_window)
-            if asset.asset_type == "aqi":
-                return self._build_aqi_group_query(asset, time_window)
-            return self._build_group_query(asset, time_window)
-        if asset.asset_type == "cold_room":
-            return self._build_cold_room_query(asset, time_window)
-        if asset.asset_type == "filling_machine":
-            return self._build_filling_machine_query(asset, time_window)
-        if asset.asset_type == "tank":
-            return self._build_tank_query(asset, time_window)
-        if asset.asset_type == "smoke_alarm":
-            return self._build_smoke_device_query(asset, time_window)
-        return self._build_generic_query(asset, time_window)
-
-    def _build_smoke_group_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        root_id = self._escape_sql(asset.db_asset_id or asset.asset_id)
-        offset = self._settings.local_time_offset_hours
-        timestamp_window_filter = self._window_filter_sql("ad.timestamp", time_window, local=False)
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes, attributes::jsonb AS static_attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes, c.attributes::jsonb AS static_attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name, static_attributes
-    FROM hierarchy
-    WHERE id != '{root_id}'
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        d.static_attributes,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value AS sensor_data,
-        LOWER(COALESCE(ad.value->>'warn', CASE WHEN ad.attribute_name ILIKE '%warn%' OR ad.attribute_name ILIKE '%smoke%' THEN ad.value::text END, '')) AS warn_raw,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'temp', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS temperature,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'humi', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS humidity,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_percent', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_percent,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_voltage', CASE WHEN ad.attribute_name ILIKE '%voltage%' THEN ad.value::text END, ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_voltage,
-        CASE 
-            WHEN LOWER(COALESCE(ad.value->>'warn', CASE WHEN ad.attribute_name ILIKE '%warn%' OR ad.attribute_name ILIKE '%smoke%' THEN ad.value::text END, '')) IN ('warn', 'mute', '11', '0x11', '12', '0x12', '1', 'true', 'on', 'alarm') THEN 1
-            ELSE 0 
-        END AS smoke_detected,
-        COALESCE(ad.value->>'name', ad.attribute_name) AS sensor_name,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM devices d
-    LEFT JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = d.id
-    WHERE 1=1
-      {timestamp_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.asset_name, rp.attribute_name, rp.day_bucket
-            ORDER BY rp.timestamp
-        ) AS sample_bucket
-    FROM raw_points rp
-),
-sampled_points AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_name, b.attribute_name, b.day_bucket, b.sample_bucket
-                ORDER BY b.timestamp DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_name,
-    static_attributes,
-    attribute_name,
-    timestamp AS recorded_at,
-    sensor_name,
-    CASE
-        WHEN warn_raw IN ('warn', 'mute', 'low-vol', 'fault', 'ok', 'remove', 'install', 'ok-vol-test', 'low-vol-test') THEN warn_raw
-        WHEN warn_raw IN ('17', '0x17') THEN 'ok'
-        WHEN warn_raw IN ('11', '0x11') THEN 'warn'
-        WHEN warn_raw IN ('12', '0x12') THEN 'mute'
-        WHEN warn_raw IN ('14', '0x14') THEN 'low-vol'
-        WHEN warn_raw IN ('15', '0x15') THEN 'fault'
-        WHEN warn_raw IN ('1a', '0x1a', '26') THEN 'remove'
-        WHEN warn_raw IN ('1b', '0x1b', '27') THEN 'install'
-        WHEN warn_raw IN ('1e', '0x1e', '30') THEN 'ok-vol-test'
-        WHEN warn_raw IN ('1f', '0x1f', '31') THEN 'low-vol-test'
-        WHEN warn_raw = '' THEN NULL
-        ELSE 'unknown'
-    END AS warn_type,
-    temperature,
-    humidity,
-    bat_percent,
-    bat_voltage,
-    smoke_detected,
-    sensor_data
-FROM sampled_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-        return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes, attributes::jsonb AS static_attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes, c.attributes::jsonb AS static_attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name, static_attributes
-    FROM hierarchy
-    WHERE id != '{root_id}'
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        d.static_attributes,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value AS sensor_data,
-        LOWER(COALESCE(ad.value->>'warn', '')) AS warn_raw,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'temp', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS temperature,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'humi', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS humidity,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_percent', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_percent,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_voltage', CASE WHEN ad.attribute_name ILIKE '%voltage%' THEN ad.value::text END, ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_voltage,
-        CASE 
-            WHEN LOWER(COALESCE(ad.value->>'warn', CASE WHEN ad.attribute_name ILIKE '%warn%' OR ad.attribute_name ILIKE '%smoke%' THEN ad.value::text END, '')) IN ('warn', 'mute', '11', '0x11', '12', '0x12', '1', 'true', 'on', 'alarm') THEN 1
-            ELSE 0 
-        END AS smoke_detected,
-        COALESCE(ad.value->>'name', ad.attribute_name) AS sensor_name
-    FROM devices d
-    LEFT JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = d.id
-    WHERE 1=1
-      {timestamp_window_filter}
-)
-SELECT
-    asset_name,
-    static_attributes,
-    attribute_name,
-    timestamp AS recorded_at,
-    sensor_name,
-    CASE
-        WHEN warn_raw IN ('warn', 'mute', 'low-vol', 'fault', 'ok', 'remove', 'install', 'ok-vol-test', 'low-vol-test') THEN warn_raw
-        WHEN warn_raw IN ('17', '0x17') THEN 'ok'
-        WHEN warn_raw IN ('11', '0x11') THEN 'warn'
-        WHEN warn_raw IN ('12', '0x12') THEN 'mute'
-        WHEN warn_raw IN ('14', '0x14') THEN 'low-vol'
-        WHEN warn_raw IN ('15', '0x15') THEN 'fault'
-        WHEN warn_raw IN ('1a', '0x1a', '26') THEN 'remove'
-        WHEN warn_raw IN ('1b', '0x1b', '27') THEN 'install'
-        WHEN warn_raw IN ('1e', '0x1e', '30') THEN 'ok-vol-test'
-        WHEN warn_raw IN ('1f', '0x1f', '31') THEN 'low-vol-test'
-        WHEN warn_raw = '' THEN NULL
-        ELSE 'unknown'
-    END AS warn_type,
-    temperature,
-    humidity,
-    bat_percent,
-    bat_voltage,
-    smoke_detected,
-    sensor_data
-FROM raw_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-
-    def _build_smoke_device_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        exact_match = self._exact_asset_match_sql(asset.name)
-        offset = self._settings.local_time_offset_hours
-        timestamp_window_filter = self._window_filter_sql("ad.timestamp", time_window, local=False)
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH raw_points AS (
-    SELECT
-        a.id::text AS asset_id,
-        a.name AS asset_name,
-        a.attributes::jsonb AS static_attributes,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value AS sensor_data,
-        LOWER(COALESCE(ad.value->>'warn', '')) AS warn_raw,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'temp', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS temperature,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'humi', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS humidity,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_percent', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_percent,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'bat_voltage', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_voltage,
-        CASE 
-            WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('warn', 'mute', '11', '0x11', '12', '0x12', '1', 'true') THEN 1
-            ELSE 0 
-        END AS smoke_detected,
-        COALESCE(ad.value->>'name', ad.attribute_name) AS sensor_name,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset a
-    JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = a.id
-    WHERE {exact_match}
-      {timestamp_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.asset_id, rp.attribute_name, rp.day_bucket
-            ORDER BY rp.timestamp
-        ) AS sample_bucket
-    FROM raw_points rp
-),
-sampled_points AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_id, b.attribute_name, b.day_bucket, b.sample_bucket
-                ORDER BY b.timestamp DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_id,
-    asset_name,
-    static_attributes,
-    attribute_name,
-    timestamp AS recorded_at,
-    sensor_name,
-    CASE
-        WHEN warn_raw IN ('warn', 'mute', 'low-vol', 'fault', 'ok', 'remove', 'install', 'ok-vol-test', 'low-vol-test') THEN warn_raw
-        WHEN warn_raw IN ('17', '0x17') THEN 'ok'
-        WHEN warn_raw IN ('11', '0x11') THEN 'warn'
-        WHEN warn_raw IN ('12', '0x12') THEN 'mute'
-        WHEN warn_raw IN ('14', '0x14') THEN 'low-vol'
-        WHEN warn_raw IN ('15', '0x15') THEN 'fault'
-        WHEN warn_raw IN ('1a', '0x1a', '26') THEN 'remove'
-        WHEN warn_raw IN ('1b', '0x1b', '27') THEN 'install'
-        WHEN warn_raw IN ('1e', '0x1e', '30') THEN 'ok-vol-test'
-        WHEN warn_raw IN ('1f', '0x1f', '31') THEN 'low-vol-test'
-        WHEN warn_raw = '' THEN NULL
-        ELSE 'unknown'
-    END AS warn_type,
-    temperature,
-    humidity,
-    bat_percent,
-    bat_voltage,
-    smoke_detected,
-    sensor_data
-FROM sampled_points
-ORDER BY recorded_at ASC, attribute_name;
-""".strip()
-        return f"""
-SELECT
-    a.id::text AS asset_id,
-    a.name AS asset_name,
-    a.attributes::jsonb AS static_attributes,
-    ad.attribute_name,
-    (ad.timestamp + INTERVAL '{offset} hours') AS recorded_at,
-    COALESCE(ad.value->>'name', ad.attribute_name) AS sensor_name,
-    CASE
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('warn', 'mute', 'low-vol', 'fault', 'ok', 'remove', 'install', 'ok-vol-test', 'low-vol-test') THEN LOWER(ad.value->>'warn')
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('17', '0x17') THEN 'ok'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('11', '0x11') THEN 'warn'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('12', '0x12') THEN 'mute'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('14', '0x14') THEN 'low-vol'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('15', '0x15') THEN 'fault'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('1a', '0x1a', '26') THEN 'remove'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('1b', '0x1b', '27') THEN 'install'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('1e', '0x1e', '30') THEN 'ok-vol-test'
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('1f', '0x1f', '31') THEN 'low-vol-test'
-        WHEN COALESCE(ad.value->>'warn', '') = '' THEN NULL
-        ELSE 'unknown'
-    END AS warn_type,
-    NULLIF(regexp_replace(COALESCE(ad.value->>'temp', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS temperature,
-    NULLIF(regexp_replace(COALESCE(ad.value->>'humi', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS humidity,
-    NULLIF(regexp_replace(COALESCE(ad.value->>'bat_percent', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_percent,
-    NULLIF(regexp_replace(COALESCE(ad.value->>'bat_voltage', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS bat_voltage,
-    CASE 
-        WHEN LOWER(COALESCE(ad.value->>'warn', '')) IN ('warn', 'mute', '11', '0x11', '12', '0x12', '1', 'true') THEN 1
-        ELSE 0 
-    END AS smoke_detected,
-    (ad.timestamp + INTERVAL '{offset} hours') AS recorded_at,
-    ad.value AS sensor_data
-FROM {self._get_schema()}.asset a
-JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = a.id
-WHERE {exact_match}
-  {timestamp_window_filter}
-ORDER BY recorded_at ASC, ad.attribute_name;
-""".strip()
-
-    def _build_group_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        interval = self._interval_sql(time_window)
-        root_id = self._escape_sql(asset.db_asset_id or asset.asset_id)
-        offset = self._settings.local_time_offset_hours
-        timestamp_window_filter = self._window_filter_sql("ad.timestamp", time_window, local=False)
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_points AS (
-    SELECT
-        ad.entity_id,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {timestamp_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.entity_id, rp.day_bucket
-            ORDER BY rp.timestamp
-        ) AS sample_bucket
-    FROM raw_points rp
-),
-sampled_points AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.entity_id, b.day_bucket, b.sample_bucket
-                ORDER BY b.timestamp DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    d.name AS asset_name,
-    sp.attribute_name,
-    sp.timestamp,
-    sp.value AS sensor_data
-FROM devices d
-LEFT JOIN sampled_points sp ON sp.entity_id = d.id
-ORDER BY d.name, sp.timestamp, sp.attribute_name;
-""".strip()
-        return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-latest_points AS (
-    SELECT DISTINCT ON (ad.entity_id, ad.attribute_name)
-        ad.entity_id,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {timestamp_window_filter}
-    ORDER BY ad.entity_id, ad.attribute_name, ad.timestamp DESC
-)
-SELECT
-    d.name AS asset_name,
-    lp.attribute_name,
-    lp.timestamp,
-    lp.value AS sensor_data
-FROM devices d
-LEFT JOIN latest_points lp ON lp.entity_id = d.id
-ORDER BY d.name, lp.attribute_name;
-""".strip()
-
-    def _build_energy_group_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        root_id = self._escape_sql(asset.db_asset_id or asset.asset_id)
-        offset = self._settings.local_time_offset_hours
-        local_time_window_filter = self._window_filter_sql(
-            f"(ad.timestamp + INTERVAL '{offset} hours')",
-            time_window,
-            local=True,
-        )
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ad.value AS sensor_data,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentA', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_a,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentB', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_b,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentC', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_c,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerA', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_a,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerB', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_b,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerC', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_c,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'EnergyTotalABC', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS energy_total,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {local_time_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.asset_name, rp.attribute_name, rp.day_bucket
-            ORDER BY rp.timestamp
-        ) AS sample_bucket
-    FROM raw_points rp
-),
-sampled_points AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_name, b.attribute_name, b.day_bucket, b.sample_bucket
-                ORDER BY b.local_time DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_name,
-    attribute_name,
-    local_time AS recorded_at,
-    current_a,
-    current_b,
-    current_c,
-    power_a,
-    power_b,
-    power_c,
-    energy_total,
-    sensor_data
-FROM sampled_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-        return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ad.value AS sensor_data,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentA', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_a,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentB', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_b,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'CurrentC', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS current_c,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerA', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_a,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerB', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_b,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'PowerC', CASE WHEN ad.attribute_name ILIKE '%PowerC%' THEN ad.value::text END, ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS power_c,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'EnergyTotalABC', CASE WHEN ad.attribute_name ILIKE '%Energy%' THEN ad.value::text END, ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS energy_total
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {local_time_window_filter}
-)
-SELECT
-    asset_name,
-    attribute_name,
-    local_time AS recorded_at,
-    current_a,
-    current_b,
-    current_c,
-    power_a,
-    power_b,
-    power_c,
-    energy_total,
-    sensor_data
-FROM raw_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-
-    def _build_aqi_group_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        root_id = self._escape_sql(asset.db_asset_id or asset.asset_id)
-        offset = self._settings.local_time_offset_hours
-        local_time_window_filter = self._window_filter_sql(
-            f"(ad.timestamp + INTERVAL '{offset} hours')",
-            time_window,
-            local=True,
-        )
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ad.value AS sensor_data,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'AQIIndex001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS aqi_index,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'pm25', ad.value->>'PM25', ad.value->>'PM2.5', ad.value->>'pm2.5', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS pm25,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'pm10', ad.value->>'PM10', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS pm10,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'co2', ad.value->>'CO2', ad.value->>'AQICO2001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS co2,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'voc', ad.value->>'VOC', ad.value->>'AQIVOC001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS voc,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {local_time_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.asset_name, rp.attribute_name, rp.day_bucket
-            ORDER BY rp.raw_time
-        ) AS sample_bucket
-    FROM raw_points rp
-),
-sampled_points AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_name, b.attribute_name, b.day_bucket, b.sample_bucket
-                ORDER BY b.local_time DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_name,
-    attribute_name,
-    local_time AS recorded_at,
-    aqi_index,
-    pm25,
-    pm10,
-    co2,
-    voc,
-    sensor_data
-FROM sampled_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-        return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_points AS (
-    SELECT
-        d.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ad.value AS sensor_data,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'AQIIndex001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS aqi_index,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'pm25', ad.value->>'PM25', ad.value->>'PM2.5', ad.value->>'pm2.5', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS pm25,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'pm10', ad.value->>'PM10', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS pm10,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'co2', ad.value->>'CO2', ad.value->>'AQICO2001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS co2,
-        NULLIF(regexp_replace(COALESCE(ad.value->>'voc', ad.value->>'VOC', ad.value->>'AQIVOC001', ''), '[^0-9\\.-]', '', 'g'), '')::numeric AS voc
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      {local_time_window_filter}
-)
-SELECT
-    asset_name,
-    attribute_name,
-    local_time AS recorded_at,
-    aqi_index,
-    pm25,
-    pm10,
-    co2,
-    voc,
-    sensor_data
-FROM raw_points
-ORDER BY asset_name, recorded_at ASC, attribute_name;
-""".strip()
-
-    def _build_tank_group_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        interval = self._interval_sql(time_window)
-        root_id = self._escape_sql(asset.db_asset_id or asset.asset_id)
-        offset = self._settings.local_time_offset_hours
-        timestamp_window_filter = self._window_filter_sql("ad.timestamp", time_window, local=False)
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name, attributes
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_level_points AS (
-    SELECT
-        ad.entity_id,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      AND (
-        NULLIF(COALESCE(ad.value->>'TankOilLevelInFeet001', CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END), '') IS NOT NULL
-        OR NULLIF(COALESCE(ad.value->>'Level', CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END), '') IS NOT NULL
-      )
-      {timestamp_window_filter}
-),
-bucketed AS (
-    SELECT
-        rp.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rp.entity_id, rp.day_bucket
-            ORDER BY rp.timestamp
-        ) AS sample_bucket
-    FROM raw_level_points rp
-),
-tank_payload AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.entity_id,
-            b.attribute_name,
-            b.timestamp,
-            b.value,
-            row_number() OVER (
-                PARTITION BY b.entity_id, b.day_bucket, b.sample_bucket
-                ORDER BY b.timestamp DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-),
-capacity_payload AS (
-    SELECT
-        d.id AS entity_id,
-        'asset.maxcapacity.value' AS attribute_name,
-        NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric AS max_ft_from_payload
-    FROM devices d
-    WHERE NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '') IS NOT NULL
-)
-SELECT
-    d.name AS asset_name,
-    tp.attribute_name AS level_attribute,
-    COALESCE(cp.attribute_name, 'asset.maxcapacity.value') AS max_ft_attribute,
-    tp.timestamp,
-    COALESCE(
-        NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric,
-        cp.max_ft_from_payload
-    ) AS max_ft,
-    COALESCE(
-        NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric,
-        NULLIF(CASE WHEN tp.attribute_name = 'TankOilLevelInFeet001' THEN tp.value::text END, '')::numeric,
-        NULLIF(tp.value->>'Level', '')::numeric,
-        NULLIF(CASE WHEN tp.attribute_name = 'Level' THEN tp.value::text END, '')::numeric
-    ) AS tank_oil_level_in_feet_001,
-    GREATEST(
-        COALESCE(
-            NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric,
-            cp.max_ft_from_payload,
-            0
-        ) - COALESCE(
-            NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric,
-            NULLIF(CASE WHEN tp.attribute_name = 'TankOilLevelInFeet001' THEN tp.value::text END, '')::numeric,
-            NULLIF(tp.value->>'Level', '')::numeric,
-            NULLIF(CASE WHEN tp.attribute_name = 'Level' THEN tp.value::text END, '')::numeric,
-            0
-        ),
-        0
-    ) AS current_level_ft,
-    ROUND(
-        (GREATEST(COALESCE(NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric, cp.max_ft_from_payload, 0) - COALESCE(NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric, NULLIF(tp.value->>'Level', '')::numeric, 0), 0)
-        / NULLIF(COALESCE(NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric, cp.max_ft_from_payload), 0)) * 100,
-        1
-    ) AS percentage_filled,
-    tp.value AS sensor_data
-FROM devices d
-LEFT JOIN tank_payload tp ON tp.entity_id = d.id
-LEFT JOIN capacity_payload cp ON cp.entity_id = d.id
-ORDER BY d.name, tp.timestamp;
-""".strip()
-        return f"""
-WITH RECURSIVE hierarchy AS (
-    SELECT id, name, parent_id, attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset
-    WHERE id = '{root_id}'
-    UNION ALL
-    SELECT c.id, c.name, c.parent_id, c.attributes::jsonb AS attributes
-    FROM {self._get_schema()}.asset c
-    JOIN hierarchy h ON c.parent_id = h.id
-),
-devices AS (
-    SELECT id, name, attributes
-    FROM hierarchy
-    WHERE id != '{root_id}'
-      AND attributes IS NOT NULL
-      AND (attributes - 'notes' - 'location') != '{{}}'::jsonb
-),
-raw_level_points AS (
-    SELECT
-        ad.entity_id,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN devices d ON d.id = ad.entity_id
-    WHERE 1=1
-      AND (
-        NULLIF(COALESCE(ad.value->>'TankOilLevelInFeet001', CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END), '') IS NOT NULL
-        OR NULLIF(COALESCE(ad.value->>'Level', CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END), '') IS NOT NULL
-      )
-      {timestamp_window_filter}
-    ORDER BY ad.entity_id, ad.timestamp ASC, ad.attribute_name
-),
-tank_payload AS (
-    SELECT
-        rp.entity_id,
-        rp.attribute_name,
-        rp.timestamp,
-        rp.value
-    FROM raw_level_points rp
-),
-capacity_payload AS (
-    SELECT
-        d.id AS entity_id,
-        'asset.maxcapacity.value' AS attribute_name,
-        NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric AS max_ft_from_payload
-    FROM devices d
-    WHERE NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '') IS NOT NULL
-)
-SELECT
-    d.name AS asset_name,
-    tp.attribute_name AS level_attribute,
-    COALESCE(cp.attribute_name, 'asset.maxcapacity.value') AS max_ft_attribute,
-    tp.timestamp,
-    COALESCE(
-        NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric,
-        cp.max_ft_from_payload
-    ) AS max_ft,
-    COALESCE(
-        NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric,
-        NULLIF(CASE WHEN tp.attribute_name = 'TankOilLevelInFeet001' THEN tp.value::text END, '')::numeric,
-        NULLIF(tp.value->>'Level', '')::numeric,
-        NULLIF(CASE WHEN tp.attribute_name = 'Level' THEN tp.value::text END, '')::numeric
-    ) AS tank_oil_level_in_feet_001,
-    GREATEST(
-        COALESCE(
-            NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric,
-            cp.max_ft_from_payload,
-            0
-        ) - COALESCE(
-            NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric,
-            NULLIF(CASE WHEN tp.attribute_name = 'TankOilLevelInFeet001' THEN tp.value::text END, '')::numeric,
-            NULLIF(tp.value->>'Level', '')::numeric,
-            NULLIF(CASE WHEN tp.attribute_name = 'Level' THEN tp.value::text END, '')::numeric,
-            0
-        ),
-        0
-    ) AS current_level_ft,
-    ROUND(
-        (GREATEST(COALESCE(NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric, cp.max_ft_from_payload, 0) - COALESCE(NULLIF(tp.value->>'TankOilLevelInFeet001', '')::numeric, NULLIF(tp.value->>'Level', '')::numeric, 0), 0) 
-        / NULLIF(COALESCE(NULLIF(d.attributes->'maxcapacity'->'value'->>'MaxFt', '')::numeric, cp.max_ft_from_payload), 0)) * 100, 
-        1
-    ) AS percentage_filled,
-    tp.value AS sensor_data
-FROM devices d
-LEFT JOIN tank_payload tp ON tp.entity_id = d.id
-LEFT JOIN capacity_payload cp ON cp.entity_id = d.id
-ORDER BY d.name, tp.timestamp ASC;
-""".strip()
-
-    def _build_cold_room_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        temp_expr = self._coalesce_json_value(asset.temperature_keys or ["Temperature", "temperature"])
-        humidity_expr = self._coalesce_json_value(asset.humidity_keys or ["Humidity", "humidity"])
-        offset = self._settings.local_time_offset_hours
-        interval = self._interval_sql(time_window)
-        exact_match = self._exact_asset_match_sql(asset.name)
-        local_time_window_filter = self._window_filter_sql(
-            f"(ad.timestamp + INTERVAL '{offset} hours')",
-            time_window,
-            local=True,
-        )
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH raw_data AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        regexp_replace({temp_expr}, '[^0-9\\.-]', '', 'g')::numeric AS temperature,
-        regexp_replace({humidity_expr}, '[^0-9\\.-]', '', 'g')::numeric AS humidity
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      AND {temp_expr} IS NOT NULL
-      AND NULLIF(regexp_replace({temp_expr}, '[^0-9\\.-]', '', 'g'), '') IS NOT NULL
-      {local_time_window_filter}
-),
-bucketed AS (
-    SELECT
-        rd.*,
-        date_trunc('day', rd.local_time) AS day_bucket,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rd.asset_uuid, date_trunc('day', rd.local_time)
-            ORDER BY rd.local_time
-        ) AS sample_bucket
-    FROM raw_data rd
-),
-sampled_data AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_uuid, b.day_bucket, b.sample_bucket
-                ORDER BY b.local_time DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    local_time AS recorded_at,
-    temperature,
-    humidity,
-    raw_time < NOW() - INTERVAL '{asset.nominal_range.get("max_stale_hours", 2)} hours' AS is_stale
-FROM sampled_data
-ORDER BY recorded_at ASC;
-""".strip()
-
-        return f"""
-WITH raw_data AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        regexp_replace({temp_expr}, '[^0-9\\.-]', '', 'g')::numeric AS temperature,
-        regexp_replace({humidity_expr}, '[^0-9\\.-]', '', 'g')::numeric AS humidity
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      AND {temp_expr} IS NOT NULL
-      AND NULLIF(regexp_replace({temp_expr}, '[^0-9\\.-]', '', 'g'), '') IS NOT NULL
-      {local_time_window_filter}
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    local_time AS recorded_at,
-    temperature,
-    humidity,
-    raw_time < NOW() - INTERVAL '{asset.nominal_range.get("max_stale_hours", 2)} hours' AS is_stale
-FROM raw_data
-ORDER BY recorded_at DESC
-LIMIT 500;
-""".strip()
-
-    def _build_filling_machine_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        offset = self._settings.local_time_offset_hours
-        interval = self._interval_sql(time_window)
-        exact_match = self._exact_asset_match_sql(asset.name)
-        local_time_window_filter = self._window_filter_sql(
-            f"(ad.timestamp + INTERVAL '{offset} hours')",
-            time_window,
-            local=True,
-        )
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH aggregated_readings AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.timestamp AS raw_time,
-        jsonb_object_agg(ad.attribute_name, ad.value) AS sensor_data
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      {local_time_window_filter}
-    GROUP BY a.id, a.name, ad.timestamp
-),
-raw_data AS (
-    SELECT
-        asset_uuid,
-        asset_name,
-        raw_time,
-        (raw_time + INTERVAL '{offset} hours') AS local_time,
-        (COALESCE(
-            sensor_data->>'prod_shift_1_today',
-            sensor_data->'data'->>'prod_shift_1_today'
-        ))::numeric AS shift_1_count,
-        (COALESCE(
-            sensor_data->>'prod_shift_2_today',
-            sensor_data->'data'->>'prod_shift_2_today'
-        ))::numeric AS shift_2_count,
-        (COALESCE(
-            sensor_data->>'prod_shift_3_today',
-            sensor_data->'data'->>'prod_shift_3_today'
-        ))::numeric AS shift_3_count,
-        (COALESCE(
-            sensor_data->>'prod_total_today',
-            sensor_data->'data'->>'prod_total_today'
-        ))::numeric AS total_count,
-        COALESCE(
-            NULLIF(COALESCE(sensor_data->>'Timestamp', sensor_data->'data'->>'Timestamp'), '')::timestamp,
-            raw_time + INTERVAL '{offset} hours'
-        ) AS payload_time
-    FROM aggregated_readings
-    WHERE COALESCE(
-        sensor_data->>'prod_total_today',
-        sensor_data->'data'->>'prod_total_today'
-    ) IS NOT NULL
-),
-bucketed AS (
-    SELECT
-        rd.*,
-        date_trunc('day', rd.local_time) AS day_bucket,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rd.asset_uuid, date_trunc('day', rd.local_time)
-            ORDER BY rd.local_time
-        ) AS sample_bucket
-    FROM raw_data rd
-),
-sampled_data AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_uuid, b.day_bucket, b.sample_bucket
-                ORDER BY b.local_time DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    local_time AS recorded_at,
-    shift_1_count,
-    shift_2_count,
-    shift_3_count,
-    total_count,
-    payload_time,
-    payload_time < (NOW() + INTERVAL '{offset} hours') - INTERVAL '{asset.nominal_range.get("max_stale_hours", 6)} hours' AS is_stale
-FROM sampled_data
-ORDER BY recorded_at ASC;
-""".strip()
-
-        return f"""
-WITH aggregated_readings AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.timestamp AS raw_time,
-        jsonb_object_agg(ad.attribute_name, ad.value) AS sensor_data
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      {local_time_window_filter}
-    GROUP BY a.id, a.name, ad.timestamp
-),
-raw_data AS (
-    SELECT
-        asset_uuid,
-        asset_name,
-        raw_time,
-        (raw_time + INTERVAL '{offset} hours') AS local_time,
-        (COALESCE(
-            sensor_data->>'prod_shift_1_today',
-            sensor_data->'data'->>'prod_shift_1_today'
-        ))::numeric AS shift_1_count,
-        (COALESCE(
-            sensor_data->>'prod_shift_2_today',
-            sensor_data->'data'->>'prod_shift_2_today'
-        ))::numeric AS shift_2_count,
-        (COALESCE(
-            sensor_data->>'prod_shift_3_today',
-            sensor_data->'data'->>'prod_shift_3_today'
-        ))::numeric AS shift_3_count,
-        (COALESCE(
-            sensor_data->>'prod_total_today',
-            sensor_data->'data'->>'prod_total_today'
-        ))::numeric AS total_count,
-        COALESCE(
-            NULLIF(COALESCE(sensor_data->>'Timestamp', sensor_data->'data'->>'Timestamp'), '')::timestamp,
-            raw_time + INTERVAL '{offset} hours'
-        ) AS payload_time
-    FROM aggregated_readings
-    WHERE COALESCE(
-        sensor_data->>'prod_total_today',
-        sensor_data->'data'->>'prod_total_today'
-    ) IS NOT NULL
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    local_time AS recorded_at,
-    shift_1_count,
-    shift_2_count,
-    shift_3_count,
-    total_count,
-    payload_time,
-    payload_time < (NOW() + INTERVAL '{offset} hours') - INTERVAL '{asset.nominal_range.get("max_stale_hours", 6)} hours' AS is_stale
-FROM raw_data
-ORDER BY recorded_at DESC
-LIMIT 500;
-""".strip()
-
-
-    def _build_tank_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        offset = self._settings.local_time_offset_hours
-        interval = self._interval_sql(time_window)
-        exact_match = self._exact_asset_match_sql(asset.name)
-        local_time_window_filter = self._window_filter_sql(
-            f"(ad.timestamp + INTERVAL '{offset} hours')",
-            time_window,
-            local=True,
-        )
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH tank_data AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ROUND(
-            regexp_replace(
-                COALESCE(
-                    ad.value->>'TankOilLevelInFeet001',
-                    CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-                    ad.value->>'Level',
-                    CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-                ),
-                '[^0-9\\.-]',
-                '',
-                'g'
-            )::numeric,
-            2
-        ) AS tank_oil_level_in_feet_001
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      AND COALESCE(
-            ad.value->>'TankOilLevelInFeet001',
-            CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-            ad.value->>'Level',
-            CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-          ) IS NOT NULL
-      AND NULLIF(
-            regexp_replace(
-                COALESCE(
-                    ad.value->>'TankOilLevelInFeet001',
-                    CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-                    ad.value->>'Level',
-                    CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-                ),
-                '[^0-9\\.-]',
-                '',
-                'g'
-            ),
-            ''
-          ) IS NOT NULL
-      {local_time_window_filter}
-),
-bucketed AS (
-    SELECT
-        td.*,
-        date_trunc('day', td.local_time) AS day_bucket,
-        ntile({per_day_points}) OVER (
-            PARTITION BY td.asset_uuid, date_trunc('day', td.local_time)
-            ORDER BY td.local_time
-        ) AS sample_bucket
-    FROM tank_data td
-),
-sampled_tank_data AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_uuid, b.day_bucket, b.sample_bucket
-                ORDER BY b.local_time DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-),
-latest_capacity AS (
-    SELECT
-        a.id AS asset_uuid,
-        'asset.maxcapacity.value' AS attribute_name,
-        NULLIF(a.attributes::jsonb->'maxcapacity'->'value'->>'MaxFt', '')::numeric AS max_ft
-    FROM {self._get_schema()}.asset a
-    WHERE {exact_match}
-      AND NULLIF(a.attributes::jsonb->'maxcapacity'->'value'->>'MaxFt', '') IS NOT NULL
-),
-ordered AS (
-    SELECT
-           td.asset_uuid,
-           td.asset_name,
-           td.attribute_name AS level_attribute,
-           td.raw_time,
-           td.local_time,
-           lc.attribute_name AS max_ft_attribute,
-           lc.max_ft,
-           td.tank_oil_level_in_feet_001,
-           GREATEST(COALESCE(lc.max_ft, 0) - COALESCE(td.tank_oil_level_in_feet_001, 0), 0) AS current_level_ft,
-           LAG(GREATEST(COALESCE(lc.max_ft, 0) - COALESCE(td.tank_oil_level_in_feet_001, 0), 0))
-               OVER (PARTITION BY asset_name ORDER BY local_time ASC) AS previous_level
-    FROM sampled_tank_data td
-    LEFT JOIN latest_capacity lc ON lc.asset_uuid = td.asset_uuid
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    level_attribute,
-    max_ft_attribute,
-    local_time AS recorded_at,
-    max_ft,
-    tank_oil_level_in_feet_001,
-    current_level_ft,
-    ROUND((current_level_ft / NULLIF(max_ft, 0)) * 100, 1) AS percentage_filled,
-    CASE
-        WHEN previous_level IS NULL THEN 0
-        ELSE ROUND(current_level_ft - previous_level, 2)
-    END AS level_change,
-    raw_time < NOW() - INTERVAL '{asset.nominal_range.get("max_stale_hours", 1)} hours' AS is_stale
-FROM ordered
-ORDER BY recorded_at ASC;
-""".strip()
-
-        return f"""
-WITH tank_data AS (
-    SELECT
-        a.id AS asset_uuid,
-        a.name AS asset_name,
-        ad.attribute_name,
-        ad.timestamp AS raw_time,
-        (ad.timestamp + INTERVAL '{offset} hours') AS local_time,
-        ROUND(
-            regexp_replace(
-                COALESCE(
-                    ad.value->>'TankOilLevelInFeet001',
-                    CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-                    ad.value->>'Level',
-                    CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-                ),
-                '[^0-9\\.-]',
-                '',
-                'g'
-            )::numeric,
-            2
-        ) AS tank_oil_level_in_feet_001
-    FROM {self._get_schema()}.asset_datapoint ad
-    JOIN {self._get_schema()}.asset a ON a.id = ad.entity_id
-    WHERE {exact_match}
-      AND COALESCE(
-            ad.value->>'TankOilLevelInFeet001',
-            CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-            ad.value->>'Level',
-            CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-          ) IS NOT NULL
-      AND NULLIF(
-            regexp_replace(
-                COALESCE(
-                    ad.value->>'TankOilLevelInFeet001',
-                    CASE WHEN ad.attribute_name = 'TankOilLevelInFeet001' THEN ad.value::text END,
-                    ad.value->>'Level',
-                    CASE WHEN ad.attribute_name = 'Level' THEN ad.value::text END
-                ),
-                '[^0-9\\.-]',
-                '',
-                'g'
-            ),
-            ''
-          ) IS NOT NULL
-      {local_time_window_filter}
-),
-latest_capacity AS (
-    SELECT
-        a.id AS asset_uuid,
-        'asset.maxcapacity.value' AS attribute_name,
-        NULLIF(a.attributes::jsonb->'maxcapacity'->'value'->>'MaxFt', '')::numeric AS max_ft
-    FROM {self._get_schema()}.asset a
-    WHERE {exact_match}
-      AND NULLIF(a.attributes::jsonb->'maxcapacity'->'value'->>'MaxFt', '') IS NOT NULL
-),
-ordered AS (
-    SELECT
-           td.asset_uuid,
-           td.asset_name,
-           td.attribute_name AS level_attribute,
-           td.raw_time,
-           td.local_time,
-           lc.attribute_name AS max_ft_attribute,
-           lc.max_ft,
-           td.tank_oil_level_in_feet_001,
-           GREATEST(COALESCE(lc.max_ft, 0) - COALESCE(td.tank_oil_level_in_feet_001, 0), 0) AS current_level_ft,
-           LAG(GREATEST(COALESCE(lc.max_ft, 0) - COALESCE(td.tank_oil_level_in_feet_001, 0), 0))
-               OVER (PARTITION BY asset_name ORDER BY local_time ASC) AS previous_level
-    FROM tank_data td
-    LEFT JOIN latest_capacity lc ON lc.asset_uuid = td.asset_uuid
-)
-SELECT
-    asset_uuid::text AS asset_id,
-    asset_name,
-    level_attribute,
-    max_ft_attribute,
-    local_time AS recorded_at,
-    max_ft,
-    tank_oil_level_in_feet_001,
-    current_level_ft,
-    ROUND((current_level_ft / NULLIF(max_ft, 0)) * 100, 1) AS percentage_filled,
-    CASE
-        WHEN previous_level IS NULL THEN 0
-        ELSE ROUND(current_level_ft - previous_level, 2)
-    END AS level_change,
-    raw_time < NOW() - INTERVAL '{asset.nominal_range.get("max_stale_hours", 1)} hours' AS is_stale
-FROM ordered
-ORDER BY recorded_at DESC
-LIMIT 500;
-""".strip()
-
-    def _build_generic_query(self, asset: AssetProfile, time_window: TimeWindow) -> str:
-        interval = self._interval_sql(time_window)
-        exact_match = self._exact_asset_match_sql(asset.name)
-        offset = self._settings.local_time_offset_hours
-        timestamp_window_filter = self._window_filter_sql("ad.timestamp", time_window, local=False)
-        sampled = self._is_multi_day_window(time_window)
-        per_day_points = self._points_per_day(time_window)
-        if sampled:
-            return f"""
-WITH raw_data AS (
-    SELECT
-        a.id::text AS asset_id,
-        a.name AS asset_name,
-        ad.attribute_name,
-        (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-        ad.value AS sensor_data,
-        date_trunc('day', ad.timestamp + INTERVAL '{offset} hours') AS day_bucket
-    FROM {self._get_schema()}.asset a
-    JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = a.id
-    WHERE {exact_match}
-      {timestamp_window_filter}
-),
-bucketed AS (
-    SELECT
-        rd.*,
-        ntile({per_day_points}) OVER (
-            PARTITION BY rd.asset_id, rd.attribute_name, rd.day_bucket
-            ORDER BY rd.timestamp
-        ) AS sample_bucket
-    FROM raw_data rd
-),
-sampled_data AS (
-    SELECT *
-    FROM (
-        SELECT
-            b.*,
-            row_number() OVER (
-                PARTITION BY b.asset_id, b.attribute_name, b.day_bucket, b.sample_bucket
-                ORDER BY b.timestamp DESC
-            ) AS rn
-        FROM bucketed b
-    ) ranked
-    WHERE rn = 1
-)
-SELECT
-    asset_id,
-    asset_name,
-    attribute_name,
-    (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-    sensor_data
-FROM sampled_data
-ORDER BY timestamp ASC, attribute_name;
-""".strip()
-        return f"""
-SELECT
-    a.id::text AS asset_id,
-    a.name AS asset_name,
-    ad.attribute_name,
-    (ad.timestamp + INTERVAL '{offset} hours') AS timestamp,
-    ad.value AS sensor_data
-FROM {self._get_schema()}.asset a
-JOIN {self._get_schema()}.asset_datapoint ad ON ad.entity_id = a.id
-WHERE {exact_match}
-  {timestamp_window_filter}
-ORDER BY ad.timestamp DESC
-LIMIT 500;
-""".strip()
-
-    def _coalesce_json_value(self, keys: list[str]) -> str:
-        expressions = []
-        for key in keys:
-            expressions.append(f"ad.value->>'{key}'")
-            expressions.append(f"CASE WHEN ad.attribute_name = '{key}' THEN ad.value::text END")
-        return f"COALESCE({', '.join(expressions)})"
-
-    def _exact_asset_match_sql(self, name: str) -> str:
-        escaped = self._escape_sql(name)
-        return (
-            "REPLACE(LOWER(a.name), ' ', '') = "
-            f"REPLACE(LOWER('{escaped}'), ' ', '')"
-        )
-
-    def _interval_sql(self, time_window: TimeWindow) -> str:
-        unit = time_window.unit.rstrip("s")
-        value = max(1, time_window.value)
-        return f"{value} {unit}"
-
-    def _window_filter_sql(self, column_expr: str, time_window: TimeWindow, local: bool) -> str:
-        bounds = self._absolute_window_bounds(time_window)
-        offset = self._settings.local_time_offset_hours
-        if bounds is not None:
-            start_dt, end_dt = bounds
-            start_text = start_dt.strftime("%Y-%m-%d %H:%M:%S")
-            end_text = end_dt.strftime("%Y-%m-%d %H:%M:%S")
-            if not local:
-                return (
-                    f"AND {column_expr} >= TIMESTAMP '{start_text}' - INTERVAL '{offset} hours'\n"
-                    f"      AND {column_expr} < TIMESTAMP '{end_text}' - INTERVAL '{offset} hours'"
-                )
-            return (
-                f"AND {column_expr} >= TIMESTAMP '{start_text}'\n"
-                f"      AND {column_expr} < TIMESTAMP '{end_text}'"
-            )
-
-        interval = self._interval_sql(time_window)
-        if local:
-            return (
-                f"AND {column_expr} >= NOW() + INTERVAL '{offset} hours' - INTERVAL '{interval}'"
-            )
-        return f"AND {column_expr} >= NOW() - INTERVAL '{interval}'"
-
-    def _absolute_window_bounds(self, time_window: TimeWindow) -> tuple[datetime, datetime] | None:
-        if not time_window.start_at or not time_window.end_at:
-            return None
-        try:
-            start_dt = datetime.fromisoformat(time_window.start_at)
-            end_dt = datetime.fromisoformat(time_window.end_at)
-            return start_dt, end_dt
-        except ValueError:
-            return None
-
-    def _is_multi_day_window(self, time_window: TimeWindow) -> bool:
-        if time_window.unit in {"days", "weeks", "months"}:
-            return True
-        return time_window.unit == "hours" and time_window.value >= 24
-
-    def _points_per_day(self, time_window: TimeWindow) -> int:
-        # Keep payload manageable while preserving trend shape for long windows.
-        if time_window.unit == "months":
-            return 10
-        if time_window.unit in {"weeks", "days"}:
-            return 12
-        return 15
-
-    def _escape_sql(self, value: str) -> str:
-        return value.replace("'", "''")
-
-
-nl_to_sql_service = NLToSQLService()

agents/analysis/backend/app/services/report_builder.py

@@ -1,123 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from jinja2 import Template
-
-from agents.analysis.backend.app.models.schemas import AnalysisPlan, AnalysisReport, AssetProfile
-from agents.analysis.backend.app.services.deterministic_analysis import deterministic_analysis_service
-
-
-class ReportBuilderService:
-    def __init__(self) -> None:
-        self._template_path = Path(__file__).resolve().parents[1] / "templates" / "report.html"
-
-    def build(
-        self,
-        asset: AssetProfile,
-        plan: AnalysisPlan,
-        rows: list[dict],
-        summary_override: str = "",
-    ) -> AnalysisReport:
-        title = f"{asset.name} - {plan.analysis_name}"
-        summary_body = summary_override or self._summarize_rows(asset, plan, rows)
-        summary = self._with_analysis_period(plan, summary_body)
-        markdown = self._to_markdown(title=title, asset=asset, plan=plan, rows=rows, summary=summary)
-        html = self._to_html(title=title, asset=asset, plan=plan, rows=rows, summary=summary)
-        return AnalysisReport(
-            title=title,
-            summary=summary,
-            markdown=markdown,
-            html=html,
-        )
-
-    def _summarize_rows(self, asset: AssetProfile, plan: AnalysisPlan, rows: list[dict]) -> str:
-        if not rows:
-            return (
-                f"No rows were returned for {asset.name}. "
-                f"The agent selected `{plan.analysis_name}` for {plan.time_window.label}."
-            )
-
-        metrics = ", ".join(asset.metrics) or "available telemetry"
-        stats = deterministic_analysis_service.summarize(asset, rows)
-        metric_lines = []
-        for metric, values in list(stats["numeric_metrics"].items())[:3]:
-            metric_lines.append(
-                f"{metric}: latest {values['latest']:.2f}, min {values['min']:.2f}, "
-                f"max {values['max']:.2f}, avg {values['avg']:.2f}"
-            )
-        findings = " ".join(stats["findings"][:3])
-        stats_text = " ".join(metric_lines)
-        return (
-            f"{asset.name} was analyzed using `{plan.analysis_name}` over {plan.time_window.label}. "
-            f"The report uses {len(rows)} rows and focuses on {metrics}. {findings} {stats_text}".strip()
-        )
-
-    def _with_analysis_period(self, plan: AnalysisPlan, summary: str) -> str:
-        period = plan.query_window_label or plan.time_window.label
-        prefix = f"Analysis period: {period}."
-        cleaned_summary = summary.strip()
-        if cleaned_summary.lower().startswith("analysis period:"):
-            return cleaned_summary
-        if not cleaned_summary:
-            return prefix
-        return f"{prefix}\n\n{cleaned_summary}"
-
-    def _to_markdown(
-        self,
-        title: str,
-        asset: AssetProfile,
-        plan: AnalysisPlan,
-        rows: list[dict],
-        summary: str,
-    ) -> str:
-        sample = rows[:5]
-        lines = [
-            f"# {title}",
-            "",
-            f"**Asset:** {asset.name}",
-            f"**Asset type:** {asset.asset_type}",
-            f"**Analysis:** {plan.analysis_name}",
-            f"**Time window:** {plan.time_window.label}",
-            "",
-            "## Summary",
-            summary,
-            "",
-            "## Reasoning",
-            plan.reasoning,
-            "",
-            "## SQL",
-            "```sql",
-            plan.sql_query,
-            "```",
-            "",
-            "## Sample Rows",
-            "```json",
-            str(sample),
-            "```",
-        ]
-        return "\n".join(lines)
-
-    def _to_html(
-        self,
-        title: str,
-        asset: AssetProfile,
-        plan: AnalysisPlan,
-        rows: list[dict],
-        summary: str,
-    ) -> str:
-        template = Template(self._template_path.read_text(encoding="utf-8"))
-        columns = list(rows[0].keys()) if rows else ["message"]
-        display_rows = rows[:10] if rows else [{"message": "No rows returned"}]
-        return template.render(
-            title=title,
-            subtitle=f"{asset.asset_type} | {plan.time_window.label}",
-            summary=summary,
-            details=plan.reasoning,
-            sql_query=plan.sql_query,
-            columns=columns,
-            rows=display_rows,
-        )
-
-
-report_builder_service = ReportBuilderService()