@ai.ntellect/core 0.6.17 → 0.6.19

package/dist/{memory → modules/memory}/adapters/redis/index.js

@@ -11,7 +11,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisAdapter = void 0;
 const redis_1 = require("redis");
+/**
+ * @module RedisAdapter
+ * @description Adapter implementation for Redis as a memory storage solution.
+ * Provides integration with Redis for storing and retrieving memory entries with TTL support.
+ * @implements {IMemoryAdapter}
+ */
 class RedisAdapter {
+    /**
+     * Creates an instance of RedisAdapter
+     * @param {string} redisUrl - Redis connection URL
+     * @param {Object} options - Configuration options
+     * @param {string} [options.cachePrefix="memory:"] - Prefix for Redis keys
+     * @param {number} [options.cacheTTL=3600] - Default TTL in seconds
+     */
     constructor(redisUrl, options) {
         this.redisUrl = redisUrl;
         this.cachePrefix = options.cachePrefix || "memory:";
@@ -24,36 +37,64 @@ class RedisAdapter {
             },
         });
     }
-    initializeConnection() {
+    /**
+     * Initializes the Redis connection
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    init(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             this.redis.on("error", (err) => console.error("Redis Client Error:", err));
             yield this.redis.connect();
         });
     }
-    createMemory(memory, ttl) {
+    /**
+     * Creates a new memory entry in Redis
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
+     */
+    createMemory(input) {
         return __awaiter(this, void 0, void 0, function* () {
+            const memory = {
+                id: input.id || crypto.randomUUID(),
+                data: input.data,
+                embedding: input.embedding,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
             const key = memory.roomId
                 ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
                 : `${this.cachePrefix}${memory.id}`;
             yield this.redis.set(key, JSON.stringify(memory), {
-                EX: ttl || this.cacheTTL,
+                EX: this.cacheTTL,
             });
+            return memory;
         });
     }
+    /**
+     * Retrieves a memory by ID and room ID from Redis
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
     getMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const key = roomId
-                ? `${this.cachePrefix}${roomId}:${id}`
-                : `${this.cachePrefix}${id}`;
+            const key = `${this.cachePrefix}${roomId}:${id}`;
             const data = yield this.redis.get(key);
             return data ? JSON.parse(data) : null;
         });
     }
-    getMemoryByIndex(query_1) {
-        return __awaiter(this, arguments, void 0, function* (query, options = {}) {
-            const pattern = options.roomId
-                ? `${this.cachePrefix}${options.roomId}:*`
-                : `${this.cachePrefix}*`;
+    /**
+     * Searches for memories in Redis based on pattern matching
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pattern = `${this.cachePrefix}${options.roomId}:*`;
             const keys = yield this.redis.keys(pattern);
             const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
                 const data = yield this.redis.get(key);
@@ -62,9 +103,15 @@ class RedisAdapter {
             return memories.filter(Boolean).slice(0, options.limit || 10);
         });
     }
-    getAllMemories() {
+    /**
+     * Retrieves all memories for a room from Redis
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
+    getAllMemories(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const keys = yield this.redis.keys(`${this.cachePrefix}*`);
+            const pattern = `${this.cachePrefix}${roomId}:*`;
+            const keys = yield this.redis.keys(pattern);
             const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
                 const data = yield this.redis.get(key);
                 return data ? JSON.parse(data) : null;
@@ -72,11 +119,22 @@ class RedisAdapter {
             return memories.filter(Boolean);
         });
     }
-    clearMemoryById(id) {
+    /**
+     * Deletes a specific memory from Redis
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    clearMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.redis.del(`${this.cachePrefix}${id}`);
+            const key = `${this.cachePrefix}${roomId}:${id}`;
+            yield this.redis.del(key);
         });
     }
+    /**
+     * Clears all memories across all rooms from Redis
+     * @returns {Promise<void>}
+     */
     clearAllMemories() {
         return __awaiter(this, void 0, void 0, function* () {
             const keys = yield this.redis.keys(`${this.cachePrefix}*`);
@@ -85,6 +143,10 @@ class RedisAdapter {
             }
         });
     }
+    /**
+     * Closes the Redis connection
+     * @returns {Promise<void>}
+     */
     quit() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.redis) {

package/dist/modules/memory/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+const interfaces_1 = require("../../interfaces");
+/**
+ * @module Memory
+ * @description A module for managing memory storage and retrieval operations.
+ * Implements the BaseMemory abstract class and provides concrete implementations
+ * for memory-related operations using the provided adapter.
+ * @extends {BaseMemory}
+ */
+class Memory extends interfaces_1.BaseMemory {
+    /**
+     * Creates an instance of Memory
+     * @param {IMemoryAdapter} adapter - The memory adapter implementation to use
+     */
+    constructor(adapter) {
+        super(adapter);
+    }
+    /**
+     * Initializes the memory module with default room
+     * @returns {Promise<void>}
+     */
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.init("default");
+        });
+    }
+    /**
+     * Creates a new memory entry
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
+     */
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.adapter.createMemory(input);
+        });
+    }
+    /**
+     * Retrieves a memory by ID and room ID
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.adapter.getMemoryById(id, roomId);
+        });
+    }
+    /**
+     * Searches for memories based on query and options
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results to return
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.adapter.getMemoryByIndex(query, options);
+        });
+    }
+    /**
+     * Retrieves all memories for a specific room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories in the room
+     */
+    getAllMemories(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.adapter.getAllMemories(roomId);
+        });
+    }
+    /**
+     * Deletes a specific memory
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    clearMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.clearMemoryById(id, roomId);
+        });
+    }
+    /**
+     * Clears all memories across all rooms
+     * @returns {Promise<void>}
+     */
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.clearAllMemories();
+        });
+    }
+}
+exports.Memory = Memory;

package/dist/utils/{stringifiy-zod-schema.js → generate-action-schema.js}

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaString = exports.stringifyZodSchema = void 0;
+exports.getSchemaString = exports.generateActionSchema = void 0;
 const zod_1 = require("zod");
-const stringifyZodSchema = (nodes) => {
+const generateActionSchema = (nodes) => {
     return nodes
         .map((node) => {
-        const schemaStr = node.parameters
-            ? (0, exports.getSchemaString)(node.parameters)
+        const schemaStr = node.inputs
+            ? (0, exports.getSchemaString)(node.inputs)
             : "No parameters";
         return `Workflow: ${node.name}\nParameters: ${schemaStr}`;
     })
         .join("\n\n");
 };
-exports.stringifyZodSchema = stringifyZodSchema;
+exports.generateActionSchema = generateActionSchema;
 const getSchemaString = (schema) => {
     if (schema instanceof zod_1.z.ZodObject) {
         const entries = Object.entries(schema.shape);

package/graph/controller.ts

@@ -1,10 +1,22 @@
 import { ZodSchema } from "zod";
-import { Graph } from ".";
 import { GraphContext } from "../types";
+import { GraphFlow } from "./index";
 
+/**
+ * Controller class for managing the execution of graph flows
+ * Handles both sequential and parallel execution of multiple graphs
+ */
 export class GraphController {
+  /**
+   * Executes multiple graphs sequentially
+   * @param graphs - Array of GraphFlow instances to execute
+   * @param startNodes - Array of starting node identifiers for each graph
+   * @param inputContexts - Optional array of initial contexts for each graph
+   * @returns Map containing results of each graph execution, keyed by graph name and index
+   * @template T - Zod schema type for graph context validation
+   */
   static async executeSequential<T extends ZodSchema>(
-    graphs: Graph<T>[],
+    graphs: GraphFlow<T>[],
     startNodes: string[],
     inputContexts?: Partial<GraphContext<T>>[]
   ): Promise<Map<string, GraphContext<T>>> {
@@ -16,11 +28,21 @@ export class GraphController {
     return results;
   }
 
+  /**
+   * Executes multiple graphs in parallel with optional concurrency control
+   * @param graphs - Array of GraphFlow instances to execute
+   * @param startNodes - Array of starting node identifiers for each graph
+   * @param inputContexts - Optional array of initial contexts for each graph
+   * @param inputs - Optional array of additional inputs for each graph
+   * @param concurrencyLimit - Optional limit on number of concurrent graph executions
+   * @returns Map containing results of each graph execution, keyed by graph name
+   * @template T - Zod schema type for graph context validation
+   */
   static async executeParallel<T extends ZodSchema>(
-    graphs: Graph<T>[],
+    graphs: GraphFlow<T>[],
     startNodes: string[],
     inputContexts?: Partial<GraphContext<T>>[],
-    inputParams?: any[],
+    inputs?: any[],
     concurrencyLimit?: number
   ): Promise<Map<string, GraphContext<T>>> {
     const results = new Map<string, GraphContext<T>>();
@@ -29,20 +51,22 @@ export class GraphController {
       inputContexts = inputContexts.map((ctx) => ctx || {});
     }
 
-    if (inputParams) {
-      inputParams = inputParams.map((params) => params || {});
+    if (inputs) {
+      inputs = inputs.map((input) => input || {});
     }
 
     if (concurrencyLimit) {
       for (let i = 0; i < graphs.length; i += concurrencyLimit) {
         const batchResults = await Promise.all(
-          graphs.slice(i, i + concurrencyLimit).map((graph, index) =>
-            graph.execute(
-              startNodes[i + index],
-              inputContexts?.[i + index] || {},
-              inputParams?.[i + index] || {} // ✅ Passe bien les paramètres
+          graphs
+            .slice(i, i + concurrencyLimit)
+            .map((graph, index) =>
+              graph.execute(
+                startNodes[i + index],
+                inputContexts?.[i + index] || {},
+                inputs?.[i + index]
+              )
             )
-          )
         );
         batchResults.forEach((result, index) => {
           results.set(`${graphs[i + index].name}`, result);
@@ -54,7 +78,7 @@ export class GraphController {
           graph.execute(
             startNodes[index],
             inputContexts?.[index] || {},
-            inputParams?.[index] || {}
+            inputs?.[index] || {}
           )
         )
       );