@ai.ntellect/core 0.1.81 → 0.1.84

package/README.FR.md

@@ -230,79 +230,50 @@ export const prepareTransaction = {
 
 ## 3. Exécution du workflow
 
-Le workflow représente l'ensemble du processus d'exécution d'un certain nombre d'actions définies. Lorsqu'un utilisateur envoie un prompt, l'orchestrateur détermine les actions à exécuter en fonction des besoins.
-
-### Exemple de création d'un workflow :
+L'agent gère l'ensemble du processus de compréhension des requêtes utilisateur et de coordination des réponses. Voici un exemple d'utilisation de l'agent :
 
 ```typescript
-const tools = [
-  prepareEvmTransaction,
-  getNews, // Exemple d'action pour obtenir les dernières nouvelles
-];
-
-const orchestrator = new Orchestrator(tools);
+const memory = new PersistentMemory({
+  host: "http://localhost:7700",
+  apiKey: "VOTRE_CLE_API",
+});
 
-const workflow = new Workflow(
-  { id: from }, // ID utilisateur ou contexte
-  { orchestrator, memoryCache, eventEmitter } // Composants nécessaires
+const orchestrator = new Orchestrator(
+  [
+    getChainsTVL,
+    getRssNews,
+    // autres outils...
+  ],
+  memory
 );
-```
-
-- **Orchestrator** : Gestion de l'ordre des actions.
-- **MemoryCache** : Réutilisation des résultats précédents.
-- **EventEmitter** : Suivi et notification de l'état du workflow.
-
-### Processus du workflow :
-
-1. Le prompt utilisateur est analysé.
-2. L'orchestrateur décide des actions nécessaires et leur ordre.
-3. Les actions sont exécutées.
-4. Les résultats sont synthétisés et renvoyés à l'utilisateur.
 
----
-
-## 4. Appels API et côté client
+const agent = new Agent({
+  user: { id: "user_id" },
+  orchestrator,
+  persistentMemory: memory,
+  stream: false,
+  maxEvaluatorIteration: 1,
+});
 
-```typescript
-fastify.post("/api/chat", {
-  preHandler: requireAuth,
-  handler: async (request, reply) => {
-    const { messages, from } = request.body;
-    const latestMessage = messages[messages.length - 1];
-
-    const workflow = new Workflow(
-      { id: from },
-      { orchestrator, memoryCache, eventEmitter }
-    );
-    return workflow.start(latestMessage.content, messages);
+// Traitement d'une requête utilisateur
+const result = await agent.process(prompt, context, {
+  onMessage: (message) => {
+    console.log({ message });
   },
 });
 ```
 
-```typescript
-export function Chat({ id, initialMessages }) {
-  const { messages, setMessages, handleSubmit, input, setInput } = useChat({
-    api: "/api/chat",
-    body: { id, from: activeAccount?.address },
-  });
-
-  return (
-    <div>
-      <div>{messages}</div>
-      <input
-        type="text"
-        value={input}
-        onChange={(e) => setInput(e.target.value)}
-      />
-      <button onClick={handleSubmit}>Envoyer</button>
-    </div>
-  );
-}
-```
+### Flux de traitement de l'agent :
+
+1. L'utilisateur envoie un prompt
+2. L'agent analyse le prompt et le contexte
+3. L'orchestrateur exécute les outils/actions nécessaires
+4. L'évaluateur évalue les résultats
+5. L'agent génère la réponse finale
 
 ---
 
-## 5. WIP (Work in Progress)
+## 4. WIP (Work in Progress)
 
 Voici les éléments actuellement en développement ou à améliorer :
 

package/README.md

@@ -1,50 +1,51 @@
 # AI.ntellect Core Framework
 
-## Table of Contents
+## Table of contents
 
-1. [Main Components](#main-components)
+1. [Main components](#main-components)
+   - [Agent](#agent)
    - [Orchestrator](#orchestrator)
-   - [Queue Manager](#queue-manager)
    - [Synthesizer](#synthesizer)
    - [Evaluator](#evaluator)
    - [Memory](#memory-architecture)
-2. [Action Creation and Management](#action-creation-and-management)
-3. [Workflow Execution](#workflow-execution)
-4. [API Calls and Client Side](#api-calls-and-client-side)
-5. [WIP (Work in Progress)](#wip-work-in-progress)
+2. [Action creation and management](#action-creation-and-management)
+3. [Agent processing](#agent-processing)
+4. [WIP (Work in Progress)](#wip-work-in-progress)
 
 ---
 
 ## 1. Main components
 
-The system relies on several key components that ensure smooth and efficient management of actions and the overall workflow process.
+The system relies on several key components that ensure smooth and efficient processing of user requests through an AI agent architecture.
 
-### Orchestrator
+### Agent
 
-The orchestrator is responsible for managing the execution of actions within a workflow. It analyzes the needs based on inputs (like the user prompt) and decides the order of actions to be performed. It interacts with other components like the cache memory and events to organize the execution of tasks.
+The agent is the core component that processes user requests and manages the entire interaction flow. It coordinates with other components to understand user needs, execute appropriate actions, and generate relevant responses.
 
-- **Main Role**: Organize and direct the execution of actions.
-- **Interactions**:
-  - Analyzes user prompts to determine required actions
-  - Requests actions to be executed
-  - Uses cache memory to avoid redundancy
-  - Emits events to inform other components about the state of the workflow
+- **Main role**: Process user requests and coordinate system components
+- **Key features**:
+  - Processes user prompts
+  - Manages conversation context
+  - Coordinates with orchestrator for action execution
+  - Handles response generation
+  - Maintains user state and memory
 
-### Queue Manager
+### Orchestrator
 
-The queue manager organizes the actions to be executed and manages their execution order. It ensures a smooth flow of execution by adding actions to the queue based on the priorities defined by the orchestrator.
+The orchestrator works under the agent's direction to manage the execution of actions. It analyzes requirements based on the agent's interpretation of user needs and coordinates the execution of appropriate tools.
 
-- **Main Role**: Manage the action queue and ensure actions are executed in the correct order.
-- **Main Functions**:
-  - Add new actions to the queue.
-  - Manage action priorities.
-  - Ensure proper and timely execution of actions.
+- **Main role**: Organize and direct the execution of actions
+- **Interactions**:
+  - Manages available tools/actions
+  - Executes actions based on agent requests
+  - Uses memory for context and caching
+  - Coordinates with evaluator for result assessment
 
 ### Synthesizer
 
 The synthesizer is responsible for generating responses and analyzing actions based on the results obtained in the workflow. It can create summaries or more complex responses from the raw results obtained during the execution of actions.
 
-- **Main Role**: Transform the results of actions into a comprehensible and structured output
+- **Main role**: Transform the results of actions into a comprehensible and structured output
 - **Interactions**:
   - Takes the results of executed actions
   - Creates summaries or tailored responses
@@ -55,8 +56,8 @@ The synthesizer is responsible for generating responses and analyzing actions ba
 
 The evaluator is responsible for assessing the results of executed actions and determining if additional actions are needed. It works in conjunction with the orchestrator to ensure all user requirements are met.
 
-- **Main Role**: Evaluate action results and determine next steps
-- **Main Functions**:
+- **Main role**: Evaluate action results and determine next steps
+- **Main functions**:
   - Analyzes results from executed actions
   - Determines if additional actions are needed
   - Suggests next actions to the orchestrator
@@ -139,7 +140,7 @@ sudo apt-get install redis-server
 
 CAG optimizes workflow execution through Redis-based caching:
 
-- **Main Role**: Cache frequently used procedural patterns
+- **Main role**: Cache frequently used procedural patterns
 - **Implementation**:
 
   - Uses Redis for high-performance storage
@@ -229,81 +230,50 @@ export const prepareTransaction = {
 
 ---
 
-## 3. Workflow execution
-
-The workflow represents the entire process of executing a number of defined actions. When a user sends a prompt, the orchestrator determines which actions to perform based on the needs.
+## 3. Agent processing
 
-### Example of creating a workflow:
+The agent handles the entire process of understanding user requests and coordinating responses. Here's an example of how to use the agent:
 
 ```typescript
-const tools = [
-  prepareEvmTransaction,
-  getNews, // Example action to fetch the latest news
-];
-
-const orchestrator = new Orchestrator(tools);
+const memory = new PersistentMemory({
+  host: "http://localhost:7700",
+  apiKey: "YOUR_API_KEY",
+});
 
-const workflow = new Workflow(
-  { id: from }, // User ID or context
-  { orchestrator, memoryCache, eventEmitter } // Required components
+const orchestrator = new Orchestrator(
+  [
+    getChainsTVL,
+    getRssNews,
+    // other tools...
+  ],
+  memory
 );
-```
-
-- **Orchestrator**: Manages the order of actions.
-- **MemoryCache**: Reuses previous results.
-- **EventEmitter**: Tracks and notifies the state of the workflow.
-
-### Workflow process:
 
-1. The user’s prompt is analyzed.
-2. The orchestrator decides which actions are needed and their order.
-3. Actions are executed.
-4. Results are synthesized and returned to the user.
-
----
-
-## 4. API calls and client side
+const agent = new Agent({
+  user: { id: "user_id" },
+  orchestrator,
+  persistentMemory: memory,
+  stream: false,
+  maxEvaluatorIteration: 1,
+});
 
-```typescript
-fastify.post("/api/chat", {
-  preHandler: requireAuth,
-  handler: async (request, reply) => {
-    const { messages, from } = request.body;
-    const latestMessage = messages[messages.length - 1];
-
-    const workflow = new Workflow(
-      { id: from },
-      { orchestrator, memoryCache, eventEmitter }
-    );
-    return workflow.start(latestMessage.content, messages);
+// Process a user request
+const result = await agent.process(prompt, context, {
+  onMessage: (message) => {
+    console.log({ message });
   },
 });
 ```
 
-```typescript
-export function Chat({ id, initialMessages }) {
-  const { messages, setMessages, handleSubmit, input, setInput } = useChat({
-    api: "/api/chat",
-    body: { id, from: activeAccount?.address },
-  });
-
-  return (
-    <div>
-      <div>{messages}</div>
-      <input
-        type="text"
-        value={input}
-        onChange={(e) => setInput(e.target.value)}
-      />
-      <button onClick={handleSubmit}>Send</button>
-    </div>
-  );
-}
-```
+### Agent process flow:
 
----
+1. User sends a prompt
+2. Agent analyzes the prompt and context
+3. Orchestrator executes required tools/actions
+4. Evaluator assesses results
+5. Agent generates final response
 
-## 5. WIP (Work in Progress)
+## 4. WIP (Work in Progress)
 
 Here are the elements currently in development or improvement:
 
@@ -313,9 +283,10 @@ Here are the elements currently in development or improvement:
 
 **Objective**: Enable multiple agents to collaborate on complex tasks with specialization and coordination.
 
-**Interest**: Collaboration between agents allows breaking down complex tasks into specialized subtasks, enhancing the efficiency and quality of results. It also enables better resource management and faster adaptation to changes.
+**Interest**: Collaboration between agents allows breaking down complex tasks into specialized subtasks, enhancing the
+efficiency and quality of results. It also enables better resource management and faster adaptation to changes.
 
-**Steps to Implement**:
+**Steps to implement**:
 
 - [ ] Task delegation framework.
 - [ ] Shared context management.
@@ -329,9 +300,11 @@ Here are the elements currently in development or improvement:
 
 **Objective**: Create a model for recognizing on-chain interactions and creating workflows for complex interactions.
 
-**Interest**: This feature allows the agent to understand and interact with smart contracts more intuitively, facilitating the execution of complex actions on the blockchain. It improves accessibility and efficiency in interacting with smart contracts.
+**Interest**: This feature allows the agent to understand and interact with smart contracts more intuitively,
+facilitating the execution of complex actions on the blockchain. It improves accessibility and efficiency in
+interacting with smart contracts.
 
-**Steps to Implement**:
+**Steps to implement**:
 
 - [ ] Extraction and processing of relevant contract ABIs.
 - [ ] Filtering of relevant functions.
@@ -347,9 +320,13 @@ Here are the elements currently in development or improvement:
 
 ## Lit Protocol implementation
 
-**Objective**: Add the ability to execute Lit actions, enabling decentralized and secure calculations on the Lit network.
+**Objective**: Add the ability to execute Lit actions, enabling decentralized and secure calculations on the Lit
+network.
 
-**Interest**: Integrating the Lit Protocol allows executing Lit actions in a decentralized manner, using cryptographic keys to validate operations. These actions can be used to run JavaScript scripts in a decentralized environment, offering transparency as all interactions are recorded on the blockchain. The main benefit lies in automation and security while preserving user privacy, which enhances trust in on-chain interactions.
+**Interest**: Integrating the Lit Protocol allows executing Lit actions in a decentralized manner, using cryptographic
+keys to validate operations. These actions can be used to run JavaScript scripts in a decentralized environment,
+offering transparency as all interactions are recorded on the blockchain. The main benefit lies in automation and
+security while preserving user privacy, which enhances trust in on-chain interactions.
 
 **Steps to Implement**:
 
@@ -358,4 +335,5 @@ Here are the elements currently in development or improvement:
 - [ ] Develop modules for executing Lit actions, including signature management and secure script execution.
 - [ ] Test the integration, security, and transparency of Lit actions to ensure they function properly.
 
-**Status**: Under study to determine feasibility and technical implications, particularly regarding integrating decentralization into the existing system.
+**Status**: Under study to determine feasibility and technical implications, particularly regarding integrating
+decentralization into the existing system.

package/agent/handlers/ActionHandler.ts

@@ -17,7 +17,7 @@ export class ActionHandler {
         onActionStart: callbacks?.onActionStart,
         onActionComplete: callbacks?.onActionComplete,
         onQueueComplete: callbacks?.onQueueComplete,
-        onConfirmationRequired: async (message) => {
+        onConfirmationRequired: async (message: any) => {
           if (callbacks?.onConfirmationRequired) {
             return await callbacks.onConfirmationRequired(message);
           }

package/agent/index.ts

@@ -3,8 +3,17 @@ import { Orchestrator } from "../llm/orchestrator";
 import { Synthesizer } from "../llm/synthesizer";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { ActionSchema, AgentEvent, MemoryScope, User } from "../types";
+import {
+  ActionSchema,
+  AgentEvent,
+  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 class Agent {
@@ -18,6 +27,7 @@ export class Agent {
   private readonly stream: boolean;
   private readonly maxEvaluatorIteration: number;
   private evaluatorIteration = 0;
+  private accumulatedResults: QueueResult[] = [];
 
   constructor({
     user,
@@ -41,6 +51,7 @@ export class Agent {
     this.stream = stream;
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
+    this.accumulatedResults = [];
   }
 
   async process(
@@ -48,20 +59,44 @@ export class Agent {
     contextualizedPrompt: string,
     events: AgentEvent
   ): Promise<any> {
-    const request = await this.orchestrator.process(contextualizedPrompt);
-
-    events.onMessage?.(request);
+    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 (request.actions.length > 0) {
-      return this.handleActions(
-        {
-          initialPrompt: prompt,
-          contextualizedPrompt: contextualizedPrompt,
-          actions: request.actions,
-        },
-        events
-      );
+    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;
     }
+
+    return actions && actions.length > 0
+      ? this.handleActions(
+          {
+            initialPrompt: prompt,
+            contextualizedPrompt: contextualizedPrompt,
+            actions: actions as ActionSchema[],
+          },
+          events
+        )
+      : undefined;
   }
 
   private async handleActions(
@@ -76,8 +111,7 @@ export class Agent {
     },
     events: AgentEvent
   ): Promise<any> {
-    const similarActions = await this.findSimilarActions(initialPrompt);
-    const queueItems = this.transformActions(actions, similarActions);
+    const queueItems = this.transformActions(actions);
 
     const actionsResult = await this.actionHandler.executeActions(
       queueItems,
@@ -91,81 +125,89 @@ export class Agent {
       }
     );
 
+    this.accumulatedResults = [
+      ...this.accumulatedResults,
+      ...actionsResult.data,
+    ];
+
     if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-      return this.handleActionResults({ ...actionsResult, initialPrompt });
+      return this.handleActionResults({
+        data: this.accumulatedResults,
+        initialPrompt,
+      });
     }
 
     const evaluator = new Evaluator(
       this.orchestrator.tools,
       this.persistentMemory
     );
+    console.log("Accumulated results:");
+    console.dir(this.accumulatedResults, { depth: null });
+
+    const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
     const evaluation = await evaluator.process(
       initialPrompt,
       contextualizedPrompt,
-      JSON.stringify(actionsResult.data)
+      sanitizedResults
     );
 
     events.onMessage?.(evaluation);
 
-    if (evaluation.nextActions.length > 0) {
+    if (evaluation.isNextActionNeeded) {
       this.evaluatorIteration++;
       return this.handleActions(
         {
           initialPrompt: contextualizedPrompt,
           contextualizedPrompt: initialPrompt,
-          actions: evaluation.nextActions,
+          actions: evaluation.nextActionsNeeded,
         },
         events
       );
     }
 
-    if (!this.actionHandler.hasNonPrepareActions(actionsResult.data)) {
+    if (!this.actionHandler.hasNonPrepareActions(this.accumulatedResults)) {
       return {
-        data: actionsResult.data,
+        data: this.accumulatedResults,
         initialPrompt,
       };
     }
 
-    return this.handleActionResults({ ...actionsResult, initialPrompt });
+    return this.handleActionResults({
+      data: this.accumulatedResults,
+      initialPrompt,
+    });
   }
 
   private async handleActionResults(actionsResult: {
-    data: any;
+    data: QueueResult[];
     initialPrompt: string;
   }) {
     const synthesizer = new Synthesizer();
+    const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
     const summaryData = JSON.stringify({
-      result: actionsResult.data,
+      result: sanitizedResults,
       initialPrompt: actionsResult.initialPrompt,
     });
 
+    this.accumulatedResults = [];
+    this.evaluatorIteration = 0;
+
+    await this.cacheMemory?.createMemory({
+      content: actionsResult.initialPrompt,
+      data: actionsResult.data,
+      scope: MemoryScope.GLOBAL,
+      type: MemoryType.ACTION,
+    });
+
     return this.stream
       ? (await synthesizer.streamProcess(summaryData)).toDataStreamResponse()
       : await synthesizer.process(summaryData);
   }
 
-  private async findSimilarActions(prompt: string) {
-    if (!this.cacheMemory) {
-      return [];
-    }
-
-    return this.cacheMemory.findBestMatches(prompt, {
-      similarityThreshold: this.SIMILARITY_THRESHOLD,
-      maxResults: this.MAX_RESULTS,
-      userId: this.user.id,
-      scope: MemoryScope.USER,
-    });
-  }
-
-  private transformActions(actions: ActionSchema[], similarActions: any[]) {
+  private transformActions(actions: ActionSchema[]) {
     let predefinedActions =
       QueueItemTransformer.transformActionsToQueueItems(actions) || [];
 
-    if (similarActions?.length > 0) {
-      predefinedActions =
-        QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
-    }
-
     return predefinedActions;
   }
 }

package/dist/agent/index.d.ts

@@ -13,6 +13,7 @@ export declare class Agent {
     private readonly stream;
     private readonly maxEvaluatorIteration;
     private evaluatorIteration;
+    private accumulatedResults;
     constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration, }: {
         user: User;
         orchestrator: Orchestrator;
@@ -24,6 +25,5 @@ export declare class Agent {
     process(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
     private handleActions;
     private handleActionResults;
-    private findSimilarActions;
     private transformActions;
 }