"""Une exécution : les conversations étiquetées tri:diagnostic, les agents, une note privée, les étiquettes d'état. python -m support_diagnostic.run — configuration par l'environnement (spec §7, §9.2). Seul ce code déterministe écrit dans LibreDesk, par le client restreint ; les agents rendent du texte. """ import email.header import html import os import sys import tempfile import time from dataclasses import dataclass from pathlib import Path from typing import Mapping from .libredesk import Garde, LibreDesk TRI, EN_COURS, RELANCER = "tri:diagnostic", "diag:en-cours", "diag:relancer" ETIQUETTES = [TRI, EN_COURS, "diag:fait", "diag:erreur", "diag:ignore", RELANCER] # le contrat (README) ENTETE = "

🤖 BROUILLON IA — à relire, ne pas envoyer tel quel

" TYPES_IMAGE = {"image/png", "image/jpeg", "image/gif", "image/webp"} TAILLE_MIN = 10_000 # ponytail: octets, écarte les logos des signatures (comme Support-Agent) MODELE = "claude-opus-5-5" # celui de agents/support/agent.py @dataclass class Config: url: str cle: str secret: str ecrire: bool autorisees: set[str] | None # None : toutes (« * ») ; vide (simulation sans liste) : aucune plafond: int conversation: str # "" : toutes les éligibles donnees: Path cases: Path @staticmethod def depuis_env(env: Mapping[str, str]) -> "Config | None": """None si KILL_SWITCH est actif. Écrire exige DRY_RUN=false et une liste blanche (des uuid, ou *).""" if env.get("KILL_SWITCH", "").strip() not in ("", "false", "0"): return None ecrire = env.get("DRY_RUN", "true").strip() == "false" liste = env.get("ALLOWED_CONVERSATION_IDS", "").strip() autorisees = None if liste == "*" else {u.strip() for u in liste.split(",") if u.strip()} if ecrire and autorisees is not None and not autorisees: # « , » ne vaut pas « * » raise ValueError("DRY_RUN=false exige ALLOWED_CONVERSATION_IDS (des uuid séparés par des virgules, ou *)") return Config(env["LIBREDESK_URL"], env["LIBREDESK_API_KEY"], env["LIBREDESK_API_SECRET"], ecrire, autorisees, int(env.get("MAX_CONVERSATIONS_PER_RUN") or 3), env.get("CONVERSATION", "").strip(), Path(env.get("AIMSIGHT_DATA") or "data"), Path(env.get("AIMSIGHT_CASES") or tempfile.mkdtemp(prefix="cases-"))) def eligible(etiquettes: list[str]) -> bool: diag = [t for t in etiquettes if t.startswith("diag:")] return TRI in etiquettes and EN_COURS not in diag and (not diag or RELANCER in diag) def _objet(s: str | None) -> str: try: return str(email.header.make_header(email.header.decode_header(s or ""))) except (LookupError, ValueError, UnicodeDecodeError): return s or "" def fil(messages: list[dict], moi: int) -> tuple[str, str]: """(le mail, le contexte). Le mail : le fil avec le client, le plus récent en tête, comme un mail collé (repris de Support-Agent/app/serveur/libredesk.py). Le contexte : les notes privées des humains ; jamais les nôtres.""" blocs, notes = [], [] for m in sorted(messages, key=lambda m: m["created_at"], reverse=True): texte = (m.get("text_content") or m.get("content") or "").strip() if m.get("private"): # les activités (« X added tag … ») sont privées aussi : seules les notes comptent if m.get("type") == "outgoing" and m.get("sender_id") != moi and texte: notes.append(texte) continue if m.get("type") not in ("incoming", "outgoing") or not texte: continue a, meta = m.get("author") or {}, m.get("meta") or {} qui = " ".join(filter(None, [a.get("first_name"), a.get("last_name")])) or ", ".join(meta.get("from") or []) tete = [f"De: {qui}" + (f" <{a['email']}>" if a.get("email") else ""), f"Date: {m['created_at']}"] if meta.get("subject"): tete.append(f"Objet: {_objet(meta['subject'])}") blocs.append("\n".join(tete) + "\n\n" + texte) return "\n\n---\n\n".join(blocs), "\n\n".join(reversed(notes)) def _paragraphes(texte: str) -> str: return "".join(f"

{html.escape(p.strip()).replace(chr(10), '
')}

" for p in texte.split("\n\n") if p.strip()) def note(r, execution: str) -> str: """La note privée (spec §8, version de départ ; le format est à valider avec l'équipe support).""" titre = "Proposition de réponse au client :" if r.statut == "fait" else "Pas de proposition :" figures = (f"

Figures préparées (non jointes) : {html.escape(', '.join(p.name for p in r.pieces))}

" if r.pieces else "") return (f"{ENTETE}

{titre}

{_paragraphes(r.texte)}{figures}" f"

Exécution {html.escape(execution)} · modèle {MODELE} · coût {r.cout:.2f} $

") def _execution() -> str: e = os.environ ou = (f"{e['GITHUB_SERVER_URL']}/{e['GITHUB_REPOSITORY']}/actions/runs/{e['GITHUB_RUN_ID']}" if all(e.get(k) for k in ("GITHUB_SERVER_URL", "GITHUB_REPOSITORY", "GITHUB_RUN_ID")) else "local") return f"{ou} · commit {e.get('GITHUB_SHA', '')[:7] or '?'}" def _images(ld, messages: list[dict]) -> list[tuple[str, bytes]]: return [(p["content_type"], ld.piece(p["url"])) for m in messages if m.get("type") == "incoming" and not m.get("private") for p in m.get("attachments") or [] if p.get("content_type") in TYPES_IMAGE and (p.get("size") or 0) >= TAILLE_MIN and p.get("url")] def _une(ld, cfg: Config, uuid: str, diag, execution: str): from .diagnostic import Resultat # ponytail: verrou orphelin non détecté (runner tué) : un humain retire diag:en-cours ; date de l'étiquette si ça arrive ld.etiqueter(uuid, [EN_COURS]) messages = ld.messages(uuid) mail, contexte = fil(messages, ld.moi()) if not "".join(m.get("text_content") or "" for m in messages if m.get("type") == "incoming").strip(): r = Resultat("ignore", "Le mail du client ne contient pas de texte.", [], 0.0, None) else: r = diag(mail, _images(ld, messages), contexte, cfg.donnees, cfg.cases) ld.note_privee(uuid, note(r, execution)) ld.etiqueter(uuid, ["diag:" + r.statut], [EN_COURS, RELANCER]) return r def traiter(ld, cfg: Config, diag=None) -> dict[str, str]: if diag is None: from .diagnostic import diagnostiquer as diag debut, execution, statuts, couts = time.monotonic(), _execution(), {}, {} ids = ld.ids_etiquettes() if cfg.ecrire and (manque := [t for t in ETIQUETTES if t not in ids]): raise RuntimeError(f"étiquettes absentes de LibreDesk, à créer par un admin : {manque}") if cfg.conversation: candidates = [cfg.conversation] else: candidates = [c["uuid"] for c in ld.conversations(ids[TRI])] for uuid in candidates: if len(statuts) >= cfg.plafond: break if (cfg.autorisees is not None and uuid not in cfg.autorisees) or not eligible(ld.etiquettes(uuid)): continue print(f"--- {uuid}", flush=True) try: r = _une(ld, cfg, uuid, diag, execution) statuts[uuid], couts[uuid] = r.statut, r.cout except Garde: try: ld.etiqueter(uuid, ["diag:erreur"], [EN_COURS, RELANCER]) except Exception as e2: # noqa: BLE001 — c'est le Garde qui doit remonter print(f"[erreur] {uuid} : {type(e2).__name__}: {e2}", flush=True) raise except Exception as e: # noqa: BLE001 — une conversation en échec n'arrête pas les autres print(f"[erreur] {uuid} : {type(e).__name__}: {e}", flush=True) statuts[uuid], couts[uuid] = "erreur", 0.0 for essai in (lambda: ld.note_privee(uuid, f"{ENTETE}

Diagnostic en échec : {html.escape(type(e).__name__)}." f"


Exécution {html.escape(execution)}

"), lambda: ld.etiqueter(uuid, ["diag:erreur"], [EN_COURS, RELANCER])): try: essai() except Garde: raise except Exception as e2: # noqa: BLE001 print(f"[erreur] {uuid} : {type(e2).__name__}: {e2}", flush=True) for uuid, s in statuts.items(): print(f"{uuid} {s} {couts[uuid]:.2f} $") print(f"{len(statuts)} conversation(s), {sum(couts.values()):.2f} $, {time.monotonic() - debut:.0f} s" + ("" if cfg.ecrire else " (simulation : rien n'a été écrit)")) return statuts def main() -> int: cfg = Config.depuis_env(os.environ) if cfg is None: print("KILL_SWITCH actif : rien n'est lu ni écrit.") return 0 ld = LibreDesk(cfg.url, cfg.cle, cfg.secret, cfg.ecrire) try: traiter(ld, cfg) except Garde as e: print(f"[garde-fou] arrêt de toute l'exécution : {e}", file=sys.stderr) return 1 return 0 if __name__ == "__main__": sys.exit(main())