Copie des agents de Support-Agent/API (sortie mail)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-09 08:35:00 +01:00
1 parent cbaab49d3f
commit 5e3faa47b4
49 files changed
+6662

No files matched your search

+123
View File
@@ -0,0 +1,123 @@
"""Un agent de l'API Claude qui reste vivant : un historique seulement ajouté, une boucle d'outils, son coût.
L'historique n'est jamais réécrit (le modèle refuse un historique édité qui contient ses blocs de réflexion) ; un
message assistant qui demande des outils n'y entre qu'avec ses tool_result, pour qu'une erreur au milieu d'un tour ne
laisse pas de tool_use orphelin.
"""
import json
import threading
from pathlib import Path
from typing import Callable
from langsmith import traceable
PRIX = {"claude-opus-5-5": {"entree": 4.0, "sortie": 20.0, "cache_lu": 0.20, "cache_ecrit": 5.0}} # $ / Mtok
MAX_TOKENS = 64000
@traceable(run_type="llm", name="claude")
def _llm(client, **kw):
"""Un appel à l'API, tracé dans LangSmith (son enveloppe wrap_anthropic ne couvre pas beta.messages.stream)."""
with client.beta.messages.stream(**kw) as flux:
return flux.get_final_message()
@traceable(run_type="tool")
def _outil(executer, nom: str, entree: dict):
return executer(nom, entree)
def _resume(entree: dict) -> str:
t = json.dumps(entree, ensure_ascii=False)
return t if len(t) <= 200 else t[:200] + "…"
# ponytail: l'historique grossit sans limite, images comprises (voir_image, voir_page) ; une longue analyse
# approfondie finira par dépasser la taille de requête de l'API, et on ne peut pas tronquer l'historique.
# Sortie prévue : la compaction côté serveur (beta compact-2026-01-12) ou le context editing des vieux tool_result.
class Agent:
def __init__(self, nom: str, systeme: str, outils: list[dict], executer: Callable[[str, dict], str | list[dict]],
client, journal: Callable[[dict], None], effort: str, modele: str = "claude-opus-5-5"):
self.nom, self.systeme, self.outils, self.executer = nom, systeme, outils, executer
self.client, self.journal, self.effort, self.modele = client, journal, effort, modele
self.messages: list[dict] = []
self.cout = 0.0
self.occupe = False
self._verrou = threading.Lock()
def _dire(self, type_: str, texte: str, **plus):
self.journal({"agent": self.nom, "type": type_, "texte": texte, **plus})
def _ajouter_user(self, blocs: list[dict]):
# après un tour interrompu, l'historique finit sur un message user : on y ajoute plutôt que d'en mettre deux
if self.messages and self.messages[-1]["role"] == "user":
self.messages[-1]["content"] += blocs
else:
self.messages.append({"role": "user", "content": blocs})
def _compter(self, usage):
p = PRIX[self.modele]
self.cout += (usage.input_tokens * p["entree"] + usage.output_tokens * p["sortie"]
+ (getattr(usage, "cache_read_input_tokens", 0) or 0) * p["cache_lu"]
+ (getattr(usage, "cache_creation_input_tokens", 0) or 0) * p["cache_ecrit"]) / 1e6
self._dire("cout", f"{self.cout:.2f}")
def _appel(self):
return _llm(self.client, model=self.modele, max_tokens=MAX_TOKENS,
system=[{"type": "text", "text": self.systeme, "cache_control": {"type": "ephemeral"}}],
tools=self.outils, messages=self.messages, thinking={"type": "adaptive"},
output_config={"effort": self.effort}, cache_control={"type": "ephemeral"})
# pas de fallbacks="default" : un bloc de repli renvoyé tel quel casse l'historique (clé from_, blocs à
# retirer) ; un refus finit le tour comme un max_tokens, sans rien ajouter à l'historique
def tour(self, contenu: str | list[dict], source: str) -> str:
"""Ajoute le message de `source` (marc ou support), fait tourner la boucle jusqu'à la fin du tour, rend le
texte final (vide si le tour s'arrête sur une erreur)."""
blocs = [{"type": "text", "text": contenu}] if isinstance(contenu, str) else list(contenu)
texte = next((b["text"] for b in blocs if b.get("type") == "text"), "")
blocs = [{"type": "text", "text": f"<source>{source}</source>"}] + blocs
with self._verrou:
self.occupe = True
try:
self._ajouter_user(blocs)
self._dire("entree", texte, source=source)
return self._boucle()
finally:
self.occupe = False
def _boucle(self) -> str:
while True:
try:
r = self._appel()
except Exception as e: # noqa: BLE001 — surcharge, quota, réseau : le tour s'arrête, l'historique reste valide
self._dire("erreur", f"{type(e).__name__}: {e}")
return ""
self._compter(r.usage)
if r.stop_reason not in ("tool_use", "end_turn", "pause_turn"):
# max_tokens, refusal… : la réponse peut porter un tool_use sans suite, qui rendrait l'historique
# invalide pour toujours ; elle n'y entre pas, le tour s'arrête, le message suivant repart d'ici
self._dire("erreur", f"tour arrêté : {r.stop_reason} (réponse non gardée)")
return ""
contenu = [b.model_dump(mode="json", exclude_none=True, by_alias=True) for b in r.content]
for b in contenu:
if b["type"] == "text" and b["text"].strip():
self._dire("texte", b["text"])
if r.stop_reason == "tool_use":
resultats = []
for b in (b for b in contenu if b["type"] == "tool_use"):
self._dire("outil", f"{b['name']} {_resume(b['input'])}")
try:
res = {"type": "tool_result", "tool_use_id": b["id"], "content": _outil(self.executer, b["name"], b["input"])}
except Exception as e: # noqa: BLE001 — l'erreur d'un outil est rendue au modèle
res = {"type": "tool_result", "tool_use_id": b["id"], "content": f"{type(e).__name__}: {e}",
"is_error": True}
resultats.append(res)
self.messages += [{"role": "assistant", "content": contenu}, {"role": "user", "content": resultats}]
continue
self.messages.append({"role": "assistant", "content": contenu})
if r.stop_reason == "pause_turn": # seulement avec des outils serveur, que nous n'avons pas
continue
return "\n".join(b["text"] for b in contenu if b["type"] == "text")
def sauver(self, chemin: Path) -> None:
Path(chemin).write_text(json.dumps(self.messages, ensure_ascii=False, indent=1))
+300
View File
@@ -0,0 +1,300 @@
"""Vérifications du support par l'API, sans appel à l'API (faux client) : API/.venv/bin/python API/support/check.py"""
import sys
from pathlib import Path
from types import SimpleNamespace as NS
sys.path.insert(0, str(Path(__file__).resolve().parent))
from agent import Agent # noqa: E402
API = Path(__file__).resolve().parents[1]
DONNEES = API.parent / "data"
class Bloc(NS):
def model_dump(self, **_):
return {k: v for k, v in vars(self).items() if v is not None}
def reponse(contenu, stop, entree=10, sortie=10):
return NS(content=contenu, stop_reason=stop, usage=NS(input_tokens=entree, output_tokens=sortie,
cache_read_input_tokens=0, cache_creation_input_tokens=0))
class FauxClient:
"""beta.messages.stream(**kw) rend, dans l'ordre, les réponses scriptées ; une exception scriptée est levée."""
def __init__(self, *reponses):
self.reponses, self.appels = list(reponses), []
self.beta = NS(messages=NS(stream=self._stream))
def _stream(self, **kw):
self.appels.append(kw)
r = self.reponses.pop(0)
client = self
class Flux:
def __enter__(self):
if isinstance(r, Exception):
raise r
return NS(get_final_message=lambda: r)
def __exit__(self, *_):
return False
client.dernier = kw
return Flux()
def agent(client, executer=lambda n, e: "ok"):
journal = []
a = Agent("analyste", "système", [], executer, client, journal.append, effort="high")
return a, journal
def check_boucle():
appels = []
c = FauxClient(reponse([Bloc(type="tool_use", id="t1", name="detecteurs", input={"station": "X"})], "tool_use"),
reponse([Bloc(type="text", text="fini")], "end_turn"))
a, _ = agent(c, lambda n, e: appels.append((n, e)) or "3 événements")
assert a.tour("question", "support") == "fini"
roles = [m["role"] for m in a.messages]
assert roles == ["user", "assistant", "user", "assistant"], roles
res = a.messages[2]["content"][0]
assert res["type"] == "tool_result" and res["tool_use_id"] == "t1" and res["content"] == "3 événements"
assert appels == [("detecteurs", {"station": "X"})]
assert not a.occupe
def check_erreur():
c = FauxClient(reponse([Bloc(type="tool_use", id="t1", name="detecteurs", input={})], "tool_use"),
RuntimeError("surcharge"))
a, journal = agent(c)
a.tour("question", "marc")
assert any(e["type"] == "erreur" for e in journal)
dernier = a.messages[-1]
assert not (dernier["role"] == "assistant" and any(b.get("type") == "tool_use" for b in dernier["content"]))
assert not a.occupe
# le tour suivant repart proprement : user après user est permis, pas de tool_use orphelin
c.reponses.append(reponse([Bloc(type="text", text="repris")], "end_turn"))
assert a.tour("encore", "marc") == "repris"
def check_cout():
r = reponse([Bloc(type="text", text="x")], "end_turn", entree=1_000_000, sortie=100_000)
a, journal = agent(FauxClient(r))
a.tour("q", "marc")
assert abs(a.cout - 6.0) < 1e-9, a.cout
assert any(e["type"] == "cout" for e in journal)
def check_source():
a, journal = agent(FauxClient(reponse([Bloc(type="text", text="x")], "end_turn")))
a.tour("bonjour", "marc")
premier = a.messages[0]["content"][0]
assert premier["type"] == "text" and premier["text"].startswith("<source>marc</source>")
assert journal[0]["type"] == "entree" and journal[0]["source"] == "marc"
def check_outil_qui_leve():
c = FauxClient(reponse([Bloc(type="tool_use", id="t1", name="x", input={})], "tool_use"),
reponse([Bloc(type="text", text="vu")], "end_turn"))
a, _ = agent(c, lambda n, e: 1 / 0)
a.tour("q", "marc")
res = a.messages[2]["content"][0]
assert res["is_error"] is True and "division" in res["content"]
def boite(dossier, station="NEBRASKA"):
from outils import Boite
return Boite(lambda: dossier, lambda: station, DONNEES, lambda m: "réponse", lambda st, su: dossier)
def leve(f, *a):
from outils import ErreurOutil
try:
f(*a)
except ErreurOutil as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas levé ErreurOutil")
def seance_temporaire():
import tempfile
return Path(tempfile.mkdtemp(prefix="seance-"))
def check_lecture_refusee():
b = boite(seance_temporaire())
assert "rm" in leve(b.executer_analyste, "outil_de_lecture", {"nom": "rm", "arguments": []})
def check_chemin():
b = boite(seance_temporaire())
for c in ("../../.env", "/etc/passwd"):
leve(b.executer_analyste, "voir_image", {"chemin": c})
def check_station_absente():
b = boite(seance_temporaire())
m = leve(b.executer_analyste, "detecteurs", {"station": "NULLEPART", "du": "2026-10-01", "au": "2026-10-02"})
assert "NULLEPART" in m
def check_detecteurs():
b = boite(seance_temporaire())
t = b.executer_analyste("detecteurs", {"station": "NEBRASKA", "du": "2026-10-20", "au": "2026-11-01"})
assert "événement" in t and "capteurs :" in t, t
def check_plafond():
from outils import plafonner
t = plafonner("x" * 50_000)
assert len(t) <= 40_100 and t.endswith("tronqué : 50000 caractères]"), t[-60:]
def check_image():
import base64
import io
from PIL import Image
from outils import bloc_image
jpg = sorted((DONNEES / "NEBRASKA" / "images").glob("*.jpg"))[0]
b = bloc_image(jpg)
assert b["type"] == "image" and b["source"]["media_type"] == "image/jpeg"
im = Image.open(io.BytesIO(base64.b64decode(b["source"]["data"])))
assert max(im.size) <= 1568, im.size
def check_compiler():
import re
import shutil
d = seance_temporaire()
modele = (API / "knowledge" / "support" / "modele.typ").read_text()
(d / "nebraska.typ").write_text(modele)
for f in set(re.findall(r'image\("([^"]+)"\)', modele)):
shutil.copy(API.parent / "support" / "2026-11-02_BREITHORN_rapport-situation" / f, d)
b = boite(d)
assert b.executer_support("compiler", {}).startswith("v1.pdf : ") and (d / "v1.pdf").exists()
assert b.executer_support("compiler", {}).startswith("v2.pdf : ")
(d / "nebraska.typ").write_text("#oups(")
leve(b.executer_support, "compiler", {})
assert not (d / "v3.pdf").exists()
page = b.executer_support("voir_page", {"n": 1})
assert page[0]["type"] == "image"
def check_max_tokens():
# un tour coupé (max_tokens, refus) avec un tool_use : rien n'entre dans l'historique, la séance continue
c = FauxClient(reponse([Bloc(type="tool_use", id="t1", name="ecrire_presentation", input={})], "max_tokens"),
reponse([Bloc(type="text", text="repris")], "end_turn"))
a, journal = agent(c)
a.tour("q", "marc")
assert any(e["type"] == "erreur" for e in journal)
assert all(m["role"] == "user" for m in a.messages), [m["role"] for m in a.messages]
assert a.tour("encore", "marc") == "repris"
def check_sans_repli():
# le repli de modèle casse l'historique renvoyé (clé from_) : il n'est pas demandé
c = FauxClient(reponse([Bloc(type="text", text="x")], "end_turn"))
a, _ = agent(c)
a.tour("q", "marc")
assert "fallbacks" not in c.dernier and "server-side-fallback-2026-07-01" not in c.dernier.get("betas", [])
def check_capture_reduite():
import io
import shutil
from PIL import Image
from seance import Seance
tampon = io.BytesIO()
Image.new("RGB", (4000, 3000), "white").save(tampon, "PNG")
s = Seance("mail", [("image/png", tampon.getvalue())], "", DONNEES, lambda e: None,
client=FauxClient(reponse([Bloc(type="text", text="x")], "end_turn")))
try:
s.demarrer()
bloc = next(b for b in s.support.messages[0]["content"] if b.get("type") == "image")
import base64
im = Image.open(io.BytesIO(base64.b64decode(bloc["source"]["data"])))
assert max(im.size) <= 1568, im.size
finally:
shutil.rmtree(s.dossier)
def check_image_proche():
from datetime import datetime, timedelta
b = boite(seance_temporaire())
jpg = sorted((DONNEES / "NEBRASKA" / "images").glob("*.jpg"))[0]
t = datetime.strptime(jpg.name[:14], "%Y%m%dT%H%MZ") + timedelta(minutes=2)
bloc = b.executer_analyste("voir_image", {"chemin": "images/" + t.strftime("%Y%m%dT%H%MZ")})
assert bloc[0]["type"] == "image"
assert b._image_proche(t.strftime("%Y%m%dT%H%MZ")) == jpg
leve(b._image_proche, "20200101T0000Z")
def check_stabilite():
b = boite(seance_temporaire(), "LENZSPITZE")
t = b.executer_analyste("stabilite", {"station": "LENZSPITZE", "du": "2026-10-16", "au": "2026-10-20",
"hors": ["2026-10-17T00:00Z/2026-10-18T00:00Z"]})
assert "1017" in t and "étendue" in t, t[:400]
ligne = next(l for l in t.splitlines() if l.startswith("1017 "))
assert ligne.split()[1] == "3", ligne # 4 jours, dont le 17 écarté
def check_lire_document():
b = boite(seance_temporaire())
t = b.executer_analyste("lire_document", {"nom": "carte-des-etiquettes.md",
"section": "La station s'éteint faute d'énergie"})
assert t.startswith("#### La station s'éteint faute d'énergie") and "#### Coupure du secteur" not in t, t[:200]
assert "Les frontières" in b.executer_analyste("lire_document", {"nom": "familles.md", "section": ""})
assert "sections" in leve(b.executer_analyste, "lire_document", {"nom": "familles.md", "section": "n'existe pas"})
leve(b.executer_analyste, "lire_document", {"nom": "../../.env", "section": ""})
def check_cartes():
from seance import systeme
a = systeme("analyste")
assert len(a) < 60_000, len(a) # les cartes, pas tout le savoir (214 000 caractères avant)
assert "## Sommaire" in a and "#### Un trou commun" not in a and "## Les frontières" in a
assert "lire-les-donnees.md" in a # dans l'index
assert "#### Un trou commun" not in a and "## Les outils" not in a
def check_stations_dans_la_seance():
from outils import AVEC_SORTIE
assert "stations" in AVEC_SORTIE
def check_sortie_mail():
# la sortie mail : prompt sans la présentation, outils sans compiler, versions mail-vN.json, pièces du dossier seules
import json
from seance import Seance, systeme
m, p = systeme("support", "mail"), systeme("support", "pdf")
assert "ecrire_mail" in m and "modele.typ\">" not in m and "ecrire_presentation" not in m.split("<sortie>")[-1]
assert "modele.typ\">" in p and "ecrire_presentation" in p.split("<sortie>")[-1]
d = seance_temporaire()
(d / "bosse.png").write_bytes(b"x")
b = boite(d)
assert "pièces refusées" in leve(b.executer_support, "ecrire_mail", {"texte": "t", "pieces_jointes": ["../x.png"]})
leve(b.executer_support, "ecrire_mail", {"texte": "t", "pieces_jointes": ["absente.png"]})
assert b.executer_support("ecrire_mail", {"texte": "Bonjour,", "pieces_jointes": ["bosse.png"]}).startswith("mail-v1.json")
b.executer_support("ecrire_mail", {"texte": "Bonjour, v2", "pieces_jointes": []})
assert json.loads((d / "mail-v2.json").read_text()) == {"texte": "Bonjour, v2", "pieces_jointes": []}
import seance
seance.CASES, avant = d, seance.CASES
try:
s = Seance("mail", [], "", DONNEES, lambda e: None, client=FauxClient(), sortie="mail")
assert [o["name"] for o in s.support.outils][-1] == "ecrire_mail" and s.derniere_version() is None
for i in (1, 2, 10):
(s.dossier / f"mail-v{i}.json").write_text("{}")
assert s.derniere_version().name == "mail-v10.json"
finally:
seance.CASES = avant
CHECKS = [check_sortie_mail, check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee,
check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
+296
View File
@@ -0,0 +1,296 @@
"""Les outils des deux agents : leurs schémas pour l'API, et la Boite qui les exécute sur le poste.
Tout outil lance une copie de `API/tools/` par `subprocess`, n'écrit que dans le dossier de la séance (et dans la fabrique
Typst `tools/typst/{documents,build}/`), et lève ErreurOutil sur une erreur : l'agent la rend au modèle en `is_error`.
"""
import base64
import io
import json
import os
import re
import shutil
import subprocess
from datetime import datetime
from pathlib import Path
from typing import Callable
from PIL import Image
API = Path(__file__).resolve().parents[1]
PY = str(API / ".venv" / "bin" / "python")
TOOLS = API / "tools"
TYPST = TOOLS / "typst"
KNOWLEDGE = API / "knowledge"
LECTURE = {"inventaire", "resume", "plages", "jours", "vignettes", "qualite", "ensemble", "graphique", "metriques",
"stations"}
AVEC_SORTIE = {"graphique", "ensemble", "jours", "metriques", "vignettes", "qualite", "stations"} # ceux qui écrivent des PNG
DELAI = 600 # s
VOIR = 1000 # px : les images regardées restent dans l'historique et repartent à chaque appel
NOM = re.compile(r"^[A-Za-z0-9_-]+$")
INSTANT = re.compile(r"^\d{8}T\d{4}Z$") # AAAAMMJJTHHMMZ, comme le début du nom des images
PROCHE = 90 # min : au-delà, pas d'image « à cette heure »
class ErreurOutil(Exception):
pass
def plafonner(texte: str, n: int = 40_000) -> str:
return texte if len(texte) <= n else texte[:n] + f"\n[… tronqué : {len(texte)} caractères]"
def section(texte: str, titre: str) -> str:
"""La section d'un markdown dont le titre contient `titre` (sans la casse), jusqu'au titre suivant de même niveau ou
plus haut ; lève ErreurOutil avec la liste des titres si aucun ne convient."""
lignes = texte.splitlines()
titres = [(i, len(l) - len(l.lstrip("#"))) for i, l in enumerate(lignes) if l.startswith("#")]
for k, (i, niveau) in enumerate(titres):
if titre.lower() in lignes[i].lstrip("#").strip().lower():
fin = next((j for j, n in titres[k + 1:] if n <= niveau), len(lignes))
return "\n".join(lignes[i:fin]).strip()
raise ErreurOutil(f"pas de section « {titre} » ; sections : " + " | ".join(lignes[i].strip() for i, _ in titres))
def bloc_image(chemin: Path, cote: int = 1568) -> dict:
"""Image -> bloc image de l'API, plus grand côté ≤ cote px (au-delà de 1568, l'API la réduirait de toute façon)."""
im = Image.open(chemin)
im.thumbnail((cote, cote))
jpeg = Path(chemin).suffix.lower() in (".jpg", ".jpeg")
if im.mode not in ("RGB", "L"):
im = im.convert("RGB")
tampon = io.BytesIO()
im.save(tampon, "JPEG" if jpeg else "PNG")
return {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg" if jpeg else "image/png",
"data": base64.b64encode(tampon.getvalue()).decode()}}
def _schema(nom: str, description: str, props: dict) -> dict:
return {"name": nom, "description": description, "strict": True,
"input_schema": {"type": "object", "properties": props, "required": list(props),
"additionalProperties": False}}
S, I = {"type": "string"}, {"type": "integer"}
LISTE = {"type": "array", "items": {"type": "string"}}
OUTILS_ANALYSTE = [
_schema("detecteurs", "Les événements des détecteurs du journal sur une plage : famille, sorte, capteurs, phrase. "
"du et au : AAAA-MM-JJ, UTC, au exclu.", {"station": S, "du": S, "au": S}),
_schema("stabilite", "La stabilité verticale chiffrée : pour chaque cible, la médiane de corr_y jour par jour et "
"l'étendue de ces médianes (de combien elle a varié d'un jour à l'autre), mesures rejetées écartées ; hors : "
"plages à écarter, AAAA-MM-JJTHH:MMZ/AAAA-MM-JJTHH:MMZ (les nuits de visibilité réduite). du, au : AAAA-MM-JJ, "
"au exclu.", {"station": S, "du": S, "au": S, "hors": LISTE}),
_schema("lire_document", "Lit un document de ton savoir (l'index de ton prompt), entier (section vide) ou une seule "
"section par son titre (ex. une fiche de la carte des étiquettes : « La pluie »).", {"nom": S, "section": S}),
_schema("outil_de_lecture", "Lance un outil de lecture (lire-les-donnees.md) : nom parmi " + ", ".join(sorted(LECTURE))
+ ". arguments : la ligne de commande après le nom du script, data/<STATION> pour le dossier.",
{"nom": S, "arguments": LISTE}),
_schema("figure_courbes", "Figure corr_y à plage grisée (figure-y.py) dans le dossier de la séance, <nom>.png. "
"debut, fin : AAAA-MM-JJTHH:MMZ. options : --cam tilt,pan, --temp, --zone D/F, --ligne T, --hauteur 5…",
{"nom": S, "debut": S, "fin": S, "cibles": LISTE, "options": LISTE}),
_schema("image_de_la_cause", "Recadrages éclaircis côte à côte autour d'une cible (x, y : pixel dans l'image entière), "
"<nom>.png. instants : AAAAMMJJTHHMMZ=légende (l'image la plus proche de chaque heure), d'abord un instant "
"sans la cause. cibles : les seules cibles dont le nom est écrit, celles dont parle la diapositive.",
{"nom": S, "x": I, "y": I, "instants": LISTE, "cibles": LISTE}),
_schema("voir_image", "Regarder une image : un fichier du dossier de la séance (ex. bosse.png), ou une image de la "
"caméra, images/AAAAMMJJTHHMMZ (la plus proche de cette heure UTC) ou images/<fichier>.", {"chemin": S}),
]
OUTILS_SUPPORT = [
_schema("poser_station", "Fixe la station de la séance (un dossier de données) et le sujet en 2-3 mots "
"(ex. courbes-bruitees) ; rend ce que la station a comme données.", {"station": S, "sujet": S}),
_schema("demander_analyste", "Envoie un message à l'analyste (station, plage UTC, question ; ou un retour de fond) "
"et rend sa réponse.", {"message": S}),
_schema("ecrire_presentation", "Écrit le source Typst complet de la présentation dans le dossier de la séance.",
{"source_typ": S}),
_schema("compiler", "Compile la présentation : rend la version (v1.pdf, v2.pdf…), le nombre de diapositives qui "
"débordent et les remarques du lint, ou l'erreur de Typst.", {}),
_schema("voir_page", "Regarder la page n (à partir de 1) de la dernière version du PDF.", {"n": I}),
]
PIECES = (".png", ".jpg", ".jpeg", ".gif") # ce qu'un mail peut joindre, du dossier de la séance
# La sortie mail : sans les outils de la présentation, avec ecrire_mail
OUTILS_SUPPORT_MAIL = [o for o in OUTILS_SUPPORT if o["name"] in ("poser_station", "demander_analyste")] + [
_schema("ecrire_mail", "Écrit une version du mail de réponse (mail-v1.json, mail-v2.json…) : le corps, et les "
"fichiers du dossier de la séance à joindre (.png, .jpg, .gif ; liste vide : aucun).",
{"texte": S, "pieces_jointes": {"type": "array", "items": S}}),
]
class Boite:
def __init__(self, dossier_seance: Callable[[], Path], station: Callable[[], str | None], donnees: Path,
demander_analyste: Callable[[str], str], poser: Callable[[str, str], Path]):
self.dossier, self.station, self.donnees = dossier_seance, station, Path(donnees)
self.demander_analyste, self.poser = demander_analyste, poser
# --- aides
def _lancer(self, args: list[str], env: dict | None = None) -> str:
try:
r = subprocess.run(args, cwd=self.dossier(), capture_output=True, text=True, timeout=DELAI,
env={**os.environ, **(env or {})})
except subprocess.TimeoutExpired:
raise ErreurOutil(f"délai de {DELAI} s dépassé : {' '.join(args[1:3])}")
sortie = (r.stdout + ("\n" + r.stderr if r.stderr.strip() else "")).strip()
if r.returncode:
raise ErreurOutil(plafonner(sortie or f"code de sortie {r.returncode}"))
return plafonner(sortie or "(rien)")
def _station(self, station: str | None = None) -> Path:
station = station or self.station()
if not station:
raise ErreurOutil("pas encore de station : le support doit d'abord appeler poser_station")
if not NOM.match(station) or not (self.donnees / station).is_dir():
raise ErreurOutil(f"station inconnue : {station} (pas de dossier dans les données)")
return self.donnees / station
def _nom(self, nom: str) -> str:
if not NOM.match(nom):
raise ErreurOutil(f"nom de fichier refusé : {nom} (lettres, chiffres, - et _)")
return nom
def _data(self, a: str) -> str:
return str(self.donnees) + a[4:] if a == "data" or a.startswith("data/") else a
def _image_proche(self, instant: str) -> Path:
"""L'image de la station la plus proche de l'instant (les images tombent à :00 ou :01, à un nom près)."""
t = datetime.strptime(instant, "%Y%m%dT%H%MZ")
ecart = lambda p: abs((datetime.strptime(p.name[:14], "%Y%m%dT%H%MZ") - t).total_seconds()) # noqa: E731
images = [p for p in (self._station() / "images").glob("*.jpg") if INSTANT.match(p.name[:14])]
proche = min(images, key=ecart, default=None)
if not proche or ecart(proche) > PROCHE * 60:
raise ErreurOutil(f"pas d'image à moins de {PROCHE} min de {instant}")
return proche
def _image(self, chemin: str) -> Path:
if chemin.startswith("images/") and INSTANT.match(chemin[7:21]) and not (self._station() / chemin).is_file():
return self._image_proche(chemin[7:21])
if chemin.startswith("images/"):
base = self._station() / "images"
p = (base / chemin[7:]).resolve()
else:
base = self.dossier()
p = (base / chemin).resolve()
if Path(chemin).is_absolute() or not p.is_relative_to(base.resolve()) or not p.is_file():
raise ErreurOutil(f"image refusée ou absente : {chemin}")
return p
def _versions(self) -> list[Path]:
return sorted(self.dossier().glob("v*.pdf"), key=lambda p: int(p.stem[1:]))
# --- l'analyste
def executer_analyste(self, nom: str, e: dict):
if nom == "detecteurs":
return self._lancer([PY, str(TOOLS / "journal.py"), str(self._station(e["station"])), "--du", e["du"],
"--au", e["au"]])
if nom == "lire_document":
p = KNOWLEDGE / "analyste" / e["nom"]
if "/" in e["nom"] or not p.is_file():
raise ErreurOutil(f"document inconnu : {e['nom']} ; documents : "
+ ", ".join(sorted(f.name for f in (KNOWLEDGE / "analyste").iterdir())))
texte = p.read_text()
return plafonner(section(texte, e["section"]) if e["section"].strip() else texte)
if nom == "stabilite":
return self._lancer([PY, str(TOOLS / "stabilite.py"), str(self._station(e["station"])), "--du", e["du"],
"--au", e["au"], *(["--hors", *e["hors"]] if e["hors"] else [])])
if nom == "outil_de_lecture":
if e["nom"] not in LECTURE:
raise ErreurOutil(f"outil inconnu : {e['nom']} (permis : {', '.join(sorted(LECTURE))})")
args = [self._data(a) for a in e["arguments"]]
if e["nom"] in AVEC_SORTIE:
args += ["--sortie", str(self.dossier())]
return self._lancer([PY, str(TOOLS / "agent-tools" / f"{e['nom']}.py"), *args])
if nom == "figure_courbes":
sortie = self.dossier() / f"{self._nom(e['nom'])}.png"
self._lancer([PY, str(TOOLS / "figures" / "figure-y.py"), str(self._station()), str(sortie), e["debut"],
e["fin"], "--cibles", ",".join(e["cibles"]), *e["options"]])
return f"{sortie.name} écrite ; la regarder avec voir_image avant de la garder"
if nom == "image_de_la_cause":
sortie = self.dossier() / f"{self._nom(e['nom'])}.png"
instants = [] # chaque instant ramené à l'image la plus proche, sa légende gardée
for i in e["instants"]:
k, egal, legende = i.partition("=")
instants.append(self._image_proche(k).name[:14] + egal + legende)
self._lancer([PY, str(TOOLS / "figures" / "image-de-la-cause.py"), str(self._station()), str(e["x"]),
str(e["y"]), str(sortie), *instants, *(["--cibles", ",".join(e["cibles"])] if e["cibles"] else [])])
return (f"{sortie.name} écrite, images : {', '.join(i.partition('=')[0] for i in instants)} ; "
"la regarder avec voir_image avant de la garder")
if nom == "voir_image":
return [bloc_image(self._image(e["chemin"]), VOIR)]
raise ErreurOutil(f"outil inconnu : {nom}")
# --- le support
def executer_support(self, nom: str, e: dict):
if nom == "poser_station":
dossier = self._station(e["station"])
self.poser(e["station"], self._nom(e["sujet"]))
sous = ", ".join(f"{d.name} ({sum(1 for _ in d.iterdir())} fichiers)" for d in sorted(dossier.iterdir())
if d.is_dir())
return f"station {e['station']} posée ; données : {sous}"
if nom == "demander_analyste":
return self.demander_analyste(e["message"])
if nom == "ecrire_presentation":
p = self.dossier() / f"{self._station().name.lower()}.typ"
p.write_text(e["source_typ"])
return f"{p.name} écrit ({len(e['source_typ'])} caractères)"
if nom == "compiler":
return self._compiler()
if nom == "voir_page":
return self._voir_page(int(e["n"]))
if nom == "ecrire_mail":
return self._ecrire_mail(e["texte"], e["pieces_jointes"])
raise ErreurOutil(f"outil inconnu : {nom}")
def _ecrire_mail(self, texte: str, pieces: list[str]) -> str:
absentes = [p for p in pieces if "/" in p or not p.lower().endswith(PIECES) or not (self.dossier() / p).is_file()]
if absentes:
raise ErreurOutil(f"pièces refusées ou absentes du dossier de la séance : {', '.join(absentes)}")
version = self.dossier() / f"mail-v{len(list(self.dossier().glob('mail-v*.json'))) + 1}.json"
version.write_text(json.dumps({"texte": texte, "pieces_jointes": pieces}, ensure_ascii=False, indent=1))
return f"{version.name} écrit ({len(texte)} caractères, {len(pieces)} pièce(s) jointe(s))"
def _compiler(self) -> str:
station = self._station().name.lower()
source = self.dossier() / f"{station}.typ"
if not source.exists():
raise ErreurOutil("pas de source : appeler ecrire_presentation d'abord")
slug = f"{station}-support"
doc = TYPST / "documents" / slug
shutil.rmtree(doc, ignore_errors=True)
doc.mkdir(parents=True)
shutil.copy(source, doc / "main.typ")
for png in self.dossier().glob("*.png"):
shutil.copy(png, doc)
env = {"PATH": f"{Path.home() / '.local' / 'bin'}:{os.environ.get('PATH', '')}"}
try:
r = subprocess.run([PY, "brand/tools/build.py", slug], cwd=TYPST, capture_output=True, text=True,
timeout=DELAI, env={**os.environ, **env})
except subprocess.TimeoutExpired:
raise ErreurOutil(f"compilation : délai de {DELAI} s dépassé")
sortie = (r.stdout + "\n" + r.stderr).strip()
pdf = TYPST / "build" / f"{slug}-draft.pdf"
if r.returncode or not pdf.exists():
raise ErreurOutil(plafonner(sortie))
version = self.dossier() / f"v{len(self._versions()) + 1}.pdf"
shutil.copy(pdf, version)
pdf.unlink() # la prochaine compilation ratée ne doit pas trouver l'ancien PDF
texte = subprocess.run(["pdftotext", str(version), "-"], capture_output=True, text=True).stdout
remarques = "\n".join(l for l in sortie.splitlines() if "warning" in l and "bare-image" not in l)
return f"{version.name} : {texte.count('Overflow')} diapositive(s) qui débordent" + (
f"\nremarques du lint :\n{plafonner(remarques, 4000)}" if remarques else "")
def _voir_page(self, n: int) -> list[dict]:
versions = self._versions()
if not versions:
raise ErreurOutil("pas encore de PDF : compiler d'abord")
prefixe = self.dossier() / f".page-{n}"
r = subprocess.run(["pdftoppm", "-f", str(n), "-l", str(n), "-png", "-r", "80", str(versions[-1]),
str(prefixe)], capture_output=True, text=True)
pages = sorted(self.dossier().glob(f".page-{n}-*.png"))
if r.returncode or not pages:
raise ErreurOutil(f"page {n} introuvable dans {versions[-1].name}")
bloc = bloc_image(pages[0])
for p in pages:
p.unlink()
return [bloc]
+166
View File
@@ -0,0 +1,166 @@
"""Une séance de support : un mail, le support et l'analyste vivants, le dossier de la séance dans API/cases/.
Une séance = un fil (thread) LangSmith : chaque tour de Marc y est une trace, avec les appels à l'API et aux outils.
"""
import os
from datetime import datetime, timezone
from pathlib import Path
from typing import Callable
API = Path(__file__).resolve().parents[1]
CASES = Path(os.environ.get("AIMSIGHT_CASES", API / "cases")).resolve()
TYPES_IMAGE = {"image/png", "image/jpeg", "image/gif", "image/webp"}
def charger_env(chemin: Path = API / ".env") -> None:
"""Les lignes CLE=valeur de API/.env dans l'environnement (sans écraser ce qui y est déjà)."""
if chemin.exists():
for ligne in chemin.read_text().splitlines():
ligne = ligne.strip().removeprefix("export ") # accepte aussi la forme du shell : export CLE=valeur
cle, egal, valeur = ligne.partition("=")
if egal and cle and not cle.startswith("#"):
os.environ.setdefault(cle.strip(), valeur.strip().strip('"').strip("'"))
charger_env() # avant d'importer langsmith, qui garde en cache les variables qu'il a lues (LANGSMITH_ENDPOINT…)
import anthropic # noqa: E402
from langsmith import traceable # noqa: E402
from agent import Agent # noqa: E402
from outils import OUTILS_ANALYSTE, OUTILS_SUPPORT, OUTILS_SUPPORT_MAIL, Boite, bloc_image, section # noqa: E402
# Le savoir toujours présent (les cartes) ; le reste se lit à la demande par lire_document (Marc, 2026-11-05 : le strict
# nécessaire aux agents). Un document absent d'ici est entier dans le prompt ; une liste : seulement ces sections.
CARTES = {"analyste": {"familles.md": None, "regles-de-preuve.md": None,
"carte-des-etiquettes.md": ["Sommaire", "2. Les règles de lecture", "3. Faux amis",
"4. Le contexte des stations"]}}
SORTIES = {"pdf": OUTILS_SUPPORT, "mail": OUTILS_SUPPORT_MAIL} # ce que Marc veut recevoir : les outils du support
SANS = {"mail": {"presentation.md", "modele.typ"}} # le savoir inutile à une sortie
def systeme(nom: str, sortie: str | None = None) -> str:
"""Le prompt de l'agent, puis son savoir dans des balises : les cartes en entier (ou leurs sections), et l'index
de ce qui se lit à la demande ; pour le support, la sortie à la fin (prompts/support-<sortie>.md). Stable d'une
séance à l'autre, donc en cache."""
texte = (API / "prompts" / f"{nom}.md").read_text()
cartes, index = CARTES.get(nom), []
for f in sorted((API / "knowledge" / nom).iterdir()):
if f.name in SANS.get(sortie, ()):
continue
contenu = f.read_text()
if cartes is None or (f.name in cartes and cartes[f.name] is None):
texte += f'\n\n<savoir fichier="{f.name}">\n{contenu}\n</savoir>'
continue
if f.name in cartes:
parties = "\n\n".join(section(contenu, t) for t in cartes[f.name])
texte += f'\n\n<savoir fichier="{f.name}" extrait="{", ".join(cartes[f.name])}">\n{parties}\n</savoir>'
titres = [l.lstrip("#").strip() for l in contenu.splitlines() if l.startswith("## ")]
index.append(f"- `{f.name}` ({len(contenu) // 1000} k car.) : {next((l[2:] for l in contenu.splitlines() if l.startswith('# ')), f.stem)}"
+ (f" ; sections : {' | '.join(titres)}" if titres else ""))
if index:
texte += ("\n\n<index>\nÀ lire à la demande, par lire_document(nom, section) : seulement ce qui sert au cas. "
"Les fiches de la carte des étiquettes se lisent par leur titre (le sommaire ci-dessus).\n"
+ "\n".join(index) + "\n</index>")
if sortie:
texte += "\n\n" + (API / "prompts" / f"{nom}-{sortie}.md").read_text()
return texte
def donnees_par_defaut() -> Path:
return Path(os.environ.get("AIMSIGHT_DATA", API.parent / "data")).resolve()
class Seance:
def __init__(self, mail: str, images: list[tuple[str, bytes]], contexte: str, donnees: Path,
journal: Callable[[dict], None], client=None, sortie: str = "pdf"):
if sortie not in SORTIES:
raise ValueError(f"sortie inconnue : {sortie} ({', '.join(SORTIES)})")
self.mail, self.images, self.contexte, self.journal, self.sortie = mail, images, contexte, journal, sortie
self.id = datetime.now(timezone.utc).strftime("%Y-%m-%d_%H%M%S")
self.dossier = CASES / self.id
self.dossier.mkdir(parents=True)
self.station: str | None = None
self._echanges: list[tuple[str, str]] = [] # ce que Marc a dit à l'analyste, pour le prochain tour du support
client = client or anthropic.Anthropic()
boite = Boite(lambda: self.dossier, lambda: self.station, donnees, self._demander_analyste, self._poser)
self.support = Agent("support", systeme("support", sortie), SORTIES[sortie], boite.executer_support, client, journal,
effort="medium")
self.analyste = Agent("analyste", systeme("analyste"), OUTILS_ANALYSTE, boite.executer_analyste, client,
journal, effort="high")
# --- rappels des outils
def _poser(self, station: str, sujet: str) -> Path:
jour = self.id[:10]
nouveau, i = CASES / f"{jour}_{station}_{sujet}", 2
while nouveau.exists() and nouveau != self.dossier:
nouveau, i = CASES / f"{jour}_{station}_{sujet}-{i}", i + 1
if nouveau != self.dossier:
self.dossier.rename(nouveau)
self.dossier = nouveau
self.station = station
return nouveau
def _demander_analyste(self, message: str) -> str:
r = self.analyste.tour(message, "support")
self._sauver()
return r or "(l'analyste s'est arrêté sur une erreur, voir son fil)"
# --- ce que fait Marc
def _trace(self, nom: str, f, *args):
return traceable(name=nom, metadata={"thread_id": self.id})(f)(*args)
def demarrer(self) -> None:
blocs, lignes = [], []
for i, (type_, donnee) in enumerate(self.images, 1):
if type_ not in TYPES_IMAGE:
continue
nom = f"capture-{i}.{type_.split('/')[1]}"
(self.dossier / nom).write_bytes(donnee)
lignes.append(f"![Capture {i}]({nom})")
blocs.append(bloc_image(self.dossier / nom)) # réduite : une capture 4K serait refusée, et pour toujours
(self.dossier / "demande.md").write_text(
f"# Demande du {self.id[:10]}\n\n## Mail du client\n\n{self.mail}\n\n## Contexte de Marc\n\n"
f"{self.contexte or '(aucun)'}\n\n" + "\n".join(lignes) + "\n")
texte = f"<mail>\n{self.mail}\n</mail>\n<contexte>\n{self.contexte or '(aucun)'}\n</contexte>"
self._trace("séance : le mail", self._tour_support, [{"type": "text", "text": texte}, *blocs])
def parler(self, agent: str, texte: str) -> None:
if agent == "analyste":
self._trace("séance : Marc à l'analyste", self._tour_analyste, texte)
else:
self._trace("séance : Marc au support", self._tour_support, [{"type": "text", "text": texte}])
def _tour_analyste(self, texte: str) -> None:
self._echanges.append((texte, self.analyste.tour(texte, "marc")))
self._sauver()
def _tour_support(self, blocs: list[dict]) -> None:
if self._echanges:
rapport = "\n".join(f"<marc>{q}</marc>\n<analyste>{r}</analyste>" for q, r in self._echanges)
blocs = [{"type": "text", "text": f"<echange_marc_analyste>\n{rapport}\n</echange_marc_analyste>"}, *blocs]
self._echanges = []
self.support.tour(blocs, "marc")
self._sauver()
def _sauver(self) -> None:
self.support.sauver(self.dossier / "support.json")
self.analyste.sauver(self.dossier / "analyste.json")
# --- ce que lit la page
def occupe(self, agent: str) -> bool:
return (self.support if agent == "support" else self.analyste).occupe
def cout(self) -> dict:
return {"support": self.support.cout, "analyste": self.analyste.cout,
"total": self.support.cout + self.analyste.cout}
def derniere_version(self) -> Path | None:
"""v3.pdf, ou mail-v3.json pour une sortie mail."""
motif, prefixe = ("mail-v*.json", "mail-v") if self.sortie == "mail" else ("v*.pdf", "v")
v = sorted(self.dossier.glob(motif), key=lambda p: int(p.stem.removeprefix(prefixe)))
return v[-1] if v else None