@ai.ntellect/core 0.1.81 → 0.1.84

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.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const fetchMarkPrice: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        symbol: z.ZodString;
+        params: z.ZodObject<{
+            subType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            subType: string;
+        }, {
+            subType: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        params: {
+            subType: string;
+        };
+    }, {
+        symbol: string;
+        params: {
+            subType: string;
+        };
+    }>;
+    execute: ({ symbol, params }: {
+        symbol: string;
+        params: any;
+    }) => Promise<import("ccxt").Ticker>;
+};
+export declare const getChainsTVL: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+    }, {
+        limit?: number | undefined;
+    }>;
+    execute: ({ limit }: {
+        limit: number;
+    }) => Promise<{
+        summary: {
+            totalTVL: number;
+            numberOfChains: number;
+        };
+        topChains: {
+            name: string;
+            tvl: number;
+            tokenSymbol: string | null;
+        }[];
+    }>;
+};
+export declare const getRssNews: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute: () => Promise<{
+        status: string;
+        items: {
+            title: any;
+            content: string;
+            link: any;
+            date: any;
+            source: any;
+        }[];
+    }>;
+};

package/dist/test.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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",
+    parameters: zod_1.z.object({
+        limit: zod_1.z
+            .number()
+            .optional()
+            .default(10)
+            .describe("Number of top chains to return (default: 10)"),
+    }),
+    execute: async ({ limit }) => {
+        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());
+            // 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.message}`);
+        }
+    },
+};
+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)
+        return "";
+    return content
+        .replace(/<[^>]*>/g, "")
+        .replace(/\n/g, "")
+        .replace(" ", "");
+}
+exports.getRssNews = {
+    name: "get-news-rss",
+    description: "Get latest news about on website",
+    parameters: zod_1.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) => {
+                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) {
+            throw error;
+        }
+    },
+};
+(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([exports.getRssNews, exports.getChainsTVL, exports.fetchMarkPrice], memory);
+    const agent = new agent_1.Agent({
+        user: {
+            id: "1",
+        },
+        orchestrator,
+        cacheMemory,
+        persistentMemory: memory,
+        stream: false,
+        maxEvaluatorIteration: 1,
+    });
+    const prompt = "analyse le ai16z";
+    const context = prompt;
+    // 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: QueueResult[];
     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;
@@ -136,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/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/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/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/evaluator/context.ts

@@ -8,7 +8,7 @@ export const evaluatorContext = {
       "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.",
+      "Extra and relevant information they don't have be stored in the memory: link symbol to token address, name to wallet, etc.",
     ],
     warnings: [
       "NEVER modify the results directly",
@@ -30,10 +30,8 @@ export const evaluatorContext = {
       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)
+      4. Extract relevant information to remember
+      5. For each facts, generate a memoryType (3 memory types: episodic, semantic, procedural)
     `;
   },
 };