@ai.ntellect/core 0.1.8 → 0.1.83

package/memory/cache.ts

@@ -56,22 +56,23 @@ export class CacheMemory {
   private async storeMemory(memory: CacheMemoryType) {
     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(
+  async findSimilarQueries(
     query: string,
     options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
   ): Promise<
     {
       data: any;
       similarityPercentage: number;
-      purpose: string;
+      query: string;
     }[]
   > {
-    console.log("\n🔍 Searching in cache for query:", query);
+    console.log("\nSearching in cache for query:", query);
 
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
@@ -79,21 +80,20 @@ export class CacheMemory {
     });
 
     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 = 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,
         };
@@ -109,10 +109,10 @@ export class CacheMemory {
       : 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)}%)`
+          `- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`
         );
       });
     } else {
@@ -123,7 +123,7 @@ export class CacheMemory {
     return results;
   }
 
-  private async getAllMemories(
+  async getAllMemories(
     scope?: MemoryScope,
     userId?: string
   ): Promise<CacheMemoryType[]> {
@@ -162,23 +162,28 @@ export class CacheMemory {
   public async createMemory(
     input: CreateMemoryInput
   ): Promise<string | undefined> {
-    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)}%)`
+          `- ${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 generateObject({
       model: openai("gpt-4"),
       schema: z.object({
@@ -186,20 +191,17 @@ export class CacheMemory {
         queries: z.array(z.object({ text: 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,
     });
@@ -212,7 +214,6 @@ export class CacheMemory {
             content: variation.text,
             type: input.type,
             data: input.data,
-            purpose: variations.object.request,
             userId: input.userId,
             scope: input.scope,
           });
@@ -229,20 +230,20 @@ export class CacheMemory {
     content: string;
     type: MemoryType;
     data: any;
-    purpose: string;
     userId?: string;
     scope?: MemoryScope;
   }): Promise<CacheMemoryType> {
+    console.log("Creating new cache memory...", params.content);
+    console.log("Creating embedding...");
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
       value: params.content,
     });
-
+    console.log("Embedding created");
     const memory: CacheMemoryType = {
       id: params.id,
       type: params.type,
       data: params.data,
-      purpose: params.purpose,
       query: params.content,
       embedding,
       userId: params.userId,
@@ -250,7 +251,6 @@ export class CacheMemory {
         params.scope || (params.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
       createdAt: new Date(),
     };
-
     await this.storeMemory(memory);
     return memory;
   }

package/memory/persistent.ts

@@ -77,7 +77,6 @@ export class PersistentMemory {
     options: RequestInit = {}
   ): Promise<T> {
     const url = `${this.host}${path}`;
-    console.log("Making request to:", url);
     const response = await fetch(url, {
       ...options,
       headers: {
@@ -187,7 +186,7 @@ export class PersistentMemory {
    * Find best matching memories
    */
   async searchSimilarQueries(query: string, options: SearchOptions = {}) {
-    console.log("\n🔍 Searching in persistent memory:", query);
+    console.log("\nSearching in persistent memory:", query);
 
     // Generate embedding for the query
     const { embedding: queryEmbedding } = await embed({
@@ -240,7 +239,9 @@ export class PersistentMemory {
       }
     }
 
-    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
@@ -272,7 +273,7 @@ export class PersistentMemory {
 
     // 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)}% (${

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.1.8",
+  "version": "0.1.83",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -14,7 +14,10 @@
   "dependencies": {
     "@ai-sdk/openai": "1.0.6",
     "ai": "^3.0.0",
+    "ethers": "^6.13.5",
+    "langchain": "^0.3.11",
     "redis": "^4.7.0",
+    "rss-parser": "^3.13.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {

package/services/queue.ts

@@ -42,7 +42,6 @@ export class ActionQueueManager {
 
     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
         const shouldProceed = await this.callbacks.onConfirmationRequired?.(
@@ -62,6 +61,7 @@ export class ActionQueueManager {
           continue;
         }
       }
+      const parameters = this.formatArguments(action.parameters);
 
       actionPromises.push(
         this.executeAction(action)
@@ -72,7 +72,7 @@ export class ActionQueueManager {
           .catch((error) => {
             const result = {
               name: action.name,
-              parameters: this.formatArguments(action.parameters),
+              parameters,
               result: null,
               error: error.message || "Unknown error occurred",
             };
@@ -98,7 +98,23 @@ export class ActionQueueManager {
 
   private formatArguments(args: QueueItemParameter[]): Record<string, string> {
     return args.reduce<Record<string, string>>((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;
     }, {});
   }
@@ -115,13 +131,7 @@ export class ActionQueueManager {
         error: `Action '${action.name}' not found in actions list`,
       };
     }
-    const actionArgs = action.parameters.reduce<Record<string, string>>(
-      (acc: Record<string, string>, arg: QueueItemParameter) => {
-        acc[arg.name] = arg.value;
-        return acc;
-      },
-      {}
-    );
+    const actionArgs = this.formatArguments(action.parameters);
     try {
       const result = await actionConfig.execute(actionArgs);
       const actionResult = {
@@ -130,8 +140,7 @@ export 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) {
       const actionResult = {

package/t.ts

@@ -0,0 +1,133 @@
+export interface NetworkConfig {
+  name: string;
+  id?: number;
+  rpc: string;
+  explorerUrl: string;
+  nativeToken: string; // WETH
+}
+export const networkConfigs: Record<string, NetworkConfig> = {
+  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",
+  },
+};
+
+export const getNetworkProvider = (networkName: string) => {
+  const config = networkConfigs[networkName.toLowerCase()];
+  if (!config) {
+    throw new Error(`Network ${networkName} not supported`);
+  }
+  return { config };
+};
+
+import { parseEther } from "ethers";
+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 const prepareEvmTransaction = {
+  name: "prepare-evm-transaction",
+  description: "Prepare a transaction for the user to sign.",
+  parameters: z.object({
+    walletAddress: z.string(),
+    amount: z
+      .string()
+      .describe("Ask the user for the amount to send, if not specified"),
+    network: z
+      .string()
+      .describe(
+        "Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."
+      ),
+  }),
+  execute: async ({
+    walletAddress,
+    amount,
+    network,
+  }: {
+    walletAddress: string;
+    amount: string;
+    network: string;
+  }): Promise<TransactionPrepared> => {
+    try {
+      console.log("💰 Preparing transaction", {
+        to: walletAddress,
+        amount,
+        network,
+      });
+
+      const networkConfig = networkConfigs[network.toLowerCase()];
+
+      if (!networkConfig) {
+        throw new Error(`Network ${network} not found`);
+      }
+
+      return {
+        to: walletAddress,
+        value: 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/types.ts

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

package/utils/inject-actions.ts

@@ -5,7 +5,7 @@ export const injectActions = (actions: ActionSchema[]) => {
   return actions.map((action) => {
     const parameters = action.parameters as z.ZodObject<any>;
     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/test.ts

@@ -1,148 +0,0 @@
-import Parser from "rss-parser";
-import { z } from "zod";
-import { Agent } from "./agent";
-import { Orchestrator } from "./llm/orchestrator";
-import { PersistentMemory } from "./memory/persistent";
-
-interface ChainTVL {
-  name: string;
-  tvl: number;
-  tokenSymbol: string | null;
-  chainId: number | string | null;
-  gecko_id: string | null;
-  cmcId: string | null;
-}
-
-export const getChainsTVL = {
-  name: "get_chains_tvl",
-  description:
-    "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
-  parameters: z.object({
-    limit: z
-      .number()
-      .optional()
-      .default(10)
-      .describe("Number of top chains to return (default: 10)"),
-  }),
-  execute: async ({ limit }: { limit: number }) => {
-    try {
-      const response = await fetch("https://api.llama.fi/v2/chains", {
-        headers: { accept: "*/*" },
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-
-      const chains = (await response.json()) as ChainTVL[];
-
-      // Sort chains by TVL in descending order and take top N
-      const topChains = chains
-        .sort((a, b) => b.tvl - a.tvl)
-        .slice(0, limit)
-        .map((chain) => ({
-          name: chain.name,
-          tvl: chain.tvl,
-          tokenSymbol: chain.tokenSymbol,
-        }));
-
-      const totalTVL = chains.reduce((sum, chain) => sum + chain.tvl, 0);
-
-      return {
-        summary: {
-          totalTVL,
-          numberOfChains: chains.length,
-        },
-        topChains,
-      };
-    } catch (error) {
-      console.error("Error retrieving chains TVL data:", error);
-      throw new Error(
-        `Failed to fetch chains TVL data: ${(error as Error).message}`
-      );
-    }
-  },
-};
-
-const RSS_FEEDS = ["https://www.investing.com/rss/news_301.rss"];
-
-const parser = new Parser();
-
-function stripHtmlTags(content: string): string {
-  if (!content) return "";
-  return content
-    .replace(/<[^>]*>/g, "")
-    .replace(/\n/g, "")
-    .replace(" ", "");
-}
-
-export const getRssNews = {
-  name: "get-news-rss",
-  description: "Get latest news about on website",
-  parameters: z.object({}),
-  execute: async () => {
-    const itemsPerSource = 5;
-
-    try {
-      const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
-      const results = await Promise.allSettled(feedPromises);
-      const successfulFeeds = results
-        .filter(
-          (result): result is PromiseFulfilledResult<Parser.Output<any>> => {
-            return (
-              result.status === "fulfilled" && result.value?.items?.length > 0
-            );
-          }
-        )
-        .map((result) => result.value);
-      const allItems = successfulFeeds
-        .flatMap((feed) => feed.items.slice(0, itemsPerSource))
-        .sort((a, b) => {
-          const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
-          const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
-          return dateB - dateA;
-        })
-        .slice(0, 5)
-        .map((item) => ({
-          title: item.title,
-          content: stripHtmlTags(item.content),
-          link: item.link,
-          date: item.pubDate,
-          source: item.creator || new URL(item.link).hostname,
-        }));
-
-      const result = {
-        status: "success",
-        items: allItems,
-      };
-      return result;
-    } catch (error: any) {
-      throw error;
-    }
-  },
-};
-
-(async () => {
-  const memory = new PersistentMemory({
-    host: "http://localhost:7700",
-    apiKey: "aSampleMasterKey",
-  });
-  const orchestrator = new Orchestrator([], memory);
-  const agent = new Agent({
-    user: {
-      id: "1",
-    },
-    orchestrator,
-    persistentMemory: memory,
-    stream: false,
-    maxEvaluatorIteration: 1,
-  });
-
-  const prompt = "fais moi une analyse ethereum";
-  const context = prompt;
-  const result = await agent.process(prompt, context, {
-    onMessage: (message) => {
-      console.log({ message });
-    },
-  });
-})();