deploy: backend from 5bbaa0e

.env.example

@@ -17,8 +17,6 @@ DEEPSEEK_REASONER_MODEL=deepseek-reasoner
 # HF API token — kept only for HF Space deployment and dataset push
 HF_API_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-# HF Model ID for AI monitoring proxy
-VITE_HF_MODEL_ID=Qwen/QwQ-32B
 
 # ── Model Selection ───────────────────────────────────────────────
 # LOCAL DEVELOPMENT — deepseek-chat (fast, $0.14/M input)

codemap.md

@@ -16,7 +16,7 @@ FastAPI backend entry point: initializes Firebase/Firestore, authentication, mid
 4. Data paths read/write Firestore and model/RAG providers; async generation stores task state for `/api/tasks/{task_id}` polling.
 
 ## Integration
-- Router modules: `rag`, `admin_model`, `admin`, `curriculum`, `diagnostic`, `video`, `quiz_battle`, `teacher_materials`, `class_records`, `risk`, `tutor_checkin`, `practice`, `try_it_yourself`, `ai_monitoring`, `class_analytics`, `intervention`, `pipeline`, `deepseek_rag`, `at_risk_resolution`, `fun_modules`, `jev`.
+- Router modules: `rag`, `admin_model`, `admin`, `curriculum`, `diagnostic`, `video`, `quiz_battle`, `teacher_materials`, `class_records`, `risk`, `tutor_checkin`, `practice`, `try_it_yourself`, `class_analytics`, `intervention`, `pipeline`, `deepseek_rag`, `at_risk_resolution`, `fun_modules`, `jev`.
 - Core routes include `/api/chat`, `/api/chat/stream`, `/api/verify-solution`, `/api/predict-risk`, `/api/learning-path`, `/api/lesson/generate`, `/api/quiz/generate`, account import, class-record upload, admin users, analytics, and `/api/automation/*`.
 - Firebase Auth token claims/Firestore `users` provide identity and role data. Other directly used collections include `diagnosticResults`, `classRecordImports`, `normalizedClassRecords`, `classrooms`, `managedStudents`, `riskRefreshEvents`, `riskRefreshJobs`, `riskRefreshStats`, and `classSectionOwnership`.
 - Uses `middleware.rate_limiter`, `config.models.yaml`/`config.ai_pricing.py`, `services.*`, `rag.*`, and top-level `analytics.py`/`automation_engine.py`.

main.py

@@ -93,7 +93,7 @@ import httpx
 import uvicorn
 from services.inference_client import (
     InferenceRequest, create_default_client,
-    get_model_for_task, get_current_runtime_config,
+    get_model_for_task,
 )
 from services.deterministic_cache import DeterministicResponseCache
 from services.logging_utils import log_model_call
@@ -124,7 +124,6 @@ from routes.risk_router import router as risk_router
 from routes.tutor_checkin import router as tutor_checkin_router
 from routes.practice import router as practice_router
 from routes.try_it_yourself import router as try_it_yourself_router
-from routes.ai_monitoring import router as ai_monitoring_router
 from routes.class_analytics_routes import router as class_analytics_router
 from routes.intervention_routes import router as intervention_router
 from routes.pipeline_routes import router as pipeline_router
@@ -469,7 +468,6 @@ ROLE_POLICIES: Dict[str, Set[str]] = {
     "/api/analytics/class-insights": TEACHER_OR_ADMIN,
     "/api/analytics/refresh-cache": ADMIN_ONLY,
     "/api/testing/reset-data": ALL_APP_ROLES,
-    "/api/hf/monitoring": ADMIN_ONLY,
     "/api/dev/generate-mock-data": ADMIN_ONLY,
     "/api/analytics/config": TEACHER_OR_ADMIN,
     "/api/analytics/imported-class-overview": TEACHER_OR_ADMIN,
@@ -1224,7 +1222,6 @@ app.include_router(risk_router)
 app.include_router(tutor_checkin_router)
 app.include_router(practice_router)
 app.include_router(try_it_yourself_router)
-app.include_router(ai_monitoring_router)
 app.include_router(class_analytics_router)
 app.include_router(intervention_router)
 app.include_router(pipeline_router)
@@ -9722,11 +9719,6 @@ class AsyncTaskCancelResponse(BaseModel):
     message: str
 
 
-class HFMonitoringDataResponse(BaseModel):
-    success: bool
-    data: Dict[str, Any]
-
-
 class ImportGroundedFeedbackRequest(BaseModel):
     flow: str = Field(..., description="Flow identifier: quiz or lesson")
     status: str = Field(..., description="Event status: success, failed, or skipped")
@@ -12304,83 +12296,6 @@ async def cancel_async_task(http_request: Request, task_id: str):
     )
 
 
-@app.get("/api/hf/monitoring", response_model=HFMonitoringDataResponse)
-async def get_hf_monitoring(http_request: Request):
-    """
-    Aggregates DeepSeek AI status, model config, and latency probe.
-    Returns distilled data safe for frontend consumption.
-
-    Requires admin authentication.
-    """
-    user = get_current_user(http_request)
-    if user.role != "admin":
-        raise HTTPException(status_code=403, detail="Forbidden for this role")
-
-    _ensure_deepseek_available()
-
-    try:
-        generation_model_id = get_model_for_task("chat")
-    except Exception:
-        generation_model_id = CHAT_MODEL
-
-    embedding_model_id = os.getenv("EMBEDDING_MODEL", "BAAI/bge-small-en-v1.5")
-
-    runtime_config = get_current_runtime_config()
-
-    task_resolved: dict[str, str] = {}
-    for task in [
-        "chat", "verify_solution", "lesson_generation", "quiz_generation",
-        "learning_path", "daily_insight", "risk_classification", "risk_narrative",
-        "rag_lesson", "rag_problem", "rag_analysis_context",
-    ]:
-        try:
-            task_resolved[task] = get_model_for_task(task)
-        except Exception:
-            task_resolved[task] = generation_model_id
-
-    result: Dict[str, Any] = {
-        "modelId": generation_model_id,
-        "modelStatus": "Operational",
-        "avgResponseTimeMs": 0,
-        "embeddingModelId": embedding_model_id,
-        "embeddingModelStatus": "Operational",
-        "inferenceBalance": 0.0,
-        "totalPeriodCost": 0.0,
-        "hubApiCallsUsed": 0,
-        "hubApiCallsLimit": 2500,
-        "zeroGpuMinutesUsed": 0,
-        "zeroGpuMinutesLimit": 25,
-        "publicStorageUsedTB": 0.0,
-        "publicStorageLimitTB": 11.2,
-        "lastChecked": datetime.now(timezone.utc).isoformat(),
-        "periodStart": "",
-        "periodEnd": "",
-        "activeProfile": runtime_config.get("profile") or os.getenv("MODEL_PROFILE", "dev"),
-        "runtimeOverridesActive": len(runtime_config.get("overrides", {})) > 0,
-        "resolvedModels": task_resolved,
-        "provider": "deepseek",
-        "apiBaseUrl": os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com"),
-    }
-
-    try:
-        client = get_deepseek_client()
-        latency_start = time.time()
-        probe_response = client.chat.completions.create(
-            model=str(CHAT_MODEL),
-            messages=[{"role": "user", "content": "Hi"}],
-            max_tokens=1,
-            temperature=0.0,
-        )
-        latency_ms = int((time.time() - latency_start) * 1000)
-        result["avgResponseTimeMs"] = latency_ms
-        result["modelStatus"] = "Operational"
-    except Exception as e:
-        logger.warning(f"DeepSeek latency probe failed: {e}")
-        result["modelStatus"] = "Degraded"
-
-    return HFMonitoringDataResponse(success=True, data=result)
-
-
 @app.get("/api/quiz/topics")
 async def get_quiz_topics(response: Response, gradeLevel: Optional[str] = None):
     """

routes/ai_monitoring.py

@@ -1,243 +0,0 @@
-# backend/routes/ai_monitoring.py
-# TODO: Review pricing after 2026-05-31
-from datetime import date, datetime, time, timedelta, timezone
-from zoneinfo import ZoneInfo
-from fastapi import APIRouter, Depends, HTTPException, Request
-import logging
-
-from config.ai_pricing import get_active_pricing, get_full_pricing, DEEPSEEK_PRICING
-
-logger = logging.getLogger("mathpulse.ai_monitoring")
-
-router = APIRouter(prefix="/api/admin/ai-monitoring", tags=["admin", "ai-monitoring"])
-MANILA = ZoneInfo("Asia/Manila")
-
-
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _get_firestore_client():
-    try:
-        from firebase_admin import firestore
-
-        return firestore.client()
-    except Exception as exc:
-        logger.warning("AI monitoring Firestore unavailable: %s", exc)
-        return None
-
-
-def _as_datetime(value) -> datetime | None:
-    if isinstance(value, datetime):
-        return value.replace(tzinfo=timezone.utc) if value.tzinfo is None else value
-    if isinstance(value, str):
-        try:
-            return datetime.fromisoformat(value.replace("Z", "+00:00"))
-        except ValueError:
-            return None
-    return None
-
-
-def _aggregate_telemetry() -> dict:
-    """Aggregate attempt events into Manila days; pending events count as failed attempts."""
-    today = _now().astimezone(MANILA).date()
-    first_day = today - timedelta(days=29)
-    days: dict[date, dict] = {
-        first_day + timedelta(days=offset): {
-            "date": (first_day + timedelta(days=offset)).isoformat(),
-            "totalAttempts": 0,
-            "successfulAttempts": 0,
-            "completedRequests": 0,
-            "latencyTotalMs": 0.0,
-        }
-        for offset in range(30)
-    }
-    requests_by_task_type: dict[str, int] = {}
-    start_at = datetime.combine(first_day, time.min, tzinfo=MANILA).astimezone(timezone.utc)
-    end_at = datetime.combine(today + timedelta(days=1), time.min, tzinfo=MANILA).astimezone(timezone.utc)
-    db = _get_firestore_client()
-    if db is not None:
-        try:
-            events = (
-                db.collection("ai_usage_logs")
-                .where("timestamp", ">=", start_at)
-                .where("timestamp", "<", end_at)
-                .stream()
-            )
-            for snapshot in events:
-                event = snapshot.to_dict() or {}
-                timestamp = _as_datetime(event.get("timestamp"))
-                if timestamp is None:
-                    timestamp = _as_datetime(event.get("createdAtIso"))
-                if timestamp is None:
-                    continue
-                bucket = timestamp.astimezone(MANILA).date()
-                if bucket not in days:
-                    continue
-                daily = days[bucket]
-                daily["totalAttempts"] += 1
-                task_type = event.get("taskType")
-                if isinstance(task_type, str) and task_type:
-                    requests_by_task_type[task_type] = requests_by_task_type.get(task_type, 0) + 1
-                if event.get("status") == "success":
-                    daily["successfulAttempts"] += 1
-                    latency_ms = event.get("latencyMs")
-                    if isinstance(latency_ms, (int, float)) and latency_ms >= 0:
-                        daily["completedRequests"] += 1
-                        daily["latencyTotalMs"] += latency_ms
-        except Exception as exc:
-            logger.warning("AI monitoring telemetry read failed: %s", exc)
-
-    daily_metrics = []
-    total_attempts = successful_attempts = completed_requests = 0
-    latency_total_ms = 0.0
-    for daily in days.values():
-        total_attempts += daily["totalAttempts"]
-        successful_attempts += daily["successfulAttempts"]
-        completed_requests += daily["completedRequests"]
-        latency_total_ms += daily["latencyTotalMs"]
-        daily_metrics.append({
-            "date": daily["date"],
-            "totalAttempts": daily["totalAttempts"],
-            "successfulAttempts": daily["successfulAttempts"],
-            "completedRequests": daily["completedRequests"],
-            "averageLatencyMs": round(daily["latencyTotalMs"] / daily["completedRequests"], 2) if daily["completedRequests"] else None,
-            "successRate": round(daily["successfulAttempts"] / daily["totalAttempts"] * 100, 1) if daily["totalAttempts"] else None,
-        })
-
-    return {
-        "dailyMetrics": daily_metrics,
-        "requestsByTaskType": requests_by_task_type,
-        "totalAttempts": total_attempts,
-        "successfulAttempts": successful_attempts,
-        "completedRequests": completed_requests,
-        "averageLatencyMs": round(latency_total_ms / completed_requests, 2) if completed_requests else None,
-        "successRate": round(successful_attempts / total_attempts * 100, 1) if total_attempts else None,
-        "latencyDefinition": "Mean generation time in milliseconds across completed requests only.",
-        "successRateDefinition": "Successful attempts divided by all attempts, as a percentage.",
-        "dayTimezone": "Asia/Manila",
-    }
-
-
-def require_admin(request: Request):
-    user = getattr(request.state, "user", None)
-    if user is None:
-        raise HTTPException(status_code=401, detail="Authentication required")
-    if user.role not in ("admin", "superadmin"):
-        raise HTTPException(status_code=403, detail="Admin access required")
-    return user
-
-
-def _build_pricing_meta(model_id: str = "deepseek-v4-pro") -> dict:
-    """Build pricingMeta block for response."""
-    pricing = get_active_pricing(model_id)
-    full = get_full_pricing(model_id)
-    now = datetime.now(timezone.utc)
-    promo_config = DEEPSEEK_PRICING.get(model_id, {}).get("promotional", {})
-    expires = promo_config.get("expires_utc", now)
-    days_remaining = max(0, (expires - now).days) if pricing.get("is_promotional") else 0
-
-    return {
-        "activeModel": model_id,
-        "isPromotional": pricing.get("is_promotional", False),
-        "promoExpiresUtc": expires.isoformat() if pricing.get("is_promotional") else None,
-        "daysUntilPromoEnds": days_remaining,
-        "currentInputCacheMissRate": pricing["input_cache_miss_per_1m"],
-        "currentOutputRate": pricing["output_per_1m"],
-        "fullPriceInputRate": full["input_cache_miss_per_1m"],
-        "fullPriceOutputRate": full["output_per_1m"],
-    }
-
-
-FEATURE_NAMES = {
-    "chat": "AI Chat Tutor",
-    "rag_lesson": "RAG Lessons",
-    "lesson_generation": "Lesson Generation",
-    "quiz_generation": "Quiz Generation",
-    "verify_solution": "Solution Verification",
-    "intervention_plan": "Intervention Plans",
-    "class_report": "Class Reports",
-    "daily_insight": "Daily Insights",
-    "learning_path": "Learning Paths",
-    "risk_narrative": "Risk Narratives",
-}
-COST_TRACKING_NOTE = (
-    "Token usage, cost and cache hits are not logged; only attempt counts, outcomes and latency are measured."
-)
-
-
-def _aggregate_summary(telemetry: dict | None = None) -> dict:
-    """Summarise measured attempts per task type. Cost and cache figures are not measured and stay null."""
-    if telemetry is None:
-        telemetry = _aggregate_telemetry()
-    model_id = "deepseek-v4-pro"
-    pricing = get_active_pricing(model_id)
-    total_attempts = telemetry["totalAttempts"]
-    by_task_type = sorted(telemetry["requestsByTaskType"].items(), key=lambda entry: (-entry[1], entry[0]))
-
-    features = [
-        {
-            "featureId": task_type,
-            "featureName": FEATURE_NAMES.get(task_type, task_type.replace("_", " ").title()),
-            "modelId": model_id,
-            "monthlyCost": None,
-            "requestShare": round(count / total_attempts * 100, 1) if total_attempts else 0.0,
-            "totalRequests": count,
-            "totalInputTokens": None,
-            "totalOutputTokens": None,
-            "cacheHitRate": None,
-            "isMostActive": position == 0,
-            "isTopSpending": False,
-            "icon": "Zap",
-        }
-        for position, (task_type, count) in enumerate(by_task_type)
-    ]
-
-    summary = {
-        "systemStatus": "healthy",
-        "actionRequired": False,
-        "hasPerformanceIssues": False,
-        "monthlyCost": None,
-        "projectedMonthlyCost": None,
-        "billingCycleLabel": "Last 30 days",
-        "costBreakdown": None,
-        "costTrackingNote": COST_TRACKING_NOTE,
-        "totalUsage": total_attempts,
-        "totalInputTokens": None,
-        "totalOutputTokens": None,
-        "cacheHitRate": None,
-        "activeEngine": "DeepSeek-V4 Pro",
-        "activeEngineModelId": model_id,
-        "engineTier": "High-Performance LLM",
-        "promotionalPricingActive": pricing.get("is_promotional", False),
-        "promotionalPriceExpiresUtc": pricing.get("promo_expires_utc", ""),
-        "estimatedCostAfterPromo": None,
-        "lastUpdated": datetime.now(timezone.utc).isoformat(),
-    }
-
-    return {"summary": summary, "features": features}
-
-
-@router.get("/summary")
-def get_monitoring_summary(_admin=Depends(require_admin)):
-    """Returns AI monitoring summary + feature metrics + pricing metadata."""
-    telemetry = _aggregate_telemetry()
-    aggregated = _aggregate_summary(telemetry)
-    return {
-        **aggregated["summary"],
-        "features": aggregated["features"],
-        "pricingMeta": _build_pricing_meta(),
-        "telemetry": telemetry,
-    }
-
-
-@router.post("/refresh")
-def refresh_monitoring(_admin=Depends(require_admin)):
-    """Acknowledge a refresh; the summary endpoint re-aggregates on every read."""
-    # TODO: Write to Firestore ai_monitoring/summary when Firestore admin SDK is available
-    pricing = get_active_pricing("deepseek-v4-pro")
-    return {
-        "success": True,
-        "updatedAt": datetime.now(timezone.utc).isoformat(),
-        "pricingUsed": pricing,
-    }

services/inference_client.py

@@ -540,39 +540,13 @@ class InferenceClient:
         except Exception as e:
             LOGGER.warning(f"?????? Failed to persist metrics: {e}")
 
-    def _record_attempt(self, *, task_type: str, provider: str, route: str, fallback_depth: int):
+    def _record_attempt(self, *, task_type: str, provider: str, route: str, fallback_depth: int) -> None:
         self._bump_metric("requests_total", 1)
         self._bump_bucket("task_counts", (task_type or "default").strip().lower(), 1)
         self._bump_bucket("provider_counts", provider, 1)
         self._bump_bucket("route_counts", route, 1)
         if fallback_depth > 0:
             self._bump_metric("fallback_attempts", 1)
-        try:
-            from datetime import datetime, timezone
-            from firebase_admin import firestore as firebase_firestore
-
-            firestore_client = self.firestore or firebase_firestore.client()
-            return firestore_client.collection("ai_usage_logs").add({
-                "timestamp": datetime.now(timezone.utc),
-                "taskType": task_type,
-                "provider": provider,
-                "route": route,
-                "fallbackDepth": fallback_depth,
-                "status": "pending",
-                "latencyMs": None,
-            })[1]
-        except Exception as exc:
-            LOGGER.warning("AI monitoring attempt logging skipped: %s", exc)
-            return None
-
-    @staticmethod
-    def _finish_telemetry_attempt(document, *, status: str, latency_ms: float) -> None:
-        if document is None:
-            return
-        try:
-            document.update({"status": status, "latencyMs": round(latency_ms, 2) if status == "success" else None})
-        except Exception as exc:
-            LOGGER.warning("AI monitoring attempt update skipped: %s", exc)
 
     def snapshot_metrics(self) -> Dict[str, Any]:
         with self._metrics_lock:
@@ -768,7 +742,7 @@ class InferenceClient:
             params["response_format"] = {"type": "json_object"}
 
         for attempt in range(max_retries):
-            telemetry_document = self._record_attempt(
+            self._record_attempt(
                 task_type=task_type,
                 provider="deepseek",
                 route=route,
@@ -803,12 +777,10 @@ class InferenceClient:
                 )
                 self._record_completion(latency_ms=latency_ms)
                 self._bump_metric("requests_ok", 1)
-                self._finish_telemetry_attempt(telemetry_document, status="success", latency_ms=latency_ms)
                 return text
 
             except RateLimitError:
                 latency_ms = (time.perf_counter() - start) * 1000
-                self._finish_telemetry_attempt(telemetry_document, status="error", latency_ms=latency_ms)
                 if attempt < max_retries - 1:
                     log_model_call(
                         LOGGER,
@@ -835,7 +807,6 @@ class InferenceClient:
 
             except APITimeoutError:
                 latency_ms = (time.perf_counter() - start) * 1000
-                self._finish_telemetry_attempt(telemetry_document, status="error", latency_ms=latency_ms)
                 if attempt < max_retries - 1:
                     log_model_call(
                         LOGGER,
@@ -862,7 +833,6 @@ class InferenceClient:
 
             except APIError as e:
                 latency_ms = (time.perf_counter() - start) * 1000
-                self._finish_telemetry_attempt(telemetry_document, status="error", latency_ms=latency_ms)
                 status = getattr(e, "status_code", None)
                 if status in (401, 403):
                     self._bump_metric("requests_error", 1)
@@ -934,7 +904,6 @@ class InferenceClient:
 
             except Exception as exc:
                 latency_ms = (time.perf_counter() - start) * 1000
-                self._finish_telemetry_attempt(telemetry_document, status="error", latency_ms=latency_ms)
                 self._bump_metric("requests_error", 1)
                 log_model_call(
                     LOGGER,

tests/role_policy_expectations.py

@@ -68,7 +68,6 @@ EXPECTED_ROLE_POLICIES = {
     "/api/analytics/class-insights": TEACHER_ADMIN,
     "/api/analytics/refresh-cache": ADMIN_ONLY,
     "/api/testing/reset-data": ALL_ROLES,
-    "/api/hf/monitoring": ADMIN_ONLY,
     "/api/dev/generate-mock-data": ADMIN_ONLY,
     "/api/analytics/config": TEACHER_ADMIN,
     "/api/analytics/imported-class-overview": TEACHER_ADMIN,
@@ -153,8 +152,6 @@ EXPECTED_REGISTERED_ROUTE_METHODS = {
     "/api/try-it-yourself/complete-session": frozenset({"POST"}),
     "/api/try-it-yourself/generate-round": frozenset({"POST"}),
     "/api/try-it-yourself/shadow-retry": frozenset({"POST"}),
-    "/api/admin/ai-monitoring/summary": frozenset({"GET"}),
-    "/api/admin/ai-monitoring/refresh": frozenset({"POST"}),
     "/api/analytics/class/{class_id}": frozenset({"GET"}),
     "/api/analytics/class/{class_id}/students": frozenset({"GET"}),
     "/api/analytics/class/{class_id}/topics": frozenset({"GET"}),
@@ -212,7 +209,6 @@ EXPECTED_REGISTERED_ROUTE_METHODS = {
     "/api/tasks/{task_id}": frozenset({"GET"}),
     "/api/tasks": frozenset({"GET"}),
     "/api/tasks/{task_id}/cancel": frozenset({"POST"}),
-    "/api/hf/monitoring": frozenset({"GET"}),
     "/api/quiz/topics": frozenset({"GET"}),
     "/api/quiz/student-competency": frozenset({"POST"}),
     "/api/calculator/evaluate": frozenset({"POST"}),
@@ -293,8 +289,6 @@ HANDLER_GUARDED_ROUTE_EXCEPTIONS = {
     ("POST", "/api/admin/audit-log"): "admin/teacher role check",
     ("GET", "/api/admin/reingest-status"): "admin role check",
     ("GET", "/api/admin/dashboard-analytics"): "admin role check",
-    ("GET", "/api/admin/ai-monitoring/summary"): "admin role check",
-    ("POST", "/api/admin/ai-monitoring/refresh"): "admin role check",
     ("GET", "/api/quiz-battle/results"): "teacher/admin role check",
     ("POST", "/api/teacher-materials/{moduleId}/generate-quiz"): "teacher/admin role check",
     ("POST", "/api/class-records/intervention-plan"): "teacher/admin role check",

tests/test_ai_monitoring_contract.py

@@ -1,75 +0,0 @@
-from datetime import datetime, timezone
-from unittest.mock import Mock
-from zoneinfo import ZoneInfo
-
-from routes import ai_monitoring
-from services.inference_client import InferenceClient
-
-
-class FakeSnapshot:
-    def __init__(self, payload):
-        self.payload = payload
-
-    def to_dict(self):
-        return self.payload
-
-
-def test_daily_telemetry_uses_manila_days_and_documented_denominators(monkeypatch):
-    manila = ZoneInfo("Asia/Manila")
-    now = datetime(2025, 2, 1, 0, 0, tzinfo=manila)
-    docs = [
-        FakeSnapshot({"timestamp": datetime(2025, 1, 31, 15, 59, tzinfo=timezone.utc), "status": "success", "latencyMs": 100}),
-        FakeSnapshot({"timestamp": datetime(2025, 1, 31, 16, 0, tzinfo=timezone.utc), "status": "error", "latencyMs": 900}),
-        FakeSnapshot({"timestamp": datetime(2025, 1, 31, 17, 0, tzinfo=timezone.utc), "status": "success", "latencyMs": 300}),
-    ]
-    collection = Mock()
-    collection.where.return_value.where.return_value.stream.return_value = docs
-    firestore = Mock()
-    firestore.collection.return_value = collection
-    monkeypatch.setattr(ai_monitoring, "_get_firestore_client", lambda: firestore)
-    monkeypatch.setattr(ai_monitoring, "_now", lambda: now)
-
-    telemetry = ai_monitoring._aggregate_telemetry()
-
-    recent_days = [day for day in telemetry["dailyMetrics"] if day["date"] in {"2025-01-31", "2025-02-01"}]
-    assert recent_days == [
-        {"date": "2025-01-31", "totalAttempts": 1, "successfulAttempts": 1, "completedRequests": 1, "averageLatencyMs": 100.0, "successRate": 100.0},
-        {"date": "2025-02-01", "totalAttempts": 2, "successfulAttempts": 1, "completedRequests": 1, "averageLatencyMs": 300.0, "successRate": 50.0},
-    ]
-    assert telemetry["totalAttempts"] == 3
-    assert telemetry["successfulAttempts"] == 2
-    assert telemetry["completedRequests"] == 2
-    assert telemetry["averageLatencyMs"] == 200.0
-    assert telemetry["successRate"] == 66.7
-
-
-def test_daily_telemetry_returns_empty_metrics_without_firestore(monkeypatch):
-    monkeypatch.setattr(ai_monitoring, "_get_firestore_client", lambda: None)
-    telemetry = ai_monitoring._aggregate_telemetry()
-
-    assert telemetry["totalAttempts"] == 0
-    assert telemetry["successfulAttempts"] == 0
-    assert telemetry["completedRequests"] == 0
-    assert telemetry["averageLatencyMs"] is None
-    assert telemetry["successRate"] is None
-    assert telemetry["dailyMetrics"]
-    assert all(day["totalAttempts"] == 0 for day in telemetry["dailyMetrics"])
-
-
-def test_generation_attempt_collector_persists_pending_then_completed_status():
-    document = Mock()
-    firestore = Mock()
-    firestore.collection.return_value.add.return_value = (None, document)
-    client = InferenceClient(firestore_client=firestore)
-
-    telemetry_document = client._record_attempt(
-        task_type="chat", provider="deepseek", route="deepseek", fallback_depth=0
-    )
-    client._finish_telemetry_attempt(telemetry_document, status="success", latency_ms=250.456)
-
-    firestore.collection.assert_any_call("ai_usage_logs")
-    firestore.collection.return_value.add.assert_called_once()
-    event = firestore.collection.return_value.add.call_args.args[0]
-    assert event["status"] == "pending"
-    assert event["latencyMs"] is None
-    document.update.assert_called_once_with({"status": "success", "latencyMs": 250.46})

tests/test_ai_monitoring_telemetry.py

@@ -1,28 +0,0 @@
-from routes.ai_monitoring import COST_TRACKING_NOTE, _aggregate_summary
-
-
-def test_monitoring_summary_does_not_expose_rejected_top_level_utc_telemetry():
-    summary = _aggregate_summary()["summary"]
-
-    rejected_fields = {"dailyQuestionCount", "averageLatencyMs", "successRate"}
-    assert rejected_fields.isdisjoint(summary)
-
-
-def test_monitoring_summary_reports_measured_requests_and_null_cost_figures():
-    telemetry = {"totalAttempts": 10, "requestsByTaskType": {"quiz_generation": 3, "chat": 7}}
-
-    aggregated = _aggregate_summary(telemetry)
-    summary = aggregated["summary"]
-
-    assert [f["featureId"] for f in aggregated["features"]] == ["chat", "quiz_generation"]
-    chat = aggregated["features"][0]
-    assert chat["featureName"] == "AI Chat Tutor"
-    assert chat["totalRequests"] == 7
-    assert chat["requestShare"] == 70.0
-    assert chat["isMostActive"] is True
-    assert chat["monthlyCost"] is None and chat["cacheHitRate"] is None
-    assert summary["totalUsage"] == 10
-    assert summary["monthlyCost"] is None
-    assert summary["costBreakdown"] is None
-    assert summary["cacheHitRate"] is None
-    assert summary["costTrackingNote"] == COST_TRACKING_NOTE

tests/test_api.py

@@ -897,19 +897,6 @@ class TestQuizGeneration:
         assert "You are asking too fast, please wait a moment" in limited.json()["detail"]
 
 
-def test_ai_monitoring_summary_exposes_nested_telemetry_without_top_level_counters():
-    from routes import ai_monitoring
-
-    summary = ai_monitoring.get_monitoring_summary(_admin=object())
-
-    assert "telemetry" in summary
-    assert "dailyQuestions" not in summary
-    assert "averageLatencyMs" not in summary
-    assert "successRate" not in summary
-    assert "features" in summary
-    assert "pricingMeta" in summary
-
-
 class TestClassRecordImportMapping:
     def test_sanitize_column_mapping_drops_none_and_unknown_fields(self):
         raw_mapping = {

tests/test_hf_monitoring_routes.py

@@ -1,148 +0,0 @@
-"""
-Route-level tests for /api/hf/monitoring endpoint.
-Updated for DeepSeek AI monitoring.
-"""
-
-import os
-from unittest.mock import MagicMock, Mock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-
-import main as main_module
-from main import app
-
-main_module._firebase_ready = True
-main_module._init_firebase_admin = lambda: None
-main_module.firebase_firestore = None
-if getattr(main_module, "firebase_auth", None) is None:
-    main_module.firebase_auth = MagicMock()
-main_module.firebase_auth.verify_id_token = MagicMock(return_value={
-    "uid": "test-teacher-uid",
-    "email": "teacher@example.com", 
-    "role": "teacher",
-})
-
-admin_client = TestClient(app, headers={"Authorization": "Bearer admin-token"})
-
-EXPECTED_MONITORING_FIELDS = {
-    "modelId", "modelStatus", "avgResponseTimeMs",
-    "embeddingModelId", "embeddingModelStatus",
-    "inferenceBalance", "totalPeriodCost",
-    "hubApiCallsUsed", "hubApiCallsLimit",
-    "zeroGpuMinutesUsed", "zeroGpuMinutesLimit",
-    "publicStorageUsedTB", "publicStorageLimitTB",
-    "lastChecked", "periodStart", "periodEnd",
-    "activeProfile", "runtimeOverridesActive", "resolvedModels",
-    "provider", "apiBaseUrl",
-}
-
-EXPECTED_FIELDS_AFTER_DS_REPLACEMENT = EXPECTED_MONITORING_FIELDS
-
-
-@pytest.fixture(autouse=True)
-def _mock_env():
-    with patch.dict(os.environ, {"DEEPSEEK_API_KEY": "test-ds-monitoring-key"}):
-        yield
-
-
-# ─── Auth Enforcement ────────────────────────────────────────
-
-
-class TestMonitoringAuth:
-    def test_rejects_bad_token(self):
-        main_module.firebase_auth.verify_id_token = MagicMock(side_effect=Exception("bad"))
-        c = TestClient(app, headers={"Authorization": "Bearer bad-token"})
-        response = c.get("/api/hf/monitoring")
-        main_module.firebase_auth.verify_id_token = MagicMock(return_value={
-            "uid": "admin-uid", "email": "admin@example.com", "role": "admin",
-        })
-        assert response.status_code in {401, 403}
-
-
-# ─── Response Shape ───────────────────────────────────────────
-
-
-class TestMonitoringResponseShape:
-    @patch("main.time.time")
-    def test_success_response_contains_all_expected_fields(self, mock_time):
-        mock_time.return_value = 1000.0
-
-        response = admin_client.get("/api/hf/monitoring")
-        assert response.status_code == 200
-        data = response.json()
-        assert data["success"] is True
-        payload = data["data"]
-        for field in EXPECTED_FIELDS_AFTER_DS_REPLACEMENT:
-            assert field in payload, f"Missing field: {field}"
-
-    @patch("main.time.time")
-    @patch("services.ai_client.get_deepseek_client")
-    def test_all_probes_fail_gracefully(self, mock_ds_client_fn, mock_time):
-        mock_time.return_value = 1000.0
-        mock_client = MagicMock()
-        mock_client.chat.completions.create.side_effect = Exception("network down")
-        mock_ds_client_fn.return_value = mock_client
-
-        response = admin_client.get("/api/hf/monitoring")
-        assert response.status_code == 200
-        data = response.json()
-        assert data["success"] is True
-
-
-# ─── Response Values ──────────────────────────────────────────
-
-
-class TestMonitoringResponseValues:
-    @patch("services.ai_client.get_deepseek_client")
-    @patch("main.time.time")
-    def test_model_status_is_degraded_when_probe_fails(self, mock_time, mock_ds_client_fn):
-        mock_time.return_value = 1000.0
-        mock_client = MagicMock()
-        mock_client.chat.completions.create.side_effect = Exception("probe down")
-        mock_ds_client_fn.return_value = mock_client
-
-        response = admin_client.get("/api/hf/monitoring")
-        data = response.json()
-        assert data["success"] is True
-        assert data["data"]["modelStatus"] == "Degraded"
-
-    @patch("main.time.time")
-    def test_embedding_model_id_is_returned(self, mock_time):
-        mock_time.return_value = 1000.0
-
-        response = admin_client.get("/api/hf/monitoring")
-        data = response.json()
-        assert data["success"] is True
-        assert "bge-small" in data["data"]["embeddingModelId"].lower()
-
-    @patch("main.time.time")
-    def test_resolved_models_contains_task_keys(self, mock_time):
-        mock_time.return_value = 1000.0
-
-        response = admin_client.get("/api/hf/monitoring")
-        data = response.json()
-        resolved = data["data"].get("resolvedModels", {})
-        expected_tasks = {"chat", "rag_lesson", "rag_problem", "quiz_generation"}
-        for task in expected_tasks:
-            assert task in resolved, f"Missing task: {task}"
-            assert isinstance(resolved[task], str) and len(resolved[task]) > 0
-
-    @patch("main.time.time")
-    def test_active_profile_returned(self, mock_time):
-        mock_time.return_value = 1000.0
-
-        response = admin_client.get("/api/hf/monitoring")
-        data = response.json()
-        assert data["success"] is True
-        assert data["data"]["activeProfile"] in {"dev", "budget", "prod", ""}
-
-    @patch("main.time.time")
-    def test_provider_and_api_base_url_present(self, mock_time):
-        mock_time.return_value = 1000.0
-
-        response = admin_client.get("/api/hf/monitoring")
-        data = response.json()
-        assert data["success"] is True
-        assert data["data"]["provider"] == "deepseek"
-        assert "api.deepseek.com" in data["data"]["apiBaseUrl"]