@ai.ntellect/core 0.1.83 → 0.1.85

package/dist/test.js

@@ -3,13 +3,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRssNews = exports.getChainsTVL = void 0;
+exports.getRssNews = exports.getChainsTVL = exports.fetchMarkPrice = void 0;
+const ccxt_1 = __importDefault(require("ccxt"));
 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.fetchMarkPrice = {
+    name: "fetch-mark-price",
+    description: "Fetches mark price for the market",
+    parameters: zod_1.z.object({
+        symbol: zod_1.z
+            .string()
+            .describe("Unified symbol of the market to fetch the ticker for (default: BTC/USDT)"),
+        params: zod_1.z.object({
+            subType: zod_1.z
+                .string()
+                .describe("Type of funding rate: 'linear' or 'inverse'"),
+        }),
+    }),
+    execute: async ({ symbol, params }) => {
+        try {
+            const binance = new ccxt_1.default.binance({});
+            // Fetch mark price from the Binance API
+            const markPrice = await binance.fetchMarkPrice(symbol, params);
+            console.log("Mark price fetched:", markPrice);
+            return markPrice;
+        }
+        catch (error) {
+            console.error("Error fetching mark price:", error);
+            throw error;
+        }
+    },
+};
 exports.getChainsTVL = {
     name: "get_chains_tvl",
     description: "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
@@ -53,7 +81,11 @@ exports.getChainsTVL = {
         }
     },
 };
-const RSS_FEEDS = ["https://www.investing.com/rss/news_301.rss"];
+const RSS_FEEDS = [
+    "https://www.investing.com/rss/news_301.rss",
+    "https://cointelegraph.com/rss/category/analysis",
+    "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
+];
 const parser = new rss_parser_1.default();
 function stripHtmlTags(content) {
     if (!content)
@@ -109,7 +141,7 @@ exports.getRssNews = {
         host: "http://localhost:7700",
         apiKey: "aSampleMasterKey",
     });
-    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL], memory);
+    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL, exports.fetchMarkPrice], memory);
     const agent = new agent_1.Agent({
         user: {
             id: "1",
@@ -120,7 +152,7 @@ exports.getRssNews = {
         stream: false,
         maxEvaluatorIteration: 1,
     });
-    const prompt = "fais moi une analyse de xrp";
+    const prompt = "analyse le ai16z";
     const context = prompt;
     // const save = await cacheMemory.createMemory({
     //   content: prompt,

package/dist/types.d.ts

@@ -101,7 +101,7 @@ export interface CacheMemoryOptions {
 export interface CreateMemoryInput {
     content: any;
     type: MemoryType;
-    data: ActionSchema[];
+    data: QueueResult[];
     userId?: string;
     scope?: MemoryScope;
 }
@@ -135,6 +135,31 @@ export interface Memory {
     createdAt: Date;
     chunks?: MemoryChunk[];
 }
+export declare const ActionSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        name: string;
+    }, {
+        value: string;
+        name: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    parameters: {
+        value: string;
+        name: string;
+    }[];
+}, {
+    name: string;
+    parameters: {
+        value: string;
+        name: string;
+    }[];
+}>, "many">;
 export declare enum MemoryType {
     ACTION = "action",
     CONVERSATION = "conversation",

package/dist/types.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryScope = exports.MemoryType = void 0;
+exports.MemoryScope = exports.MemoryType = exports.ActionSchema = void 0;
+const zod_1 = require("zod");
+exports.ActionSchema = zod_1.z.array(zod_1.z.object({
+    name: zod_1.z.string(),
+    parameters: zod_1.z.array(zod_1.z.object({
+        name: zod_1.z.string(),
+        value: zod_1.z.string(),
+    })),
+}));
 var MemoryType;
 (function (MemoryType) {
     MemoryType["ACTION"] = "action";

package/dist/utils/queue-item-transformer.d.ts

@@ -1,7 +1,7 @@
-import { ActionData, TransformedQueueItem } from "../types";
+import { ActionData, QueueResult, TransformedQueueItem } from "../types";
 export declare class QueueItemTransformer {
     static transformActionToQueueItem(action: ActionData): TransformedQueueItem;
-    static transformFromSimilarActions(similarActions: any[]): TransformedQueueItem[] | undefined;
+    static transformFromSimilarActions(similarActions: QueueResult[]): TransformedQueueItem[] | undefined;
     private static transformParameters;
     static transformActionsToQueueItems(actions: ActionData[] | undefined): TransformedQueueItem[] | undefined;
 }

package/dist/utils/queue-item-transformer.js

@@ -4,22 +4,21 @@ exports.QueueItemTransformer = void 0;
 class QueueItemTransformer {
     static transformActionToQueueItem(action) {
         return {
-            name: action.name || '',
-            parameters: QueueItemTransformer.transformParameters(action.parameters || {})
+            name: action.name || "",
+            parameters: QueueItemTransformer.transformParameters(action.parameters || {}),
         };
     }
     static transformFromSimilarActions(similarActions) {
-        const firstMatch = similarActions?.[0]?.data;
-        return firstMatch?.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
+        return similarActions?.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
     }
     static transformParameters(parameters) {
         return Object.entries(parameters).map(([name, value]) => ({
             name,
-            value: typeof value === 'object' ? JSON.stringify(value) : String(value)
+            value: typeof value === "object" ? JSON.stringify(value) : String(value),
         }));
     }
     static transformActionsToQueueItems(actions) {
-        return actions?.map(action => this.transformActionToQueueItem(action));
+        return actions?.map((action) => this.transformActionToQueueItem(action));
     }
 }
 exports.QueueItemTransformer = QueueItemTransformer;

package/dist/utils/sanitize-results.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility class to sanitize JSON results for evaluation
+ */
+export declare class ResultSanitizer {
+    /**
+     * Sanitizes JSON results by removing special characters and formatting
+     * @param results - The results to sanitize
+     * @returns Sanitized string
+     */
+    static sanitize(results: any): string;
+    /**
+     * Formats numbers to a consistent format
+     * @param value - The number to format
+     * @returns Formatted number string
+     */
+    private static formatNumber;
+}

package/dist/utils/sanitize-results.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultSanitizer = void 0;
+/**
+ * Utility class to sanitize JSON results for evaluation
+ */
+class ResultSanitizer {
+    /**
+     * Sanitizes JSON results by removing special characters and formatting
+     * @param results - The results to sanitize
+     * @returns Sanitized string
+     */
+    static sanitize(results) {
+        if (!results)
+            return "";
+        try {
+            const jsonString = JSON.stringify(results);
+            return (jsonString
+                // Basic cleanup
+                .replace(/\\n/g, " ") // Remove newlines
+                .replace(/\s+/g, " ") // Remove extra spaces
+                .replace(/\\"/g, '"') // Fix escaped quotes
+                .replace(/\\+/g, "") // Remove extra backslashes
+                // Remove unnecessary quotes around objects and arrays
+                .replace(/"\[/g, "[") // Remove quotes around arrays start
+                .replace(/\]"/g, "]") // Remove quotes around arrays end
+                .replace(/"{/g, "{") // Remove quotes around objects start
+                .replace(/}"/g, "}") // Remove quotes around objects end
+                // Clean up numbers and values
+                .replace(/"(\d+\.?\d*)"/g, "$1") // Remove quotes around numbers
+                .replace(/:\s*"(true|false|null)"/g, ": $1") // Remove quotes around booleans and null
+                // Clean up URLs and content
+                .replace(/(?<=content":")([^"]+)(?=")/g, (match) => match.trim().replace(/\s+/g, " ") // Clean content spacing
+            )
+                .replace(/(?<=link":")([^"]+)(?=")/g, (match) => match.replace(/&amp;/g, "&") // Fix URL encodings
+            )
+                // Final cleanup
+                .replace(/,\s*([}\]])/g, "$1") // Remove trailing commas
+                .replace(/:\s+/g, ":") // Remove spaces after colons
+                .replace(/,\s+/g, ",") // Remove spaces after commas
+                .trim()); // Remove leading/trailing whitespace
+        }
+        catch (error) {
+            console.error("Error sanitizing results:", error);
+            return String(results);
+        }
+    }
+    /**
+     * Formats numbers to a consistent format
+     * @param value - The number to format
+     * @returns Formatted number string
+     */
+    static formatNumber(value) {
+        return value.toLocaleString("en-US", {
+            maximumFractionDigits: 2,
+            useGrouping: false,
+        });
+    }
+}
+exports.ResultSanitizer = ResultSanitizer;

package/llm/evaluator/context.ts

@@ -1,39 +1,43 @@
 import { ActionSchema } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
-
 export const evaluatorContext = {
   role: "You are the evaluator agent. Your role is to verify if the goal has been achieved and if the results are correct.",
   guidelines: {
     important: [
-      "Verify if all required actions were executed successfully",
-      "Check if the results match the initial goal",
-      "Identify any missing or incomplete information",
-      "Examples of relavant information: link symbol to token address, name to wallet, etc.",
+      "Verify if all required actions were executed successfully.",
+      "Check if the results align with the initial goal.",
+      "Identify and extract additional relevant information naturally during the process. Examples:",
+      "  - Link a token symbol (e.g., 'USDC') to its address (e.g., '0xA0b8...6EB48').",
+      "  - Associate a wallet address (e.g., '0x1234...abcd') to a user-friendly name (e.g., 'Work Wallet').",
+      "  - Map a token address (e.g., '0x6B17...71d0F') back to its symbol or name (e.g., 'DAI').",
+      "Store these facts in memory with their type (episodic, semantic, or procedural).",
     ],
     warnings: [
-      "NEVER modify the results directly",
-      "NEVER make assumptions about missing data",
-      "NEVER repeat the same action if you already did it",
+      "NEVER modify the results directly.",
+      "NEVER make assumptions about missing data.",
+      "NEVER repeat actions already completed unless explicitly required.",
     ],
   },
   compose: (goal: string, results: string, tools: ActionSchema[]) => {
     return `
-      ${JSON.stringify(evaluatorContext.guidelines)}
-
-      ACTIONS COMPLETED: ${results}
-
-      Initial Goal: ${goal} (You must use the same language)
-
-      The actions available are: ${injectActions(tools)}
-
-      Evaluate if the goal has been achieved and provide:
-      1. Success status with explanation (no action needed)
-      2. Next actions needed (if any)
-      3. Why you are doing the next actions or why you are not doing them
-      4. Extract relevant information to remember. No need to remember specific numbers.
-      5. If there are no important results, let importantToRemembers be empty. No need to say something like "No relevant information found".
-      6. For each facts, generate a hypothetical query to search in the persistent memory.
-      7. For each facts, generate a memoryType (You have 3 memory types: episodic, semantic, procedural)
-    `;
+        You are evaluating if the following goal has been achieved: "${goal}".
+  
+        COMPLETED ACTIONS: ${results}
+  
+        The tools available are: ${injectActions(tools)}
+  
+        Follow these steps to evaluate:
+        1. Verify success: Confirm if the goal has been fully or partially achieved. If partially, describe what's missing.
+        2. Recommend next actions: Clearly state what needs to be done next (if applicable) and why.
+        3. Extract relevant information:
+           - Example: Link token symbols to addresses, map wallet names to addresses, or connect tokens to specific networks.
+           - For each fact, specify its memory type:
+             - **Episodic**: Record specific events. Format: [{"type": "episodic", "query": "query", "event": "event", "description": "description"}]
+             - **Semantic**: Store general knowledge. Format: [{"knowledge": "knowledge", "link": "link", "type": "semantic", "description": "description"}]
+             - **Procedural**: Save recurring workflows. Format: [{"type": "procedural", "actions": [{"name": "action_name", "parameters": {"param1": "value1", "param2": "value2"}}]]
+        4. Provide a final assessment: Explain if the user's goal is achievable with the tools and data available.
+  
+        Be clear, concise, and prioritize storing key facts that may help improve future interactions.
+      `;
   },
 };

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/index.ts

@@ -21,19 +21,21 @@ export class Orchestrator implements BaseLLM {
           query: z.string(),
         }),
         execute: async ({ query }: { query: string }) => {
-          const memories = await this.memory.searchSimilarQueries(query);
+          const memories = await this.memory.searchSimilarQueries(query, {
+            similarityThreshold: 95,
+          });
           return memories;
         },
       },
       {
         name: "save_memory",
-        description: "Save a query in the internal knowledge base",
+        description: "Save relevant information in the internal knowledge base",
         parameters: z.object({
           query: z.string(),
-          purpose: z.string(),
+          memoryType: z.string(),
           data: z.any(),
-          scope: z.enum(["GLOBAL", "USER"]),
-          userId: z.string().optional(),
+          scope: z.string().default("GLOBAL").describe("GLOBAL or USER"),
+          userId: z.string(),
           whyStored: z.string(),
         }),
         execute: async ({
@@ -49,7 +51,7 @@ export class Orchestrator implements BaseLLM {
           scope: MemoryScopeType;
           userId?: string;
         }) => {
-          const memories = await this.memory.storeMemory({
+          const memories = await this.memory.createMemory({
             query,
             purpose,
             data,
@@ -69,17 +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.array(
-                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,
@@ -86,15 +85,10 @@ export class CacheMemory {
       .map((memory) => {
         const similarity = cosineSimilarity(embedding, memory.embedding);
         const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
-
-        console.log(`\n📊 Query "${memory.query}":
-        - Similarity: ${similarityPercentage.toFixed(2)}%`);
-
         return {
           data: memory.data,
           query: memory.query,
           similarityPercentage,
-          // Optionnel : ajouter des métadonnées utiles
           memoryId: memory.id,
         };
       })
@@ -119,7 +113,6 @@ export class CacheMemory {
       console.log("No matches found");
     }
 
-    console.dir({ results });
     return results;
   }
 
@@ -161,7 +154,7 @@ export class CacheMemory {
 
   public async createMemory(
     input: CreateMemoryInput
-  ): Promise<string | undefined> {
+  ): Promise<CacheMemoryType | undefined> {
     console.log("Searching for similar memory", input);
     const existingPattern = await this.findSimilarQueries(input.content, {
       similarityThreshold: 95,
@@ -182,22 +175,7 @@ export class CacheMemory {
 
     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({
-        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 way to ask the same question.
-        Action results: ${JSON.stringify(input.data)}
-        - Keep variations natural and human-like
-        - Add 3-5 variations`,
-    });
-    console.log("Variations generated:", variations.object.queries);
-    await this.createSingleMemory({
+    const memory = await this.createSingleMemory({
       id: crypto.randomUUID(),
       content: input.content,
       type: input.type,
@@ -206,23 +184,7 @@ export class CacheMemory {
       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,
-            userId: input.userId,
-            scope: input.scope,
-          });
-        }
-      }
-    );
-
-    await Promise.all(variationPromises);
-    return variations.object.request;
+    return memory;
   }
 
   private async createSingleMemory(params: {

package/memory/persistent.ts

@@ -159,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);
 
@@ -178,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;
   }
 
@@ -273,7 +273,7 @@ export class PersistentMemory {
 
     // Log results
     if (results.length > 0) {
-      console.log("\n✨ Similar queries 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.83",
+  "version": "0.1.85",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/types.ts

@@ -128,7 +128,7 @@ export interface CacheMemoryOptions {
 export interface CreateMemoryInput {
   content: any;
   type: MemoryType;
-  data: ActionSchema[];
+  data: QueueResult[];
   userId?: string;
   scope?: MemoryScope;
 }
@@ -168,6 +168,18 @@ export interface Memory {
   chunks?: MemoryChunk[];
 }
 
+export const ActionSchema = z.array(
+  z.object({
+    name: z.string(),
+    parameters: z.array(
+      z.object({
+        name: z.string(),
+        value: z.string(),
+      })
+    ),
+  })
+);
+
 export enum MemoryType {
   ACTION = "action",
   CONVERSATION = "conversation",