123 lines
6.5 KiB
Python
123 lines
6.5 KiB
Python
"""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))
|