agentic-api 1.0.6 → 2.0.26

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

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

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Native Loaders for MapLLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringNativeLoader = exports.FileNativeLoader = void 0;
+const fs_1 = require("fs");
+/**
+ * FileNativeLoader - Loader pour fichiers avec chunking par lignes
+ */
+class FileNativeLoader {
+    constructor(filePath, strategy = { type: 'lines', size: 50 }) {
+        this.chunks = [];
+        const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        this.chunks = this.createChunks(content, strategy);
+    }
+    async loadNativeChunk(position) {
+        if (position >= this.chunks.length) {
+            throw new Error(`Position ${position} out of bounds (max: ${this.chunks.length - 1})`);
+        }
+        const content = this.chunks[position];
+        const nextPosition = position + 1;
+        const eof = nextPosition >= this.chunks.length;
+        return {
+            content,
+            eof,
+            position: nextPosition
+        };
+    }
+    createChunks(content, strategy) {
+        switch (strategy.type) {
+            case 'lines':
+                return this.chunkByLines(content, strategy.size);
+            case 'paragraphs':
+                return this.chunkByParagraphs(content, strategy.size);
+            default:
+                throw new Error(`Unsupported chunk strategy: ${strategy.type}`);
+        }
+    }
+    chunkByLines(content, linesPerChunk) {
+        const lines = content.split('\n');
+        const chunks = [];
+        for (let i = 0; i < lines.length; i += linesPerChunk) {
+            const chunkLines = lines.slice(i, i + linesPerChunk);
+            const chunkContent = chunkLines.join('\n').trim();
+            if (chunkContent) {
+                chunks.push(chunkContent);
+            }
+        }
+        return chunks;
+    }
+    chunkByParagraphs(content, paragraphsPerChunk) {
+        const paragraphs = content.split(/\n\s*\n/).filter(p => p.trim());
+        const chunks = [];
+        for (let i = 0; i < paragraphs.length; i += paragraphsPerChunk) {
+            const chunkParagraphs = paragraphs.slice(i, i + paragraphsPerChunk);
+            const chunkContent = chunkParagraphs.join('\n\n').trim();
+            if (chunkContent) {
+                chunks.push(chunkContent);
+            }
+        }
+        return chunks;
+    }
+}
+exports.FileNativeLoader = FileNativeLoader;
+/**
+ * StringNativeLoader - Loader pour contenu en mémoire
+ */
+class StringNativeLoader {
+    constructor(content, strategy = { type: 'lines', size: 50 }) {
+        this.chunks = [];
+        this.chunks = this.createChunks(content, strategy);
+    }
+    async loadNativeChunk(position) {
+        if (position >= this.chunks.length) {
+            throw new Error(`Position ${position} out of bounds (max: ${this.chunks.length - 1})`);
+        }
+        const content = this.chunks[position];
+        const nextPosition = position + 1;
+        const eof = nextPosition >= this.chunks.length;
+        return {
+            content,
+            eof,
+            position: nextPosition
+        };
+    }
+    createChunks(content, strategy) {
+        switch (strategy.type) {
+            case 'lines':
+                return this.chunkByLines(content, strategy.size);
+            case 'paragraphs':
+                return this.chunkByParagraphs(content, strategy.size);
+            default:
+                throw new Error(`Unsupported chunk strategy: ${strategy.type}`);
+        }
+    }
+    chunkByLines(content, linesPerChunk) {
+        const lines = content.split('\n');
+        const chunks = [];
+        for (let i = 0; i < lines.length; i += linesPerChunk) {
+            const chunkLines = lines.slice(i, i + linesPerChunk);
+            const chunkContent = chunkLines.join('\n').trim();
+            if (chunkContent) {
+                chunks.push(chunkContent);
+            }
+        }
+        return chunks;
+    }
+    chunkByParagraphs(content, paragraphsPerChunk) {
+        const paragraphs = content.split(/\n\s*\n/).filter(p => p.trim());
+        const chunks = [];
+        for (let i = 0; i < paragraphs.length; i += paragraphsPerChunk) {
+            const chunkParagraphs = paragraphs.slice(i, i + paragraphsPerChunk);
+            const chunkContent = chunkParagraphs.join('\n\n').trim();
+            if (chunkContent) {
+                chunks.push(chunkContent);
+            }
+        }
+        return chunks;
+    }
+}
+exports.StringNativeLoader = StringNativeLoader;

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

@@ -0,0 +1,16 @@
+import { StatefulReducerConfig, StatefulReduceResult, StatefulProcessOptions, ChunkLoader } from "./reducer.types";
+/**
+ * Main function to process a document using the stateful agent reduce pattern
+ *
+ * @param sessionId - Session ID for the discussion/document to process
+ * @param config - Stateful reducer configuration
+ * @param loader - ChunkLoader interface for loading content chunks
+ * @param options - Additional options
+ * @returns Promise resolving to the stateful reduce result
+ */
+export declare function statefulReduceProcess<T = any>(sessionId: string, config: StatefulReducerConfig, loader: ChunkLoader, options?: StatefulProcessOptions): Promise<StatefulReduceResult<T>>;
+/**
+ * Legacy function name for backward compatibility
+ * @deprecated Use statefulReduceProcess instead
+ */
+export declare function agentReduceProcess<T = any>(sessionId: string, config: any, loader: ChunkLoader, options?: any): Promise<any>;