npm - @ai.ntellect/core - Versions diffs - 0.4.1 → 0.5.0 - Mend

@ai.ntellect/core 0.4.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

package/README.FR.md +569 -18
package/agent/index.ts +54 -147
package/agent/workflow/conditions.ts +16 -0
package/agent/workflow/handlers/interpreter.handler.ts +48 -0
package/agent/workflow/handlers/memory.handler.ts +106 -0
package/agent/workflow/handlers/orchestrator.handler.ts +23 -0
package/agent/workflow/handlers/queue.handler.ts +34 -0
package/agent/workflow/handlers/scheduler.handler.ts +61 -0
package/agent/workflow/index.ts +62 -0
package/{agent/tools → examples/actions}/get-rss.ts +8 -1
package/examples/index.ts +10 -15
package/index.html +42 -0
package/llm/dynamic-condition/example.ts +36 -0
package/llm/dynamic-condition/index.ts +108 -0
package/llm/interpreter/context.ts +5 -12
package/llm/interpreter/index.ts +20 -16
package/llm/memory-manager/context.ts +4 -6
package/llm/memory-manager/index.ts +32 -80
package/llm/orchestrator/context.ts +5 -8
package/llm/orchestrator/index.ts +62 -102
package/llm/orchestrator/types.ts +2 -2
package/package.json +3 -1
package/script.js +167 -0
package/services/{scheduler.ts → agenda.ts} +20 -35
package/services/cache.ts +298 -0
package/services/queue.ts +3 -3
package/services/workflow.ts +491 -0
package/t.ts +21 -129
package/tsconfig.json +2 -1
package/types.ts +91 -12
package/utils/generate-object.ts +24 -12
package/utils/inject-actions.ts +3 -3
package/utils/state-manager.ts +25 -0
package/bull.ts +0 -5
package/services/redis-cache.ts +0 -128
package/t.spec +0 -38

package/examples/index.ts CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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;
+    }
+  }
+}

package/llm/interpreter/context.ts CHANGED Viewed

@@ -11,18 +11,9 @@ export type Character = {
   }[];
 };
-export const generalInterpreterCharacter: Character = {
-  role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-  language: "user_request",
-  guidelines: {
-    important: [],
-    warnings: [],
-  },
-};
 export const securityInterpreterCharacter: Character = {
   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_request",
+  language: "same_as_request",
   guidelines: {
     important: [
       "Start with a clear security analysis of the token/coin.",
@@ -52,7 +43,8 @@ export const securityInterpreterCharacter: Character = {
       ### Bad:
       Speak about the bad points of the security check. If there is no bad point, say "No bad point found"
+      TRANSLATE ALL THE TEXT TO LANGUAGE OF THE USER REQUEST
       STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
       `,
@@ -62,7 +54,7 @@ export const securityInterpreterCharacter: Character = {
 export const marketInterpreterCharacter: Character = {
   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_request",
+  language: "same_as_request",
   guidelines: {
     important: [
       "Start with a clear market sentiment (Market sentiment: Bullish/Bearish/Neutral 📈📉📊) without any additional comments before.",
@@ -93,6 +85,7 @@ export const marketInterpreterCharacter: Character = {
     ### Technical analysis (No sub-sections):
     Speak about key price levels, trading volume, technical indicators, market activity..etc
+    TRANSLATE ALL THE TEXT TO LANGUAGE OF THE USER REQUEST
     STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
     --------------------------------
     `,

package/llm/interpreter/index.ts CHANGED Viewed

@@ -1,8 +1,9 @@
 import { LanguageModel, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
-import { Behavior, State } from "../../types";
+import { Behavior, MyContext, SharedState } from "../../types";
 import { generateObject } from "../../utils/generate-object";
 import { LLMHeaderBuilder } from "../../utils/header-builder";
+import { State } from "../orchestrator/types";
 const interpreterSchema = z.object({
   requestLanguage: z
@@ -46,8 +47,7 @@ export class Interpreter {
     this.character = character;
   }
-  private buildContext(state: State) {
-    const { userRequest, results } = state;
+  private buildContext() {
     const { role, language, guidelines } = this.character;
     const { important, warnings, steps } = guidelines;
@@ -68,14 +68,11 @@ export class Interpreter {
     if (warnings.length > 0) {
       context.addHeader("NEVER", warnings);
     }
-    context.addHeader("CURRENT_RESULTS", results);
     return context;
   }
   async process(
-    prompt: string,
-    state: State,
+    state: SharedState<MyContext>,
     onFinish?: (event: any) => void
   ): Promise<
     | {
@@ -88,17 +85,24 @@ export class Interpreter {
     | StreamTextResult<Record<string, any>>
   > {
     try {
-      console.log("\n🎨 Starting interpretation process");
-      console.log("Prompt:", prompt);
-      console.log("Results to interpret:", JSON.stringify(state, null, 2));
-      const context = this.buildContext(state);
-      console.log("Context:", context.toString());
+      console.log("\n🎨 Start ing interpretation process");
+      const context = this.buildContext();
+      let prompt = LLMHeaderBuilder.create();
+      if (state.messages) {
+        prompt.addHeader(
+          "REQUEST",
+          state.messages[state.messages.length - 2].content.toString()
+        );
+      }
+      if (state.context.results) {
+        prompt.addHeader("RESULTS", JSON.stringify(state.context.results));
+      }
       const result = await generateObject<InterpretationResult>({
         model: this.model,
-        prompt,
+        prompt: prompt.toString(),
         system: context.toString(),
-        temperature: 1.3,
+        temperature: 0.5,
         schema: interpreterSchema,
       });
@@ -118,7 +122,7 @@ export class Interpreter {
     console.log("\n🎨 Starting streaming interpretation");
     console.log("Prompt:", prompt);
-    const context = this.buildContext(state);
+    const context = this.buildContext();
     const result = await streamText({
       model: this.model,

package/llm/memory-manager/context.ts CHANGED Viewed

@@ -1,15 +1,13 @@
 import { Character } from "../interpreter/context";
 export const memoryManagerInstructions: Character = {
-  role: "You are the memory curator. Your role is to extract and format memories from interactions.",
-  language: "user_request",
+  role: "You are the memory curator. Your role is to extract relevant memories from interactions.",
+  language: "same_as_request",
   guidelines: {
     important: [
-      "Generate memories based on the user request",
-      "Generate query for requested data as the user could ask for it later",
-      "Should be short-term memories only if it's ephemeral but relevant and reusable",
+      "Generate query for requested data as the user could ask for it later (Eg: 'What is the price of Bitcoin today?')s",
+      "Short-term memories need to be necessary and reusable",
       "Only store as long-term: User information, User preferences, Important facts that don't change often, Historical milestones",
-      "Make memory data concise and clear",
       "Set appropriate TTL based on data volatility",
     ],
     warnings: [

package/llm/memory-manager/index.ts CHANGED Viewed

@@ -2,10 +2,9 @@ import { LanguageModelV1 } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { MemoryScope } from "../../types";
+import { MyContext, SharedState } from "../../types";
 import { generateObject } from "../../utils/generate-object";
 import { LLMHeaderBuilder } from "../../utils/header-builder";
-import { State } from "../orchestrator/types";
 import { memoryManagerInstructions } from "./context";
 interface MemoryResponse {
@@ -27,7 +26,7 @@ interface MemoryResponse {
 }
 export class MemoryManager {
   private readonly model: LanguageModelV1;
-  private readonly memory?: {
+  public readonly memory?: {
     cache?: CacheMemory;
     persistent?: PersistentMemory;
   };
@@ -43,19 +42,39 @@ export class MemoryManager {
     this.memory = config.memory;
   }
-  buildContext(state: State) {
+  buildContext() {
     const context = LLMHeaderBuilder.create()
       .addHeader("ROLE", memoryManagerInstructions.role)
       .addHeader("LANGUAGE", memoryManagerInstructions.language)
       .addHeader("IMPORTANT", memoryManagerInstructions.guidelines.important)
-      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings)
-      .addHeader("CURRENT_CONTEXT", state.currentContext)
-      .addHeader("RESULTS", JSON.stringify(state.results));
+      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings);
     return context.toString();
   }
-  async process(state: State, result: string) {
-    const context = this.buildContext(state);
+  async process(
+    state: SharedState<MyContext>,
+    callbacks?: {
+      onMemoriesGenerated?: (event: any) => void;
+    }
+  ) {
+    const context = this.buildContext();
+    let prompt = LLMHeaderBuilder.create();
+    if (state.messages) {
+      prompt.addHeader(
+        "REQUEST",
+        state.messages[state.messages.length - 2].content.toString()
+      );
+    }
+    if (state.messages && state.messages.length > 0) {
+      prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
+    }
+    if (state.context.actions) {
+      prompt.addHeader(
+        "PREVIOUS_ACTIONS",
+        JSON.stringify(state.context.actions)
+      );
+    }
     const memories = await generateObject<MemoryResponse>({
       model: this.model,
@@ -79,85 +98,18 @@ export class MemoryManager {
           })
         ),
       }),
-      prompt: state.currentContext,
       system: context.toString(),
       temperature: 1,
+      prompt: prompt.toString(),
     });
-    console.log("Memories:", memories.object.memories);
     if (!this.memory) {
       return;
     }
-    // Store memories after all processing is complete
-    await Promise.all([
-      // Store short-term memories in cache
-      ...memories.object.memories
-        .filter((m: any) => m.type === "short-term")
-        .map(async (memoryItem: any) => {
-          if (!this.memory?.cache) {
-            return;
-          }
-          const existingCacheMemories =
-            await this.memory.cache.findSimilarActions(memoryItem.data, {
-              similarityThreshold: 85,
-              maxResults: 3,
-              scope: MemoryScope.GLOBAL,
-            });
-          if (existingCacheMemories.length > 0) {
-            console.log(
-              "⚠️ Similar memory already exists in cache:",
-              memoryItem.data
-            );
-            return;
-          }
-          await this.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
-      ...memories.object.memories
-        .filter((m) => m.type === "long-term")
-        .map(async (memoryItem) => {
-          if (!this.memory?.persistent) {
-            return;
-          }
-          const existingPersistentMemories =
-            await this.memory.persistent.findRelevantDocuments(
-              memoryItem.data,
-              {
-                similarityThreshold: 85,
-              }
-            );
-          if (existingPersistentMemories.length > 0) {
-            console.log(
-              "⚠️ Similar memory already exists in persistent storage:",
-              memoryItem.data
-            );
-            return;
-          }
+    if (callbacks?.onMemoriesGenerated)
+      callbacks.onMemoriesGenerated(memories.object);
-          await this.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 memories.object;
   }
 }

package/llm/orchestrator/context.ts CHANGED Viewed

@@ -1,16 +1,13 @@
 import { Character } from "../interpreter/context";
 export const orchestratorInstructions: Character = {
-  role: "You are the orchestrator. Your role is to evaluate the current state and determine next actions.",
-  language: "user_request",
+  role: "Your role is to evaluate the current state and determine next actions.",
+  language: "same_as_request",
   guidelines: {
     important: [
-      "Continue executing actions until ALL necessary goals are achieved",
-      "You can schedule actions in cron expression to be executed later (if needed)",
-      "Only stop when you have a complete picture of the goal",
-      "Social responses can be partial while gathering more data",
-      "Set shouldContinue to false if no more actions are needed",
-      "Once all actions are completed, choose the right interpreter to interpret the results",
+      "If no actions are needed, just answer",
+      "If required, you can schedule actions in cron expression to be executed later",
+      "If required, you choose one interpreter to interpret the results when you have a complete picture of the goal",
     ],
     warnings: [
       "Never use a tool if it's not related to the user request",