@ai.ntellect/core 0.6.21 → 0.7.0

package/dist/modules/memory/adapters/meilisearch/index.js

@@ -1,320 +0,0 @@
-"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.MeilisearchAdapter = void 0;
-/**
- * @module MeilisearchAdapter
- * @description Adapter implementation for Meilisearch as a memory storage solution.
- * Provides integration with Meilisearch for storing and retrieving memory entries.
- * @implements {IMemoryAdapter}
- */
-class MeilisearchAdapter {
-    /**
-     * Creates an instance of MeilisearchAdapter
-     * @param {MeilisearchConfig} config - Configuration for Meilisearch connection
-     */
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Makes an HTTP request to the Meilisearch API
-     * @private
-     * @param {string} path - API endpoint path
-     * @param {RequestInit} [options] - Fetch request options
-     * @returns {Promise<any>} Response data
-     * @throws {Error} If the request fails
-     */
-    makeRequest(path, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.config.host}${path}`;
-                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign({ "Content-Type": "application/json", Authorization: `Bearer ${this.config.apiKey}` }, options === null || options === void 0 ? void 0 : options.headers) }));
-                if (!response.ok) {
-                    const errorBody = yield response.text();
-                    throw new Error(`HTTP ${response.status}: ${errorBody || response.statusText}`);
-                }
-                return response.json();
-            }
-            catch (error) {
-                if (error instanceof TypeError && error.message === "Failed to fetch") {
-                    throw new Error(`Network error: Unable to connect to Meilisearch at ${this.config.host}`);
-                }
-                throw error;
-            }
-        });
-    }
-    /**
-     * Initializes a storage index for a room
-     * @private
-     * @param {string} roomId - Room identifier to create index for
-     * @returns {Promise<void>}
-     */
-    initializeStorage(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let indexExists = false;
-                try {
-                    yield this.makeRequest(`/indexes/${roomId}`);
-                    indexExists = true;
-                }
-                catch (error) {
-                    if (!indexExists) {
-                        const createResponse = yield this.makeRequest("/indexes", {
-                            method: "POST",
-                            body: JSON.stringify({
-                                uid: roomId,
-                                primaryKey: "id",
-                            }),
-                        });
-                        console.log("✅ Index creation response:", createResponse);
-                    }
-                }
-                // Appliquer les settings seulement si l'index existe bien
-                yield this.makeRequest(`/indexes/${roomId}/settings`, {
-                    method: "PATCH",
-                    body: JSON.stringify({
-                        searchableAttributes: this.config.searchableAttributes || [
-                            "data",
-                            "query",
-                        ],
-                        sortableAttributes: this.config.sortableAttributes || ["createdAt"],
-                    }),
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                console.error(`❌ Error initializing storage for index ${roomId}:`, errorMessage);
-                throw new Error(`Failed to initialize storage for index ${roomId}: ${errorMessage}`);
-            }
-        });
-    }
-    /**
-     * Adds documents to the Meilisearch index
-     * @private
-     * @param {BaseMemoryType[]} documents - Documents to add
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<void>}
-     */
-    addDocuments(documents, roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.makeRequest(`/indexes/${roomId}/documents`, {
-                method: "POST",
-                body: JSON.stringify(documents),
-            });
-        });
-    }
-    /**
-     * Deletes a storage index for a room
-     * @private
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<void>}
-     */
-    deleteStorage(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.makeRequest(`/indexes/${roomId}`, {
-                method: "DELETE",
-            });
-        });
-    }
-    /**
-     * Initializes the adapter for a specific room
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<void>}
-     */
-    init(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Initialize the default "memories" index
-                yield this.initializeStorage(roomId);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                console.error("Failed to initialize default index:", errorMessage);
-                throw new Error(`Failed to initialize default index: ${errorMessage}`);
-            }
-        });
-    }
-    /**
-     * Performs a search in the Meilisearch index
-     * @private
-     * @param {string} query - Search query
-     * @param {string} roomId - Room identifier
-     * @param {Object} [options] - Search options
-     * @param {number} [options.limit] - Maximum number of results
-     * @param {number} [options.threshold] - Minimum score threshold
-     * @returns {Promise<SearchResult[]>} Search results
-     */
-    search(query, roomId, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const searchResults = yield this.makeRequest(`/indexes/${roomId}/search`, {
-                method: "POST",
-                body: JSON.stringify({
-                    q: query,
-                    limit: (options === null || options === void 0 ? void 0 : options.limit) || 10,
-                }),
-            });
-            if (!searchResults.hits) {
-                return [];
-            }
-            return searchResults.hits.map((hit) => ({
-                document: {
-                    id: hit.id,
-                    data: hit.data,
-                    embedding: hit.embedding,
-                    roomId: hit.roomId,
-                    createdAt: hit.createdAt,
-                },
-                score: hit._score || 0,
-            }));
-        });
-    }
-    /**
-     * 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* () {
-            // Initialize storage for this roomId if needed
-            yield this.initializeStorage(input.roomId);
-            // Check if the memory already exists
-            const existingMemory = yield this.search(input.data, input.roomId, {
-                limit: 1,
-            });
-            if (existingMemory.length > 0) {
-                return existingMemory[0].document;
-            }
-            // If not found, create new memory
-            const memory = {
-                id: input.id || crypto.randomUUID(),
-                data: input.data,
-                embedding: input.embedding,
-                roomId: input.roomId,
-                createdAt: new Date(),
-            };
-            yield this.addDocuments([memory], input.roomId);
-            return memory;
-        });
-    }
-    /**
-     * 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* () {
-            try {
-                const result = yield this.makeRequest(`/indexes/${roomId}/documents/${id}`);
-                return result
-                    ? {
-                        id: result.id,
-                        data: result.data,
-                        embedding: result.embedding,
-                        roomId: result.roomId,
-                        createdAt: result.createdAt,
-                    }
-                    : null;
-            }
-            catch (_a) {
-                return null;
-            }
-        });
-    }
-    /**
-     * 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
-     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
-     */
-    getMemoryByIndex(query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.search(query, options.roomId, {
-                limit: options.limit,
-            });
-            return results
-                .filter((result) => result.document.roomId === options.roomId)
-                .map((result) => ({
-                id: result.document.id,
-                data: result.document.data,
-                embedding: result.document.embedding,
-                roomId: result.document.roomId,
-                createdAt: result.document.createdAt,
-            }));
-        });
-    }
-    /**
-     * Retrieves all memories for a room
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<BaseMemoryType[]>} Array of all memories
-     */
-    getAllMemories(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.makeRequest(`/indexes/${roomId}/documents`);
-            if (results.total === 0) {
-                return [];
-            }
-            return results.results.map((doc) => ({
-                id: doc.id,
-                data: doc.data,
-                embedding: doc.embedding,
-                roomId: doc.roomId,
-                createdAt: doc.createdAt,
-            }));
-        });
-    }
-    /**
-     * 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* () {
-            try {
-                // Ensure the index exists before attempting to delete
-                yield this.initializeStorage(roomId);
-                yield this.makeRequest(`/indexes/${roomId}/documents/${id}`, {
-                    method: "DELETE",
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                console.error(`Error clearing memory ${id} from index ${roomId}:`, errorMessage);
-                throw new Error(`Failed to clear memory ${id} from index ${roomId}: ${errorMessage}`);
-            }
-        });
-    }
-    /**
-     * Clears all memories across all rooms
-     * @returns {Promise<void>}
-     */
-    clearAllMemories() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Get all indexes
-                const response = yield this.makeRequest("/indexes");
-                const indexes = response.results || [];
-                // Delete each index
-                for (const index of indexes) {
-                    yield this.deleteStorage(index.uid);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                throw new Error(`Failed to clear all memories: ${errorMessage}`);
-            }
-        });
-    }
-}
-exports.MeilisearchAdapter = MeilisearchAdapter;

package/dist/modules/memory/adapters/redis/index.js

@@ -1,158 +0,0 @@
-"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.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:";
-        this.cacheTTL = options.cacheTTL || 3600;
-        this.redis = (0, redis_1.createClient)({
-            url: redisUrl,
-            socket: {
-                tls: true,
-                rejectUnauthorized: true,
-            },
-        });
-    }
-    /**
-     * 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();
-        });
-    }
-    /**
-     * 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: 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 = `${this.cachePrefix}${roomId}:${id}`;
-            const data = yield this.redis.get(key);
-            return data ? JSON.parse(data) : null;
-        });
-    }
-    /**
-     * 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);
-                return data ? JSON.parse(data) : null;
-            })));
-            return memories.filter(Boolean).slice(0, options.limit || 10);
-        });
-    }
-    /**
-     * 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 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;
-            })));
-            return memories.filter(Boolean);
-        });
-    }
-    /**
-     * 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* () {
-            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}*`);
-            if (keys.length > 0) {
-                yield this.redis.del(keys);
-            }
-        });
-    }
-    /**
-     * Closes the Redis connection
-     * @returns {Promise<void>}
-     */
-    quit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.redis) {
-                yield this.redis.quit();
-            }
-        });
-    }
-}
-exports.RedisAdapter = RedisAdapter;

package/dist/modules/memory/index.js

@@ -1,103 +0,0 @@
-"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/types/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaString = exports.generateActionSchema = void 0;
-const zod_1 = require("zod");
-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: ${graph.name}\nParameters: ${schemaStr}`;
-    })
-        .join("\n\n");
-};
-exports.generateActionSchema = generateActionSchema;
-const getSchemaString = (schema) => {
-    if (schema instanceof zod_1.z.ZodObject) {
-        const entries = Object.entries(schema.shape);
-        const fields = entries.map(([key, value]) => {
-            const description = value._def.description;
-            const schemaStr = (0, exports.getSchemaString)(value);
-            return description
-                ? `${key}: ${schemaStr} // ${description}`
-                : `${key}: ${schemaStr}`;
-        });
-        return `z.object({${fields.join(", ")}})`;
-    }
-    if (schema instanceof zod_1.z.ZodArray) {
-        return `z.array(${(0, exports.getSchemaString)(schema.element)})`;
-    }
-    if (schema instanceof zod_1.z.ZodString) {
-        return "z.string()";
-    }
-    if (schema instanceof zod_1.z.ZodNumber) {
-        return "z.number()";
-    }
-    if (schema instanceof zod_1.z.ZodBoolean) {
-        return "z.boolean()";
-    }
-    return `z.unknown()`;
-};
-exports.getSchemaString = getSchemaString;

package/dist/utils/header-builder.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMHeaderBuilder = void 0;
-class LLMHeaderBuilder {
-    constructor() {
-        this.headers = new Map();
-        this._result = "";
-    }
-    addHeader(key, value) {
-        if (Array.isArray(value)) {
-            this.headers.set(key, value.join("\n"));
-        }
-        else {
-            this.headers.set(key, value);
-        }
-        // Build result immediately
-        this._result = Array.from(this.headers.entries())
-            .filter(([_, value]) => value !== undefined)
-            .map(([key, value]) => `# ${key}: ${value}`)
-            .join("\n")
-            .trim();
-        return this;
-    }
-    valueOf() {
-        return this._result;
-    }
-    toString() {
-        return this._result;
-    }
-    static create() {
-        return new LLMHeaderBuilder();
-    }
-}
-exports.LLMHeaderBuilder = LLMHeaderBuilder;