@ai.ntellect/core 0.1.81 → 0.1.84

package/dist/agent/index.js

@@ -5,12 +5,14 @@ const evaluator_1 = require("../llm/evaluator");
 const synthesizer_1 = require("../llm/synthesizer");
 const types_1 = require("../types");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+const sanitize_results_1 = require("../utils/sanitize-results");
 const ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
     constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration = 1, }) {
         this.SIMILARITY_THRESHOLD = 95;
         this.MAX_RESULTS = 1;
         this.evaluatorIteration = 0;
+        this.accumulatedResults = [];
         this.user = user;
         this.orchestrator = orchestrator;
         this.cacheMemory = cacheMemory;
@@ -18,21 +20,40 @@ class Agent {
         this.stream = stream;
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
+        this.accumulatedResults = [];
     }
     async process(prompt, contextualizedPrompt, events) {
-        const request = await this.orchestrator.process(contextualizedPrompt);
-        events.onMessage?.(request);
-        if (request.actions.length > 0) {
-            return this.handleActions({
+        let actions = undefined;
+        let isSimilar = false;
+        if (this.cacheMemory) {
+            const similarActions = await this.cacheMemory.findSimilarQueries(prompt, {
+                similarityThreshold: this.SIMILARITY_THRESHOLD,
+                maxResults: this.MAX_RESULTS,
+                userId: this.user.id,
+                scope: types_1.MemoryScope.GLOBAL,
+            });
+            if (similarActions.length > 0) {
+                actions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(similarActions[0].data);
+                isSimilar = true;
+            }
+        }
+        if (!actions?.length && !isSimilar) {
+            console.log("No similar actions found in cache for query: ", prompt);
+            console.log("Requesting orchestrator for actions..");
+            const request = await this.orchestrator.process(contextualizedPrompt);
+            events.onMessage?.(request);
+            actions = request.actions;
+        }
+        return actions && actions.length > 0
+            ? this.handleActions({
                 initialPrompt: prompt,
                 contextualizedPrompt: contextualizedPrompt,
-                actions: request.actions,
-            }, events);
-        }
+                actions: actions,
+            }, events)
+            : undefined;
     }
     async handleActions({ initialPrompt, contextualizedPrompt, actions, }, events) {
-        const similarActions = await this.findSimilarActions(initialPrompt);
-        const queueItems = this.transformActions(actions, similarActions);
+        const queueItems = this.transformActions(actions);
         const actionsResult = await this.actionHandler.executeActions(queueItems, this.orchestrator.tools, {
             onQueueStart: events.onQueueStart,
             onActionStart: events.onActionStart,
@@ -40,55 +61,62 @@ class Agent {
             onQueueComplete: events.onQueueComplete,
             onConfirmationRequired: events.onConfirmationRequired,
         });
+        this.accumulatedResults = [
+            ...this.accumulatedResults,
+            ...actionsResult.data,
+        ];
         if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-            return this.handleActionResults({ ...actionsResult, initialPrompt });
+            return this.handleActionResults({
+                data: this.accumulatedResults,
+                initialPrompt,
+            });
         }
         const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.persistentMemory);
-        const evaluation = await evaluator.process(initialPrompt, contextualizedPrompt, JSON.stringify(actionsResult.data));
+        console.log("Accumulated results:");
+        console.dir(this.accumulatedResults, { depth: null });
+        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(this.accumulatedResults);
+        const evaluation = await evaluator.process(initialPrompt, contextualizedPrompt, sanitizedResults);
         events.onMessage?.(evaluation);
-        if (evaluation.nextActions.length > 0) {
+        if (evaluation.isNextActionNeeded) {
             this.evaluatorIteration++;
             return this.handleActions({
                 initialPrompt: contextualizedPrompt,
                 contextualizedPrompt: initialPrompt,
-                actions: evaluation.nextActions,
+                actions: evaluation.nextActionsNeeded,
             }, events);
         }
-        if (!this.actionHandler.hasNonPrepareActions(actionsResult.data)) {
+        if (!this.actionHandler.hasNonPrepareActions(this.accumulatedResults)) {
             return {
-                data: actionsResult.data,
+                data: this.accumulatedResults,
                 initialPrompt,
             };
         }
-        return this.handleActionResults({ ...actionsResult, initialPrompt });
+        return this.handleActionResults({
+            data: this.accumulatedResults,
+            initialPrompt,
+        });
     }
     async handleActionResults(actionsResult) {
         const synthesizer = new synthesizer_1.Synthesizer();
+        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(this.accumulatedResults);
         const summaryData = JSON.stringify({
-            result: actionsResult.data,
+            result: sanitizedResults,
             initialPrompt: actionsResult.initialPrompt,
         });
+        this.accumulatedResults = [];
+        this.evaluatorIteration = 0;
+        await this.cacheMemory?.createMemory({
+            content: actionsResult.initialPrompt,
+            data: actionsResult.data,
+            scope: types_1.MemoryScope.GLOBAL,
+            type: types_1.MemoryType.ACTION,
+        });
         return this.stream
             ? (await synthesizer.streamProcess(summaryData)).toDataStreamResponse()
             : await synthesizer.process(summaryData);
     }
-    async findSimilarActions(prompt) {
-        if (!this.cacheMemory) {
-            return [];
-        }
-        return this.cacheMemory.findBestMatches(prompt, {
-            similarityThreshold: this.SIMILARITY_THRESHOLD,
-            maxResults: this.MAX_RESULTS,
-            userId: this.user.id,
-            scope: types_1.MemoryScope.USER,
-        });
-    }
-    transformActions(actions, similarActions) {
+    transformActions(actions) {
         let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
-        if (similarActions?.length > 0) {
-            predefinedActions =
-                queue_item_transformer_1.QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
-        }
         return predefinedActions;
     }
 }

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./agent";
 export * from "./llm/orchestrator";
 export * from "./llm/synthesizer";
-export * from "./services/queue";
 export * from "./types";
 export * from "./memory/cache";
 export * from "./memory/persistent";

package/dist/index.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent"), exports);
 __exportStar(require("./llm/orchestrator"), exports);
 __exportStar(require("./llm/synthesizer"), exports);
-__exportStar(require("./services/queue"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./memory/cache"), exports);
 __exportStar(require("./memory/persistent"), exports);

package/dist/llm/evaluator/context.js

@@ -9,7 +9,7 @@ exports.evaluatorContext = {
             "Verify if all required actions were executed successfully",
             "Check if the results match the initial goal",
             "Identify any missing or incomplete information",
-            "Examples of relavant information: link symbol to token address, name to wallet, etc.",
+            "Extra and relevant information they don't have be stored in the memory: link symbol to token address, name to wallet, etc.",
         ],
         warnings: [
             "NEVER modify the results directly",
@@ -31,10 +31,8 @@ exports.evaluatorContext = {
       1. Success status with explanation (no action needed)
       2. Next actions needed (if any)
       3. Why you are doing the next actions or why you are not doing them
-      4. Extract relevant information to remember. No need to remember specific numbers.
-      5. If there are no important results, let importantToRemembers be empty. No need to say something like "No relevant information found".
-      6. For each facts, generate a hypothetical query to search in the persistent memory.
-      7. For each facts, generate a memoryType (You have 3 memory types: episodic, semantic, procedural)
+      4. Extract relevant information to remember
+      5. For each facts, generate a memoryType (3 memory types: episodic, semantic, procedural)
     `;
     },
 };

package/dist/llm/evaluator/index.js

@@ -17,35 +17,31 @@ class Evaluator {
             const response = await (0, ai_1.generateObject)({
                 model: this.model,
                 schema: zod_1.z.object({
-                    nextActions: zod_1.z.array(zod_1.z.object({
-                        name: zod_1.z.string(),
-                        parameters: zod_1.z.object({
-                            name: zod_1.z.string(),
-                            value: zod_1.z.string(),
-                        }),
-                    })),
-                    why: zod_1.z.string(),
-                    isImportantToRemember: zod_1.z.boolean(),
-                    importantToRemembers: zod_1.z.array(zod_1.z.object({
+                    isRemindNeeded: zod_1.z.boolean(),
+                    extraInformationsToRemember: zod_1.z.array(zod_1.z.object({
                         memoryType: zod_1.z.string(),
-                        hypotheticalQuery: zod_1.z.string(),
-                        result: zod_1.z.string(),
+                        content: zod_1.z.string(),
+                        data: zod_1.z.string(),
                     })),
+                    response: zod_1.z.string(),
+                    isNextActionNeeded: zod_1.z.boolean(),
+                    nextActionsNeeded: types_1.ActionSchema,
+                    why: zod_1.z.string(),
                 }),
                 prompt: prompt,
                 system: context_1.evaluatorContext.compose(goal, results, this.tools),
             });
             const validatedResponse = {
                 ...response.object,
-                nextActions: response.object.nextActions.map((action) => ({
+                nextActions: response.object.nextActionsNeeded.map((action) => ({
                     ...action,
                     parameters: action.parameters || {},
                 })),
             };
-            if (validatedResponse.isImportantToRemember) {
-                for (const item of validatedResponse.importantToRemembers) {
+            if (validatedResponse.isRemindNeeded) {
+                for (const item of validatedResponse.extraInformationsToRemember) {
                     // Check if the item is already in the memory
-                    const memories = await this.memory.searchSimilarQueries(item.hypotheticalQuery, {
+                    const memories = await this.memory.searchSimilarQueries(item.content, {
                         similarityThreshold: 95,
                     });
                     if (memories.length > 0) {
@@ -56,14 +52,14 @@ class Evaluator {
                     }
                     if (memories.length === 0) {
                         console.log("Adding to memory", {
-                            query: item.hypotheticalQuery,
-                            data: item.result,
+                            query: item.content,
+                            data: item.data,
                         });
-                        await this.memory.storeMemory({
+                        await this.memory.createMemory({
                             id: crypto.randomUUID(),
                             purpose: item.memoryType,
-                            query: item.hypotheticalQuery,
-                            data: item.result,
+                            query: item.content,
+                            data: item.data,
                             scope: types_1.MemoryScope.GLOBAL,
                             createdAt: new Date(),
                         });
@@ -79,20 +75,20 @@ class Evaluator {
                 console.log("Evaluator error");
                 console.dir(error.value, { depth: null });
                 console.error(error.message);
-                if (error.value.importantToRemembers.length > 0) {
-                    for (const item of error.value.importantToRemembers) {
+                if (error.value.extraInformationsToRemember.length > 0) {
+                    for (const item of error.value.extraInformationsToRemember) {
                         // Check if the item is already in the memory
-                        const memories = await this.memory.searchSimilarQueries(item.hypotheticalQuery);
+                        const memories = await this.memory.searchSimilarQueries(item.content);
                         if (memories.length === 0) {
                             console.log("Adding to memory", {
-                                query: item.hypotheticalQuery,
-                                data: item.result,
+                                query: item.content,
+                                data: item.data,
                             });
-                            await this.memory.storeMemory({
+                            await this.memory.createMemory({
                                 id: crypto.randomUUID(),
                                 purpose: "importantToRemember",
-                                query: item.hypotheticalQuery,
-                                data: item.result,
+                                query: item.content,
+                                data: item.data,
                                 scope: types_1.MemoryScope.USER,
                                 createdAt: new Date(),
                             });

package/dist/llm/orchestrator/context.js

@@ -7,7 +7,7 @@ exports.orchestratorContext = {
     guidelines: {
         important: [
             "If there is no action to do, you must answer in the 'answer' field.",
-            "If some parameters are not clear or missing, YOU MUST ask the user for them.",
+            "If some parameters are not clear or missing, don't add the action, YOU MUST ask the user for them.",
             "ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
             "For QUESTIONS or ANALYSIS, BEFORE executing ANY actions, you MUST search in memory for similar queries AS THE ONLY ACTION TO EXECUTE.",
         ],

package/dist/llm/orchestrator/index.js

@@ -4,6 +4,7 @@ exports.Orchestrator = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
+const types_1 = require("../../types");
 const context_1 = require("./context");
 class Orchestrator {
     constructor(tools, memory) {
@@ -17,8 +18,34 @@ class Orchestrator {
                 parameters: zod_1.z.object({
                     query: zod_1.z.string(),
                 }),
-                execute: async (params) => {
-                    const memories = await this.memory.searchSimilarQueries(params.value);
+                execute: async ({ query }) => {
+                    const memories = await this.memory.searchSimilarQueries(query, {
+                        similarityThreshold: 95,
+                    });
+                    return memories;
+                },
+            },
+            {
+                name: "save_memory",
+                description: "Save relevant information in the internal knowledge base",
+                parameters: zod_1.z.object({
+                    query: zod_1.z.string(),
+                    memoryType: zod_1.z.string(),
+                    data: zod_1.z.any(),
+                    scope: zod_1.z.string().default("GLOBAL").describe("GLOBAL or USER"),
+                    userId: zod_1.z.string(),
+                    whyStored: zod_1.z.string(),
+                }),
+                execute: async ({ query, purpose, data, scope, userId, }) => {
+                    const memories = await this.memory.createMemory({
+                        query,
+                        purpose,
+                        data,
+                        scope,
+                        userId,
+                        createdAt: new Date(),
+                        id: crypto.randomUUID(),
+                    });
                     return memories;
                 },
             },
@@ -29,13 +56,7 @@ class Orchestrator {
             const response = await (0, ai_1.generateObject)({
                 model: this.model,
                 schema: zod_1.z.object({
-                    actions: zod_1.z.array(zod_1.z.object({
-                        name: zod_1.z.string(),
-                        parameters: zod_1.z.object({
-                            name: zod_1.z.string(),
-                            value: zod_1.z.string(),
-                        }),
-                    })),
+                    actions: types_1.ActionSchema,
                     answer: zod_1.z.string(),
                 }),
                 prompt: prompt,

package/dist/llm/synthesizer/index.d.ts

@@ -5,11 +5,7 @@ export declare class Synthesizer implements BaseLLM {
     process(prompt: string, onFinish?: (event: any) => void): Promise<{
         actions: {
             name: string;
-            relevantResult: string;
-            explain: {
-                how: string;
-                why: string;
-            };
+            reasoning: string;
         }[];
         response: string;
     } | StreamTextResult<Record<string, any>>>;

package/dist/llm/synthesizer/index.js

@@ -16,11 +16,7 @@ class Synthesizer {
             schema: zod_1.z.object({
                 actions: zod_1.z.array(zod_1.z.object({
                     name: zod_1.z.string(),
-                    relevantResult: zod_1.z.string(),
-                    explain: zod_1.z.object({
-                        how: zod_1.z.string(),
-                        why: zod_1.z.string(),
-                    }),
+                    reasoning: zod_1.z.string(),
                 })),
                 response: zod_1.z.string(),
             }),

package/dist/memory/cache.d.ts

@@ -1,4 +1,4 @@
-import { CacheMemoryOptions, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
+import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
 export declare class CacheMemory {
     private redis;
     private readonly CACHE_PREFIX;
@@ -7,16 +7,16 @@ export declare class CacheMemory {
     private initRedis;
     private getMemoryKey;
     private storeMemory;
-    findBestMatches(query: string, options?: MatchOptions & {
+    findSimilarQueries(query: string, options?: MatchOptions & {
         userId?: string;
         scope?: MemoryScope;
     }): Promise<{
         data: any;
         similarityPercentage: number;
-        purpose: string;
+        query: string;
     }[]>;
-    private getAllMemories;
+    getAllMemories(scope?: MemoryScope, userId?: string): Promise<CacheMemoryType[]>;
     private getMemoriesFromKeys;
-    createMemory(input: CreateMemoryInput): Promise<string | undefined>;
+    createMemory(input: CreateMemoryInput): Promise<CacheMemoryType | undefined>;
     private createSingleMemory;
 }

package/dist/memory/cache.js

@@ -4,7 +4,6 @@ exports.CacheMemory = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const redis_1 = require("redis");
-const zod_1 = require("zod");
 const types_1 = require("../types");
 class CacheMemory {
     constructor(options = {}) {
@@ -43,30 +42,27 @@ class CacheMemory {
     async storeMemory(memory) {
         const prefix = this.getMemoryKey(memory.scope, memory.userId);
         const key = `${prefix}${memory.id}`;
-        await this.redis.set(key, JSON.stringify(memory), {
+        const result = await this.redis.set(key, JSON.stringify(memory), {
             EX: this.CACHE_TTL,
         });
+        console.log("Cache memory created: ", result);
     }
-    async findBestMatches(query, options = {}) {
-        console.log("\n🔍 Searching in cache for query:", query);
+    async findSimilarQueries(query, options = {}) {
+        console.log("\nSearching in cache for query:", query);
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: query,
         });
         const memories = await this.getAllMemories(options.scope, options.userId);
-        console.log("\n📚 Found", memories.length, "memories to compare with");
+        console.log("\n📚 Found", memories.length, "queries to compare with");
         const matches = memories
             .map((memory) => {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
             const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
-            console.log(`\n📊 Memory "${memory.purpose}":
-        - Similarity: ${similarityPercentage.toFixed(2)}%
-        - Query: ${memory.query}`);
             return {
                 data: memory.data,
+                query: memory.query,
                 similarityPercentage,
-                purpose: memory.purpose,
-                // Optionnel : ajouter des métadonnées utiles
                 memoryId: memory.id,
             };
         })
@@ -76,15 +72,14 @@ class CacheMemory {
             ? matches.slice(0, options.maxResults)
             : matches;
         if (results.length > 0) {
-            console.log("\n✨ Best matches found:");
+            console.log("\n✨ Similar queries found:");
             results.forEach((match) => {
-                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
             });
         }
         else {
             console.log("No matches found");
         }
-        console.dir({ results });
         return results;
     }
     async getAllMemories(scope, userId) {
@@ -114,68 +109,43 @@ class CacheMemory {
         return memories;
     }
     async createMemory(input) {
-        const existingPattern = await this.findBestMatches(input.content, {
+        console.log("Searching for similar memory", input);
+        const existingPattern = await this.findSimilarQueries(input.content, {
             similarityThreshold: 95,
             userId: input.userId,
             scope: input.scope,
         });
         if (existingPattern.length > 0) {
-            console.log("\n🔍 Similar memory found:");
+            console.log("\nSimilar cache memory found:");
             existingPattern.forEach((match) => {
-                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
             });
+            console.log("Cache memory already exists. No need to create new one..");
             return;
         }
-        // Générer les variations via GPT-4
-        const variations = await (0, ai_1.generateObject)({
-            model: (0, openai_1.openai)("gpt-4"),
-            schema: zod_1.z.object({
-                request: zod_1.z.string().describe("The request to be performed"),
-                queries: zod_1.z.array(zod_1.z.object({ text: zod_1.z.string() })),
-            }),
-            prompt: `For this input: "${input.content}"
-        Generate similar variations that should match the same context.
-        Context type: ${input.type}
-        Data: ${JSON.stringify(input.data)}
-        - Keep variations natural and human-like
-        - Include the original input
-        - Add 3-5 variations`,
-        });
-        await this.createSingleMemory({
+        console.log("No similar memory found");
+        const memory = await this.createSingleMemory({
             id: crypto.randomUUID(),
             content: input.content,
             type: input.type,
             data: input.data,
-            purpose: variations.object.request,
             userId: input.userId,
             scope: input.scope,
         });
-        const variationPromises = variations.object.queries.map(async (variation) => {
-            if (variation.text !== input.content) {
-                await this.createSingleMemory({
-                    id: crypto.randomUUID(),
-                    content: variation.text,
-                    type: input.type,
-                    data: input.data,
-                    purpose: variations.object.request,
-                    userId: input.userId,
-                    scope: input.scope,
-                });
-            }
-        });
-        await Promise.all(variationPromises);
-        return variations.object.request;
+        return memory;
     }
     async createSingleMemory(params) {
+        console.log("Creating new cache memory...", params.content);
+        console.log("Creating embedding...");
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: params.content,
         });
+        console.log("Embedding created");
         const memory = {
             id: params.id,
             type: params.type,
             data: params.data,
-            purpose: params.purpose,
             query: params.content,
             embedding,
             userId: params.userId,

package/dist/memory/persistent.d.ts

@@ -41,7 +41,7 @@ export declare class PersistentMemory {
     /**
      * Store a memory in the database
      */
-    storeMemory(memory: Memory): Promise<unknown>;
+    createMemory(memory: Memory): Promise<unknown>;
     /**
      * Find best matching memories
      */

package/dist/memory/persistent.js

@@ -28,7 +28,6 @@ class PersistentMemory {
      */
     async _makeRequest(path, options = {}) {
         const url = `${this.host}${path}`;
-        console.log("Making request to:", url);
         const response = await fetch(url, {
             ...options,
             headers: {
@@ -102,7 +101,7 @@ class PersistentMemory {
     /**
      * Store a memory in the database
      */
-    async storeMemory(memory) {
+    async createMemory(memory) {
         const indexName = this._getIndexName(memory.scope, memory.userId);
         await this._getOrCreateIndex(indexName);
         const chunks = await this.processContent(memory.query);
@@ -115,14 +114,14 @@ class PersistentMemory {
             method: "POST",
             body: JSON.stringify([document]),
         });
-        console.log("Stored memory response:", response);
+        console.log("Stored persistent memory response:", response);
         return response;
     }
     /**
      * Find best matching memories
      */
     async searchSimilarQueries(query, options = {}) {
-        console.log("\n🔍 Searching in persistent memory:", query);
+        console.log("\nSearching in persistent memory:", query);
         // Generate embedding for the query
         const { embedding: queryEmbedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
@@ -162,7 +161,7 @@ class PersistentMemory {
                 searchResults.push(...userResults.hits);
             }
         }
-        console.log("Found in persistent memory:", searchResults);
+        console.log(`📚 Found ${searchResults.length} queries in persistent memory`);
         // Process and filter results using cosine similarity
         const results = searchResults
             .flatMap((hit) => {
@@ -183,7 +182,7 @@ class PersistentMemory {
             .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
         // Log results
         if (results.length > 0) {
-            console.log("\n✨ Best matches found:");
+            console.log("\n✨ Similar queries found in persistent memory:");
             results.forEach((match) => {
                 console.log(`- ${match.query} : ${match.similarityPercentage.toFixed(2)}% (${match.purpose})`);
                 console.log(`  Matching content: "${match.chunk}"`);