deploy: backend from b8e1988

main.py

@@ -350,6 +350,10 @@ CHAT_STREAM_CONTINUATION_TAIL_CHARS = max(
     80,
     int(os.getenv("CHAT_STREAM_CONTINUATION_TAIL_CHARS", "900")),
 )
+CHAT_RATE_LIMIT_REQUESTS = max(1, int(os.getenv("CHAT_RATE_LIMIT_REQUESTS", "60")))
+CHAT_RATE_LIMIT_WINDOW_SECONDS = max(1, int(os.getenv("CHAT_RATE_LIMIT_WINDOW_SECONDS", "60")))
+_chat_rate_limit_requests: Dict[str, List[float]] = defaultdict(list)
+_chat_rate_limit_lock = Lock()
 CHAT_STREAM_COMPLETION_MODE_DEFAULT = os.getenv(
     "CHAT_STREAM_COMPLETION_MODE_DEFAULT",
     "auto",
@@ -2421,6 +2425,27 @@ async def root():
 # ─── AI Chat Tutor ─────────────────────────────────────────────
 
 
+def _enforce_chat_rate_limit(http_request: Optional[Request]) -> None:
+    user = getattr(getattr(http_request, "state", None), "user", None)
+    client = getattr(http_request, "client", None)
+    user_key = getattr(user, "uid", None) or getattr(client, "host", None) or "anonymous"
+    now = time.monotonic()
+    cutoff = now - CHAT_RATE_LIMIT_WINDOW_SECONDS
+    with _chat_rate_limit_lock:
+        recent_requests = [
+            timestamp for timestamp in _chat_rate_limit_requests[user_key]
+            if timestamp > cutoff
+        ]
+        if len(recent_requests) >= CHAT_RATE_LIMIT_REQUESTS:
+            _chat_rate_limit_requests[user_key] = recent_requests
+            raise HTTPException(
+                status_code=429,
+                detail="You are asking too fast, please wait a moment",
+            )
+        recent_requests.append(now)
+        _chat_rate_limit_requests[user_key] = recent_requests
+
+
 MATH_TUTOR_SYSTEM_PROMPT = """You are Pulse, MathPulse AI's friendly math tutor for Filipino Senior High School
 students. You help students understand and solve problems in General Mathematics,
 Business Mathematics, Statistics & Probability, and Finite Mathematics, all aligned
@@ -2429,6 +2454,7 @@ with the DepEd Strengthened SHS Curriculum and SDO Navotas learning modules.
 YOUR BEHAVIOR RULES:
 1. PERSONALIZE every response. Address the student by first name occasionally.
 2. NEVER give direct answers to quiz or exam items — guide with hints and questions instead.
+   On a student's first response to a math problem, do not give the final answer: withhold the final numeric answer and ask a guiding question first. Do not state a solved value such as "x = -3" in that first response. Reveal and explain the answer only after the student has attempted the next step or explicitly asks to check their work.
 3. If the student is struggling on a critical gap topic, gently steer them back to
    prerequisite concepts before moving forward.
 4. Use the SDO Navotas step-by-step method for ALL solutions:
@@ -2709,13 +2735,14 @@ def _build_stream_continuation_prompt(original_question: str, expected_end_marke
 
 @app.post("/api/chat", response_model=ChatResponse)
 async def chat_tutor_endpoint(request: Request, chat_request: ChatRequest):
-    return await chat_tutor(chat_request)
+    return await chat_tutor(chat_request, request)
 
 
-async def chat_tutor(request: ChatRequest):
+async def chat_tutor(request: ChatRequest, http_request: Request = None):
     """AI Math Tutor powered by Hugging Face Inference routing."""
     _start_ms = int(time.monotonic() * 1000)
     try:
+        _enforce_chat_rate_limit(http_request)
         # ─── Context-Aware Intent Gate (before scope check) ──────
         # Load active state to determine if student is mid-session.
         # If so, skip scope check for short/vague replies.
@@ -2912,11 +2939,12 @@ async def _update_memory_after_response(
 
 @app.post("/api/chat/stream")
 async def chat_tutor_stream_endpoint(request: Request, chat_request: ChatRequest):
-    return await chat_tutor_stream(chat_request)
+    return await chat_tutor_stream(chat_request, request)
 
 
-async def chat_tutor_stream(request: ChatRequest):
+async def chat_tutor_stream(request: ChatRequest, http_request: Request = None):
     """SSE stream endpoint for AI Math Tutor chat responses."""
+    _enforce_chat_rate_limit(http_request)
     try:
         # ─── Context-Aware Intent Gate (before scope check) ──────
         _skip_scope_check = False
@@ -5333,6 +5361,23 @@ def _generate_temporary_password(length: int = 12) -> str:
             return candidate
 
 
+def _student_import_full_name(row: Dict[str, Any]) -> str:
+    return " ".join(
+        part for part in (str(row.get("firstName") or "").strip(), str(row.get("lastName") or "").strip()) if part
+    )
+
+
+def _duplicate_student_lrn_rows(rows: Sequence[Dict[str, Any]]) -> Dict[str, List[int]]:
+    row_numbers_by_lrn: Dict[str, List[int]] = {}
+    for row in rows:
+        # Normalize keys consistently with the import rejection gate: strip all
+        # whitespace and lowercase so variants of the same LRN always collide.
+        student_id = re.sub(r"\s+", "", str(row.get("studentId") or "")).lower()
+        if student_id:
+            row_numbers_by_lrn.setdefault(student_id, []).append(int(row.get("rowNumber") or 0))
+    return {student_id: row_numbers for student_id, row_numbers in row_numbers_by_lrn.items() if len(row_numbers) > 1}
+
+
 def _parse_provisioning_dataframe(df: Any) -> Dict[str, Any]:
     header_map: Dict[str, str] = {}
     for column in df.columns.tolist():
@@ -6049,7 +6094,7 @@ async def preview_student_account_import(
             email = str(row.get("email") or "").strip().lower()
             grade = str(row.get("grade") or "").strip() or effective_default_grade
             section = str(row.get("section") or "").strip() or effective_default_section
-            full_name = " ".join(part for part in [first_name, middle_name, last_name] if part).strip()
+            full_name = _student_import_full_name(row)
 
             issues: List[str] = []
             if not first_name:
@@ -6255,12 +6300,8 @@ async def commit_student_account_import(
             if str(row.get("status") or "") in {"valid", "move_confirmation_required"}
         ]
 
-        student_lrns = [
-            re.sub(r"\s+", "", str(row.get("studentId") or "")).lower()
-            for row in preview_rows
-            if str(row.get("studentId") or "").strip()
-        ]
-        duplicate_lrns = {lrn for lrn, count in Counter(student_lrns).items() if count > 1}
+        duplicate_lrn_rows = _duplicate_student_lrn_rows(preview_rows)
+        duplicate_lrns = set(duplicate_lrn_rows)
         has_existing_lrn = any(
             bool(row.get("duplicateLrnInFirestore"))
             and str(row.get("status") or "") != "move_confirmation_required"
@@ -11974,6 +12015,10 @@ Remember:
                 detail=f"Quiz generation returned {len(parsed_questions)} of {request.numQuestions} requested questions. Please try again.",
             )
 
+        parsed_questions = parsed_questions[:request.numQuestions]
+        for question_index, question in enumerate(parsed_questions):
+            question["topic"] = effective_topics[question_index % len(effective_topics)]
+
         topic_provenance_map: Dict[str, Dict[str, Optional[str]]] = {}
         for imported_topic in (imported_topics_payload.get("topics") or []):
             title = str(imported_topic.get("title") or "").strip()
@@ -12077,11 +12122,9 @@ Remember:
 @app.post("/api/quiz/preview", response_model=QuizResponse)
 async def preview_quiz(http_request: Request, request: QuizGenerationRequest):
     """
-    Generate a 3-question preview quiz for teachers to verify AI question
+    Generate a requested-count preview quiz for teachers to verify AI question
     quality before assigning a full quiz to students.
     """
-    # Override to produce only 3 questions
-    request.numQuestions = 3
     return await generate_quiz(http_request, request)
 
 

tests/test_api.py

@@ -855,6 +855,60 @@ class TestQuizGeneration:
         })
         assert response.status_code == 422
 
+    @patch("main.call_hf_chat")
+    def test_generate_quiz_returns_requested_count_for_selected_topic(self, mock_chat):
+        questions = [
+            {
+                "questionType": "identification",
+                "question": f"Linear equation question {index + 1}",
+                "correctAnswer": "x = -3",
+                "topic": "Algebra",
+            }
+            for index in range(5)
+        ]
+        mock_chat.return_value = json.dumps(questions)
+
+        response = client.post("/api/quiz/preview", json={
+            "topics": ["Linear Equations"],
+            "gradeLevel": "Grade 11",
+            "numQuestions": 5,
+        })
+
+        assert response.status_code == 200
+        generated = response.json()["questions"]
+        assert len(generated) == 5
+        assert all(question["topic"] == "Linear Equations" for question in generated)
+        prompt = mock_chat.call_args.args[0]
+        assert "Linear Equations" in str(prompt)
+
+    @patch("main.call_hf_chat")
+    def test_chat_rate_limit_returns_429_after_flood(self, mock_chat, monkeypatch):
+        mock_chat.return_value = "What is the first step?"
+        monkeypatch.setattr(main_module, "CHAT_RATE_LIMIT_REQUESTS", 2)
+        monkeypatch.setattr(main_module, "CHAT_RATE_LIMIT_WINDOW_SECONDS", 60)
+        main_module._chat_rate_limit_requests.clear()
+
+        payload = {"message": "How do I solve x + 2 = 5?", "history": []}
+        assert client.post("/api/chat", json=payload).status_code == 200
+        assert client.post("/api/chat", json=payload).status_code == 200
+        limited = client.post("/api/chat", json=payload)
+
+        assert limited.status_code == 429
+        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):
@@ -897,14 +951,16 @@ class TestClassRecordImportMapping:
                 "points": 1,
                 "explanation": "Slope = rise/run.",
             }
-            for index in range(3)
+            for index in range(5)
         ])
         mock_chat.return_value = quiz_json
         response = client.post("/api/quiz/preview", json={
             "topics": ["Algebra"],
             "gradeLevel": "Grade 11",
+            "numQuestions": 5,
         })
         assert response.status_code == 200
+        assert len(response.json()["questions"]) == 5
 
     @patch("main.call_hf_chat")
     def test_preview_quiz_rejects_partial_question_set(self, mock_chat):
@@ -926,6 +982,7 @@ class TestClassRecordImportMapping:
         response = client.post("/api/quiz/preview", json={
             "topics": ["Algebra"],
             "gradeLevel": "Grade 11",
+            "numQuestions": 3,
         })
 
         assert response.status_code == 502
@@ -950,6 +1007,7 @@ class TestClassRecordImportMapping:
             response = client.post("/api/quiz/preview", json={
                 "topics": ["Algebra"],
                 "gradeLevel": "Grade 11",
+                "numQuestions": 3,
             })
 
         assert response.status_code == 502

tests/test_chat_jev_socratic.py

@@ -74,6 +74,29 @@ async def test_conceptual_question_uses_normal_chat_generation(
     assert "Given → Formula → Substitute → Compute → Conclude" in system_prompt
 
 
+@pytest.mark.asyncio
+async def test_chat_system_prompt_requires_guidance_before_final_numeric_answer(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_messages: list[dict[str, str]] = []
+
+    async def route_intent(_message: str) -> dict[str, object]:
+        return {"choice": "conceptual_confusion", "confidence": 0.91}
+
+    async def capture_llm(messages: list[dict[str, str]], **_kwargs: object) -> str:
+        captured_messages.extend(messages)
+        return "What operation would isolate x first?"
+
+    monkeypatch.setattr(main, "route_student_intent", route_intent)
+    monkeypatch.setattr(main, "call_hf_chat_async", capture_llm)
+
+    await main.chat_tutor(main.ChatRequest(message="What is the answer to 3x+9=0?"))
+
+    system_prompt = captured_messages[0]["content"].lower()
+    assert "do not give the final answer" in system_prompt
+    assert "ask a guiding question first" in system_prompt
+
+
 @pytest.mark.asyncio
 async def test_jev_failure_fails_open_to_normal_chat_generation(
     monkeypatch: pytest.MonkeyPatch,

tests/test_student_account_import.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+import main
+
+
+def test_provisioning_uses_first_and_last_name_not_middle_initial():
+    parsed = main._parse_provisioning_dataframe(
+        pd.DataFrame(
+            [{"First Name": "Avery", "Middle Initial": "B", "Last Name": "Santos", "LRN": "123456789012"}]
+        )
+    )
+
+    row = parsed["rows"][0]
+    assert main._student_import_full_name(row) == "Avery Santos"
+
+
+def test_duplicate_lrns_report_source_rows_and_reject_entire_batch():
+    parsed = main._parse_provisioning_dataframe(
+        pd.DataFrame(
+            [
+                {"First Name": "Avery", "Last Name": "Santos", "LRN": "123456789012"},
+                {"First Name": "Blair", "Last Name": "Reyes", "LRN": "123456789012"},
+                {"First Name": "Casey", "Last Name": "Lim", "LRN": "210987654321"},
+            ]
+        )
+    )
+
+    assert main._duplicate_student_lrn_rows(parsed["rows"]) == {
+        "123456789012": [2, 3]
+    }