agentic-api 1.0.6 → 2.0.31

package/dist/src/agents/prompts.js

@@ -104,7 +104,7 @@ 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.
+- 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. 
@@ -146,7 +146,7 @@ exports.promptMarkdown = `# RÔLE:
 - MED: Mise en demeure.
 - WC: Toilettes.
 - M-Files: logiciel de gestion de documents
-- PR ou PRSA: Pilet-Renaud SA
+- PR ou PRSA: Pilet & Renaud SA
 - PPE: Service qui gère les copropriétés.
 - GP: Garantie Bancaire
 - BAL: Boite à Lettre
@@ -176,53 +176,116 @@ INPUT:
 // 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.systemReviewPrompt = `
-# PROMPT D’ANALYSE — Audit de directives LLM d'un prompt système
-
-## RÔLE :
-Assume le rôle d’un expert spécialisé dans l’analyse, la formalisation et l’évaluation des directives d’un prompt système d’un Agent LLM.
-On te donnera des problèmes difficiles à résoudre, qui nécessiteront plusieurs techniques principales pour les résoudre, comme l'analyse statistique, la logique, ainsi que certaines techniques métacognitives que tu pourras employer.
-
-## MISSION :
-L'utilisateur a créé un prompt système qui contient une liste de directives (instructions) pour un Agent LLM spécialisé.  
-Tu dois en avoir une connaissance exhaustive et approfondie, les lire ligne par ligne et les garder en mémoire.
-
-Ta mission est de les évaluer individuellement selon les 9 critères mentionnés ci-dessous.  
-Tu dois juger leur pertinence, leur clarté, leur alignement avec le rôle de l’agent, et leur contribution à l’objectif global.
-
-## TÂCHES :
-Tu dois avoir une connaissance exhaustive et approfondie de toutes les directives :
-  - Une directive est décrite avec des phrases sur une ligne.
-  - Tu dois suivre la structure qui organise les directives par sections pour résoudre un objectif précis de l'agent.  
-  - Dans Tu dois évaluer chaque directive individuellement selon les 9 critères ci-dessous.
-  - Tu dois comparer la directive au rôle global de l’agent et de la section pour détecter sa complémentarité et son écart.
-  - Tu dois extraire le chevauchement ou les incohérences par rapport aux autres directives.
-  - Tu dois identifier les cas de redondance et d'indécisions que cela peut créer.
-  - Tu dois produire et conserver en mémoire un schéma du "graph" complet de chaque directive et des critères d'évaluation dont le score est inférieur à 0.9.
-
-## CHAÎNE DE RAISONNEMENT (CoT) :
-
-Tu dois appliquer une démarche par raisonnement étape par étape :
-- Encadre ton raisonnement dans une balise \`<thinking>...</thinking>\`.
-- Utilise des balises \`<step>\` pour chaque étape de réflexion.
-- Reste succinct dans les étapes.
-- Ajuste ton raisonnement si tu détectes une incohérence ou un doute.
-
-
-## CRITÈRES D’ANALYSE
-
-1. **Identité** : La directive reflète-t-elle le rôle de la section actuelle ?
-2. **Périmètre** : Complète-t-elle clairement le domaine de la section actuelle, est-elle utile ?
-3. **Décision** : Y a-t-il une condition explicite du type “SI… ALORS…”, si oui est-elle correctement formulée ?
-4. **Exécution** : L’agent peut-il agir sans hésitation (une autre directive peut-elle contredire la directive en cours) ?
-5. **Interdiction** : Empêche-t-elle les comportements vagues, hors sujet ou parasites ?
-7. **Robustesse** : Faut-il prévoir des cas limites ?
-8. **Redondance (ou contradiction)** : Y a-t-il une redondance ou une contradiction avec une autre directive qui pourrait créer un biais d'interprétation ?
-9. **Simplification** : Pourrait-elle être reformulée sans perte ?
-
-
-## OUTPUT ATTENDU
-- Tu dois produire un **Rapport exhaustif de toutes les directives avec leurs critères**, les scores et les commentaires 
-- ATTENTION seuls les critères avec un scores <= 0.9 intéressent l'utilisateur et doivent être affichées.
+### Identity
+Tu es “PromptVerifier”, un auditeur senior de prompts système spécialisé dans les agents structurés. Ta mission est de relire, diagnostiquer et annoter un prompt système ligne par ligne pour fiabiliser son exécution.
+
+### Task context
+- Tu reçois un prompt (principalement un prompt système) à auditer.
+- Tu dois le comprendre précisément dans son ensemble.
+- Tu dois le parcourir section par section, directive par directive (une directive = une ligne).
+- Tu détectes les problèmes et proposes des remarques ultra-ciblées, minimales, directement au bout de la ligne concernée.
+
+### Tone context
+- Français, clair, concis, professionnel. Pas de langage fleuri. Zéro redondance.
+
+### Background data
+- Bonnes pratiques GPT‑5 sur la prédictibilité agentique, le contrôle d’eagerness, les “tool preambles”, l’exploration disciplinée, la vérification continue et l’efficacité. 
+- Utilises les ressources internet: GPT‑5 prompting guide.
+
+### Task rules
+- Analyse systématique “directive = une ligne” (section = groupe de directives), ligne par ligne. Pour chaque ligne, vérifier:
+  - Multiple interprétation / trop vague (risque de faux négatifs)
+  - Doublons
+  - Contradictions
+  - Redondances
+  - Alignement strict à la MISSION
+  - Neutralité, logique, applicabilité générale (les exemples sont spécifiques, les règles doivent rester générales)
+  - Appliques les bonnes pratique (ci-dessous) "Reasoning best practices" et "XML-like tags best practices"
+  - Séparation claire QUOI (règle/objectif) vs COMMENT (procédure/exemple)
+- Ne corrige pas le texte dans la sortie. Tu n’ajoutes que des remarques en fin de ligne pour les éléments problématique “pas OK”.
+- Une modification = une directive à la fois (discipline de changement). Pour la proposition de correction, tu la gardes implicite dans la remarque (succincte), sans réécrire la ligne.
+- Pas d’appels d’outils externes. Aucune recherche additionnelle. Raisonne localement.
+
+
+### Reasoning best practices
+- **Objectif**: maximiser exactitude et fiabilité tout en contrôlant coût/latence.
+- **Quand raisonner plus**: tâches ambiguës, mult-étapes, sécurité élevée; sinon rester minimal.
+- **Budget de réflexion**: fixer un plafond clair (ex. étapes max, temps, outils); arrêter dès critères atteints.
+- **Décomposition**: formuler le problème → lister sous‑tâches → ordonner → traiter séquentiellement.
+- **Plan → Agir → Vérifier**: annoncer un plan bref, exécuter, valider la sortie vs critères de succès.
+- **Checklist de vérification**: exactitude, complétude, cohérence règles, absence de contradictions.
+- **Auto‑évaluation (reflection)**: demander “où mon raisonnement peut-il être faux ?” puis corriger si nécessaire.
+- **Compare & critique (si utile)**: générer 2 pistes succinctes puis choisir via critères objectifs.
+- **Preuves/sources**: exiger références cliquables pour faits non triviaux; sinon marquer incertitude.
+- **Scratchpad privé**: ne pas exposer le raisonnement détaillé; n’afficher que le résultat et les annotations requises.
+- **Erreurs programmées**: si échec à une vérification, corriger une chose à la fois et revérifier.
+- **Sortie contractuelle**: respecter strictement le format demandé; ne jamais ajouter de texte hors contrat.
+- **Efficience**: privilégier la simplicité; éviter re‑recherches si l’action est possible; paralléliser lectures.
+- **Traçabilité**: noter hypothèses explicites; si non vérifiables, choisir l’option la moins risquée et poursuivre.
+
+### XML-like tags best practices
+Quand privilégier les XML‑tags: blocs opérationnels “machine‑actionables” (budgets, stop conditions, discipline d’édition, preambles/outils) :
+- **\`<context_gathering>\` — objectif**: Calibrer l’exploration (profondeur, parallélisation, critères d’arrêt) pour réduire la latence.
+
+- **\`<persistence>\` — objectif**: Encourager l’autonomie et la complétion sans rendre la main trop tôt.
+
+- **\`<tool_preambles>\` — objectif**: Annoncer clairement but, plan et updates succinctes lors des appels d’outils.
+
+- **\`<instructions>\` — objectif**: Établir les règles d’édition et de validation dans un contexte d’exécution (Terminal‑Bench).
+
+- **\`<apply_patch>\` — objectif**: Définir le format V4A de diff/patch et la manière correcte d’appliquer les edits.
+
+- **\`<exploration>\` — objectif**: Encadrer la découverte: décomposer, cartographier, cibler, puis agir rapidement.
+
+- **\`<verification>\` — objectif**: Imposer des contrôles continus et la validation finale des livrables.
+
+- **\`<efficiency>\` — objectif**: Contraindre coûts/latences via planification méticuleuse et exécution sobre.
+
+- **\`<final_instructions>\` — objectif**: Fixer les contraintes finales (outils, formats) à respecter strictement.
+
+Référence: [GPT‑5 prompting guide — OpenAI Cookbook](https://cookbook.openai.com/examples/gpt-5/gpt-5_prompting_guide)
+
+### Issue taxonomy (types et émojis)
+- Ambiguïté / Trop vague: 🤔
+- Doublon: ❌
+- Contradiction: ❌
+- Redondance: ❌
+- Hors mission / Non aligné: 🎯❌
+- Non neutre / Non logique / Non universel: 🤔
+- Mauvaise séparation QUOI/COMMENT: 🤔
+
+### Output formatting (OBLIGATOIRE)
+- Tu DOIS afficher uniquement le prompt original, intact, dans l’ordre et en entier.
+- Pour chaque ligne avec un problème tu AJOUTES À LA FIN de la ligne tes remarque au format:
+  -   **N️ EMOJI ** justification brève
+  - Exemple:  — [**🌀 Ambiguïté:** “souvent”, préciser critère mesurable
+- Numérotation N️: incrémente à chaque nouvelle remarque (1,2,3, …). 
+- Lignes sans problème: aucun ajout.
+- Zéro préambule, zéro post‑scriptum, zéro résumé, zéro légende: sors UNIQUEMENT le prompt annoté (le texte d’entrée + remarques en fin de ligne).
+- Les remarques doivent être concises (≤ 120 caractères par problème), actionnables et spécifiques.
+
+### Persistence
+- Va au bout de l’audit dans une seule passe. Ne demande pas de clarification: choisis l’hypothèse raisonnable minimale et continue.
+
+### Context gathering (calibrage eagerness)
+- Profondeur faible (pas d’outils ni relectures multiples). Early stop: dès que chaque ligne a été inspectée.
+- Pas de reformulation du prompt source; conserve-le strictement, ajoute seulement les remarques finales par ligne.
+
+### Efficiency
+- Remarques courtes, ciblées, sans jargon. Évite les répétitions. Privilégie le signal.
+
+### User request
+- Input attendu: le prompt système à auditer (texte entier).
+
+### Step-by-step reasoning CoT
+- Interne. Ne jamais afficher le raisonnement.
+
+### Final instructions
+- Sors UNIQUEMENT le prompt original, ligne par ligne, avec remarques en fin de ligne pour ce qui n’est pas OK, numérotées en gras et avec l’émoji de type.
+- Aucune autre sortie n’est permise.
+
+### References
+- GPT‑5 prompting guide — OpenAI Cookbook: https://cookbook.openai.com/examples/gpt-5/gpt-5_prompting_guide
 
 `;
 exports.systemReviewStructurePrompt = `

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

@@ -0,0 +1,12 @@
+/**
+ * MapLLM - Simple hierarchical reducer with native loaders
+ */
+import type { NativeLoader, StatefulReducerConfig, MapLLMReduceResult } from './reducer.types';
+/**
+ * MapLLM - Orchestrateur principal pour le reduce hiérarchique
+ */
+export declare class MapLLM {
+    private loader;
+    constructor(loader: NativeLoader);
+    reduce(config: StatefulReducerConfig, callback: (result: MapLLMReduceResult, currentValue: string | object) => MapLLMReduceResult, init: MapLLMReduceResult): Promise<MapLLMReduceResult>;
+}

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

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * MapLLM - Simple hierarchical reducer with native loaders
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapLLM = void 0;
+const execute_1 = require("../execute");
+const utils_1 = require("../utils");
+/**
+ * MapLLM - Orchestrateur principal pour le reduce hiérarchique
+ */
+class MapLLM {
+    constructor(loader) {
+        this.loader = loader;
+    }
+    async reduce(config, callback, init) {
+        const startTime = Date.now();
+        // Merge init with defaults
+        let result = { ...init, ...{
+                continue: false,
+                model: init.model || (0, execute_1.modelConfig)("LOW-fast"),
+                metadata: {
+                    iterations: 0,
+                    averageChunkSize: 0,
+                    processingTimeMs: 0
+                }
+            } };
+        const verbose = init.verbose || false;
+        if (verbose) {
+            console.log('🚀 MapLLM: Starting reduce process...');
+        }
+        let position = 0;
+        let totalChunkSize = 0;
+        let totalReduce = 0;
+        const openai = (0, utils_1.openaiInstance)();
+        const llm = Object.assign({}, result.model);
+        llm.stream = false;
+        delete llm.stream_options;
+        //
+        // maxIterations is set by the callback
+        while (!result.maxIterations) {
+            if (result.metadata) {
+                result.metadata.iterations++;
+            }
+            try {
+                // 1. Load chunk
+                const chunk = await this.loader.loadNativeChunk(position);
+                if (verbose) {
+                    console.log(`📦 Processing chunk ${result.metadata?.iterations} position ${position} is eof ${chunk.eof}`);
+                }
+                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
+                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
+                        }
+                    };
+                }
+                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);
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse structured output as JSON:', digestContent);
+                    }
+                }
+                //
+                // 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`);
+                }
+                // Check EOF BEFORE any continue to ensure we exit the loop
+                if (chunk.eof) {
+                    if (verbose) {
+                        console.log('🏁 End of document reached after processing final chunk');
+                    }
+                    break;
+                }
+                // Décision de réduction basée sur callback
+                if (!result.continue) {
+                    continue;
+                }
+                const accForReduce = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
+                llm.messages = [
+                    { role: "system", content: config.reducePrompt },
+                    { role: "user", content: accForReduce }
+                ];
+                // 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
+                        }
+                    };
+                }
+                const reduce = await openai.chat.completions.create(llm);
+                const reduceMessage = reduce.choices[0]?.message;
+                //
+                // should not happen
+                if (!reduceMessage.content) {
+                    continue;
+                }
+                // 3. Reduce with system - Update result.acc (replace)
+                totalReduce++;
+                // Parse JSON if structured output is enabled
+                if (result.format) {
+                    try {
+                        result.acc = JSON.parse(reduceMessage.content);
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse reduce result as JSON:', reduceMessage.content);
+                        result.acc = reduceMessage.content;
+                    }
+                }
+                else {
+                    result.acc = reduceMessage.content;
+                }
+                if (verbose) {
+                    console.log(`✅ Reduce ${result.metadata?.iterations} processed (${chunk.content.length} chars)`);
+                    console.log("✅ Reduce result:", result.acc);
+                }
+                // EOF check is now handled earlier in the loop
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(`❌ Chunk ${result.metadata?.iterations} failed: ${error}`);
+                }
+                throw new Error(`Failed to process chunk ${result.metadata?.iterations}: ${error}`);
+            }
+        }
+        // Final reduce
+        const finalAccContent = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
+        const messages = [
+            { role: "system", content: config.reducePrompt },
+            { role: "user", content: finalAccContent }
+        ];
+        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
+                }
+            };
+        }
+        const reduce = await openai.chat.completions.create(llm);
+        const finalContent = reduce.choices[0]?.message.content || '';
+        // Parse JSON if structured output is enabled
+        if (result.format && finalContent) {
+            try {
+                result.acc = JSON.parse(finalContent);
+            }
+            catch (e) {
+                console.warn('Failed to parse final result as JSON:', finalContent);
+                result.acc = finalContent;
+            }
+        }
+        else {
+            result.acc = finalContent;
+        }
+        const endTime = Date.now();
+        const processingTimeMs = endTime - startTime;
+        if (verbose) {
+            console.log(`🎉 MapLLM completed: ${result.metadata?.iterations} chunks in ${processingTimeMs}ms`);
+        }
+        // Update final metadata
+        result.continue = false; // Terminé
+        if (result.metadata) {
+            result.metadata.processingTimeMs = processingTimeMs;
+            result.metadata.averageChunkSize = Math.round(totalChunkSize / result.metadata.iterations);
+        }
+        return result;
+    }
+}
+exports.MapLLM = MapLLM;

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

@@ -0,0 +1,3 @@
+export * from './reducer.core';
+export * from './reducer.loaders';
+export * from './reducer.types';

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

@@ -0,0 +1,28 @@
+/**
+ * MapLLM Reducer - Simple hierarchical reducer
+ *
+ * Main export file for the MapLLM reducer functionality
+ */
+export { MapLLM } from './reducer.core';
+export { FileNativeLoader, StringNativeLoader } from './reducer.loaders';
+export type { NativeLoader, StatefulReducerConfig, MapLLMOptions, ReduceResult, ChunkStrategy } from './reducer.types';
+export declare const exampleConfigs: {
+    weather: {
+        digestPrompt: string;
+        reducePrompt: string;
+    };
+    foods: {
+        digestPrompt: string;
+        reducePrompt: string;
+    };
+};
+export declare const examples: {
+    /**
+     * Example: Weather data analysis
+     */
+    weatherAnalysis(weatherFilePath: string): Promise<import("./reducer.types").ReduceResult>;
+    /**
+     * Example: Food selection from string content
+     */
+    foodSelection(foodListContent: string): Promise<import("./reducer.types").ReduceResult>;
+};

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

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * MapLLM Reducer - Simple hierarchical reducer
+ *
+ * Main export file for the MapLLM reducer functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.examples = exports.exampleConfigs = exports.StringNativeLoader = exports.FileNativeLoader = exports.MapLLM = void 0;
+// Core classes
+var reducer_core_1 = require("./reducer.core");
+Object.defineProperty(exports, "MapLLM", { enumerable: true, get: function () { return reducer_core_1.MapLLM; } });
+var reducer_loaders_1 = require("./reducer.loaders");
+Object.defineProperty(exports, "FileNativeLoader", { enumerable: true, get: function () { return reducer_loaders_1.FileNativeLoader; } });
+Object.defineProperty(exports, "StringNativeLoader", { enumerable: true, get: function () { return reducer_loaders_1.StringNativeLoader; } });
+// Example configurations
+exports.exampleConfigs = {
+    weather: {
+        digestPrompt: `Tu es un expert en analyse de données météorologiques.
+Analyse ce chunk de données météo et extrais:
+- Les types de météo présents (ensoleillé, pluvieux, nuageux, neigeux, orageux)
+- Le nombre d'entrées par type
+- Les IDs associés à chaque type
+
+Réponds en JSON strict avec la structure:
+{
+  "weatherTypes": {
+    "ensoleillé": {"count": N, "ids": [...]},
+    "pluvieux": {"count": N, "ids": [...]}
+  }
+}`,
+        reducePrompt: `Tu es un expert en consolidation de données météorologiques.
+Synthétise toutes les analyses météo en un résultat consolidé:
+- Fusionne tous les types de météo
+- Additionne les counts
+- Combine les IDs (sans doublons)
+- Calcule les totaux par type
+
+Réponds en JSON avec la structure finale consolidée.`
+    },
+    foods: {
+        digestPrompt: `Tu es un expert en nutrition végétarienne.
+Analyse cette liste d'aliments et identifie:
+- Les aliments végétariens/vegan
+- Leur catégorie (légumes, fruits, céréales, légumineuses, etc.)
+- Leur valeur nutritionnelle approximative
+
+Réponds en JSON strict avec les aliments sélectionnés.`,
+        reducePrompt: `Tu es un expert en nutrition végétarienne.
+Crée une sélection équilibrée d'aliments végétariens/vegan:
+- Distribution équilibrée entre catégories
+- Maximum 50 aliments
+- Priorité aux aliments nutritifs et variés
+
+Réponds avec la liste finale sélectionnée en JSON.`
+    }
+};
+// Usage examples
+exports.examples = {
+    /**
+     * Example: Weather data analysis
+     */
+    async weatherAnalysis(weatherFilePath) {
+        const { FileNativeLoader } = await Promise.resolve().then(() => __importStar(require('./reducer.loaders')));
+        const { MapLLM } = await Promise.resolve().then(() => __importStar(require('./reducer.core')));
+        const loader = new FileNativeLoader(weatherFilePath, { type: 'lines', size: 50 });
+        const mapper = new MapLLM(loader);
+        return await mapper.reduce(exports.exampleConfigs.weather, {
+            verbose: true,
+            maxRetries: 3
+        });
+    },
+    /**
+     * Example: Food selection from string content
+     */
+    async foodSelection(foodListContent) {
+        const { StringNativeLoader } = await Promise.resolve().then(() => __importStar(require('./reducer.loaders')));
+        const { MapLLM } = await Promise.resolve().then(() => __importStar(require('./reducer.core')));
+        const loader = new StringNativeLoader(foodListContent, { type: 'lines', size: 100 });
+        const mapper = new MapLLM(loader);
+        return await mapper.reduce(exports.exampleConfigs.foods, {
+            verbose: true,
+            maxDigestSize: 3000
+        });
+    }
+};

package/dist/src/agents/reducer.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./reducer.core"), exports);
+__exportStar(require("./reducer.loaders"), exports);
+__exportStar(require("./reducer.types"), exports);

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

@@ -0,0 +1,34 @@
+/**
+ * Native Loaders for MapLLM
+ */
+import type { NativeLoader, ChunkStrategy } from './reducer.types';
+/**
+ * FileNativeLoader - Loader pour fichiers avec chunking par lignes
+ */
+export declare class FileNativeLoader implements NativeLoader {
+    private chunks;
+    constructor(filePath: string, strategy?: ChunkStrategy);
+    loadNativeChunk(position: number): Promise<{
+        content: string;
+        eof: boolean;
+        position: number;
+    }>;
+    private createChunks;
+    private chunkByLines;
+    private chunkByParagraphs;
+}
+/**
+ * StringNativeLoader - Loader pour contenu en mémoire
+ */
+export declare class StringNativeLoader implements NativeLoader {
+    private chunks;
+    constructor(content: string, strategy?: ChunkStrategy);
+    loadNativeChunk(position: number): Promise<{
+        content: string;
+        eof: boolean;
+        position: number;
+    }>;
+    private createChunks;
+    private chunkByLines;
+    private chunkByParagraphs;
+}