agentic-api 2.0.646 → 2.0.885

package/dist/src/agents/simulator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentSimulator = void 0;
 const simulator_executor_1 = require("./simulator.executor");
+const execute_1 = require("../execute");
 class AgentSimulator {
     constructor(config) {
         this.config = config;
@@ -59,6 +60,195 @@ class AgentSimulator {
         });
     }
     // ============================================================================
+    // WORKER API : runJob(input) — exécution de mission autonome
+    // ============================================================================
+    /**
+     * Exécuter un WorkerJob — boucle Worker LLM ↔ Agent LLM
+     *
+     * Parallèle à testCase() mais pour des missions de production :
+     * - Le Worker LLM formule des questions pour l'Agent
+     * - L'Agent répond avec ses tools (RAG, DB, emails, calendar...)
+     * - Le Worker LLM évalue et continue ou termine avec [WORKER_COMPLETE]
+     *
+     * @param input - Paramètres du job (query, maxIterations, agentContext)
+     * @returns WorkerResult
+     *
+     * @example
+     * ```typescript
+     * const worker = new AgentSimulator({
+     *   agents: [...], start: 'PR-knowledge', verbose: false,
+     *   mode: 'worker',
+     *   positionDescription: 'Consulter tous les mails du jour et résumer les actions'
+     * });
+     *
+     * const result = await worker.runJob({
+     *   query: 'Commence par lister les mails du jour',
+     *   maxIterations: 10,
+     *   agentContext: realContext
+     * });
+     * ```
+     */
+    async runJob(input) {
+        const startTime = Date.now();
+        const maxIterations = input.maxIterations ?? 10;
+        const stdout = input.agentContext?.stdout || execute_1.DummyWritable;
+        const emptyUsage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+        //
+        // Helper : émettre un WorkerEvent via sendFeedback
+        const emitWorkerEvent = (description, data) => {
+            (0, execute_1.sendFeedback)({
+                agent: 'worker',
+                stdout,
+                description,
+                usage: context.lastExecution?.usage || emptyUsage,
+                state: input.jobId || '',
+                data
+            });
+        };
+        //
+        // Initialiser les contextes avec le contexte réel de l'agent
+        const context = await this.executor.initializeContexts({ goals: '', persona: '', result: '' }, input.agentContext);
+        context.maxTurns = maxIterations;
+        const allMessages = [];
+        let exchangeCounter = 0;
+        //
+        // Événement : worker_started
+        emitWorkerEvent(input.description || 'Worker démarré', { type: 'worker_started', jobId: input.jobId || '', maxIterations, description: input.description });
+        try {
+            let currentUserQuery = input.query;
+            //
+            // Stocker le message initial
+            const initialMsg = { content: currentUserQuery, role: 'user' };
+            allMessages.push(initialMsg);
+            if (input.onMessage) {
+                input.onMessage(initialMsg);
+            }
+            //
+            // Boucle Worker — maxIterations échanges (parallèle à executeSimulation)
+            while (exchangeCounter < maxIterations) {
+                //
+                // Événement : worker_iteration (avant appel Agent)
+                emitWorkerEvent(currentUserQuery.substring(0, 120), { type: 'worker_iteration', iteration: exchangeCounter + 1, maxIterations, query: currentUserQuery.substring(0, 200) });
+                //
+                // Agent répond à la question
+                const agentResponse = await this.executor.executeAgent(context, currentUserQuery);
+                const agentMsg = { content: agentResponse, role: 'assistant' };
+                allMessages.push(agentMsg);
+                if (input.onMessage) {
+                    input.onMessage(agentMsg);
+                }
+                exchangeCounter++;
+                //
+                // Worker LLM évalue la réponse de l'Agent
+                const workerResponse = await this.executor.executeSimulator(context, agentResponse);
+                //
+                // Vérifier [WORKER_COMPLETE]
+                if (this.isWorkerComplete(workerResponse)) {
+                    const parsed = this.parseWorkerResult(workerResponse);
+                    if (this.isWorkerCompletionValid(parsed)) {
+                        this.lastExecution = context.lastExecution;
+                        const duration = Date.now() - startTime;
+                        emitWorkerEvent(parsed.summary || 'Worker terminé', { type: 'worker_completed', success: true, summary: parsed.summary, iterations: exchangeCounter, duration });
+                        return {
+                            success: true,
+                            deliverable: parsed.deliverable,
+                            summary: parsed.summary,
+                            confidence: parsed.confidence,
+                            iterations: exchangeCounter,
+                            maxIterations,
+                            duration,
+                            execution: context.lastExecution,
+                            messages: allMessages
+                        };
+                    }
+                    this.lastExecution = context.lastExecution;
+                    const duration = Date.now() - startTime;
+                    emitWorkerEvent('Clôture invalide', { type: 'worker_failed', error: 'deliverable must be concrete and non-empty', iterations: exchangeCounter, duration });
+                    return {
+                        success: false,
+                        deliverable: '',
+                        summary: 'Invalid [WORKER_COMPLETE] payload',
+                        confidence: 0,
+                        iterations: exchangeCounter,
+                        maxIterations,
+                        duration,
+                        execution: context.lastExecution,
+                        messages: allMessages,
+                        error: 'Worker completion rejected: deliverable must be concrete and non-empty'
+                    };
+                }
+                //
+                // Pas terminé — extraire la prochaine question pour l'Agent
+                currentUserQuery = this.extractConversationalPart(workerResponse);
+                if (currentUserQuery) {
+                    const workerMsg = { content: currentUserQuery, role: 'user' };
+                    allMessages.push(workerMsg);
+                    if (input.onMessage) {
+                        input.onMessage(workerMsg);
+                    }
+                }
+            }
+            //
+            // Budget épuisé — forcer une conclusion avant de déclarer timeout
+            // On demande au Worker LLM de synthétiser tout ce qui a été collecté
+            const forceConcludeMsg = `[BUDGET ÉPUISÉ — dernier tour obligatoire]\nTu as utilisé ${exchangeCounter}/${maxIterations} tours. Produis maintenant ton [WORKER_COMPLETE] final en synthétisant toutes les informations récoltées.`;
+            const forceResponse = await this.executor.executeSimulator(context, forceConcludeMsg);
+            if (this.isWorkerComplete(forceResponse)) {
+                const parsed = this.parseWorkerResult(forceResponse);
+                if (this.isWorkerCompletionValid(parsed)) {
+                    this.lastExecution = context.lastExecution;
+                    const duration = Date.now() - startTime;
+                    emitWorkerEvent(parsed.summary || 'Worker terminé (budget épuisé)', { type: 'worker_completed', success: true, summary: parsed.summary, iterations: exchangeCounter, duration });
+                    return {
+                        success: true,
+                        deliverable: parsed.deliverable,
+                        summary: parsed.summary,
+                        confidence: parsed.confidence,
+                        iterations: exchangeCounter,
+                        maxIterations,
+                        duration,
+                        execution: context.lastExecution,
+                        messages: allMessages
+                    };
+                }
+            }
+            //
+            // Timeout réel — le Worker n'a pas pu conclure
+            this.lastExecution = context.lastExecution;
+            const duration = Date.now() - startTime;
+            emitWorkerEvent(`Limite atteinte (${maxIterations} itérations)`, { type: 'worker_failed', error: 'Max iterations reached', iterations: exchangeCounter, duration });
+            return {
+                success: false,
+                deliverable: '',
+                summary: `Max iterations reached (${maxIterations})`,
+                confidence: 0,
+                iterations: exchangeCounter,
+                maxIterations,
+                duration,
+                execution: context.lastExecution,
+                messages: allMessages,
+                error: 'Max iterations reached without [WORKER_COMPLETE]'
+            };
+        }
+        catch (error) {
+            this.lastExecution = context.lastExecution;
+            const duration = Date.now() - startTime;
+            emitWorkerEvent(`Erreur: ${(error.message || error).substring(0, 80)}`, { type: 'worker_failed', error: error.message || String(error), iterations: exchangeCounter, duration });
+            return {
+                success: false,
+                deliverable: '',
+                summary: '',
+                confidence: 0,
+                iterations: exchangeCounter,
+                maxIterations,
+                duration,
+                execution: context.lastExecution,
+                messages: allMessages,
+                error: `Erreur d'exécution: ${error.message || error}`
+            };
+        }
+    }
+    // ============================================================================
     // ANCIENNE API : executeSimulation(options) - deprecated
     // ============================================================================
     /**
@@ -81,6 +271,7 @@ class AgentSimulator {
     async executeSimulation(options) {
         // ✅ Initialiser les contextes avec le scenario complet
         const context = await this.executor.initializeContexts(options.scenario);
+        context.maxTurns = options.maxExchanges;
         const allMessages = [];
         let lastAgentMessage = '';
         let exchangeCounter = 0; // Compteur d'échanges (user+assistant)
@@ -118,12 +309,18 @@ class AgentSimulator {
                     const parsed = this.parseSimulationResult(simulatorResult, expectedFormat, context);
                     this.lastExecution = context.lastExecution;
                     // Validation des tools si expectedTool est fourni
-                    if (options.expectedTool) {
+                    if (options.expectedTool && Object.keys(options.expectedTool).length > 0) {
                         const validation = this.validateExpectedTools(options.expectedTool);
+                        //
+                        // Toujours définir toolValidation pour inspection par les tests
+                        parsed.toolValidation = validation;
                         if (!validation.passed) {
                             parsed.success = false;
-                            parsed.error = validation.errors.join('; ');
-                            parsed.toolValidation = validation;
+                            //
+                            // Préserver l'erreur LLM si présente, ajouter l'erreur de validation
+                            const llmError = parsed.error || '';
+                            const toolError = validation.errors.join('; ');
+                            parsed.error = llmError ? `${llmError} | Tool validation: ${toolError}` : toolError;
                         }
                     }
                     // Ajouter l'historique des messages au résultat
@@ -149,12 +346,16 @@ class AgentSimulator {
             const timeout = await this.generateTimeoutReport(context, expectedFormat);
             this.lastExecution = context.lastExecution;
             // Validation des tools même en cas de timeout
-            if (options.expectedTool) {
+            if (options.expectedTool && Object.keys(options.expectedTool).length > 0) {
                 const validation = this.validateExpectedTools(options.expectedTool);
+                //
+                // Toujours définir toolValidation pour inspection par les tests
+                timeout.toolValidation = validation;
                 if (!validation.passed) {
                     timeout.success = false;
-                    timeout.error = validation.errors.join('; ');
-                    timeout.toolValidation = validation;
+                    const llmError = timeout.error || '';
+                    const toolError = validation.errors.join('; ');
+                    timeout.error = llmError ? `${llmError} | Tool validation: ${toolError}` : toolError;
                 }
             }
             return { ...timeout, exchangeCount: exchangeCounter, messages: allMessages }; // Utiliser notre compteur      
@@ -173,7 +374,7 @@ class AgentSimulator {
     }
     /**
      * Compter les occurrences d'une action dans le dernier ExecutionResult
-     * @param name Nom exact de l'action (ex: 'lookupMfilesIntervenant', 'lookupKnowledge', 'sendInternalEmail')
+     * @param name Nom exact de l'action (ex: 'resolveLocataire', '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
@@ -222,6 +423,48 @@ class AgentSimulator {
     isSimulationComplete(response) {
         return response.includes('[DONE]') || response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]');
     }
+    isWorkerComplete(response) {
+        return response.includes('[WORKER_COMPLETE]');
+    }
+    isWorkerCompletionValid(parsed) {
+        const deliverable = (parsed.deliverable || '').trim();
+        const summary = (parsed.summary || '').trim();
+        if (!deliverable) {
+            return false;
+        }
+        // Rejeter les fausses clôtures qui ne sont qu'une enveloppe JSON sérialisée en texte.
+        const isWrappedJsonEnvelope = deliverable.startsWith('{')
+            && /"deliverable"\s*:/.test(deliverable)
+            && /"summary"\s*:/.test(deliverable);
+        if (isWrappedJsonEnvelope) {
+            return false;
+        }
+        // Rejeter les clôtures déclaratives sans résultat concret.
+        if (/^instruction envoy[ée]e?/i.test(summary)) {
+            return false;
+        }
+        return true;
+    }
+    parseWorkerResult(response) {
+        const match = response.match(/\[WORKER_COMPLETE\]\s*\n?([\s\S]*)/);
+        if (match) {
+            const content = match[1].trim();
+            try {
+                const parsed = JSON.parse(content);
+                return {
+                    deliverable: parsed.deliverable || content,
+                    summary: parsed.summary || '',
+                    confidence: parsed.confidence ?? 0.5
+                };
+            }
+            catch {
+                //
+                // Fallback : contenu brut comme deliverable
+                return { deliverable: content, summary: '', confidence: 0.5 };
+            }
+        }
+        return { deliverable: '', summary: '', confidence: 0 };
+    }
     parseSimulationResult(response, expectedFormat, context) {
         // Le simulateur produit directement le résultat et rapport
         // Parsing pour détecter la fin et extraire le contenu JSON
@@ -286,7 +529,7 @@ class AgentSimulator {
     extractConversationalPart(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);
+        const tagIndex = response.search(/\[(DONE|SIMULATION_COMPLETE|TERMINE|WORKER_COMPLETE|BUG_|OBSERVATEUR|À NOTER|NOTE|ANALYSE)/i);
         if (tagIndex !== -1) {
             return response.substring(0, tagIndex).trim();
         }

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

@@ -1,18 +1,63 @@
 import { SimulationScenario } from "./simulator.types";
 /**
- * Génère le prompt du simulateur générique avec le scenario intégré
- *
- * Basé sur ClientSimulator avec Mirror Agent Model
- * Intègre directement les valeurs du scenario dans des tags XML
- *
- * @param scenario - Scenario de simulation avec persona, goals, result
- * @param instructionEx - Instructions additionnelles spécifiques à l'agent (ajoutées à la fin)
- * @returns Prompt complet avec plan de simulation intégré
+ * Section ACTEURS — décrit les 3 rôles de la boucle.
+ * Spécifique par agent : le descripteur de l'orchestrateur diffère.
  */
-export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, instructionEx?: string): string;
+export declare const acteursSectionSimulatorPrompt = "# ACTEURS\nIl y a 3 acteurs dans cette boucle de test E2E :\n1. **Utilisateur** \u2014 celui qui a pos\u00E9 la question initiale (premier message). Il est HORS boucle.\n2. **Agent** \u2014 il poss\u00E8de les outils de l'entreprise et r\u00E9pond \u00E0 tes demandes. C'est lui qu'on teste.\n3. **Toi (Simulateur)** \u2014 tu pilotes l'Agent tour par tour selon <simulation_brief> et tu \u00E9values ses r\u00E9ponses. Ta personnalit\u00E9 est d\u00E9crite dans <persona_user>.";
+export declare const acteursSectionWorkerPrompt = "# ACTEURS\nIl y a 3 acteurs dans cette boucle de travail :\n1. **Utilisateur** \u2014 celui qui a pos\u00E9 la question initiale (premier message). Il est HORS boucle pendant l'ex\u00E9cution : tu ne dois jamais le solliciter ni attendre d'information de sa part.\n2. **Agent** \u2014 il dispose des outils de l'entreprise et ex\u00E9cute tes demandes.\n3. **Toi (Worker)** \u2014 tu pilotes l'Agent tour par tour afin d'accomplir la mission d\u00E9crite dans <worker_brief>.";
 /**
- * 3 prompts variables de personnalité pré-définis à choisir manuellement
+ * Section DÉMARRAGE / premier tour — comportement au premier message.
+ * - Simulator : avertissement sur la nature du premier message (réponse Agent, pas utilisateur).
+ * - Worker : dérivation d'intention depuis les déclencheurs de la fiche de poste.
  */
+export declare const starterSectionSimulatorPrompt = "\u26A0\uFE0F Le premier message que tu re\u00E7ois est d\u00E9j\u00E0 la r\u00E9ponse de l'Agent \u00E0 la question initiale de l'Utilisateur. Ce n'est PAS un message de l'utilisateur.";
+export declare const starterSectionWorkerPrompt = "# D\u00C9MARRAGE (premier tour uniquement)\nAvant d'envoyer ta premi\u00E8re demande \u00E0 l'Agent :\n1. Identifie si une intention est **explicite** dans le message [verbe + objet direct].\n2. Si non (texte brut, r\u00E9sum\u00E9 de mail, message ambigu) \u2192 parcours les champs `D\u00E9clencheur:` des **Activit\u00E9s** de ta `<worker_brief>`. S\u00E9lectionne l'activit\u00E9 dont le d\u00E9clencheur correspond le mieux au message : son champ `Travail:` d\u00E9finit ton objectif, son champ `B\u00E9n\u00E9ficiaire:` identifie le destinataire.\n3. Formule un plan d'action en 2-3 \u00E9tapes **(raisonnement interne \u2014 ne jamais l'envoyer \u00E0 l'Agent)**.\n4. Premi\u00E8re demande = \u00E9tape 1 du plan, cibl\u00E9e et sourc\u00E9e. Pas de pr\u00E9ambule ni num\u00E9rotation.";
+/**
+ * Section LIFECYCLE — budget de tours injecté à chaque tour via <execution-context>.
+ * - Simulator : inclut aussi `tools` (outils réellement appelés) pour validation E2E.
+ * - Worker : inclut les instructions de clôture au dernier tour (fallback utile).
+ */
+export declare const lifecycleSectionSimulatorPrompt = "# LIFECYCLE\n\u00C0 chaque tour, un tag `<execution-context>` est inject\u00E9 avec :\n- `turn` : tour actuel\n- `maxTurns` : budget total\n- `turnsRemaining` : tours restants\n- `tools` : noms exacts des outils **r\u00E9ellement appel\u00E9s** par l'Agent pendant ce tour\nUtilise cette info pour planifier : si peu de tours restent, privil\u00E9gie les questions qui valident directement les objectifs.\n**CRITIQUE**: Si un outil appara\u00EEt dans `tools`, il a **r\u00E9ellement \u00E9t\u00E9 ex\u00E9cut\u00E9**.\n**\u00C9QUIVALENCE M\u00C9TIER**: pour l'\u00E9valuation, `M-Files` = `GED` = outils `resolve*` / `lookupMfiles*`. Si l'objectif demande d'utiliser le GED ou M-Files et qu'un outil `resolve*` ou `lookupMfiles*` appara\u00EEt dans `tools`, consid\u00E8re que l'objectif GED/M-Files est satisfait.";
+export declare const lifecycleSectionWorkerPrompt = "# LIFECYCLE\n\u00C0 chaque tour, un tag `<execution-context>` est inject\u00E9 avec ton budget :\n- `turn` : tour actuel\n- `maxTurns` : budget total\n- `turnsRemaining` : tours restants\nUtilise cette info pour prioriser : si peu de tours restent, concentre-toi sur le livrable.\n**DERNIER TOUR** : quand `turnsRemaining` \u2264 1, tu DOIS conclure avec `[WORKER_COMPLETE]` en synth\u00E9tisant toutes les informations r\u00E9colt\u00E9es.\nSi l'information est insuffisante, fournis un **fallback utile** : meilleures hypoth\u00E8ses explicites + options + plan d'action concret (sans inventer de faits). Ne demande pas de tour suppl\u00E9mentaire.";
+/**
+ * Section SAFETY — règles anti-hallucination.
+ * Formulation différente selon le rôle (évaluateur vs exécutant).
+ */
+export declare const safetySectionSimulatorPrompt = "# SAFETY\n- N'invente pas de r\u00E9sultats d'outils.\n- Si l'Agent a produit une r\u00E9ponse visible dans la conversation, \u00E9value-la \u2014 ne d\u00E9clare jamais \"pas de r\u00E9ponse\".";
+export declare const safetySectionWorkerPrompt = "# SAFETY\n- N'invente pas de faits.\n- Si l'information est incertaine ou incompl\u00E8te, indique-le dans `summary`.";
+/**
+ * Bloc CRITICAL final — rappel JSON strict après le trigger de sortie.
+ * Factorisé via fonction car seul le nom du trigger diffère.
+ */
+export declare function buildCriticalBlock(trigger: string): string;
 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";
+export declare const PERSONA_RESULT_CLIENT = "R\u00E9daction claire et orient\u00E9e client, empathique, sans jargon interne, avec des conclusions directement actionnables.";
+/**
+ * Préfixe injecté au premier message Worker→Agent en mode autonome.
+ * Signale à l'Agent qu'il est piloté par un orchestrateur et doit éviter
+ * les questions de clarification destinées à un utilisateur humain.
+ */
+export declare const WORKER_AUTONOMOUS_PREFIX = "[MODE AUTONOME] Tu es pilot\u00E9 par un orchestrateur. Ne pose pas de question de clarification,  va droit au but, pas de bavardage ni de formules de politesse superflues.\n\n";
+/**
+ * Génère le prompt du simulateur générique avec le scenario intégré.
+ *
+ * @param scenario - Scénario de simulation avec persona, goals, result
+ * @param positionDescription - Instructions additionnelles (ajoutées à la fin)
+ */
+export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, positionDescription?: string): string;
+/**
+ * Prompt interne fixe du WorkerJob — system prompt pour le Worker LLM.
+ *
+ * Structure (inspirée OpenClaw) :
+ *   CONTEXT     → ACTEURS, CAPACITÉS AGENT, worker_brief (persona/soul)
+ *   PROCESS     → DÉMARRAGE, MISSION, BOUCLE DE DÉCISION, STYLE
+ *   CONSTRAINTS → CONTRAINTES (RÈGLES + BLOCAGE + NO-PROGRESS + INTERDICTIONS)
+ *   OUTPUT      → LIFECYCLE, SAFETY, VÉRIFICATION, TRIGGERS, FORMAT
+ *
+ * @param positionDescription - Fiche de poste du collaborateur (= PERSONA_PROMPTS[key], tronquée à -- END --)
+ * @param personaResult - Style du deliverable final (orienté client)
+ * @param agentCapabilities - Capacités de l'Agent (firstLine de chaque tool.function.description)
+ */
+export declare function WORKER_INTERNAL_PROMPT(positionDescription: string, personaResult?: string, agentCapabilities?: string): string;