"""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}"}] + 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))