@ai.ntellect/core 0.1.81 → 0.1.84

package/llm/evaluator/index.ts

@@ -20,24 +20,18 @@ export class Evaluator {
       const response = await generateObject({
         model: this.model,
         schema: z.object({
-          nextActions: z.array(
-            z.object({
-              name: z.string(),
-              parameters: z.object({
-                name: z.string(),
-                value: z.string(),
-              }),
-            })
-          ),
-          why: z.string(),
-          isImportantToRemember: z.boolean(),
-          importantToRemembers: z.array(
+          isRemindNeeded: z.boolean(),
+          extraInformationsToRemember: z.array(
             z.object({
               memoryType: z.string(),
-              hypotheticalQuery: z.string(),
-              result: z.string(),
+              content: z.string(),
+              data: z.string(),
             })
           ),
+          response: z.string(),
+          isNextActionNeeded: z.boolean(),
+          nextActionsNeeded: ActionSchema,
+          why: z.string(),
         }),
         prompt: prompt,
         system: evaluatorContext.compose(goal, results, this.tools),
@@ -45,17 +39,17 @@ export class Evaluator {
 
       const validatedResponse = {
         ...response.object,
-        nextActions: response.object.nextActions.map((action) => ({
+        nextActions: response.object.nextActionsNeeded.map((action) => ({
           ...action,
           parameters: action.parameters || {},
         })),
       };
 
-      if (validatedResponse.isImportantToRemember) {
-        for (const item of validatedResponse.importantToRemembers) {
+      if (validatedResponse.isRemindNeeded) {
+        for (const item of validatedResponse.extraInformationsToRemember) {
           // Check if the item is already in the memory
           const memories = await this.memory.searchSimilarQueries(
-            item.hypotheticalQuery,
+            item.content,
             {
               similarityThreshold: 95,
             }
@@ -68,14 +62,14 @@ export class Evaluator {
           }
           if (memories.length === 0) {
             console.log("Adding to memory", {
-              query: item.hypotheticalQuery,
-              data: item.result,
+              query: item.content,
+              data: item.data,
             });
-            await this.memory.storeMemory({
+            await this.memory.createMemory({
               id: crypto.randomUUID(),
               purpose: item.memoryType,
-              query: item.hypotheticalQuery,
-              data: item.result,
+              query: item.content,
+              data: item.data,
               scope: MemoryScope.GLOBAL,
               createdAt: new Date(),
             });
@@ -91,22 +85,22 @@ export class Evaluator {
         console.log("Evaluator error");
         console.dir(error.value, { depth: null });
         console.error(error.message);
-        if (error.value.importantToRemembers.length > 0) {
-          for (const item of error.value.importantToRemembers) {
+        if (error.value.extraInformationsToRemember.length > 0) {
+          for (const item of error.value.extraInformationsToRemember) {
             // Check if the item is already in the memory
             const memories = await this.memory.searchSimilarQueries(
-              item.hypotheticalQuery
+              item.content
             );
             if (memories.length === 0) {
               console.log("Adding to memory", {
-                query: item.hypotheticalQuery,
-                data: item.result,
+                query: item.content,
+                data: item.data,
               });
-              await this.memory.storeMemory({
+              await this.memory.createMemory({
                 id: crypto.randomUUID(),
                 purpose: "importantToRemember",
-                query: item.hypotheticalQuery,
-                data: item.result,
+                query: item.content,
+                data: item.data,
                 scope: MemoryScope.USER,
                 createdAt: new Date(),
               });

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,46 @@ 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, {
+            similarityThreshold: 95,
+          });
+          return memories;
+        },
+      },
+      {
+        name: "save_memory",
+        description: "Save relevant information in the internal knowledge base",
+        parameters: z.object({
+          query: z.string(),
+          memoryType: z.string(),
+          data: z.any(),
+          scope: z.string().default("GLOBAL").describe("GLOBAL or USER"),
+          userId: z.string(),
+          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.createMemory({
+            query,
+            purpose,
+            data,
+            scope,
+            userId,
+            createdAt: new Date(),
+            id: crypto.randomUUID(),
+          });
           return memories;
         },
       },
@@ -34,15 +71,7 @@ export class Orchestrator implements BaseLLM {
       const response = await generateObject({
         model: this.model,
         schema: z.object({
-          actions: z.array(
-            z.object({
-              name: z.string(),
-              parameters: z.object({
-                name: z.string(),
-                value: z.string(),
-              }),
-            })
-          ),
+          actions: ActionSchema,
           answer: z.string(),
         }),
         prompt: prompt,

package/llm/synthesizer/index.ts

@@ -14,11 +14,7 @@ export class Synthesizer implements BaseLLM {
     | {
         actions: {
           name: string;
-          relevantResult: string;
-          explain: {
-            how: string;
-            why: string;
-          };
+          reasoning: string;
         }[];
         response: string;
       }
@@ -31,11 +27,7 @@ export class Synthesizer implements BaseLLM {
         actions: z.array(
           z.object({
             name: z.string(),
-            relevantResult: z.string(),
-            explain: z.object({
-              how: z.string(),
-              why: z.string(),
-            }),
+            reasoning: z.string(),
           })
         ),
         response: z.string(),

package/memory/cache.ts

@@ -1,7 +1,6 @@
 import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed, generateObject } from "ai";
+import { cosineSimilarity, embed } from "ai";
 import { createClient } from "redis";
-import { z } from "zod";
 import {
   CacheMemoryOptions,
   CacheMemoryType,
@@ -56,22 +55,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,22 +79,16 @@ 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}`);
-
         return {
           data: memory.data,
+          query: memory.query,
           similarityPercentage,
-          purpose: memory.purpose,
-          // Optionnel : ajouter des métadonnées utiles
           memoryId: memory.id,
         };
       })
@@ -109,21 +103,20 @@ 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 {
       console.log("No matches found");
     }
 
-    console.dir({ results });
     return results;
   }
 
-  private async getAllMemories(
+  async getAllMemories(
     scope?: MemoryScope,
     userId?: string
   ): Promise<CacheMemoryType[]> {
@@ -161,67 +154,37 @@ export class CacheMemory {
 
   public async createMemory(
     input: CreateMemoryInput
-  ): Promise<string | undefined> {
-    const existingPattern = await this.findBestMatches(input.content, {
+  ): Promise<CacheMemoryType | undefined> {
+    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;
     }
 
-    // Générer les variations via GPT-4
-    const variations = await generateObject({
-      model: openai("gpt-4"),
-      schema: z.object({
-        request: z.string().describe("The request to be performed"),
-        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)}
-        - Keep variations natural and human-like
-        - Include the original input
-        - Add 3-5 variations`,
-    });
+    console.log("No similar memory found");
 
-    await this.createSingleMemory({
+    const memory = 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,
     });
 
-    const variationPromises = variations.object.queries.map(
-      async (variation) => {
-        if (variation.text !== input.content) {
-          await this.createSingleMemory({
-            id: crypto.randomUUID(),
-            content: variation.text,
-            type: input.type,
-            data: input.data,
-            purpose: variations.object.request,
-            userId: input.userId,
-            scope: input.scope,
-          });
-        }
-      }
-    );
-
-    await Promise.all(variationPromises);
-    return variations.object.request;
+    return memory;
   }
 
   private async createSingleMemory(params: {
@@ -229,20 +192,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 +213,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: {
@@ -160,7 +159,7 @@ export class PersistentMemory {
   /**
    * Store a memory in the database
    */
-  async storeMemory(memory: Memory) {
+  async createMemory(memory: Memory) {
     const indexName = this._getIndexName(memory.scope, memory.userId);
     await this._getOrCreateIndex(indexName);
 
@@ -179,7 +178,7 @@ export class PersistentMemory {
         body: JSON.stringify([document]),
       }
     );
-    console.log("Stored memory response:", response);
+    console.log("Stored persistent memory response:", response);
     return response;
   }
 
@@ -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 in persistent memory:");
       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.81",
+  "version": "0.1.84",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -14,8 +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");
+    }
+  },
+};