@ai.ntellect/core 0.2.7 → 0.3.0

package/dist/test.js

@@ -3,15 +3,113 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRssNews = exports.getChainsTVL = exports.fetchMarkPrice = exports.prepareEvmTransaction = exports.getNetworkProvider = exports.networkConfigs = void 0;
+exports.getRssNews = exports.getChainsTVL = exports.fetchMarkPrice = exports.prepareEvmTransaction = exports.getNetworkProvider = exports.networkConfigs = exports.checkHoneypot = void 0;
 const ccxt_1 = __importDefault(require("ccxt"));
 const ethers_1 = require("ethers");
 const rss_parser_1 = __importDefault(require("rss-parser"));
 const zod_1 = require("zod");
 const agent_1 = require("./agent");
+const interpreter_1 = require("./llm/interpreter");
+const context_1 = require("./llm/interpreter/context");
 const orchestrator_1 = require("./llm/orchestrator");
 const cache_1 = require("./memory/cache");
 const persistent_1 = require("./memory/persistent");
+// Mapping des noms de chaînes vers leurs IDs
+const CHAIN_IDS = {
+    ethereum: "1",
+    bsc: "56",
+    polygon: "137",
+    matic: "137",
+    avalanche: "43114",
+    avax: "43114",
+    fantom: "250",
+    ftm: "250",
+    arbitrum: "42161",
+    arb: "42161",
+    optimism: "10",
+    base: "8453",
+    zksync: "324",
+    solana: "solana",
+    sol: "solana",
+};
+exports.checkHoneypot = {
+    name: "check-honeypot",
+    description: `Analyze a token to detect if it is a honeypot. RESPECT THIS FORMAT FOR CHAIN NAME: ${CHAIN_IDS.toString()}`,
+    parameters: zod_1.z.object({
+        address: zod_1.z.string().describe("Address of the token"),
+        chainName: zod_1.z.string().describe("Chain name (default: eth)"),
+    }),
+    execute: async ({ address, chainName, }) => {
+        try {
+            const API_URL = "https://api.honeypot.is/v2/IsHoneypot";
+            const chainId = getChainId(chainName);
+            console.log("💰 Checking honeypot for token", {
+                address,
+                chainId,
+            });
+            if (chainId === "solana") {
+                return {
+                    status: "error",
+                    message: "L'analyse des tokens Solana n'est pas encore supportée. Cette fonctionnalité sera disponible prochainement.",
+                    chain: {
+                        name: "Solana",
+                        id: "solana",
+                    },
+                };
+            }
+            const queryParams = new URLSearchParams({
+                address: address,
+                ...(chainId && { chainId }),
+                ...{ simulateLiquidity: "true" },
+            });
+            const response = await fetch(`${API_URL}?${queryParams}`);
+            if (!response.ok) {
+                throw new Error(`Erreur API: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            const result = {
+                status: "success",
+                token: {
+                    name: data.token.name,
+                    symbol: data.token.symbol,
+                    address: data.token.address,
+                    holders: data.token.totalHolders,
+                },
+                risk: {
+                    level: data.summary.risk,
+                    score: data.summary.riskLevel,
+                    flags: data.summary.flags || [],
+                },
+                analysis: {
+                    isHoneypot: data.honeypotResult?.isHoneypot || false,
+                    reason: data.honeypotResult?.honeypotReason || null,
+                    buyTax: data.simulationResult?.buyTax || 0,
+                    sellTax: data.simulationResult?.sellTax || 0,
+                    holders: {
+                        total: data.holderAnalysis?.holders || 0,
+                        successful: data.holderAnalysis?.successful || 0,
+                        failed: data.holderAnalysis?.failed || 0,
+                        siphoned: data.holderAnalysis?.siphoned || 0,
+                    },
+                },
+                chain: {
+                    name: data.chain.name,
+                    id: data.chain.id,
+                },
+            };
+            return result;
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+};
+function getChainId(chainName) {
+    if (!chainName)
+        return undefined;
+    const normalizedChainName = chainName.toLowerCase();
+    return CHAIN_IDS[normalizedChainName];
+}
 exports.networkConfigs = {
     ethereum: {
         name: "Ethereum Mainnet",
@@ -239,30 +337,37 @@ exports.getRssNews = {
         host: "http://localhost:7700",
         apiKey: "aSampleMasterKey",
     });
-    const orchestrator = new orchestrator_1.Orchestrator("1", [exports.getRssNews, exports.getChainsTVL, exports.fetchMarkPrice, exports.prepareEvmTransaction], {
-        persistent: memory,
-        cache: cacheMemory,
+    const orchestrator = new orchestrator_1.Orchestrator({
+        id: "1",
+        tools: [],
+        memory: {
+            persistent: memory,
+            cache: cacheMemory,
+        },
     });
+    const securityInterpreter = new interpreter_1.Interpreter("security", context_1.securityInterpreterContext);
+    const marketInterpreter = new interpreter_1.Interpreter("market", context_1.marketInterpreterContext);
+    const generalInterpreter = new interpreter_1.Interpreter("general", context_1.generalInterpreterContext);
+    // const ccacheMemory = await cacheMemory.findSimilarActions(
+    //   "le top 3 des chaines par TVL en DeFi",
+    //   {
+    //     similarityThreshold: 50,
+    //     maxResults: 5,
+    //     userId: "1",
+    //     scope: MemoryScope.GLOBAL,
+    //   }
+    // );
+    // console.log("✅ RECENT_ACTIONS: ", ccacheMemory);
     const agent = new agent_1.Agent({
-        user: {
-            id: "1",
-        },
+        interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
         orchestrator,
-        cacheMemory,
-        persistentMemory: memory,
+        memory: {
+            persistent: memory,
+            cache: cacheMemory,
+        },
         stream: false,
         maxEvaluatorIteration: 1,
     });
-    const prompt = "transfere 0.0001 eth to 0xf520cEd3b7FdA050a3A44486C160BEAb15ED3285 on ethereum";
-    const context = prompt;
-    // const save = await cacheMemory.createMemory({
-    //   content: prompt,
-    //   data: [],
-    //   scope: MemoryScope.GLOBAL,
-    //   type: MemoryType.ACTION,
-    // });
-    // consoleil.log({ save });
-    // const memo = await cacheMemory.getAllMemories();
-    // console.log({ memo });
+    const prompt = "c quoi le top 3 des chaines par TVL en DeFi";
     const result = await agent.process(prompt, {});
 })();

package/dist/types.d.ts

@@ -45,24 +45,23 @@ export interface ProcessPromptCallbacks {
     onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
     onConfirmationRequired?: (message: string) => Promise<boolean>;
 }
-export type State = {
-    behavior: {
-        role: string;
-        language: string;
-        guidelines: {
-            important: string[];
-            warnings: string[];
-            steps?: string[];
-        };
+export type Behavior = {
+    role: string;
+    language: string;
+    guidelines: {
+        important: string[];
+        warnings: string[];
+        steps?: string[];
     };
-    userRequest: string;
-    actions: ActionSchema[];
-    results: QueueResult[];
     examplesMessages?: {
         role: string;
         content: string;
     }[];
 };
+export type State = {
+    userRequest: string;
+    results: string;
+};
 export interface ActionSchema {
     name: string;
     description: string;
@@ -126,7 +125,7 @@ export interface CacheMemoryOptions {
 export interface CreateMemoryInput {
     content: any;
     type: MemoryType;
-    data: QueueResult[];
+    data: string[];
     userId?: string;
     scope?: MemoryScope;
 }

package/index.ts

@@ -1,7 +1,7 @@
 export * from "./agent";
+export * from "./llm/interpreter";
+export * from "./llm/interpreter/context";
 export * from "./llm/orchestrator";
-export * from "./llm/synthesizer";
-
 export * from "./types";
 
 export * from "./memory/cache";

package/llm/evaluator/context.ts

@@ -6,23 +6,14 @@ export const evaluatorContext = {
       important: [
         "Verify if all required actions were executed successfully.",
         "Check if the results align with the initial goal.",
-        "Identify and extract additional relevant information naturally during the process. Examples:",
-        "  - Link a token symbol (e.g., 'USDC') to its address (e.g., '0xA0b8...6EB48').",
-        "  - Associate a wallet address (e.g., '0x1234...abcd') to a user-friendly name (e.g., 'Work Wallet').",
-        "  - Map a token address (e.g., '0x6B17...71d0F') back to its symbol or name (e.g., 'DAI').",
-        "Store these facts in memory with their type (episodic, semantic, or procedural).",
+        "If you retrieved the informations from your internal knowledge base, no need to store them in 'extraInformationsToStore'.",
+        "Store ONLY extra new needed informations in 'extraInformationsToStore' (choose the most relevant informations and memory type: episodic, semantic, or procedural).",
       ],
       warnings: [
-        "NEVER modify the results directly.",
+        "NEVER store an old data you retrieve from your internal knowledge base.",
         "NEVER make assumptions about missing data.",
         "NEVER repeat actions already completed unless explicitly required.",
       ],
-      steps: [
-        "Verify success: Confirm if the goal has been fully or partially achieved. If partially, describe what's missing.",
-        "Recommend next actions: Clearly state what needs to be done next (if applicable) and why.",
-        "Store key facts: Store any relevant information in memory with their type (episodic, semantic, or procedural).",
-        "Be clear, concise, and prioritize storing key facts that may help improve future interactions.",
-      ],
     },
   },
 };

package/llm/evaluator/index.ts

@@ -1,25 +1,39 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
+import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, QueueResult, State } from "../../types";
+import { ActionSchema, MemoryScope, MemoryType, State } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
+import { Interpreter } from "../interpreter";
 import { evaluatorContext } from "./context";
 
 export class Evaluator {
   private readonly model = openai("gpt-4o");
   public tools: ActionSchema[];
-  private memory: PersistentMemory;
+  private memory: {
+    persistent: PersistentMemory;
+    cache?: CacheMemory;
+  };
+  private interpreters: Interpreter[];
 
-  constructor(tools: ActionSchema[], memory: PersistentMemory) {
+  constructor(
+    tools: ActionSchema[],
+    memory: {
+      persistent: PersistentMemory;
+      cache?: CacheMemory;
+    },
+    interpreters: Interpreter[]
+  ) {
     this.tools = tools;
     this.memory = memory;
+    this.interpreters = interpreters;
   }
 
   composeContext(state: State) {
-    const { behavior, userRequest, actions, results } = state;
-    const { role, language, guidelines } = behavior;
-    const { important, warnings, steps } = guidelines;
+    const { userRequest, results } = state;
+    const { role, language, guidelines } = evaluatorContext.behavior;
+    const { important, warnings } = guidelines;
 
     const context = `
       # ROLE: ${role}
@@ -27,20 +41,19 @@ export class Evaluator {
       # IMPORTANT: ${important.join("\n")}
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # ACTIONS AVAILABLE: ${injectActions(actions)}
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
-      # STEPS: ${steps?.join("\n") || ""}
+      # ACTIONS AVAILABLE: ${injectActions(this.tools)}
+      # CURRENT_RESULTS: ${results}
+      # INTERPRETERS: ${this.interpreters
+        .map((interpreter) => interpreter.name)
+        .join(", ")}
     `;
-    console.log("Evaluator Context:", context);
     return context;
   }
 
-  async process(prompt: string, results: QueueResult[]): Promise<any> {
+  async process(prompt: string, results: string): Promise<any> {
     try {
       const context = this.composeContext({
-        behavior: evaluatorContext.behavior,
         userRequest: prompt,
-        actions: this.tools,
         results: results,
       });
       console.log("\n🔍 Evaluator processing");
@@ -51,12 +64,12 @@ export class Evaluator {
         schema: z.object({
           actionsCompleted: z.array(z.string()),
           actionsFailed: z.array(z.string()),
-          isRemindNeeded: z.boolean(),
-          importantToRemembers: z.array(
+          extraInformationsToStore: z.array(
             z.object({
-              memoryType: z.string(),
-              content: z.string(),
+              memoryType: z.enum(["episodic", "semantic", "procedural"]),
+              queryForData: z.string(),
               data: z.string(),
+              tags: z.array(z.string()),
             })
           ),
           response: z.string(),
@@ -73,9 +86,10 @@ export class Evaluator {
             })
           ),
           why: z.string(),
+          interpreter: z.string(),
         }),
         prompt: prompt,
-        system: context,
+        system: `${context}`,
         temperature: 0,
       });
 
@@ -87,20 +101,20 @@ export class Evaluator {
         })),
       };
 
-      if (validatedResponse.isRemindNeeded) {
+      if (validatedResponse.extraInformationsToStore.length > 0) {
         console.log(
           "\n💭 Processing important memories to store",
           validatedResponse
         );
-        for (const item of validatedResponse.importantToRemembers) {
+        for (const item of validatedResponse.extraInformationsToStore) {
           console.log("\n📝 Processing memory item:");
           console.log("Type:", item.memoryType);
-          console.log("Content:", item.content);
+          console.log("Content:", item.queryForData);
 
-          const memories = await this.memory.searchSimilarQueries(
-            item.content,
+          const memories = await this.memory.persistent.searchSimilarQueries(
+            item.queryForData,
             {
-              similarityThreshold: 95,
+              similarityThreshold: 70,
             }
           );
 
@@ -110,10 +124,10 @@ export class Evaluator {
           }
 
           console.log("✨ Storing new memory");
-          await this.memory.createMemory({
+          await this.memory.persistent.createMemory({
             id: crypto.randomUUID(),
             purpose: item.memoryType,
-            query: item.content,
+            query: item.queryForData,
             data: item.data,
             scope: MemoryScope.GLOBAL,
             createdAt: new Date(),
@@ -121,6 +135,21 @@ export class Evaluator {
         }
       }
 
+      // Storing workflow actions completed
+      const cacheMemory = this.memory.cache;
+      if (cacheMemory) {
+        cacheMemory.createMemory({
+          content: prompt,
+          type: MemoryType.ACTION,
+          data: validatedResponse.actionsCompleted,
+          scope: MemoryScope.GLOBAL,
+        });
+        console.log(
+          "✅ Workflow actions completed stored in cache",
+          prompt,
+          validatedResponse.actionsCompleted
+        );
+      }
       console.log("\n✅ Evaluation completed");
       console.log("─".repeat(50));
       console.log("Results:", JSON.stringify(validatedResponse, null, 2));
@@ -132,10 +161,10 @@ export class Evaluator {
         console.log("Evaluator error");
         console.dir(error.value, { depth: null });
         console.error(error.message);
-        if (error.value.importantToRemembers.length > 0) {
-          for (const item of error.value.importantToRemembers) {
+        if (error.value.extraInformationsToStore.length > 0) {
+          for (const item of error.value.extraInformationsToStore) {
             // Check if the item is already in the memory
-            const memories = await this.memory.searchSimilarQueries(
+            const memories = await this.memory.persistent.searchSimilarQueries(
               item.content
             );
             if (memories.length === 0) {
@@ -143,7 +172,7 @@ export class Evaluator {
                 query: item.content,
                 data: item.data,
               });
-              await this.memory.createMemory({
+              await this.memory.persistent.createMemory({
                 id: crypto.randomUUID(),
                 purpose: "importantToRemember",
                 query: item.content,

package/llm/interpreter/context.ts

@@ -0,0 +1,89 @@
+export const generalInterpreterContext = {
+  role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
+  language: "user_language",
+  guidelines: {
+    important: [],
+    warnings: [],
+  },
+};
+
+export const securityInterpreterContext = {
+  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",
+  guidelines: {
+    important: [
+      "Start with a clear security analysis of the token/coin.",
+      "One section for good points of the security check. One section, no sub-sections.",
+      "One section for bad points of the security check. One section, no sub-sections.",
+      "STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS",
+    ],
+    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",
+      "NEVER explain technical errors or issues. Just say retry later.",
+    ],
+  },
+  examplesMessages: [
+    {
+      role: "user",
+      content: "Analysis security of token/coin",
+    },
+    {
+      role: "assistant",
+      content: `
+      ## Security analysis of x/y:
+      
+      ### Good:
+      Speak about the good points of the security check. If there is no good point, say "No good point found"
+  
+      ### Bad:
+      Speak about the bad points of the security check. If there is no bad point, say "No bad point found"
+  
+      STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
+      --------------------------------
+      `,
+    },
+  ],
+};
+
+export const marketInterpreterContext = {
+  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",
+  guidelines: {
+    important: [
+      "Start with a clear 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",
+    ],
+    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: [
+    {
+      role: "user",
+      content: "Analysis market sentiment of token/coin",
+    },
+    {
+      role: "assistant",
+      content: `
+    ## Analysis of x/y:
+
+    Market sentiment: Bullish 📈 (Adapt the emoji to the market sentiment)
+
+    ### Fundamental analysis (No sub-sections):
+    Speak about important events, news, trends..etc
+
+    ### Technical analysis (No sub-sections):
+    Speak about key price levels, trading volume, technical indicators, market activity..etc
+
+    STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
+    --------------------------------
+    `,
+    },
+  ],
+};

package/llm/{synthesizer → interpreter}/index.ts

@@ -1,19 +1,21 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
-import { QueueResult, State } from "../../types";
-import { synthesizerContext } from "./context";
+import { Behavior, State } from "../../types";
 
-export class Synthesizer {
+export class Interpreter {
   private readonly model = openai("gpt-4o");
+  public readonly name: string;
 
-  composeContext(state: Partial<State>) {
-    const { behavior, userRequest, results, examplesMessages } = state;
+  constructor(name: string, private readonly behavior: Behavior) {
+    this.name = name;
+    this.behavior = behavior;
+  }
+
+  composeContext(state: State) {
+    const { userRequest, results } = state;
+    const { role, language, guidelines, examplesMessages } = this.behavior;
 
-    if (!behavior) {
-      return "";
-    }
-    const { role, language, guidelines } = behavior;
     const { important, warnings, steps } = guidelines;
 
     const context = `
@@ -22,17 +24,16 @@ export class Synthesizer {
       # IMPORTANT: ${important.join("\n")}
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results?.map((r) => r.result).join(", ") || ""}
+      # CURRENT_RESULTS: ${results}
       # STEPS: ${steps?.join("\n") || ""}
       # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
     `;
-    console.log("Synthesizer Context:", context);
     return context;
   }
 
   async process(
     prompt: string,
-    results: QueueResult[],
+    state: State,
     onFinish?: (event: any) => void
   ): Promise<
     | {
@@ -44,15 +45,11 @@ export class Synthesizer {
       }
     | StreamTextResult<Record<string, any>>
   > {
-    console.log("\n🎨 Starting synthesis process");
+    console.log("\n🎨 Starting interpretation process");
     console.log("Prompt:", prompt);
-    console.log("Results to synthesize:", JSON.stringify(results, null, 2));
+    console.log("Results to interpret:", JSON.stringify(state, null, 2));
 
-    const context = this.composeContext({
-      behavior: synthesizerContext.behavior,
-      userRequest: prompt,
-      results: results,
-    });
+    const context = this.composeContext(state);
 
     const result = await generateObject({
       model: this.model,
@@ -70,7 +67,7 @@ export class Synthesizer {
       system: context,
     });
 
-    console.log("\n✅ Synthesis completed");
+    console.log("\n✅ Interpretation completed");
     console.log("─".repeat(50));
     console.log("Generated response:", result.object);
 
@@ -89,22 +86,18 @@ export class Synthesizer {
 
   async streamProcess(
     prompt: string,
-    results: QueueResult[],
+    state: State,
     onFinish?: (event: any) => void
   ): Promise<any> {
-    console.log("\n🎨 Starting streaming synthesis");
+    console.log("\n🎨 Starting streaming interpretation");
     console.log("Prompt:", prompt);
 
-    const context = this.composeContext({
-      behavior: synthesizerContext.behavior,
-      userRequest: prompt,
-      results: results,
-    });
+    const context = this.composeContext(state);
 
     const result = await streamText({
       model: this.model,
       onFinish: (event) => {
-        console.log("\n✅ Streaming synthesis completed");
+        console.log("\n✅ Streaming interpretation completed");
         if (onFinish) onFinish(event);
       },
       prompt,

package/llm/orchestrator/context.ts

@@ -8,7 +8,7 @@ export const orchestratorContext = {
         "If some parameters are not clear or missing, don't add the action, YOU MUST ask the user for them.",
         "ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
         "For ON-CHAIN actions, just use the useful actions.",
-        "For QUESTIONS or ANALYSIS, you CAN search in memory and internal knowledge base.",
+        "For QUESTIONS or ANALYSIS, you MUST search in your cache memory or/and internal knowledge base.",
         "NEVER repeat same actions if the user doesn't ask for it.",
       ],
       warnings: [],