@ai.ntellect/core 0.0.33 → 0.0.35

package/dist/agent/index.d.ts

@@ -1,22 +1,26 @@
-import EventEmitter from "events";
 import { Orchestrator } from "../llm/orchestrator";
 import { MemoryCache } from "../memory";
 import { AgentEvent, User } from "../types";
 export declare class Agent {
-    private readonly user;
-    private readonly dependencies;
-    private readonly stream;
     private readonly SIMILARITY_THRESHOLD;
     private readonly MAX_RESULTS;
     private readonly actionHandler;
-    constructor(user: User, dependencies: {
+    private readonly user;
+    private readonly orchestrator;
+    private readonly memoryCache;
+    private readonly stream;
+    private readonly maxEvaluatorIteration;
+    private readonly evaluatorIteration;
+    constructor({ user, orchestrator, memoryCache, stream, maxEvaluatorIteration, }: {
+        user: User;
         orchestrator: Orchestrator;
-        memoryCache: MemoryCache;
-        eventEmitter: EventEmitter;
-    }, stream?: boolean);
-    start(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
+        memoryCache?: MemoryCache;
+        stream: boolean;
+        maxEvaluatorIteration: number;
+    });
+    process(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
     private handleActions;
+    private handleActionResults;
     private findSimilarActions;
     private transformActions;
-    private handleActionResults;
 }

package/dist/agent/index.js

@@ -1,40 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
+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 ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
-    constructor(user, dependencies, stream = true) {
-        this.user = user;
-        this.dependencies = dependencies;
-        this.stream = stream;
+    constructor({ user, orchestrator, memoryCache, stream, maxEvaluatorIteration = 1, }) {
         this.SIMILARITY_THRESHOLD = 95;
         this.MAX_RESULTS = 1;
+        this.evaluatorIteration = 0;
+        this.user = user;
+        this.orchestrator = orchestrator;
+        this.memoryCache = memoryCache;
+        this.stream = stream;
+        this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
     }
-    async start(prompt, contextualizedPrompt, events) {
-        const request = await this.dependencies.orchestrator.process(contextualizedPrompt);
+    async process(prompt, contextualizedPrompt, events) {
+        const request = await this.orchestrator.process(contextualizedPrompt);
         events.onMessage?.(request);
         if (request.actions.length > 0) {
             return this.handleActions({
                 initialPrompt: prompt,
+                contextualizedPrompt: contextualizedPrompt,
                 actions: request.actions,
             }, events);
         }
     }
-    async handleActions({ initialPrompt, actions, }, events) {
+    async handleActions({ initialPrompt, contextualizedPrompt, actions, }, events) {
         const similarActions = await this.findSimilarActions(initialPrompt);
-        const predefinedActions = this.transformActions(actions, similarActions);
-        const callbacks = {
+        const queueItems = this.transformActions(actions, similarActions);
+        const actionsResult = await this.actionHandler.executeActions(queueItems, this.orchestrator.tools, {
             onQueueStart: events.onQueueStart,
             onActionStart: events.onActionStart,
             onActionComplete: events.onActionComplete,
             onQueueComplete: events.onQueueComplete,
             onConfirmationRequired: events.onConfirmationRequired,
-        };
-        const actionsResult = await this.actionHandler.executeActions(predefinedActions, this.dependencies.orchestrator.tools, callbacks);
+        });
+        if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
+            return this.handleActionResults({ ...actionsResult, initialPrompt });
+        }
+        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools);
+        const evaluation = await evaluator.process(initialPrompt, contextualizedPrompt, JSON.stringify(actionsResult.data));
+        events.onMessage?.(evaluation);
+        if (evaluation.nextActions.length > 0) {
+            return this.handleActions({
+                initialPrompt: contextualizedPrompt,
+                contextualizedPrompt: initialPrompt,
+                actions: evaluation.nextActions,
+            }, events);
+        }
         if (!this.actionHandler.hasNonPrepareActions(actionsResult.data)) {
             return {
                 data: actionsResult.data,
@@ -43,8 +60,21 @@ class Agent {
         }
         return this.handleActionResults({ ...actionsResult, initialPrompt });
     }
+    async handleActionResults(actionsResult) {
+        const summarizer = new synthesizer_1.Summarizer();
+        const summaryData = JSON.stringify({
+            result: actionsResult.data,
+            initialPrompt: actionsResult.initialPrompt,
+        });
+        return this.stream
+            ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
+            : await summarizer.process(summaryData);
+    }
     async findSimilarActions(prompt) {
-        return this.dependencies.memoryCache.findBestMatches(prompt, {
+        if (!this.memoryCache) {
+            return [];
+        }
+        return this.memoryCache.findBestMatches(prompt, {
             similarityThreshold: this.SIMILARITY_THRESHOLD,
             maxResults: this.MAX_RESULTS,
             userId: this.user.id,
@@ -59,15 +89,5 @@ class Agent {
         }
         return predefinedActions;
     }
-    async handleActionResults(actionsResult) {
-        const summarizer = new synthesizer_1.Summarizer();
-        const summaryData = JSON.stringify({
-            result: actionsResult.data,
-            initialPrompt: actionsResult.initialPrompt,
-        });
-        return this.stream
-            ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
-            : await summarizer.process(summaryData);
-    }
 }
 exports.Agent = Agent;

package/dist/llm/evaluator/context.d.ts

@@ -0,0 +1,9 @@
+import { ActionSchema } from "../../types";
+export declare const evaluatorContext: {
+    role: string;
+    guidelines: {
+        important: string[];
+        never: string[];
+    };
+    compose: (goal: string, results: string, tools: ActionSchema[]) => string;
+};

package/dist/llm/evaluator/context.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluatorContext = void 0;
+exports.evaluatorContext = {
+    role: "You are the evaluator agent. Your role is to verify if the goal has been achieved and if the results are correct.",
+    guidelines: {
+        important: [
+            "IMPORTANT: Verify if all required actions were executed successfully",
+            "IMPORTANT: Check if the results match the initial goal",
+            "IMPORTANT: Identify any missing or incomplete information",
+        ],
+        never: [
+            "NEVER modify the results directly",
+            "NEVER make assumptions about missing data",
+            "NEVER repeat the same action if you already did it",
+        ],
+    },
+    compose: (goal, results, tools) => {
+        return `
+      ${exports.evaluatorContext.role}
+
+      ${exports.evaluatorContext.guidelines.important.join("\n")}
+      ${exports.evaluatorContext.guidelines.never.join("\n")}
+      
+      ACTIONS COMPLETED: ${results}
+
+      Initial Goal: ${goal} (You must use the same language)
+
+      The actions available are: ${tools.map((action) => {
+            const parameters = action.parameters;
+            const schemaShape = Object.keys(parameters._def.shape()).join(", ");
+            const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments: { ${schemaShape} }`;
+            return actionString;
+        })}
+
+      Evaluate if the goal has been achieved and provide:
+      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
+    `;
+    },
+};

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

@@ -0,0 +1,7 @@
+import { ActionSchema } from "../../types";
+export declare class Evaluator {
+    private readonly model;
+    tools: ActionSchema[];
+    constructor(tools: ActionSchema[]);
+    process(prompt: string, goal: string, results: string): Promise<any>;
+}

package/dist/llm/evaluator/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const zod_1 = require("zod");
+const context_1 = require("./context");
+class Evaluator {
+    constructor(tools) {
+        this.model = (0, openai_1.openai)("gpt-4o");
+        this.tools = tools;
+    }
+    async process(prompt, goal, results) {
+        try {
+            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(),
+                }),
+                prompt: prompt,
+                system: context_1.evaluatorContext.compose(goal, results, this.tools),
+            });
+            const validatedResponse = {
+                ...response.object,
+                nextActions: response.object.nextActions.map((action) => ({
+                    ...action,
+                    parameters: action.parameters || {},
+                })),
+            };
+            return validatedResponse;
+        }
+        catch (error) {
+            if (error) {
+                return {
+                    ...error.value,
+                };
+            }
+            // throw error;
+        }
+    }
+}
+exports.Evaluator = Evaluator;

package/dist/llm/orchestrator/context.d.ts

@@ -3,6 +3,7 @@ export declare const orchestratorContext: {
     role: string;
     guidelines: {
         important: string[];
+        never: string[];
     };
     compose: (tools: ActionSchema[]) => string;
 };

package/dist/llm/orchestrator/context.js

@@ -2,23 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratorContext = void 0;
 exports.orchestratorContext = {
-    role: "You are the gateway agent, you are the first agent to be called. You are the one who will decide if the user request is clear and if it's possible to achieve the goal.",
+    role: "You are the first agent to be called. You are the one who will decide if the user request is clear and if it's possible to achieve the goal.",
     guidelines: {
         important: [
             "IMPORTANT: If there is no action to do, you must answer in the 'answer' field.",
-            "IMPORTANT: If there are actions to do, you must explain why you are doing them in the 'answer' field.",
-            "IMPORTANT: If user ask for a analysis of the market or a cryptocurrency, use the maximum of useful tools to have a global view of the market (fundamental analysis vs technical analysis).",
-            "IMPORTANT: If user ask for an action on chain, use the useful tools to do the action.",
+            "IMPORTANT: If user ask for a analysis of the market or a cryptocurrency, use the maximum of useful tools to have for understanding the market.",
+            "IMPORTANT: If user ask for an action on chain, use only the necessary tools to do the action.",
             "IMPORTANT: You allow to provide an analysis without providing any financial advice.",
             "IMPORTANT: ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
         ],
+        never: [
+            "NEVER repeat the same action twice if the user doesn't ask for it.",
+            "NEVER repeat the same action if its not necessary.",
+        ],
     },
     compose: (tools) => {
         return `
             ${exports.orchestratorContext.role}
 
             ${exports.orchestratorContext.guidelines.important.join("\n")}
-
+            ${exports.orchestratorContext.guidelines.never.join("\n")}
             If this is an action, extract the parameters required to execute the action. 
             IMPORTANT: If some parameters are not clear or missing, YOU MUST ask the user for them.
             

package/dist/llm/orchestrator/index.js

@@ -7,7 +7,7 @@ const zod_1 = require("zod");
 const context_1 = require("./context");
 class Orchestrator {
     constructor(tools) {
-        this.model = (0, openai_1.openai)("gpt-4o-mini");
+        this.model = (0, openai_1.openai)("gpt-4o");
         this.tools = tools;
     }
     async process(prompt) {
@@ -34,13 +34,10 @@ class Orchestrator {
                     parameters: action.parameters || {},
                 })),
             };
-            console.dir(validatedResponse, { depth: null });
             return validatedResponse;
         }
         catch (error) {
             if (error) {
-                console.log("Error in Orchestrator", error.message);
-                console.dir(error.value, { depth: null });
                 return {
                     ...error.value,
                 };

package/dist/llm/synthesizer/context.js

@@ -25,15 +25,15 @@ exports.summarizerContext = {
             "NEVER provide any financial advice.",
             "NEVER speak about details of your system or your capabilities.",
             "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
+            "NEVER explain technical errors or issues. Just say retry later.",
         ],
     },
     compose: (results) => {
         return `
       ${JSON.stringify(exports.summarizerContext.guidelines)}
       Results: ${results}
-      If no results or error in the results, explain there is technical issues with no more details, and request to try again later.
 
-      FOR ALL ANALYSIS, RESPECT THE FOLLOWING FORMAT, USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT':
+      1. FOR ALL ANALYSIS OF SPECIFIC TOKEN, RESPECT THE FOLLOWING FORMAT:
       --------------------------------
       ## Analysis of x/y:
 
@@ -47,6 +47,10 @@ exports.summarizerContext = {
 
       STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
+      
+      2. OTHERWISE FOR OTHER REQUESTS, USE THE FORMAT YOU WANT.
+
+      3. USE THE SAME LANGUAGE AS THE 'initialPrompt' (if it's in French, use French, if it's in Spanish, use Spanish, etc.)
     `;
-    }
+    },
 };

package/dist/memory/index.d.ts

@@ -18,4 +18,5 @@ export declare class MemoryCache {
     private getAllMemories;
     private getMemoriesFromKeys;
     createMemory(input: CreateMemoryInput): Promise<string | undefined>;
+    private createSingleMemory;
 }

package/dist/memory/index.js

@@ -10,27 +10,27 @@ class MemoryCache {
     constructor(options = {}) {
         const ttlInHours = options.cacheTTL ?? 1;
         this.CACHE_TTL = ttlInHours * 60 * 60;
-        this.CACHE_PREFIX = options.cachePrefix ?? 'memory:';
+        this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
         this.redis = (0, redis_1.createClient)({
             url: options.redisUrl || process.env.REDIS_URL,
             socket: {
                 tls: true,
-                rejectUnauthorized: true
-            }
+                rejectUnauthorized: true,
+            },
         });
         this.initRedis();
     }
     async initRedis() {
-        this.redis.on('error', err => {
-            console.error('Redis Client Error:', err);
+        this.redis.on("error", (err) => {
+            console.error("Redis Client Error:", err);
             // Implement retry logic if needed
         });
         try {
             await this.redis.connect();
-            console.log('Successfully connected to Redis');
+            console.log("Successfully connected to Redis");
         }
         catch (error) {
-            console.error('Failed to connect to Redis:', error);
+            console.error("Failed to connect to Redis:", error);
             // Handle connection failure
         }
     }
@@ -44,39 +44,40 @@ class MemoryCache {
         const prefix = this.getMemoryKey(memory.scope, memory.userId);
         const key = `${prefix}${memory.id}`;
         await this.redis.set(key, JSON.stringify(memory), {
-            EX: this.CACHE_TTL
+            EX: this.CACHE_TTL,
         });
     }
     async findBestMatches(query, options = {}) {
         console.log("\n🔍 Searching for query:", query);
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
-            value: query
+            value: query,
         });
         const memories = await this.getAllMemories(options.scope, options.userId);
         console.log("\n📚 Found", memories.length, "memories to compare with");
         const matches = memories
-            .map(memory => {
-            const similarities = memory.embeddings.map(emb => {
-                const similarity = (0, ai_1.cosineSimilarity)(embedding, emb);
-                return (similarity + 1) * 50; // Convert to percentage
-            });
-            const maxSimilarity = Math.max(...similarities);
+            .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: ${maxSimilarity.toFixed(2)}%
-          - Original queries: ${memory.queries.join(", ")}`);
+        - Similarity: ${similarityPercentage.toFixed(2)}%
+        - Query: ${memory.query}`);
             return {
                 data: memory.data,
-                similarityPercentage: maxSimilarity,
+                similarityPercentage,
                 purpose: memory.purpose,
+                // Optionnel : ajouter des métadonnées utiles
+                memoryId: memory.id,
             };
         })
-            .filter(match => match.similarityPercentage >= (options.similarityThreshold ?? 70))
+            .filter((match) => match.similarityPercentage >= (options.similarityThreshold ?? 70))
             .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-        const results = options.maxResults ? matches.slice(0, options.maxResults) : matches;
+        const results = options.maxResults
+            ? matches.slice(0, options.maxResults)
+            : matches;
         if (results.length > 0) {
             console.log("\n✨ Best matches found:");
-            results.forEach(match => {
+            results.forEach((match) => {
                 console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
             });
         }
@@ -113,30 +114,24 @@ class MemoryCache {
         return memories;
     }
     async createMemory(input) {
-        const { embedding } = await (0, ai_1.embed)({
-            model: openai_1.openai.embedding("text-embedding-3-small"),
-            value: input.content
-        });
         const existingPattern = await this.findBestMatches(input.content, {
             similarityThreshold: 95,
             userId: input.userId,
-            scope: input.scope
+            scope: input.scope,
         });
         if (existingPattern.length > 0) {
             console.log("\n🔍 Similar memory found:");
-            // Display only the name and similarity percentage
-            existingPattern.forEach(match => {
+            existingPattern.forEach((match) => {
                 console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
             });
             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()
-                }))
+                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.
@@ -144,25 +139,51 @@ class MemoryCache {
         Data: ${JSON.stringify(input.data)}
         - Keep variations natural and human-like
         - Include the original input
-        - Add 3-5 variations`
+        - Add 3-5 variations`,
         });
-        const embeddingResults = await (0, ai_1.embedMany)({
-            model: openai_1.openai.embedding("text-embedding-3-small"),
-            values: variations.object.queries.map(q => q.text)
-        });
-        const memory = {
+        await this.createSingleMemory({
             id: crypto.randomUUID(),
+            content: input.content,
             type: input.type,
             data: input.data,
             purpose: variations.object.request,
-            queries: [input.content, ...variations.object.queries.map(q => q.text)],
-            embeddings: [embedding, ...embeddingResults.embeddings],
             userId: input.userId,
-            scope: input.scope || (input.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
-            createdAt: new Date()
+            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;
+    }
+    async createSingleMemory(params) {
+        const { embedding } = await (0, ai_1.embed)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            value: params.content,
+        });
+        const memory = {
+            id: params.id,
+            type: params.type,
+            data: params.data,
+            purpose: params.purpose,
+            query: params.content,
+            embedding,
+            userId: params.userId,
+            scope: params.scope || (params.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
+            createdAt: new Date(),
         };
         await this.storeMemory(memory);
-        return variations.object.request;
+        return memory;
     }
 }
 exports.MemoryCache = MemoryCache;

package/dist/test.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const getChainsTVL: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+    }, {
+        limit?: number | undefined;
+    }>;
+    execute: ({ limit }: {
+        limit: number;
+    }) => Promise<{
+        summary: {
+            totalTVL: number;
+            numberOfChains: number;
+        };
+        topChains: {
+            name: string;
+            tvl: number;
+            tokenSymbol: string | null;
+        }[];
+    }>;
+};
+export declare const getRssNews: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute: () => Promise<{
+        status: string;
+        items: {
+            title: any;
+            content: string;
+            link: any;
+            date: any;
+            source: any;
+        }[];
+    }>;
+};

package/dist/test.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRssNews = exports.getChainsTVL = void 0;
+const rss_parser_1 = __importDefault(require("rss-parser"));
+const zod_1 = require("zod");
+const agent_1 = require("./agent");
+const orchestrator_1 = require("./llm/orchestrator");
+const memory_1 = require("./memory");
+exports.getChainsTVL = {
+    name: "get_chains_tvl",
+    description: "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
+    parameters: zod_1.z.object({
+        limit: zod_1.z
+            .number()
+            .optional()
+            .default(10)
+            .describe("Number of top chains to return (default: 10)"),
+    }),
+    execute: async ({ limit }) => {
+        try {
+            const response = await fetch("https://api.llama.fi/v2/chains", {
+                headers: { accept: "*/*" },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const chains = (await response.json());
+            // Sort chains by TVL in descending order and take top N
+            const topChains = chains
+                .sort((a, b) => b.tvl - a.tvl)
+                .slice(0, limit)
+                .map((chain) => ({
+                name: chain.name,
+                tvl: chain.tvl,
+                tokenSymbol: chain.tokenSymbol,
+            }));
+            const totalTVL = chains.reduce((sum, chain) => sum + chain.tvl, 0);
+            return {
+                summary: {
+                    totalTVL,
+                    numberOfChains: chains.length,
+                },
+                topChains,
+            };
+        }
+        catch (error) {
+            console.error("Error retrieving chains TVL data:", error);
+            throw new Error(`Failed to fetch chains TVL data: ${error.message}`);
+        }
+    },
+};
+const RSS_FEEDS = ["https://www.investing.com/rss/news_301.rss"];
+const parser = new rss_parser_1.default();
+function stripHtmlTags(content) {
+    if (!content)
+        return "";
+    return content
+        .replace(/<[^>]*>/g, "")
+        .replace(/\n/g, "")
+        .replace(" ", "");
+}
+exports.getRssNews = {
+    name: "get-news-rss",
+    description: "Get latest news about on website",
+    parameters: zod_1.z.object({}),
+    execute: async () => {
+        const itemsPerSource = 5;
+        try {
+            const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
+            const results = await Promise.allSettled(feedPromises);
+            const successfulFeeds = results
+                .filter((result) => {
+                return (result.status === "fulfilled" && result.value?.items?.length > 0);
+            })
+                .map((result) => result.value);
+            const allItems = successfulFeeds
+                .flatMap((feed) => feed.items.slice(0, itemsPerSource))
+                .sort((a, b) => {
+                const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
+                const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
+                return dateB - dateA;
+            })
+                .slice(0, 5)
+                .map((item) => ({
+                title: item.title,
+                content: stripHtmlTags(item.content),
+                link: item.link,
+                date: item.pubDate,
+                source: item.creator || new URL(item.link).hostname,
+            }));
+            const result = {
+                status: "success",
+                items: allItems,
+            };
+            return result;
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+};
+(async () => {
+    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL]);
+    const agent = new agent_1.Agent({
+        user: {
+            id: "1",
+        },
+        orchestrator,
+        memoryCache: new memory_1.MemoryCache(),
+        stream: false,
+        maxEvaluatorIteration: 1,
+    });
+    const prompt = "Analyze le marché des crypto";
+    const context = prompt;
+    const result = await agent.process(prompt, context, {
+        onMessage: (message) => {
+            console.log({ message });
+        },
+    });
+    console.log(result.text);
+})();

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { StreamTextResult } from "ai";
+import { Embedding, StreamTextResult } from "ai";
 import { z } from "zod";
 export interface BaseLLM {
     process: (prompt: string) => Promise<string | object>;
@@ -110,8 +110,8 @@ export interface Memory {
     type: MemoryType;
     data: any;
     purpose: string;
-    queries: string[];
-    embeddings: number[][];
+    query: string;
+    embedding: Embedding;
     userId?: string;
     scope: MemoryScope;
     createdAt: Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "",
   "main": "dist/index.js",
   "scripts": {