La primitive de logique agentique¶
La primitive de logique agentique fournit des agents interchangeables qui traitent les questions avec des degrés de sophistication variables — de la simple réponse en un tour aux boucles d'appel d'outils multi-tours, au raisonnement façon ReAct, à l'exécution de code façon CodeAct, à la décomposition récursive et à la communication avec des agents externes.
La classe abstraite BaseAgent¶
Tous les agents implémentent la classe de base abstraite BaseAgent, qui fournit à la fois le contrat run() et des méthodes concrètes qui évitent de réécrire le même code dans chaque sous-classe :
class BaseAgent(ABC):
agent_id: str
accepts_tools: bool = False # redéfini par ToolUsingAgent
def __init__(
self,
engine: InferenceEngine,
model: str,
*,
bus: Optional[EventBus] = None,
temperature: float = 0.7,
max_tokens: int = 1024,
) -> None: ...
@abstractmethod
def run(
self,
input: str,
context: Optional[AgentContext] = None,
**kwargs: Any,
) -> AgentResult:
"""Exécute l'agent sur *input* et renvoie un AgentResult."""
L'attribut de classe accepts_tools¶
L'attribut de classe accepts_tools (False par défaut) permet à la CLI et au SDK de détecter tout seuls quels agents acceptent qu'on leur passe des outils. Les agents qui posent accepts_tools = True peuvent recevoir --tools en ligne de commande et tools= dans le SDK.
Les méthodes concrètes d'aide¶
BaseAgent fournit cinq méthodes concrètes dont les sous-classes se servent pour ne pas dupliquer la logique commune :
| Méthode | À quoi elle sert |
|---|---|
_emit_turn_start(input) |
Publie AGENT_TURN_START sur le bus d'événements |
_emit_turn_end(**data) |
Publie AGENT_TURN_END sur le bus d'événements |
_build_messages(input, context, *, system_prompt) |
Assemble la liste des messages à partir du prompt système facultatif, du contexte de conversation et de la question de l'utilisateur |
_generate(messages, **extra_kwargs) |
Appelle engine.generate() avec les valeurs par défaut mémorisées (modèle, température, nombre maximum de jetons) |
_max_turns_result(tool_results, turns, content) |
Construit l'AgentResult standard pour le cas où max_turns est dépassé |
_strip_think_tags(text) |
Retire les blocs <think>...</think> de la sortie du modèle (méthode statique) |
Le contrat run()¶
La méthode run() est le point d'entrée unique de toutes les implémentations d'agent. Elle reçoit :
input— le texte de la question de l'utilisateurcontext— unAgentContextfacultatif, avec l'historique de la conversation, les noms d'outils et les résultats de mémoire**kwargs— les paramètres supplémentaires propres à l'implémentation
Elle renvoie un AgentResult contenant le contenu de la réponse, les éventuels résultats d'outils, le nombre de tours effectués et des métadonnées.
Les dataclasses associées¶
@dataclass(slots=True)
class AgentContext:
conversation: Conversation # Messages antérieurs, pour le contexte multi-tours
tools: List[str] # Noms des outils disponibles
memory_results: List[Any] # Résultats de recherche mémoire récupérés d'avance
metadata: Dict[str, Any] # Paires clé-valeur arbitraires
@dataclass(slots=True)
class AgentResult:
content: str # Le texte de la réponse de l'agent
tool_results: List[ToolResult] # Résultats des invocations d'outils
turns: int # Nombre de tours d'inférence effectués
metadata: Dict[str, Any] # Métadonnées arbitraires
ToolUsingAgent¶
ToolUsingAgent est une classe de base intermédiaire pour les agents qui acceptent et utilisent des outils. Elle étend BaseAgent avec :
accepts_tools = True— active l'introspection des outils par la CLI et le SDKToolExecutor— initialisé depuis la liste d'outils fournie, il prend en charge l'aiguillage avec l'analyse des arguments JSON, le suivi de la latence et l'intégration au bus d'événementsmax_turns— la limite d'itérations de la boucle, configurable (10 par défaut)
class ToolUsingAgent(BaseAgent):
accepts_tools: bool = True
def __init__(
self,
engine: InferenceEngine,
model: str,
*,
tools: Optional[List[BaseTool]] = None,
bus: Optional[EventBus] = None,
max_turns: int = 10,
temperature: float = 0.7,
max_tokens: int = 1024,
) -> None: ...
Tous les agents qui utilisent des outils (OrchestratorAgent, NativeReActAgent, NativeOpenHandsAgent, RLMAgent) étendent cette classe.
Les agents qui contournent ToolUsingAgent
Certains agents étendent BaseAgent directement et posent accepts_tools = False : SimpleAgent (un seul tour, pas d'outils), OpenHandsAgent (la gestion des outils revient à openhands-sdk) et ClaudeCodeAgent (les outils sont gérés par le Claude Agent SDK). SandboxedAgent étend lui aussi BaseAgent directement, parce qu'il enveloppe un autre agent au lieu d'appeler des outils lui-même.
Choisir un agent¶
Commence ici. Prends l'agent le plus simple qui fasse le travail — les agents simples sont plus rapides, consomment moins de jetons et se déboguent plus facilement. Ne va chercher un agent plus complexe que si la tâche l'exige.
| Cas d'usage | Agent | Pourquoi |
|---|---|---|
| Question-réponse simple, en un tour | simple |
Aucun surcoût, un seul appel d'inférence |
| Plusieurs étapes avec des outils (calculatrice, recherche, fichiers) | orchestrator |
Boucle d'appel de fonctions, la plus compatible avec les modèles au format OpenAI |
| Chaînes de raisonnement explicites | native_react |
Boucle Pensée-Action-Observation fondée sur ReAct (Yao et coll., 2023) ; les traces de raisonnement sont visibles et déboguables |
| Génération et exécution de code | native_openhands |
Motif CodeAct inspiré d'OpenHands (Wang et coll., 2024) ; génère et exécute du Python en ligne |
| Longs documents, décomposition récursive | rlm |
Range le contexte dans un REPL persistant, décompose par des appels récursifs à un sous-modèle |
| Entrées non fiables | sandboxed enveloppant n'importe quel agent |
Isolation par conteneur, réseau coupé et listes blanches de montages |
Conseil général : orchestrator est le choix par défaut pour la plupart des tâches qui utilisent des outils. Prends native_react quand tu veux voir les traces de raisonnement (pour déboguer ou auditer le comportement de l'agent, par exemple). Prends native_openhands quand la tâche consiste à écrire et à lancer du code. Prends rlm quand le contexte est trop long pour tenir dans une seule fenêtre de prompt.
Les implémentations d'agents¶
SimpleAgent¶
Clé de registre : simple
L'implémentation la plus simple — une chaîne question-réponse en un seul tour, sans outils. Étend BaseAgent directement (n'accepte pas d'outils).
graph LR
Q["Question de l'utilisateur"] --> M["Construire les messages"]
M --> E["Engine.generate()"]
E --> R["AgentResult"]
Comment ça marche :
- Appelle
_emit_turn_start()pour publierAGENT_TURN_STARTsur le bus d'événements - Appelle
_build_messages()pour assembler la liste des messages à partir du contexte de conversation et de la question de l'utilisateur - Appelle
_generate()pour invoquer le moteur avec les valeurs par défaut mémorisées - Appelle
_emit_turn_end()et renvoie unAgentResultavecturns=1
from diapason.agents.simple import SimpleAgent
agent = SimpleAgent(engine, model="qwen3:8b", bus=bus)
result = agent.run("Quelle est la capitale de la France ?")
print(result.content) # « La capitale de la France est Paris. »
OrchestratorAgent¶
Clé de registre : orchestrator
Un agent multi-tours qui met en œuvre une boucle d'appel d'outils. Étend ToolUsingAgent. Le modèle peut demander des invocations d'outils, et les résultats lui sont renvoyés pour la suite du traitement, jusqu'à ce qu'il produise une réponse textuelle finale.
Deux modes sont gérés :
function_calling(par défaut) — utilise le format d'appel de fonctions d'OpenAI, viaToolExecutor.get_openai_tools()structured— utilise le format de sortie structurée, pour les modèles qui le prennent en charge
graph TD
Q["Question de l'utilisateur"] --> BUILD["Construire les messages<br/>+ les définitions d'outils"]
BUILD --> GEN["Engine.generate()<br/>avec les outils"]
GEN --> CHECK{"Des appels d'outils<br/>dans la réponse ?"}
CHECK -->|Non| DONE["Rendre la réponse finale"]
CHECK -->|Oui| EXEC["Exécuter chaque outil<br/>via ToolExecutor"]
EXEC --> APPEND["Ajouter les résultats d'outils<br/>aux messages"]
APPEND --> MAXCHECK{"Nombre de tours<br/>dépassé ?"}
MAXCHECK -->|Non| GEN
MAXCHECK -->|Oui| TIMEOUT["Rendre avec<br/>max_turns_exceeded"]
Comment ça marche :
- Construit les messages initiaux à partir du contexte et de la question de l'utilisateur
- Convertit les outils disponibles au format d'appel de fonctions d'OpenAI, via
ToolExecutor.get_openai_tools() - Entre dans une boucle (jusqu'à
max_turnsitérations) :- Appelle
engine.generate()avec les messages et les définitions d'outils - Si la réponse contient des
tool_calls, exécute chaque outil et ajoute les résultats comme messagesTOOL - S'il n'y a aucun
tool_calls, rend le contenu comme réponse finale
- Appelle
- Si
max_turnsest dépassé, rend le dernier contenu ou un message d'avertissement
from diapason.agents.orchestrator import OrchestratorAgent
from diapason.tools.calculator import CalculatorTool
from diapason.tools.think import ThinkTool
agent = OrchestratorAgent(
engine,
model="qwen3:8b",
tools=[CalculatorTool(), ThinkTool()],
bus=bus,
max_turns=10,
)
result = agent.run("Combien font 2^10 + 3^5 ?")
# L'agent peut appeler l'outil calculatrice, obtenir « 1267 », puis répondre
NativeReActAgent¶
Clé de registre : native_react (alias : react)
Un agent ReAct (Reasoning + Acting) qui met en œuvre une boucle Pensée-Action-Observation. Étend ToolUsingAgent. Le modèle est invité à produire du texte structuré avec les champs Thought:, Action:, Action Input: et Final Answer:, que l'agent analyse pour piloter l'exécution des outils.
graph TD
Q["Question de l'utilisateur"] --> SYS["Construire le prompt système<br/>avec les descriptions d'outils"]
SYS --> GEN["Générer la réponse"]
GEN --> PARSE["Analyser la sortie ReAct"]
PARSE --> FINAL{"Final Answer ?"}
FINAL -->|Oui| DONE["Rendre la réponse"]
FINAL -->|Non| ACTION{"Une Action ?"}
ACTION -->|Non| DONE2["Rendre le contenu tel quel"]
ACTION -->|Oui| EXEC["Exécuter l'outil<br/>via ToolExecutor<br/>(sans tenir compte de la casse)"]
EXEC --> OBS["Ajouter l'Observation"]
OBS --> MAXCHECK{"Nombre de tours<br/>dépassé ?"}
MAXCHECK -->|Non| GEN
MAXCHECK -->|Oui| TIMEOUT["Rendre max_turns_result"]
Comment ça marche :
- Construit un prompt système avec des descriptions d'outils enrichies, via
build_tool_descriptions(). L'analyse ne tient pas compte de la casse. - Génère une réponse et analyse la sortie structurée ReAct
- Si un
Final Answer:est trouvé, le rend - Si une
Action:est trouvée, exécute l'outil et lui renvoie le résultat sous forme d'Observation: - Boucle jusqu'à ce qu'une réponse finale soit produite ou que
max_turnssoit dépassé
Compatibilité ascendante
L'ancien chemin d'import from diapason.agents.react import ReActAgent fonctionne toujours, par une passerelle de compatibilité. L'alias de registre "react" pointe lui aussi vers NativeReActAgent.
from diapason.agents.native_react import NativeReActAgent
agent = NativeReActAgent(
engine,
model="qwen3:8b",
tools=[CalculatorTool(), ThinkTool()],
max_turns=10,
)
result = agent.run("Quelle est la racine carrée de 256 ?")
NativeOpenHandsAgent¶
Clé de registre : native_openhands
Un agent façon CodeAct, qui génère et exécute du code Python. Étend ToolUsingAgent. Il peut aussi invoquer des outils par une sortie structurée Action: / Action Input:. Les URL présentes dans l'entrée sont récupérées d'avance et insérées telles quelles pour le modèle.
Comment ça marche :
- Construit un prompt système détaillé, avec des descriptions d'outils enrichies (via le constructeur partagé
build_tool_descriptions()) et les consignes d'exécution de code - Récupère d'avance les URL présentes dans l'entrée de l'utilisateur et en insère le contenu directement
- À chaque tour :
- Génère une réponse et retire les balises
<think> - Si un bloc de code
\``pythonest trouvé, l'exécute viacode_interpreter` - Si un
Action:/Action Input:est trouvé, aiguille vers l'outil - Si ni l'un ni l'autre n'est trouvé, rend le contenu comme réponse finale
- Génère une réponse et retire les balises
- Gère le dépassement de la fenêtre de contexte par une troncature automatique
from diapason.agents.native_openhands import NativeOpenHandsAgent
agent = NativeOpenHandsAgent(
engine,
model="qwen3:8b",
tools=[CalculatorTool(), WebSearchTool()],
max_turns=3,
max_tokens=2048,
)
result = agent.run("Résume https://example.com/article")
RLMAgent¶
Clé de registre : rlm
Un agent à modèle de langue récursif, fondé sur l'article RLM. Plutôt que de passer un long contexte directement dans le prompt du modèle, RLM le range dans une variable Python d'un REPL persistant. Un « modèle racine » écrit du code Python pour inspecter, décomposer et traiter le contexte à l'aide d'appels récursifs à un sous-modèle, via llm_query() et llm_batch(). Étend ToolUsingAgent.
graph TD
Q["Question de l'utilisateur<br/>+ contexte"] --> REPL["Créer un REPL persistant<br/>(le contexte devient une variable)"]
REPL --> GEN["Générer du code"]
GEN --> CODE{"Un bloc de code<br/>trouvé ?"}
CODE -->|Non| DONE["Rendre le contenu<br/>comme réponse finale"]
CODE -->|Oui| EXEC["Exécuter dans le REPL"]
EXEC --> TERM{"FINAL() appelé ?"}
TERM -->|Oui| RESULT["Rendre la réponse finale"]
TERM -->|Non| FEED["Renvoyer la sortie<br/>comme message utilisateur"]
FEED --> MAXCHECK{"Nombre de tours<br/>dépassé ?"}
MAXCHECK -->|Non| GEN
MAXCHECK -->|Oui| TIMEOUT["Rendre max_turns_result"]
Comment ça marche :
- Crée un REPL persistant avec les rappels
llm_query()etllm_batch(). Les descriptions d'outils y sont injectées par le constructeur partagébuild_tool_descriptions()quand des outils sont fournis. - Injecte dans le REPL, sous forme de variable, le contexte venu des métadonnées de l'
AgentContextou des résultats de mémoire - Génère du code et l'exécute dans le REPL
- Si
FINAL(value)ouFINAL_VAR("name")est appelé, rend la réponse finale - Si aucun bloc de code n'est trouvé, traite le contenu comme une réponse directe
L'agent accepte des paramètres configurables pour le sous-modèle des appels récursifs :
| Paramètre | Défaut | Description |
|---|---|---|
sub_model |
le même que model |
Modèle des appels au sous-modèle |
sub_temperature |
0.3 |
Température des appels au sous-modèle |
sub_max_tokens |
1024 |
Nombre maximum de jetons des appels au sous-modèle |
max_output_chars |
10000 |
Nombre maximum de caractères en sortie du REPL |
system_prompt |
RLM_SYSTEM_PROMPT |
Remplace le prompt système |
from diapason.agents.rlm import RLMAgent
agent = RLMAgent(
engine,
model="qwen3:8b",
max_turns=10,
sub_model="qwen3:1.7b", # un modèle plus petit pour les sous-questions
sub_temperature=0.3,
)
result = agent.run("Résume ce document", context=ctx)
OpenHandsAgent (SDK)¶
Clé de registre : openhands
Une fine enveloppe autour du vrai paquet openhands-sdk, pour les tâches de développement logiciel pilotées par l'IA. Étend BaseAgent directement (n'utilise pas ToolUsingAgent, puisque la gestion des outils revient au SDK).
Dépendance facultative
Cet agent réclame le paquet openhands-sdk (uv sync --extra openhands). Le SDK exige Python 3.12+.
Comment ça marche :
- Importe
openhands.sdkà l'exécution (import paresseux) - Crée un LLM, un Agent et une Conversation depuis le SDK
- Envoie l'entrée de l'utilisateur comme message et fait tourner la conversation
- Extrait le contenu du message final de la conversation
from diapason.agents.openhands import OpenHandsAgent
agent = OpenHandsAgent(
engine,
model="gpt-4",
workspace="/path/to/project",
api_key="sk-...",
)
result = agent.run("Corrige le test qui échoue dans test_utils.py")
ClaudeCodeAgent¶
Clé de registre : claude_code
Enveloppe le SDK @anthropic-ai/claude-code par un pont en sous-processus Node.js, livré avec lui. Contrairement à tous les autres agents, l'inférence est entièrement prise en charge par le Claude Agent SDK — le moteur d'inférence de Diapason n'est pas utilisé. ClaudeCodeAgent est donc un véritable agent externe, dans le même esprit qu'OpenHandsAgent, mais mis en œuvre par un sous-processus plutôt que par un SDK Python importable.
graph LR
Q["Question de l'utilisateur"] --> PY["Python : construire la requête JSON"]
PY --> SPAWN["Lancer : node dist/index.js"]
SPAWN --> NODE["Exécuteur Node.js<br/>SDK @anthropic-ai/claude-code"]
NODE --> SDK["Claude Agent SDK<br/>(inférence dans le nuage)"]
SDK --> NODE
NODE --> JSON["JSON délimité par des sentinelles<br/>sur la sortie standard"]
JSON --> PARSE["Python : analyser la sortie"]
PARSE --> R["AgentResult"]
Comment ça marche :
- Au premier appel, copie le
claude_code_runner/livré avec lui vers~/.diapason/claude_code_runner/et lancenpm install --productionsinode_modulesest absent - Construit une requête JSON avec
prompt,api_key,workspace,allowed_tools,system_promptetsession_id - Lance
node dist/index.jset écrit la requête sur son entrée standard - Lit la sortie standard et en extrait la charge JSON comprise entre les sentinelles
---DIAPASON_OUTPUT_START---et---DIAPASON_OUTPUT_END--- - À défaut de sentinelles, traite toute la sortie standard comme du contenu en texte brut
Node.js 22+ obligatoire
ClaudeCodeAgent lève RuntimeError au moment du run() si node est introuvable dans le PATH. Une variable d'environnement ANTHROPIC_API_KEY est nécessaire pour que le Claude Agent SDK s'authentifie.
from diapason.agents.claude_code import ClaudeCodeAgent
agent = ClaudeCodeAgent(
engine=None, # inutilisé
model="", # inutilisé
workspace="/path/to/project",
timeout=120,
)
result = agent.run("Ajoute des annotations de type à toutes les fonctions de utils.py")
SandboxedAgent et ContainerRunner¶
SandboxedAgent et ContainerRunner mettent en œuvre ensemble l'exécution d'agents isolée par conteneur, sur le modèle d'enveloppe de GuardrailsEngine. SandboxedAgent enveloppe n'importe quel BaseAgent et délègue l'exécution à un conteneur Docker (ou Podman) piloté par ContainerRunner.
graph LR
Q["Question de l'utilisateur"] --> SA["SandboxedAgent.run()"]
SA --> CR["ContainerRunner.run()"]
CR --> VALIDATE["Valider les montages<br/>face à la liste blanche"]
VALIDATE --> DOCKER["docker run --rm<br/>--network none<br/>-i image"]
DOCKER --> STDIN["Écrire la charge JSON<br/>sur l'entrée standard"]
STDIN --> CONTAINER["Conteneur : lancer l'agent,<br/>écrire la sortie sur stdout"]
CONTAINER --> PARSE["Analyser le JSON délimité<br/>par des sentinelles"]
PARSE --> R["AgentResult"]
ContainerRunner gère tout le cycle de vie du conteneur :
- Valide les chemins de montage face à une
MountAllowlistavant de démarrer le conteneur (lèveValueErrorpour un chemin bloqué ou hors de la racine) - Construit
docker run --rm --network none -i <image>avec les montages liés en lecture seule, une fois validés - Envoie une charge JSON sur l'entrée standard du conteneur (le prompt, l'identifiant de l'agent, le modèle et d'éventuels secrets)
- Lit la sortie standard et analyse le JSON délimité par des sentinelles
- En cas de dépassement du délai, tue le conteneur de force par
docker rm -f cleanup_orphans()supprime les conteneurs restés en plan portant l'étiquettediapason-sandbox=true
La sécurité des montages (sandbox/mount_security.py) impose deux contrôles indépendants sur chaque chemin monté :
- Motifs bloqués : les composants du chemin sont confrontés à
DEFAULT_BLOCKED_PATTERNS(.ssh,.env,*.pem,*.key, configurations de services dans le nuage, etc.). Une correspondance lèveValueError. - Racines autorisées : si des
rootssont configurées dans la liste blanche, le chemin résolu doit se trouver sous l'une d'elles. Une listerootsvide autorise n'importe quel chemin non bloqué.
from diapason.sandbox import ContainerRunner, SandboxedAgent
runner = ContainerRunner(
image="diapason-sandbox:latest",
timeout=60,
runtime="docker",
)
# Enveloppe n'importe quel BaseAgent
inner = SimpleAgent(engine, model="qwen3:8b")
sandboxed = SandboxedAgent(
agent=inner,
runner=runner,
mounts=["/home/user/data"],
)
result = sandboxed.run("Résume les rapports dans /home/user/data")
accepts_tools = False
SandboxedAgent n'accepte pas d'outils par --tools ni par tools=. L'appel d'outils à l'intérieur du bac à sable revient à l'agent intérieur qu'il enveloppe.
L'intégration au système d'outils¶
Toutes les sous-classes de ToolUsingAgent passent par le ToolExecutor pour aiguiller les appels d'outils. Le système d'outils est bâti sur la classe abstraite BaseTool :
class BaseTool(ABC):
tool_id: str
@property
@abstractmethod
def spec(self) -> ToolSpec:
"""Renvoie la spécification de l'outil."""
@abstractmethod
def execute(self, **params: Any) -> ToolResult:
"""Exécute l'outil avec les paramètres donnés."""
def to_openai_function(self) -> Dict[str, Any]:
"""Convertit au format d'appel de fonctions d'OpenAI."""
Les outils intégrés¶
| Outil | Clé de registre | Description |
|---|---|---|
CalculatorTool |
calculator |
Évaluateur d'expressions sûr, fondé sur l'AST |
ThinkTool |
think |
Brouillon de raisonnement (rend l'entrée telle quelle) |
RetrievalTool |
retrieval |
Recherche en mémoire, par un moteur de mémoire |
LLMTool |
llm |
Appels à un sous-modèle (interroger un autre modèle) |
FileReadTool |
file_read |
Lecture de fichier sûre, avec validation du chemin |
ToolExecutor¶
Le ToolExecutor prend en charge l'aiguillage des outils, avec l'analyse des arguments JSON, le suivi de la latence et l'intégration au bus d'événements :
class ToolExecutor:
def __init__(self, tools: List[BaseTool], bus: Optional[EventBus] = None):
self._tools = {t.spec.name: t for t in tools}
self._bus = bus
def execute(self, tool_call: ToolCall) -> ToolResult:
"""Analyse les arguments, aiguille vers l'outil, mesure la latence, émet les événements."""
def get_openai_tools(self) -> List[Dict[str, Any]]:
"""Rend les outils au format d'appel de fonctions d'OpenAI."""
Pour chaque appel d'outil :
- Cherche l'outil par son nom
- Analyse la chaîne d'arguments JSON
- Publie
TOOL_CALL_STARTsur le bus d'événements - Exécute l'outil en le chronométrant
- Publie
TOOL_CALL_ENDavec le statut de réussite et la latence - Rend le
ToolResult
L'intégration au bus d'événements¶
Tous les agents s'intègrent à l'EventBus, pour la télémétrie et la collecte de traces :
| Événement | Publié par | Quand |
|---|---|---|
AGENT_TURN_START |
Tous les agents (par la méthode _emit_turn_start) |
Avant de commencer à traiter la question |
AGENT_TURN_END |
Tous les agents (par la méthode _emit_turn_end) |
Après avoir produit une réponse |
TOOL_CALL_START |
ToolExecutor (toutes les sous-classes de ToolUsingAgent) |
Avant d'exécuter un outil |
TOOL_CALL_END |
ToolExecutor (toutes les sous-classes de ToolUsingAgent) |
Après avoir exécuté un outil |
Les événements d'inférence
Les événements INFERENCE_START et INFERENCE_END sont publiés par l'enveloppe InstrumentedEngine (dans telemetry/instrumented_engine.py), pas par les agents eux-mêmes. La télémétrie reste ainsi facultative et transparente pour le code des agents.
Ces événements sont consommés par le TelemetryStore (pour les métriques) et le TraceCollector (pour les traces d'interaction).
L'enregistrement des agents¶
Les agents s'enregistrent par le décorateur @AgentRegistry.register("nom") :
from diapason.core.registry import AgentRegistry
from diapason.agents._stubs import BaseAgent
@AgentRegistry.register("my-agent")
class MyAgent(BaseAgent):
agent_id = "my-agent"
def run(self, input, context=None, **kwargs):
...
Pour lister tous les agents enregistrés :
from diapason.core.registry import AgentRegistry
print(AgentRegistry.keys())
# ("simple", "orchestrator", "native_react", "react", "native_openhands", "rlm", "openhands")
Pour instancier un agent à partir de sa clé :