agentic-api 2.0.646 → 2.0.885

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

@@ -1,4 +1,4 @@
-import { SimulatorConfig, SimulationOptions, SimulationResult, TestScenario, TestCaseInput } from './simulator.types';
+import { SimulatorConfig, SimulationOptions, SimulationResult, TestScenario, TestCaseInput, WorkerJobInput, WorkerResult } from './simulator.types';
 export declare class AgentSimulator {
     private config;
     private executor;
@@ -27,6 +27,33 @@ export declare class AgentSimulator {
      * ```
      */
     testCase(scenario: TestScenario, testCase: TestCaseInput): Promise<SimulationResult>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    runJob(input: WorkerJobInput): Promise<WorkerResult>;
     /**
      * @deprecated Utiliser testCase(scenario, case) à la place
      *
@@ -47,7 +74,7 @@ export declare class AgentSimulator {
     executeSimulation(options: SimulationOptions): Promise<SimulationResult>;
     /**
      * 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
@@ -67,6 +94,9 @@ export declare class AgentSimulator {
         execution: any;
     };
     private isSimulationComplete;
+    private isWorkerComplete;
+    private isWorkerCompletionValid;
+    private parseWorkerResult;
     private parseSimulationResult;
     private extractConversationalPart;
     /**

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

@@ -1,17 +1,21 @@
+import { AgenticContext } from '../types';
 import { SimulatorConfig, ExecutionContext, SimulationScenario } from './simulator.types';
 export declare class AgentExecutor {
     private config;
     private simulatorAgentBase;
     private mockCacheInitializer?;
     private ragManager?;
+    private isWorkerMode;
     constructor(config: SimulatorConfig & {
         mockCacheInitializer?: (sessionId: string) => Promise<void>;
     });
     /**
-     * Initialiser les contextes agent et simulateur
-     * @param scenario Le scenario de simulation complet avec persona, goals, result
+     * Initialiser les contextes agent et orchestrateur (simulateur ou worker)
+     *
+     * @param scenario Le scenario de simulation (ignoré en mode worker)
+     * @param externalAgentContext Contexte réel de l'agent (mode worker uniquement)
      */
-    initializeContexts(scenario: SimulationScenario): Promise<ExecutionContext>;
+    initializeContexts(scenario: SimulationScenario, externalAgentContext?: AgenticContext): Promise<ExecutionContext>;
     /**
      * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
      */
@@ -21,8 +25,7 @@ export declare class AgentExecutor {
      */
     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é
+     * Construire l'injection de contexte à chaque tour
      */
     private buildAgentContextInjection;
     /**
@@ -34,3 +37,10 @@ export declare class AgentExecutor {
      */
     private getLastAssistantMessage;
 }
+/**
+ * Construit le tag <execution-context> injecté à chaque tour.
+ * Exporté pour tests unitaires.
+ */
+export declare function buildExecutionContextTag(exchangeCount: number, maxTurns?: number, actions?: {
+    action: string;
+}[]): string;

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

@@ -1,71 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentExecutor = void 0;
+exports.buildExecutionContextTag = buildExecutionContextTag;
+const utils_1 = require("../utils");
 const rag_1 = require("../rag");
 const stategraph_1 = require("../stategraph");
 const execute_1 = require("../execute");
+const simulator_types_1 = require("./simulator.types");
 const simulator_prompts_1 = require("./simulator.prompts");
 class AgentExecutor {
     constructor(config) {
         this.config = config;
-        // Configuration de base du simulateur (instructions seront construites dynamiquement avec le scenario)
+        this.isWorkerMode = config.mode === 'worker';
+        //
+        // Configuration de base du LLM orchestrateur
+        // - Mode simulator : testeur automatisé avec GENERIC_SIMULATOR_PROMPT
+        // - Mode worker : collaborateur avec WORKER_INTERNAL_PROMPT
         this.simulatorAgentBase = {
-            name: "simple-simulator",
-            model: ("HIGH-fast"),
-            publicDescription: "Simulateur simple pour tests - TOUJOURS retourner JSON valide",
+            name: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_NAME : simulator_types_1.SIMULATOR_AGENT_NAME,
+            model: (config.workerModel || 'HIGH-fast'),
+            publicDescription: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_DESCRIPTION : simulator_types_1.SIMULATOR_AGENT_DESCRIPTION,
             cancelMemory: true,
-            instructions: '', // Sera construit dans initializeContexts avec GENERIC_SIMULATOR_PROMPT
+            instructions: '', // Sera construit dans initializeContexts
             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);
+        // DANGER: sans ce filtre, le Worker appelle createWorkerJob en boucle
+        // récursive (33 jobs créés en <1s, crash sur la limite de 20).
+        // IMPORTANT: cloner les agents pour ne pas muter l'original (singleton _defaultAgent)
+        // FIXME: remplacer par une construction dynamique du périmètre tools
+        // (ex: excludeTools sur AgentConfig, lu par injectTransferTools)
+        const EXCLUDES_TOOLS = ['searchNoteMemories', 'updateUserMemory', 'createWorkerJob', 'createTaskListJob', 'sendFeedbackEmail'];
+        // const JOB_TOOLS = ['createWorkerJob', 'createTaskListJob'];
+        config.agents = config.agents.map(agent => ({
+            ...agent,
+            tools: agent.tools ? [...agent.tools] : [],
+            //
+            // Override du modèle de l'agent piloté si spécifié
+            ...(this.isWorkerMode && config.agentModel ? { model: config.agentModel } : {})
+        }));
+        if (this.isWorkerMode) {
+            //
+            // Mode worker : supprimer les tools de création de jobs (anti-récursion)
+            // et les tools mémoire (réservés aux interactions directes utilisateur)
+            const excludeWorker = [...EXCLUDES_TOOLS];
+            config.agents.forEach(agent => {
+                agent.tools = agent.tools.filter(t => !excludeWorker.includes(t.function?.name));
+            });
+        }
+        else {
+            //
+            // Mode simulator : supprimer les tools mémoire des agents en test
+            config.agents.forEach(agent => {
+                agent.cancelMemory = true;
+                agent.tools = agent.tools.filter(t => !EXCLUDES_TOOLS.includes(t.function?.name));
+            });
+        }
+        //
+        // Mode simulator uniquement : mockCacheInitializer et RAGManager
+        if (!this.isWorkerMode) {
+            this.mockCacheInitializer = config.mockCacheInitializer;
+            if (config.ragConfig) {
+                try {
+                    this.ragManager = rag_1.RAGManager.get(config.ragConfig);
+                }
+                catch (error) {
+                    console.warn('⚠️ Impossible d\'initialiser le RAGManager pour le simulateur:', error);
+                }
             }
         }
     }
     /**
-     * Initialiser les contextes agent et simulateur
-     * @param scenario Le scenario de simulation complet avec persona, goals, result
+     * Initialiser les contextes agent et orchestrateur (simulateur ou worker)
+     *
+     * @param scenario Le scenario de simulation (ignoré en mode worker)
+     * @param externalAgentContext Contexte réel de l'agent (mode worker uniquement)
      */
-    async initializeContexts(scenario) {
-        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: [] },
-            // ✅ 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}` },
-            credential: { test: true, sessionId: `sim-${sessionId}` },
+    async initializeContexts(scenario, externalAgentContext) {
+        const sessionId = `${this.isWorkerMode ? 'worker' : 'simulation'}-${Date.now()}`;
+        //
+        // Mode worker : utiliser le contexte réel fourni
+        // Mode simulator : créer un contexte mock
+        const agentContext = (this.isWorkerMode && externalAgentContext)
+            ? externalAgentContext
+            : {
+                user: { id: `test-user`, role: 'user', uid: `test-${sessionId}`, mail: `test-${sessionId}@simulator.local` },
+                credential: { test: true, sessionId: `agent-${sessionId}` },
+                verbose: this.config.verbose,
+                session: { id: `agent-${sessionId}`, data: {}, messages: [] },
+                ...(this.ragManager ? { customRag: this.ragManager.getDefault() } : {})
+            };
+        //
+        // Contexte isolé pour le LLM orchestrateur (toujours séparé)
+        const orchestratorContext = {
+            user: { id: `${this.isWorkerMode ? 'worker' : 'simulator'}-user`, role: 'user', uid: `orch-${sessionId}` },
+            credential: { test: true, sessionId: `orch-${sessionId}` },
             verbose: this.config.verbose,
-            session: { id: `sim-${sessionId}`, data: {}, messages: [] }
+            session: { id: `orch-${sessionId}`, data: {}, messages: [] }
         };
-        // ✅ Initialiser le cache mock si fourni (pour les tests SGC avec M-Files)
-        if (this.mockCacheInitializer) {
+        //
+        // Mode simulator : initialiser le cache mock
+        if (!this.isWorkerMode && 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);
+        //
+        // Construire les instructions selon le mode
+        // - Simulator : GENERIC_SIMULATOR_PROMPT(scenario) + positionDescription
+        // - Worker : WORKER_INTERNAL_PROMPT(positionDescription + personaResult)
+        const fullInstructions = this.isWorkerMode
+            ? (0, simulator_prompts_1.WORKER_INTERNAL_PROMPT)(this.config.positionDescription || '', this.config.personaResult, (0, utils_1.extractAgentCapabilities)(this.config.agents, this.config.start))
+            : (0, simulator_prompts_1.GENERIC_SIMULATOR_PROMPT)(scenario, this.config.positionDescription);
         return {
             agentContext,
-            simulatorContext,
+            simulatorContext: orchestratorContext,
             simulatorAgent: {
                 ...this.simulatorAgentBase,
                 instructions: fullInstructions
@@ -78,7 +126,6 @@ class AgentExecutor {
                 actions: [],
                 lastMessage: '',
                 usage: { prompt: 0, completion: 0, total: 0, cost: 0 }
-                // moreThinkin removed (obsolete)
             }
         };
     }
@@ -86,27 +133,41 @@ class AgentExecutor {
      * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
      */
     async executeAgent(context, query) {
+        //
+        // Mode worker uniquement : signaler à l'Agent qu'il est piloté par un orchestrateur
+        // afin d'éviter les questions de clarification sans réponse possible
+        const finalQuery = this.isWorkerMode ? simulator_prompts_1.WORKER_AUTONOMOUS_PREFIX + query : query;
         // Logique extraite de AgentVsAgentTester.executeAgentWithContext()
         const execResult = await (0, execute_1.executeAgentSet)(this.config.agents, context.agentContext, {
-            query,
+            query: finalQuery,
             home: this.config.start,
             stdout: execute_1.DummyWritable,
             verbose: this.config.verbose,
             debug: false
         });
-        // Accumuler seulement l'usage, pas les actions
+        //
+        // Accumuler usage ET actions pour la validation des outils
         if (context.lastExecution) {
+            //
+            // Accumuler l'usage
             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;
+            //
+            // Accumuler les actions (important pour toolValidation)
+            context.lastExecution.actions = [
+                ...(context.lastExecution.actions || []),
+                ...(execResult.actions || [])
+            ];
+            //
+            // Mettre à jour les autres champs avec les valeurs du dernier échange
+            context.lastExecution.runId = execResult.runId;
+            context.lastExecution.lastMessage = execResult.lastMessage;
+        }
+        else {
+            context.lastExecution = execResult;
         }
-        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);
@@ -119,36 +180,25 @@ class AgentExecutor {
         // ✅ 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);
+        // console.log(`📡 Simulator input (turn ${context.exchangeCount}/${context.maxTurns || '?'}):\n  query[${enrichedQuery.length}]: ${enrichedQuery.substring(0, 200)}${enrichedQuery.length > 200 ? '...' : ''}\n  context: ${agentContextInjection.substring(0, 120)}`);
         await (0, execute_1.executeAgentSet)([context.simulatorAgent], context.simulatorContext, {
             query: enrichedQuery,
-            home: 'simple-simulator',
+            home: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_NAME : simulator_types_1.SIMULATOR_AGENT_NAME,
             stdout: execute_1.DummyWritable,
             verbose: false,
             debug: false
         });
         const response = this.getLastAssistantMessage(context.simulatorContext);
+        // console.log(`📡 Simulator output (turn ${context.exchangeCount}): ${response.substring(0, 200)}${response.length > 200 ? '...' : ''}`);
         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é
+     * Construire l'injection de contexte à chaque tour
      */
     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>`;
+        const actions = !this.isWorkerMode ? context.lastExecution?.actions : undefined;
+        return buildExecutionContextTag(context.exchangeCount, context.maxTurns, actions);
     }
     /**
      * ✅ Récupérer le dernier message de l'agent testé (extraction de agent-vs-agent.ts ligne 168-191)
@@ -188,3 +238,20 @@ class AgentExecutor {
     }
 }
 exports.AgentExecutor = AgentExecutor;
+/**
+ * Construit le tag <execution-context> injecté à chaque tour.
+ * Exporté pour tests unitaires.
+ */
+function buildExecutionContextTag(exchangeCount, maxTurns, actions) {
+    const max = maxTurns || 10;
+    const contextData = {
+        turn: exchangeCount,
+        maxTurns: max,
+        // Le simulateur doit toujours disposer d'un tour pour évaluer la réponse courante.
+        turnsRemaining: exchangeCount === 0 ? max : Math.max(1, max - exchangeCount)
+    };
+    if (actions?.length) {
+        contextData.tools = actions.map(a => a.action);
+    }
+    return `<execution-context>\n${JSON.stringify(contextData)}\n</execution-context>`;
+}