Files
Support-Agent/API/support/agent.py
T
maximeandClaude Opus 5.5 8ba75b92fa API: support page with two Claude API clients, support and analyst (D-133)
Self-contained sub-project API/: a local support page where Marc pastes a
client's mail; a support agent and an analyst agent stay alive for the session
and produce a slide PDF that answers the client's question. Tools, detectors,
knowledge and Typst brand are copied (API/PROVENANCE.md). First real case:
Crissier (LENZSPITZE), workflow validated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 12:58:39 +01:00

124 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))