ajout libellé COICOP sortie

quick_deploy_agent.py

@@ -17,6 +17,7 @@ FALLBACK_MODELS = [
 ]
 
 
+# ---- Mini référentiel COICOP (démo) ----
 # ---- Mini référentiel COICOP (démo) ----
 COICOP_ITEMS = [
     {"code": "01.1.4.5.1", "label": "Laits caillés, fromage blanc, petites crèmes fromagères"},
@@ -29,6 +30,11 @@ COICOP_ITEMS = [
     {"code": "01.1.1.3", "label": "Pâtes, couscous et produits similaires"},
 ]
 
+# ✅ Map code -> libellé (avec un libellé pour le code générique)
+CODE_TO_LABEL = {it["code"]: it["label"] for it in COICOP_ITEMS}
+CODE_TO_LABEL.setdefault("01.1.4.5", "Fromages (générique)")
+
+
 def normalize_txt(s: str) -> str:
     if not s: return ""
     s = s.upper()
@@ -564,11 +570,14 @@ class Resolve(Tool):
     output_type = "object"
 
     def _fallback_min3(self):
-        # ordre neutre et scores modestes
+        # ordre neutre et scores modestes (avec libellés)
         base = [
-            {"code":"01.1.4.5.2","score_final":0.50,"votes":0,"evidences":["fallback (aucune évidence)"]},
-            {"code":"01.1.4.5.3","score_final":0.49,"votes":0,"evidences":["fallback (aucune évidence)"]},
-            {"code":"01.1.4.5.5","score_final":0.48,"votes":0,"evidences":["fallback (aucune évidence)"]},
+            {"code":"01.1.4.5.2","label": CODE_TO_LABEL.get("01.1.4.5.2",""),
+             "score_final":0.50,"votes":0,"evidences":["fallback (aucune évidence)"]},
+            {"code":"01.1.4.5.3","label": CODE_TO_LABEL.get("01.1.4.5.3",""),
+             "score_final":0.49,"votes":0,"evidences":["fallback (aucune évidence)"]},
+            {"code":"01.1.4.5.5","label": CODE_TO_LABEL.get("01.1.4.5.5",""),
+             "score_final":0.48,"votes":0,"evidences":["fallback (aucune évidence)"]},
         ]
         return base
 
@@ -586,21 +595,36 @@ class Resolve(Tool):
             if isinstance(s, str):
                 try: data = json.loads(s)
                 except Exception: data = {}
-            if not isinstance(data, dict): continue
+            if not isinstance(data, dict): 
+                continue
             for c in data.get("candidates", []):
-                code = c.get("code"); 
-                if not code: continue
+                code = c.get("code")
+                if not code: 
+                    continue
                 score = float(c.get("score", c.get("score_final", 0.0)))
                 why = c.get("why", "") or c.get("label", "")
+                # ✅ libellé via le mapping (fallback sur un éventuel label déjà présent)
+                label = CODE_TO_LABEL.get(code, c.get("label", ""))
+
                 if code not in bucket:
-                    bucket[code] = {"code":code,"score":score,"votes":1,"evidences":[why] if why else []}
+                    bucket[code] = {
+                        "code": code,
+                        "label": label,      # <-- ajouté
+                        "score": score,
+                        "votes": 1,
+                        "evidences": [why] if why else []
+                    }
                 else:
                     bucket[code]["score"] = max(bucket[code]["score"], score)
                     bucket[code]["votes"] += 1
-                    if why: bucket[code]["evidences"].append(why)
+                    if why: 
+                        bucket[code]["evidences"].append(why)
+                    # garde un label si absent
+                    if not bucket[code].get("label"):
+                        bucket[code]["label"] = label
 
         if not bucket:
-            # 🔁 Fallback global si VRAIMENT rien n'a pu être agrégé
+            # 🔁 Fallback global si VRAIMENT rien n'a pu être agrégé (avec labels)
             ranked = self._fallback_min3()
             final = ranked[0]
             alts  = ranked[1:]
@@ -615,23 +639,39 @@ class Resolve(Tool):
         # Top fusionné : au moins 3
         min_top = max(3, topn if isinstance(topn, int) and topn>0 else 3)
         if len(ranked) < min_top:
-            # compléter avec un petit fallback sans dupliquer
+            # compléter avec un petit fallback sans dupliquer (avec labels)
             already = {r["code"] for r in ranked}
             for fb in self._fallback_min3():
-                if len(ranked) >= min_top: break
-                if fb["code"] in already: continue
+                if len(ranked) >= min_top: 
+                    break
+                if fb["code"] in already: 
+                    continue
                 ranked.append(fb)
 
+        # Sélection finale
         final = ranked[0]
         alts  = ranked[1:1+min_top-1]
 
+        # Sécurise le label si jamais manquant (ne change rien au scoring)
+        final.setdefault("label", CODE_TO_LABEL.get(final["code"], ""))
+        for a in alts:
+            a.setdefault("label", CODE_TO_LABEL.get(a["code"], ""))
+
         ev = final.get("evidences", [])
         exp = (
             f"Choix {final['code']} (score {final['score_final']:.2f}) – votes={final.get('votes',0)} – raisons: {', '.join(sorted(set(ev)))}"
             if ev else
             f"Choix {final['code']} (score {final['score_final']:.2f}) – fallback partiel."
         )
-        return {"final": final, "alternatives": alts, "candidates_top": ranked[:min_top], "explanation": exp}
+
+        # candidates_top avec labels assurés
+        candidates_top = []
+        for r in ranked[:min_top]:
+            r.setdefault("label", CODE_TO_LABEL.get(r["code"], ""))
+            candidates_top.append(r)
+
+        return {"final": final, "alternatives": alts, "candidates_top": candidates_top, "explanation": exp}
+