@ai.ntellect/core 0.1.81 → 0.1.83

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(),

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.81",
+  "version": "0.1.83",
   "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");
+    }
+  },
+};

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;
   });
 };