Update evo_inference.py

evo_inference.py

@@ -1,9 +1,10 @@
 """
-evo_inference.py — Step 8 (FLAN-optimized)
-- Generative path uses a FLAN-friendly prompt: Instruction / Context / Question / Answer
+evo_inference.py — FLAN-optimized + anti-echo
+- FLAN-friendly prompt with explicit bullet structure
 - Filters placeholder chunks
-- Cleans common prompt-echo lines
-- Keeps labeled [Generative] / [Extractive] outputs with safe fallback
+- Cleans prompt-echo lines
+- Anti-echo guard: if the model repeats the question or outputs too little, we fall back to Extractive
+- Labeled outputs: [Generative] / [Extractive]
 """
 
 from typing import List, Dict
@@ -13,28 +14,24 @@ from utils_lang import L, normalize_lang
 # Try to load your real Evo plugin first; else use the example; else None.
 _GENERATOR = None
 try:
-    from evo_plugin import load_model as _load_real   # your future file (optional)
+    from evo_plugin import load_model as _load_real
     _GENERATOR = _load_real()
 except Exception:
     try:
         from evo_plugin_example import load_model as _load_example
         _GENERATOR = _load_example()
     except Exception:
-        _GENERATOR = None  # no generator available
+        _GENERATOR = None
 
 MAX_SNIPPET_CHARS = 400
 
-
 def _snippet(text: str) -> str:
     text = " ".join(text.split())
     return text[:MAX_SNIPPET_CHARS] + ("..." if len(text) > MAX_SNIPPET_CHARS else "")
 
-
 def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
-    """Old safe mode: show top snippets + standard steps, now labeled."""
     if not hits:
         return "**[Extractive]**\n\n" + L(lang, "intro_err")
-
     bullets = [f"- {_snippet(h['text'])}" for h in hits[:4]]
     steps = {
         "en": [
@@ -56,7 +53,6 @@ def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
             "• Step 4: Gard referans/reso; swiv letan tretman.",
         ],
     }[normalize_lang(lang)]
-
     return (
         "**[Extractive]**\n\n"
         f"**{L(lang, 'intro_ok')}**\n\n"
@@ -65,71 +61,58 @@ def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
         f"**Suggested steps:**\n" + "\n".join(steps)
     )
 
-
 def _lang_name(code: str) -> str:
     return {"en": "English", "fr": "French", "mfe": "Kreol Morisien"}.get(code, "English")
 
-
 def _filter_hits(hits: List[Dict], keep: int = 6) -> List[Dict]:
-    """
-    Prefer non-placeholder chunks; if all are placeholders, return originals.
-    """
-    filtered = [
-        h for h in hits
-        if "placeholder" not in h["text"].lower() and "disclaimer" not in h["text"].lower()
-    ]
+    # Prefer non-placeholder chunks; if all are placeholders, return originals.
+    filtered = [h for h in hits if "placeholder" not in h["text"].lower() and "disclaimer" not in h["text"].lower()]
     if not filtered:
         filtered = hits
     return filtered[:keep]
 
-
 def _build_grounded_prompt(question: str, lang: str, hits: List[Dict]) -> str:
     """
     FLAN-style prompt:
-    Instruction: ...
-    Context:
-    1) ...
-    2) ...
+    Instruction: (clear constraints)
+    Context: 1) ... 2) ...
     Question: ...
-    Answer:
+    Answer:  - bullet  - bullet ...
     """
     lang = normalize_lang(lang)
     lang_readable = _lang_name(lang)
 
-    instruction = (
-        "You are the Mauritius Government Copilot. Answer ONLY using the provided context. "
-        "If a detail is missing (fees, required docs, office or processing time), say so clearly. "
-        "Structure the answer as short bullet points with: Required documents, Fees, Where to apply, "
-        "Processing time, and Steps. Keep it concise (6–10 lines)."
-    )
     if lang == "fr":
         instruction = (
-            "Tu es le Copilote Gouvernemental de Maurice. Réponds UNIQUEMENT à partir du contexte fourni. "
-            "Si une information manque (frais, documents requis, bureau ou délai), dis-le clairement. "
-            "Structure en puces courtes : Documents requis, Frais, Où postuler, Délai de traitement, Étapes. "
-            "Reste concis (6–10 lignes)."
+            "Tu es le Copilote Gouvernemental de Maurice. Réponds UNIQUEMENT à partir du contexte. "
+            "Ne répète pas la question. Donne 6–10 puces courtes couvrant: Documents requis, Frais, "
+            "Où postuler, Délai de traitement, Étapes. Si une info manque, dis-le. Pas d'autres sections."
         )
     elif lang == "mfe":
         instruction = (
-            "To enn Copilot Gouv Moris. Reponn zis lor konteks ki donn. "
-            "Si enn detay manke (fre, dokiman, biro, letan tretman), dir li kler. "
-            "Servi pwen kout: Dokiman, Fre, Kot pou al, Letan tretman, Steps. "
-            "Reste kout (6–10 ligner)."
+            "To enn Copilot Gouv Moris. Reponn zis lor konteks. Pa repete kestyon. Donn 6–10 pwin kout "
+            "lor: Dokiman, Fre, Kot pou al, Letan tretman, Steps. Si info manke, dir li. Pa azout seksion anplis."
+        )
+    else:
+        instruction = (
+            "You are the Mauritius Government Copilot. Use ONLY the context. Do not repeat the question. "
+            "Write 6–10 short bullet points covering: Required documents, Fees, Where to apply, "
+            "Processing time, and Steps. If something is missing, say so. No extra sections."
         )
 
     chosen = _filter_hits(hits, keep=6)
     ctx_lines = [f"{i+1}) {_snippet(h['text'])}" for i, h in enumerate(chosen)]
     ctx_block = "\n".join(ctx_lines) if ctx_lines else "(none)"
 
+    # Prime with a leading dash to encourage bullets.
     prompt = (
         f"Instruction ({lang_readable}): {instruction}\n\n"
         f"Context:\n{ctx_block}\n\n"
         f"Question: {question}\n\n"
-        f"Answer ({lang_readable}):"
+        f"Answer ({lang_readable}):\n- "
     )
     return prompt
 
-
 _ECHO_PATTERNS = [
     r"^\s*Instruction.*$", r"^\s*Context:.*$", r"^\s*Question:.*$", r"^\s*Answer.*$",
     r"^\s*\[Instructions?\].*$", r"^\s*Be concise.*$", r"^\s*Do not invent.*$",
@@ -137,9 +120,7 @@ _ECHO_PATTERNS = [
 ]
 
 def _clean_generated(text: str) -> str:
-    """
-    Remove common echoed lines from the model output.
-    """
+    # Remove common echoed lines from the model output.
     lines = [ln.strip() for ln in text.strip().splitlines()]
     out = []
     for ln in lines:
@@ -147,10 +128,18 @@ def _clean_generated(text: str) -> str:
             continue
         out.append(ln)
     cleaned = "\n".join(out).strip()
-    # extra guard: collapse repeated blank lines
     cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
     return cleaned
 
+def _is_echo_or_too_short(ans: str, question: str) -> bool:
+    # Normalize and check if answer is basically the question or too short.
+    a = re.sub(r"\W+", " ", (ans or "").lower()).strip()
+    q = re.sub(r"\W+", " ", (question or "").lower()).strip()
+    if len(a) < 40:
+        return True
+    if q and (a.startswith(q) or q in a[: max(80, len(q) + 10)]):
+        return True
+    return False
 
 def synthesize_with_evo(
     user_query: str,
@@ -160,16 +149,12 @@ def synthesize_with_evo(
     max_new_tokens: int = 192,
     temperature: float = 0.4,
 ) -> str:
-    """
-    If mode=='generative' and a generator exists, generate a grounded answer
-    (labeled [Generative]). Otherwise, return the labeled extractive fallback.
-    """
+    # No context → safe fallback
     lang = normalize_lang(lang)
-
-    # No retrieved context? Stay safe.
     if not hits:
         return _extractive_answer(user_query, lang, hits)
 
+    # Extractive path or no generator available
     if mode != "generative" or _GENERATOR is None:
         return _extractive_answer(user_query, lang, hits)
 
@@ -181,8 +166,7 @@ def synthesize_with_evo(
             temperature=float(temperature),
         )
         text = _clean_generated(text)
-        # Fallback if empty or suspiciously short
-        if not text or len(text) < 20:
+        if _is_echo_or_too_short(text, user_query):
             return _extractive_answer(user_query, lang, hits)
         return "**[Generative]**\n\n" + text
     except Exception: