@ai.ntellect/core 0.1.8 → 0.1.83

package/dist/llm/orchestrator/index.js

@@ -17,8 +17,32 @@ class Orchestrator {
                 parameters: zod_1.z.object({
                     query: zod_1.z.string(),
                 }),
-                execute: async (params) => {
-                    const memories = await this.memory.searchSimilarQueries(params.value);
+                execute: async ({ query }) => {
+                    const memories = await this.memory.searchSimilarQueries(query);
+                    return memories;
+                },
+            },
+            {
+                name: "save_memory",
+                description: "Save a query in the internal knowledge base",
+                parameters: zod_1.z.object({
+                    query: zod_1.z.string(),
+                    purpose: zod_1.z.string(),
+                    data: zod_1.z.any(),
+                    scope: zod_1.z.enum(["GLOBAL", "USER"]),
+                    userId: zod_1.z.string().optional(),
+                    whyStored: zod_1.z.string(),
+                }),
+                execute: async ({ query, purpose, data, scope, userId, }) => {
+                    const memories = await this.memory.storeMemory({
+                        query,
+                        purpose,
+                        data,
+                        scope,
+                        userId,
+                        createdAt: new Date(),
+                        id: crypto.randomUUID(),
+                    });
                     return memories;
                 },
             },
@@ -31,10 +55,10 @@ class Orchestrator {
                 schema: zod_1.z.object({
                     actions: zod_1.z.array(zod_1.z.object({
                         name: zod_1.z.string(),
-                        parameters: zod_1.z.object({
+                        parameters: zod_1.z.array(zod_1.z.object({
                             name: zod_1.z.string(),
                             value: zod_1.z.string(),
-                        }),
+                        })),
                     })),
                     answer: zod_1.z.string(),
                 }),

package/dist/memory/cache.d.ts

@@ -1,4 +1,4 @@
-import { CacheMemoryOptions, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
+import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
 export declare class CacheMemory {
     private redis;
     private readonly CACHE_PREFIX;
@@ -7,15 +7,15 @@ export declare class CacheMemory {
     private initRedis;
     private getMemoryKey;
     private storeMemory;
-    findBestMatches(query: string, options?: MatchOptions & {
+    findSimilarQueries(query: string, options?: MatchOptions & {
         userId?: string;
         scope?: MemoryScope;
     }): Promise<{
         data: any;
         similarityPercentage: number;
-        purpose: string;
+        query: string;
     }[]>;
-    private getAllMemories;
+    getAllMemories(scope?: MemoryScope, userId?: string): Promise<CacheMemoryType[]>;
     private getMemoriesFromKeys;
     createMemory(input: CreateMemoryInput): Promise<string | undefined>;
     private createSingleMemory;

package/dist/memory/cache.js

@@ -43,29 +43,29 @@ class CacheMemory {
     async storeMemory(memory) {
         const prefix = this.getMemoryKey(memory.scope, memory.userId);
         const key = `${prefix}${memory.id}`;
-        await this.redis.set(key, JSON.stringify(memory), {
+        const result = await this.redis.set(key, JSON.stringify(memory), {
             EX: this.CACHE_TTL,
         });
+        console.log("Cache memory created: ", result);
     }
-    async findBestMatches(query, options = {}) {
-        console.log("\n🔍 Searching in cache for query:", query);
+    async findSimilarQueries(query, options = {}) {
+        console.log("\nSearching in cache for query:", query);
         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, "memories to compare with");
+        console.log("\n📚 Found", memories.length, "queries to compare with");
         const matches = memories
             .map((memory) => {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
             const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
-            console.log(`\n📊 Memory "${memory.purpose}":
-        - Similarity: ${similarityPercentage.toFixed(2)}%
-        - Query: ${memory.query}`);
+            console.log(`\n📊 Query "${memory.query}":
+        - Similarity: ${similarityPercentage.toFixed(2)}%`);
             return {
                 data: memory.data,
+                query: memory.query,
                 similarityPercentage,
-                purpose: memory.purpose,
                 // Optionnel : ajouter des métadonnées utiles
                 memoryId: memory.id,
             };
@@ -76,9 +76,9 @@ class CacheMemory {
             ? matches.slice(0, options.maxResults)
             : matches;
         if (results.length > 0) {
-            console.log("\n✨ Best matches found:");
+            console.log("\n✨ Similar queries found:");
             results.forEach((match) => {
-                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
             });
         }
         else {
@@ -114,19 +114,23 @@ class CacheMemory {
         return memories;
     }
     async createMemory(input) {
-        const existingPattern = await this.findBestMatches(input.content, {
+        console.log("Searching for similar memory", input);
+        const existingPattern = await this.findSimilarQueries(input.content, {
             similarityThreshold: 95,
             userId: input.userId,
             scope: input.scope,
         });
         if (existingPattern.length > 0) {
-            console.log("\n🔍 Similar memory found:");
+            console.log("\nSimilar cache memory found:");
             existingPattern.forEach((match) => {
-                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+                console.log(`- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`);
             });
+            console.log("Cache memory already exists. No need to create new one..");
             return;
         }
+        console.log("No similar memory found");
         // Générer les variations via GPT-4
+        console.log("Generating variations...");
         const variations = await (0, ai_1.generateObject)({
             model: (0, openai_1.openai)("gpt-4"),
             schema: zod_1.z.object({
@@ -134,19 +138,17 @@ class CacheMemory {
                 queries: zod_1.z.array(zod_1.z.object({ text: zod_1.z.string() })),
             }),
             prompt: `For this input: "${input.content}"
-        Generate similar variations that should match the same context.
-        Context type: ${input.type}
-        Data: ${JSON.stringify(input.data)}
+        Generate similar way to ask the same question.
+        Action results: ${JSON.stringify(input.data)}
         - Keep variations natural and human-like
-        - Include the original input
         - Add 3-5 variations`,
         });
+        console.log("Variations generated:", variations.object.queries);
         await this.createSingleMemory({
             id: crypto.randomUUID(),
             content: input.content,
             type: input.type,
             data: input.data,
-            purpose: variations.object.request,
             userId: input.userId,
             scope: input.scope,
         });
@@ -157,7 +159,6 @@ class CacheMemory {
                     content: variation.text,
                     type: input.type,
                     data: input.data,
-                    purpose: variations.object.request,
                     userId: input.userId,
                     scope: input.scope,
                 });
@@ -167,15 +168,17 @@ class CacheMemory {
         return variations.object.request;
     }
     async createSingleMemory(params) {
+        console.log("Creating new cache memory...", params.content);
+        console.log("Creating embedding...");
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: params.content,
         });
+        console.log("Embedding created");
         const memory = {
             id: params.id,
             type: params.type,
             data: params.data,
-            purpose: params.purpose,
             query: params.content,
             embedding,
             userId: params.userId,

package/dist/memory/persistent.js

@@ -28,7 +28,6 @@ class PersistentMemory {
      */
     async _makeRequest(path, options = {}) {
         const url = `${this.host}${path}`;
-        console.log("Making request to:", url);
         const response = await fetch(url, {
             ...options,
             headers: {
@@ -122,7 +121,7 @@ class PersistentMemory {
      * Find best matching memories
      */
     async searchSimilarQueries(query, options = {}) {
-        console.log("\n🔍 Searching in persistent memory:", query);
+        console.log("\nSearching in persistent memory:", query);
         // Generate embedding for the query
         const { embedding: queryEmbedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
@@ -162,7 +161,7 @@ class PersistentMemory {
                 searchResults.push(...userResults.hits);
             }
         }
-        console.log("Found in persistent memory:", searchResults);
+        console.log(`📚 Found ${searchResults.length} queries in persistent memory`);
         // Process and filter results using cosine similarity
         const results = searchResults
             .flatMap((hit) => {
@@ -183,7 +182,7 @@ class PersistentMemory {
             .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
         // Log results
         if (results.length > 0) {
-            console.log("\n✨ Best matches found:");
+            console.log("\n✨ Similar queries found:");
             results.forEach((match) => {
                 console.log(`- ${match.query} : ${match.similarityPercentage.toFixed(2)}% (${match.purpose})`);
                 console.log(`  Matching content: "${match.chunk}"`);

package/dist/services/queue.js

@@ -44,6 +44,7 @@ class ActionQueueManager {
                     continue;
                 }
             }
+            const parameters = this.formatArguments(action.parameters);
             actionPromises.push(this.executeAction(action)
                 .then((result) => {
                 this.callbacks.onActionComplete?.(result);
@@ -52,7 +53,7 @@ class ActionQueueManager {
                 .catch((error) => {
                 const result = {
                     name: action.name,
-                    parameters: this.formatArguments(action.parameters),
+                    parameters,
                     result: null,
                     error: error.message || "Unknown error occurred",
                 };
@@ -76,7 +77,23 @@ class ActionQueueManager {
     }
     formatArguments(args) {
         return args.reduce((acc, arg) => {
-            acc[arg.name] = arg.value;
+            try {
+                // Parse the JSON string if the value is a stringified JSON object
+                const parsedValue = JSON.parse(arg.value);
+                if (parsedValue &&
+                    typeof parsedValue === "object" &&
+                    "value" in parsedValue) {
+                    acc[parsedValue.name] = parsedValue.value;
+                }
+                else {
+                    // Fallback to original value if not in expected format
+                    acc[arg.name] = arg.value;
+                }
+            }
+            catch {
+                // If JSON parsing fails, use the original value
+                acc[arg.name] = arg.value;
+            }
             return acc;
         }, {});
     }
@@ -92,10 +109,7 @@ class ActionQueueManager {
                 error: `Action '${action.name}' not found in actions list`,
             };
         }
-        const actionArgs = action.parameters.reduce((acc, arg) => {
-            acc[arg.name] = arg.value;
-            return acc;
-        }, {});
+        const actionArgs = this.formatArguments(action.parameters);
         try {
             const result = await actionConfig.execute(actionArgs);
             const actionResult = {
@@ -104,8 +118,7 @@ class ActionQueueManager {
                 result,
                 error: null,
             };
-            console.log("Action executed successfully: ", action.name);
-            console.dir(actionResult, { depth: null });
+            console.log("Action executed successfully: ", action.name, "🎉");
             return actionResult;
         }
         catch (error) {

package/dist/t.d.ts

@@ -0,0 +1,46 @@
+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;
+};
+import { z } from "zod";
+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>;
+};

package/dist/t.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareEvmTransaction = exports.getNetworkProvider = exports.networkConfigs = void 0;
+exports.networkConfigs = {
+    ethereum: {
+        name: "Ethereum Mainnet",
+        id: 1,
+        rpc: "https://eth.llamarpc.com",
+        explorerUrl: "https://etherscan.io",
+        nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    },
+    polygon: {
+        name: "Polygon Mainnet",
+        id: 137,
+        rpc: "https://polygon.llamarpc.com",
+        explorerUrl: "https://polygonscan.com",
+        nativeToken: "0x0000000000000000000000000000000000001010",
+    },
+    arbitrum: {
+        name: "Arbitrum Mainnet",
+        id: 42161,
+        rpc: "https://arbitrum.llamarpc.com",
+        explorerUrl: "https://arbiscan.io",
+        nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+    },
+    base: {
+        name: "Base Mainnet",
+        id: 8453,
+        rpc: "https://base.llamarpc.com",
+        explorerUrl: "https://basescan.org",
+        nativeToken: "0x4200000000000000000000000000000000000006",
+    },
+    solana: {
+        name: "Solana Mainnet",
+        rpc: "https://api.mainnet-beta.solana.com",
+        explorerUrl: "https://solscan.io",
+        nativeToken: "So11111111111111111111111111111111111111112",
+    },
+    sepolia: {
+        name: "Sepolia Testnet",
+        id: 11155111,
+        rpc: "https://sepolia.llamarpc.com",
+        explorerUrl: "https://sepolia.etherscan.io",
+        nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+    },
+    baseSepolia: {
+        name: "Base Sepolia Testnet",
+        id: 84532,
+        rpc: "https://base-sepolia-rpc.publicnode.com",
+        explorerUrl: "https://sepolia.basescan.org",
+        nativeToken: "0x4200000000000000000000000000000000000006",
+    },
+};
+const getNetworkProvider = (networkName) => {
+    const config = exports.networkConfigs[networkName.toLowerCase()];
+    if (!config) {
+        throw new Error(`Network ${networkName} not supported`);
+    }
+    return { config };
+};
+exports.getNetworkProvider = getNetworkProvider;
+const ethers_1 = require("ethers");
+const zod_1 = require("zod");
+exports.prepareEvmTransaction = {
+    name: "prepare-evm-transaction",
+    description: "Prepare a transaction for the user to sign.",
+    parameters: zod_1.z.object({
+        walletAddress: zod_1.z.string(),
+        amount: zod_1.z
+            .string()
+            .describe("Ask the user for the amount to send, if not specified"),
+        network: zod_1.z
+            .string()
+            .describe("Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."),
+    }),
+    execute: async ({ walletAddress, amount, network, }) => {
+        try {
+            console.log("💰 Preparing transaction", {
+                to: walletAddress,
+                amount,
+                network,
+            });
+            const networkConfig = exports.networkConfigs[network.toLowerCase()];
+            if (!networkConfig) {
+                throw new Error(`Network ${network} not found`);
+            }
+            return {
+                to: walletAddress,
+                value: (0, ethers_1.parseEther)(amount).toString(),
+                chain: {
+                    id: networkConfig.id || 0,
+                    rpc: networkConfig.rpc,
+                },
+                type: "transfer",
+            };
+        }
+        catch (error) {
+            console.error("💰 Error sending transaction:", error);
+            throw new Error("An error occurred while sending the transaction");
+        }
+    },
+};

package/dist/test.js

@@ -8,6 +8,7 @@ const rss_parser_1 = __importDefault(require("rss-parser"));
 const zod_1 = require("zod");
 const agent_1 = require("./agent");
 const orchestrator_1 = require("./llm/orchestrator");
+const cache_1 = require("./memory/cache");
 const persistent_1 = require("./memory/persistent");
 exports.getChainsTVL = {
     name: "get_chains_tvl",
@@ -103,25 +104,32 @@ exports.getRssNews = {
     },
 };
 (async () => {
+    const cacheMemory = new cache_1.CacheMemory();
     const memory = new persistent_1.PersistentMemory({
         host: "http://localhost:7700",
         apiKey: "aSampleMasterKey",
     });
-    const orchestrator = new orchestrator_1.Orchestrator([], memory);
+    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL], memory);
     const agent = new agent_1.Agent({
         user: {
             id: "1",
         },
         orchestrator,
+        cacheMemory,
         persistentMemory: memory,
         stream: false,
         maxEvaluatorIteration: 1,
     });
-    const prompt = "fais moi une analyse ethereum";
+    const prompt = "fais moi une analyse de xrp";
     const context = prompt;
-    const result = await agent.process(prompt, context, {
-        onMessage: (message) => {
-            console.log({ message });
-        },
-    });
+    // const save = await cacheMemory.createMemory({
+    //   content: prompt,
+    //   data: [],
+    //   scope: MemoryScope.GLOBAL,
+    //   type: MemoryType.ACTION,
+    // });
+    // console.log({ save });
+    // const memo = await cacheMemory.getAllMemories();
+    // console.log({ memo });
+    const result = await agent.process(prompt, context, {});
 })();

package/dist/types.d.ts

@@ -99,9 +99,9 @@ export interface CacheMemoryOptions {
     cachePrefix?: string;
 }
 export interface CreateMemoryInput {
-    content: string;
+    content: any;
     type: MemoryType;
-    data: any;
+    data: ActionSchema[];
     userId?: string;
     scope?: MemoryScope;
 }
@@ -109,7 +109,6 @@ export interface CacheMemoryType {
     id: string;
     type: MemoryType;
     data: any;
-    purpose: string;
     query: string;
     embedding: Embedding;
     userId?: string;

package/dist/utils/inject-actions.js

@@ -5,7 +5,7 @@ const injectActions = (actions) => {
     return actions.map((action) => {
         const parameters = action.parameters;
         const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-        const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments: { ${schemaShape} }`;
+        const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments (STRICTLY REQUIRED): { ${schemaShape} }`;
         return actionString;
     });
 };

package/index.ts

@@ -2,7 +2,6 @@ export * from "./agent";
 export * from "./llm/orchestrator";
 export * from "./llm/synthesizer";
 
-export * from "./services/queue";
 export * from "./types";
 
 export * from "./memory/cache";

package/llm/orchestrator/context.ts

@@ -6,7 +6,7 @@ export const orchestratorContext = {
   guidelines: {
     important: [
       "If there is no action to do, you must answer in the 'answer' field.",
-      "If some parameters are not clear or missing, YOU MUST ask the user for them.",
+      "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 QUESTIONS or ANALYSIS, BEFORE executing ANY actions, you MUST search in memory for similar queries AS THE ONLY ACTION TO EXECUTE.",
     ],

package/llm/orchestrator/index.ts

@@ -1,9 +1,8 @@
 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, BaseLLM } from "../../types";
+import { ActionSchema, BaseLLM, MemoryScopeType } from "../../types";
 import { orchestratorContext } from "./context";
 
 export class Orchestrator implements BaseLLM {
@@ -21,8 +20,44 @@ export class Orchestrator implements BaseLLM {
         parameters: z.object({
           query: z.string(),
         }),
-        execute: async (params) => {
-          const memories = await this.memory.searchSimilarQueries(params.value);
+        execute: async ({ query }: { query: string }) => {
+          const memories = await this.memory.searchSimilarQueries(query);
+          return memories;
+        },
+      },
+      {
+        name: "save_memory",
+        description: "Save a query in the internal knowledge base",
+        parameters: z.object({
+          query: z.string(),
+          purpose: z.string(),
+          data: z.any(),
+          scope: z.enum(["GLOBAL", "USER"]),
+          userId: z.string().optional(),
+          whyStored: z.string(),
+        }),
+        execute: async ({
+          query,
+          purpose,
+          data,
+          scope,
+          userId,
+        }: {
+          query: string;
+          purpose: string;
+          data: any;
+          scope: MemoryScopeType;
+          userId?: string;
+        }) => {
+          const memories = await this.memory.storeMemory({
+            query,
+            purpose,
+            data,
+            scope,
+            userId,
+            createdAt: new Date(),
+            id: crypto.randomUUID(),
+          });
           return memories;
         },
       },
@@ -37,10 +72,12 @@ export class Orchestrator implements BaseLLM {
           actions: z.array(
             z.object({
               name: z.string(),
-              parameters: z.object({
-                name: z.string(),
-                value: z.string(),
-              }),
+              parameters: z.array(
+                z.object({
+                  name: z.string(),
+                  value: z.string(),
+                })
+              ),
             })
           ),
           answer: z.string(),