deploy: backend from aae52f5

main.py

@@ -3525,7 +3525,9 @@ Respond with ONLY a JSON object (no markdown, no explanation outside the JSON):
         json_start = raw.find("{")
         json_end = raw.rfind("}") + 1
         if json_start >= 0 and json_end > json_start:
-            parsed = json.loads(raw[json_start:json_end])
+            parsed = loads_jsonish(raw[json_start:json_end])
+            if not isinstance(parsed, dict):
+                raise ValueError("Could not parse judge response")
         else:
             logger.warning(f"LLM judge returned non-JSON: {raw[:200]}")
             return {"correct": False, "issues": ["Could not parse judge response"], "confidence": 0.0}
@@ -9135,7 +9137,7 @@ TEXT:
                     json_end = topic_text.rfind("}") + 1
                     topic_payload: Dict[str, Any] = {}
                     if json_start >= 0 and json_end > json_start:
-                        topic_payload = json.loads(topic_text[json_start:json_end])
+                        topic_payload = loads_jsonish(topic_text[json_start:json_end]) or {}
 
                     for idx, topic in enumerate((topic_payload.get("topics") or [])[:10]):
                         title = str(topic.get("title", "")).strip()
@@ -10139,7 +10141,7 @@ def _parse_lesson_plan_json(raw: str) -> Dict[str, Any]:
     end = cleaned.rfind("}") + 1
     if start >= 0 and end > start:
         try:
-            parsed = json.loads(cleaned[start:end])
+            parsed = loads_jsonish(cleaned[start:end])
             if isinstance(parsed, dict):
                 return parsed
         except Exception:
@@ -11706,7 +11708,7 @@ def _validate_quiz_questions(
                     return []
                 if text.startswith("[") and text.endswith("]"):
                     try:
-                        parsed = json.loads(text)
+                        parsed = loads_jsonish(text)
                         if isinstance(parsed, list):
                             return [str(item).strip() for item in parsed if str(item).strip()]
                     except Exception:
@@ -13890,10 +13892,12 @@ Return ONLY this exact JSON (no other text):
         import re
         json_match = re.search(r'\{.*\}', response, re.DOTALL)
         if json_match:
-            lesson_data = json.loads(json_match.group())
+            lesson_data = loads_jsonish(json_match.group())
         else:
-            lesson_data = json.loads(response)
-        
+            lesson_data = loads_jsonish(response)
+        if lesson_data is None:
+            raise ValueError("Could not parse lesson JSON from model response")
+
         return DiagnosticLessonResponse(**sanitize_tree(lesson_data))
     except Exception as e:
         logger.error(f"Diagnostic lesson generation error: {e}")
@@ -14306,10 +14310,12 @@ Return ONLY this strict JSON array:
         import re
         json_match = re.search(r'\[.*\]', items_json, re.DOTALL)
         if json_match:
-            raw_items = json.loads(json_match.group())
+            raw_items = loads_jsonish(json_match.group())
         else:
-            raw_items = json.loads(items_json) if items_json.strip().startswith('[') else []
-        
+            raw_items = loads_jsonish(items_json) if items_json.strip().startswith('[') else []
+        if raw_items is None:
+            raise ValueError("Could not parse quiz items JSON from model response")
+
         items: List[AdaptiveQuizItem] = []
         for i, qi in enumerate(raw_items[:count]):
             qi = sanitize_tree(qi) if isinstance(qi, dict) else qi
@@ -14513,9 +14519,11 @@ Return as JSON with fields: topic, sections (array of title/content), suggested_
             # Extract JSON from response
             json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
             if json_match:
-                lesson_data = json.loads(json_match.group())
+                lesson_data = loads_jsonish(json_match.group())
             else:
-                lesson_data = json.loads(response_text)
+                lesson_data = loads_jsonish(response_text)
+            if lesson_data is None:
+                raise json.JSONDecodeError("Unparseable lesson JSON", response_text, 0)
 
             lesson_data = sanitize_tree(lesson_data)
             return PersonalizedLessonResponse(

rag/pdf_ingestion.py

@@ -24,6 +24,7 @@ import pypdf
 
 from rag.firebase_storage_loader import _init_firebase_storage
 from services.ai_client import complete_text, get_anthropic_client, CHAT_MODEL
+from services.llm_json import loads_jsonish
 
 logger = logging.getLogger(__name__)
 
@@ -96,7 +97,7 @@ Return a JSON array only, no extra text."""
             json_output=True,
             timeout=120.0,
         )
-        questions = json.loads(raw_response)
+        questions = loads_jsonish(raw_response)
         return questions if isinstance(questions, list) else []
     except json.JSONDecodeError as e:
         logger.error(f"Failed to parse Claude response as JSON for chunk {chunk_id}: {e}")

rag/teacher_module_generator.py

@@ -6,6 +6,8 @@ import logging
 import uuid
 from datetime import datetime
 
+from services.llm_json import loads_jsonish
+
 logger = logging.getLogger(__name__)
 
 class ExampleItem(BaseModel):
@@ -95,19 +97,15 @@ def _parse_module_json(raw: str) -> Optional[Dict[str, Any]]:
     cleaned = re.sub(r"<think>[\s\S]*?</think>", "", cleaned, flags=re.IGNORECASE)
     cleaned = cleaned.strip()
 
-    try:
-        return json.loads(cleaned)
-    except json.JSONDecodeError:
-        # Try to find a JSON object in the string
-        try:
-            start_idx = cleaned.find('{')
-            end_idx = cleaned.rfind('}')
-            if start_idx != -1 and end_idx != -1 and end_idx >= start_idx:
-                json_str = cleaned[start_idx:end_idx + 1]
-                return json.loads(json_str)
-        except Exception:
-            pass
-        return None
+    parsed = loads_jsonish(cleaned)
+    if parsed is not None:
+        return parsed
+    # Try to find a JSON object in the string
+    start_idx = cleaned.find('{')
+    end_idx = cleaned.rfind('}')
+    if start_idx != -1 and end_idx != -1 and end_idx >= start_idx:
+        return loads_jsonish(cleaned[start_idx:end_idx + 1])
+    return None
 
 async def generate_teacher_module(
     course_material_text: str,

routes/class_records_router.py

@@ -20,6 +20,7 @@ from fastapi import APIRouter, Form, HTTPException, Query, Request, UploadFile,
 from fastapi.responses import StreamingResponse
 
 from services.inference_client import call_hf_chat_async
+from services.llm_json import loads_jsonish
 from services.wri_service import compute_wri
 
 logger = logging.getLogger("mathpulse.class_records")
@@ -725,8 +726,6 @@ async def get_upload_students(
 
 @router.post("/class-records/{uploadId}/ai-report")
 async def generate_ai_class_report(request: Request, uploadId: str):
-    import json as _json
-
     user: Any = getattr(request.state, "user", None)
     if user is None:
         raise HTTPException(status_code=401, detail="Authentication required")
@@ -790,7 +789,7 @@ async def generate_ai_class_report(request: Request, uploadId: str):
             max_tokens=400, task_type="class_report"
         )
         try:
-            parsed = _json.loads(response_text)
+            parsed = loads_jsonish(response_text)
             recommendations = parsed.get("recommendations", [])
         except Exception:
             recommendations = [r.strip() for r in response_text.split('\n') if len(r.strip()) > 20][:2]

routes/diagnostic.py

@@ -21,13 +21,17 @@ from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
 from services.ai_client import complete_text
-from services.llm_json import LLMJsonError, extract_json_value, extract_dict_list
+from services.llm_json import LLMJsonError, extract_json_value, extract_dict_list, loads_jsonish
 from rag.curriculum_rag import retrieve_curriculum_context
 import firebase_admin
 from firebase_admin import firestore as fs
 
 logger = logging.getLogger("mathpulse.diagnostic")
 
+# Bump when cached AI analyses must regenerate (e.g. they were saved with corrupted LaTeX).
+_ANALYSIS_CACHE_VERSION = "2026-10-latex"
+_ANALYSIS_CACHE_VERSION_FIELD = "cacheVersion"
+
 router = APIRouter(prefix="/api/diagnostic", tags=["diagnostic"])
 
 # In-memory fallback session store (used if Firestore is unavailable)
@@ -904,8 +908,10 @@ async def analyze_diagnostic(request: DiagnosticAnalysisRequest, req: Request):
     # Check server-side cache first
     cache_ref = firestore_client.collection("diagnosticResults").document(request.user_id).collection("cache").document("analysis")
     cache_doc = cache_ref.get()
-    if cache_doc.exists:
-        return DiagnosticAnalysisResponse(success=True, analysis=cache_doc.to_dict())
+    cached_analysis = (cache_doc.to_dict() or {}) if cache_doc.exists else {}
+    # A version mismatch is a cache miss, so analyses cached before the LaTeX-repair fix regenerate.
+    if cached_analysis.pop(_ANALYSIS_CACHE_VERSION_FIELD, None) == _ANALYSIS_CACHE_VERSION:
+        return DiagnosticAnalysisResponse(success=True, analysis=cached_analysis)
 
     results_data = results_doc.to_dict() or {}
     responses = results_data.get("responses", [])
@@ -1011,7 +1017,9 @@ Return ONLY valid JSON, no markdown fences."""
                 cleaned = cleaned[:-3]
             cleaned = cleaned.strip()
 
-        analysis = json.loads(cleaned)
+        analysis = loads_jsonish(cleaned)
+        if analysis is None:
+            raise json.JSONDecodeError("Unparseable analysis JSON", cleaned, 0)
     except json.JSONDecodeError as e:
         logger.warning(f"[diagnostic/analyze] AI JSON parse failed: {e}, using fallback")
         analysis = _build_fallback_analysis(responses, domain_scores, risk_profile)
@@ -1021,7 +1029,7 @@ Return ONLY valid JSON, no markdown fences."""
 
     # Cache the analysis in Firestore for future requests
     try:
-        cache_ref.set(analysis)
+        cache_ref.set({**analysis, _ANALYSIS_CACHE_VERSION_FIELD: _ANALYSIS_CACHE_VERSION})
     except Exception as e:
         logger.warning(f"[diagnostic/analyze] Failed to cache analysis: {e}")
 

routes/rag_routes.py

@@ -380,7 +380,7 @@ def _ensure_7_sections(lesson_data: dict, lesson_title: str, chunks: Optional[Li
 # ─── Lesson pipeline: per-student cache, in-flight dedupe, streamed generation ─
 
 # Bump when build_lesson_prompt or the richness rules change: new keys -> lessons regenerate on next open.
-LESSON_PROMPT_VERSION = "2026-10-v2"
+LESSON_PROMPT_VERSION = "2026-10-v3"
 _LESSON_MEMORY_MAX_ENTRIES = 256
 _RETRIEVAL_MEMORY_MAX_ENTRIES = 256
 _LESSON_GENERATION_CAP_SEC = 300.0

routes/teacher_materials.py

@@ -26,7 +26,7 @@ from fastapi import File, Form, UploadFile
 from pydantic import BaseModel, Field
 
 from services.ai_client import CHAT_MODEL
-from services.llm_json import extract_dict_list, extract_json_value
+from services.llm_json import extract_dict_list, extract_json_value, loads_jsonish
 
 logger = logging.getLogger("mathpulse.teacher_materials")
 
@@ -338,7 +338,10 @@ Respond with JSON only, no markdown or extra text."""
         if json_start < 0 or json_end <= json_start:
             raise ValueError(f"Could not find JSON in AI response: {raw_response[:200]}")
 
-        module_json = json.loads(raw_response[json_start:json_end])
+        module_span = raw_response[json_start:json_end]
+        module_json = loads_jsonish(module_span)
+        if module_json is None:
+            raise json.JSONDecodeError("Unparseable module JSON", module_span, 0)
         return module_json
 
     except json.JSONDecodeError as e:

services/ai_client.py

@@ -18,6 +18,8 @@ from anthropic import (
 from anthropic.lib.streaming import BetaMessageStreamManager
 from anthropic.types.beta import BetaMessage
 
+from .llm_json import normalize_candidate
+
 try:
     from dotenv import load_dotenv
     for _env_path in [
@@ -213,11 +215,13 @@ def outer_json(text: str) -> Optional[str]:
     if not starts or end < min(starts):
         return None
     candidate = text[min(starts) : end + 1]
+    # Return the repaired span so the caller's json.loads keeps single-backslash LaTeX (\times, \sqrt) intact.
+    repaired = normalize_candidate(candidate)
     try:
-        json.loads(candidate)
+        json.loads(repaired)
     except json.JSONDecodeError:
         return None
-    return candidate
+    return repaired
 
 
 def reply_text(message: BetaMessage, *, json_output: bool = False) -> str:

services/class_analytics_engine.py

@@ -481,7 +481,8 @@ Be specific to Filipino K-12 DepEd context. If data is limited, acknowledge it a
                 json_output=True,
                 timeout=60.0,
             )
-            parsed = json.loads(content or "{}")
+            from services.llm_json import loads_jsonish
+            parsed = loads_jsonish(content or "{}")
 
             return ClassInsights(
                 class_id=class_id,

services/inference_client.py

@@ -52,6 +52,7 @@ from .ai_client import (
     outer_json,
     reply_text,
 )
+from .llm_json import loads_jsonish
 from .logging_utils import configure_structured_logging, log_model_call
 
 LOGGER = configure_structured_logging("mathpulse.inference")
@@ -956,7 +957,7 @@ def parse_json_response(text: Optional[str]) -> Optional[dict]:
     if not text:
         return None
     candidate = outer_json(text)
-    parsed = json.loads(candidate) if candidate else None
+    parsed = loads_jsonish(candidate) if candidate else None
     if not isinstance(parsed, dict):
         LOGGER.warning("[CLAUDE] Failed to parse JSON response")
         return None

services/intervention_engine.py

@@ -431,7 +431,8 @@ Return as JSON:
                 json_output=True,
                 timeout=60.0,
             )
-            insights = json.loads(content or "{}")
+            from services.llm_json import loads_jsonish
+            insights = loads_jsonish(content or "{}")
             return {k: to_plain_text(v, strip_bullets=False) if isinstance(v, str) else v for k, v in insights.items()}
         except Exception as e:
             logger.warning(f"Claude insights failed: {e}")
@@ -504,7 +505,8 @@ Return ONLY valid JSON:
                 json_output=True,
                 timeout=60.0,
             )
-            parsed = sanitize_tree(json.loads(content or "{}"))
+            from services.llm_json import loads_jsonish
+            parsed = sanitize_tree(loads_jsonish(content or "{}"))
 
             steps = []
             for s in parsed.get("steps", []):
@@ -586,7 +588,8 @@ Return as a JSON array of strings. Each recommendation max 25 words. Be specific
                 json_output=True,
                 timeout=60.0,
             )
-            parsed = json.loads(content or "[]")
+            from services.llm_json import loads_jsonish
+            parsed = loads_jsonish(content or "[]")
             if isinstance(parsed, dict):
                 parsed = parsed.get("recommendations", parsed.get("actions", []))
             if isinstance(parsed, list):

services/llm_json.py

@@ -22,6 +22,7 @@ __all__ = [
     "strip_reasoning",
     "extract_json_blocks",
     "normalize_candidate",
+    "repair_latex_backslashes",
     "loads_jsonish",
     "extract_json_value",
     "extract_json_object",
@@ -88,6 +89,41 @@ def extract_json_blocks(text: str) -> List[str]:
     return blocks
 
 
+# TeX commands that start with ``n``; any other ``\n<letters>`` is a newline
+# followed by prose ("\nThe next step").
+TEX_N_COMMANDS = frozenset(
+    {
+        "nabla", "natural", "nearrow", "neg", "neq", "newline", "ngeq", "ngtr",
+        "ni", "nleq", "nless", "nmid", "not", "notin", "nparallel", "nsubseteq",
+        "nsupseteq", "nu", "nwarrow",
+    }
+)
+_BACKSLASH_ESCAPE_RE = re.compile(r"\\(u[0-9a-fA-F]{4}|.)([A-Za-z]*)", re.DOTALL)
+
+
+def _repair_backslash(match: "re.Match[str]") -> str:
+    escape, letters = match.group(1), match.group(2)
+    whole = match.group(0)
+    if escape in ('"', "\\", "/") or len(escape) == 5:
+        return whole
+    if escape == "n":
+        return "\\" + whole if escape + letters in TEX_N_COMMANDS else whole
+    if escape in "bfrt" and not letters:
+        return whole
+    # A TeX command (\times, \text, \frac, \beta, \right) or an escape JSON
+    # rejects (\sqrt, \cdot): keep the backslash literal.
+    return "\\" + whole
+
+
+def repair_latex_backslashes(candidate: str) -> str:
+    r"""Double single backslashes that start LaTeX commands inside JSON text.
+
+    Models write ``\times`` where JSON needs ``\\times``; ``json.loads`` would
+    decode the ``\t`` as a TAB and the lesson would show "imes".
+    """
+    return _BACKSLASH_ESCAPE_RE.sub(_repair_backslash, candidate)
+
+
 def normalize_candidate(candidate: str) -> str:
     """Repair the defects models introduce into otherwise valid JSON."""
     normalized = candidate.strip().lstrip("\ufeff")
@@ -100,6 +136,7 @@ def normalize_candidate(candidate: str) -> str:
         .replace("\u2018", "'")
         .replace("\u2019", "'")
     )
+    normalized = repair_latex_backslashes(normalized)
     # Drop trailing commas before an object/array closer.
     return re.sub(r",(\s*[}\]])", r"\1", normalized)
 

services/llm_text.py

@@ -21,6 +21,8 @@ from __future__ import annotations
 import re
 from typing import Any, Callable, Iterable, Mapping, Optional
 
+from services.llm_json import TEX_N_COMMANDS
+
 __all__ = [
     "clean_llm_text",
     "to_plain_text",
@@ -111,7 +113,14 @@ def _outside_math(text: str, fn: Callable[[str], str]) -> str:
 
 def _fix_escapes(segment: str) -> str:
     # JSON-escaped newlines/tabs that survived parsing as literal text.
-    segment = segment.replace("\\r\\n", "\n").replace("\\n", "\n").replace("\\t", "  ")
+    # A letter run after \n or \t can be a TeX command (\neq, \times): keep those.
+    segment = segment.replace("\\r\\n", "\n")
+    segment = re.sub(
+        r"\\n([A-Za-z]*)",
+        lambda m: m.group(0) if "n" + m.group(1) in TEX_N_COMMANDS else "\n" + m.group(1),
+        segment,
+    )
+    segment = re.sub(r"\\t(?![A-Za-z])", "  ", segment)
     # Double-escaped TeX from over-escaped JSON strings: \\frac → \frac
     segment = re.sub(r"\\\\(?=[A-Za-z])", r"\\", segment)
     # Escaped dollars in front of TeX commands block the math delimiter.

services/student_intelligence_pipeline.py

@@ -512,7 +512,8 @@ Generate JSON:
                 json_output=True,
                 timeout=60.0,
             )
-            parsed = json.loads(content or "{}")
+            from services.llm_json import loads_jsonish
+            parsed = loads_jsonish(content or "{}")
             parsed["generated_at"] = _now_iso()
             parsed["based_on_wri_status"] = profile.get("risk_status", "pending_assessment")
             return parsed

services/variance_engine.py

@@ -12,6 +12,7 @@ import random
 from typing import List, Dict
 
 from services.ai_client import complete_text, CHAT_MODEL
+from services.llm_json import loads_jsonish
 
 logger = logging.getLogger("mathpulse.variance_engine")
 from services.question_bank_service import get_cached_session, cache_session_questions
@@ -91,7 +92,7 @@ Do NOT change "topic", "difficulty", "grade_level", or "source_chunk_id"."""
             json_output=True,
             timeout=120.0,
         )
-        varied_questions = json.loads(content)
+        varied_questions = loads_jsonish(content)
 
         if not isinstance(varied_questions, list) or len(varied_questions) != len(questions):
             raise ValueError("Invalid response format from Claude")

tests/test_llm_json.py

@@ -140,3 +140,39 @@ class TestCollectDictObjects:
 
     def test_ignores_arrays(self) -> None:
         assert collect_dict_objects("[1, 2]") == []
+
+
+class TestLatexBackslashes:
+    """Models often emit single-backslash LaTeX inside JSON strings."""
+
+    @pytest.mark.parametrize(
+        "tex",
+        [
+            r"G = r \times d",
+            r"\text{Profit} = S - C",
+            r"\frac{1}{2}",
+            r"\beta + \rho",
+            r"x \neq 0",
+            r"\nabla f",
+            r"\left( x \right)",
+            r"\sqrt{x} \cdot y",
+            r"\underline{x} \le 3",
+        ],
+    )
+    def test_single_backslash_tex_survives(self, tex: str) -> None:
+        raw = '{"body": "Use $' + tex + '$ here."}'
+        assert extract_json_object(raw) == {"body": f"Use ${tex}$ here."}
+
+    def test_correctly_escaped_tex_is_unchanged(self) -> None:
+        raw = r'{"body": "$\\times$ and $\\frac{a}{b}$"}'
+        assert extract_json_object(raw) == {"body": r"$\times$ and $\frac{a}{b}$"}
+
+    def test_real_json_escapes_still_decode(self) -> None:
+        raw = r'{"body": "Line one\nThe next line\n\nSay \"hi\" ₱ a\/b \\ end"}'
+        assert extract_json_object(raw) == {
+            "body": 'Line one\nThe next line\n\nSay "hi" ₱ a/b \\ end'
+        }
+
+    def test_newline_before_prose_word_stays_newline(self) -> None:
+        raw = r'{"body": "Step 1\nNote that\nnext"}'
+        assert extract_json_object(raw) == {"body": "Step 1\nNote that\nnext"}

tests/test_llm_text.py

@@ -17,6 +17,13 @@ class TestCleanLlmText:
         raw = "Step 1\\nStep 2 uses \\(x^2\\) and \\[a = b\\]"
         assert clean_llm_text(raw) == "Step 1\nStep 2 uses $x^2$ and $$a = b$$"
 
+    def test_tex_commands_starting_with_n_t_r_survive(self):
+        raw = r"$G = r \times d$, $\text{Profit} = S - C$, $a \neq b$, $\nabla f$, $\theta \to \rho$"
+        assert clean_llm_text(raw) == raw
+
+    def test_literal_escapes_before_prose_still_decode(self):
+        assert clean_llm_text(r"Step 1\nThe next\n\nnext\t2") == "Step 1\nThe next\n\nnext  2"
+
     def test_double_escaped_tex_unescaped(self):
         assert clean_llm_text("Use $\\\\frac{1}{2}$") == "Use $\\frac{1}{2}$"
 

tests/test_parse_json_response.py

@@ -1,5 +1,7 @@
 """parse_json_response feeds weakness detection and the at-risk brief; a reply it can't read falls back silently."""
 
+import json
+
 import pytest
 
 from services.inference_client import parse_json_response
@@ -20,6 +22,20 @@ def test_recovers_the_json_object(reply: str) -> None:
     assert parse_json_response(reply) == FLAGGED
 
 
+def test_keeps_single_backslash_latex() -> None:
+    # \t, \f decode as control characters and \s, \c are invalid JSON escapes unless repaired.
+    reply = r'Result: {"a": "$\sqrt{x} \times 2 \frac{1}{2}$"}'
+    assert parse_json_response(reply) == {"a": r"$\sqrt{x} \times 2 \frac{1}{2}$"}
+
+
+def test_outer_json_returns_repaired_span() -> None:
+    from services.ai_client import outer_json
+
+    span = outer_json(r'text {"a": "$\sqrt{x} \times 2$"} end')
+    assert span is not None
+    assert json.loads(span) == {"a": r"$\sqrt{x} \times 2$"}
+
+
 @pytest.mark.parametrize(
     "reply",
     [