agentic-api 2.0.31 → 2.0.491

package/dist/src/agents/simulator.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentSimulator = void 0;
 const simulator_executor_1 = require("./simulator.executor");
-const simulator_prompts_1 = require("./simulator.prompts");
 class AgentSimulator {
     constructor(config) {
         this.config = config;
@@ -11,56 +10,98 @@ class AgentSimulator {
     /**
      * Exécuter la simulation complète
      *
+     * Architecture :
+     * - Le scénario (Personnalité, Question, Objectifs, Format JSON) est injecté UNE SEULE FOIS
+     *   dans les instructions du simulateur au moment de l'initialisation (AVANT la boucle).
+     *
      * Format de la query passée à l'agent testé :
-     * - Message initial : réponse du simulateur après analyse du scenario
+     * - Message initial : query fournie par l'utilisateur
      * - Messages suivants : réponse conversationnelle du simulateur (sans tags d'évaluation)
      *
      * Format de la query passée au simulateur :
-     * - Message initial : buildSimulatorQuery(scenario) - format structuré avec SIMULATION SCENARIO
-     * - Messages suivants : réponse de l'agent testé (pour évaluation et réaction)
+     * - Instructions système : scénario complet intégré via GENERIC_SIMULATOR_PROMPT
+     * - Tous les messages : réponse directe de l'agent testé (agentResponse)
      */
     async executeSimulation(options) {
-        const context = await this.executor.initializeContexts();
+        // ✅ Initialiser les contextes avec le scenario complet
+        const context = await this.executor.initializeContexts(options.scenario);
+        const allMessages = [];
+        let lastAgentMessage = '';
+        let exchangeCounter = 0; // Compteur d'échanges (user+assistant)
         try {
-            // Construire la query formatée avec buildSimulatorQuery() 
-            // Les instructions supplémentaires sont déjà intégrées dans le constructeur de l'executor
-            const scenarioQuery = (0, simulator_prompts_1.buildSimulatorQuery)(options.scenario);
-            // Générer le message initial du simulateur avec le scénario
-            let currentUserQuery = await this.executor.executeSimulator(context, scenarioQuery);
-            // Callback pour message initial du simulateur
+            // ✅ Pour le premier message, utiliser directement la query fournie
+            // Le simulateur ne doit PAS reformuler la question initiale
+            const initialQuery = options.query || options.scenario.testQuery || '';
+            let currentUserQuery = initialQuery;
+            // Stocker le message initial (query brute de l'utilisateur)
+            const initialMsg = { content: currentUserQuery, role: 'user' };
+            allMessages.push(initialMsg);
             if (options.onMessage) {
-                options.onMessage({ content: currentUserQuery, role: 'user' });
+                options.onMessage(initialMsg);
             }
-            // Boucle de conversation
-            for (let i = 0; i < options.maxExchanges; i++) {
+            // Boucle de conversation - maxExchanges = nombre de paires (user+assistant)
+            while (exchangeCounter < options.maxExchanges) {
                 // Agent testé répond et retourne sa réponse
+                // La première fois la query est options.query, les fois suivantes c'est la réponse conversationnelle du simulateur
                 const agentResponse = await this.executor.executeAgent(context, currentUserQuery);
-                // Callback pour réponse de l'agent
+                lastAgentMessage = agentResponse;
+                // Stocker la réponse de l'agent
+                const agentMsg = { content: agentResponse, role: 'assistant' };
+                allMessages.push(agentMsg);
                 if (options.onMessage) {
-                    options.onMessage({ content: agentResponse, role: 'assistant' });
+                    options.onMessage(agentMsg);
                 }
-                // Simulateur évalue et répond
+                // Incrémenter le compteur après la réponse de l'agent (assistant)
+                exchangeCounter++;
+                // ✅ Passer directement agentResponse au simulateur (scénario déjà dans les instructions)
                 const simulatorResult = await this.executor.executeSimulator(context, agentResponse);
+                // console.log('---- DBG simulatorResult',simulatorResult);
                 // Vérifier si terminé
                 if (this.isSimulationComplete(simulatorResult)) {
-                    const parsed = this.parseSimulationResult(simulatorResult, options.scenario.testResult, context);
+                    const expectedFormat = options.scenario.result || options.scenario.testResult || '{"success": boolean, "error": string}';
+                    const parsed = this.parseSimulationResult(simulatorResult, expectedFormat, context);
                     this.lastExecution = context.lastExecution;
+                    // Validation des tools si expectedTool est fourni
+                    if (options.expectedTool) {
+                        const validation = this.validateExpectedTools(options.expectedTool);
+                        if (!validation.passed) {
+                            parsed.success = false;
+                            parsed.error = validation.errors.join('; ');
+                            parsed.toolValidation = validation;
+                        }
+                    }
+                    // Ajouter l'historique des messages au résultat
                     return {
                         ...parsed,
                         execution: context.lastExecution,
-                        exchangeCount: context.exchangeCount
+                        exchangeCount: exchangeCounter, // Utiliser notre compteur d'échanges
+                        messages: allMessages
                     };
                 }
                 currentUserQuery = this.extractConversationalPart(simulatorResult);
-                // Callback pour réponse du simulateur (si pas terminé)
-                if (options.onMessage && currentUserQuery) {
-                    options.onMessage({ content: currentUserQuery, role: 'user' });
+                // Stocker la réponse du simulateur (si pas terminé)
+                if (currentUserQuery) {
+                    const simulatorMsg = { content: currentUserQuery, role: 'user' };
+                    allMessages.push(simulatorMsg);
+                    if (options.onMessage) {
+                        options.onMessage(simulatorMsg);
+                    }
                 }
             }
             // Timeout - générer rapport final
-            const timeout = await this.generateTimeoutReport(context, options.scenario.testResult);
+            const expectedFormat = options.scenario.result || options.scenario.testResult || '{"success": boolean, "error": string}';
+            const timeout = await this.generateTimeoutReport(context, expectedFormat);
             this.lastExecution = context.lastExecution;
-            return { ...timeout, exchangeCount: context.exchangeCount };
+            // Validation des tools même en cas de timeout
+            if (options.expectedTool) {
+                const validation = this.validateExpectedTools(options.expectedTool);
+                if (!validation.passed) {
+                    timeout.success = false;
+                    timeout.error = validation.errors.join('; ');
+                    timeout.toolValidation = validation;
+                }
+            }
+            return { ...timeout, exchangeCount: exchangeCounter, messages: allMessages }; // Utiliser notre compteur      
         }
         catch (error) {
             this.lastExecution = context.lastExecution;
@@ -69,7 +110,8 @@ class AgentSimulator {
                 message: '',
                 error: `Erreur d'exécution: ${error.message || error}`,
                 execution: context.lastExecution,
-                exchangeCount: context.exchangeCount
+                exchangeCount: exchangeCounter, // Utiliser notre compteur
+                messages: allMessages
             };
         }
     }
@@ -112,8 +154,8 @@ class AgentSimulator {
             startQuery: result.execution?.startQuery,
             actions: result.execution?.actions?.map((elem) => elem.action) || [],
             lastMessage: result.execution?.lastMessage,
-            usage: result.execution?.usage,
-            moreThinkin: result.execution?.moreThinkin
+            usage: result.execution?.usage
+            // moreThinkin removed (obsolete)
         };
         const execution = {
             ...result.execution,
@@ -122,17 +164,17 @@ class AgentSimulator {
         return { summary, execution };
     }
     isSimulationComplete(response) {
-        return response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]');
+        return response.includes('[DONE]') || response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]');
     }
     parseSimulationResult(response, expectedFormat, context) {
         // Le simulateur produit directement le résultat et rapport
         // Parsing pour détecter la fin et extraire le contenu JSON
-        // Détecter [SIMULATION_COMPLETE] ou [TERMINE]
-        if (response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]')) {
+        // Détecter [DONE], [SIMULATION_COMPLETE] ou [TERMINE]
+        if (response.includes('[DONE]') || response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]')) {
             // Extraire le contenu après le tag
-            const match = response.match(/\[SIMULATION_COMPLETE\]\s*\n?([\s\S]*)/);
+            const match = response.match(/\[(DONE|SIMULATION_COMPLETE|TERMINE)\]\s*\n?([\s\S]*)/);
             if (match) {
-                const resultContent = match[1].trim();
+                const resultContent = match[2].trim();
                 // Essayer de parser comme JSON d'abord
                 try {
                     const jsonResult = JSON.parse(resultContent);
@@ -141,7 +183,8 @@ class AgentSimulator {
                         message: jsonResult.description || resultContent,
                         error: jsonResult.error || '',
                         execution: context.lastExecution,
-                        exchangeCount: context.exchangeCount
+                        exchangeCount: context.exchangeCount,
+                        messages: [] // Sera rempli par executeSimulation
                     };
                 }
                 catch (jsonError) {
@@ -159,7 +202,8 @@ class AgentSimulator {
                         message: description,
                         error: errorMatch ? errorMatch[1].trim() : '',
                         execution: context.lastExecution,
-                        exchangeCount: context.exchangeCount
+                        exchangeCount: context.exchangeCount,
+                        messages: [] // Sera rempli par executeSimulation
                     };
                 }
             }
@@ -169,7 +213,8 @@ class AgentSimulator {
                 message: response,
                 error: '',
                 execution: context.lastExecution,
-                exchangeCount: context.exchangeCount
+                exchangeCount: context.exchangeCount,
+                messages: [] // Sera rempli par executeSimulation
             };
         }
         // Si pas de tag de fin détecté
@@ -178,28 +223,69 @@ class AgentSimulator {
             message: response,
             error: 'Simulation non terminée',
             execution: context.lastExecution,
-            exchangeCount: context.exchangeCount
+            exchangeCount: context.exchangeCount,
+            messages: [] // Sera rempli par executeSimulation
         };
     }
     extractConversationalPart(response) {
-        // Extraire la partie conversationnelle avant les tags d'évaluation
-        const tagIndex = response.search(/\[(SIMULATION_COMPLETE|TERMINE|BUG_)/);
-        return tagIndex !== -1 ? response.substring(0, tagIndex).trim() : response;
+        // Extraire la partie conversationnelle avant les tags d'évaluation ou d'observation
+        // Filtrer tous les tags système : [DONE], [OBSERVATEUR SILENCIEUX], [À NOTER], etc.
+        const tagIndex = response.search(/\[(DONE|SIMULATION_COMPLETE|TERMINE|BUG_|OBSERVATEUR|À NOTER|NOTE|ANALYSE)/i);
+        if (tagIndex !== -1) {
+            return response.substring(0, tagIndex).trim();
+        }
+        // Filtrer aussi les lignes qui commencent par "Agent :" ou "[...]" (méta-commentaires)
+        const lines = response.split('\n');
+        const conversationalLines = lines.filter(line => {
+            const trimmed = line.trim();
+            // Exclure les lignes qui sont des méta-commentaires
+            if (trimmed.startsWith('Agent :') ||
+                trimmed.startsWith('[') && trimmed.includes(']') && !trimmed.match(/^\[[^\]]{1,3}\]/)) {
+                return false;
+            }
+            return true;
+        });
+        return conversationalLines.join('\n').trim();
     }
     /**
      * Générer le rapport final en cas de timeout
      */
     async generateTimeoutReport(context, expectedFormat) {
         const reportQuery = `
-    La simulation a atteint la limite d'échanges sans conclusion.
+    La conversation a atteint la limite d'échanges sans conclusion.
     Génère maintenant ton rapport final au format:
-    [SIMULATION_COMPLETE]
+    [DONE]
     success: false  
     error: Limite d'échanges atteinte
-    description: Simulation interrompue - timeout
+    description: Conversation interrompue - timeout
     `;
         const finalResult = await this.executor.executeSimulator(context, reportQuery);
         return this.parseSimulationResult(finalResult, expectedFormat, context);
     }
+    /**
+     * Valider que les outils attendus ont été appelés le bon nombre de fois
+     */
+    validateExpectedTools(expected) {
+        const errors = [];
+        for (const [toolName, constraint] of Object.entries(expected)) {
+            const { count } = this.executionActionCount(toolName);
+            // Validation equal (égalité exacte)
+            if (constraint.equal !== undefined && count !== constraint.equal) {
+                errors.push(`Tool '${toolName}': expected equal to ${constraint.equal}, got ${count}`);
+            }
+            // Validation gte (greater than or equal - supérieur ou égal)
+            if (constraint.gte !== undefined && count < constraint.gte) {
+                errors.push(`Tool '${toolName}': expected >= ${constraint.gte}, got ${count}`);
+            }
+            // Validation lte (less than or equal - inférieur ou égal)
+            if (constraint.lte !== undefined && count > constraint.lte) {
+                errors.push(`Tool '${toolName}': expected <= ${constraint.lte}, got ${count}`);
+            }
+        }
+        return {
+            passed: errors.length === 0,
+            errors
+        };
+    }
 }
 exports.AgentSimulator = AgentSimulator;

package/dist/src/agents/simulator.prompts.d.ts

@@ -1,16 +1,18 @@
 import { SimulationScenario } from "./simulator.types";
 /**
- * Prompt de simulateur générique basé sur ClientSimulator
- * COPIÉ et ADAPTÉ depuis agentInstructionModules.ClientSimulator
+ * Génère le prompt du simulateur générique avec le scenario intégré
+ *
+ * Basé sur ClientSimulator avec Mirror Agent Model
+ * Intègre directement les valeurs du scenario dans des tags XML
+ *
+ * @param scenario - Scenario de simulation avec persona, goals, result
+ * @param instructionEx - Instructions additionnelles spécifiques à l'agent (ajoutées à la fin)
+ * @returns Prompt complet avec plan de simulation intégré
  */
-export declare const GENERIC_SIMULATOR_PROMPT = "\n## R\u00D4LE - SIMULATEUR VALIDATEUR\nTu es un **DOUBLE AGENT** qui joue 2 r\u00F4les simultan\u00E9s :\n1. **Utilisateur r\u00E9el** qui teste un agent conversationnel\n2. **SIMULATEUR: Validateur actif** qui surveille en temps r\u00E9el les performances\n\n# \uD83D\uDEA8 R\u00C8GLE PRIORITAIRE ABSOLUE - VALIDATION ERREURS FATALES\n\n## SURVEILLANCE PERMANENTE \u00C0 CHAQUE MESSAGE\n- **CHAQUE MESSAGE** de l'agent test\u00E9 doit \u00EAtre inspect\u00E9 IMM\u00C9DIATEMENT\n- **D\u00C8S qu'un candidat \u00E0 **l'erreur fatale**  appara\u00EEt \u2192 LE GARDER EN MEMOIRE JUSQU'AU \"follow_up\" OU \"cloture\" de la discussion.\n- **D\u00C8S que la discussion est dans l'\u00E9tat \"follow_up\" OU \"cloture\" SI l'erreur fatale en m\u00E9moire N'A PAS \u00C9T\u00C9 CORRIG\u00C9E, TU DOIS arr\u00EAter la simulation avec [SIMULATION_COMPLETE] {\"success\": false, \"error\": \"Erreur fatale d\u00E9tect\u00E9e: [d\u00E9tail pr\u00E9cis]\"}\n- **Format obligatoire d'arr\u00EAt** : [SIMULATION_COMPLETE] avec success:false\n- **Pas d'exception** : m\u00EAme si l'agent atteint les objectifs, une erreur fatale = \u00C9CHEC\n- **D\u00C8S qu'une erreur fatale appara\u00EEt** \u2192 ARR\u00CAT IMM\u00C9DIAT DE LA SIMULATION\n\n## R\u00C8GLES D'ANALYSE INTELLIGENTE ET CONTEXTUELLE\n- D\u00E9tection SEMANTIQUE uniquement avec TOL\u00C9RANCE pour les formules standards professionnelles.\n- **DISTINGUER** entre promesses de l'Agent et demande de l'utilisateur.\n\n## PROCESSUS D'INSPECTION OBLIGATOIRE\n\u00C0 CHAQUE message de l'agent, tu DOIS :\n\n### \u00C9TAPE 1 : INSPECTION ERREURS FATALES (PRIORIT\u00C9 1)\nSi \"erreurs fatales\" sp\u00E9cifi\u00E9es dans le sc\u00E9nario :\n\u2192 Examiner le message de l'agent pour ces termes/comportements interdits\n\u2192 Si d\u00E9tect\u00E9es : STOP IMM\u00C9DIAT avec [SIMULATION_COMPLETE] {\"success\": false, \"error\": \"Erreur fatale d\u00E9tect\u00E9e: [d\u00E9tail pr\u00E9cis]\"}\n\n### \u00C9TAPE 2 : COMPORTEMENT UTILISATEUR (PRIORIT\u00C9 2)\n\u2192 Si aucune erreur fatale : continuer la conversation selon persona + objectifs\n\u2192 Si conditions de fin atteintes : [SIMULATION_COMPLETE] avec rapport selon format\n\n# MISSION UTILISATEUR (seulement si aucune erreur fatale d\u00E9tect\u00E9e)\n1. **Recr\u00E9er une conversation r\u00E9elle** bas\u00E9e sur les instructions de simulation\n2. **Communiquer comme un vrai utilisateur** va \u00E0 l'essentiel sans bavardage\n3. **Agir selon la personnalit\u00E9 d\u00E9finie** dans le sc\u00E9nario de test\n4. **Tester la capacit\u00E9 de l'agent** \u00E0 atteindre les objectifs d\u00E9finis\n5. **\u00C9mettre** [SIMULATION_COMPLETE] quand les conditions de fin sont remplies\n\n# R\u00C8GLES DE COMMUNICATION\n- **CONCISION ABSOLUE** : R\u00E9ponses courtes et naturelles comme un vrai utilisateur\n- **\u00C9viter les r\u00E9p\u00E9titions** : Ne pas r\u00E9p\u00E9ter ce que l'agent vient de dire\n- **Confirmer simplement** : \"Oui\", \"D'accord\", \"Tr\u00E8s bien\", \"Entendu\"\n- **Pas de r\u00E9capitulatifs** : Un utilisateur ne r\u00E9sume pas, il r\u00E9pond \u00E0 la question pos\u00E9e\n- **Personnalit\u00E9 authentique** : adopter la persona d\u00E9finie\n- **Pas de m\u00E9ta** : jamais mentionner \"test\", \"simulation\", \"objectifs\", \"\u00E9valuation\"\n\n# FORMAT INPUT ATTENDU\nTu recevras toujours un INPUT structur\u00E9. Les erreurs fatales (si sp\u00E9cifi\u00E9es) sont EN HAUT et PRIORITAIRES.\n\n## PROCESSUS DE LECTURE OBLIGATOIRE :\n1. **LIRE D'ABORD** les erreurs fatales (si pr\u00E9sentes) et les m\u00E9moriser\n2. **ADOPTER** la personnalit\u00E9 indiqu\u00E9e\n3. **V\u00C9RIFIER** les objectifs tout en surveillant activement les erreurs\n4. **TERMINER** selon les conditions OU d\u00E8s qu'une erreur fatale appara\u00EEt\n\n# GUIDE POUR VARIABLES DE TEST\n- **testStart** : Premi\u00E8re phrase/question du client pour commencer la simulation\n- **testGoals** : Objectifs que l'agent doit atteindre (ce qui constitue un succ\u00E8s)\n- **testEnd** : Conditions sp\u00E9cifiques qui marquent la fin r\u00E9ussie de la simulation\n- **testPersona** : Personnalit\u00E9 \u00E0 adopter (patient, press\u00E9, \u00E9nerv\u00E9, etc.)\n- **testError** : Termes/comportements interdits qui causent un \u00E9chec imm\u00E9diat (erreurs fatales)\n- **testResult** : Format JSON attendu pour le rapport final de simulation\n\n# \u00C9VALUATION FINALE\n**TOUJOURS retourner un JSON strict valide** selon le format demand\u00E9 dans le sc\u00E9nario\n";
+export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, instructionEx?: string): string;
 /**
  * 3 prompts variables de personnalité pré-définis à choisir manuellement
  */
 export declare const PERSONA_PATIENT = "Utilisateur patient et poli qui prend le temps d'expliquer sa situation";
 export declare const PERSONA_PRESSE = "Utilisateur press\u00E9 qui veut une solution rapide, r\u00E9pond bri\u00E8vement";
 export declare const PERSONA_ENERVE = "Utilisateur \u00E9nerv\u00E9 et frustr\u00E9, c'est son 3\u00E8me appel pour le m\u00EAme probl\u00E8me, ton direct et impatient";
-/**
- * Construire la query formatée selon le format SimulationScenario
- */
-export declare const buildSimulatorQuery: (scenario: SimulationScenario) => string;

package/dist/src/agents/simulator.prompts.js

@@ -1,108 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSimulatorQuery = exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = exports.GENERIC_SIMULATOR_PROMPT = void 0;
+exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = void 0;
+exports.GENERIC_SIMULATOR_PROMPT = GENERIC_SIMULATOR_PROMPT;
 /**
- * Prompt de simulateur générique basé sur ClientSimulator
- * COPIÉ et ADAPTÉ depuis agentInstructionModules.ClientSimulator
+ * Génère le prompt du simulateur générique avec le scenario intégré
+ *
+ * Basé sur ClientSimulator avec Mirror Agent Model
+ * Intègre directement les valeurs du scenario dans des tags XML
+ *
+ * @param scenario - Scenario de simulation avec persona, goals, result
+ * @param instructionEx - Instructions additionnelles spécifiques à l'agent (ajoutées à la fin)
+ * @returns Prompt complet avec plan de simulation intégré
  */
-exports.GENERIC_SIMULATOR_PROMPT = `
-## RÔLE - SIMULATEUR VALIDATEUR
-Tu es un **DOUBLE AGENT** qui joue 2 rôles simultanés :
-1. **Utilisateur réel** qui teste un agent conversationnel
-2. **SIMULATEUR: Validateur actif** qui surveille en temps réel les performances
+function GENERIC_SIMULATOR_PROMPT(scenario, instructionEx) {
+    const persona = scenario.persona || scenario.testPersona || '';
+    const goals = scenario.goals || scenario.testGoals || '';
+    const resultFormat = scenario.result || scenario.testResult || '';
+    return `# IDENTITÉ
+Tu es un **TESTEUR AUTOMATISÉ** conçu pour évaluer un **AGENT CONVERSATIONNEL** externe selon le **Mirror Agent Model** :  
+* Un schéma où un agent simulé interagit en miroir avec un agent observé, pendant qu'un observateur caché vérifie la conformité aux objectifs \`<simulation_goals>\`.
 
-# 🚨 RÈGLE PRIORITAIRE ABSOLUE - VALIDATION ERREURS FATALES
+Tu incarnes **deux rôles distincts et simultanés** :
+1. **UTILISATEUR MIROIR (visible)** — tu simules un humain réel selon la personnalité fournie avec l'Agent testé.  
+2. **OBSERVATEUR SILENCIEUX (invisible)** — tu analyses la conversation et les données internes pour déterminer si les objectifs \`<simulation_goals>\` sont atteints.
 
-## SURVEILLANCE PERMANENTE À CHAQUE MESSAGE
-- **CHAQUE MESSAGE** de l'agent testé doit être inspecté IMMÉDIATEMENT
-- **DÈS qu'un candidat à **l'erreur fatale**  apparaît → LE GARDER EN MEMOIRE JUSQU'AU "follow_up" OU "cloture" de la discussion.
-- **DÈS que la discussion est dans l'état "follow_up" OU "cloture" SI l'erreur fatale en mémoire N'A PAS ÉTÉ CORRIGÉE, TU DOIS arrêter la simulation avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail précis]"}
-- **Format obligatoire d'arrêt** : [SIMULATION_COMPLETE] avec success:false
-- **Pas d'exception** : même si l'agent atteint les objectifs, une erreur fatale = ÉCHEC
-- **DÈS qu'une erreur fatale apparaît** → ARRÊT IMMÉDIAT DE LA SIMULATION
+# MISSION
+- Tu reçois un message en entrée provenant de l'Agent testé (nommé "l'Agent").
+- Tu l'analyses en tant qu'<identity_observer>. Tu peux décider de terminer la simulation. 
+- Puis tu réponds en tant qu'<identity_user>. (nommé "Toi")
+---
 
-## RÈGLES D'ANALYSE INTELLIGENTE ET CONTEXTUELLE
-- Détection SEMANTIQUE uniquement avec TOLÉRANCE pour les formules standards professionnelles.
-- **DISTINGUER** entre promesses de l'Agent et demande de l'utilisateur.
+<identity_user>
+## RÔLE 1 (Utilisateur) — UTILISATEUR MIROIR (visible)
+- Tu représentes un **utilisateur humain typique** qui bluf l'Agent testé selon la **Personnalité** fournie.  
+- Tu t'exprimes en **langage naturel**, sans jargon ni répétition.  
+- Tu **ignores** tout du fonctionnement interne de l'Agent testé et de ses outils.  
+- Tu **ne mentionnes jamais** des éléments de tes identités <identity_observer> et <identity_user> et de ta mission.
+- Tu ne répète jamais la réponse de l'agent observé.
 
-## PROCESSUS D'INSPECTION OBLIGATOIRE
-À CHAQUE message de l'agent, tu DOIS :
+- Voici la personnalité de l'utilisateur simulé:
+${persona}
 
-### ÉTAPE 1 : INSPECTION ERREURS FATALES (PRIORITÉ 1)
-Si "erreurs fatales" spécifiées dans le scénario :
-→ Examiner le message de l'agent pour ces termes/comportements interdits
-→ Si détectées : STOP IMMÉDIAT avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail précis]"}
+Exemple de conversation:
+> Agent : "Souhaitez-vous tout le canton ou une zone précise ?"  
+> Toi : "Tout le canton de Genève." ✅
+</identity_user>
 
-### ÉTAPE 2 : COMPORTEMENT UTILISATEUR (PRIORITÉ 2)
-→ Si aucune erreur fatale : continuer la conversation selon persona + objectifs
-→ Si conditions de fin atteintes : [SIMULATION_COMPLETE] avec rapport selon format
+---
 
-# MISSION UTILISATEUR (seulement si aucune erreur fatale détectée)
-1. **Recréer une conversation réelle** basée sur les instructions de simulation
-2. **Communiquer comme un vrai utilisateur** va à l'essentiel sans bavardage
-3. **Agir selon la personnalité définie** dans le scénario de test
-4. **Tester la capacité de l'agent** à atteindre les objectifs définis
-5. **Émettre** [SIMULATION_COMPLETE] quand les conditions de fin sont remplies
+<identity_observer>
+## RÔLE 2 — OBSERVATEUR SILENCIEUX (invisible)
+- Tu observes toutes les questions de l'Agent testé et détermine l'arrêt de la simulation selon les **Objectifs** du \`<simulation_goals>\` 
+- Tu utilises également, si présent, (\`<agent-context>\`) pour déterminer l'arrêt de la simulation.
+- Tu es silencieux et ne réponds jamais rien à l'exception du trigger de fin:
+  Tu retournes le trigger de fin: \`[DONE] {"success": true, "explain": "..."}\` ou \`[DONE] {"success": false, "error": "..."}\`.
 
-# RÈGLES DE COMMUNICATION
-- **CONCISION ABSOLUE** : Réponses courtes et naturelles comme un vrai utilisateur
-- **Éviter les répétitions** : Ne pas répéter ce que l'agent vient de dire
-- **Confirmer simplement** : "Oui", "D'accord", "Très bien", "Entendu"
-- **Pas de récapitulatifs** : Un utilisateur ne résume pas, il répond à la question posée
-- **Personnalité authentique** : adopter la persona définie
-- **Pas de méta** : jamais mentionner "test", "simulation", "objectifs", "évaluation"
+### CONTEXT (\`<agent-context>\` invisible pour le CLIENT)
+- Le tag \`<agent-context>\` contient des données techniques de l'agent testé (outils appelés, nombre d'échanges, etc).  
+- Ces informations sont **strictement réservées à toi l'observateur.  
+**AUTORISÉ** : les exploiter pour valider les objectifs ou décider de la fin du test.  
 
-# FORMAT INPUT ATTENDU
-Tu recevras toujours un INPUT structuré. Les erreurs fatales (si spécifiées) sont EN HAUT et PRIORITAIRES.
+Exemple avec sortie pour <simulation_goals>CONDITION DE FIN: L'agent demande si l'utilisateur souhaite chercher sur internet</simulation_goals>:
+> Toi : "Quelle est la température du lac à Genève ?"  
+> Agent : "Je n'ai pas cette information, souhaitez-vous que je cherche sur internet ?"  
+> Toi : "[DONE] {success=true, ...}" ✅
 
-## PROCESSUS DE LECTURE OBLIGATOIRE :
-1. **LIRE D'ABORD** les erreurs fatales (si présentes) et les mémoriser
-2. **ADOPTER** la personnalité indiquée
-3. **VÉRIFIER** les objectifs tout en surveillant activement les erreurs
-4. **TERMINER** selon les conditions OU dès qu'une erreur fatale apparaît
+</identity_observer>
+---
 
-# GUIDE POUR VARIABLES DE TEST
-- **testStart** : Première phrase/question du client pour commencer la simulation
-- **testGoals** : Objectifs que l'agent doit atteindre (ce qui constitue un succès)
-- **testEnd** : Conditions spécifiques qui marquent la fin réussie de la simulation
-- **testPersona** : Personnalité à adopter (patient, pressé, énervé, etc.)
-- **testError** : Termes/comportements interdits qui causent un échec immédiat (erreurs fatales)
-- **testResult** : Format JSON attendu pour le rapport final de simulation
+# PLAN DE SIMULATION
+<simulation_goals>
+${goals}
+</simulation_goals>
 
-# ÉVALUATION FINALE
-**TOUJOURS retourner un JSON strict valide** selon le format demandé dans le scénario
-`;
+<simulation_result_format>
+${resultFormat}
+</simulation_result_format>
+
+**CRITICAL**: Your response after [DONE] must be valid JSON format only.
+${instructionEx ? `\n\n${instructionEx}` : ''}`;
+}
 /**
  * 3 prompts variables de personnalité pré-définis à choisir manuellement
  */
 exports.PERSONA_PATIENT = 'Utilisateur patient et poli qui prend le temps d\'expliquer sa situation';
 exports.PERSONA_PRESSE = 'Utilisateur pressé qui veut une solution rapide, répond brièvement';
 exports.PERSONA_ENERVE = 'Utilisateur énervé et frustré, c\'est son 3ème appel pour le même problème, ton direct et impatient';
-/**
- * Construire la query formatée selon le format SimulationScenario
- */
-const buildSimulatorQuery = (scenario) => {
-    // 🔧 CORRECTION: Mettre les erreurs fatales EN PREMIER et bien visibles
-    const errorSection = scenario.testError
-        ? `
-- ERREURS FATALES ET SURVEILLANCE OBLIGATOIRE:
-   ⚠️ PROCESSUS : Inspecter UNIQUEMENT les messages de l'agent (l'agent est l'utilisateur du simulateur)
-   ⚠️ QUAND : À chaque fois que l'agent m'envoie une réponse, vérifier ces erreurs dans son message
-   ⚠️ SI DÉTECTÉES : ARRÊT IMMÉDIAT avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail]"}
-   ⚠️ EXCEPTION : Ne pas inspecter ce prompt initial, seulement les réponses de l'agent
-  **${scenario.testError}**
-` : '';
-    return `# INSTRUCTIONS DE SIMULATION (PRIVÉES - NE PAS TRANSMETTRE À L'AGENT)
-- Votre personnalité: ${scenario.testPersona}
-- Objectifs à atteindre: ${scenario.testGoals} 
-- Critères de fin: ${scenario.testEnd} 
-- Format du rapport: ${scenario.testResult}
-${errorSection}
-
-# 🚀 ACTION REQUISE : DÉMARRER LA CONVERSATION
-Vous êtes le SIMULATEUR CLIENT. Envoyez à l'agent UNIQUEMENT le message ci-dessous (sans ces instructions).
-
-# MESSAGE À ENVOYER À L'AGENT :
-${scenario.testQuery}`;
-};
-exports.buildSimulatorQuery = buildSimulatorQuery;

package/dist/src/agents/simulator.types.d.ts

@@ -1,22 +1,34 @@
 import { AgentMessage } from "../stategraph";
 import { AgentConfig, AgenticContext, ExecutionResult } from "../types";
+import { RAGManagerConfig } from "../rag";
 export interface SimulatorConfig {
     agents: AgentConfig[];
     start: string;
     verbose: boolean;
     instructionEx?: string;
+    mockCacheInitializer?: (sessionId: string) => Promise<void>;
+    ragConfig?: RAGManagerConfig;
 }
 export interface SimulationScenario {
-    testGoals: string;
-    testEnd: string;
-    testPersona: string;
-    testQuery: string;
-    testResult: string;
+    goals?: string;
+    persona?: string;
+    result?: string;
+    testGoals?: string;
+    testEnd?: string;
     testError?: string;
+    testPersona?: string;
+    testQuery?: string;
+    testResult?: string;
 }
 export interface SimulationOptions {
     scenario: SimulationScenario;
+    query?: string;
     maxExchanges: number;
+    expectedTool?: Record<string, {
+        equal?: number;
+        gte?: number;
+        lte?: number;
+    }>;
     onMessage?: (message: AgentMessage) => void;
 }
 export interface SimulationResult {
@@ -25,10 +37,16 @@ export interface SimulationResult {
     error: string;
     execution: ExecutionResult;
     exchangeCount: number;
+    messages: AgentMessage[];
+    toolValidation?: {
+        passed: boolean;
+        errors: string[];
+    };
 }
 export interface ExecutionContext {
     agentContext: AgenticContext;
     simulatorContext: AgenticContext;
+    simulatorAgent: AgentConfig;
     conversationHistory: string[];
     exchangeCount: number;
     lastExecution: ExecutionResult;

package/dist/src/agents/simulator.utils.d.ts

@@ -9,12 +9,17 @@ export declare function loadScenario(ticketPath: string): {
 };
 /**
  * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
- * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ * Permet de surcharger tous les champs avec custom
+ * Note: Cette fonction retourne un scenario SANS query - il faut la passer séparément à executeSimulation
  */
 export declare function buildScenarioFromTicket(ticketPath: string, clientType: 'locataire' | 'proprietaire', persona?: string, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
-custom?: Partial<SimulationScenario>): SimulationScenario;
+custom?: Partial<SimulationScenario>): {
+    scenario: SimulationScenario;
+    query: string;
+};
 /**
  * Construire SimulationScenario générique directement
+ * Supporte l'ancien format (testGoals, testEnd, etc.) pour rétrocompatibilité
  */
 export declare function buildGenericScenario(scenario: SimulationScenario): SimulationScenario;
 export { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE };

package/dist/src/agents/simulator.utils.js

@@ -53,7 +53,8 @@ function loadScenario(ticketPath) {
 }
 /**
  * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
- * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ * Permet de surcharger tous les champs avec custom
+ * Note: Cette fonction retourne un scenario SANS query - il faut la passer séparément à executeSimulation
  */
 function buildScenarioFromTicket(ticketPath, clientType, persona = simulator_prompts_1.PERSONA_PATIENT, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
 custom // Surcharge optionnelle de tous les champs
@@ -61,27 +62,46 @@ custom // Surcharge optionnelle de tous les champs
     const { ticketMarkdown, ticketId } = loadScenario(ticketPath);
     // Scenario par défaut complet
     const defaultScenario = {
-        testGoals: `Valider les Objectifs de PRSolver pour ticket ${ticketId}`,
-        testEnd: 'Agent termine avec salutations (état 5_cloture)',
-        testPersona: persona,
-        testQuery: `Je suis le client (demandeur '${clientType}') du ticket en ANNEXE. Démarre la conversation exactement comme décrit dans l'ANNEXE.      
+        goals: `Valider les Objectifs de PRSolver pour ticket ${ticketId}. Agent termine avec salutations (état 5_cloture)`,
+        persona: persona,
+        result: 'done:boolean, error:string, description:string'
+    };
+    const query = `Je suis le client (demandeur '${clientType}') du ticket en ANNEXE. Démarre la conversation exactement comme décrit dans l'ANNEXE.      
 ## ANNEXE - Ticket ${ticketId}
 \`\`\` 
 ${ticketMarkdown}
 \`\`\`
-    `,
-        testResult: 'done:boolean, error:string, description:string'
-    };
+  `;
     // Merger avec custom
-    return { ...defaultScenario, ...custom };
+    return {
+        scenario: { ...defaultScenario, ...custom },
+        query
+    };
 }
 /**
  * Construire SimulationScenario générique directement
+ * Supporte l'ancien format (testGoals, testEnd, etc.) pour rétrocompatibilité
  */
 function buildGenericScenario(scenario) {
+    // Gérer la rétrocompatibilité avec l'ancien format
+    if (scenario.testGoals || scenario.testEnd || scenario.testError) {
+        // Ancien format détecté - conversion vers le nouveau format
+        let goals = scenario.testGoals || '';
+        if (scenario.testEnd) {
+            goals += `\nCONDITION DE FIN: ${scenario.testEnd}`;
+        }
+        if (scenario.testError) {
+            goals += `\nERREUR FATALE: ${scenario.testError}`;
+        }
+        return {
+            goals: goals.trim(),
+            persona: scenario.testPersona || scenario.persona || '',
+            result: scenario.testResult || scenario.result || '{"success": boolean, "error": string, "description": string}',
+        };
+    }
+    // Nouveau format - juste ajouter un result par défaut si manquant
     return {
         ...scenario,
-        // Assurer le format par défaut si pas spécifié
-        testResult: scenario.testResult || 'done:boolean, error:string, description:string'
+        result: scenario.result || '{"success": boolean, "error": string, "description": string}'
     };
 }