@ai.ntellect/core 0.1.91 → 0.1.92

package/agent/index.ts

@@ -9,16 +9,32 @@ import {
   MemoryScope,
   MemoryType,
   QueueResult,
-  TransformedQueueItem,
   User,
 } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
 import { ResultSanitizer } from "../utils/sanitize-results";
 import { ActionHandler } from "./handlers/ActionHandler";
 
+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 class Agent {
-  private readonly SIMILARITY_THRESHOLD = 95;
-  private readonly MAX_RESULTS = 1;
   private readonly actionHandler: ActionHandler;
   private readonly user: User;
   private readonly orchestrator: Orchestrator;
@@ -54,45 +70,19 @@ export class Agent {
     this.accumulatedResults = [];
   }
 
-  async process(
-    prompt: string,
-    contextualizedPrompt: string,
-    events: AgentEvent
-  ): Promise<any> {
-    let actions: ActionSchema[] | TransformedQueueItem[] | undefined =
-      undefined;
-    let isSimilar: boolean = false;
-
-    if (this.cacheMemory) {
-      const similarActions = await this.cacheMemory.findSimilarQueries(prompt, {
-        similarityThreshold: this.SIMILARITY_THRESHOLD,
-        maxResults: this.MAX_RESULTS,
-        userId: this.user.id,
-        scope: MemoryScope.GLOBAL,
-      });
-
-      if (similarActions.length > 0) {
-        actions = 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: string, events: AgentEvent): Promise<any> {
+    console.log("Requesting orchestrator for actions..");
+    const request = await this.orchestrator.process(
+      prompt,
+      this.accumulatedResults
+    );
+    events.onMessage?.(request);
 
-    return actions && actions.length > 0
+    return request.actions.length > 0
       ? this.handleActions(
           {
             initialPrompt: prompt,
-            contextualizedPrompt: contextualizedPrompt,
-            actions: actions as ActionSchema[],
+            actions: request.actions as ActionSchema[],
           },
           events
         )
@@ -102,11 +92,9 @@ export class Agent {
   private async handleActions(
     {
       initialPrompt,
-      contextualizedPrompt,
       actions,
     }: {
       initialPrompt: string;
-      contextualizedPrompt: string;
       actions: ActionSchema[];
     },
     events: AgentEvent
@@ -144,11 +132,10 @@ export class Agent {
     console.log("Accumulated results:");
     console.dir(this.accumulatedResults, { depth: null });
 
-    const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
+    // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
     const evaluation = await evaluator.process(
       initialPrompt,
-      contextualizedPrompt,
-      sanitizedResults
+      this.accumulatedResults
     );
 
     events.onMessage?.(evaluation);
@@ -157,8 +144,7 @@ export class Agent {
       this.evaluatorIteration++;
       return this.handleActions(
         {
-          initialPrompt: contextualizedPrompt,
-          contextualizedPrompt: initialPrompt,
+          initialPrompt: initialPrompt,
           actions: evaluation.nextActionsNeeded,
         },
         events
@@ -191,12 +177,16 @@ export class Agent {
     this.accumulatedResults = [];
     this.evaluatorIteration = 0;
 
-    await this.cacheMemory?.createMemory({
-      content: actionsResult.initialPrompt,
-      data: actionsResult.data,
-      scope: MemoryScope.GLOBAL,
-      type: MemoryType.ACTION,
-    });
+    for (const action of actionsResult.data) {
+      if (!action.error) {
+        await this.cacheMemory?.createMemory({
+          content: actionsResult.initialPrompt,
+          data: action.result,
+          scope: MemoryScope.GLOBAL,
+          type: MemoryType.ACTION,
+        });
+      }
+    }
 
     return this.stream
       ? (
@@ -205,7 +195,10 @@ export class Agent {
             summaryData
           )
         ).toDataStreamResponse()
-      : await synthesizer.process(actionsResult.initialPrompt, summaryData);
+      : await synthesizer.process(
+          actionsResult.initialPrompt,
+          this.accumulatedResults
+        );
   }
 
   private transformActions(actions: ActionSchema[]) {

package/llm/evaluator/context.ts

@@ -1,43 +1,28 @@
-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 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.",
-    ],
-  },
-  compose: (goal: string, results: string, tools: ActionSchema[]) => {
-    return `
-        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.
-      `;
+  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/llm/evaluator/index.ts

@@ -1,8 +1,10 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
+import { State } from "../../agent";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope } from "../../types";
+import { ActionSchema, MemoryScope, QueueResult } from "../../types";
+import { injectActions } from "../../utils/inject-actions";
 import { evaluatorContext } from "./context";
 
 export class Evaluator {
@@ -15,13 +17,43 @@ export class Evaluator {
     this.memory = memory;
   }
 
-  async process(prompt: string, goal: string, results: string): Promise<any> {
+  composeContext(state: 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: ${injectActions(actions)}
+      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # STEPS: ${steps?.join("\n") || ""}
+    `;
+
+    return context;
+  }
+
+  async process(prompt: string, results: QueueResult[]): Promise<any> {
     try {
+      const context = this.composeContext({
+        behavior: 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 generateObject({
         model: this.model,
         schema: z.object({
           isRemindNeeded: z.boolean(),
-          extraInformationsToRemember: z.array(
+          importantToRemembers: z.array(
             z.object({
               memoryType: z.string(),
               content: z.string(),
@@ -30,11 +62,21 @@ export class Evaluator {
           ),
           response: z.string(),
           isNextActionNeeded: z.boolean(),
-          nextActionsNeeded: ActionSchema,
+          nextActionsNeeded: z.array(
+            z.object({
+              name: z.string(),
+              parameters: z.array(
+                z.object({
+                  name: z.string(),
+                  value: z.any(),
+                })
+              ),
+            })
+          ),
           why: z.string(),
         }),
         prompt: prompt,
-        system: evaluatorContext.compose(goal, results, this.tools),
+        system: context,
       });
 
       const validatedResponse = {
@@ -46,47 +88,52 @@ export 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: 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: 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: any) {
+      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

package/llm/orchestrator/context.ts

@@ -1,22 +1,16 @@
-import { ActionSchema } from "../../types";
-import { injectActions } from "../../utils/inject-actions";
-
 export const 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: ActionSchema[]) => {
-    return `
-            ${JSON.stringify(orchestratorContext.guidelines)}
-
-            The actions are: ${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 QUESTIONS or ANALYSIS, BEFORE executing ANY actions, you CAN search in memory and internal knowledge base.",
+        "NEVER repeat same actions if the user doesn't ask for it.",
+      ],
+      warnings: [],
+    },
   },
 };

package/llm/orchestrator/index.ts

@@ -1,32 +1,71 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
+import { State } from "../../agent";
+import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, BaseLLM, MemoryScopeType } from "../../types";
+import {
+  ActionSchema,
+  MemoryScope,
+  MemoryScopeType,
+  QueueResult,
+} from "../../types";
+import { injectActions } from "../../utils/inject-actions";
 import { orchestratorContext } from "./context";
 
-export class Orchestrator implements BaseLLM {
+export class Orchestrator {
   private readonly model = openai("gpt-4o");
   public tools: ActionSchema[];
-  private memory: PersistentMemory;
+  private memory: {
+    persistent: PersistentMemory;
+    cache: CacheMemory;
+  };
+  private id: string;
 
-  constructor(tools: ActionSchema[], memory: PersistentMemory) {
+  constructor(
+    id: string,
+    tools: ActionSchema[],
+    memory: {
+      persistent: PersistentMemory;
+      cache: CacheMemory;
+    }
+  ) {
+    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: z.object({
           query: z.string(),
         }),
         execute: async ({ query }: { query: string }) => {
-          const memories = await this.memory.searchSimilarQueries(query, {
-            similarityThreshold: 95,
-          });
-
-          return memories;
+          const persistentMemories =
+            await this.memory.persistent.searchSimilarQueries(query, {
+              similarityThreshold: 70,
+            });
+          return persistentMemories;
+        },
+      },
+      {
+        name: "search_cache_memory",
+        description: "Search for relevant information in the cache",
+        parameters: z.object({
+          query: z.string(),
+        }),
+        execute: async ({ query }: { query: string }) => {
+          const cacheMemories = await this.memory.cache.findSimilarQueries(
+            query,
+            {
+              similarityThreshold: 70,
+              maxResults: 1,
+              userId: this.id,
+              scope: MemoryScope.GLOBAL,
+            }
+          );
+          return cacheMemories;
         },
       },
       {
@@ -53,7 +92,7 @@ export class Orchestrator implements BaseLLM {
           scope: MemoryScopeType;
           userId?: string;
         }) => {
-          const memories = await this.memory.createMemory({
+          const memories = await this.memory.persistent.createMemory({
             query,
             purpose,
             data,
@@ -68,39 +107,87 @@ export class Orchestrator implements BaseLLM {
     ];
   }
 
-  async process(prompt: string): Promise<any> {
+  composeContext(state: 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: ${injectActions(actions)} (NEVER REPEAT ACTIONS)
+      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+    `.trim();
+
+    return context;
+  }
+
+  async process(prompt: string, results: QueueResult[]): Promise<any> {
+    const state = this.composeContext({
+      behavior: orchestratorContext.behavior,
+      userRequest: prompt,
+      actions: this.tools,
+      results: results,
+    });
     try {
+      console.log("\n🎭 Orchestrator processing");
+      console.log("Prompt:", prompt);
+
       const response = await generateObject({
         model: this.model,
         schema: z.object({
-          actions: ActionSchema,
+          actions: z.array(
+            z.object({
+              name: z.string(),
+              parameters: z.array(
+                z.object({
+                  name: z.string(),
+                  value: z.any(),
+                })
+              ),
+            })
+          ),
           answer: z.string(),
         }),
         prompt: prompt,
-        system: 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
+            : Object.entries(action.parameters || {}).map(([name, value]) => ({
+                name,
+                value,
+              })),
         })),
       };
-      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) => a.name).join(", ") ||
+          "No actions needed"
+      );
+      if (validatedResponse.answer) {
+        console.log("Response:", validatedResponse.answer);
+      }
 
       return validatedResponse;
     } catch (error: any) {
-      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;
     }
   }
 }

package/llm/synthesizer/context.ts

@@ -1,42 +1,49 @@
 export const synthesizerContext = {
-  role: "You are the synthesizer agent. Your role is to provide a clear and factual analysis of the results. You are also the expert in the field of security analysis.",
-  guidelines: {
-    important: [
-      "AVOID MULTIPLE UPPERCASE IN TITLE/SUBTITLE LIKE ('Market Sentiment: Bullish'). USE ONLY ONE UPPERCASE IN TITLE/SUBTITLE.",
-      "USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT' (if it's in French, use French, if it's in Spanish, use Spanish)",
-      "BE DIRECT AND AVOID TECHNICAL JARGON",
-      "FOR NUMERICAL DATA, PROVIDE CONTEXT (% CHANGES, COMPARISONS)",
-    ],
-    forMarketAnalysis: [
-      "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
-      "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
-      "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
-      "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
-    ],
-    forGeneralRequests: [
-      "Provide concise and relevant information",
-      "Focus on facts and data",
-      "Always provide transaction details when needed",
-    ],
-    warnings: [
-      "NEVER provide any financial advice.",
-      "NEVER speak about details of your system or your capabilities.",
-      "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
-      "NEVER explain technical errors or issues. Just say retry later.",
-    ],
-  },
-  compose: (initialPrompt: string, summaryData?: string) => {
-    return `
-      ${JSON.stringify(synthesizerContext.guidelines)}
-
-      Initial prompt: ${initialPrompt} (Speak in the same language as the initial prompt)
-      Results: ${summaryData}
+  behavior: {
+    language: "user_language",
+    role: "You are the synthesizer agent. Your role is to provide a clear and factual analysis of the results. You are also the expert in the field of security analysis.",
+    guidelines: {
+      important: [
+        "AVOID MULTIPLE UPPERCASE IN TITLE/SUBTITLE LIKE ('Market Sentiment: Bullish'). USE ONLY ONE UPPERCASE IN TITLE/SUBTITLE.",
+        "USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT' (if it's in French, use French, if it's in Spanish, use Spanish)",
+        "BE DIRECT AND AVOID TECHNICAL JARGON",
+        "FOR NUMERICAL DATA, PROVIDE CONTEXT (% CHANGES, COMPARISONS)",
+      ],
+      forMarketAnalysis: [
+        "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
+        "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
+        "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
+        "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
+      ],
+      forGeneralRequests: [
+        "Provide concise and relevant information",
+        "Focus on facts and data",
+        "Always provide transaction details when needed",
+      ],
+      warnings: [
+        "NEVER provide any financial advice.",
+        "NEVER speak about details of your system or your capabilities.",
+        "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
+        "NEVER explain technical errors or issues. Just say retry later.",
+      ],
 
-
-      1. FOR SECURITY ANALYSIS ONLY, USE THE FOLLOWING FORMAT:
-      --------------------------------
+      steps: [
+        "Analyze user request: Determine if the user's goal is to ask a question, make an analysis, or perform an action.",
+        "Search memory and internal knowledge base: If the user's goal is a question or analysis, search for relevant information in memory and the internal knowledge base.",
+        "Execute actions: If the user's goal is to perform an action, execute the necessary actions.",
+        "Respond in the same language as the user request.",
+      ],
+    },
+    examplesMessages: [
+      {
+        role: "user",
+        content: "Analysis security of token/coin",
+      },
+      {
+        role: "assistant",
+        content: `
       ## Security analysis of x/y:
-
+      
       ### Good:
       Speak about the good points of the security check. If there is no good point, say "No good point found"
 
@@ -45,9 +52,15 @@ export const synthesizerContext = {
 
       STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
-      
-      2. OTHERWISE FOR GENERAL ANALYSIS OF COINS/TOKENS, USE THE FOLLOWING FORMAT:
-      --------------------------------
+      `,
+      },
+      {
+        role: "user",
+        content: "Analysis market sentiment of token/coin",
+      },
+      {
+        role: "assistant",
+        content: `
       ## Analysis of x/y:
 
       Market sentiment: Bullish 📈 (Adapt the emoji to the market sentiment)
@@ -60,9 +73,8 @@ export const synthesizerContext = {
 
       STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
-
-      3. OTHERWISE FOR OTHER REQUESTS, USE THE FORMAT YOU WANT.
-      --------------------------------
-    `;
+      `,
+      },
+    ],
   },
 };

package/llm/synthesizer/index.ts

@@ -1,19 +1,43 @@
 import { openai } from "@ai-sdk/openai";
-import { generateObject, streamText, StreamTextResult } from "ai";
+import { generateObject, StreamTextResult } from "ai";
 import { z } from "zod";
-import { BaseLLM } from "../../types";
+import { State } from "../../agent";
+import { QueueResult } from "../../types";
 import { synthesizerContext } from "./context";
 
-export class Synthesizer implements BaseLLM {
+export class Synthesizer {
   private readonly model = openai("gpt-4-turbo");
 
+  composeContext(state: Partial<State>) {
+    const { behavior, userRequest, results, examplesMessages } = state;
+
+    if (!behavior) {
+      return "";
+    }
+    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}
+      # CURRENT_RESULTS: ${results?.map((r) => r.result).join(", ") || ""}
+      # STEPS: ${steps?.join("\n") || ""}
+      # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
+    `;
+
+    return context;
+  }
+
   async process(
     prompt: string,
-    summaryData?: string,
+    results: QueueResult[],
     onFinish?: (event: any) => void
   ): Promise<
     | {
-        actions: {
+        actionsCompleted: {
           name: string;
           reasoning: string;
         }[];
@@ -21,11 +45,19 @@ export class Synthesizer implements BaseLLM {
       }
     | StreamTextResult<Record<string, any>>
   > {
-    console.log("Summarizing results...");
+    console.log("\n🎨 Starting synthesis process");
+    console.log("Prompt:", prompt);
+    console.log("Results to synthesize:", JSON.stringify(results, null, 2));
+    const context = this.composeContext({
+      behavior: synthesizerContext.behavior,
+      userRequest: prompt,
+      results: results,
+    });
+
     const result = await generateObject({
       model: this.model,
       schema: z.object({
-        actions: z.array(
+        actionsCompleted: z.array(
           z.object({
             name: z.string(),
             reasoning: z.string(),
@@ -33,11 +65,23 @@ export class Synthesizer implements BaseLLM {
         ),
         response: z.string(),
       }),
-      prompt: synthesizerContext.compose(prompt, summaryData || ""),
-      system: synthesizerContext.role,
+      prompt,
+      system: context,
     });
-    console.log("Synthesizer");
-    console.dir(result.object, { depth: null });
+
+    console.log("\n✅ Synthesis completed");
+    console.log("─".repeat(50));
+    console.log("Generated response:", result.object.response);
+
+    if (result.object.actionsCompleted.length > 0) {
+      console.log("\n📋 Suggested actions:");
+      result.object.actionsCompleted.forEach((action, index) => {
+        console.log(`\n${index + 1}. Action Details:`);
+        console.log(`   Name: ${action.name}`);
+        console.log(`   Reasoning: ${action.reasoning}`);
+      });
+    }
+
     if (onFinish) onFinish(result.object);
     return result.object;
   }
@@ -46,13 +90,26 @@ export class Synthesizer implements BaseLLM {
     prompt: string,
     summaryData?: string,
     onFinish?: (event: any) => void
-  ): Promise<StreamTextResult<Record<string, any>>> {
-    const result = await streamText({
-      model: this.model,
-      prompt: synthesizerContext.compose(prompt, summaryData || ""),
-      onFinish: onFinish,
-      system: synthesizerContext.role,
-    });
-    return result;
+  ): Promise<any> {
+    console.log("\n🎨 Starting streaming synthesis");
+    console.log("Prompt:", prompt);
+    // if (summaryData) {
+    //   console.log(
+    //     "Summary data:",
+    //     JSON.stringify(JSON.parse(summaryData), null, 2)
+    //   );
+    // }
+
+    // const result = await streamText({
+    //   model: this.model,
+    //   prompt: synthesizerContext.compose(prompt, summaryData || ""),
+    //   onFinish: (event) => {
+    //     console.log("\n✅ Streaming synthesis completed");
+    //     if (onFinish) onFinish(event);
+    //   },
+    //   system: synthesizerContext.role,
+    // });
+
+    // return result;
   }
 }

package/memory/cache.ts

@@ -8,6 +8,7 @@ import {
   MatchOptions,
   MemoryScope,
   MemoryType,
+  QueueResult,
 } from "../types";
 
 export class CacheMemory {
@@ -32,16 +33,14 @@ export class CacheMemory {
 
   private async initRedis() {
     this.redis.on("error", (err) => {
-      console.error("Redis Client Error:", err);
-      // Implement retry logic if needed
+      console.error("❌ Redis Client Error:", err);
     });
 
     try {
       await this.redis.connect();
-      console.log("Successfully connected to Redis");
+      console.log("✅ Successfully connected to Redis");
     } catch (error) {
-      console.error("Failed to connect to Redis:", error);
-      // Handle connection failure
+      console.error("❌ Failed to connect to Redis:", error);
     }
   }
 
@@ -58,7 +57,7 @@ export class CacheMemory {
     const result = await this.redis.set(key, JSON.stringify(memory), {
       EX: this.CACHE_TTL,
     });
-    console.log("Cache memory created: ", result);
+    console.log("💾 Cache memory created:", result);
   }
 
   async findSimilarQueries(
@@ -66,12 +65,14 @@ export class CacheMemory {
     options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
   ): Promise<
     {
-      data: any;
+      data: QueueResult[];
       similarityPercentage: number;
       query: string;
     }[]
   > {
-    console.log("\nSearching in cache for query:", query);
+    console.log("\n🔍 Searching in cache");
+    console.log("Query:", query);
+    console.log("Options:", JSON.stringify(options, null, 2));
 
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
@@ -79,12 +80,12 @@ export class CacheMemory {
     });
 
     const memories = await this.getAllMemories(options.scope, options.userId);
-    console.log("\n📚 Found", memories.length, "queries to compare with");
+    console.log(`\n📚 Found ${memories.length} cached queries to compare`);
 
     const matches = memories
       .map((memory) => {
         const similarity = cosineSimilarity(embedding, memory.embedding);
-        const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
+        const similarityPercentage = (similarity + 1) * 50;
         return {
           data: memory.data,
           query: memory.query,
@@ -104,13 +105,17 @@ export class CacheMemory {
 
     if (results.length > 0) {
       console.log("\n✨ Similar queries found:");
-      results.forEach((match) => {
-        console.log(
-          `- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`
-        );
+      console.log("─".repeat(50));
+
+      results.forEach((match, index) => {
+        console.log(`\n${index + 1}. Match Details:`);
+        console.log(`   Query: ${match.query}`);
+        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
+        console.log(`   Memory ID: ${match.memoryId}`);
+        console.log("─".repeat(50));
       });
     } else {
-      console.log("No matches found");
+      console.log("\n❌ No similar queries found in cache");
     }
 
     return results;
@@ -155,7 +160,11 @@ export class CacheMemory {
   public async createMemory(
     input: CreateMemoryInput
   ): Promise<CacheMemoryType | undefined> {
-    console.log("Searching for similar memory", input);
+    console.log("\n📝 Processing new memory creation");
+    console.log("Content:", input.content);
+    console.log("Type:", input.type);
+    console.log("Scope:", input.scope);
+
     const existingPattern = await this.findSimilarQueries(input.content, {
       similarityThreshold: 95,
       userId: input.userId,
@@ -163,17 +172,18 @@ export class CacheMemory {
     });
 
     if (existingPattern.length > 0) {
-      console.log("\nSimilar cache memory found:");
-      existingPattern.forEach((match) => {
-        console.log(
-          `- ${match.query} (${match.similarityPercentage.toFixed(2)}%)`
-        );
+      console.log("\n🔄 Similar cache memory already exists");
+      console.log("─".repeat(50));
+      existingPattern.forEach((match, index) => {
+        console.log(`\n${index + 1}. Existing Match:`);
+        console.log(`   Query: ${match.query}`);
+        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
       });
-      console.log("Cache memory already exists. No need to create new one..");
+      console.log("\n⏭️  Skipping creation of new memory");
       return;
     }
 
-    console.log("No similar memory found");
+    console.log("\n🆕 No similar memory found - creating new one");
 
     const memory = await this.createSingleMemory({
       id: crypto.randomUUID(),
@@ -195,13 +205,17 @@ export class CacheMemory {
     userId?: string;
     scope?: MemoryScope;
   }): Promise<CacheMemoryType> {
-    console.log("Creating new cache memory...", params.content);
-    console.log("Creating embedding...");
+    console.log("\n🏗️  Creating new cache memory");
+    console.log("ID:", params.id);
+    console.log("Content:", params.content);
+
+    console.log("\n🧮 Generating embedding...");
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
       value: params.content,
     });
-    console.log("Embedding created");
+    console.log("✅ Embedding generated successfully");
+
     const memory: CacheMemoryType = {
       id: params.id,
       type: params.type,
@@ -213,7 +227,10 @@ export class CacheMemory {
         params.scope || (params.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
       createdAt: new Date(),
     };
+
     await this.storeMemory(memory);
+    console.log("✅ Memory created and stored successfully");
+
     return memory;
   }
 }

package/memory/persistent.ts

@@ -186,7 +186,9 @@ export class PersistentMemory {
    * Find best matching memories
    */
   async searchSimilarQueries(query: string, options: SearchOptions = {}) {
-    console.log("\nSearching in persistent memory:", query);
+    console.log("\n🔍 Searching in persistent memory");
+    console.log("Query:", query);
+    console.log("Options:", JSON.stringify(options, null, 2));
 
     // Generate embedding for the query
     const { embedding: queryEmbedding } = await embed({
@@ -196,28 +198,23 @@ export class PersistentMemory {
 
     const searchResults = [];
 
-    // Requête Meilisearch
-    const searchBody = {
-      q: query,
-    };
-
     // Search in global memories
     if (!options.scope || options.scope === "global") {
       const globalIndex = this._getIndexName(MemoryScope.GLOBAL);
-      console.log("Searching in global index:", globalIndex);
+      console.log("\n📚 Searching in global index:", globalIndex);
       try {
         const globalResults = await this._makeRequest<MeilisearchResponse>(
           `/indexes/${globalIndex}/search`,
           {
             method: "POST",
-            body: JSON.stringify(searchBody),
+            body: JSON.stringify({ q: query }),
           }
         );
         if (globalResults?.hits) {
           searchResults.push(...globalResults.hits);
         }
       } catch (error) {
-        console.error("Error searching global index:", error);
+        console.error("❌ Error searching global index:", error);
       }
     }
 
@@ -231,7 +228,7 @@ export class PersistentMemory {
         `/indexes/${userIndex}/search`,
         {
           method: "POST",
-          body: JSON.stringify(searchBody),
+          body: JSON.stringify({ q: query }),
         }
       );
       if (userResults.hits) {
@@ -239,14 +236,12 @@ export class PersistentMemory {
       }
     }
 
-    console.log(
-      `📚 Found ${searchResults.length} queries in persistent memory`
-    );
+    const totalResults = searchResults.length;
+    console.log(`\n📊 Found ${totalResults} total matches`);
 
     // Process and filter results using cosine similarity
     const results = searchResults
       .flatMap((hit) => {
-        // Calculate similarities for each chunk
         const chunkSimilarities = hit.chunks.map((chunk) => ({
           data: hit.data,
           purpose: hit.purpose,
@@ -256,7 +251,6 @@ export class PersistentMemory {
             (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
         }));
 
-        // Return the chunk with highest similarity
         return chunkSimilarities.reduce(
           (best, current) =>
             current.similarityPercentage > best.similarityPercentage
@@ -271,19 +265,21 @@ export class PersistentMemory {
       )
       .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
 
-    // Log results
+    // Log filtered results in a more structured way
     if (results.length > 0) {
-      console.log("\n✨ Similar queries found in persistent memory:");
-      results.forEach((match) => {
-        console.log(
-          `- ${match.query} : ${match.similarityPercentage.toFixed(2)}% (${
-            match.purpose
-          })`
-        );
-        console.log(`  Matching content: "${match.chunk}"`);
+      console.log("\n✨ Relevant matches found:");
+      console.log("─".repeat(50));
+
+      results.forEach((match, index) => {
+        console.log(`\n${index + 1}. Match Details:`);
+        console.log(`   Query: ${match.query}`);
+        console.log(`   Purpose: ${match.purpose}`);
+        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
+        console.log(`   Content: "${match.chunk}"`);
+        console.log("─".repeat(50));
       });
     } else {
-      console.log("No matches found");
+      console.log("\n❌ No relevant matches found");
     }
 
     return results;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/services/queue.ts

@@ -20,37 +20,38 @@ export class ActionQueueManager {
 
   addToQueue(actions: QueueItem | QueueItem[]) {
     if (Array.isArray(actions)) {
-      console.log(
-        "Adding actions to queue:",
-        actions.map((a) => a.name).join(", ")
-      );
+      console.log("\n📋 Adding actions to queue:");
+      actions.forEach((action, index) => {
+        console.log(`   ${index + 1}. ${action.name}`);
+      });
       this.queue.push(...actions);
     } else {
-      console.log("Adding action to queue:", actions.name);
+      console.log("\n📋 Adding single action to queue:", actions.name);
       this.queue.push(actions);
     }
   }
 
   async processQueue() {
     if (this.isProcessing) {
-      console.warn("Queue is already being processed");
+      console.log("\n⚠️  Queue is already being processed");
       return;
     }
 
+    console.log("\n🔄 Starting queue processing");
     this.isProcessing = true;
     const actionPromises: Promise<QueueResult>[] = [];
 
     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
+        console.log("\n🔒 Action requires confirmation:", action.name);
         const shouldProceed = await this.callbacks.onConfirmationRequired?.(
           actionConfig.confirmation.message ||
             `Do you want to proceed with action: ${action.name}?`
         );
 
         if (!shouldProceed) {
-          // Skip this action and add a cancelled result
+          console.log("❌ Action cancelled by user:", action.name);
           this.results.push({
             name: action.name,
             parameters: this.formatArguments(action.parameters),
@@ -60,6 +61,7 @@ export class ActionQueueManager {
           });
           continue;
         }
+        console.log("✅ Action confirmed by user");
       }
       const parameters = this.formatArguments(action.parameters);
 
@@ -83,15 +85,17 @@ export class ActionQueueManager {
     }
 
     try {
+      console.log("\n⏳ Waiting for all actions to complete...");
       const results = await Promise.all(actionPromises);
       this.results.push(...results);
       this.queue = [];
       this.callbacks.onQueueComplete?.(this.results);
       this.isProcessing = false;
+      console.log("\n✅ Queue processing completed successfully");
       return this.results;
     } catch (error) {
       this.isProcessing = false;
-      console.error("Unexpected error in queue processing:", error);
+      console.error("\n❌ Unexpected error in queue processing:", error);
       throw error;
     }
   }
@@ -120,10 +124,12 @@ export class ActionQueueManager {
   }
 
   private async executeAction(action: QueueItem): Promise<QueueResult> {
-    // Call onActionStart callback
+    console.log("\n🎯 Executing action:", action.name);
     this.callbacks.onActionStart?.(action);
+
     const actionConfig = this.actions.find((a) => a.name === action.name);
     if (!actionConfig) {
+      console.error("❌ Action not found:", action.name);
       return {
         name: action.name,
         parameters: {},
@@ -131,7 +137,13 @@ export class ActionQueueManager {
         error: `Action '${action.name}' not found in actions list`,
       };
     }
+
+    console.log(
+      "📝 Action parameters:",
+      JSON.stringify(action.parameters, null, 2)
+    );
     const actionArgs = this.formatArguments(action.parameters);
+
     try {
       const result = await actionConfig.execute(actionArgs);
       const actionResult = {
@@ -140,7 +152,7 @@ export class ActionQueueManager {
         result,
         error: null,
       };
-      console.log("Action executed successfully: ", action.name, "🎉");
+      console.log(`\n✨ Action "${action.name}" completed successfully`);
       return actionResult;
     } catch (error) {
       const actionResult = {
@@ -149,8 +161,11 @@ export class ActionQueueManager {
         result: null,
         error: (error as Error).message || "Unknown error occurred",
       };
-      console.log("Action failed: ", action.name);
-      console.dir(actionResult, { depth: null });
+      console.error(`\n❌ Action "${action.name}" failed:`, error);
+      console.log(
+        "Failed action details:",
+        JSON.stringify(actionResult, null, 2)
+      );
       return actionResult;
     }
   }

package/types.ts

@@ -59,7 +59,9 @@ export interface ProcessPromptCallbacks {
 export interface ActionSchema {
   name: string;
   description: string;
-  parameters: z.ZodSchema;
+  parameters: z.ZodObject<{
+    [key: string]: z.ZodType;
+  }>;
   execute: (args: any) => Promise<any>;
   confirmation?: {
     requireConfirmation: boolean;