agentic-api 2.0.31 → 2.0.314

package/dist/src/agents/reducer.loaders.js

@@ -3,8 +3,9 @@
  * Native Loaders for MapLLM
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringNativeLoader = exports.FileNativeLoader = void 0;
+exports.TaskListLoader = exports.StringNativeLoader = exports.FileNativeLoader = void 0;
 const fs_1 = require("fs");
+const crypto_1 = require("crypto");
 /**
  * FileNativeLoader - Loader pour fichiers avec chunking par lignes
  */
@@ -120,3 +121,115 @@ class StringNativeLoader {
     }
 }
 exports.StringNativeLoader = StringNativeLoader;
+/**
+ * TaskListLoader - Loader pour exécution séquentielle de tâches
+ * Compatible avec NativeLoader pour réutiliser la logique de MapLLM
+ * Job = TaskListLoader (pas de type séparé)
+ */
+class TaskListLoader {
+    /**
+     * Constructeur principal - crée un nouveau Job avec ID auto-généré
+     * @param tasks Liste des tâches
+     * @param agents Liste des agents matérialisés
+     * @param description Description du Job (optionnel)
+     */
+    constructor(tasks, agents, description) {
+        this._id = (0, crypto_1.randomUUID)();
+        this._tasks = tasks;
+        this._agents = agents;
+        this._description = description || '';
+    }
+    /**
+     * ✅ Restaure depuis Job avec liste d'agents matérialisés
+     * @param job Job sérialisé (agents = string[])
+     * @param availableAgents Liste d'agents matérialisés pour reconstruction
+     */
+    static fromJob(job, availableAgents) {
+        //
+        // Reconstruire AgentConfig[] depuis job.agents (string[])
+        const agents = job.agents
+            .map(name => availableAgents.find(a => a.name === name))
+            .filter(Boolean);
+        if (agents.length === 0) {
+            throw new Error('No matching agents found for Job');
+        }
+        const instance = new TaskListLoader(job.tasks, agents, job.description);
+        instance._id = job.id; // ✅ Préserver l'ID
+        return instance;
+    }
+    /**
+     * ✅ Méthode static pour charger depuis OneDrive
+     * @param credential Token credential
+     * @param jobId ID du Job à charger
+     * @param availableAgents Liste d'agents matérialisés
+     */
+    static async loadJob(credential, jobId, availableAgents) {
+        //
+        // Import dynamique pour éviter dépendance circulaire
+        // getJobsFromOneDrive sera fourni par job.service.ts (agentic-server)
+        const jobs = await getJobsFromOneDrive(credential);
+        const job = jobs.find(j => j.id === jobId);
+        if (!job)
+            return null;
+        return TaskListLoader.fromJob(job, availableAgents);
+    }
+    /**
+     * Getters
+     */
+    get id() { return this._id; }
+    get tasks() { return this._tasks; }
+    get agents() { return this._agents; }
+    get description() { return this._description; }
+    get label() { return this._description; }
+    /**
+     * Ajoute une tâche (agent et model optionnels)
+     * @param task Tâche sans ID (auto-généré)
+     */
+    addTask(task) {
+        const newTask = {
+            ...task,
+            id: (0, crypto_1.randomUUID)(),
+            agentName: task.agentName || this._agents[0]?.name
+        };
+        this._tasks.push(newTask);
+    }
+    /**
+     * ✅ Retourne Job sérialisable (AgentConfig → string[])
+     */
+    toJob() {
+        return {
+            id: this._id,
+            tasks: this._tasks,
+            agents: this._agents.map(a => a.name), // ✅ Seulement les noms
+            description: this._description,
+            discussions: [],
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+    }
+    async loadNativeChunk(position) {
+        if (position >= this._tasks.length) {
+            throw new Error(`Task position ${position} out of bounds (total: ${this._tasks.length})`);
+        }
+        const task = this._tasks[position];
+        //
+        // Serialize task as JSON string (compatible avec content: string)
+        const content = JSON.stringify(task);
+        const nextPosition = position + 1;
+        const eof = nextPosition >= this._tasks.length;
+        return {
+            content,
+            eof,
+            position: nextPosition
+        };
+    }
+}
+exports.TaskListLoader = TaskListLoader;
+/**
+ * Helper pour TaskListLoader.loadJob
+ * Sera fourni par job.service.ts pour éviter import circulaire
+ */
+async function getJobsFromOneDrive(credential) {
+    // Placeholder - implémenté dans agentic-server/src/pinned/job.service.ts
+    return [];
+}

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

@@ -1,7 +1,7 @@
 /**
  * Types for the MapLLM reducer functionality
  */
-import type { AgentModel } from '../types';
+import { Writable } from 'stream';
 export interface NativeLoader {
     loadNativeChunk(position: number): Promise<{
         content: string;
@@ -16,6 +16,10 @@ export interface StatefulReducerConfig {
     reducePrompt: string;
     /** Modulo for reducing the digest */
     reduceModulo?: number;
+    /** ✅ Context pour exécution (optionnel - accès credential, session, etc.) */
+    context?: any;
+    /** ✅ Stdout pour feedback streaming (optionnel) */
+    stdout?: any;
 }
 export interface StructuredOutputFormat {
     /** Schema name for the structured output */
@@ -28,12 +32,15 @@ export interface StructuredOutputFormat {
 export interface MapLLMReduceResult {
     /** Accumulator - string for text mode, object for structured output */
     acc: string | Record<string, any>;
+    stdout?: Writable;
     continue?: boolean;
     maxIterations?: boolean;
+    /** ✅ Configuration déplacée ici (plus dans params reduce) */
+    config?: StatefulReducerConfig;
     /** OpenAI structured output format configuration */
     format?: StructuredOutputFormat;
     /** Model configuration */
-    model?: AgentModel;
+    model?: string;
     verbose?: boolean;
     /** Processing metadata */
     metadata?: {
@@ -48,3 +55,39 @@ export interface ChunkStrategy {
     size: number;
     overlap?: number;
 }
+/**
+ * Task definition for Plan-Executor
+ */
+export interface Task {
+    /** Unique task identifier */
+    id: string;
+    /** Task prompt/query to execute */
+    prompt: string;
+    /** Optional: Agent name to use (if not specified, uses default) */
+    agentName?: string;
+    /** Optional: Force model to use for this task */
+    model?: string;
+    /** Optional: Tools to add/override for this task */
+    tools?: any[];
+    /** Optional: Metadata for tracking */
+    meta?: Record<string, any>;
+}
+/**
+ * Job sérialisable (stocké en OneDrive)
+ * Les agents sont stockés comme string[] (noms) car AgentConfig n'est pas sérialisable
+ */
+export interface Job {
+    /** Identifiant unique du Job */
+    id: string;
+    /** Liste des tâches */
+    tasks: Task[];
+    /** Noms des agents (sérialisable - AgentConfig n'est pas sérialisable) */
+    agents: string[];
+    /** Description du Job */
+    description?: string;
+    /** IDs des discussions liées à ce Job */
+    discussions: string[];
+    /** Dates */
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/src/agents/semantic.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.semantic = void 0;
-const execute_1 = require("../execute");
 const utils_1 = require("../utils");
 const prompts_1 = require("./prompts");
 exports.semantic = {
     name: "semantic",
-    model: (0, execute_1.modelConfig)("LOW"),
+    model: "LOW",
     publicDescription: "Agent spécialisé dans l’extraction sémantique structurée",
     instructions: prompts_1.semanticPrompt,
     tools: [],

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

@@ -44,4 +44,8 @@ export declare class AgentSimulator {
      * Générer le rapport final en cas de timeout
      */
     private generateTimeoutReport;
+    /**
+     * Valider que les outils attendus ont été appelés le bon nombre de fois
+     */
+    private validateExpectedTools;
 }

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

@@ -2,7 +2,11 @@ import { SimulatorConfig, ExecutionContext } from './simulator.types';
 export declare class AgentExecutor {
     private config;
     private simulatorAgent;
-    constructor(config: SimulatorConfig);
+    private mockCacheInitializer?;
+    private ragManager?;
+    constructor(config: SimulatorConfig & {
+        mockCacheInitializer?: (sessionId: string) => Promise<void>;
+    });
     /**
      * Initialiser les contextes agent et simulateur
      */

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentExecutor = void 0;
-const types_1 = require("../types");
+const rag_1 = require("../rag");
 const stategraph_1 = require("../stategraph");
 const execute_1 = require("../execute");
 const simulator_prompts_1 = require("./simulator.prompts");
@@ -11,16 +11,34 @@ class AgentExecutor {
         // 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.';
+            '\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 = {
             name: "simple-simulator",
-            model: (0, execute_1.modelConfig)("MEDIUM-fast"), // JSON sera forcé via les instructions du prompt
+            model: ("MEDIUM-fast"), // JSON sera forcé via les instructions du prompt
             publicDescription: "Simulateur simple pour tests - TOUJOURS retourner JSON valide",
+            cancelMemory: true,
             instructions: fullInstructions,
             tools: [],
             downstreamAgents: []
         };
+        //
+        // ✅ Annuler la mémoire pour tous les agents en simulation
+        config.agents.forEach(agent => {
+            agent.cancelMemory = true;
+        });
+        this.mockCacheInitializer = config.mockCacheInitializer;
+        // ✅ Initialiser le RAGManager si la configuration est fournie
+        if (config.ragConfig) {
+            try {
+                this.ragManager = rag_1.RAGManager.get(config.ragConfig);
+                console.log(`✅ RAGManager initialisé pour le simulateur (default: ${this.ragManager.getDefault()})`);
+            }
+            catch (error) {
+                console.warn('⚠️ Impossible d\'initialiser le RAGManager pour le simulateur:', error);
+            }
+        }
     }
     /**
      * Initialiser les contextes agent et simulateur
@@ -31,7 +49,9 @@ class AgentExecutor {
             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: [] }
+            session: { id: `agent-${sessionId}`, data: {}, messages: [] },
+            // ✅ Ajouter customRag au contexte si le RAG est configuré
+            ...(this.ragManager ? { customRag: this.ragManager.getDefault() } : {})
         };
         const simulatorContext = {
             user: { id: `simulator-user`, role: 'user', uid: `sim-${sessionId}` },
@@ -39,6 +59,10 @@ class AgentExecutor {
             verbose: this.config.verbose,
             session: { id: `sim-${sessionId}`, data: {}, messages: [] }
         };
+        // ✅ Initialiser le cache mock si fourni (pour les tests SGC avec M-Files)
+        if (this.mockCacheInitializer) {
+            await this.mockCacheInitializer(agentContext.session.id);
+        }
         return {
             agentContext,
             simulatorContext,
@@ -62,16 +86,23 @@ class AgentExecutor {
         const execResult = await (0, execute_1.executeAgentSet)(this.config.agents, context.agentContext, {
             query,
             home: this.config.start,
-            stdout: { write: () => { }, end: () => { }, writableEnded: false },
+            stdout: execute_1.DummyWritable,
             verbose: this.config.verbose,
             debug: false
         });
+        // Accumuler seulement l'usage, pas les actions
         if (context.lastExecution) {
-            context.lastExecution = (0, types_1.executionResultMerge)(context.lastExecution, execResult);
-        }
-        else {
-            context.lastExecution = execResult;
+            context.lastExecution.usage.prompt += execResult.usage.prompt;
+            context.lastExecution.usage.completion += execResult.usage.completion;
+            context.lastExecution.usage.total += execResult.usage.total;
+            context.lastExecution.usage.cost += execResult.usage.cost;
         }
+        context.lastExecution = execResult;
+        // if (context.lastExecution) {
+        //   context.lastExecution = 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);
@@ -99,6 +130,7 @@ class AgentExecutor {
     getLastAgentMessage(agentContext) {
         const stateGraph = (0, stategraph_1.sessionStateGraphGet)(agentContext);
         const messages = stateGraph.discussions[0].messages;
+        // console.log('---- DBG system message (check context-trail):', messages[0]?.content?.substring(messages[0].content.indexOf('<context-trail>'), messages[0].content.indexOf('</context-trail>') + 17));
         if (!messages || !messages.length) {
             return '[Aucun message trouvé]';
         }

package/dist/src/agents/simulator.js

@@ -21,46 +21,83 @@ class AgentSimulator {
      */
     async executeSimulation(options) {
         const context = await this.executor.initializeContexts();
+        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);
+            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);
-            // Callback pour message initial du simulateur
+            // Stocker le message initial du simulateur
+            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
                 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);
                 }
+                // Incrémenter le compteur après la réponse de l'agent (assistant)
+                exchangeCounter++;
                 // Simulateur évalue et répond
                 const simulatorResult = await this.executor.executeSimulator(context, agentResponse);
+                // console.log(context.agentContext.messages);
                 // 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 +106,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
             };
         }
     }
@@ -122,17 +160,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 +179,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 +198,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 +209,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,12 +219,13 @@ 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_)/);
+        const tagIndex = response.search(/\[(DONE|SIMULATION_COMPLETE|TERMINE|BUG_)/);
         return tagIndex !== -1 ? response.substring(0, tagIndex).trim() : response;
     }
     /**
@@ -191,15 +233,31 @@ class AgentSimulator {
      */
     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);
+            if (constraint.equal !== undefined && count !== constraint.equal) {
+                errors.push(`Tool '${toolName}': expected ${constraint.equal}, got ${count}`);
+            }
+        }
+        return {
+            passed: errors.length === 0,
+            errors
+        };
+    }
 }
 exports.AgentSimulator = AgentSimulator;

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

@@ -3,7 +3,7 @@ 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";
+export declare const GENERIC_SIMULATOR_PROMPT = "\n# TON R\u00D4LE\nTu dois v\u00E9rifier le comportement d'un AGENT CONVERSATIONNEL externe (The Guardian).\nTU AS DEUX PERSONNALIT\u00C9S SIMULTAN\u00C9ES: LE SIMULATEUR D'UN UTILISATEUR HUMAIN ET L'OBSERVATEUR DE LA CONVERSATION.\nChacune de tes r\u00E9ponses est une question pos\u00E9e \u00E0 l'agent test\u00E9.\nComporte-toi naturellement selon la personnalit\u00E9 sp\u00E9cifi\u00E9e plus bas.\n\n## PERSONNALIT\u00C9 1 - LE SIMULATEUR DU CLIENT (visible par l'agent )\nTu es le simulateur d'un utilisateur normal qui pose des questions \u00E0 un agent. \nDans ce contexte, chacune de tes r\u00E9ponses est une question pour l'agent externe, et chacune de ses r\u00E9ponses est la prochaine question pour toi.\n- Tu parles UNIQUEMENT en texte naturel non r\u00E9p\u00E9titif.\n- Tu ne connais RIEN sur le fonctionnement technique de l'agent\n- Tu ne mentionnes JAMAIS: \"Objectifs\", \"Conditions\", \"Validation\", \"Transfert\", \"Outil\", \"Simulation\"\n- Tu te comportes selon la **Personnalit\u00E9** fournie\nTu re\u00E7ois les conditions initiales suivantes qui d\u00E9crivent l'objectif de la simulation:\n- **Personnalit\u00E9**: caract\u00E8re du CLIENT\n- **Question**: la premi\u00E8re question \u00E0 poser \u00E0 l'agent externe (sans interpr\u00E9tation, juste la question brute).\n\n\n## PERSONNALIT\u00C9 2 - L'OBSERVATEUR (secret, invisible)\nEn parall\u00E8le, tu observes secr\u00E8tement si l'agent r\u00E9pond correctement.\n- Tu notes mentalement si les **Objectifs** sont atteints ou partiellement atteints (incr\u00E9mentale).\n- Tu ne R\u00C9V\u00C8LES JAMAIS les observations dans tes messages.\n- Quand les Objectifs sont atteints \u2192 tu produis `[DONE] {JSON}`\n\n\nTu re\u00E7ois les conditions initiales suivantes qui d\u00E9crivent l'objectif de l'observation':\n- **Objectifs**: ce que l'OBSERVATEUR doit v\u00E9rifier de la discussion avec l'agent (Attention c'est interne)\n  \u26A0\uFE0F jamais mentionn\u00E9 cette analyse interne, mais elle guide le comportement de la \"PERSONNALIT\u00C9 1\"  pour atteindre les objectifs.\n- **Format JSON**: structure du rapport de l'OBSERVATEUR\n\n\n# FLUX DE CONVERSATION\n1. Re\u00E7ois l'INPUT avec ta **Question** initiale\n2. Pose cette question \u00E0 l'agent (PERSONNALIT\u00C9 CLIENT)\n3. L'agent r\u00E9pond\n4. Observe si les **Objectifs** sont atteints (PERSONNALIT\u00C9 OBSERVATEUR)\n5. Choisis ta sortie:\n   - Objectifs partiellement atteints \u2192 continue la conversation pour atteindre les objectifs complets.\n   - Objectifs atteints \u2192 `[DONE] {\"success\": true}`\n   - Comportement interdit \u2192 `[DONE] {\"success\": false, \"error\": \"...\"}` explique la raison de l'\u00E9chec.\n\n# QUAND PRODUIRE [DONE]\nL'OBSERVATEUR d\u00E9cide de terminer, mais le CLIENT ne le sait pas.\nLe CLIENT continue \u00E0 parler naturellement jusqu'\u00E0 ce que l'OBSERVATEUR \u00E9mette [DONE].\n\n# FORMAT INPUT\n- **Personnalit\u00E9**: caract\u00E8re du CLIENT\n- **Question**: ce que le CLIENT demande initialement\n- **Objectifs**: ce que l'OBSERVATEUR doit v\u00E9rifier (PRIV\u00C9, jamais mentionn\u00E9 par le CLIENT)\n- **Format JSON**: format du rapport de l'OBSERVATEUR\n\n";
 /**
  * 3 prompts variables de personnalité pré-définis à choisir manuellement
  */
@@ -12,5 +12,6 @@ export declare const PERSONA_PRESSE = "Utilisateur press\u00E9 qui veut une solu
 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
+ * Supporte l'ancien format avec testQuery pour rétrocompatibilité
  */
-export declare const buildSimulatorQuery: (scenario: SimulationScenario) => string;
+export declare const buildSimulatorQuery: (scenario: SimulationScenario, query?: string) => string;