@ai.ntellect/core 0.4.0 → 0.5.0

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/dist/agent/index.d.ts

@@ -9,7 +9,7 @@ export declare class Agent {
     private readonly agent;
     private readonly memoryManager;
     private readonly cache;
-    private webSocketClients;
+    private listeners;
     private readonly config;
     constructor(config: {
         cache: CacheConfig;

package/dist/agent/index.js

@@ -12,7 +12,7 @@ const redis_cache_1 = require("../services/redis-cache");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
 class Agent {
     constructor(config) {
-        this.webSocketClients = new Map();
+        this.listeners = 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);
@@ -104,7 +104,7 @@ class Agent {
         return interpreters.find((interpreter) => interpreter.name === name);
     }
     addListener(id, url, subscriptionMessageFactory, callback) {
-        if (this.webSocketClients.has(id)) {
+        if (this.listeners.has(id)) {
             console.warn(`WebSocket with ID ${id} already exists.`);
             return;
         }
@@ -137,7 +137,7 @@ class Agent {
         socket.on("close", () => {
             console.log(`🔌 WebSocket closed for ID: ${id}`);
         });
-        this.webSocketClients.set(id, { socket, callback: wrappedCallback });
+        this.listeners.set(id, { socket, callback: wrappedCallback });
     }
 }
 exports.Agent = Agent;

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;
 

package/examples/index.ts

@@ -4,33 +4,27 @@ import { deepseek } from "@ai-sdk/deepseek";
 import { configDotenv } from "dotenv";
 import readline from "readline";
 import { Agent } from "../agent";
-import { getRssNews } from "../agent/tools/get-rss";
 import { Interpreter } from "../llm/interpreter";
 import {
-  generalInterpreterCharacter,
   marketInterpreterCharacter,
   securityInterpreterCharacter,
 } from "../llm/interpreter/context";
+import { getRssNews } from "./actions/get-rss";
 configDotenv();
 // Initialiser l'agent une fois pour toute la session
 const initializeAgent = () => {
-  const model = deepseek("deepseek-reasoner");
+  const model = deepseek("deepseek-chat");
 
   const securityInterpreter = new Interpreter({
-    name: "security",
+    name: "security-check",
     model,
     character: securityInterpreterCharacter,
   });
   const marketInterpreter = new Interpreter({
-    name: "market",
+    name: "market-analysis",
     model,
     character: marketInterpreterCharacter,
   });
-  const generalInterpreter = new Interpreter({
-    name: "general",
-    model,
-    character: generalInterpreterCharacter,
-  });
 
   const agent = new Agent({
     cache: {
@@ -41,7 +35,7 @@ const initializeAgent = () => {
       model,
       tools: [getRssNews],
     },
-    interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+    interpreters: [securityInterpreter, marketInterpreter],
     memoryManager: {
       model,
     },
@@ -80,12 +74,13 @@ const startChatSession = async () => {
       return;
     }
 
-    state.currentContext = input;
-
     console.log("Agent en réflexion...");
     try {
-      const result = await agent.process(state);
-      console.log(`Agent > ${result}\n`);
+      const result = await agent.process(input, {
+        onMessage: (message) => {
+          console.log(`Agent > ${message.socialResponse?.response}\n`);
+        },
+      });
     } catch (error) {
       console.error("Erreur avec l'agent :", error);
     }

package/index.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Workflow Visualization with Order</title>
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+    <style>
+      .node {
+        fill: steelblue;
+        stroke: black;
+        stroke-width: 1.5px;
+        cursor: pointer;
+      }
+      .node.selected {
+        fill: orange;
+      }
+      .link {
+        stroke: #ccc;
+        stroke-width: 2px;
+        opacity: 0.7;
+      }
+      .link.active {
+        stroke: orange;
+        stroke-width: 3px;
+      }
+      text {
+        font-size: 12px;
+        fill: black;
+      }
+      .order {
+        font-size: 10px;
+        fill: white;
+        font-weight: bold;
+      }
+    </style>
+  </head>
+  <body>
+    <svg id="graph" width="800" height="600"></svg>
+    <script src="script.js"></script>
+  </body>
+</html>

package/llm/dynamic-condition/example.ts

@@ -0,0 +1,36 @@
+import { deepseek } from "@ai-sdk/deepseek";
+import { configDotenv } from "dotenv";
+import { DynamicConditionGenerator } from "./index";
+
+const schema = `{
+  "type": "object",
+  "properties": {
+    "volume": { "type": "number" }
+  },
+  "required": ["volume"]
+}`;
+
+const testData = {
+  volume: 100000,
+};
+
+configDotenv();
+
+async function example() {
+  const generator = new DynamicConditionGenerator(
+    deepseek("deepseek-reasoner")
+  );
+
+  const result = await generator.generateCondition(
+    schema,
+    "check all pools with more than 100k volume",
+    {
+      functionName: "tradingCondition",
+      testData,
+    }
+  );
+
+  console.log("Generated function:", result);
+}
+
+example();

package/llm/dynamic-condition/index.ts

@@ -0,0 +1,108 @@
+import { generateText, LanguageModel } from "ai";
+import { z } from "zod";
+import { LLMHeaderBuilder } from "../../utils/header-builder";
+
+// Define the schema for condition validation
+const conditionSchema = z.object({
+  function: z.string().describe("The generated dynamic condition function"),
+  testResult: z
+    .boolean()
+    .optional()
+    .describe("The test result if test data provided"),
+});
+
+export interface DynamicConditionConfig {
+  functionName?: string;
+  testData?: Record<string, any>;
+}
+
+export class DynamicConditionGenerator {
+  private readonly model: LanguageModel;
+
+  constructor(model: LanguageModel) {
+    this.model = model;
+  }
+
+  /** Generate a JavaScript function named dynamicCondition that takes an object matching this schema and returns true following the prompt.
+The function must name 'dynamicCondition(data)' dynamically adapt to this schema. If fields are missing or do not match the schema, it should return false.
+Only return one JavaScript function code.
+
+BAD EXAMPLE:
+\`\`\`javascript
+function dynamicCondition(data) {
+  return data.amount > 0.1 && data.status === "completed";
+}
+\`\`\`
+
+GOOD EXAMPLE:
+function dynamicCondition(data) {
+  return data.amount > 0.1 && data.status === "completed";
+}
+
+OUTPUT ONLY THE FUNCTION CODE, NO 'TRIPLE QUOTES' OR ANY OTHER TEXT. ONLY THE FUNCTION CODE. */
+  private buildContext(schema: string, config: DynamicConditionConfig) {
+    const context = LLMHeaderBuilder.create()
+      .addHeader(
+        "ROLE",
+        "Generate a JavaScript function named 'dynamicCondition(data)' that takes an object matching this schema and returns true following the prompt."
+      )
+      .addHeader("IMPORTANT", [
+        "The function must name 'dynamicCondition(data)'",
+        "If fields are missing or do not match the schema, it should return false.",
+        "Only return one JavaScript function code.",
+        "OUTPUT ONLY THE FUNCTION CODE, NO 'TRIPLE QUOTES' OR ANY OTHER TEXT. ONLY THE FUNCTION CODE.",
+      ])
+      .addHeader(
+        "BAD EXAMPLE",
+        `\`\`\`javascript
+function dynamicCondition(data) {
+  return data.amount > 0.1 && data.status === 'completed';
+}
+\`\`\``
+      )
+      .addHeader(
+        "GOOD EXAMPLE",
+        `
+function dynamicCondition(data) {
+  return data.amount > 0.1 && data.status === 'completed';
+}`
+      )
+      .addHeader("SCHEMA", schema)
+      .addHeader("FUNCTION_NAME", config.functionName || "dynamicCondition");
+
+    return context.toString();
+  }
+
+  async generateCondition(
+    schema: string,
+    condition: string,
+    config: DynamicConditionConfig = {}
+  ) {
+    try {
+      const context = this.buildContext(schema, config);
+
+      const result = await generateText({
+        model: this.model,
+        system: context.toString(),
+        prompt: `Generate a function that validates this condition: ${condition}`,
+        temperature: 0,
+      });
+
+      // Test the generated function if test data is provided
+      if (config.testData) {
+        try {
+          const functionEval = eval(`(${result.text})`);
+          const testResult = functionEval(config.testData);
+          console.log("Test result:", testResult);
+        } catch (error) {
+          console.error("Error testing function:", error);
+        }
+      }
+
+      return result.text;
+    } catch (error) {
+      console.error("Error generating condition:", error);
+      throw error;
+    }
+  }
+}