@ai.ntellect/core 0.6.20 → 0.6.21

package/dist/graph/index.js

@@ -29,15 +29,21 @@ class GraphFlow {
      * Creates a new instance of GraphFlow
      * @param {string} name - The name of the graph flow
      * @param {GraphDefinition<T>} config - Configuration object containing nodes, schema, context, and error handlers
+     * @param {Object} options - Optional options for the graph flow
      */
-    constructor(name, config) {
+    constructor(name, config, options = {}) {
+        var _a;
         this.name = name;
+        this.logs = [];
+        this.verbose = false;
         this.nodes = new Map(config.nodes.map((node) => [node.name, node]));
         this.validator = config.schema;
         this.context = config.schema.parse(config.context);
         this.globalErrorHandler = config.onError;
-        this.eventEmitter = config.eventEmitter || new events_1.EventEmitter();
+        this.eventEmitter =
+            config.eventEmitter || new events_1.EventEmitter();
         this.graphEvents = config.events;
+        this.verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : false;
         this.setupEventListeners();
         this.setupGraphEventListeners();
     }
@@ -93,6 +99,27 @@ class GraphFlow {
             }
         }
     }
+    addLog(message) {
+        const logMessage = `[${new Date().toISOString()}] ${message}`;
+        this.logs.push(logMessage);
+        if (this.verbose) {
+            console.log(`[${this.name}] ${message}`);
+        }
+    }
+    /**
+     * Enable or disable verbose logging
+     * @param {boolean} enabled - Whether to enable verbose logging
+     */
+    setVerbose(enabled) {
+        this.verbose = enabled;
+    }
+    /**
+     * Get current verbose setting
+     * @returns {boolean} Current verbose setting
+     */
+    isVerbose() {
+        return this.verbose;
+    }
     /**
      * Executes a specific node in the graph
      * @private
@@ -104,76 +131,142 @@ class GraphFlow {
      */
     executeNode(nodeName_1, context_1, inputs_1) {
         return __awaiter(this, arguments, void 0, function* (nodeName, context, inputs, triggeredByEvent = false) {
-            var _a, _b, _c, _d;
+            var _a;
             const node = this.nodes.get(nodeName);
             if (!node)
-                throw new Error(`❌ Node "${nodeName}" not found.`);
-            if (node.condition && !node.condition(context)) {
-                return;
-            }
-            let attempts = 0;
-            const maxAttempts = ((_a = node.retry) === null || _a === void 0 ? void 0 : _a.maxAttempts) || 1;
-            const delay = ((_b = node.retry) === null || _b === void 0 ? void 0 : _b.delay) || 0;
-            while (attempts < maxAttempts) {
-                try {
-                    let validatedInputs;
-                    if (node.inputs) {
-                        if (!inputs) {
-                            throw new Error(`❌ Inputs required for node "${nodeName}" but received: ${inputs}`);
-                        }
-                        validatedInputs = node.inputs.parse(inputs);
-                    }
-                    this.eventEmitter.emit("nodeStarted", { name: nodeName, context });
-                    // Execute the node
-                    yield node.execute(context, validatedInputs);
-                    if (node.outputs) {
-                        node.outputs.parse(context);
+                throw new Error(`Node "${nodeName}" not found.`);
+            this.addLog(`🚀 Starting node "${nodeName}"`);
+            this.eventEmitter.emit("nodeStarted", { name: nodeName });
+            try {
+                const localContext = structuredClone(context);
+                if (node.condition && !node.condition(localContext)) {
+                    this.addLog(`⏭️ Skipping node "${nodeName}" - condition not met`);
+                    return;
+                }
+                // Validate inputs
+                if (node.inputs) {
+                    if (!inputs) {
+                        this.addLog(`❌ Missing required inputs for node "${nodeName}"`);
+                        throw new Error(`Inputs required for node "${nodeName}"`);
                     }
-                    this.validateContext(context);
-                    this.eventEmitter.emit("nodeCompleted", { name: nodeName, context });
-                    // IMPORTANT: Si le nœud est déclenché par un événement et a des événements définis,
-                    // on arrête ici et on ne suit pas la chaîne next
-                    if (triggeredByEvent && node.events && node.events.length > 0) {
-                        this.context = structuredClone(context);
-                        return;
+                    this.addLog(`📥 Validating inputs for node "${nodeName}"`);
+                    inputs = node.inputs.parse(inputs);
+                }
+                // Handle retry logic
+                if (node.retry && node.retry.maxAttempts > 0) {
+                    let attempts = 0;
+                    let lastError = null;
+                    while (attempts < node.retry.maxAttempts) {
+                        try {
+                            this.addLog(`🔄 Attempt ${attempts + 1}/${node.retry.maxAttempts}`);
+                            yield node.execute(localContext, inputs);
+                            lastError = null;
+                            break;
+                        }
+                        catch (error) {
+                            lastError = error;
+                            attempts++;
+                            this.addLog(`❌ Attempt ${attempts} failed: ${error.message}`);
+                            if (attempts === node.retry.maxAttempts) {
+                                // Si toutes les tentatives ont échoué et qu'il y a un gestionnaire d'échec
+                                if (node.retry.onRetryFailed) {
+                                    this.addLog(`🔄 Executing retry failure handler for node "${nodeName}"`);
+                                    try {
+                                        yield node.retry.onRetryFailed(lastError, localContext);
+                                        // Si le gestionnaire d'échec réussit, on continue l'exécution
+                                        // SEULEMENT si le gestionnaire a explicitement retourné true
+                                        if (node.retry.continueOnFailed) {
+                                            this.addLog(`✅ Retry failure handler succeeded for node "${nodeName}" - continuing execution`);
+                                            break;
+                                        }
+                                        else {
+                                            this.addLog(`⚠️ Retry failure handler executed but node "${nodeName}" will still fail`);
+                                            throw lastError;
+                                        }
+                                    }
+                                    catch (handlerError) {
+                                        this.addLog(`❌ Retry failure handler failed for node "${nodeName}": ${handlerError.message}`);
+                                        throw handlerError;
+                                    }
+                                }
+                                // Si pas de gestionnaire d'échec ou si le gestionnaire a échoué
+                                throw lastError;
+                            }
+                            if (attempts < node.retry.maxAttempts) {
+                                this.addLog(`⏳ Waiting ${node.retry.delay}ms before next attempt`);
+                                yield new Promise((resolve) => { var _a; return setTimeout(resolve, ((_a = node.retry) === null || _a === void 0 ? void 0 : _a.delay) || 0); });
+                            }
+                        }
                     }
-                    // Gérer les nœuds suivants
-                    if (node.next && node.next.length > 0) {
-                        const branchContexts = [];
-                        // Exécuter toutes les branches valides
-                        for (const nextNodeName of node.next) {
+                }
+                else {
+                    yield node.execute(localContext, inputs);
+                }
+                // Validate outputs
+                if (node.outputs) {
+                    this.addLog(`📤 Validating outputs for node "${nodeName}"`);
+                    node.outputs.parse(localContext);
+                }
+                Object.assign(context, localContext);
+                this.addLog(`✅ Node "${nodeName}" executed successfully ${JSON.stringify(context)}`);
+                this.eventEmitter.emit("nodeCompleted", { name: nodeName });
+                // Handle waitForEvent
+                if (node.waitForEvent && !triggeredByEvent) {
+                    this.addLog(`⏳ Node "${nodeName}" waiting for events: ${(_a = node.events) === null || _a === void 0 ? void 0 : _a.join(", ")}`);
+                    yield new Promise((resolve) => {
+                        var _a;
+                        const eventHandler = () => {
+                            this.addLog(`🚀 Event received for node "${nodeName}"`);
+                            resolve();
+                        };
+                        (_a = node.events) === null || _a === void 0 ? void 0 : _a.forEach((event) => {
+                            this.eventEmitter.once(event, eventHandler);
+                        });
+                    });
+                    const nextNodes = typeof node.next === "function"
+                        ? node.next(context)
+                        : node.next || [];
+                    if (nextNodes.length > 0) {
+                        this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
+                        // Execute next nodes
+                        for (const nextNodeName of nextNodes) {
+                            this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
                             const nextNode = this.nodes.get(nextNodeName);
-                            if (!nextNode)
-                                continue;
-                            const branchContext = structuredClone(context);
-                            // Si le nœud a une condition et qu'elle n'est pas remplie, passer au suivant
-                            if (nextNode.condition && !nextNode.condition(branchContext)) {
-                                continue;
+                            if (nextNode) {
+                                yield this.executeNode(nextNodeName, context, undefined, nextNode.waitForEvent);
                             }
-                            yield this.executeNode(nextNodeName, branchContext);
-                            branchContexts.push(branchContext);
-                        }
-                        // Fusionner les résultats des branches dans l'ordre
-                        if (branchContexts.length > 0) {
-                            const finalContext = branchContexts[branchContexts.length - 1];
-                            Object.assign(context, finalContext);
+                            this.addLog(`✅ Branch "${nextNodeName}" completed`);
                         }
+                        this.eventEmitter.emit("graphCompleted", {
+                            name: this.name,
+                            context: this.context,
+                        });
+                        return;
                     }
-                    // Mettre à jour le contexte global
-                    this.context = structuredClone(context);
-                    return;
                 }
-                catch (error) {
-                    attempts++;
-                    if (attempts >= maxAttempts) {
-                        this.eventEmitter.emit("nodeError", { nodeName, error });
-                        (_c = node.onError) === null || _c === void 0 ? void 0 : _c.call(node, error);
-                        (_d = this.globalErrorHandler) === null || _d === void 0 ? void 0 : _d.call(this, error, context);
-                        throw error;
+                // Execute next nodes
+                const nextNodes = typeof node.next === "function"
+                    ? node.next(localContext)
+                    : node.next || [];
+                if (nextNodes.length > 0) {
+                    this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
+                    // Execute next nodes
+                    for (const nextNodeName of nextNodes) {
+                        this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
+                        const nextNode = this.nodes.get(nextNodeName);
+                        if (nextNode) {
+                            yield this.executeNode(nextNodeName, context, undefined, nextNode.waitForEvent);
+                        }
+                        this.addLog(`✅ Branch "${nextNodeName}" completed`);
                     }
-                    console.warn(`[Graph ${this.name}] Retry attempt ${attempts} for node ${nodeName}`, { error });
-                    yield new Promise((resolve) => setTimeout(resolve, delay));
                 }
+                // Mettre à jour le contexte global
+                Object.assign(this.context, context);
+            }
+            catch (error) {
+                this.addLog(`❌ Error in node "${nodeName}": ${error.message}`);
+                this.eventEmitter.emit("nodeError", { name: nodeName, error });
+                throw error;
             }
         });
     }
@@ -195,31 +288,28 @@ class GraphFlow {
      * @param {any} inputParams - Optional input parameters for the start node
      * @returns {Promise<GraphContext<T>>} Final context after execution
      */
-    execute(startNode, inputContext, inputParams) {
+    execute(startNode, inputParams, inputContext) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            // Fresh local context from the global
-            const context = this.createNewContext();
-            if (inputContext)
-                Object.assign(context, inputContext);
-            // Emit "graphStarted"
+            if (inputParams) {
+                // Merge inputParams into context
+                Object.assign(this.context, inputParams);
+            }
+            if (inputContext) {
+                Object.assign(this.context, inputContext);
+            }
             this.eventEmitter.emit("graphStarted", { name: this.name });
             try {
-                // Because we're calling explicitly, it's NOT triggered by an event
-                yield this.executeNode(startNode, context, inputParams, 
-                /* triggeredByEvent= */ false);
-                // Emit "graphCompleted"
+                yield this.executeNode(startNode, this.context, inputParams, false);
                 this.eventEmitter.emit("graphCompleted", {
                     name: this.name,
                     context: this.context,
                 });
-                // Return a snapshot of the final global context
-                return structuredClone(this.context);
+                return this.getContext();
             }
             catch (error) {
-                // Emit "graphError"
                 this.eventEmitter.emit("graphError", { name: this.name, error });
-                (_a = this.globalErrorHandler) === null || _a === void 0 ? void 0 : _a.call(this, error, context);
+                (_a = this.globalErrorHandler) === null || _a === void 0 ? void 0 : _a.call(this, error, this.context);
                 throw error;
             }
         });
@@ -232,14 +322,17 @@ class GraphFlow {
      */
     emit(eventName, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Merge data into a fresh copy of the global context if desired
-            const context = this.createNewContext();
-            if (data)
-                Object.assign(context, data);
-            // Just emit the event; the node-based event listeners in setupEventListeners()
-            // will handle calling "executeNode(...)"
-            this.eventEmitter.emit(eventName, context);
-            // Return the updated global context
+            const workingContext = this.createNewContext();
+            if (data) {
+                Object.assign(workingContext, data);
+            }
+            const eventNodes = Array.from(this.nodes.values()).filter((node) => { var _a; return (_a = node.events) === null || _a === void 0 ? void 0 : _a.includes(eventName); });
+            // Exécuter les nœuds d'événements séquentiellement
+            for (const node of eventNodes) {
+                yield this.executeNode(node.name, workingContext, undefined, true);
+            }
+            // Mettre à jour le contexte global
+            this.context = workingContext;
             return this.getContext();
         });
     }
@@ -294,8 +387,8 @@ class GraphFlow {
         this.setupGraphEventListeners();
     }
     /**
-     * Returns the current context
-     * @returns {GraphContext<T>} Current graph context
+     * Gets a copy of the current context
+     * @returns {GraphContext<T>} A deep copy of the current context
      */
     getContext() {
         return structuredClone(this.context);
@@ -398,5 +491,11 @@ class GraphFlow {
             });
         }
     }
+    getLogs() {
+        return [...this.logs];
+    }
+    clearLogs() {
+        this.logs = [];
+    }
 }
 exports.GraphFlow = GraphFlow;

package/dist/index.js

@@ -26,8 +26,8 @@ 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("./graph"), exports);
 __exportStar(require("./graph/controller"), exports);
+__exportStar(require("./graph/index"), exports);
 __exportStar(require("./modules/memory"), exports);
 __exportStar(require("./modules/memory/adapters/meilisearch"), exports);
 __exportStar(require("./modules/memory/adapters/redis"), exports);

package/dist/modules/embedding/index.js

@@ -9,18 +9,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Embedding = void 0;
+exports.EmbeddingManager = void 0;
 const ai_1 = require("ai");
 /**
- * @module Embedding
+ * @module EmbeddingManager
  * @description A module for generating and managing text embeddings.
  * Provides functionality for converting text into vector representations
  * and calculating similarities between embeddings.
  * @implements {IEmbeddingModule}
  */
-class Embedding {
+class EmbeddingManager {
     /**
-     * Creates an instance of Embedding
+     * Creates an instance of EmbeddingManager
      * @param {IEmbeddingModel} embeddingModel - The embedding model implementation to use
      */
     constructor(embeddingModel) {
@@ -56,4 +56,4 @@ class Embedding {
         return ((0, ai_1.cosineSimilarity)(embedding1, embedding2) + 1) * 50;
     }
 }
-exports.Embedding = Embedding;
+exports.EmbeddingManager = EmbeddingManager;

package/dist/utils/generate-action-schema.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSchemaString = exports.generateActionSchema = void 0;
 const zod_1 = require("zod");
-const generateActionSchema = (nodes) => {
-    return nodes
-        .map((node) => {
-        const schemaStr = node.inputs
-            ? (0, exports.getSchemaString)(node.inputs)
+const generateActionSchema = (graphs) => {
+    return graphs
+        .map((graph) => {
+        const rootNode = Array.from(graph.nodes.values())[0];
+        const schemaStr = rootNode.inputs
+            ? (0, exports.getSchemaString)(rootNode.inputs)
             : "No parameters";
-        return `Workflow: ${node.name}\nParameters: ${schemaStr}`;
+        return `Workflow: ${graph.name}\nParameters: ${schemaStr}`;
     })
         .join("\n\n");
 };

package/graph/index.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "events";
-import { IEventEmitter } from "interfaces";
 import { ZodSchema } from "zod";
 import { GraphContext, GraphDefinition, Node } from "../types";
+import { IEventEmitter } from "../interfaces";
 
 /**
  * @module GraphFlow
@@ -17,7 +17,6 @@ import { GraphContext, GraphDefinition, Node } from "../types";
  * @template T - Extends ZodSchema for type validation
  */
 export class GraphFlow<T extends ZodSchema> {
-  private nodes: Map<string, Node<T, any>>;
   private context: GraphContext<T>;
   public validator?: T;
   private eventEmitter: IEventEmitter;
@@ -26,6 +25,7 @@ export class GraphFlow<T extends ZodSchema> {
   private entryNode?: string;
   private logs: string[] = [];
   private verbose: boolean = false;
+  public nodes: Map<string, Node<T, any>>;
 
   /**
    * Creates a new instance of GraphFlow
@@ -279,18 +279,14 @@ export class GraphFlow<T extends ZodSchema> {
         if (nextNodes.length > 0) {
           this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
 
-          // Créer un contexte unique pour toutes les branches
-          const branchContext = structuredClone(context);
-
-          // Exécuter les branches séquentiellement avec le même contexte
+          // Execute next nodes
           for (const nextNodeName of nextNodes) {
             this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
             const nextNode = this.nodes.get(nextNodeName);
             if (nextNode) {
-              // Utiliser le même contexte pour toutes les branches
               await this.executeNode(
                 nextNodeName,
-                branchContext,
+                context,
                 undefined,
                 nextNode.waitForEvent
               );
@@ -298,10 +294,6 @@ export class GraphFlow<T extends ZodSchema> {
             this.addLog(`✅ Branch "${nextNodeName}" completed`);
           }
 
-          // Mettre à jour le contexte global avec le résultat final des branches
-          Object.assign(context, branchContext);
-          this.context = structuredClone(context);
-
           this.eventEmitter.emit("graphCompleted", {
             name: this.name,
             context: this.context,
@@ -320,29 +312,24 @@ export class GraphFlow<T extends ZodSchema> {
       if (nextNodes.length > 0) {
         this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
 
-        // Créer un contexte unique pour toutes les branches
-        const branchContext = structuredClone(context);
-
-        // Exécuter les branches séquentiellement avec le même contexte
+        // Execute next nodes
         for (const nextNodeName of nextNodes) {
           this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
           const nextNode = this.nodes.get(nextNodeName);
           if (nextNode) {
-            // Utiliser le même contexte pour toutes les branches
             await this.executeNode(
               nextNodeName,
-              branchContext,
+              context,
               undefined,
               nextNode.waitForEvent
             );
           }
           this.addLog(`✅ Branch "${nextNodeName}" completed`);
         }
-
-        // Mettre à jour le contexte global avec le résultat final des branches
-        Object.assign(context, branchContext);
-        this.context = structuredClone(context);
       }
+
+      // Mettre à jour le contexte global
+      Object.assign(this.context, context);
     } catch (error: any) {
       this.addLog(`❌ Error in node "${nodeName}": ${error.message}`);
       this.eventEmitter.emit("nodeError", { name: nodeName, error });
@@ -411,7 +398,7 @@ export class GraphFlow<T extends ZodSchema> {
     eventName: string,
     data?: Partial<GraphContext<T>>
   ): Promise<GraphContext<T>> {
-    const workingContext = structuredClone(this.context);
+    const workingContext = this.createNewContext();
 
     if (data) {
       Object.assign(workingContext, data);
@@ -421,18 +408,13 @@ export class GraphFlow<T extends ZodSchema> {
       node.events?.includes(eventName)
     );
 
-    // Execute event nodes sequentially with shared context
+    // Exécuter les nœuds d'événements séquentiellement
     for (const node of eventNodes) {
       await this.executeNode(node.name, workingContext, undefined, true);
     }
 
-    // Update global context after all event nodes are executed
-    this.context = structuredClone(workingContext);
-
-    this.eventEmitter.emit("graphCompleted", {
-      name: this.name,
-      context: this.context,
-    });
+    // Mettre à jour le contexte global
+    this.context = workingContext;
 
     return this.getContext();
   }

package/modules/embedding/index.ts

@@ -2,15 +2,15 @@ import { cosineSimilarity } from "ai";
 import { IEmbeddingModel, IEmbeddingModule } from "../../interfaces";
 
 /**
- * @module Embedding
+ * @module EmbeddingManager
  * @description A module for generating and managing text embeddings.
  * Provides functionality for converting text into vector representations
  * and calculating similarities between embeddings.
  * @implements {IEmbeddingModule}
  */
-export class Embedding implements IEmbeddingModule {
+export class EmbeddingManager implements IEmbeddingModule {
   /**
-   * Creates an instance of Embedding
+   * Creates an instance of EmbeddingManager
    * @param {IEmbeddingModel} embeddingModel - The embedding model implementation to use
    */
   constructor(private readonly embeddingModel: IEmbeddingModel) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -13,34 +13,21 @@
   "author": "Lorcann Rauzduel",
   "license": "ISC",
   "dependencies": {
-    "@ai-sdk/deepseek": "^0.1.0",
-    "@ai-sdk/openai": "1.0.6",
     "@types/node-cron": "^3.0.11",
     "ai": "^3.0.0",
-    "chalk": "^5.4.1",
-    "ethers": "^6.13.5",
-    "ioredis": "^5.4.2",
-    "langchain": "^0.3.11",
     "node-cron": "^3.0.3",
-    "readline": "^1.3.0",
     "redis": "^4.7.0",
-    "rss-parser": "^3.13.0",
-    "sinon": "^19.0.2",
-    "ws": "^8.18.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
     "@types/chai": "^4.3.20",
-    "@types/mocha": "^10.0.0",
+    "@types/mocha": "^10.0.10",
     "@types/sinon": "^17.0.3",
-    "@types/ws": "^8.5.14",
     "chai": "^4.5.0",
-    "dotenv": "^16.4.7",
-    "meilisearch": "^0.37.0",
     "mocha": "^10.0.0",
     "nyc": "^17.1.0",
     "redis": "^4.6.13",
+    "sinon": "^19.0.2",
     "ts-node": "^10.9.0",
     "typescript": "^5.7.2"
   },