ajout outil merge

quick_deploy_agent.py

@@ -466,6 +466,84 @@ class WebGet(Tool):
         except Exception as e:
             return {"ok": False, "url": url, "error": str(e), "text": ""}
 
+# ---- MergeCandidatesTool ----
+
+class MergeCandidatesTool(Tool):
+    name = "merge_candidates"
+    description = ("Fusionne des listes de candidats COICOP (dédupe par code, prend le score max, "
+                   "agrège les justifs) et garantit min_k éléments avec padding neutre.")
+    inputs = {
+        "candidates_lists": {"type": "array", "description": "Liste de dicts {'candidates':[...]} venant d'autres outils."},
+        "min_k":            {"type": "integer", "description": "Taille minimale de la liste fusionnée (défaut 3).", "nullable": True},
+        "fallback_bias":    {"type": "string",  "description": "Indice métier pour le padding (ex: 'cheese' ou '').", "nullable": True},
+        "score_cap":        {"type": "number",  "description": "Clip des scores à [0, score_cap] (défaut 1.0).", "nullable": True},
+    }
+    output_type = "object"
+
+    def forward(self, candidates_lists, min_k: int = 3, fallback_bias: str = "", score_cap: float = 1.0):
+        # 1) Collecte
+        if not isinstance(candidates_lists, list):
+            return {"candidates": []}
+
+        bucket = {}  # code -> {code, score, votes, why_list}
+        for obj in candidates_lists:
+            if not isinstance(obj, dict): 
+                continue
+            for c in obj.get("candidates", []):
+                code = c.get("code")
+                if not code:
+                    continue
+                score = float(c.get("score", c.get("score_final", 0.0)))
+                if score_cap is not None:
+                    score = max(0.0, min(float(score_cap), score))
+                why = c.get("why", "") or c.get("label", "")
+                if code not in bucket:
+                    bucket[code] = {"code": code, "score": score, "votes": 1, "why_list": [why] if why else []}
+                else:
+                    # Garde le meilleur score, incrémente les votes, agrège les raisons
+                    if score > bucket[code]["score"]:
+                        bucket[code]["score"] = score
+                    bucket[code]["votes"] += 1
+                    if why:
+                        bucket[code]["why_list"].append(why)
+
+        merged = list(bucket.values())
+
+        # 2) Tri primaire par score puis par votes
+        merged.sort(key=lambda x: (x["score"], x["votes"]), reverse=True)
+
+        # 3) Padding si < min_k
+        def _fallback_order(bias: str):
+            # Ordre neutre mais raisonnable pour les fromages
+            base = ["01.1.4.5.2", "01.1.4.5.3", "01.1.4.5.5", "01.1.4.5.1", "01.1.4.5"]
+            return base if (bias or "").lower() == "cheese" else base
+
+        if len(merged) < max(1, int(min_k or 3)):
+            present = {m["code"] for m in merged}
+            for code in _fallback_order(fallback_bias):
+                if len(merged) >= min_k:
+                    break
+                if code in present:
+                    continue
+                merged.append({
+                    "code": code,
+                    "score": 0.5 if (fallback_bias or "").lower() == "cheese" else 0.48,
+                    "votes": 0,
+                    "why_list": ["padding fallback"]
+                })
+                present.add(code)
+
+        # 4) Normalisation finale de forme (why synthétique)
+        out = []
+        for m in merged[:max(1, int(min_k or 3))]:
+            why = ", ".join(sorted(set([w for w in m.get("why_list", []) if w])))
+            if not why:
+                why = "fusion (pas d'explications)"
+            out.append({"code": m["code"], "score": m["score"], "votes": m["votes"], "why": why})
+
+        return {"candidates": out}
+
+
 # ---- Resolve ----
 class Resolve(Tool):
     name, description = "resolve_coicop_candidates", "Fusionne candidats → choix final + alternatives + explication."
@@ -559,6 +637,7 @@ def build_agent(model_id: str | None = None) -> CodeAgent:
             SemSim(),
             WebSearch(),     # <-- autorise recherche web
             WebGet(),        # <-- autorise lecture de pages
+            MergeCandidatesTool(), 
             Resolve(),
         ],
         model=model,
@@ -579,35 +658,35 @@ if __name__ == "__main__":
 
     agent = build_agent()
     task = f"""
-    Classe ce produit en COICOP:
-    EAN: {ean}
-    Libellé: {label}
-
-    Outils autorisés UNIQUEMENT :
-      - validate_ean
-      - openfoodfacts_product_by_ean
-      - map_off_to_coicop
-      - coicop_regex_rules
-      - coicop_semantic_similarity
-      - web_search
-      - web_get
-      - resolve_coicop_candidates
-
-    RÈGLES:
-      - TU PEUX interroger Internet via web_search puis web_get pour récupérer infos produit (fiche marque, page drive, comparateurs, etc.).
-      - N'UTILISE PAS python_interpreter. N'ÉCRIS PAS DE CODE.
-      - N'INDEXE JAMAIS la sortie d'un tool (copie-colle uniquement ce qui est utile).
-
-    Pipeline :
-      1) validate_ean(ean)
-      2) openfoodfacts_product_by_ean(ean)
-      3) map_off_to_coicop(off_payload=<sortie brute de (2)>) ou, si nécessaire, map_off_to_coicop(product_name, categories_tags, ingredients_text)
-      3bis) SI doute (peu d'infos ou contradictions), web_search(query = "EAN + libellé + marque" ou libellé seul) → choisir 1–2 urls pertinentes → web_get(url)
-      4) coicop_regex_rules(text = LIBELLÉ UTILISATEUR)
-      4bis) coicop_regex_rules(text = TEXTE DES PAGES WEB RÉCUPÉRÉES)  # pour capter des mots-clés comme camembert/brie/emmental/etc.
-      5) coicop_semantic_similarity(text=LIBELLÉ UTILISATEUR, topk=5)  # retourne un dict "candidates"
-      6) resolve_coicop_candidates(json_lists=[<sortie de (3)>, <sortie de (4)>, <sortie de (5)>], topn=3)
-      → Retourne la sortie de l’étape 6 telle quelle (JSON objet complet).
+        Classe ce produit en COICOP:
+        EAN: {ean}
+        Libellé: {label}
+
+        Outils autorisés :
+        - validate_ean
+        - openfoodfacts_product_by_ean
+        - map_off_to_coicop
+        - coicop_regex_rules
+        - coicop_semantic_similarity
+        - merge_candidates
+        - resolve_coicop_candidates
+        - python_interpreter   # ✅ autorisé si besoin pour fusionner/traiter les données
+
+        Règles strictes :
+        - Utilise python_interpreter uniquement pour manipuler des résultats (listes/dicts, filtrage, fusion).
+        - N’écris pas de code inutile : chaque appel doit servir à transformer ou agréger les sorties des outils.
+        - Ne télécharge rien en dehors des outils fournis.
+        - Retourne uniquement un JSON valide (objet), sans backticks.
+
+        Pipeline :
+        1) v = validate_ean(ean)  # si v.valid==False => expliquer via resolve (fallback générique)
+        2) off = openfoodfacts_product_by_ean(ean)
+        3) offmap = map_off_to_coicop(off_payload=off)  # ou map_off_to_coicop(product_name, categories_tags, ingredients_text, ...)
+        4) rx = coicop_regex_rules(text=LIBELLÉ UTILISATEUR)
+        5) sem = coicop_semantic_similarity(text=LIBELLÉ UTILISATEUR, topk=5)
+        6) merged = merge_candidates(candidates_lists=[offmap, rx, sem], min_k=3, fallback_bias="cheese")
+        7) res = resolve_coicop_candidates(json_lists=[merged], topn=3)
+        → Retourne res tel quel (objet contenant final, alternatives, candidates_top le cas échéant).
 
 
     Retourne uniquement un JSON valide (objet), sans backticks.