Copie des agents de Support-Agent/API (sortie mail)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
cbaab49d3f
commit
5e3faa47b4
49 files changed
+6662
No files matched your search
@@ -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))
|
||||
@@ -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__)
|
||||
@@ -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]
|
||||
@@ -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"")
|
||||
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
|
||||
Reference in new issue
Block a user