Update evo_inference.py

evo_inference.py

@@ -1,25 +1,19 @@
 """
-evo_inference.py — Step 8 (refined)
-Adds a GENERATIVE path using a small plugin (FLAN-T5 stand-in) while keeping the
-old EXTRACTIVE fallback (bullet points) if generation isn't available.
-
-What's new in this refinement:
-- Answers are explicitly labeled **[Generative]** or **[Extractive]** so you
-  can tell which path ran at a glance.
-
-How it works:
-- We try to import your real evo plugin (evo_plugin.py). If not found, we load
-  evo_plugin_example.py instead. If both fail, we stay in extractive mode.
-- synthesize_with_evo(...) accepts mode/temp/max_tokens from the UI.
+evo_inference.py — Step 8 (FLAN-optimized)
+- Generative path uses a FLAN-friendly prompt: Instruction / Context / Question / Answer
+- Filters placeholder chunks
+- Cleans common prompt-echo lines
+- Keeps labeled [Generative] / [Extractive] outputs with safe fallback
 """
 
 from typing import List, Dict
+import re
 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   # your future file (optional)
     _GENERATOR = _load_real()
 except Exception:
     try:
@@ -72,27 +66,90 @@ def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
     )
 
 
+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()
+    ]
+    if not filtered:
+        filtered = hits
+    return filtered[:keep]
+
+
 def _build_grounded_prompt(question: str, lang: str, hits: List[Dict]) -> str:
-    """Create a compact prompt that includes the question + top retrieved snippets."""
+    """
+    FLAN-style prompt:
+    Instruction: ...
+    Context:
+    1) ...
+    2) ...
+    Question: ...
+    Answer:
+    """
     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":
-        system = ("Tu es le Copilote Gouvernemental de Maurice. Réponds clairement, étape "
-                  "par étape, en te basant UNIQUEMENT sur le contexte. Inclure: documents requis, "
-                  "frais, où postuler, délais. Dire si une info manque.")
+        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)."
+        )
     elif lang == "mfe":
-        system = ("To enn Copilot Gouv Moris. Reponn kler ek pas-a-pas, servi zis konteks ki donn. "
-                  "Met: ki dokiman bizin, fre, kot pou al, delai. Dir si info manke.")
-    else:
-        system = ("You are the Mauritius Government Copilot. Answer clearly and step-by-step using "
-                  "ONLY the provided context. Include: required documents, fees, where to apply, "
-                  "processing time. State if anything is missing.")
-
-    ctx = "\n".join([f"[Context #{i+1}] {_snippet(h['text'])}" for i, h in enumerate(hits[:6])]) or "[Context] (none)"
-    return (
-        f"{system}\n\n[Question]\n{question}\n\n{ctx}\n\n"
-        f"[Instructions]\n- Be concise (6–10 lines)\n- Use bullet steps\n"
-        f"- Do not invent links/fees\n- Answer in language code: {lang}\n[Answer]\n"
+        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)."
+        )
+
+    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)"
+
+    prompt = (
+        f"Instruction ({lang_readable}): {instruction}\n\n"
+        f"Context:\n{ctx_block}\n\n"
+        f"Question: {question}\n\n"
+        f"Answer ({lang_readable}):"
     )
+    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.*$",
+    r"^\s*(en|fr|mfe)\s*$",
+]
+
+def _clean_generated(text: str) -> str:
+    """
+    Remove common echoed lines from the model output.
+    """
+    lines = [ln.strip() for ln in text.strip().splitlines()]
+    out = []
+    for ln in lines:
+        if any(re.match(pat, ln, flags=re.IGNORECASE) for pat in _ECHO_PATTERNS):
+            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 synthesize_with_evo(
@@ -105,7 +162,7 @@ def synthesize_with_evo(
 ) -> str:
     """
     If mode=='generative' and a generator exists, generate a grounded answer
-    and label it **[Generative]**. Otherwise, return the labeled extractive fallback.
+    (labeled [Generative]). Otherwise, return the labeled extractive fallback.
     """
     lang = normalize_lang(lang)
 
@@ -122,13 +179,11 @@ def synthesize_with_evo(
             prompt,
             max_new_tokens=int(max_new_tokens),
             temperature=float(temperature),
-        ).strip()
-
-        if not text:
+        )
+        text = _clean_generated(text)
+        # Fallback if empty or suspiciously short
+        if not text or len(text) < 20:
             return _extractive_answer(user_query, lang, hits)
-
         return "**[Generative]**\n\n" + text
-
     except Exception:
-        # Any runtime issue falls back to safe mode
         return _extractive_answer(user_query, lang, hits)