@ai.ntellect/core 0.3.3 → 0.4.0

package/agent/index.ts

@@ -1,260 +1,243 @@
-import { Evaluator } from "../llm/evaluator";
+import { LanguageModel } from "ai";
+import WebSocket from "ws";
 import { Interpreter } from "../llm/interpreter";
-import { Orchestrator } from "../llm/orchestrator";
+import { MemoryManager } from "../llm/memory-manager";
+import { AgentRuntime } from "../llm/orchestrator";
+import { State } from "../llm/orchestrator/types";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
 import { ActionQueueManager } from "../services/queue";
-import { ActionScheduler } from "../services/scheduler";
-import {
-  ActionSchema,
-  AgentEvent,
-  MemoryScope,
-  QueueResult,
-  ScheduledAction,
-} from "../types";
+import { CacheConfig, RedisCache } from "../services/redis-cache";
+import { ActionData, ActionSchema, QueueCallbacks } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
-import { ResultSanitizer } from "../utils/sanitize-results";
-import { ActionHandler } from "./handlers/ActionHandler";
-
 export class Agent {
-  private readonly actionHandler: ActionHandler;
-  private readonly orchestrator: Orchestrator;
-  private readonly interpreters: Interpreter[];
-  private readonly memory: {
-    persistent: PersistentMemory;
-    cache?: CacheMemory;
+  private readonly agent: AgentRuntime;
+  private readonly memoryManager: MemoryManager;
+  private readonly cache: RedisCache;
+
+  private webSocketClients: Map<
+    string,
+    { socket: WebSocket; callback: (data: any) => Promise<void> }
+  > = new Map();
+  private readonly config: {
+    orchestrator: {
+      model: LanguageModel;
+      tools: ActionSchema[];
+      memory?: {
+        cache?: CacheMemory;
+        persistent?: PersistentMemory;
+      };
+    };
+    interpreters: Interpreter[];
+    memoryManager: {
+      model: LanguageModel;
+      memory?: {
+        cache?: CacheMemory;
+        persistent?: PersistentMemory;
+      };
+    };
+    maxIterations: number;
   };
-  private readonly stream: boolean;
-  private readonly maxEvaluatorIteration: number;
-  private evaluatorIteration = 0;
-  private accumulatedResults: string = "";
-  private currentInterpreter: Interpreter | undefined;
-  private readonly scheduler: ActionScheduler;
 
-  constructor({
-    orchestrator,
-    interpreters,
-    memory,
-    stream,
-    maxEvaluatorIteration = 1,
-  }: {
-    orchestrator: Orchestrator;
+  constructor(config: {
+    cache: CacheConfig;
+    orchestrator: {
+      model: LanguageModel;
+      tools: ActionSchema[];
+      memory?: {
+        cache?: CacheMemory;
+        persistent?: PersistentMemory;
+      };
+    };
     interpreters: Interpreter[];
-    memory: {
-      persistent: PersistentMemory;
-      cache?: CacheMemory;
+    memoryManager: {
+      model: LanguageModel;
+      memory?: {
+        cache?: CacheMemory;
+        persistent?: PersistentMemory;
+      };
     };
-    stream: boolean;
-    maxEvaluatorIteration: number;
+    callbacks?: QueueCallbacks;
+    maxIterations: number;
   }) {
-    this.orchestrator = orchestrator;
-    this.interpreters = interpreters;
-    this.memory = memory;
-    this.stream = stream;
-    this.maxEvaluatorIteration = maxEvaluatorIteration;
-    this.actionHandler = new ActionHandler();
-    this.accumulatedResults = "";
-    this.scheduler = new ActionScheduler(
-      new ActionQueueManager(this.orchestrator.tools),
-      this.orchestrator
+    this.cache = new RedisCache(config.cache);
+    this.config = config;
+    this.agent = new AgentRuntime(
+      config.orchestrator.model,
+      config.orchestrator.tools,
+      config.interpreters,
+      config.cache,
+      config.orchestrator.memory
     );
+    this.memoryManager = new MemoryManager({
+      model: config.memoryManager.model,
+      memory: {
+        cache: config.memoryManager.memory?.cache ?? undefined,
+        persistent: config.memoryManager.memory?.persistent ?? undefined,
+      },
+    });
+    this.config.maxIterations = 3;
   }
 
-  async process(prompt: string, events: AgentEvent): Promise<any> {
-    this.accumulatedResults = "";
-    this.evaluatorIteration = 0;
-    console.log("Requesting orchestrator for actions..");
-    const parsedPrompt = JSON.parse(prompt);
-    const promptOnly = parsedPrompt.userRequest;
-    const cacheMemories = await this.memory.cache?.findSimilarActions(
-      promptOnly,
-      {
-        similarityThreshold: 70,
-        maxResults: 5,
-        userId: "1",
-        scope: MemoryScope.GLOBAL,
-      }
-    );
-    console.log("✅ RECENT_ACTIONS: ", cacheMemories);
+  public async process(state: State, callbacks?: QueueCallbacks): Promise<any> {
+    console.log("🔄 Processing state:");
+    console.dir(state, { depth: null });
+    let countIterations = 0;
+    const response = await this.agent.process(state);
 
-    const persistentMemory = await this.memory.persistent.findRelevantDocuments(
-      prompt,
-      {
-        similarityThreshold: 80,
-      }
-    );
-    console.log("✅ PERSISTENT_MEMORY: ", persistentMemory);
-    const request = await this.orchestrator.process(
-      prompt,
-      `## RECENT_ACTIONS: ${JSON.stringify(
-        cacheMemories
-      )} ## PERSISTENT_MEMORY: ${JSON.stringify(
-        persistentMemory
-      )} ## CURRENT_RESULTS: ${this.accumulatedResults}`
+    const unscheduledActions = response.actions.filter(
+      (action) => !action.scheduler?.isScheduled
     );
-    events.onMessage?.(request);
-
-    return request.actions.length > 0
-      ? this.handleActions(
-          {
-            initialPrompt: prompt,
-            actions: request.actions,
-          },
-          events
-        )
-      : undefined;
-  }
-
-  private async handleActions(
-    {
-      initialPrompt,
-      actions,
-    }: {
-      initialPrompt: string;
-      actions: {
-        name: string;
-        type: string;
-        parameters: {
-          name: string;
-          value: any;
-        }[];
-      }[];
-    },
-    events: AgentEvent
-  ): Promise<any> {
-    const queueItems = this.transformActions(actions as any);
-
-    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,
+    // Execute actions if needed
+    if (unscheduledActions?.length > 0 && response.shouldContinue) {
+      console.log("\n📋 Processing action queue");
+      const queueManager = new ActionQueueManager(
+        this.config.orchestrator.tools,
+        callbacks
+      );
+      const queueItems = QueueItemTransformer.transformActionsToQueueItems(
+        response.actions as ActionData[]
+      );
+      if (!queueItems) {
+        throw new Error("No queue items found");
       }
-    );
 
-    this.accumulatedResults += this.formatResults(actionsResult.data);
+      console.log(
+        "📋 Actions to execute:",
+        queueItems
+          .map((item) => (typeof item === "string" ? item : item.name))
+          .join(", ")
+      );
 
-    const isOnChainAction = actions.some(
-      (action) => action.type === "on-chain"
-    );
+      queueManager.addToQueue(queueItems);
+      console.log("\n⚡ Executing actions...");
+      const results = await queueManager.processQueue();
+      console.log("✅ Execution results:", results);
 
-    if (isOnChainAction) {
-      return {
-        data: this.accumulatedResults,
-        initialPrompt,
+      const updatedNextState: State = {
+        ...state,
+        currentContext: state.currentContext,
+        previousActions: [...(state.previousActions || []), ...(results || [])],
       };
-    }
 
-    if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-      return this.interpreterResult({
-        data: this.accumulatedResults,
-        initialPrompt,
-        interpreter: this.currentInterpreter,
-      });
+      console.log("\n🔁 Recursively processing with updated state");
+      countIterations++;
+      if (countIterations < this.config.maxIterations) {
+        return this.process(updatedNextState);
+      }
     }
 
-    const evaluator = new Evaluator(
-      this.orchestrator.tools,
-      this.memory,
-      this.interpreters
-    );
+    if (countIterations >= this.config.maxIterations) {
+      console.log("Max iterations reached");
+      response.shouldContinue = false;
+      console.log("Forcing stop");
+    }
 
-    const evaluation = await evaluator.process(
-      initialPrompt,
-      this.accumulatedResults
-    );
+    // 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,
+        }
+      )) as { response: string };
 
-    this.currentInterpreter = this.getInterpreter(
-      this.interpreters,
-      evaluation.interpreter
-    );
+      console.log("\n📊 Final Analysis:", interpretationResult.response);
 
-    events.onMessage?.(evaluation);
+      const finalState: State = {
+        ...state,
+        results: interpretationResult.response,
+      };
 
-    if (evaluation.isNextActionNeeded) {
-      this.evaluatorIteration++;
-      return this.handleActions(
-        {
-          initialPrompt: initialPrompt,
-          actions: evaluation.nextActionsNeeded,
-        },
-        events
-      );
+      console.log("🔄 Final state:", finalState);
     }
 
-    return this.interpreterResult({
-      data: this.accumulatedResults,
-      initialPrompt,
-      interpreter: this.currentInterpreter,
-    });
+    // 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 result;
   }
 
   private getInterpreter(interpreters: Interpreter[], name: string) {
-    console.log({ interpreters, name });
     return interpreters.find((interpreter) => interpreter.name === name);
   }
 
-  private async interpreterResult(actionsResult: {
-    data: string;
-    initialPrompt: string;
-    interpreter: Interpreter | undefined;
-  }) {
-    const { interpreter, initialPrompt, data } = actionsResult;
-    if (!interpreter) {
-      throw new Error("Interpreter not found");
+  public addListener(
+    id: string,
+    url: string,
+    subscriptionMessageFactory: () => string,
+    callback: (data: any, agentContext: Agent) => Promise<void>
+  ): void {
+    if (this.webSocketClients.has(id)) {
+      console.warn(`WebSocket with ID ${id} already exists.`);
+      return;
     }
-    console.log("✅ INTERPRETER: ", interpreter.name);
-    return this.stream
-      ? (
-          await interpreter.streamProcess(initialPrompt, {
-            userRequest: initialPrompt,
-            results: data,
-          })
-        ).toDataStreamResponse()
-      : await interpreter.process(initialPrompt, {
-          userRequest: initialPrompt,
-          results: data,
-        });
-  }
 
-  private transformActions(actions: ActionSchema[]) {
-    let predefinedActions =
-      QueueItemTransformer.transformActionsToQueueItems(actions) || [];
+    const socket = new WebSocket(url);
 
-    return predefinedActions;
-  }
+    const wrappedCallback = async (data: any) => {
+      await callback(data, this);
+    };
 
-  private formatResults(results: QueueResult[]): string {
-    const formattedResults = results.map((result) => ({
-      ...result,
-      result:
-        typeof result.result === "object"
-          ? JSON.stringify(result.result)
-          : result.result,
-    }));
-    const sanitizedResults = ResultSanitizer.sanitize(formattedResults);
-    return sanitizedResults;
-  }
+    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
+        );
+      }
+    });
 
-  async scheduleAction(
-    action: ActionSchema,
-    scheduledTime: Date,
-    userId: string,
-    recurrence?: ScheduledAction["recurrence"]
-  ): Promise<string> {
-    return this.scheduler.scheduleAction(
-      action,
-      scheduledTime,
-      userId,
-      recurrence
-    );
-  }
+    socket.on("message", async (message: string) => {
+      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}`);
+    });
 
-  async cancelScheduledAction(actionId: string): Promise<boolean> {
-    return this.scheduler.cancelScheduledAction(actionId);
+    this.webSocketClients.set(id, { socket, callback: wrappedCallback });
   }
 }

package/agent/tools/get-rss.ts

@@ -0,0 +1,64 @@
+import Parser from "rss-parser";
+import { z } from "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 Parser();
+
+function stripHtmlTags(content: string): string {
+  if (!content) return "";
+  return content
+    .replace(/<[^>]*>/g, "")
+    .replace(/\n/g, "")
+    .replace(" ", "");
+}
+
+export const getRssNews = {
+  name: "get-news-rss",
+  description: "Get latest news about on website",
+  parameters: 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): result is PromiseFulfilledResult<Parser.Output<any>> => {
+            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: any) {
+      throw error;
+    }
+  },
+};

package/bull.ts

@@ -0,0 +1,5 @@
+import cron from "node-cron";
+
+cron.schedule("* * * * *", () => {
+  console.log("running a task every minute");
+});

package/dist/agent/index.d.ts

@@ -1,35 +1,38 @@
+import { LanguageModel } from "ai";
 import { Interpreter } from "../llm/interpreter";
-import { Orchestrator } from "../llm/orchestrator";
+import { State } from "../llm/orchestrator/types";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { ActionSchema, AgentEvent, ScheduledAction } from "../types";
+import { CacheConfig } from "../services/redis-cache";
+import { ActionSchema, QueueCallbacks } from "../types";
 export declare class Agent {
-    private readonly actionHandler;
-    private readonly orchestrator;
-    private readonly interpreters;
-    private readonly memory;
-    private readonly stream;
-    private readonly maxEvaluatorIteration;
-    private evaluatorIteration;
-    private accumulatedResults;
-    private currentInterpreter;
-    private readonly scheduler;
-    constructor({ orchestrator, interpreters, memory, stream, maxEvaluatorIteration, }: {
-        orchestrator: Orchestrator;
+    private readonly agent;
+    private readonly memoryManager;
+    private readonly cache;
+    private webSocketClients;
+    private readonly config;
+    constructor(config: {
+        cache: CacheConfig;
+        orchestrator: {
+            model: LanguageModel;
+            tools: ActionSchema[];
+            memory?: {
+                cache?: CacheMemory;
+                persistent?: PersistentMemory;
+            };
+        };
         interpreters: Interpreter[];
-        memory: {
-            persistent: PersistentMemory;
-            cache?: CacheMemory;
+        memoryManager: {
+            model: LanguageModel;
+            memory?: {
+                cache?: CacheMemory;
+                persistent?: PersistentMemory;
+            };
         };
-        stream: boolean;
-        maxEvaluatorIteration: number;
+        callbacks?: QueueCallbacks;
+        maxIterations: number;
     });
-    process(prompt: string, events: AgentEvent): Promise<any>;
-    private handleActions;
+    process(state: State, callbacks?: QueueCallbacks): Promise<any>;
     private getInterpreter;
-    private interpreterResult;
-    private transformActions;
-    private formatResults;
-    scheduleAction(action: ActionSchema, scheduledTime: Date, userId: string, recurrence?: ScheduledAction["recurrence"]): Promise<string>;
-    cancelScheduledAction(actionId: string): Promise<boolean>;
+    addListener(id: string, url: string, subscriptionMessageFactory: () => string, callback: (data: any, agentContext: Agent) => Promise<void>): void;
 }