@ai.ntellect/core 0.4.1 → 0.5.0

package/agent/index.ts

@@ -2,34 +2,25 @@ import { LanguageModel } from "ai";
 import WebSocket from "ws";
 import { Interpreter } from "../llm/interpreter";
 import { MemoryManager } from "../llm/memory-manager";
-import { AgentRuntime } from "../llm/orchestrator";
-import { State } from "../llm/orchestrator/types";
+import { Orchestrator } from "../llm/orchestrator";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { ActionQueueManager } from "../services/queue";
-import { CacheConfig, RedisCache } from "../services/redis-cache";
-import { ActionData, ActionSchema, QueueCallbacks } from "../types";
-import { QueueItemTransformer } from "../utils/queue-item-transformer";
+import { CacheConfig, RedisCache } from "../services/cache";
+import { Workflow } from "../services/workflow";
+import { AgentEvent, MyContext, QueueCallbacks, SharedState } from "../types";
+import { createMainWorkflow } from "./workflow";
 
 export class Agent {
-  private readonly agent: AgentRuntime;
-  private readonly memoryManager: MemoryManager;
-  private readonly cache: RedisCache;
-
+  public readonly memoryManager: MemoryManager;
+  public readonly cache: RedisCache;
+  public readonly orchestrator: Orchestrator;
   private listeners: Map<
     string,
     { socket: WebSocket; callback: (data: any) => Promise<void> }
   > = new Map();
-  private readonly config: {
-    orchestrator: {
-      model: LanguageModel;
-      tools: ActionSchema[];
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
+  public readonly config: {
     interpreters: Interpreter[];
+    orchestrator: Orchestrator;
     memoryManager: {
       model: LanguageModel;
       memory?: {
@@ -42,15 +33,8 @@ export class Agent {
 
   constructor(config: {
     cache: CacheConfig;
-    orchestrator: {
-      model: LanguageModel;
-      tools: ActionSchema[];
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
     interpreters: Interpreter[];
+    orchestrator: Orchestrator;
     memoryManager: {
       model: LanguageModel;
       memory?: {
@@ -63,13 +47,7 @@ export class Agent {
   }) {
     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: {
@@ -77,125 +55,54 @@ export class Agent {
         persistent: config.memoryManager.memory?.persistent ?? undefined,
       },
     });
+    this.orchestrator = config.orchestrator;
     this.config.maxIterations = 3;
   }
 
-  public async process(state: State, callbacks?: QueueCallbacks): Promise<any> {
+  public async process(prompt: string, callbacks?: AgentEvent): Promise<any> {
     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 ActionQueueManager(
-        this.config.orchestrator.tools,
-        callbacks
-      );
-      const queueItems = QueueItemTransformer.transformActionsToQueueItems(
-        response.actions as ActionData[]
-      );
-      if (!queueItems) {
-        throw new Error("No queue items found");
-      }
+    const agent = this;
+    const recentMessages = await this.cache.getRecentMessages();
+    const previousActions = await this.cache.getRecentPreviousActions(1);
+
+    const initialState: SharedState<MyContext> = {
+      messages: [...recentMessages, { role: "user", content: prompt }],
+      context: {
+        prompt,
+        processing: {
+          stop: false,
+        },
+        results: previousActions,
+      },
+    };
 
-      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 = {
-        ...state,
-        currentContext: state.currentContext,
-        previousActions: [...(state.previousActions || []), ...(results || [])],
-      };
+    const mainWorkflow = createMainWorkflow(agent, prompt, callbacks);
+    const workflow = new Workflow<MyContext>(mainWorkflow);
 
-      console.log("\n🔁 Recursively processing with updated state");
-      countIterations++;
-      if (countIterations < this.config.maxIterations) {
-        return this.process(updatedNextState);
+    await workflow.execute(
+      initialState,
+      mainWorkflow.entryNode,
+      async (state) => {
+        callbacks?.onMessage && (await callbacks.onMessage(state));
       }
-    }
-
-    if (countIterations >= this.config.maxIterations) {
-      console.log("Max iterations reached");
-      response.shouldContinue = false;
-      console.log("Forcing stop");
-    }
-
-    // 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 };
-
-      console.log("\n📊 Final Analysis:", interpretationResult.response);
-
-      const finalState: State = {
-        ...state,
-        results: interpretationResult.response,
-      };
-
-      console.log("🔄 Final state:", finalState);
-    }
-
-    // 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) {
+  public getInterpreter(interpreters: Interpreter[], name: string) {
     return interpreters.find((interpreter) => interpreter.name === name);
   }
 
-  public addListener(
-    id: string,
-    url: string,
-    subscriptionMessageFactory: () => string,
-    callback: (data: any, agentContext: Agent) => Promise<void>
-  ): void {
+  public addListener({
+    id,
+    url,
+    onSubscribe,
+    onMessage,
+  }: {
+    id: string;
+    url: string;
+    onSubscribe: () => string;
+    onMessage: (data: any, agentContext: Agent) => Promise<void>;
+  }): void {
     if (this.listeners.has(id)) {
       console.warn(`WebSocket with ID ${id} already exists.`);
       return;
@@ -203,16 +110,16 @@ export class Agent {
 
     const socket = new WebSocket(url);
 
-    const wrappedCallback = async (data: any) => {
-      await callback(data, this);
+    const wrappedOnMessage = async (data: any) => {
+      await onMessage(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();
+      if (onSubscribe) {
+        const subscriptionMessage = onSubscribe();
         socket.send(subscriptionMessage);
         console.log(
           `📡 Sent subscription message for ID ${id}:`,
@@ -225,7 +132,7 @@ export class Agent {
       console.log(`📨 Message received for WebSocket ID ${id}:`, message);
       try {
         const data = JSON.parse(message);
-        await wrappedCallback(data);
+        await wrappedOnMessage(data);
       } catch (error) {
         console.error(`❌ Error in callback for WebSocket ID ${id}:`, error);
       }
@@ -239,6 +146,6 @@ export class Agent {
       console.log(`🔌 WebSocket closed for ID: ${id}`);
     });
 
-    this.listeners.set(id, { socket, callback: wrappedCallback });
+    this.listeners.set(id, { socket, callback: wrappedOnMessage });
   }
 }

package/agent/workflow/conditions.ts

@@ -0,0 +1,16 @@
+import { SharedState } from "../../types";
+
+export const hasActions = (state: SharedState<any>): boolean =>
+  !!state.context.actions && state.context.actions.length > 0;
+
+export const isNotStopped = (state: SharedState<any>): boolean =>
+  !state.context.processing?.stop;
+
+export const isInterpreterDefined = (state: SharedState<any>): boolean =>
+  !!state.context.interpreter;
+
+export const isResultsDefined = (state: SharedState<any>): boolean =>
+  !!state.context.results && state.context.results.length > 0;
+
+export const isStopped = (state: SharedState<any>): boolean =>
+  !!state.context.processing?.stop;

package/agent/workflow/handlers/interpreter.handler.ts

@@ -0,0 +1,48 @@
+import { Agent } from "../..";
+import { ActionData, MyContext, SharedState } from "../../../types";
+import { StateManager } from "../../../utils/state-manager";
+
+export const handleInterpreter = async (
+  sharedState: SharedState<MyContext>,
+  agent: Agent
+) => {
+  console.log("🔄 Interpreting actions");
+  const interpreter = agent.getInterpreter(
+    agent.config.interpreters,
+    sharedState.context.interpreter ?? ""
+  );
+
+  if (!interpreter) {
+    throw new Error("No interpreter found");
+  }
+
+  console.log("🎭 Selected Interpreter:", interpreter?.name);
+  (await interpreter?.process(sharedState, async (event: any) => {
+    console.log("🎭 Interpreter event:", event);
+
+    // Store message in recent messages
+    await agent.cache.storeMessage("assistant", event.response);
+  })) as { response: string };
+
+  const validatedActions = sharedState.context.actions?.map(
+    (action: ActionData) => ({
+      ...action,
+      name: action.name || "default", // Ensure name is always defined
+      parameters:
+        action.parameters?.map((param: { value: string }) => ({
+          ...param,
+          value: param.value ?? null,
+        })) ?? [],
+    })
+  );
+
+  return StateManager.updateState(sharedState, {
+    context: {
+      actions: validatedActions,
+      prompt: sharedState.context.prompt,
+      processing: {
+        stop: true,
+      },
+    },
+  });
+};

package/agent/workflow/handlers/memory.handler.ts

@@ -0,0 +1,106 @@
+import { Agent } from "../..";
+import { MemoryScope, MyContext, SharedState } from "../../../types";
+import { StateManager } from "../../../utils/state-manager";
+
+export const handleMemory = async (
+  sharedState: SharedState<MyContext>,
+  agent: Agent
+) => {
+  console.log("🔄 Storing memories");
+  const recentMessages = await agent.cache.getRecentMessages();
+
+  const updatedState = StateManager.updateState(sharedState, {
+    messages: recentMessages,
+  });
+
+  await agent.memoryManager.process(updatedState, {
+    onMemoriesGenerated: async (event) => {
+      if (event.memories.length === 0) {
+        return;
+      }
+      // Store memories after all processing is complete
+      await Promise.all([
+        // Store short-term memories in cache
+        ...event.memories
+          .filter((m: any) => m.type === "short-term")
+          .map(async (memoryItem: any) => {
+            await agent.cache.storeMemory(
+              memoryItem.data,
+              memoryItem.category,
+              memoryItem.tags,
+              memoryItem.ttl
+            );
+
+            const existingCacheMemories =
+              await agent.memoryManager.memory?.cache?.findSimilarActions(
+                memoryItem.data,
+                {
+                  similarityThreshold: 85,
+                  maxResults: 3,
+                  scope: MemoryScope.GLOBAL,
+                }
+              );
+
+            if (
+              existingCacheMemories?.length &&
+              existingCacheMemories.length > 0
+            ) {
+              console.log(
+                "⚠️ Similar memory already exists in cache:",
+                memoryItem.data
+              );
+              return;
+            }
+
+            await agent.memoryManager.memory?.cache?.createMemory({
+              query: memoryItem.queryForMemory,
+              data: memoryItem.data,
+              ttl: memoryItem.ttl, // Use TTL from LLM
+            });
+            console.log("✅ Memory stored in cache:", memoryItem.data);
+          }),
+
+        // Store long-term memories in persistent storage
+        ...event.memories
+          .filter((m: any) => m.type === "long-term")
+          .map(async (memoryItem: any) => {
+            if (!agent.memoryManager.memory?.persistent) {
+              return;
+            }
+
+            const existingPersistentMemories =
+              await agent.memoryManager.memory?.persistent?.findRelevantDocuments(
+                memoryItem.data,
+                {
+                  similarityThreshold: 85,
+                }
+              );
+
+            if (
+              existingPersistentMemories?.length &&
+              existingPersistentMemories.length > 0
+            ) {
+              console.log(
+                "⚠️ Similar memory already exists in persistent storage:",
+                memoryItem.data
+              );
+              return;
+            }
+
+            await agent.memoryManager.memory?.persistent?.createMemory({
+              query: memoryItem.queryForMemory,
+              data: memoryItem.data,
+              category: memoryItem.category,
+              tags: memoryItem.tags,
+              roomId: "global",
+              createdAt: new Date(),
+              id: crypto.randomUUID(),
+            });
+            console.log("✅ Memory stored in persistent storage:", memoryItem);
+          }),
+      ]);
+    },
+  });
+
+  return updatedState;
+};

package/agent/workflow/handlers/orchestrator.handler.ts

@@ -0,0 +1,23 @@
+import { Agent } from "../..";
+import { AgentEvent, MyContext, SharedState } from "../../../types";
+import { StateManager } from "../../../utils/state-manager";
+
+export const handleOrchestrator = async (
+  prompt: string,
+  sharedState: SharedState<MyContext>,
+  agent: Agent,
+  callbacks?: AgentEvent
+) => {
+  try {
+    const result = await agent.orchestrator.process(sharedState);
+
+    return StateManager.updateState(sharedState, {
+      context: {
+        ...result,
+      },
+    });
+  } catch (error) {
+    console.error("🔄 Start handler error:", error);
+    throw error;
+  }
+};

package/agent/workflow/handlers/queue.handler.ts

@@ -0,0 +1,34 @@
+import { Agent } from "../..";
+import { Queue } from "../../../services/queue";
+import { ActionData, AgentEvent, MyContext, SharedState } from "../../../types";
+import { QueueItemTransformer } from "../../../utils/queue-item-transformer";
+import { StateManager } from "../../../utils/state-manager";
+
+export const handleQueue = async (
+  sharedState: SharedState<MyContext>,
+  agent: Agent,
+  callbacks?: AgentEvent
+) => {
+  console.log("🔄 Queue actions:", sharedState.context.actions);
+  const queue = new Queue(agent.config.orchestrator.tools, callbacks);
+  const queueItems = QueueItemTransformer.transformActionsToQueueItems(
+    sharedState.context.actions as ActionData[]
+  );
+  if (!queueItems) {
+    throw new Error("No queue items found");
+  }
+  queue.add(queueItems);
+  const results = await queue.execute();
+  if (results) {
+    await agent.cache.storePreviousActions(crypto.randomUUID(), results);
+  }
+
+  return StateManager.updateState(sharedState, {
+    context: {
+      results,
+      processing: {
+        stop: false,
+      },
+    },
+  });
+};

package/agent/workflow/handlers/scheduler.handler.ts

@@ -0,0 +1,61 @@
+import { CoreMessage } from "ai";
+import { Agent } from "../..";
+import { MyContext, SharedState } from "../../../types";
+
+export const handleScheduler = async (
+  prompt: string,
+  sharedState: SharedState<MyContext>,
+  agent: Agent
+) => {
+  for (const action of sharedState.context.actions ?? []) {
+    if (action.scheduler?.isScheduled && action.scheduler?.cronExpression) {
+      await agent.agenda.scheduleRequest(
+        {
+          originalRequest: prompt,
+          cronExpression: action.scheduler.cronExpression,
+        },
+        {
+          onScheduled: (id) => {
+            console.log("🔄 Scheduled action:", id);
+          },
+          onExecuted: async (id, originalRequest) => {
+            console.log("🔄 Executed action:", id);
+
+            // Add context about when this request was scheduled
+            const contextualRequest = `You are a scheduler. 
+    You were asked to execute this request: ${originalRequest}\n 
+    Date of the request: ${new Date().toISOString()}\n
+    Act like if you know the request was scheduled.
+    Don't reschedule the same action. 
+    Just execute it.`;
+
+            const updatedSharedState = {
+              ...sharedState,
+              messages: [
+                {
+                  role: "user",
+                  content: contextualRequest,
+                },
+                ...(sharedState.messages ?? []),
+              ] as CoreMessage[],
+              context: {
+                ...sharedState.context,
+                originalRequest,
+              },
+            };
+
+            // Process the request as if it was just received
+            const result = await agent.orchestrator.process(updatedSharedState);
+
+            // Store the new actions in cache
+            if (result.actions.length > 0) {
+              await agent.cache.storePreviousActions(id, result.actions);
+            }
+          },
+        }
+      );
+    }
+  }
+
+  return sharedState;
+};

package/agent/workflow/index.ts

@@ -0,0 +1,62 @@
+import { Agent } from "..";
+import { MyContext, WorkflowDefinition } from "../../types";
+import {
+  hasActions,
+  isInterpreterDefined,
+  isNotStopped,
+  isResultsDefined,
+  isStopped,
+} from "./conditions";
+import { handleInterpreter } from "./handlers/interpreter.handler";
+import { handleMemory } from "./handlers/memory.handler";
+import { handleOrchestrator } from "./handlers/orchestrator.handler";
+import { handleQueue } from "./handlers/queue.handler";
+import { handleScheduler } from "./handlers/scheduler.handler";
+
+export const createMainWorkflow = (
+  agent: Agent,
+  prompt: string,
+  callbacks?: any
+): WorkflowDefinition<MyContext> => ({
+  name: "agentWorkflow", // Name of the graph
+  entryNode: "makeDecision", // Entry node
+  nodes: {
+    makeDecision: {
+      name: "makeDecision",
+      description: "Make a decision following the environment",
+      execute: async (state) =>
+        handleOrchestrator(prompt, state, agent, callbacks),
+      condition: (state) => isNotStopped(state), // Check if the agent is not stopped
+      next: ["checkEnvironment", "scheduleActions", "interpretResults"], // Next nodes to execute
+    },
+    checkEnvironment: {
+      name: "checkEnvironment", // Check the environment
+      description: "Check the environment for any actions to handle",
+      execute: async (state) => handleQueue(state, agent, callbacks),
+      condition: (state) => hasActions(state) && isNotStopped(state), // Check if there are actions to handle and the agent is not stopped
+      next: ["makeDecision"],
+    },
+    scheduleActions: {
+      name: "scheduleActions",
+      description: "Schedule actions for the future",
+      execute: async (state) => handleScheduler(prompt, state, agent),
+      condition: (state) => hasActions(state), // Check if there are actions to schedule
+    },
+    interpretResults: {
+      name: "interpretResults",
+      description: "Interpret the results of the actions",
+      execute: async (state) => handleInterpreter(state, agent),
+      condition: (state) =>
+        isInterpreterDefined(state) && // Check if interpreter is defined
+        isResultsDefined(state) && // Check if results are defined
+        isStopped(state), // Check if processing is stopped
+      next: ["saveMemory"],
+    },
+    saveMemory: {
+      name: "saveMemory",
+      description: "Save memory",
+      execute: async (state) => handleMemory(state, agent),
+      condition: (state) => isResultsDefined(state), // Check if results are defined
+    },
+  },
+});

package/{agent/tools → examples/actions}/get-rss.ts

@@ -20,7 +20,14 @@ function stripHtmlTags(content: string): string {
 export const getRssNews = {
   name: "get-news-rss",
   description: "Get latest news about on website",
-  parameters: z.object({}),
+  parameters: z.object({
+    url: z.enum([
+      "https://news.google.com/rss/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGx1YlY4U0FtVnVHZ0pWVXlnQVAB?hl=en-US&gl=US&ceid=US:en",
+      "https://www.investing.com/rss/news_301.rss",
+      "https://cointelegraph.com/rss/category/analysis",
+      "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
+    ]),
+  }),
   execute: async () => {
     const itemsPerSource = 5;