@ai.ntellect/core 0.1.97 → 0.1.99

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

@@ -1,10 +1,15 @@
 export declare const synthesizerContext: {
-    role: string;
-    guidelines: {
-        important: string[];
-        forMarketAnalysis: string[];
-        forGeneralRequests: string[];
-        warnings: string[];
+    behavior: {
+        language: string;
+        role: string;
+        guidelines: {
+            important: string[];
+            warnings: string[];
+            steps: string[];
+        };
+        examplesMessages: {
+            role: string;
+            content: string;
+        }[];
     };
-    compose: (results: string) => string;
 };

package/dist/llm/synthesizer/context.js

@@ -2,39 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.synthesizerContext = void 0;
 exports.synthesizerContext = {
-    role: "You are the synthesizer agent. Your role is to provide a clear and factual analysis of the results.",
-    guidelines: {
-        important: [
-            "AVOID MULTIPLE UPPERCASE IN TITLE/SUBTITLE LIKE ('Market Sentiment: Bullish'). USE ONLY ONE UPPERCASE IN TITLE/SUBTITLE.",
-            "USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT' (if it's in French, use French, if it's in Spanish, use Spanish)",
-            "BE DIRECT AND AVOID TECHNICAL JARGON",
-            "FOR NUMERICAL DATA, PROVIDE CONTEXT (% CHANGES, COMPARISONS)",
-        ],
-        forMarketAnalysis: [
-            "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",
-        ],
-        forGeneralRequests: [
-            "Provide concise and relevant information",
-            "Focus on facts and data",
-            "Always provide transaction details when needed",
-        ],
-        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.",
-        ],
-    },
-    compose: (results) => {
-        return `
-      ${JSON.stringify(exports.synthesizerContext.guidelines)}
-      Results: ${results}
+    behavior: {
+        language: "user_language",
+        role: "You are the synthesizer agent. Your role is to provide a clear and factual analysis of the results. You are also the expert in the field of security analysis.",
+        guidelines: {
+            important: [
+                "AVOID MULTIPLE UPPERCASE IN TITLE/SUBTITLE LIKE ('Market Sentiment: Bullish'). USE ONLY ONE UPPERCASE IN TITLE/SUBTITLE.",
+                "USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT' (if it's in French, use French, if it's in Spanish, use Spanish)",
+                "BE DIRECT AND AVOID TECHNICAL JARGON",
+                "FOR NUMERICAL DATA, PROVIDE CONTEXT (% CHANGES, COMPARISONS)",
+            ],
+            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.",
+            ],
+            steps: [
+                "Analyze user request: Determine if the user's goal is to ask a question, make an analysis, or perform an action.",
+                "Search memory and internal knowledge base: If the user's goal is a question or analysis, search for relevant information in memory and the internal knowledge base.",
+                "Execute actions: If the user's goal is to perform an action, execute the necessary actions.",
+                "Respond in the same language as the user request.",
+            ],
+        },
+        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"
 
-      1. FOR ALL ANALYSIS OF SPECIFIC TOKEN, RESPECT THE FOLLOWING FORMAT:
+      STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
+      `,
+            },
+            {
+                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)
@@ -47,8 +64,8 @@ exports.synthesizerContext = {
 
       STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
-      
-      2. OTHERWISE FOR OTHER REQUESTS, USE THE FORMAT YOU WANT.
-    `;
+      `,
+            },
+        ],
     },
 };

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

@@ -1,13 +1,15 @@
 import { StreamTextResult } from "ai";
-import { BaseLLM } from "../../types";
-export declare class Synthesizer implements BaseLLM {
+import { State } from "../../agent";
+import { QueueResult } from "../../types";
+export declare class Synthesizer {
     private readonly model;
-    process(prompt: string, onFinish?: (event: any) => void): Promise<{
-        actions: {
+    composeContext(state: Partial<State>): string;
+    process(prompt: string, results: QueueResult[], onFinish?: (event: any) => void): Promise<{
+        actionsCompleted: {
             name: string;
             reasoning: string;
         }[];
         response: string;
     } | StreamTextResult<Record<string, any>>>;
-    streamProcess(prompt: string, onFinish?: (event: any) => void): Promise<StreamTextResult<Record<string, any>>>;
+    streamProcess(prompt: string, summaryData?: string, onFinish?: (event: any) => void): Promise<any>;
 }

package/dist/llm/synthesizer/index.js

@@ -7,36 +7,83 @@ const zod_1 = require("zod");
 const context_1 = require("./context");
 class Synthesizer {
     constructor() {
-        this.model = (0, openai_1.openai)("gpt-4-turbo");
+        this.model = (0, openai_1.openai)("gpt-4o");
     }
-    async process(prompt, onFinish) {
-        console.log("Summarizing results...");
+    composeContext(state) {
+        const { behavior, userRequest, results, examplesMessages } = state;
+        if (!behavior) {
+            return "";
+        }
+        const { role, language, guidelines } = behavior;
+        const { important, warnings, steps } = guidelines;
+        const context = `
+      # ROLE: ${role}
+      # LANGUAGE: ${language}
+      # IMPORTANT: ${important.join("\n")}
+      # NEVER: ${warnings.join("\n")}
+      # USER_REQUEST: ${userRequest}
+      # CURRENT_RESULTS: ${results?.map((r) => r.result).join(", ") || ""}
+      # STEPS: ${steps?.join("\n") || ""}
+      # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
+    `;
+        return context;
+    }
+    async process(prompt, results, onFinish) {
+        console.log("\n🎨 Starting synthesis 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,
+        });
         const result = await (0, ai_1.generateObject)({
             model: this.model,
             schema: zod_1.z.object({
-                actions: zod_1.z.array(zod_1.z.object({
+                requestLanguage: zod_1.z.string(),
+                actionsCompleted: zod_1.z.array(zod_1.z.object({
                     name: zod_1.z.string(),
                     reasoning: zod_1.z.string(),
                 })),
                 response: zod_1.z.string(),
             }),
-            prompt: context_1.synthesizerContext.compose(prompt),
-            system: context_1.synthesizerContext.role,
+            prompt,
+            system: context,
         });
-        console.log("Synthesizer");
-        console.dir(result.object, { depth: null });
+        console.log("\n✅ Synthesis completed");
+        console.log("─".repeat(50));
+        console.log("Generated response:", result.object);
+        if (result.object.actionsCompleted.length > 0) {
+            console.log("\n📋 Suggested actions:");
+            result.object.actionsCompleted.forEach((action, index) => {
+                console.log(`\n${index + 1}. Action Details:`);
+                console.log(`   Name: ${action.name}`);
+                console.log(`   Reasoning: ${action.reasoning}`);
+            });
+        }
         if (onFinish)
             onFinish(result.object);
         return result.object;
     }
-    async streamProcess(prompt, onFinish) {
-        const result = await (0, ai_1.streamText)({
-            model: this.model,
-            prompt: context_1.synthesizerContext.compose(prompt),
-            onFinish: onFinish,
-            system: context_1.synthesizerContext.role,
-        });
-        return result;
+    async streamProcess(prompt, summaryData, onFinish) {
+        console.log("\n🎨 Starting streaming synthesis");
+        console.log("Prompt:", prompt);
+        // if (summaryData) {
+        //   console.log(
+        //     "Summary data:",
+        //     JSON.stringify(JSON.parse(summaryData), null, 2)
+        //   );
+        // }
+        // const result = await streamText({
+        //   model: this.model,
+        //   prompt: synthesizerContext.compose(prompt, summaryData || ""),
+        //   onFinish: (event) => {
+        //     console.log("\n✅ Streaming synthesis completed");
+        //     if (onFinish) onFinish(event);
+        //   },
+        //   system: synthesizerContext.role,
+        // });
+        // return result;
     }
 }
 exports.Synthesizer = Synthesizer;

package/dist/memory/cache.d.ts

@@ -1,4 +1,4 @@
-import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
+import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope, QueueResult } from "../types";
 export declare class CacheMemory {
     private redis;
     private readonly CACHE_PREFIX;
@@ -11,7 +11,7 @@ export declare class CacheMemory {
         userId?: string;
         scope?: MemoryScope;
     }): Promise<{
-        data: any;
+        data: QueueResult[];
         similarityPercentage: number;
         query: string;
     }[]>;

package/dist/memory/cache.js

@@ -21,16 +21,14 @@ class CacheMemory {
     }
     async initRedis() {
         this.redis.on("error", (err) => {
-            console.error("Redis Client Error:", err);
-            // Implement retry logic if needed
+            console.error("❌ Redis Client Error:", err);
         });
         try {
             await this.redis.connect();
-            console.log("Successfully connected to Redis");
+            console.log("✅ Successfully connected to Redis");
         }
         catch (error) {
-            console.error("Failed to connect to Redis:", error);
-            // Handle connection failure
+            console.error("❌ Failed to connect to Redis:", error);
         }
     }
     getMemoryKey(scope, userId) {
@@ -45,20 +43,22 @@ class CacheMemory {
         const result = await this.redis.set(key, JSON.stringify(memory), {
             EX: this.CACHE_TTL,
         });
-        console.log("Cache memory created: ", result);
+        console.log("💾 Cache memory created:", result);
     }
     async findSimilarQueries(query, options = {}) {
-        console.log("\nSearching in cache for query:", query);
+        console.log("\n🔍 Searching in cache");
+        console.log("Query:", query);
+        console.log("Options:", JSON.stringify(options, null, 2));
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: query,
         });
         const memories = await this.getAllMemories(options.scope, options.userId);
-        console.log("\n📚 Found", memories.length, "queries to compare with");
+        console.log(`\n📚 Found ${memories.length} cached queries to compare`);
         const matches = memories
             .map((memory) => {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
-            const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
+            const similarityPercentage = (similarity + 1) * 50;
             return {
                 data: memory.data,
                 query: memory.query,
@@ -73,12 +73,17 @@ class CacheMemory {
             : matches;
         if (results.length > 0) {
             console.log("\n✨ Similar queries found:");
-            results.forEach((match) => {
-                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
+            console.log("─".repeat(50));
+            results.forEach((match, index) => {
+                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));
             });
         }
         else {
-            console.log("No matches found");
+            console.log("\n❌ No similar queries found in cache");
         }
         return results;
     }
@@ -109,21 +114,27 @@ class CacheMemory {
         return memories;
     }
     async createMemory(input) {
-        console.log("Searching for similar memory", input);
+        console.log("\n📝 Processing new memory creation");
+        console.log("Content:", input.content);
+        console.log("Type:", input.type);
+        console.log("Scope:", input.scope);
         const existingPattern = await this.findSimilarQueries(input.content, {
             similarityThreshold: 95,
             userId: input.userId,
             scope: input.scope,
         });
         if (existingPattern.length > 0) {
-            console.log("\nSimilar cache memory found:");
-            existingPattern.forEach((match) => {
-                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
+            console.log("\n🔄 Similar cache memory already exists");
+            console.log("─".repeat(50));
+            existingPattern.forEach((match, index) => {
+                console.log(`\n${index + 1}. Existing Match:`);
+                console.log(`   Query: ${match.query}`);
+                console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
             });
-            console.log("Cache memory already exists. No need to create new one..");
+            console.log("\n⏭️  Skipping creation of new memory");
             return;
         }
-        console.log("No similar memory found");
+        console.log("\n🆕 No similar memory found - creating new one");
         const memory = await this.createSingleMemory({
             id: crypto.randomUUID(),
             content: input.content,
@@ -135,13 +146,15 @@ class CacheMemory {
         return memory;
     }
     async createSingleMemory(params) {
-        console.log("Creating new cache memory...", params.content);
-        console.log("Creating embedding...");
+        console.log("\n🏗️  Creating new cache memory");
+        console.log("ID:", params.id);
+        console.log("Content:", params.content);
+        console.log("\n🧮 Generating embedding...");
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: params.content,
         });
-        console.log("Embedding created");
+        console.log("✅ Embedding generated successfully");
         const memory = {
             id: params.id,
             type: params.type,
@@ -153,6 +166,7 @@ class CacheMemory {
             createdAt: new Date(),
         };
         await this.storeMemory(memory);
+        console.log("✅ Memory created and stored successfully");
         return memory;
     }
 }

package/dist/memory/persistent.js

@@ -121,32 +121,30 @@ class PersistentMemory {
      * Find best matching memories
      */
     async searchSimilarQueries(query, options = {}) {
-        console.log("\nSearching in persistent memory:", query);
+        console.log("\n🔍 Searching in persistent memory");
+        console.log("Query:", query);
+        console.log("Options:", JSON.stringify(options, null, 2));
         // Generate embedding for the query
         const { embedding: queryEmbedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: query,
         });
         const searchResults = [];
-        // Requête Meilisearch
-        const searchBody = {
-            q: query,
-        };
         // Search in global memories
         if (!options.scope || options.scope === "global") {
             const globalIndex = this._getIndexName(types_1.MemoryScope.GLOBAL);
-            console.log("Searching in global index:", globalIndex);
+            console.log("\n📚 Searching in global index:", globalIndex);
             try {
                 const globalResults = await this._makeRequest(`/indexes/${globalIndex}/search`, {
                     method: "POST",
-                    body: JSON.stringify(searchBody),
+                    body: JSON.stringify({ q: query }),
                 });
                 if (globalResults?.hits) {
                     searchResults.push(...globalResults.hits);
                 }
             }
             catch (error) {
-                console.error("Error searching global index:", error);
+                console.error("❌ Error searching global index:", error);
             }
         }
         // Search in user memories
@@ -155,17 +153,17 @@ class PersistentMemory {
             const userIndex = this._getIndexName(types_1.MemoryScope.USER, options.userId);
             const userResults = await this._makeRequest(`/indexes/${userIndex}/search`, {
                 method: "POST",
-                body: JSON.stringify(searchBody),
+                body: JSON.stringify({ q: query }),
             });
             if (userResults.hits) {
                 searchResults.push(...userResults.hits);
             }
         }
-        console.log(`📚 Found ${searchResults.length} queries in persistent memory`);
+        const totalResults = searchResults.length;
+        console.log(`\n📊 Found ${totalResults} total matches`);
         // Process and filter results using cosine similarity
         const results = searchResults
             .flatMap((hit) => {
-            // Calculate similarities for each chunk
             const chunkSimilarities = hit.chunks.map((chunk) => ({
                 data: hit.data,
                 purpose: hit.purpose,
@@ -173,23 +171,27 @@ class PersistentMemory {
                 chunk: chunk.content,
                 similarityPercentage: ((0, ai_1.cosineSimilarity)(queryEmbedding, chunk.embedding) + 1) * 50,
             }));
-            // Return the chunk with highest similarity
             return chunkSimilarities.reduce((best, current) => current.similarityPercentage > best.similarityPercentage
                 ? current
                 : best, chunkSimilarities[0]);
         })
             .filter((match) => match.similarityPercentage >= (options.similarityThreshold || 70))
             .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-        // Log results
+        // Log filtered results in a more structured way
         if (results.length > 0) {
-            console.log("\n✨ Similar queries found in persistent memory:");
-            results.forEach((match) => {
-                console.log(`- ${match.query} : ${match.similarityPercentage.toFixed(2)}% (${match.purpose})`);
-                console.log(`  Matching content: "${match.chunk}"`);
+            console.log("\n✨ Relevant matches found:");
+            console.log("─".repeat(50));
+            results.forEach((match, index) => {
+                console.log(`\n${index + 1}. Match Details:`);
+                console.log(`   Query: ${match.query}`);
+                console.log(`   Purpose: ${match.purpose}`);
+                console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
+                console.log(`   Content: "${match.chunk}"`);
+                console.log("─".repeat(50));
             });
         }
         else {
-            console.log("No matches found");
+            console.log("\n❌ No relevant matches found");
         }
         return results;
     }

package/dist/services/queue.js

@@ -11,29 +11,33 @@ class ActionQueueManager {
     }
     addToQueue(actions) {
         if (Array.isArray(actions)) {
-            console.log("Adding actions to queue:", actions.map((a) => a.name).join(", "));
+            console.log("\n📋 Adding actions to queue:");
+            actions.forEach((action, index) => {
+                console.log(`   ${index + 1}. ${action.name}`);
+            });
             this.queue.push(...actions);
         }
         else {
-            console.log("Adding action to queue:", actions.name);
+            console.log("\n📋 Adding single action to queue:", actions.name);
             this.queue.push(actions);
         }
     }
     async processQueue() {
         if (this.isProcessing) {
-            console.warn("Queue is already being processed");
+            console.log("\n⚠️  Queue is already being processed");
             return;
         }
+        console.log("\n🔄 Starting queue processing");
         this.isProcessing = true;
         const actionPromises = [];
         for (const action of this.queue) {
             const actionConfig = this.actions.find((a) => a.name === action.name);
             if (actionConfig?.confirmation?.requireConfirmation) {
-                // Wait for user confirmation before executing this action
+                console.log("\n🔒 Action requires confirmation:", action.name);
                 const shouldProceed = await this.callbacks.onConfirmationRequired?.(actionConfig.confirmation.message ||
                     `Do you want to proceed with action: ${action.name}?`);
                 if (!shouldProceed) {
-                    // Skip this action and add a cancelled result
+                    console.log("❌ Action cancelled by user:", action.name);
                     this.results.push({
                         name: action.name,
                         parameters: this.formatArguments(action.parameters),
@@ -43,6 +47,7 @@ class ActionQueueManager {
                     });
                     continue;
                 }
+                console.log("✅ Action confirmed by user");
             }
             const parameters = this.formatArguments(action.parameters);
             actionPromises.push(this.executeAction(action)
@@ -62,16 +67,18 @@ class ActionQueueManager {
             }));
         }
         try {
+            console.log("\n⏳ Waiting for all actions to complete...");
             const results = await Promise.all(actionPromises);
             this.results.push(...results);
             this.queue = [];
             this.callbacks.onQueueComplete?.(this.results);
             this.isProcessing = false;
+            console.log("\n✅ Queue processing completed successfully");
             return this.results;
         }
         catch (error) {
             this.isProcessing = false;
-            console.error("Unexpected error in queue processing:", error);
+            console.error("\n❌ Unexpected error in queue processing:", error);
             throw error;
         }
     }
@@ -98,10 +105,11 @@ class ActionQueueManager {
         }, {});
     }
     async executeAction(action) {
-        // Call onActionStart callback
+        console.log("\n🎯 Executing action:", action.name);
         this.callbacks.onActionStart?.(action);
         const actionConfig = this.actions.find((a) => a.name === action.name);
         if (!actionConfig) {
+            console.error("❌ Action not found:", action.name);
             return {
                 name: action.name,
                 parameters: {},
@@ -109,6 +117,7 @@ class ActionQueueManager {
                 error: `Action '${action.name}' not found in actions list`,
             };
         }
+        console.log("📝 Action parameters:", JSON.stringify(action.parameters, null, 2));
         const actionArgs = this.formatArguments(action.parameters);
         try {
             const result = await actionConfig.execute(actionArgs);
@@ -118,7 +127,7 @@ class ActionQueueManager {
                 result,
                 error: null,
             };
-            console.log("Action executed successfully: ", action.name, "🎉");
+            console.log(`\n✨ Action "${action.name}" completed successfully`);
             return actionResult;
         }
         catch (error) {
@@ -128,8 +137,8 @@ class ActionQueueManager {
                 result: null,
                 error: error.message || "Unknown error occurred",
             };
-            console.log("Action failed: ", action.name);
-            console.dir(actionResult, { depth: null });
+            console.error(`\n❌ Action "${action.name}" failed:`, error);
+            console.log("Failed action details:", JSON.stringify(actionResult, null, 2));
             return actionResult;
         }
     }

package/dist/test.d.ts

@@ -1,4 +1,49 @@
 import { z } from "zod";
+export interface NetworkConfig {
+    name: string;
+    id?: number;
+    rpc: string;
+    explorerUrl: string;
+    nativeToken: string;
+}
+export declare const networkConfigs: Record<string, NetworkConfig>;
+export declare const getNetworkProvider: (networkName: string) => {
+    config: NetworkConfig;
+};
+export type TransactionPrepared = {
+    to: string;
+    value: string;
+    data?: string;
+    chain: {
+        id: number;
+        rpc: string;
+    };
+    type: "transfer" | "approve" | "swap";
+    method?: string;
+    params?: any[];
+};
+export declare const prepareEvmTransaction: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        walletAddress: z.ZodString;
+        amount: z.ZodString;
+        network: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        walletAddress: string;
+        amount: string;
+        network: string;
+    }, {
+        walletAddress: string;
+        amount: string;
+        network: string;
+    }>;
+    execute: ({ walletAddress, amount, network, }: {
+        walletAddress: string;
+        amount: string;
+        network: string;
+    }) => Promise<TransactionPrepared>;
+};
 export declare const fetchMarkPrice: {
     name: string;
     description: string;