agentic-api 2.0.314 → 2.0.585

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

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulatorDashboard = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+const path_1 = __importDefault(require("path"));
+const simulator_1 = require("./simulator");
+// ============================================================================
+// CLASS: SimulatorDashboard
+// ============================================================================
+class SimulatorDashboard {
+    constructor(config) {
+        this.config = config;
+        this.simulator = null;
+        this.abortController = null;
+        this._currentOutputPath = null;
+        this._currentInputPath = null;
+        this.status = this.createInitialStatus();
+    }
+    /**
+     * Chemin du fichier output actuel (ou du dernier run)
+     */
+    get currentOutputPath() {
+        return this._currentOutputPath;
+    }
+    /**
+     * Chemin du fichier input actuel (ou du dernier run)
+     */
+    get currentInputPath() {
+        return this._currentInputPath;
+    }
+    createInitialStatus() {
+        return {
+            isRunning: false,
+            sessionId: null,
+            currentTest: 0,
+            totalTests: 0,
+            passed: 0,
+            failed: 0,
+            errors: 0,
+            startTime: null,
+            lastUpdate: null
+        };
+    }
+    /**
+     * Obtenir le status actuel (pour le contrôleur backend)
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Vérifier si une exécution est en cours
+     */
+    isRunning() {
+        return this.status.isRunning;
+    }
+    /**
+     * Annuler l'exécution en cours
+     */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    /**
+     * Charger un fichier JSON d'entrée
+     */
+    async loadInputFile(filePath) {
+        const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    /**
+     * Générer le chemin du fichier output basé sur le fichier input
+     * Exemple: tests/my-tests.json → tests/results.my-tests.jsonl
+     */
+    createOutputPath(inputPath) {
+        const dir = path_1.default.dirname(inputPath);
+        const basename = path_1.default.basename(inputPath, path_1.default.extname(inputPath));
+        return path_1.default.join(dir, `results.${basename}.jsonl`);
+    }
+    /**
+     * Charger les résultats JSONL existants (en cours ou terminés)
+     * Supporte le streaming partiel (fichier en cours d'écriture)
+     *
+     * @param inputPath - Chemin du fichier JSON d'entrée (génère automatiquement le output path)
+     * @returns Les lignes parsées ou null si le fichier n'existe pas
+     */
+    async loadResults(inputPath) {
+        // Déterminer le chemin du fichier output
+        let outputPath = null;
+        if (inputPath) {
+            outputPath = this.createOutputPath(inputPath);
+        }
+        else if (this._currentInputPath) {
+            outputPath = this.createOutputPath(this._currentInputPath);
+        }
+        else if (this._currentOutputPath) {
+            outputPath = this._currentOutputPath;
+        }
+        if (!outputPath || !(0, fs_1.existsSync)(outputPath)) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            const lines = [];
+            const stream = (0, fs_1.createReadStream)(outputPath, { encoding: 'utf-8' });
+            const rl = (0, readline_1.createInterface)({ input: stream, crlfDelay: Infinity });
+            rl.on('line', (line) => {
+                if (line.trim()) {
+                    try {
+                        lines.push(JSON.parse(line));
+                    }
+                    catch (e) {
+                        // Ignorer les lignes mal formées (fichier en cours d'écriture)
+                    }
+                }
+            });
+            rl.on('close', () => resolve(lines));
+            rl.on('error', reject);
+        });
+    }
+    /**
+     * Obtenir le résumé des résultats (dernière ligne type='end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    async getResultsSummary(inputPath) {
+        const results = await this.loadResults(inputPath);
+        if (!results)
+            return null;
+        const endLine = results.find(r => r.type === 'end');
+        return endLine?.summary || null;
+    }
+    /**
+     * Vérifier si les résultats sont complets (contient une ligne 'end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    async isResultsComplete(inputPath) {
+        const results = await this.loadResults(inputPath);
+        if (!results)
+            return false;
+        return results.some(r => r.type === 'end');
+    }
+    /**
+     * Exécuter les tests et écrire les résultats en JSONL
+     *
+     * @param input - Données d'entrée (ou chemin vers fichier JSON)
+     * @param outputPath - Chemin du fichier JSONL de sortie
+     * @param onLine - Callback optionnel pour chaque ligne JSONL (streaming)
+     */
+    async run(input, outputPath, onLine) {
+        // Stocker et charger l'input si c'est un chemin
+        const isInputFile = typeof input === 'string';
+        this._currentInputPath = isInputFile ? input : null;
+        const data = isInputFile
+            ? await this.loadInputFile(input)
+            : input;
+        // Générer automatiquement le outputPath si input est un fichier
+        const resolvedOutputPath = outputPath ?? (isInputFile ? this.createOutputPath(input) : undefined);
+        this._currentOutputPath = resolvedOutputPath || null;
+        // Initialiser le status
+        const sessionId = `session-${Date.now()}`;
+        this.status = {
+            isRunning: true,
+            sessionId,
+            currentTest: 0,
+            totalTests: data.tests.length,
+            passed: 0,
+            failed: 0,
+            errors: 0,
+            startTime: new Date(),
+            lastUpdate: new Date()
+        };
+        // Créer le simulateur avec config mergée
+        const mergedConfig = {
+            ...this.config,
+            ...data.config
+        };
+        this.simulator = new simulator_1.AgentSimulator(mergedConfig);
+        // Créer l'AbortController
+        this.abortController = new AbortController();
+        // Ouvrir le fichier de sortie si spécifié
+        let writeStream = null;
+        if (resolvedOutputPath) {
+            writeStream = (0, fs_1.createWriteStream)(resolvedOutputPath, { encoding: 'utf-8' });
+        }
+        const results = [];
+        const startTime = Date.now();
+        // Helper pour écrire une ligne
+        const writeLine = (line) => {
+            results.push(line);
+            const jsonLine = JSON.stringify(line) + '\n';
+            if (writeStream) {
+                writeStream.write(jsonLine);
+            }
+            if (onLine) {
+                onLine(line);
+            }
+        };
+        try {
+            // Écrire la ligne de début
+            writeLine({
+                type: 'start',
+                timestamp: new Date().toISOString(),
+                sessionId,
+                totalTests: data.tests.length
+            });
+            // Exécuter chaque test
+            for (let i = 0; i < data.tests.length; i++) {
+                // Vérifier si annulé
+                if (this.abortController.signal.aborted) {
+                    break;
+                }
+                const testCase = data.tests[i];
+                const testId = testCase.id || `test-${i}`;
+                const testStartTime = Date.now();
+                // Mettre à jour le status
+                this.status.currentTest = i + 1;
+                this.status.lastUpdate = new Date();
+                try {
+                    // Exécuter le test
+                    const result = await this.simulator.testCase(testCase.scenario, testCase.case);
+                    // Déterminer le status
+                    const status = result.success ? 'completed' : 'failed';
+                    // Mettre à jour les compteurs
+                    if (result.success) {
+                        this.status.passed++;
+                    }
+                    else {
+                        this.status.failed++;
+                    }
+                    // Écrire le résultat
+                    writeLine({
+                        type: 'result',
+                        timestamp: new Date().toISOString(),
+                        testId,
+                        testIndex: i,
+                        name: testCase.name || testId,
+                        description: testCase.scenario.description || testCase.scenario.goals,
+                        query: testCase.case.query,
+                        status,
+                        success: result.success,
+                        message: result.message,
+                        error: result.error || undefined,
+                        exchangeCount: result.exchangeCount,
+                        messages: result.messages,
+                        duration: Date.now() - testStartTime
+                    });
+                }
+                catch (error) {
+                    // Erreur d'exécution
+                    this.status.errors++;
+                    writeLine({
+                        type: 'error',
+                        timestamp: new Date().toISOString(),
+                        testId,
+                        testIndex: i,
+                        name: testCase.name || testId,
+                        description: testCase.scenario.description || testCase.scenario.goals,
+                        query: testCase.case.query,
+                        status: 'error',
+                        success: false,
+                        error: error.message || String(error),
+                        duration: Date.now() - testStartTime
+                    });
+                }
+            }
+            // Écrire la ligne de fin
+            writeLine({
+                type: 'end',
+                timestamp: new Date().toISOString(),
+                sessionId,
+                summary: {
+                    total: data.tests.length,
+                    passed: this.status.passed,
+                    failed: this.status.failed,
+                    errors: this.status.errors,
+                    totalDuration: Date.now() - startTime
+                }
+            });
+        }
+        finally {
+            // Fermer le stream et attendre la fin de l'écriture
+            if (writeStream) {
+                await new Promise((resolve, reject) => {
+                    writeStream.end(() => resolve());
+                    writeStream.on('error', reject);
+                });
+            }
+            // Reset le status
+            this.status.isRunning = false;
+            this.status.lastUpdate = new Date();
+            this.simulator = null;
+            this.abortController = null;
+        }
+        return results;
+    }
+    /**
+     * Exécuter avec callback de streaming (pour SSE/WebSocket)
+     */
+    async runWithStream(input, onLine) {
+        return this.run(input, undefined, onLine);
+    }
+    /**
+     * Créer un fichier JSON d'exemple pour les tests
+     */
+    static createExampleInput() {
+        return {
+            name: "Example Test Suite",
+            description: "Exemple de suite de tests pour le simulator",
+            tests: [
+                {
+                    id: "test-greeting",
+                    name: "Test de salutation",
+                    scenario: {
+                        goals: "L'agent doit répondre poliment à la salutation",
+                        persona: "Utilisateur poli et patient"
+                    },
+                    case: {
+                        query: "Bonjour, comment allez-vous?"
+                        // maxExchanges: 1 par défaut
+                        // expectedTools: {} par défaut
+                    }
+                },
+                {
+                    id: "test-transfer",
+                    name: "Test de transfert",
+                    scenario: {
+                        goals: "L'agent doit transférer vers l'agent spécialisé",
+                        persona: "Utilisateur avec une demande spécifique"
+                    },
+                    case: {
+                        query: "J'ai besoin d'aide spécialisée",
+                        maxExchanges: 3,
+                        expectedTools: { 'transferAgents': { gte: 1 } }
+                    }
+                }
+            ]
+        };
+    }
+}
+exports.SimulatorDashboard = SimulatorDashboard;

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

@@ -1,7 +1,7 @@
-import { SimulatorConfig, ExecutionContext } from './simulator.types';
+import { SimulatorConfig, ExecutionContext, SimulationScenario } from './simulator.types';
 export declare class AgentExecutor {
     private config;
-    private simulatorAgent;
+    private simulatorAgentBase;
     private mockCacheInitializer?;
     private ragManager?;
     constructor(config: SimulatorConfig & {
@@ -9,8 +9,9 @@ export declare class AgentExecutor {
     });
     /**
      * Initialiser les contextes agent et simulateur
+     * @param scenario Le scenario de simulation complet avec persona, goals, result
      */
-    initializeContexts(): Promise<ExecutionContext>;
+    initializeContexts(scenario: SimulationScenario): Promise<ExecutionContext>;
     /**
      * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
      */
@@ -19,6 +20,11 @@ export declare class AgentExecutor {
      * ✅ Exécuter le simulateur et retourner sa réponse (extraction de client-simulator.ts)
      */
     executeSimulator(context: ExecutionContext, query: string): Promise<string>;
+    /**
+     * ✅ Construire l'injection de contexte technique pour le simulateur
+     * Permet au simulateur de connaître les tools utilisés par l'agent testé
+     */
+    private buildAgentContextInjection;
     /**
      * ✅ Récupérer le dernier message de l'agent testé (extraction de agent-vs-agent.ts ligne 168-191)
      */

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

@@ -8,18 +8,13 @@ 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 [DONE] must be valid JSON format only.';
-        // console.log('---- DBG simulator fullInstructions',fullInstructions);
-        // Agent simulateur simple pour éviter les dépendances complexes du ClientSimulator  
-        this.simulatorAgent = {
+        // Configuration de base du simulateur (instructions seront construites dynamiquement avec le scenario)
+        this.simulatorAgentBase = {
             name: "simple-simulator",
-            model: ("MEDIUM-fast"), // JSON sera forcé via les instructions du prompt
+            model: ("HIGH-fast"),
             publicDescription: "Simulateur simple pour tests - TOUJOURS retourner JSON valide",
             cancelMemory: true,
-            instructions: fullInstructions,
+            instructions: '', // Sera construit dans initializeContexts avec GENERIC_SIMULATOR_PROMPT
             tools: [],
             downstreamAgents: []
         };
@@ -42,8 +37,9 @@ class AgentExecutor {
     }
     /**
      * Initialiser les contextes agent et simulateur
+     * @param scenario Le scenario de simulation complet avec persona, goals, result
      */
-    async initializeContexts() {
+    async initializeContexts(scenario) {
         const sessionId = `simulation-${Date.now()}`;
         const agentContext = {
             user: { id: `test-user`, role: 'user', uid: `test-${sessionId}` },
@@ -63,9 +59,17 @@ class AgentExecutor {
         if (this.mockCacheInitializer) {
             await this.mockCacheInitializer(agentContext.session.id);
         }
+        // ✅ Construire les instructions complètes avec le scénario intégré via la fonction
+        const fullInstructions = (0, simulator_prompts_1.GENERIC_SIMULATOR_PROMPT)(scenario, this.config.instructionEx);
+        if (this.config.verbose)
+            console.log('---- DBG fullInstructions', fullInstructions);
         return {
             agentContext,
             simulatorContext,
+            simulatorAgent: {
+                ...this.simulatorAgentBase,
+                instructions: fullInstructions
+            },
             conversationHistory: [],
             exchangeCount: 0,
             lastExecution: {
@@ -73,8 +77,8 @@ class AgentExecutor {
                 startQuery: '',
                 actions: [],
                 lastMessage: '',
-                usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
-                moreThinkin: false,
+                usage: { prompt: 0, completion: 0, total: 0, cost: 0 }
+                // moreThinkin removed (obsolete)
             }
         };
     }
@@ -111,12 +115,15 @@ class AgentExecutor {
      * ✅ 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,
+        // Utiliser le simulateur avec les instructions complètes (incluant le scénario)
+        // ✅ Injecter le contexte technique si disponible
+        const agentContextInjection = this.buildAgentContextInjection(context);
+        const enrichedQuery = agentContextInjection ? `${query}\n\n${agentContextInjection}` : query;
+        // console.log('DEBUG: Exécution du simulateur avec query:\n', enrichedQuery);
+        await (0, execute_1.executeAgentSet)([context.simulatorAgent], context.simulatorContext, {
+            query: enrichedQuery,
             home: 'simple-simulator',
-            stdout: { write: () => { }, end: () => { }, writableEnded: false },
+            stdout: execute_1.DummyWritable,
             verbose: false,
             debug: false
         });
@@ -124,6 +131,25 @@ class AgentExecutor {
         context.conversationHistory.push(`Simulator: ${response}`);
         return response;
     }
+    /**
+     * ✅ Construire l'injection de contexte technique pour le simulateur
+     * Permet au simulateur de connaître les tools utilisés par l'agent testé
+     */
+    buildAgentContextInjection(context) {
+        if (!context.lastExecution || !context.lastExecution.actions || context.lastExecution.actions.length === 0) {
+            return '';
+        }
+        // Extraire les noms des tools appelés (sans les arguments)
+        const tools = context.lastExecution.actions.map(action => action.action);
+        if (tools.length === 0) {
+            return '';
+        }
+        const contextData = {
+            tools: tools,
+            exchangeCount: context.exchangeCount
+        };
+        return `<agent-context>\n${JSON.stringify(contextData, null, 2)}\n</agent-context>`;
+    }
     /**
      * ✅ Récupérer le dernier message de l'agent testé (extraction de agent-vs-agent.ts ligne 168-191)
      */

package/dist/src/agents/simulator.js

@@ -2,35 +2,94 @@
 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);
     }
+    // ============================================================================
+    // NOUVELLE API : testCase(scenario, case)
+    // ============================================================================
     /**
+     * Exécuter un cas de test avec scénario et paramètres séparés
+     *
+     * @param scenario - Contexte stable (goals, persona, result)
+     * @param testCase - Paramètres du test (query, maxExchanges, model, expectedTools)
+     * @returns SimulationResult
+     *
+     * @example
+     * ```typescript
+     * const scenario = {
+     *   goals: 'Obtenir le nombre secret 1942',
+     *   persona: PERSONA_PATIENT,
+     *   result: '{"success": boolean, "error": string}'
+     * };
+     *
+     * const result = await simulator.testCase(scenario, {
+     *   query: 'À quel nombre penses-tu?',
+     *   maxExchanges: 3,  // défaut: 1 (oneshot)
+     *   expectedTools: { 'transferAgents': { equal: 1 } }  // défaut: {}
+     * });
+     * ```
+     */
+    async testCase(scenario, testCase) {
+        // Appliquer les défauts
+        const resolvedCase = {
+            query: testCase.query,
+            maxExchanges: testCase.maxExchanges ?? 1, // Défaut: 1 (oneshot)
+            expectedTools: testCase.expectedTools ?? {}, // Défaut: pas de validation
+            model: testCase.model,
+            onMessage: testCase.onMessage
+        };
+        // TODO: Support model override (Phase 2)
+        // if (resolvedCase.model) {
+        //   this.overrideModel(resolvedCase.model);
+        // }
+        // Convertir TestScenario vers SimulationScenario et déléguer
+        return this.executeSimulation({
+            scenario: {
+                goals: scenario.goals,
+                persona: scenario.persona,
+                result: scenario.result || '{"success": boolean, "explain": string, "error": string}'
+            },
+            query: resolvedCase.query,
+            maxExchanges: resolvedCase.maxExchanges,
+            expectedTool: resolvedCase.expectedTools,
+            onMessage: resolvedCase.onMessage
+        });
+    }
+    // ============================================================================
+    // ANCIENNE API : executeSimulation(options) - deprecated
+    // ============================================================================
+    /**
+     * @deprecated Utiliser testCase(scenario, case) à la place
+     *
      * 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, options.query);
-            // Générer le message initial du simulateur avec le scénario
-            let currentUserQuery = await this.executor.executeSimulator(context, scenarioQuery);
-            // Stocker le 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) {
@@ -39,6 +98,7 @@ class AgentSimulator {
             // 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);
                 lastAgentMessage = agentResponse;
                 // Stocker la réponse de l'agent
@@ -49,9 +109,9 @@ class AgentSimulator {
                 }
                 // Incrémenter le compteur après la réponse de l'agent (assistant)
                 exchangeCounter++;
-                // Simulateur évalue et répond
+                // ✅ Passer directement agentResponse au simulateur (scénario déjà dans les instructions)
                 const simulatorResult = await this.executor.executeSimulator(context, agentResponse);
-                // console.log(context.agentContext.messages);
+                // console.log('---- DBG simulatorResult',simulatorResult);
                 // Vérifier si terminé
                 if (this.isSimulationComplete(simulatorResult)) {
                     const expectedFormat = options.scenario.result || options.scenario.testResult || '{"success": boolean, "error": string}';
@@ -150,8 +210,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,
@@ -224,9 +284,24 @@ class AgentSimulator {
         };
     }
     extractConversationalPart(response) {
-        // Extraire la partie conversationnelle avant les tags d'évaluation
-        const tagIndex = response.search(/\[(DONE|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
@@ -250,8 +325,17 @@ class AgentSimulator {
         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 ${constraint.equal}, got ${count}`);
+                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 {