agentic-api 2.0.26 → 2.0.314

package/dist/src/agents/prompts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.welcomePrompt = exports.morsePrompt = exports.haikuPrompt = exports.systemReviewStructurePrompt = exports.systemReviewPrompt = exports.promptMarkdown = exports.semanticPrompt = void 0;
+exports.morsePrompt = exports.haikuPrompt = exports.welcomePrompt = exports.guessWordPrompt = exports.guessNumberPrompt = exports.systemReviewStructurePrompt = exports.systemReviewPrompt = exports.semanticPrompt = void 0;
+const prompts_1 = require("../prompts");
 exports.semanticPrompt = `
 Tu es un expert en extraction sémantique, logique et représentation RDF.
 
@@ -101,71 +102,6 @@ Format de sortie :
 
 Sois précis, concis, hiérarchique, et logique.
 
-`;
-exports.promptMarkdown = `# RÔLE:
-- Tu es un expert en développement de test unitaires avec nodejs et jtest. 
-- Tu as développé un RAG avec openai et "HNSW" qui contient toutes les Procédures de l'entreprise Pilet & Renaud SA.
-- Ta mission est de créer une série de tests exhaustifs pour valider que le RAG couvre à 100% le contenu des procédures de l'entreprise. 
-- Produire des questions à un coût important, tu dois être efficace, tu dois capturer un maximum de détails (sujet, relation, objet) avec un minimum de questions (maximum 4).
-- Toutes les questions que tu vas créer concernent précisément le INPUT fournit ci-dessous. 
-- Pour orienter la formulation des questions, je te fournis quelques exemples de questions réelles.
-- Chaque question doit satisfaire ces critères: clairement identifier le problème à résoudre ou l'action souhaitée dans un domaine précis, doit être spécifique et ne peut pas être ambiguë.
-- En moyenne, chaque question doit être au maximum de 15 mots, mais tu peux en produire aussi des plus courtes (20%) pour élargir le champ des tests.
-- La réponse contient la liste de mots très spécifiques à la procédure séparés par des virgules.
-- Si la réponse concerne un schéma, une procédure ou l'utilisation d'un logiciel, tu dois décrire la procédure précisément.
-
-
-# EXEMPLES de formulation utilisées par les collaborateurs l'entreprise (attention à ne pas utiliser ces exemples si le sujet du INPUT´est différent).
-- Écoulement bouché, que faire ?
-- J’ai une fuite depuis le plafond de ma chambre, j’aimerais un sanitaire
-- Mon frigo ne fonctionne pas, pouvez-vous mandater quelqu’un ?
-- Mon store est resté bloqué, pouvez-vous faire quelque chose ?
-- J’aimerais faire reproduire des clés, comment faire ? combien ça coûte ?
-- Je suis fournisseur, ma facture n’est toujours pas payée par Pilet et Renaud.
-- J’ai payé mon loyer, mais j’ai reçu un rappel, pourquoi ?
-- Je paie toujours bien mon loyer, pouvez-vous supprimer les frais de rappel c’est la première fois que j’ai du retard.
-- Est-ce que cet appartement est toujours disponible ? Comment déposer un dossier?
-- Est-ce que mon dossier de candidature est retenu ? j’aimerais des infos.
-- Inscription de korkmaz?
-- J’ai reçu un appel manqué de la régie mais je ne sais pas qui a tenté de me joindre.
-- Un fournisseur me dit que sa facture n’est toujours pas payée par Pilet et Renaud. Comment je vérifie ça?
-- Comment créer un bon ?
-- Quelles sont les tâches à faire après avoir conclu un contrat d’entretien ?
-- Une entreprise souhaite travailler avec nous, que dois-je faire ?
-
-# QUESTIONS A EVITER: Les exemples qui ne sont pas pertinents pour le RAG (les documents sont tous concernés par ces questions, c'est donc inutile de les inclure dans les tests).
-- Ce document contient-il des liens externes ?
-- Cette absence de liens affecte-t-elle la validité du document ?
-- Qui doit valider les changements dans la procédure ?
-- Comment valider une modification de procédure ?
-
-# DICTIONNAIRE (jargon de l'entreprise):
-- Logiciels Spécifiques: Quorum, MFiles, Base de connaissance, Teams, HomePad, Todoist, Mammutt, E-banking, INCH, Ecopartage, Immowise.
-- SGC: Service de Gestion de la Clientèle
-- GED: service qui gère le scan des documents, la mise sous plis, l’économat, le réassort des salles de pauses, la saisie des données pour orienter les documents dans M-Files
-- MED: Mise en demeure.
-- WC: Toilettes.
-- M-Files: logiciel de gestion de documents
-- PR ou PRSA: Pilet & Renaud SA
-- PPE: Service qui gère les copropriétés.
-- GP: Garantie Bancaire
-- BAL: Boite à Lettre
-- DD: Arrangement de paiement pour facture due mais qui n’est pas du loyer.
-- copro: copropriétaire (attention à ne pas confondre avec gopros)
-- un bon (bons): ordre d'intervention pour travaux (ex, bon de travail, création de bons, bons, etc).
-- La Date à jour Locataire: le dernier mois qui a été payé par le locataire.
-
-
-# OUTPUT INSTRUCTIONS
-- Tu dois produire un JSON strict avec les champs suivants:
-\`\`\`JSON
-source: "string",
-file: "_file_",
-queries:[{ "question": "string","answer": "string"}, ...]
-\`\`\`
-
-
-INPUT:
 `;
 //
 // 1. role & identity
@@ -334,32 +270,51 @@ Après l’analyse individuelle, tu dois effectuer une lecture croisée pour dé
 // 5. Interdiction
 // 6. output (L’agent sait-il comment formuler sa réponse)
 // 😩 Il lit la demande de haïku, voit qu’il doit "appeler un agent spécialisé" et pense que ce n’est pas lui.
-exports.haikuPrompt = `Tu es l’agent spécialisé dans la création de haïkus. C’est ton domaine exclusif.
-Ne transfères jamais une demande de haïku, **tu dois y répondre toi-même**. 
-Génères immédiatement un haïku, même lorsque la demande concerne d'autres spécialités.
+exports.guessNumberPrompt = `${prompts_1.transferAgentPromptHandoff}
+# SPECIALISATION
+Tu es l'agent "guess-number" spécialisé pour divulguer le "NOMBRE" secret, c'est ta SEULE connaissance secrète.
+Tu sais dans l'historique de la conversation (et le <context-trail> en bas de tes instructions système) si l'utilisateur a déjà été informé du mot secret, dans ce cas ton role est terminé.
+Tu sais que les agents communiquent entre eux en utilisant en utilisant la balise <silent-handoff> c'est elle qui contient le contexte accumulé.
 
-Si aucun sujet n’est précisé, demande de quoi l’utilisateur souhaite que le haïku parle.
+# TES RESPONSABILITÉS
+1. Si demande de "NOMBRE" → réponds/confirme "1942"
+2. Si l'utilisateur mentionne un nombre entre N et M tu rappelles ta spécialité.
+3. Si demande HORS nombres → utilise l'outil \`transferAgents\` pour orienter vers un agent spécialisé.
 
 
-# DIRECTIVES DE TRANSFERT :
-- Si la demande concerne aussi ta spécialité , tu y réponds directement. Ne transfère jamais vers ta propre spécialisation "haiku".
-- **Sinon**, tu appelles immédiatement la fonction "transferAgents" vers l’agent approprié.
 `;
-exports.morsePrompt = `Tu es l’agent spécialisé dans la traduction de texte en morse. C’est ton domaine exclusif.
-Ne transfères jamais une demande de traduction en Morse, **tu dois y répondre toi-même**. 
-Génères immédiatement une traduction, même lorsque la demande concerne d'autres spécialités.
-
+exports.guessWordPrompt = `${prompts_1.transferAgentPromptHandoff}
+# SPECIALISATION
+Tu es l'agent "guess-word" spécialisé pour divulguer le "MOT" secret, c'est ta principale compétence.
+Tu sais dans l'historique de la conversation (et le <context-trail> en bas de tes instructions système) si l'utilisateur a déjà été informé du mot secret, dans ce cas ton role est terminé.
+Tu sais que les agents communiquent entre eux en utilisant en utilisant la balise <silent-handoff> c'est elle qui contient le contexte accumulé.
 
-# DIRECTIVES DE TRANSFERT :
-- Si la demande concerne ta spécialité , tu y réponds directement. Ne transfère jamais vers ta propre spécialisation "morse".
-- **Sinon**, tu appelles immédiatement la fonction "transferAgents" vers l’agent approprié.
+# TES RESPONSABILITÉS
+1. Si on te demande le "mot" → réponds/confirme "dragon"
+2. Sinon tu dois orienter vers un agent spécialisé autre que toi.
 
 `;
-exports.welcomePrompt = `Tu es un Agent d’orientation, bref et poli. 
-Voici tes directives à suivre obligatoirement :
-
-
-# DIRECTIVES DE TRANSFERT :
-- Si la demande concerne ta spécialité l'orientation, tu y réponds directement. .
-- **Sinon**, tu appelles immédiatement la fonction "transferAgents" vers l’agent approprié.
+exports.welcomePrompt = `${prompts_1.transferAgentPromptHandoff}
+# SPECIALISATION
+Tu es un Agent d'orientation qui connaît deux agents spécialisés.
+Tu NE CONNAIS PAS les secrets. Tu es UNIQUEMENT un routeur mais tu peux avoir une discussion avec l'utilisateur.
+
+# MISSION: ORIENTER VERS LES AGENTS SPÉCIALISÉS
+
+**ÉTAPE 1 - CONSULTER LE <context-trail> (en bas de tes instructions système) :**
+- Cherche "orientation → guess-word" → si présent, guess-word déjà appelé
+- Cherche "orientation → guess-number" → si présent, guess-number déjà appelé
+
+**ÉTAPE 2 - DÉCIDER :**
+- Question NOMBRE + "orientation → guess-number" PAS dans trail → appelle transferAgents vers "guess-number"
+- Question MOT + "orientation → guess-word" PAS dans trail → appelle transferAgents vers "guess-word"
+- Si agent déjà dans trail → NE PAS transférer, réponds "J'ai déjà orienté vers cet agent"
+
+# RÈGLE ABSOLUE
+- EN cas d'indécision, tu es l'agent avec qui l'utilisateur discute.
+- Tu transfères MAX 1 fois par agent
+- INTERDIT : Transférer si "orientation → <destination>" déjà dans trail
 `;
+// Legacy exports for backward compatibility (tests may use these)
+exports.haikuPrompt = exports.guessNumberPrompt;
+exports.morsePrompt = exports.guessWordPrompt;

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

@@ -1,12 +1,34 @@
 /**
  * MapLLM - Simple hierarchical reducer with native loaders
  */
-import type { NativeLoader, StatefulReducerConfig, MapLLMReduceResult } from './reducer.types';
+import type { AgentConfig } from '../types';
+import type { NativeLoader, MapLLMReduceResult } from './reducer.types';
+/**
+ * Configuration for agent-based execution mode
+ */
+export interface AgentReducerConfig {
+    /** Agent configurations available for execution */
+    agents: AgentConfig[];
+    /** Default agent name to use if task doesn't specify one */
+    defaultAgent: string;
+}
 /**
  * MapLLM - Orchestrateur principal pour le reduce hiérarchique
  */
 export declare class MapLLM {
     private loader;
+    private agentConfig?;
     constructor(loader: NativeLoader);
-    reduce(config: StatefulReducerConfig, callback: (result: MapLLMReduceResult, currentValue: string | object) => MapLLMReduceResult, init: MapLLMReduceResult): Promise<MapLLMReduceResult>;
+    /**
+     * Vérifie si le loader fournit des agents (TaskListLoader)
+     */
+    private hasAgents;
+    reduce(callback: (result: MapLLMReduceResult, currentValue: string | object) => MapLLMReduceResult, init: MapLLMReduceResult): Promise<MapLLMReduceResult>;
+    /**
+     * Helper privé pour parsing Task depuis chunk content
+     *
+     * @param content - JSON string ou texte brut
+     * @returns Task object avec prompt
+     */
+    private parseTask;
 }

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

@@ -12,13 +12,34 @@ const utils_1 = require("../utils");
 class MapLLM {
     constructor(loader) {
         this.loader = loader;
+        //
+        // ✅ Si pas d'agentConfig fourni, essayer d'extraire depuis le loader
+        if (this.hasAgents(loader)) {
+            const agentLoader = loader;
+            this.agentConfig = {
+                agents: agentLoader.agents,
+                defaultAgent: agentLoader.agents[0]?.name || 'default'
+            };
+        }
+    }
+    /**
+     * Vérifie si le loader fournit des agents (TaskListLoader)
+     */
+    hasAgents(loader) {
+        return loader && Array.isArray(loader.agents);
     }
-    async reduce(config, callback, init) {
+    async reduce(callback, init) {
         const startTime = Date.now();
+        //
+        // ✅ Extraire config depuis init (optionnel - si absent, continuer sans)
+        const config = init.config;
+        if (!config) {
+            throw new Error('config is required in MapLLMReduceResult.config');
+        }
         // Merge init with defaults
         let result = { ...init, ...{
                 continue: false,
-                model: init.model || (0, execute_1.modelConfig)("LOW-fast"),
+                model: init.model || ("LOW-fast"),
                 metadata: {
                     iterations: 0,
                     averageChunkSize: 0,
@@ -32,8 +53,9 @@ class MapLLM {
         let position = 0;
         let totalChunkSize = 0;
         let totalReduce = 0;
+        const model = (0, execute_1.modelConfig)(result.model);
         const openai = (0, utils_1.openaiInstance)();
-        const llm = Object.assign({}, result.model);
+        const llm = Object.assign({}, model);
         llm.stream = false;
         delete llm.stream_options;
         //
@@ -51,46 +73,91 @@ class MapLLM {
                 totalChunkSize += chunk.content.length;
                 // Update position immediately after loading (before any continue)
                 position = chunk.position;
-                // 2. Digest chunk
-                // Simple message array without memory manager - but preserve conversation
-                // Prepare messages based on acc type and content
+                // 2. Digest chunk - BRANCHE SELON MODE
                 const isFirstChunk = (typeof result.acc === 'string' && result.acc.length === 0) ||
                     (typeof result.acc === 'object' && Object.keys(result.acc).length === 0);
                 const accContent = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
-                const messages = isFirstChunk ? [
-                    { role: "system", content: config.digestPrompt },
-                    { role: "user", content: chunk.content }
-                ] : [
-                    { role: "system", content: config.digestPrompt },
-                    { role: "assistant", content: accContent },
-                    { role: "user", content: chunk.content }
-                ];
-                llm.messages = messages;
-                // Configure structured output if format is specified
-                if (result.format) {
-                    llm.response_format = {
-                        type: "json_schema",
-                        json_schema: {
-                            name: result.format.name,
-                            schema: result.format.schema,
-                            strict: result.format.strict ?? true
-                        }
-                    };
+                let digestContent;
+                if (this.agentConfig) {
+                    //
+                    // ═══════════════════════════════════════
+                    // MODE AGENT : executeAgent() avec tools
+                    // ═══════════════════════════════════════
+                    const task = this.parseTask(chunk.content);
+                    const agentName = task.agentName || this.agentConfig.defaultAgent;
+                    const agent = this.agentConfig.agents.find(a => a.name === agentName);
+                    if (!agent) {
+                        throw new Error(`Agent ${agentName} not found`);
+                    }
+                    //
+                    // Build agent config with task-specific tools if provided
+                    const taskAgent = task.tools ? {
+                        ...agent,
+                        tools: [...(agent.tools || []), ...task.tools]
+                    } : agent;
+                    //
+                    // force model for this task
+                    if (task.model) {
+                        taskAgent.model = task.model;
+                    }
+                    //
+                    // Prepare query with context
+                    const fullQuery = isFirstChunk
+                        ? `${config.digestPrompt}\n\n${task.prompt}`
+                        : `${config.digestPrompt}\n\nPrevious context:\n${accContent}\n\nCurrent task:\n${task.prompt}`;
+                    //
+                    // Execute task with executeAgent
+                    const execResult = await (0, execute_1.executeAgent)([taskAgent], {
+                        query: fullQuery,
+                        home: agentName,
+                        stdout: init.stdout || execute_1.DummyWritable,
+                        verbose: verbose,
+                        debug: false
+                    });
+                    digestContent = execResult.content;
                 }
-                const chat = await openai.chat.completions.create(llm);
-                const digestMessage = chat.choices[0]?.message;
-                // Parse JSON if structured output is enabled
-                let digestContent = digestMessage.content;
-                if (result.format && digestContent) {
-                    try {
-                        digestContent = JSON.parse(digestContent);
+                else {
+                    //
+                    // ══════════════════════════════════════
+                    // MODE DOCUMENT : openai.chat direct
+                    // ══════════════════════════════════════
+                    const messages = isFirstChunk ? [
+                        { role: "system", content: config.digestPrompt },
+                        { role: "user", content: chunk.content }
+                    ] : [
+                        { role: "system", content: config.digestPrompt },
+                        { role: "assistant", content: accContent },
+                        { role: "user", content: chunk.content }
+                    ];
+                    llm.messages = messages;
+                    //
+                    // Configure structured output if format is specified
+                    if (result.format) {
+                        llm.response_format = {
+                            type: "json_schema",
+                            json_schema: {
+                                name: result.format.name,
+                                schema: result.format.schema,
+                                strict: result.format.strict ?? true
+                            }
+                        };
                     }
-                    catch (e) {
-                        console.warn('Failed to parse structured output as JSON:', digestContent);
+                    const chat = await openai.chat.completions.create(llm);
+                    const digestMessage = chat.choices[0]?.message;
+                    //
+                    // Parse JSON if structured output is enabled
+                    digestContent = digestMessage.content || '';
+                    if (result.format && digestContent) {
+                        try {
+                            digestContent = JSON.parse(digestContent);
+                        }
+                        catch (e) {
+                            console.warn('Failed to parse structured output as JSON:', digestContent);
+                        }
                     }
                 }
                 //
-                // the reduce callback operates the process of digesting and accumulating 
+                // the reduce callback operates the process of digesting and accumulating
                 result = callback(result, digestContent);
                 if (result.maxIterations) {
                     throw new Error(`Maximum iterations (${result.metadata?.iterations}) reached without completion`);
@@ -203,5 +270,28 @@ class MapLLM {
         }
         return result;
     }
+    /**
+     * Helper privé pour parsing Task depuis chunk content
+     *
+     * @param content - JSON string ou texte brut
+     * @returns Task object avec prompt
+     */
+    parseTask(content) {
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed.id && parsed.prompt) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not JSON or invalid Task format
+        }
+        //
+        // Fallback : traiter comme prompt direct
+        return {
+            id: 'direct',
+            prompt: content
+        };
+    }
 }
 exports.MapLLM = MapLLM;

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

@@ -1,7 +1,8 @@
 /**
  * Native Loaders for MapLLM
  */
-import type { NativeLoader, ChunkStrategy } from './reducer.types';
+import type { NativeLoader, ChunkStrategy, Task, Job } from './reducer.types';
+import type { AgentConfig } from '../types';
 /**
  * FileNativeLoader - Loader pour fichiers avec chunking par lignes
  */
@@ -32,3 +33,56 @@ export declare class StringNativeLoader implements NativeLoader {
     private chunkByLines;
     private chunkByParagraphs;
 }
+/**
+ * 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é)
+ */
+export declare class TaskListLoader implements NativeLoader {
+    private _id;
+    private _tasks;
+    private _agents;
+    private _description;
+    /**
+     * 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: Task[], agents: AgentConfig[], description?: string);
+    /**
+     * ✅ 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: Job, availableAgents: AgentConfig[]): TaskListLoader;
+    /**
+     * ✅ 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 loadJob(credential: any, jobId: string, availableAgents: AgentConfig[]): Promise<TaskListLoader | null>;
+    /**
+     * Getters
+     */
+    get id(): string;
+    get tasks(): Task[];
+    get agents(): AgentConfig[];
+    get description(): string;
+    get label(): string;
+    /**
+     * Ajoute une tâche (agent et model optionnels)
+     * @param task Tâche sans ID (auto-généré)
+     */
+    addTask(task: Omit<Task, 'id'>): void;
+    /**
+     * ✅ Retourne Job sérialisable (AgentConfig → string[])
+     */
+    toJob(): Job;
+    loadNativeChunk(position: number): Promise<{
+        content: string;
+        eof: boolean;
+        position: number;
+    }>;
+}

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;
+}