@ai.ntellect/core 0.3.1 → 0.4.0

package/dist/agent/index.js

@@ -1,116 +1,143 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
-const evaluator_1 = require("../llm/evaluator");
-const types_1 = require("../types");
+const ws_1 = __importDefault(require("ws"));
+const memory_manager_1 = require("../llm/memory-manager");
+const orchestrator_1 = require("../llm/orchestrator");
+const queue_1 = require("../services/queue");
+const redis_cache_1 = require("../services/redis-cache");
 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({ orchestrator, interpreters, memory, stream, maxEvaluatorIteration = 1, }) {
-        this.evaluatorIteration = 0;
-        this.accumulatedResults = "";
-        this.orchestrator = orchestrator;
-        this.interpreters = interpreters;
-        this.memory = memory;
-        this.stream = stream;
-        this.maxEvaluatorIteration = maxEvaluatorIteration;
-        this.actionHandler = new ActionHandler_1.ActionHandler();
-        this.accumulatedResults = "";
-    }
-    async process(prompt, events) {
-        this.accumulatedResults = "";
-        this.evaluatorIteration = 0;
-        console.log("Requesting orchestrator for actions..");
-        const cacheMemories = await this.memory.cache?.findSimilarActions(prompt, {
-            similarityThreshold: 70,
-            maxResults: 5,
-            userId: "1",
-            scope: types_1.MemoryScope.GLOBAL,
+    constructor(config) {
+        this.webSocketClients = new Map();
+        this.cache = new redis_cache_1.RedisCache(config.cache);
+        this.config = config;
+        this.agent = new orchestrator_1.AgentRuntime(config.orchestrator.model, config.orchestrator.tools, config.interpreters, config.cache, config.orchestrator.memory);
+        this.memoryManager = new memory_manager_1.MemoryManager({
+            model: config.memoryManager.model,
+            memory: {
+                cache: config.memoryManager.memory?.cache ?? undefined,
+                persistent: config.memoryManager.memory?.persistent ?? undefined,
+            },
         });
-        console.log("✅ RECENT_ACTIONS: ", cacheMemories);
-        const request = await this.orchestrator.process(prompt, `## RECENT_ACTIONS: ${JSON.stringify(cacheMemories)} ## CURRENT_RESULTS: ${this.accumulatedResults}`);
-        events.onMessage?.(request);
-        return request.actions.length > 0
-            ? this.handleActions({
-                initialPrompt: prompt,
-                actions: request.actions,
-            }, events)
-            : undefined;
+        this.config.maxIterations = 3;
     }
-    async handleActions({ initialPrompt, actions, }, events) {
-        const queueItems = this.transformActions(actions);
-        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,
-        });
-        this.accumulatedResults += this.formatResults(actionsResult.data);
-        const isOnChainAction = actions.some((action) => action.type === "on-chain");
-        if (isOnChainAction) {
-            return {
-                data: this.accumulatedResults,
-                initialPrompt,
+    async process(state, callbacks) {
+        console.log("🔄 Processing state:");
+        console.dir(state, { depth: null });
+        let countIterations = 0;
+        const response = await this.agent.process(state);
+        const unscheduledActions = response.actions.filter((action) => !action.scheduler?.isScheduled);
+        // Execute actions if needed
+        if (unscheduledActions?.length > 0 && response.shouldContinue) {
+            console.log("\n📋 Processing action queue");
+            const queueManager = new queue_1.ActionQueueManager(this.config.orchestrator.tools, callbacks);
+            const queueItems = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(response.actions);
+            if (!queueItems) {
+                throw new Error("No queue items found");
+            }
+            console.log("📋 Actions to execute:", queueItems
+                .map((item) => (typeof item === "string" ? item : item.name))
+                .join(", "));
+            queueManager.addToQueue(queueItems);
+            console.log("\n⚡ Executing actions...");
+            const results = await queueManager.processQueue();
+            console.log("✅ Execution results:", results);
+            const updatedNextState = {
+                ...state,
+                currentContext: state.currentContext,
+                previousActions: [...(state.previousActions || []), ...(results || [])],
             };
+            console.log("\n🔁 Recursively processing with updated state");
+            countIterations++;
+            if (countIterations < this.config.maxIterations) {
+                return this.process(updatedNextState);
+            }
         }
-        if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-            return this.interpreterResult({
-                data: this.accumulatedResults,
-                initialPrompt,
-                interpreter: this.interpreters[0],
-            });
+        if (countIterations >= this.config.maxIterations) {
+            console.log("Max iterations reached");
+            response.shouldContinue = false;
+            console.log("Forcing stop");
         }
-        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.memory, this.interpreters);
-        // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
-        const evaluation = await evaluator.process(initialPrompt, this.accumulatedResults);
-        events.onMessage?.(evaluation);
-        if (evaluation.isNextActionNeeded) {
-            this.evaluatorIteration++;
-            return this.handleActions({
-                initialPrompt: initialPrompt,
-                actions: evaluation.nextActionsNeeded,
-            }, events);
+        // Handle final interpretation
+        if (!response.shouldContinue &&
+            state.previousActions?.length &&
+            response.interpreter) {
+            console.log("\n🏁 Analysis complete - generating final interpretation");
+            const interpreter = this.getInterpreter(this.config.interpreters, response.interpreter);
+            console.log("🎭 Selected Interpreter:", interpreter?.name);
+            console.dir(state, { depth: null });
+            const interpretationResult = (await interpreter?.process("Interpret the analysis results", {
+                ...state,
+                results: JSON.stringify(state.previousActions),
+                userRequest: state.currentContext,
+            }));
+            console.log("\n📊 Final Analysis:", interpretationResult.response);
+            const finalState = {
+                ...state,
+                results: interpretationResult.response,
+            };
+            console.log("🔄 Final state:", finalState);
         }
-        const interpreter = this.getInterpreter(this.interpreters, evaluation.interpreter);
-        if (!interpreter) {
-            throw new Error("Interpreter not found");
+        // Return the final response at the end of the function
+        const validatedActions = response.actions.map((action) => ({
+            ...action,
+            parameters: action.parameters.map((param) => ({
+                ...param,
+                value: param.value ?? null, // Set a default value if undefined
+            })),
+        }));
+        const result = {
+            ...response,
+            actions: validatedActions,
+            results: JSON.stringify(state.previousActions),
+        };
+        if (!result.shouldContinue) {
+            await this.memoryManager.process(state, JSON.stringify(result));
         }
-        return this.interpreterResult({
-            data: this.accumulatedResults,
-            initialPrompt,
-            interpreter,
-        });
+        return result;
     }
     getInterpreter(interpreters, name) {
         return interpreters.find((interpreter) => interpreter.name === name);
     }
-    async interpreterResult(actionsResult) {
-        const { interpreter, initialPrompt, data } = actionsResult;
-        return this.stream
-            ? (await interpreter.streamProcess(initialPrompt, {
-                userRequest: initialPrompt,
-                results: data,
-            })).toDataStreamResponse()
-            : await interpreter.process(initialPrompt, {
-                userRequest: initialPrompt,
-                results: data,
-            });
-    }
-    transformActions(actions) {
-        let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
-        return predefinedActions;
-    }
-    formatResults(results) {
-        const formattedResults = results.map((result) => ({
-            ...result,
-            result: typeof result.result === "object"
-                ? JSON.stringify(result.result)
-                : result.result,
-        }));
-        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(formattedResults);
-        return sanitizedResults;
+    addListener(id, url, subscriptionMessageFactory, callback) {
+        if (this.webSocketClients.has(id)) {
+            console.warn(`WebSocket with ID ${id} already exists.`);
+            return;
+        }
+        const socket = new ws_1.default(url);
+        const wrappedCallback = async (data) => {
+            await callback(data, this);
+        };
+        socket.on("open", () => {
+            console.log(`🔗 WebSocket connected for ID: ${id}`);
+            // Envoie le message d'abonnement si une factory est fournie
+            if (subscriptionMessageFactory) {
+                const subscriptionMessage = subscriptionMessageFactory();
+                socket.send(subscriptionMessage);
+                console.log(`📡 Sent subscription message for ID ${id}:`, subscriptionMessage);
+            }
+        });
+        socket.on("message", async (message) => {
+            console.log(`📨 Message received for WebSocket ID ${id}:`, message);
+            try {
+                const data = JSON.parse(message);
+                await wrappedCallback(data);
+            }
+            catch (error) {
+                console.error(`❌ Error in callback for WebSocket ID ${id}:`, error);
+            }
+        });
+        socket.on("error", (error) => {
+            console.error(`❌ WebSocket error for ID ${id}:`, error);
+        });
+        socket.on("close", () => {
+            console.log(`🔌 WebSocket closed for ID: ${id}`);
+        });
+        this.webSocketClients.set(id, { socket, callback: wrappedCallback });
     }
 }
 exports.Agent = Agent;

package/dist/agent/tools/get-rss.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+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/agent/tools/get-rss.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRssNews = void 0;
+const rss_parser_1 = __importDefault(require("rss-parser"));
+const zod_1 = require("zod");
+const RSS_FEEDS = [
+    "https://www.investing.com/rss/news_301.rss",
+    "https://cointelegraph.com/rss/category/analysis",
+    "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
+];
+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;
+        }
+    },
+};

package/dist/bull.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bull.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_cron_1 = __importDefault(require("node-cron"));
+node_cron_1.default.schedule("* * * * *", () => {
+    console.log("running a task every minute");
+});

package/dist/examples/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/examples/index.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepseek_1 = require("@ai-sdk/deepseek");
+const dotenv_1 = require("dotenv");
+const readline_1 = __importDefault(require("readline"));
+const agent_1 = require("../agent");
+const get_rss_1 = require("../agent/tools/get-rss");
+const interpreter_1 = require("../llm/interpreter");
+const context_1 = require("../llm/interpreter/context");
+(0, dotenv_1.configDotenv)();
+// Initialiser l'agent une fois pour toute la session
+const initializeAgent = () => {
+    const model = (0, deepseek_1.deepseek)("deepseek-reasoner");
+    const securityInterpreter = new interpreter_1.Interpreter({
+        name: "security",
+        model,
+        character: context_1.securityInterpreterCharacter,
+    });
+    const marketInterpreter = new interpreter_1.Interpreter({
+        name: "market",
+        model,
+        character: context_1.marketInterpreterCharacter,
+    });
+    const generalInterpreter = new interpreter_1.Interpreter({
+        name: "general",
+        model,
+        character: context_1.generalInterpreterCharacter,
+    });
+    const agent = new agent_1.Agent({
+        cache: {
+            host: process.env.REDIS_HOST || "localhost",
+            port: Number(process.env.REDIS_PORT) || 6379,
+        },
+        orchestrator: {
+            model,
+            tools: [get_rss_1.getRssNews],
+        },
+        interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+        memoryManager: {
+            model,
+        },
+        maxIterations: 3,
+    });
+    return agent;
+};
+// Fonction pour lancer une session interactive
+const startChatSession = async () => {
+    console.log("Bienvenue dans votre session de chat avec l'agent !");
+    console.log("Tapez 'exit' pour quitter.\n");
+    const agent = initializeAgent();
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: "Vous > ",
+    });
+    let state = {
+        currentContext: "",
+        previousActions: [],
+    };
+    rl.prompt();
+    rl.on("line", async (line) => {
+        const input = line.trim();
+        if (input.toLowerCase() === "exit") {
+            console.log("Fin de la session. À bientôt !");
+            rl.close();
+            return;
+        }
+        state.currentContext = input;
+        console.log("Agent en réflexion...");
+        try {
+            const result = await agent.process(state);
+            console.log(`Agent > ${result}\n`);
+        }
+        catch (error) {
+            console.error("Erreur avec l'agent :", error);
+        }
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log("Session terminée.");
+        process.exit(0);
+    });
+};
+// Lancer la session de chat
+startChatSession();

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

@@ -1,32 +1,15 @@
-export declare const generalInterpreterContext: {
-    role: string;
-    language: string;
-    guidelines: {
-        important: never[];
-        warnings: never[];
-    };
-};
-export declare const securityInterpreterContext: {
-    role: string;
-    language: string;
-    guidelines: {
-        important: string[];
-        warnings: string[];
-    };
-    examplesMessages: {
-        role: string;
-        content: string;
-    }[];
-};
-export declare const marketInterpreterContext: {
+export type Character = {
     role: string;
     language: string;
     guidelines: {
         important: string[];
         warnings: string[];
     };
-    examplesMessages: {
+    examplesMessages?: {
         role: string;
         content: string;
     }[];
 };
+export declare const generalInterpreterCharacter: Character;
+export declare const securityInterpreterCharacter: Character;
+export declare const marketInterpreterCharacter: Character;

package/dist/llm/interpreter/context.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.marketInterpreterContext = exports.securityInterpreterContext = exports.generalInterpreterContext = void 0;
-exports.generalInterpreterContext = {
+exports.marketInterpreterCharacter = exports.securityInterpreterCharacter = exports.generalInterpreterCharacter = void 0;
+exports.generalInterpreterCharacter = {
     role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-    language: "user_language",
+    language: "user_request",
     guidelines: {
         important: [],
         warnings: [],
     },
 };
-exports.securityInterpreterContext = {
+exports.securityInterpreterCharacter = {
     role: "You are the security expert. Your role is to provide a clear and factual analysis of the security of the token/coin.",
-    language: "user_language",
+    language: "user_request",
     guidelines: {
         important: [
             "Start with a clear security analysis of the token/coin.",
@@ -48,12 +48,12 @@ exports.securityInterpreterContext = {
         },
     ],
 };
-exports.marketInterpreterContext = {
+exports.marketInterpreterCharacter = {
     role: "You are the market expert. Your role is to provide a clear and factual analysis of the market sentiment of the token/coin.",
-    language: "user_language",
+    language: "user_request",
     guidelines: {
         important: [
-            "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
+            "Start with a clear market sentiment (Market sentiment: Bullish/Bearish/Neutral 📈📉📊) without any additional comments before.",
             "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
             "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
             "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
@@ -61,7 +61,6 @@ exports.marketInterpreterContext = {
         warnings: [
             "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",
         ],
     },
     examplesMessages: [

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

@@ -1,11 +1,15 @@
-import { StreamTextResult } from "ai";
+import { LanguageModel, StreamTextResult } from "ai";
 import { Behavior, State } from "../../types";
 export declare class Interpreter {
-    private readonly behavior;
-    private readonly model;
+    readonly model: LanguageModel;
     readonly name: string;
-    constructor(name: string, behavior: Behavior);
-    composeContext(state: State): string;
+    readonly character: Behavior;
+    constructor({ name, model, character, }: {
+        name: string;
+        model: LanguageModel;
+        character: Behavior;
+    });
+    private buildContext;
     process(prompt: string, state: State, onFinish?: (event: any) => void): Promise<{
         actionsCompleted: {
             name: string;