@ai.ntellect/core 0.1.83 → 0.1.85

package/agent/index.ts

@@ -8,9 +8,12 @@ import {
   AgentEvent,
   MemoryScope,
   MemoryType,
+  QueueResult,
+  TransformedQueueItem,
   User,
 } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
+import { ResultSanitizer } from "../utils/sanitize-results";
 import { ActionHandler } from "./handlers/ActionHandler";
 
 export class Agent {
@@ -24,6 +27,7 @@ export class Agent {
   private readonly stream: boolean;
   private readonly maxEvaluatorIteration: number;
   private evaluatorIteration = 0;
+  private accumulatedResults: QueueResult[] = [];
 
   constructor({
     user,
@@ -47,6 +51,7 @@ export class Agent {
     this.stream = stream;
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
+    this.accumulatedResults = [];
   }
 
   async process(
@@ -54,7 +59,9 @@ export class Agent {
     contextualizedPrompt: string,
     events: AgentEvent
   ): Promise<any> {
-    let actions: ActionSchema[] = [];
+    let actions: ActionSchema[] | TransformedQueueItem[] | undefined =
+      undefined;
+    let isSimilar: boolean = false;
 
     if (this.cacheMemory) {
       const similarActions = await this.cacheMemory.findSimilarQueries(prompt, {
@@ -63,27 +70,29 @@ export class Agent {
         userId: this.user.id,
         scope: MemoryScope.GLOBAL,
       });
+
       if (similarActions.length > 0) {
-        actions = similarActions[0].data;
-        console.log("Similar actions found for query: ", prompt);
-        console.dir(actions, { depth: null });
+        actions = QueueItemTransformer.transformActionsToQueueItems(
+          similarActions[0].data
+        );
+        isSimilar = true;
       }
     }
 
-    if (!actions.length) {
-      console.log("No similar actions found for query: ", prompt);
-      console.log("Requesting orchestrator for actions");
+    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.length > 0
+    return actions && actions.length > 0
       ? this.handleActions(
           {
             initialPrompt: prompt,
             contextualizedPrompt: contextualizedPrompt,
-            actions: actions,
+            actions: actions as ActionSchema[],
           },
           events
         )
@@ -116,62 +125,80 @@ export class Agent {
       }
     );
 
+    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(
       this.orchestrator.tools,
       this.persistentMemory
     );
+    console.log("Accumulated results:");
+    console.dir(this.accumulatedResults, { depth: null });
 
+    const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
     const evaluation = await evaluator.process(
       initialPrompt,
       contextualizedPrompt,
-      JSON.stringify(actionsResult.data)
+      sanitizedResults
     );
 
     events.onMessage?.(evaluation);
 
-    await this.cacheMemory?.createMemory({
-      content: initialPrompt,
-      data: actions,
-      scope: MemoryScope.GLOBAL,
-      type: MemoryType.ACTION,
-    });
-
-    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,
+    });
   }
 
   private async handleActionResults(actionsResult: {
-    data: any;
+    data: QueueResult[];
     initialPrompt: string;
   }) {
     const synthesizer = new Synthesizer();
+    const sanitizedResults = 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: MemoryScope.GLOBAL,
+      type: MemoryType.ACTION,
+    });
+
     return this.stream
       ? (await synthesizer.streamProcess(summaryData)).toDataStreamResponse()
       : await synthesizer.process(summaryData);

package/dist/agent/index.d.ts

@@ -13,6 +13,7 @@ export declare class Agent {
     private readonly stream;
     private readonly maxEvaluatorIteration;
     private evaluatorIteration;
+    private accumulatedResults;
     constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration, }: {
         user: User;
         orchestrator: Orchestrator;

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,9 +20,11 @@ class Agent {
         this.stream = stream;
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
+        this.accumulatedResults = [];
     }
     async process(prompt, contextualizedPrompt, events) {
-        let actions = [];
+        let actions = undefined;
+        let isSimilar = false;
         if (this.cacheMemory) {
             const similarActions = await this.cacheMemory.findSimilarQueries(prompt, {
                 similarityThreshold: this.SIMILARITY_THRESHOLD,
@@ -29,19 +33,18 @@ class Agent {
                 scope: types_1.MemoryScope.GLOBAL,
             });
             if (similarActions.length > 0) {
-                actions = similarActions[0].data;
-                console.log("Similar actions found for query: ", prompt);
-                console.dir(actions, { depth: null });
+                actions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(similarActions[0].data);
+                isSimilar = true;
             }
         }
-        if (!actions.length) {
-            console.log("No similar actions found for query: ", prompt);
-            console.log("Requesting orchestrator for actions");
+        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.length > 0
+        return actions && actions.length > 0
             ? this.handleActions({
                 initialPrompt: prompt,
                 contextualizedPrompt: contextualizedPrompt,
@@ -58,40 +61,56 @@ 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);
-        await this.cacheMemory?.createMemory({
-            content: initialPrompt,
-            data: actions,
-            scope: types_1.MemoryScope.GLOBAL,
-            type: types_1.MemoryType.ACTION,
-        });
-        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);

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/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) {
@@ -18,23 +19,25 @@ class Orchestrator {
                     query: zod_1.z.string(),
                 }),
                 execute: async ({ query }) => {
-                    const memories = await this.memory.searchSimilarQueries(query);
+                    const memories = await this.memory.searchSimilarQueries(query, {
+                        similarityThreshold: 95,
+                    });
                     return memories;
                 },
             },
             {
                 name: "save_memory",
-                description: "Save a query in the internal knowledge base",
+                description: "Save relevant information in the internal knowledge base",
                 parameters: zod_1.z.object({
                     query: zod_1.z.string(),
-                    purpose: zod_1.z.string(),
+                    memoryType: zod_1.z.string(),
                     data: zod_1.z.any(),
-                    scope: zod_1.z.enum(["GLOBAL", "USER"]),
-                    userId: zod_1.z.string().optional(),
+                    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.storeMemory({
+                    const memories = await this.memory.createMemory({
                         query,
                         purpose,
                         data,
@@ -53,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.array(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

@@ -17,6 +17,6 @@ export declare class CacheMemory {
     }[]>;
     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 = {}) {
@@ -60,13 +59,10 @@ class CacheMemory {
             .map((memory) => {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
             const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
-            console.log(`\n📊 Query "${memory.query}":
-        - Similarity: ${similarityPercentage.toFixed(2)}%`);
             return {
                 data: memory.data,
                 query: memory.query,
                 similarityPercentage,
-                // Optionnel : ajouter des métadonnées utiles
                 memoryId: memory.id,
             };
         })
@@ -84,7 +80,6 @@ class CacheMemory {
         else {
             console.log("No matches found");
         }
-        console.dir({ results });
         return results;
     }
     async getAllMemories(scope, userId) {
@@ -129,22 +124,7 @@ class CacheMemory {
             return;
         }
         console.log("No similar memory found");
-        // Générer les variations via GPT-4
-        console.log("Generating variations...");
-        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 way to ask the same question.
-        Action results: ${JSON.stringify(input.data)}
-        - Keep variations natural and human-like
-        - Add 3-5 variations`,
-        });
-        console.log("Variations generated:", variations.object.queries);
-        await this.createSingleMemory({
+        const memory = await this.createSingleMemory({
             id: crypto.randomUUID(),
             content: input.content,
             type: input.type,
@@ -152,20 +132,7 @@ class CacheMemory {
             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,
-                    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);

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

@@ -101,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);
@@ -114,7 +114,7 @@ class PersistentMemory {
             method: "POST",
             body: JSON.stringify([document]),
         });
-        console.log("Stored memory response:", response);
+        console.log("Stored persistent memory response:", response);
         return response;
     }
     /**
@@ -182,7 +182,7 @@ class PersistentMemory {
             .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
         // Log results
         if (results.length > 0) {
-            console.log("\n✨ Similar queries 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}"`);

package/dist/test.d.ts

@@ -1,4 +1,32 @@
 import { z } from "zod";
+export declare const fetchMarkPrice: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        symbol: z.ZodString;
+        params: z.ZodObject<{
+            subType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            subType: string;
+        }, {
+            subType: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        params: {
+            subType: string;
+        };
+    }, {
+        symbol: string;
+        params: {
+            subType: string;
+        };
+    }>;
+    execute: ({ symbol, params }: {
+        symbol: string;
+        params: any;
+    }) => Promise<import("ccxt").Ticker>;
+};
 export declare const getChainsTVL: {
     name: string;
     description: string;