@ai.ntellect/core 0.2.7 → 0.3.0

package/dist/llm/evaluator/index.js

@@ -8,34 +8,34 @@ const types_1 = require("../../types");
 const inject_actions_1 = require("../../utils/inject-actions");
 const context_1 = require("./context");
 class Evaluator {
-    constructor(tools, memory) {
+    constructor(tools, memory, interpreters) {
         this.model = (0, openai_1.openai)("gpt-4o");
         this.tools = tools;
         this.memory = memory;
+        this.interpreters = interpreters;
     }
     composeContext(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 } = context_1.evaluatorContext.behavior;
+        const { important, warnings } = guidelines;
         const context = `
       # ROLE: ${role}
       # LANGUAGE: ${language}
       # IMPORTANT: ${important.join("\n")}
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # ACTIONS AVAILABLE: ${(0, inject_actions_1.injectActions)(actions)}
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
-      # STEPS: ${steps?.join("\n") || ""}
+      # ACTIONS AVAILABLE: ${(0, inject_actions_1.injectActions)(this.tools)}
+      # CURRENT_RESULTS: ${results}
+      # INTERPRETERS: ${this.interpreters
+            .map((interpreter) => interpreter.name)
+            .join(", ")}
     `;
-        console.log("Evaluator Context:", context);
         return context;
     }
     async process(prompt, results) {
         try {
             const context = this.composeContext({
-                behavior: context_1.evaluatorContext.behavior,
                 userRequest: prompt,
-                actions: this.tools,
                 results: results,
             });
             console.log("\n🔍 Evaluator processing");
@@ -45,11 +45,11 @@ class Evaluator {
                 schema: zod_1.z.object({
                     actionsCompleted: zod_1.z.array(zod_1.z.string()),
                     actionsFailed: zod_1.z.array(zod_1.z.string()),
-                    isRemindNeeded: zod_1.z.boolean(),
-                    importantToRemembers: zod_1.z.array(zod_1.z.object({
-                        memoryType: zod_1.z.string(),
-                        content: zod_1.z.string(),
+                    extraInformationsToStore: zod_1.z.array(zod_1.z.object({
+                        memoryType: zod_1.z.enum(["episodic", "semantic", "procedural"]),
+                        queryForData: zod_1.z.string(),
                         data: zod_1.z.string(),
+                        tags: zod_1.z.array(zod_1.z.string()),
                     })),
                     response: zod_1.z.string(),
                     isNextActionNeeded: zod_1.z.boolean(),
@@ -61,9 +61,10 @@ class Evaluator {
                         })),
                     })),
                     why: zod_1.z.string(),
+                    interpreter: zod_1.z.string(),
                 }),
                 prompt: prompt,
-                system: context,
+                system: `${context}`,
                 temperature: 0,
             });
             const validatedResponse = {
@@ -73,30 +74,41 @@ class Evaluator {
                     parameters: action.parameters || {},
                 })),
             };
-            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);
-                    const memories = await this.memory.searchSimilarQueries(item.content, {
-                        similarityThreshold: 95,
+                    console.log("Content:", item.queryForData);
+                    const memories = await this.memory.persistent.searchSimilarQueries(item.queryForData, {
+                        similarityThreshold: 70,
                     });
                     if (memories.length > 0) {
                         console.log("🔄 Similar memory already exists - skipping");
                         continue;
                     }
                     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: types_1.MemoryScope.GLOBAL,
                         createdAt: new Date(),
                     });
                 }
             }
+            // Storing workflow actions completed
+            const cacheMemory = this.memory.cache;
+            if (cacheMemory) {
+                cacheMemory.createMemory({
+                    content: prompt,
+                    type: types_1.MemoryType.ACTION,
+                    data: validatedResponse.actionsCompleted,
+                    scope: types_1.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));
@@ -108,16 +120,16 @@ 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(item.content);
+                        const memories = await this.memory.persistent.searchSimilarQueries(item.content);
                         if (memories.length === 0) {
                             console.log("Adding to memory", {
                                 query: item.content,
                                 data: item.data,
                             });
-                            await this.memory.createMemory({
+                            await this.memory.persistent.createMemory({
                                 id: crypto.randomUUID(),
                                 purpose: "importantToRemember",
                                 query: item.content,

package/dist/llm/interpreter/context.d.ts

@@ -0,0 +1,32 @@
+export declare const generalInterpreterContext: {
+    role: string;
+    language: string;
+    guidelines: {
+        important: never[];
+        warnings: never[];
+    };
+};
+export declare const securityInterpreterContext: {
+    role: string;
+    language: string;
+    guidelines: {
+        important: string[];
+        warnings: string[];
+    };
+    examplesMessages: {
+        role: string;
+        content: string;
+    }[];
+};
+export declare const marketInterpreterContext: {
+    role: string;
+    language: string;
+    guidelines: {
+        important: string[];
+        warnings: string[];
+    };
+    examplesMessages: {
+        role: string;
+        content: string;
+    }[];
+};

package/dist/llm/interpreter/context.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketInterpreterContext = exports.securityInterpreterContext = exports.generalInterpreterContext = void 0;
+exports.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: [],
+    },
+};
+exports.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
+      --------------------------------
+      `,
+        },
+    ],
+};
+exports.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/dist/llm/interpreter/index.d.ts

@@ -0,0 +1,17 @@
+import { StreamTextResult } from "ai";
+import { Behavior, State } from "../../types";
+export declare class Interpreter {
+    private readonly behavior;
+    private readonly model;
+    readonly name: string;
+    constructor(name: string, behavior: Behavior);
+    composeContext(state: State): string;
+    process(prompt: string, state: State, onFinish?: (event: any) => void): Promise<{
+        actionsCompleted: {
+            name: string;
+            reasoning: string;
+        }[];
+        response: string;
+    } | StreamTextResult<Record<string, any>>>;
+    streamProcess(prompt: string, state: State, onFinish?: (event: any) => void): Promise<any>;
+}

package/dist/llm/{synthesizer → interpreter}/index.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Synthesizer = void 0;
+exports.Interpreter = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
-const context_1 = require("./context");
-class Synthesizer {
-    constructor() {
+class Interpreter {
+    constructor(name, behavior) {
+        this.behavior = behavior;
         this.model = (0, openai_1.openai)("gpt-4o");
+        this.name = name;
+        this.behavior = behavior;
     }
     composeContext(state) {
-        const { behavior, userRequest, results, examplesMessages } = state;
-        if (!behavior) {
-            return "";
-        }
-        const { role, language, guidelines } = behavior;
+        const { userRequest, results } = state;
+        const { role, language, guidelines, examplesMessages } = this.behavior;
         const { important, warnings, steps } = guidelines;
         const context = `
       # ROLE: ${role}
@@ -22,22 +21,17 @@ 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, results, onFinish) {
-        console.log("\n🎨 Starting synthesis process");
+    async process(prompt, state, onFinish) {
+        console.log("\n🎨 Starting interpretation process");
         console.log("Prompt:", prompt);
-        console.log("Results to synthesize:", JSON.stringify(results, null, 2));
-        const context = this.composeContext({
-            behavior: context_1.synthesizerContext.behavior,
-            userRequest: prompt,
-            results: results,
-        });
+        console.log("Results to interpret:", JSON.stringify(state, null, 2));
+        const context = this.composeContext(state);
         const result = await (0, ai_1.generateObject)({
             model: this.model,
             schema: zod_1.z.object({
@@ -51,7 +45,7 @@ class Synthesizer {
             prompt,
             system: context,
         });
-        console.log("\n✅ Synthesis completed");
+        console.log("\n✅ Interpretation completed");
         console.log("─".repeat(50));
         console.log("Generated response:", result.object);
         if (result.object.actionsCompleted.length > 0) {
@@ -66,18 +60,14 @@ class Synthesizer {
             onFinish(result.object);
         return result.object;
     }
-    async streamProcess(prompt, results, onFinish) {
-        console.log("\n🎨 Starting streaming synthesis");
+    async streamProcess(prompt, state, onFinish) {
+        console.log("\n🎨 Starting streaming interpretation");
         console.log("Prompt:", prompt);
-        const context = this.composeContext({
-            behavior: context_1.synthesizerContext.behavior,
-            userRequest: prompt,
-            results: results,
-        });
+        const context = this.composeContext(state);
         const result = await (0, ai_1.streamText)({
             model: this.model,
             onFinish: (event) => {
-                console.log("\n✅ Streaming synthesis completed");
+                console.log("\n✅ Streaming interpretation completed");
                 if (onFinish)
                     onFinish(event);
             },
@@ -87,4 +77,4 @@ class Synthesizer {
         return result;
     }
 }
-exports.Synthesizer = Synthesizer;
+exports.Interpreter = Interpreter;

package/dist/llm/orchestrator/context.js

@@ -11,7 +11,7 @@ exports.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: [],

package/dist/llm/orchestrator/index.d.ts

@@ -1,17 +1,21 @@
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, QueueResult, State } from "../../types";
+import { ActionSchema, State } from "../../types";
 export declare class Orchestrator {
     private readonly model;
     tools: ActionSchema[];
     private memory;
     private id;
-    constructor(id: string, tools: ActionSchema[], memory: {
-        persistent: PersistentMemory;
-        cache: CacheMemory;
+    constructor({ id, tools, memory, }: {
+        id: string;
+        tools: ActionSchema[];
+        memory: {
+            persistent: PersistentMemory;
+            cache: CacheMemory;
+        };
     });
     composeContext(state: State): string;
-    process(prompt: string, results: QueueResult[]): Promise<{
+    process(prompt: string, results: string): Promise<{
         actions: {
             name: string;
             type: string;

package/dist/llm/orchestrator/index.js

@@ -4,11 +4,10 @@ exports.Orchestrator = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
-const types_1 = require("../../types");
 const inject_actions_1 = require("../../utils/inject-actions");
 const context_1 = require("./context");
 class Orchestrator {
-    constructor(id, tools, memory) {
+    constructor({ id, tools, memory, }) {
         this.model = (0, openai_1.openai)("gpt-4o");
         this.id = id;
         this.memory = memory;
@@ -24,70 +23,28 @@ class Orchestrator {
                     const persistentMemories = await this.memory.persistent.searchSimilarQueries(query, {
                         similarityThreshold: 70,
                     });
-                    return persistentMemories;
-                },
-            },
-            {
-                name: "search_cache_memory",
-                description: "Search for relevant information in the cache",
-                parameters: zod_1.z.object({
-                    query: zod_1.z.string(),
-                }),
-                execute: async ({ query }) => {
-                    const cacheMemories = await this.memory.cache.findSimilarQueries(query, {
-                        similarityThreshold: 70,
-                        maxResults: 1,
-                        userId: this.id,
-                        scope: types_1.MemoryScope.GLOBAL,
-                    });
-                    return cacheMemories;
-                },
-            },
-            {
-                name: "save_memory",
-                description: "Save relevant information in the internal knowledge base",
-                parameters: zod_1.z.object({
-                    query: zod_1.z.string(),
-                    memoryType: zod_1.z.string(),
-                    data: zod_1.z.any(),
-                    scope: zod_1.z.string().default("GLOBAL").describe("GLOBAL or USER"),
-                    userId: zod_1.z.string(),
-                    whyStored: zod_1.z.string(),
-                }),
-                execute: async ({ query, purpose, data, scope, userId, }) => {
-                    const memories = await this.memory.persistent.createMemory({
-                        query,
-                        purpose,
-                        data,
-                        scope,
-                        userId,
-                        createdAt: new Date(),
-                        id: crypto.randomUUID(),
-                    });
-                    return memories;
+                    return `# LONG_TERM_MEMORY: ${JSON.stringify(persistentMemories)}`;
                 },
             },
         ];
     }
     composeContext(state) {
-        const { behavior, userRequest, actions, results } = state;
-        const { role, language, guidelines } = behavior;
+        const { userRequest, results } = state;
+        const { role, language, guidelines } = context_1.orchestratorContext.behavior;
         const { important, warnings } = guidelines;
         const context = `
       # ROLE: ${role}
       # LANGUAGE: ${language}
       # IMPORTANT: ${important.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # ACTIONS_AVAILABLES: ${(0, inject_actions_1.injectActions)(actions)} (NEVER REPEAT ACTIONS)
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # ACTIONS_AVAILABLES: ${(0, inject_actions_1.injectActions)(this.tools)} (NEVER REPEAT ACTIONS)
+      # CURRENT_RESULTS: ${results}
     `.trim();
         return context;
     }
     async process(prompt, results) {
         const state = this.composeContext({
-            behavior: context_1.orchestratorContext.behavior,
             userRequest: prompt,
-            actions: this.tools,
             results: results,
         });
         try {

package/dist/memory/cache.d.ts

@@ -7,11 +7,11 @@ export declare class CacheMemory {
     private initRedis;
     private getMemoryKey;
     private storeMemory;
-    findSimilarQueries(query: string, options?: MatchOptions & {
+    findSimilarActions(query: string, options?: MatchOptions & {
         userId?: string;
         scope?: MemoryScope;
     }): Promise<{
-        data: QueueResult[];
+        actions: QueueResult[];
         similarityPercentage: number;
         query: string;
     }[]>;

package/dist/memory/cache.js

@@ -45,7 +45,7 @@ class CacheMemory {
         });
         console.log("💾 Cache memory created:", result);
     }
-    async findSimilarQueries(query, options = {}) {
+    async findSimilarActions(query, options = {}) {
         console.log("\n🔍 Searching in cache");
         console.log("Query:", query);
         console.log("Options:", JSON.stringify(options, null, 2));
@@ -60,10 +60,10 @@ class CacheMemory {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
             const similarityPercentage = (similarity + 1) * 50;
             return {
-                data: memory.data,
+                actions: memory.data,
                 query: memory.query,
                 similarityPercentage,
-                memoryId: memory.id,
+                createdAt: memory.createdAt,
             };
         })
             .filter((match) => match.similarityPercentage >= (options.similarityThreshold ?? 70))
@@ -78,7 +78,6 @@ class CacheMemory {
                 console.log(`\n${index + 1}. Match Details:`);
                 console.log(`   Query: ${match.query}`);
                 console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
-                console.log(`   Memory ID: ${match.memoryId}`);
                 console.log("─".repeat(50));
             });
         }
@@ -118,7 +117,7 @@ class CacheMemory {
         console.log("Content:", input.content);
         console.log("Type:", input.type);
         console.log("Scope:", input.scope);
-        const existingPattern = await this.findSimilarQueries(input.content, {
+        const existingPattern = await this.findSimilarActions(input.content, {
             similarityThreshold: 95,
             userId: input.userId,
             scope: input.scope,

package/dist/memory/persistent.d.ts

@@ -46,6 +46,7 @@ export declare class PersistentMemory {
      * Find best matching memories
      */
     searchSimilarQueries(query: string, options?: SearchOptions): Promise<{
+        createdAt: string;
         data: any;
         purpose: string;
         query: string;

package/dist/memory/persistent.js

@@ -104,7 +104,7 @@ class PersistentMemory {
     async createMemory(memory) {
         const indexName = this._getIndexName(memory.scope, memory.userId);
         await this._getOrCreateIndex(indexName);
-        const chunks = await this.processContent(memory.query);
+        const chunks = await this.processContent(memory.data);
         const document = {
             ...memory,
             chunks,
@@ -165,6 +165,7 @@ class PersistentMemory {
         const results = searchResults
             .flatMap((hit) => {
             const chunkSimilarities = hit.chunks.map((chunk) => ({
+                createdAt: hit.createdAt,
                 data: hit.data,
                 purpose: hit.purpose,
                 query: hit.query,

package/dist/test.d.ts

@@ -1,4 +1,58 @@
 import { z } from "zod";
+export declare const checkHoneypot: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        address: z.ZodString;
+        chainName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chainName: string;
+    }, {
+        address: string;
+        chainName: string;
+    }>;
+    execute: ({ address, chainName, }: {
+        address: string;
+        chainName?: string;
+    }) => Promise<{
+        status: string;
+        token: {
+            name: any;
+            symbol: any;
+            address: any;
+            holders: any;
+        };
+        risk: {
+            level: any;
+            score: any;
+            flags: any;
+        };
+        analysis: {
+            isHoneypot: any;
+            reason: any;
+            buyTax: any;
+            sellTax: any;
+            holders: {
+                total: any;
+                successful: any;
+                failed: any;
+                siphoned: any;
+            };
+        };
+        chain: {
+            name: any;
+            id: any;
+        };
+    } | {
+        status: string;
+        message: string;
+        chain: {
+            name: string;
+            id: string;
+        };
+    }>;
+};
 export interface NetworkConfig {
     name: string;
     id?: number;