@ai.ntellect/core 0.1.97 → 0.1.99

package/dist/agent/index.d.ts

@@ -1,10 +1,26 @@
 import { Orchestrator } from "../llm/orchestrator";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { AgentEvent, User } from "../types";
+import { ActionSchema, AgentEvent, QueueResult, User } from "../types";
+export type State = {
+    behavior: {
+        role: string;
+        language: string;
+        guidelines: {
+            important: string[];
+            warnings: string[];
+            steps?: string[];
+        };
+    };
+    userRequest: string;
+    actions: ActionSchema[];
+    results: QueueResult[];
+    examplesMessages?: {
+        role: string;
+        content: string;
+    }[];
+};
 export declare class Agent {
-    private readonly SIMILARITY_THRESHOLD;
-    private readonly MAX_RESULTS;
     private readonly actionHandler;
     private readonly user;
     private readonly orchestrator;
@@ -22,7 +38,7 @@ export declare class Agent {
         stream: boolean;
         maxEvaluatorIteration: number;
     });
-    process(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
+    process(prompt: string, events: AgentEvent): Promise<any>;
     private handleActions;
     private handleActionResults;
     private transformActions;

package/dist/agent/index.js

@@ -9,8 +9,6 @@ const sanitize_results_1 = require("../utils/sanitize-results");
 const ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
     constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration = 1, }) {
-        this.SIMILARITY_THRESHOLD = 95;
-        this.MAX_RESULTS = 1;
         this.evaluatorIteration = 0;
         this.accumulatedResults = [];
         this.user = user;
@@ -22,37 +20,25 @@ class Agent {
         this.actionHandler = new ActionHandler_1.ActionHandler();
         this.accumulatedResults = [];
     }
-    async process(prompt, contextualizedPrompt, events) {
-        let actions = undefined;
-        let isSimilar = false;
-        if (this.cacheMemory) {
-            const similarActions = await this.cacheMemory.findSimilarQueries(prompt, {
-                similarityThreshold: this.SIMILARITY_THRESHOLD,
-                maxResults: this.MAX_RESULTS,
-                userId: this.user.id,
-                scope: types_1.MemoryScope.GLOBAL,
-            });
-            if (similarActions.length > 0) {
-                actions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(similarActions[0].data);
-                isSimilar = true;
-            }
-        }
-        if (!actions?.length && !isSimilar) {
-            console.log("No similar actions found in cache for query: ", prompt);
-            console.log("Requesting orchestrator for actions..");
-            const request = await this.orchestrator.process(contextualizedPrompt);
-            events.onMessage?.(request);
-            actions = request.actions;
+    async process(prompt, events) {
+        console.log("Requesting orchestrator for actions..");
+        const request = await this.orchestrator.process(prompt, this.accumulatedResults);
+        events.onMessage?.(request);
+        const isOnChainAction = request.actions.some((action) => action.type === "on-chain");
+        if (isOnChainAction) {
+            return {
+                data: this.accumulatedResults,
+                initialPrompt: prompt,
+            };
         }
-        return actions && actions.length > 0
+        return request.actions.length > 0
             ? this.handleActions({
                 initialPrompt: prompt,
-                contextualizedPrompt: contextualizedPrompt,
-                actions: actions,
+                actions: request.actions,
             }, events)
             : undefined;
     }
-    async handleActions({ initialPrompt, contextualizedPrompt, actions, }, events) {
+    async handleActions({ initialPrompt, actions, }, events) {
         const queueItems = this.transformActions(actions);
         const actionsResult = await this.actionHandler.executeActions(queueItems, this.orchestrator.tools, {
             onQueueStart: events.onQueueStart,
@@ -74,23 +60,16 @@ class Agent {
         const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.persistentMemory);
         console.log("Accumulated results:");
         console.dir(this.accumulatedResults, { depth: null });
-        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(this.accumulatedResults);
-        const evaluation = await evaluator.process(initialPrompt, contextualizedPrompt, sanitizedResults);
+        // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
+        const evaluation = await evaluator.process(initialPrompt, this.accumulatedResults);
         events.onMessage?.(evaluation);
         if (evaluation.isNextActionNeeded) {
             this.evaluatorIteration++;
             return this.handleActions({
-                initialPrompt: contextualizedPrompt,
-                contextualizedPrompt: initialPrompt,
+                initialPrompt: initialPrompt,
                 actions: evaluation.nextActionsNeeded,
             }, events);
         }
-        if (!this.actionHandler.hasNonPrepareActions(this.accumulatedResults)) {
-            return {
-                data: this.accumulatedResults,
-                initialPrompt,
-            };
-        }
         return this.handleActionResults({
             data: this.accumulatedResults,
             initialPrompt,
@@ -101,19 +80,22 @@ class Agent {
         const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(this.accumulatedResults);
         const summaryData = JSON.stringify({
             result: sanitizedResults,
-            initialPrompt: actionsResult.initialPrompt,
         });
         this.accumulatedResults = [];
         this.evaluatorIteration = 0;
-        await this.cacheMemory?.createMemory({
-            content: actionsResult.initialPrompt,
-            data: actionsResult.data,
-            scope: types_1.MemoryScope.GLOBAL,
-            type: types_1.MemoryType.ACTION,
-        });
+        for (const action of actionsResult.data) {
+            if (!action.error) {
+                await this.cacheMemory?.createMemory({
+                    content: actionsResult.initialPrompt,
+                    data: action.result,
+                    scope: types_1.MemoryScope.GLOBAL,
+                    type: types_1.MemoryType.ACTION,
+                });
+            }
+        }
         return this.stream
-            ? (await synthesizer.streamProcess(summaryData)).toDataStreamResponse()
-            : await synthesizer.process(summaryData);
+            ? (await synthesizer.streamProcess(actionsResult.initialPrompt, summaryData)).toDataStreamResponse()
+            : await synthesizer.process(actionsResult.initialPrompt, this.accumulatedResults);
     }
     transformActions(actions) {
         let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];

package/dist/llm/evaluator/context.d.ts

@@ -1,9 +1,11 @@
-import { ActionSchema } from "../../types";
 export declare const evaluatorContext: {
-    role: string;
-    guidelines: {
-        important: string[];
-        warnings: string[];
+    behavior: {
+        language: string;
+        role: string;
+        guidelines: {
+            important: string[];
+            warnings: string[];
+            steps: string[];
+        };
     };
-    compose: (goal: string, results: string, tools: ActionSchema[]) => string;
 };

package/dist/llm/evaluator/context.js

@@ -1,38 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluatorContext = void 0;
-const inject_actions_1 = require("../../utils/inject-actions");
 exports.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",
-            "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",
-            "NEVER make assumptions about missing data",
-            "NEVER repeat the same action if you already did it",
-        ],
-    },
-    compose: (goal, results, tools) => {
-        return `
-      ${JSON.stringify(exports.evaluatorContext.guidelines)}
-
-      ACTIONS COMPLETED: ${results}
-
-      Initial Goal: ${goal} (You must use the same language)
-
-      The actions available are: ${(0, inject_actions_1.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
-      5. For each facts, generate a memoryType (3 memory types: episodic, semantic, procedural)
-    `;
+    behavior: {
+        language: "user_language",
+        role: "Your role is to verify if the goal has been achieved and make a response or suggest next actions.",
+        guidelines: {
+            important: [
+                "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 actions already completed unless explicitly required.",
+            ],
+            steps: [
+                "Verify success: Confirm if the goal has been fully or partially achieved. If partially, describe what's missing.",
+                "Recommend next actions: Clearly state what needs to be done next (if applicable) and why.",
+                "Store key facts: Store any relevant information in memory with their type (episodic, semantic, or procedural).",
+                "Be clear, concise, and prioritize storing key facts that may help improve future interactions.",
+            ],
+        },
     },
 };

package/dist/llm/evaluator/index.d.ts

@@ -1,9 +1,11 @@
+import { State } from "../../agent";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema } from "../../types";
+import { ActionSchema, QueueResult } from "../../types";
 export declare class Evaluator {
     private readonly model;
     tools: ActionSchema[];
     private memory;
     constructor(tools: ActionSchema[], memory: PersistentMemory);
-    process(prompt: string, goal: string, results: string): Promise<any>;
+    composeContext(state: State): string;
+    process(prompt: string, results: QueueResult[]): Promise<any>;
 }

package/dist/llm/evaluator/index.js

@@ -5,6 +5,7 @@ const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
 const types_1 = require("../../types");
+const inject_actions_1 = require("../../utils/inject-actions");
 const context_1 = require("./context");
 class Evaluator {
     constructor(tools, memory) {
@@ -12,24 +13,56 @@ class Evaluator {
         this.tools = tools;
         this.memory = memory;
     }
-    async process(prompt, goal, results) {
+    composeContext(state) {
+        const { behavior, userRequest, actions, results } = state;
+        const { role, language, guidelines } = behavior;
+        const { important, warnings, steps } = guidelines;
+        const context = `
+      # ROLE: ${role}
+      # LANGUAGE: ${language}
+      # IMPORTANT: ${important.join("\n")}
+      # NEVER: ${warnings.join("\n")}
+      # USER_REQUEST: ${userRequest}
+      # ACTIONS AVAILABLE: ${(0, inject_actions_1.injectActions)(actions)}
+      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # STEPS: ${steps?.join("\n") || ""}
+    `;
+        return context;
+    }
+    async process(prompt, results) {
         try {
+            const context = this.composeContext({
+                behavior: context_1.evaluatorContext.behavior,
+                userRequest: prompt,
+                actions: this.tools,
+                results: results,
+            });
+            console.log("\n🔍 Evaluator processing");
+            console.log("Goal:", prompt);
+            console.log("Results to evaluate:", JSON.stringify(results, null, 2));
             const response = await (0, ai_1.generateObject)({
                 model: this.model,
                 schema: zod_1.z.object({
                     isRemindNeeded: zod_1.z.boolean(),
-                    extraInformationsToRemember: zod_1.z.array(zod_1.z.object({
+                    importantToRemembers: zod_1.z.array(zod_1.z.object({
                         memoryType: zod_1.z.string(),
                         content: zod_1.z.string(),
                         data: zod_1.z.string(),
                     })),
                     response: zod_1.z.string(),
                     isNextActionNeeded: zod_1.z.boolean(),
-                    nextActionsNeeded: types_1.ActionSchema,
+                    nextActionsNeeded: 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.any(),
+                        })),
+                    })),
                     why: zod_1.z.string(),
                 }),
                 prompt: prompt,
-                system: context_1.evaluatorContext.compose(goal, results, this.tools),
+                system: context,
+                temperature: 0,
             });
             const validatedResponse = {
                 ...response.object,
@@ -39,44 +72,42 @@ class Evaluator {
                 })),
             };
             if (validatedResponse.isRemindNeeded) {
-                for (const item of validatedResponse.extraInformationsToRemember) {
-                    // Check if the item is already in the memory
+                console.log("\n💭 Processing important memories to store", validatedResponse);
+                for (const item of validatedResponse.importantToRemembers) {
+                    console.log("\n📝 Processing memory item:");
+                    console.log("Type:", item.memoryType);
+                    console.log("Content:", item.content);
                     const memories = await this.memory.searchSimilarQueries(item.content, {
                         similarityThreshold: 95,
                     });
                     if (memories.length > 0) {
-                        console.log("Similar memorie found, no need to remember", {
-                            memories,
-                        });
+                        console.log("🔄 Similar memory already exists - skipping");
                         continue;
                     }
-                    if (memories.length === 0) {
-                        console.log("Adding to memory", {
-                            query: item.content,
-                            data: item.data,
-                        });
-                        await this.memory.createMemory({
-                            id: crypto.randomUUID(),
-                            purpose: item.memoryType,
-                            query: item.content,
-                            data: item.data,
-                            scope: types_1.MemoryScope.GLOBAL,
-                            createdAt: new Date(),
-                        });
-                    }
+                    console.log("✨ Storing new memory");
+                    await this.memory.createMemory({
+                        id: crypto.randomUUID(),
+                        purpose: item.memoryType,
+                        query: item.content,
+                        data: item.data,
+                        scope: types_1.MemoryScope.GLOBAL,
+                        createdAt: new Date(),
+                    });
                 }
             }
-            console.log("Evaluator response");
-            console.dir(validatedResponse, { depth: null });
+            console.log("\n✅ Evaluation completed");
+            console.log("─".repeat(50));
+            console.log("Results:", JSON.stringify(validatedResponse, null, 2));
             return validatedResponse;
         }
         catch (error) {
+            console.error("\n❌ Evaluator error:", error.message);
             if (error) {
                 console.log("Evaluator error");
                 console.dir(error.value, { depth: null });
                 console.error(error.message);
-                if (error.value.extraInformationsToRemember.length > 0) {
-                    for (const item of error.value.extraInformationsToRemember) {
+                if (error.value.importantToRemembers.length > 0) {
+                    for (const item of error.value.importantToRemembers) {
                         // Check if the item is already in the memory
                         const memories = await this.memory.searchSimilarQueries(item.content);
                         if (memories.length === 0) {

package/dist/llm/orchestrator/context.d.ts

@@ -1,9 +1,10 @@
-import { ActionSchema } from "../../types";
 export declare const orchestratorContext: {
-    role: string;
-    guidelines: {
-        important: string[];
-        warnings: string[];
+    behavior: {
+        language: string;
+        role: string;
+        guidelines: {
+            important: string[];
+            warnings: never[];
+        };
     };
-    compose: (tools: ActionSchema[]) => string;
 };

package/dist/llm/orchestrator/context.js

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratorContext = void 0;
-const inject_actions_1 = require("../../utils/inject-actions");
 exports.orchestratorContext = {
-    role: "You are the orchestrator agent. Your role is to determine what actions are needed to achieve the user goal.",
-    guidelines: {
-        important: [
-            "If there is no action to do, you must answer in the 'answer' field.",
-            "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.",
-        ],
-        warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
-    },
-    compose: (tools) => {
-        return `
-            ${JSON.stringify(exports.orchestratorContext.guidelines)}
-
-            The actions are: ${(0, inject_actions_1.injectActions)(tools)}
-        `;
+    behavior: {
+        language: "user_language",
+        role: "You are the orchestrator agent. Your role is to determine what actions are needed to achieve the user goal.",
+        guidelines: {
+            important: [
+                "If there is no action to do, you must answer in the 'answer' field.",
+                "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 ON-CHAIN actions, just use the useful actions.",
+                "For QUESTIONS or ANALYSIS, you CAN search in memory and internal knowledge base.",
+                "NEVER repeat same actions if the user doesn't ask for it.",
+            ],
+            warnings: [],
+        },
     },
 };

package/dist/llm/orchestrator/index.d.ts

@@ -1,9 +1,26 @@
+import { State } from "../../agent";
+import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, BaseLLM } from "../../types";
-export declare class Orchestrator implements BaseLLM {
+import { ActionSchema, QueueResult } from "../../types";
+export declare class Orchestrator {
     private readonly model;
     tools: ActionSchema[];
     private memory;
-    constructor(tools: ActionSchema[], memory: PersistentMemory);
-    process(prompt: string): Promise<any>;
+    private id;
+    constructor(id: string, tools: ActionSchema[], memory: {
+        persistent: PersistentMemory;
+        cache: CacheMemory;
+    });
+    composeContext(state: State): string;
+    process(prompt: string, results: QueueResult[]): Promise<{
+        actions: {
+            name: string;
+            type: string;
+            parameters: {
+                name: string;
+                value: any;
+            }[];
+        }[];
+        answer: string;
+    }>;
 }

package/dist/llm/orchestrator/index.js

@@ -5,24 +5,42 @@ const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
 const types_1 = require("../../types");
+const inject_actions_1 = require("../../utils/inject-actions");
 const context_1 = require("./context");
 class Orchestrator {
-    constructor(tools, memory) {
+    constructor(id, tools, memory) {
         this.model = (0, openai_1.openai)("gpt-4o");
+        this.id = id;
         this.memory = memory;
         this.tools = [
             ...tools,
             {
-                name: "search_memory",
+                name: "search_internal_knowledge_base",
                 description: "Search for relevant information in the internal knowledge base",
                 parameters: zod_1.z.object({
                     query: zod_1.z.string(),
                 }),
                 execute: async ({ query }) => {
-                    const memories = await this.memory.searchSimilarQueries(query, {
-                        similarityThreshold: 95,
+                    const persistentMemories = await this.memory.persistent.searchSimilarQueries(query, {
+                        similarityThreshold: 70,
                     });
-                    return memories;
+                    return persistentMemories;
+                },
+            },
+            {
+                name: "search_cache_memory",
+                description: "Search for relevant information in the cache",
+                parameters: zod_1.z.object({
+                    query: zod_1.z.string(),
+                }),
+                execute: async ({ query }) => {
+                    const cacheMemories = await this.memory.cache.findSimilarQueries(query, {
+                        similarityThreshold: 70,
+                        maxResults: 1,
+                        userId: this.id,
+                        scope: types_1.MemoryScope.GLOBAL,
+                    });
+                    return cacheMemories;
                 },
             },
             {
@@ -37,7 +55,7 @@ class Orchestrator {
                     whyStored: zod_1.z.string(),
                 }),
                 execute: async ({ query, purpose, data, scope, userId, }) => {
-                    const memories = await this.memory.createMemory({
+                    const memories = await this.memory.persistent.createMemory({
                         query,
                         purpose,
                         data,
@@ -51,38 +69,79 @@ class Orchestrator {
             },
         ];
     }
-    async process(prompt) {
+    composeContext(state) {
+        const { behavior, userRequest, actions, results } = state;
+        const { role, language, guidelines } = behavior;
+        const { important, warnings } = guidelines;
+        const context = `
+      # ROLE: ${role}
+      # LANGUAGE: ${language}
+      # IMPORTANT: ${important.join("\n")}
+      # USER_REQUEST: ${userRequest}
+      # ACTIONS_AVAILABLES: ${(0, inject_actions_1.injectActions)(actions)} (NEVER REPEAT ACTIONS)
+      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+    `.trim();
+        return context;
+    }
+    async process(prompt, results) {
+        const state = this.composeContext({
+            behavior: context_1.orchestratorContext.behavior,
+            userRequest: prompt,
+            actions: this.tools,
+            results: results,
+        });
         try {
+            console.log("\n🎭 Orchestrator processing");
+            console.log("Prompt:", prompt);
             const response = await (0, ai_1.generateObject)({
                 model: this.model,
                 schema: zod_1.z.object({
-                    actions: types_1.ActionSchema,
+                    actions: zod_1.z.array(zod_1.z.object({
+                        name: zod_1.z.string(),
+                        type: zod_1.z.enum(["on-chain", "off-chain", "question", "analysis"]),
+                        parameters: zod_1.z.array(zod_1.z.object({
+                            name: zod_1.z.string(),
+                            value: zod_1.z.any(),
+                        })),
+                    })),
                     answer: zod_1.z.string(),
                 }),
                 prompt: prompt,
-                system: context_1.orchestratorContext.compose(this.tools),
+                system: state,
+                temperature: 0,
             });
             const validatedResponse = {
                 ...response.object,
                 actions: response.object.actions.map((action) => ({
                     ...action,
-                    parameters: action.parameters || {},
+                    parameters: Array.isArray(action.parameters)
+                        ? action.parameters.map((param) => ({
+                            name: param.name,
+                            value: param.value ?? null,
+                        }))
+                        : Object.entries(action.parameters || {}).map(([name, value]) => ({
+                            name,
+                            value: value ?? null,
+                        })),
                 })),
             };
-            console.log("Orchestrator response");
-            console.dir(validatedResponse, { depth: null });
+            console.log("\n✅ Orchestration completed");
+            console.log("─".repeat(50));
+            console.log("Actions determined:", validatedResponse.actions.map((a) => {
+                return `${a.name} (${a.type})`;
+            }));
+            if (validatedResponse.answer) {
+                console.log("Response:", validatedResponse.answer);
+            }
             return validatedResponse;
         }
         catch (error) {
-            if (error) {
-                console.log("Orchestrator response");
-                console.dir(error.value, { depth: null });
-                console.error(error.message);
-                return {
-                    ...error.value,
-                };
+            console.error("\n❌ Orchestrator error:", error.message);
+            if (error?.value) {
+                console.log("Partial response:", JSON.stringify(error.value, null, 2));
+                return { ...error.value };
             }
-            // throw error;
+            throw error;
         }
     }
 }