agentic-api 2.0.31 → 2.0.491

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

@@ -7,13 +7,17 @@ export declare class AgentSimulator {
     /**
      * 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)
      */
     executeSimulation(options: SimulationOptions): Promise<SimulationResult>;
     /**
@@ -44,4 +48,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

@@ -1,12 +1,17 @@
-import { SimulatorConfig, ExecutionContext } from './simulator.types';
+import { SimulatorConfig, ExecutionContext, SimulationScenario } from './simulator.types';
 export declare class AgentExecutor {
     private config;
-    private simulatorAgent;
-    constructor(config: SimulatorConfig);
+    private simulatorAgentBase;
+    private mockCacheInitializer?;
+    private ragManager?;
+    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
      */
-    initializeContexts(): Promise<ExecutionContext>;
+    initializeContexts(scenario: SimulationScenario): Promise<ExecutionContext>;
     /**
      * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
      */
@@ -15,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

@@ -1,37 +1,53 @@
 "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");
 class AgentExecutor {
     constructor(config) {
         this.config = config;
-        // Construire les instructions complètes du simulateur
-        const fullInstructions = simulator_prompts_1.GENERIC_SIMULATOR_PROMPT +
-            (config.instructionEx ? `\n\n${config.instructionEx}` : '') +
-            '\n\n**CRITICAL**: Your response after [SIMULATION_COMPLETE] must be valid JSON format only.';
-        // Agent simulateur simple pour éviter les dépendances complexes du ClientSimulator  
-        this.simulatorAgent = {
+        // Configuration de base du simulateur (instructions seront construites dynamiquement avec le scenario)
+        this.simulatorAgentBase = {
             name: "simple-simulator",
-            model: (0, execute_1.modelConfig)("MEDIUM-fast"), // JSON sera forcé via les instructions du prompt
+            model: ("HIGH-fast"),
             publicDescription: "Simulateur simple pour tests - TOUJOURS retourner JSON valide",
-            instructions: fullInstructions,
+            cancelMemory: true,
+            instructions: '', // Sera construit dans initializeContexts avec GENERIC_SIMULATOR_PROMPT
             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
+     * @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}` },
             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,9 +55,21 @@ 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);
+        }
+        // ✅ 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: {
@@ -49,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)
             }
         };
     }
@@ -62,16 +90,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);
@@ -80,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
         });
@@ -93,12 +131,32 @@ 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)
      */
     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é]';
         }