agentic-api 1.0.6 → 2.0.31

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentExecutor = void 0;
+const types_1 = require("../types");
+const stategraph_1 = require("../stategraph");
+const execute_1 = require("../execute");
+const simulator_prompts_1 = require("./simulator.prompts");
+class AgentExecutor {
+    constructor(config) {
+        this.config = config;
+        // Construire les instructions complètes du simulateur
+        const fullInstructions = simulator_prompts_1.GENERIC_SIMULATOR_PROMPT +
+            (config.instructionEx ? `\n\n${config.instructionEx}` : '') +
+            '\n\n**CRITICAL**: Your response after [SIMULATION_COMPLETE] must be valid JSON format only.';
+        // Agent simulateur simple pour éviter les dépendances complexes du ClientSimulator  
+        this.simulatorAgent = {
+            name: "simple-simulator",
+            model: (0, execute_1.modelConfig)("MEDIUM-fast"), // JSON sera forcé via les instructions du prompt
+            publicDescription: "Simulateur simple pour tests - TOUJOURS retourner JSON valide",
+            instructions: fullInstructions,
+            tools: [],
+            downstreamAgents: []
+        };
+    }
+    /**
+     * Initialiser les contextes agent et simulateur
+     */
+    async initializeContexts() {
+        const sessionId = `simulation-${Date.now()}`;
+        const agentContext = {
+            user: { id: `test-user`, role: 'user', uid: `test-${sessionId}` },
+            credential: { test: true, sessionId: `agent-${sessionId}` },
+            verbose: this.config.verbose,
+            session: { id: `agent-${sessionId}`, data: {}, messages: [] }
+        };
+        const simulatorContext = {
+            user: { id: `simulator-user`, role: 'user', uid: `sim-${sessionId}` },
+            credential: { test: true, sessionId: `sim-${sessionId}` },
+            verbose: this.config.verbose,
+            session: { id: `sim-${sessionId}`, data: {}, messages: [] }
+        };
+        return {
+            agentContext,
+            simulatorContext,
+            conversationHistory: [],
+            exchangeCount: 0,
+            lastExecution: {
+                runId: '',
+                startQuery: '',
+                actions: [],
+                lastMessage: '',
+                usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+                moreThinkin: false,
+            }
+        };
+    }
+    /**
+     * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
+     */
+    async executeAgent(context, query) {
+        // Logique extraite de AgentVsAgentTester.executeAgentWithContext()
+        const execResult = await (0, execute_1.executeAgentSet)(this.config.agents, context.agentContext, {
+            query,
+            home: this.config.start,
+            stdout: { write: () => { }, end: () => { }, writableEnded: false },
+            verbose: this.config.verbose,
+            debug: false
+        });
+        if (context.lastExecution) {
+            context.lastExecution = (0, types_1.executionResultMerge)(context.lastExecution, execResult);
+        }
+        else {
+            context.lastExecution = execResult;
+        }
+        context.exchangeCount++;
+        // ✅ Extraire et retourner le dernier message de l'agent (logique de getLastPRSolverMessage)
+        return this.getLastAgentMessage(context.agentContext);
+    }
+    /**
+     * ✅ Exécuter le simulateur et retourner sa réponse (extraction de client-simulator.ts)
+     */
+    async executeSimulator(context, query) {
+        // Utiliser le simulateur dynamique avec instructions étendues
+        // console.log('DEBUG: Exécution du simulateur avec query:\n', query);
+        await (0, execute_1.executeAgentSet)([this.simulatorAgent], context.simulatorContext, {
+            query,
+            home: 'simple-simulator',
+            stdout: { write: () => { }, end: () => { }, writableEnded: false },
+            verbose: false,
+            debug: false
+        });
+        const response = this.getLastAssistantMessage(context.simulatorContext);
+        context.conversationHistory.push(`Simulator: ${response}`);
+        return response;
+    }
+    /**
+     * ✅ Récupérer le dernier message de l'agent testé (extraction de agent-vs-agent.ts ligne 168-191)
+     */
+    getLastAgentMessage(agentContext) {
+        const stateGraph = (0, stategraph_1.sessionStateGraphGet)(agentContext);
+        const messages = stateGraph.discussions[0].messages;
+        if (!messages || !messages.length) {
+            return '[Aucun message trouvé]';
+        }
+        // Filtrer pour récupérer le dernier message assistant (agent testé)
+        const assistantMessages = messages.filter(msg => msg.role === 'assistant');
+        if (assistantMessages.length === 0)
+            return '[Aucun message trouvé]';
+        const rawMessage = assistantMessages[assistantMessages.length - 1].content;
+        let isTerminated = '';
+        if (rawMessage.includes('<step>[5_cloture]</step>')) {
+            isTerminated = ' <step>[5_cloture]</step>';
+        }
+        // Nettoyer le message des éléments de debug
+        const cleanMessage = rawMessage
+            .replace(/<step>.*?<\/step>/mg, '') // Supprimer les balises <step>
+            .trim();
+        return cleanMessage + isTerminated;
+    }
+    /**
+     * ✅ Récupérer le dernier message du simulateur (extraction de client-simulator.ts)
+     */
+    getLastAssistantMessage(simulatorContext) {
+        const stateGraph = (0, stategraph_1.sessionStateGraphGet)(simulatorContext);
+        const messages = stateGraph.discussions[0].messages;
+        if (!messages || messages.length === 0) {
+            return '';
+        }
+        return messages[messages.length - 1].content;
+    }
+}
+exports.AgentExecutor = AgentExecutor;

package/dist/src/agents/simulator.js

@@ -0,0 +1,205 @@
+"use strict";
+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;
+        this.executor = new simulator_executor_1.AgentExecutor(config);
+    }
+    /**
+     * Exécuter la simulation complète
+     *
+     * Format de la query passée à l'agent testé :
+     * - Message initial : réponse du simulateur après analyse du scenario
+     * - 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)
+     */
+    async executeSimulation(options) {
+        const context = await this.executor.initializeContexts();
+        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
+            if (options.onMessage) {
+                options.onMessage({ content: currentUserQuery, role: 'user' });
+            }
+            // Boucle de conversation
+            for (let i = 0; i < options.maxExchanges; i++) {
+                // Agent testé répond et retourne sa réponse
+                const agentResponse = await this.executor.executeAgent(context, currentUserQuery);
+                // Callback pour réponse de l'agent
+                if (options.onMessage) {
+                    options.onMessage({ content: agentResponse, role: 'assistant' });
+                }
+                // Simulateur évalue et répond
+                const simulatorResult = await this.executor.executeSimulator(context, agentResponse);
+                // Vérifier si terminé
+                if (this.isSimulationComplete(simulatorResult)) {
+                    const parsed = this.parseSimulationResult(simulatorResult, options.scenario.testResult, context);
+                    this.lastExecution = context.lastExecution;
+                    return {
+                        ...parsed,
+                        execution: context.lastExecution,
+                        exchangeCount: context.exchangeCount
+                    };
+                }
+                currentUserQuery = this.extractConversationalPart(simulatorResult);
+                // Callback pour réponse du simulateur (si pas terminé)
+                if (options.onMessage && currentUserQuery) {
+                    options.onMessage({ content: currentUserQuery, role: 'user' });
+                }
+            }
+            // Timeout - générer rapport final
+            const timeout = await this.generateTimeoutReport(context, options.scenario.testResult);
+            this.lastExecution = context.lastExecution;
+            return { ...timeout, exchangeCount: context.exchangeCount };
+        }
+        catch (error) {
+            this.lastExecution = context.lastExecution;
+            return {
+                success: false,
+                message: '',
+                error: `Erreur d'exécution: ${error.message || error}`,
+                execution: context.lastExecution,
+                exchangeCount: context.exchangeCount
+            };
+        }
+    }
+    /**
+     * Compter les occurrences d'une action dans le dernier ExecutionResult
+     * @param name Nom exact de l'action (ex: 'lookupMfilesIntervenant', 'lookupKnowledge', 'sendInternalEmail')
+     * @returns { firstPos, count, total } où:
+     *  - firstPos: index de la première occurrence (ou -1 si absente)
+     *  - count: nombre d'occurrences de cette action
+     *  - total: nombre total d'actions du même type (fonction vs transfert)
+     */
+    executionActionCount(name) {
+        const execution = this.lastExecution;
+        const actions = execution?.actions || [];
+        const firstPos = actions.findIndex((a) => (a.action === name));
+        const count = actions.filter((a) => a.action === name).length;
+        // Déterminer le type par convention de nommage
+        const isTransfer = name === 'transfert';
+        const total = actions.filter((a) => {
+            if (isTransfer) {
+                return a.action === name;
+            }
+            else {
+                return a.action !== 'transfert';
+            }
+        }).length;
+        return { firstPos, count, total };
+    }
+    /**
+     * Fonction d'affichage pour les tests - n'altère pas la structure originale
+     * Crée une version simplifiée pour l'affichage avec juste les noms des actions
+     */
+    printSimulationResult(result) {
+        const summary = {
+            success: result.success,
+            message: result.message,
+            error: result.error,
+            exchangeCount: result.exchangeCount,
+            runId: result.execution?.runId,
+            startQuery: result.execution?.startQuery,
+            actions: result.execution?.actions?.map((elem) => elem.action) || [],
+            lastMessage: result.execution?.lastMessage,
+            usage: result.execution?.usage,
+            moreThinkin: result.execution?.moreThinkin
+        };
+        const execution = {
+            ...result.execution,
+            actions: result.execution?.actions?.map((elem) => elem.action) || []
+        };
+        return { summary, execution };
+    }
+    isSimulationComplete(response) {
+        return 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]')) {
+            // Extraire le contenu après le tag
+            const match = response.match(/\[SIMULATION_COMPLETE\]\s*\n?([\s\S]*)/);
+            if (match) {
+                const resultContent = match[1].trim();
+                // Essayer de parser comme JSON d'abord
+                try {
+                    const jsonResult = JSON.parse(resultContent);
+                    return {
+                        success: jsonResult.success === undefined ? true : jsonResult.success, // true par défaut, utilise la valeur JSON si présente
+                        message: jsonResult.description || resultContent,
+                        error: jsonResult.error || '',
+                        execution: context.lastExecution,
+                        exchangeCount: context.exchangeCount
+                    };
+                }
+                catch (jsonError) {
+                    // Fallback : parsing manuel pour format "success:boolean, error:string, description:string"
+                    const successMatch = resultContent.match(/success:\s*(true|false)/);
+                    const errorMatch = resultContent.match(/error:\s*([^\n,]*)/);
+                    // Description en dernier car elle peut être multiligne
+                    let description = resultContent.trim();
+                    if (successMatch || errorMatch) {
+                        const descMatch = resultContent.match(/description:\s*([\s\S]*?)$/);
+                        description = descMatch ? descMatch[1].trim() : description;
+                    }
+                    return {
+                        success: successMatch ? successMatch[1] === 'true' : true,
+                        message: description,
+                        error: errorMatch ? errorMatch[1].trim() : '',
+                        execution: context.lastExecution,
+                        exchangeCount: context.exchangeCount
+                    };
+                }
+            }
+            // Fallback si parsing échoue
+            return {
+                success: true,
+                message: response,
+                error: '',
+                execution: context.lastExecution,
+                exchangeCount: context.exchangeCount
+            };
+        }
+        // Si pas de tag de fin détecté
+        return {
+            success: false,
+            message: response,
+            error: 'Simulation non terminée',
+            execution: context.lastExecution,
+            exchangeCount: context.exchangeCount
+        };
+    }
+    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;
+    }
+    /**
+     * 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.
+    Génère maintenant ton rapport final au format:
+    [SIMULATION_COMPLETE]
+    success: false  
+    error: Limite d'échanges atteinte
+    description: Simulation interrompue - timeout
+    `;
+        const finalResult = await this.executor.executeSimulator(context, reportQuery);
+        return this.parseSimulationResult(finalResult, expectedFormat, context);
+    }
+}
+exports.AgentSimulator = AgentSimulator;

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

@@ -0,0 +1,16 @@
+import { SimulationScenario } from "./simulator.types";
+/**
+ * Prompt de simulateur générique basé sur ClientSimulator
+ * COPIÉ et ADAPTÉ depuis agentInstructionModules.ClientSimulator
+ */
+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";
+/**
+ * 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

@@ -0,0 +1,108 @@
+"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;
+/**
+ * Prompt de simulateur générique basé sur ClientSimulator
+ * COPIÉ et ADAPTÉ depuis agentInstructionModules.ClientSimulator
+ */
+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
+
+# 🚨 RÈGLE PRIORITAIRE ABSOLUE - VALIDATION ERREURS FATALES
+
+## 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
+
+## 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.
+
+## PROCESSUS D'INSPECTION OBLIGATOIRE
+À CHAQUE message de l'agent, tu DOIS :
+
+### É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]"}
+
+### É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
+
+# 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"
+
+# FORMAT INPUT ATTENDU
+Tu recevras toujours un INPUT structuré. Les erreurs fatales (si spécifiées) sont EN HAUT et PRIORITAIRES.
+
+## 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
+
+# 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
+
+# ÉVALUATION FINALE
+**TOUJOURS retourner un JSON strict valide** selon le format demandé dans le scénario
+`;
+/**
+ * 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

@@ -0,0 +1,42 @@
+import { AgentMessage } from "../stategraph";
+import { AgentConfig, AgenticContext, ExecutionResult } from "../types";
+export interface SimulatorConfig {
+    agents: AgentConfig[];
+    start: string;
+    verbose: boolean;
+    instructionEx?: string;
+}
+export interface SimulationScenario {
+    testGoals: string;
+    testEnd: string;
+    testPersona: string;
+    testQuery: string;
+    testResult: string;
+    testError?: string;
+}
+export interface SimulationOptions {
+    scenario: SimulationScenario;
+    maxExchanges: number;
+    onMessage?: (message: AgentMessage) => void;
+}
+export interface SimulationResult {
+    success: boolean;
+    message: string;
+    error: string;
+    execution: ExecutionResult;
+    exchangeCount: number;
+}
+export interface ExecutionContext {
+    agentContext: AgenticContext;
+    simulatorContext: AgenticContext;
+    conversationHistory: string[];
+    exchangeCount: number;
+    lastExecution: ExecutionResult;
+}
+export interface TestScenario {
+    ticketId: string;
+    ticketMarkdown: string;
+    clientType: 'locataire' | 'proprietaire';
+    ton?: 'patient' | 'presse' | 'enerve';
+    variant?: any;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,20 @@
+import { SimulationScenario } from './simulator.types';
+import { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE } from './simulator.prompts';
+/**
+ * Charger un ticket depuis le filesystem (comme agent-vs-agent.ts)
+ */
+export declare function loadScenario(ticketPath: string): {
+    ticketMarkdown: string;
+    ticketId: string;
+};
+/**
+ * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
+ * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ */
+export declare function buildScenarioFromTicket(ticketPath: string, clientType: 'locataire' | 'proprietaire', persona?: string, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
+custom?: Partial<SimulationScenario>): SimulationScenario;
+/**
+ * Construire SimulationScenario générique directement
+ */
+export declare function buildGenericScenario(scenario: SimulationScenario): SimulationScenario;
+export { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE };

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

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = void 0;
+exports.loadScenario = loadScenario;
+exports.buildScenarioFromTicket = buildScenarioFromTicket;
+exports.buildGenericScenario = buildGenericScenario;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const simulator_prompts_1 = require("./simulator.prompts");
+Object.defineProperty(exports, "PERSONA_PATIENT", { enumerable: true, get: function () { return simulator_prompts_1.PERSONA_PATIENT; } });
+Object.defineProperty(exports, "PERSONA_PRESSE", { enumerable: true, get: function () { return simulator_prompts_1.PERSONA_PRESSE; } });
+Object.defineProperty(exports, "PERSONA_ENERVE", { enumerable: true, get: function () { return simulator_prompts_1.PERSONA_ENERVE; } });
+/**
+ * Charger un ticket depuis le filesystem (comme agent-vs-agent.ts)
+ */
+function loadScenario(ticketPath) {
+    const ticketMarkdown = fs.readFileSync(ticketPath, 'utf8');
+    const ticketId = path.basename(ticketPath).split('-')[0];
+    return { ticketMarkdown, ticketId };
+}
+/**
+ * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
+ * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ */
+function buildScenarioFromTicket(ticketPath, clientType, persona = simulator_prompts_1.PERSONA_PATIENT, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
+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.      
+## ANNEXE - Ticket ${ticketId}
+\`\`\` 
+${ticketMarkdown}
+\`\`\`
+    `,
+        testResult: 'done:boolean, error:string, description:string'
+    };
+    // Merger avec custom
+    return { ...defaultScenario, ...custom };
+}
+/**
+ * Construire SimulationScenario générique directement
+ */
+function buildGenericScenario(scenario) {
+    return {
+        ...scenario,
+        // Assurer le format par défaut si pas spécifié
+        testResult: scenario.testResult || 'done:boolean, error:string, description:string'
+    };
+}

package/dist/src/execute.d.ts

@@ -1,15 +1,21 @@
-import { AgentConfig, AgenticContext, AgenticMemory, AgentModel, Feedback } from "./types";
+import { AgentConfig, AgenticContext, AgentModel, ExecuteAgentResult, Feedback, ExecutionResult } from "./types";
 import { Writable } from "stream";
+import { AgentStateGraph } from "./stategraph";
 export declare function modelConfig(model: string, custom?: any): AgentModel;
 export declare function sendFeedback(params: Feedback): void;
 export interface ReadCompletionsStreamOptions {
-    memory: AgenticMemory;
+    stateGraph: AgentStateGraph;
+    discussion: any;
+    agentConfig: AgentConfig;
+    agents: AgentConfig[];
+    agentName: string;
     stdout: Writable;
     session: AgenticContext;
     final: any;
-    enrichWithMemory?: (role?: string) => Promise<string>;
+    verbose?: boolean;
+    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
 }
-export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<boolean | undefined>;
+export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<ExecutionResult>;
 /**
  * Parameters for executing an agent set
  * @interface ExecuteAgentSetParams
@@ -21,7 +27,7 @@ export declare function readCompletionsStream(params: ReadCompletionsStreamOptio
  * @property {number} [maxSteps] - Maximum number of steps to execute
  */
 export interface ExecuteAgentSetParams {
-    enrichWithMemory?: (role?: string) => Promise<string>;
+    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
     query: string;
     home?: string;
     stdout: Writable;
@@ -39,4 +45,5 @@ export interface ExecuteAgentSetParams {
  * @param {ExecuteAgentSetParams} params - Execution parameters
  * @returns {Promise<void>}
  */
-export declare function executeAgentSet(agentSet: AgentConfig[], session: AgenticContext, params: ExecuteAgentSetParams): Promise<void>;
+export declare function executeAgentSet(agentSet: AgentConfig[], context: AgenticContext, params: ExecuteAgentSetParams): Promise<ExecutionResult>;
+export declare function executeAgent(agentSet: AgentConfig[], params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;