La boucle ReAct et le bus de tools

Un « agent », c'est une boucle while

Le copilot conversationnel n'a rien de magique :

async def run_react_turn(messages, tools):
    for _ in range(MAX_ITERATIONS):                       # garde-fou anti-boucle infinie
        response = await llm.stream(messages, tools=tools)
        if response.stop_reason != "tool_use":
            return response                                # le modèle a fini : il répond
        results = await asyncio.gather(*[                  # tools du tour en PARALLÈLE
            execute_tool(call) for call in response.tool_calls
        ])
        messages += [response, tool_results(results)]      # ré-injecter et re-boucler

Le modèle raisonne (« il me faut le stock ») → agit (appelle get_stock) → observe (le résultat revient dans les messages) → recommence, jusqu'à produire une réponse finale. ReAct = Reason + Act. Le MAX_ITERATIONS n'est pas un détail : c'est le circuit breaker de l'agent.

Les tools : un registre déclaré et contraint

Chaque tool est une définition typée (nom, description, schéma d'arguments JSON, permission: read|write), enregistrée dans un ToolBus :

• la whitelist par contexte : l'agent ne reçoit que les tools autorisés pour ce tenant/cette page — pas « tout le SDK » ;
• l'idempotence : chaque exécution porte une clé d'idempotence — un retry ne crée pas deux devis ;
• les tools write passent (par design) par une étape d'approbation humaine — le hook HITL du module 6 ;
• cas remarquable : le tool query_database fait analyser le SQL généré par le LLM avec sqlglot (re-qualification, rejet des écritures) avant exécution — on ne fait jamais confiance au SQL d'un modèle.

L'invariant privacy : model_view vs ui_events

La trouvaille architecturale du projet. Chaque résultat de tool a deux surfaces :

• model_view : ce qui est ré-injecté au LLM — compact (ids, compteurs, statuts). Le modèle n'a PAS besoin des 200 lignes de résultat pour raisonner ;
• ui_events : le payload complet, streamé au front pour affichage — jamais vu par le LLM.

Double gain : les données sensibles (prix détaillés, PII) ne transitent pas par le modèle, et le contexte reste petit (coût, latence, fenêtre). Le LLM raconte, l'UI rend.