@ai.ntellect/core 0.4.1 → 0.6.0

package/utils/state-manager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+class StateManager {
+    /**
+     * Updates the shared state while preserving immutability
+     * @param currentState Current shared state
+     * @param updates Partial updates to apply
+     * @returns Updated shared state
+     */
+    static updateState(state, updates) {
+        return Object.assign(Object.assign({}, state), { context: Object.assign(Object.assign({}, (state.context || {})), updates) });
+    }
+    static createUpdate(updates) {
+        return {
+            context: Object.assign({}, updates),
+        };
+    }
+}
+exports.StateManager = StateManager;

package/utils/state-manager.ts

@@ -0,0 +1,30 @@
+import { SharedState } from "../types";
+
+export class StateManager {
+  /**
+   * Updates the shared state while preserving immutability
+   * @param currentState Current shared state
+   * @param updates Partial updates to apply
+   * @returns Updated shared state
+   */
+  static updateState<T>(
+    state: SharedState<T>,
+    updates: Partial<T>
+  ): SharedState<T> {
+    return {
+      ...state,
+      context: {
+        ...(state.context || {}),
+        ...updates,
+      },
+    };
+  }
+
+  static createUpdate<T>(updates: Partial<T>) {
+    return {
+      context: {
+        ...updates,
+      },
+    };
+  }
+}

package/.nvmrc

@@ -1 +0,0 @@
-v22.0.0 

package/README.FR.md

@@ -1,365 +0,0 @@
-# AI.ntellect Core Framework
-
-## Vue d'ensemble
-
-Ce framework est conçu pour exécuter des workflows complexes à l'aide d'une orchestration avancée, de la gestion de mémoire et d'une intelligence exploitable. Il intègre des outils, des interpréteurs et des systèmes de mémoire pour :
-
-- Analyser les entrées utilisateur dans leur contexte.
-- Exécuter des workflows prédéfinis et des actions dynamiques.
-- Gérer efficacement la mémoire à court et à long terme.
-- Permettre une intégration fluide avec des API et outils externes.
-
----
-
-## Table des matières
-
-1. [Composants d'architecture](#composants-darchitecture)
-   - [Runtime de l'agent](#runtime-de-lagent)
-   - [Orchestrateur](#orchestrateur)
-   - [Gestionnaire de file d'attente](#gestionnaire-de-file-dattente)
-   - [Interpréteur](#interpréteur)
-   - [Système de mémoire](#système-de-mémoire)
-   - [Listeners](#listeners)
-   - [Schedulers](#schedulers)
-2. [Définir et exécuter des actions](#définir-et-exécuter-des-actions)
-3. [Gestion de l'état et récursivité](#gestion-de-letat-et-recursivité)
-4. [Installation et configuration](#installation-et-configuration)
-5. [Exemple d'utilisation](#exemple-dutilisation)
-6. [Travaux en cours (WIP)](#travaux-en-cours-wip)
-
----
-
-## Composants d'architecture
-
-### Runtime de l'agent
-
-Le `AgentRuntime` est le moteur principal qui coordonne le workflow global. Il connecte tous les composants et garantit que les tâches sont exécutées efficacement.
-
-**Responsabilités :**
-
-- Construire un contexte pour l'état actuel à l'aide des systèmes de mémoire (RAG et CAG).
-- Orchestrer les actions à l'aide du gestionnaire de file d'attente.
-- Exploiter les interpréteurs pour analyser les résultats et générer des réponses.
-
-#### Construction du contexte
-
-La méthode `buildContext` crée un contexte complet en :
-
-1. Ajoutant les outils et les demandes utilisateur.
-2. Récupérant les actions récentes via la mémoire cache (CAG).
-3. Cherchant les connaissances pertinentes dans la mémoire persistante (RAG).
-4. Incluant les interpréteurs disponibles pour la demande.
-
-#### Traitement des workflows
-
-La méthode `process` :
-
-1. Génère des réponses basées sur le contexte à l'aide d'un modèle de langage.
-2. Gère les workflows récursifs pour l'exécution des actions.
-3. Sélectionne les interpréteurs appropriés pour analyser les résultats.
-
----
-
-### Orchestrateur
-
-L'**orchestrateur** dirige les workflows en analysant les entrées utilisateur et en planifiant les actions. Il interagit avec les outils, les systèmes de mémoire et les interpréteurs pour garantir une exécution logique.
-
-**Caractéristiques clés :**
-
-- Sélection dynamique des actions en fonction du contexte.
-- Gestion des interactions mémoire pour les opérations RAG et CAG.
-- Gestion des workflows multi-étapes avec affinage itératif.
-
----
-
-### Gestionnaire de file d'attente
-
-Le **gestionnaire de file d'attente** est chargé d'organiser et d'exécuter les actions dans le bon ordre, qu'elles soient séquentielles ou parallèles. Il agit comme le mécanisme central pour gérer les workflows, en s'assurant que chaque action est correctement mise en file d'attente, validée et exécutée.
-
-**Responsabilités principales :**
-
-1. **Mise en file d'attente des actions :**
-
-   - Les actions sont ajoutées à une file pour exécution, individuellement ou en lot.
-   - Prise en charge des journaux pour le débogage et la traçabilité.
-
-2. **Traitement des actions :**
-
-   - Exécute les actions en maintenant le bon ordre.
-   - Respecte les dépendances entre les actions.
-   - Gère les erreurs ou confirmations via des rappels.
-
-3. **Gestion des confirmations :**
-   - Prend en charge les invites de confirmation pour les actions critiques.
-   - S'appuie sur des rappels pour décider de poursuivre des actions spécifiques.
-
-**Exemple :**
-
-```typescript
-import { ActionQueueManager } from "@ai-ntellect/core";
-import { actions, callbacks } from "@ai-ntellect/core/examples";
-
-const queueManager = new ActionQueueManager(actions, callbacks);
-queueManager.addToQueue([{ name: "fetch-data", parameters: [...] }]);
-const results = await queueManager.processQueue();
-console.log("Résultats :", results);
-```
-
----
-
-### Interpréteur
-
-L'**interpréteur** se spécialise dans l'analyse des résultats et la génération d'informations spécifiques à un domaine. Chaque interpréteur est adapté à un cas d'utilisation particulier et utilise sa propre configuration de caractère.
-
-**Exemples :**
-
-1. **MarketInterpreter** : Analyse des données financières de marché.
-2. **SecurityInterpreter** : Vérification de la sécurité.
-3. **GeneralInterpreter** : Traitement des demandes générales.
-
-#### Workflow d'interprétation
-
-1. Construit un contexte avec l'état actuel, y compris les résultats et les demandes utilisateur.
-2. Utilise le modèle de langage pour générer des informations exploitables.
-3. Fournit des réponses détaillées pour l'utilisateur final.
-
----
-
-### Système de mémoire
-
-L'architecture mémoire combine une mémoire à court terme et une mémoire à long terme pour fournir un traitement contextuel.
-
-#### Types de mémoire
-
-1. **Mémoire cache (Redis) :**
-   - Stocke des données temporaires pour un accès rapide.
-   - Exemples : Actions récentes, données de session.
-2. **Mémoire persistante (Meilisearch) :**
-   - Stocke des données à long terme comme les interactions historiques et les connaissances.
-   - Permet des recherches sémantiques et des récupérations basées sur des vecteurs.
-
----
-
-### Listeners
-
-Les **listeners** permettent de se connecter à des événements externes via WebSocket. Ils écoutent les mises à jour en temps réel et déclenchent des actions ou des callbacks spécifiques en réponse aux événements.
-
-**Caractéristiques principales :**
-
-- Connexion à des WebSockets pour écouter les événements.
-- Gestion des abonnements avec des messages personnalisés.
-- Déclenchement de callbacks pour traiter les données reçues.
-
-**Exemple d'utilisation :**
-
-```typescript
-agent.addListener(
-  "listener-id",
-  "wss://example.com/socket",
-  () => JSON.stringify({ action: "subscribe" }),
-  async (data) => {
-    console.log("Data reçue :", data);
-  }
-);
-```
-
----
-
-### Schedulers
-
-Les **schedulers** permettent de planifier des tâches ou actions pour une exécution ultérieure. Ils utilisent des expressions cron pour définir les intervalles de planification.
-
-**Caractéristiques principales :**
-
-- Planification basée sur des expressions cron.
-- Support des tâches récurrentes et non récurrentes.
-- Gestion et annulation des tâches planifiées.
-
-**Exemple d'utilisation :**
-
-```typescript
-const scheduler = new TaskScheduler(agentRuntime, redisCache);
-
-const taskId = await scheduler.scheduleRequest({
-  originalRequest: "Analyse de marché",
-  cronExpression: "0 9 * * *", // Tous les jours à 9h
-});
-
-console.log(`Tâche planifiée avec ID : ${taskId}`);
-
-// Annuler la tâche si nécessaire
-scheduler.cancelScheduledRequest(taskId);
-```
-
----
-
-## Définir et exécuter des actions
-
-### Qu'est-ce qu'une action ?
-
-Les actions sont les tâches fondamentales exécutées par le framework. Chaque action comprend :
-
-- Un nom et une description uniques.
-- Des paramètres d'entrée validés à l'aide de schémas.
-- Une logique d'exécution encapsulée dans la méthode `execute`.
-
-### Exemple d'action
-
-```typescript
-import { z } from "zod";
-import { parseEther } from "ethers";
-
-export const prepareTransaction = {
-  name: "prepare-transaction",
-  description: "Prépare un transfert de token pour approbation utilisateur.",
-  parameters: z.object({
-    walletAddress: z.string(),
-    amount: z.string(),
-    networkId: z.string(),
-  }),
-  execute: async ({ walletAddress, amount, networkId }) => {
-    return {
-      to: walletAddress,
-      value: parseEther(amount).toString(),
-      network: networkId,
-    };
-  },
-};
-```
-
----
-
-## Gestion de l'état et récursivité
-
-L'agent gère l'état et les workflows récursifs pour s'assurer que les actions sont exécutées de manière ordonnée et jusqu'à leur achèvement, tout en respectant un maximum d'itérations pour éviter les boucles infinies.
-
-### Gestion de l'état
-
-L'état (`State`) contient :
-
-- `currentContext` : Contexte actuel de la requête utilisateur.
-- `previousActions` : Liste des actions exécutées précédemment.
-
-Lorsqu'une action est terminée, l'état est mis à jour pour inclure :
-
-- Les résultats des actions précédentes.
-- Le contexte restant à traiter.
-
-### Récursivité contrôlée
-
-Pour éviter les boucles infinies, le système limite le nombre d'itérations via la configuration `maxIterations`.
-
-**Fonctionnement :**
-
-1. **Initialisation :** À chaque itération, l'agent :
-
-   - Exécute les actions dans la file d'attente.
-   - Met à jour l'état avec les nouveaux résultats.
-
-2. **Validation des limites :**
-
-   - Si le nombre d'itérations dépasse `maxIterations`, le traitement est interrompu avec un message "Max iterations reached".
-
-3. **Récursivité :**
-   - Si des actions restent à exécuter, l'agent appelle récursivement la méthode `process` avec le nouvel état.
-
-**Exemple de gestion d'état et récursivité :**
-
-```typescript
-const updatedNextState: State = {
-  ...state,
-  currentContext: state.currentContext,
-  previousActions: [...(state.previousActions || []), ...(results || [])],
-};
-
-if (countIterations < this.config.maxIterations) {
-  return this.process(updatedNextState);
-} else {
-  console.log("Max iterations reached");
-  response.shouldContinue = false;
-}
-```
-
----
-
-## Installation et configuration
-
-### Installer les dépendances
-
-```bash
-npm install
-```
-
-### Configurer les services externes
-
-#### Redis (Mémoire cache)
-
-```bash
-docker run --name redis -d -p 6379:6379 redis
-```
-
-#### Meilisearch (Mémoire persistante)
-
-```bash
-curl -L https://install.meilisearch.com | sh
-./meilisearch --master-key="VOTRE_CLÉ_MAÎTRE"
-```
-
----
-
-## Exemple d'utilisation
-
-### Initialiser l'agent
-
-```typescript
-import { deepseek } from "@ai-ntellect/core";
-import { Agent } from "@ai-ntellect/core";
-import { checkHoneypot, fetchMarkPrice } from "@ai-ntellect/core/actions";
-import {
-  generalInterpreterCharacter,
-  marketInterpreterCharacter,
-  securityInterpreterCharacter,
-} from "@ai-ntellect/core/interpreter/context";
-
-const model = deepseek("deepseek-reasoner");
-
-const agent = new Agent({
-  orchestrator: {
-    model,
-    tools: [checkHoneypot, fetchMarkPrice],
-  },
-  interpreters: [
-    new Interpreter({
-      name: "security",
-      model,
-      character: securityInterpreterCharacter,
-    }),
-    new Interpreter({
-      name: "market",
-      model,
-      character: marketInterpreterCharacter,
-    }),
-    new Interpreter({
-      name: "general",
-      model,
-      character: generalInterpreterCharacter,
-    }),
-  ],
-  memoryManager: {
-    model,
-  },
-  maxIterations: 3,
-});
-```
-
-### Traiter une demande
-
-```typescript
-const state = {
-  currentContext: "Analyse des tendances de marché XRP/USD",
-  previousActions: [],
-};
-
-const result = await agent.process(state);
-console.log("Résultat :", result);
-```

package/agent/index.ts

@@ -1,244 +0,0 @@
-import { LanguageModel } from "ai";
-import WebSocket from "ws";
-import { Interpreter } from "../llm/interpreter";
-import { MemoryManager } from "../llm/memory-manager";
-import { AgentRuntime } from "../llm/orchestrator";
-import { State } from "../llm/orchestrator/types";
-import { CacheMemory } from "../memory/cache";
-import { PersistentMemory } from "../memory/persistent";
-import { ActionQueueManager } from "../services/queue";
-import { CacheConfig, RedisCache } from "../services/redis-cache";
-import { ActionData, ActionSchema, QueueCallbacks } from "../types";
-import { QueueItemTransformer } from "../utils/queue-item-transformer";
-
-export class Agent {
-  private readonly agent: AgentRuntime;
-  private readonly memoryManager: MemoryManager;
-  private readonly cache: RedisCache;
-
-  private listeners: Map<
-    string,
-    { socket: WebSocket; callback: (data: any) => Promise<void> }
-  > = new Map();
-  private readonly config: {
-    orchestrator: {
-      model: LanguageModel;
-      tools: ActionSchema[];
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    interpreters: Interpreter[];
-    memoryManager: {
-      model: LanguageModel;
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    maxIterations: number;
-  };
-
-  constructor(config: {
-    cache: CacheConfig;
-    orchestrator: {
-      model: LanguageModel;
-      tools: ActionSchema[];
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    interpreters: Interpreter[];
-    memoryManager: {
-      model: LanguageModel;
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    callbacks?: QueueCallbacks;
-    maxIterations: number;
-  }) {
-    this.cache = new RedisCache(config.cache);
-    this.config = config;
-    this.agent = new AgentRuntime(
-      config.orchestrator.model,
-      config.orchestrator.tools,
-      config.interpreters,
-      config.cache,
-      config.orchestrator.memory
-    );
-    this.memoryManager = new MemoryManager({
-      model: config.memoryManager.model,
-      memory: {
-        cache: config.memoryManager.memory?.cache ?? undefined,
-        persistent: config.memoryManager.memory?.persistent ?? undefined,
-      },
-    });
-    this.config.maxIterations = 3;
-  }
-
-  public async process(state: State, callbacks?: QueueCallbacks): Promise<any> {
-    console.log("🔄 Processing state:");
-    console.dir(state, { depth: null });
-    let countIterations = 0;
-    const response = await this.agent.process(state);
-
-    const unscheduledActions = response.actions.filter(
-      (action) => !action.scheduler?.isScheduled
-    );
-    // Execute actions if needed
-    if (unscheduledActions?.length > 0 && response.shouldContinue) {
-      console.log("\n📋 Processing action queue");
-      const queueManager = new ActionQueueManager(
-        this.config.orchestrator.tools,
-        callbacks
-      );
-      const queueItems = QueueItemTransformer.transformActionsToQueueItems(
-        response.actions as ActionData[]
-      );
-      if (!queueItems) {
-        throw new Error("No queue items found");
-      }
-
-      console.log(
-        "📋 Actions to execute:",
-        queueItems
-          .map((item) => (typeof item === "string" ? item : item.name))
-          .join(", ")
-      );
-
-      queueManager.addToQueue(queueItems);
-      console.log("\n⚡ Executing actions...");
-      const results = await queueManager.processQueue();
-      console.log("✅ Execution results:", results);
-
-      const updatedNextState: State = {
-        ...state,
-        currentContext: state.currentContext,
-        previousActions: [...(state.previousActions || []), ...(results || [])],
-      };
-
-      console.log("\n🔁 Recursively processing with updated state");
-      countIterations++;
-      if (countIterations < this.config.maxIterations) {
-        return this.process(updatedNextState);
-      }
-    }
-
-    if (countIterations >= this.config.maxIterations) {
-      console.log("Max iterations reached");
-      response.shouldContinue = false;
-      console.log("Forcing stop");
-    }
-
-    // Handle final interpretation
-    if (
-      !response.shouldContinue &&
-      state.previousActions?.length &&
-      response.interpreter
-    ) {
-      console.log("\n🏁 Analysis complete - generating final interpretation");
-      const interpreter = this.getInterpreter(
-        this.config.interpreters,
-        response.interpreter
-      );
-      console.log("🎭 Selected Interpreter:", interpreter?.name);
-      console.dir(state, { depth: null });
-      const interpretationResult = (await interpreter?.process(
-        "Interpret the analysis results",
-        {
-          ...state,
-          results: JSON.stringify(state.previousActions),
-          userRequest: state.currentContext,
-        }
-      )) as { response: string };
-
-      console.log("\n📊 Final Analysis:", interpretationResult.response);
-
-      const finalState: State = {
-        ...state,
-        results: interpretationResult.response,
-      };
-
-      console.log("🔄 Final state:", finalState);
-    }
-
-    // Return the final response at the end of the function
-    const validatedActions = response.actions.map((action) => ({
-      ...action,
-      parameters: action.parameters.map((param) => ({
-        ...param,
-        value: param.value ?? null, // Set a default value if undefined
-      })),
-    }));
-
-    const result = {
-      ...response,
-      actions: validatedActions,
-      results: JSON.stringify(state.previousActions),
-    };
-    if (!result.shouldContinue) {
-      await this.memoryManager.process(state, JSON.stringify(result));
-    }
-    return result;
-  }
-
-  private getInterpreter(interpreters: Interpreter[], name: string) {
-    return interpreters.find((interpreter) => interpreter.name === name);
-  }
-
-  public addListener(
-    id: string,
-    url: string,
-    subscriptionMessageFactory: () => string,
-    callback: (data: any, agentContext: Agent) => Promise<void>
-  ): void {
-    if (this.listeners.has(id)) {
-      console.warn(`WebSocket with ID ${id} already exists.`);
-      return;
-    }
-
-    const socket = new WebSocket(url);
-
-    const wrappedCallback = async (data: any) => {
-      await callback(data, this);
-    };
-
-    socket.on("open", () => {
-      console.log(`🔗 WebSocket connected for ID: ${id}`);
-
-      // Envoie le message d'abonnement si une factory est fournie
-      if (subscriptionMessageFactory) {
-        const subscriptionMessage = subscriptionMessageFactory();
-        socket.send(subscriptionMessage);
-        console.log(
-          `📡 Sent subscription message for ID ${id}:`,
-          subscriptionMessage
-        );
-      }
-    });
-
-    socket.on("message", async (message: string) => {
-      console.log(`📨 Message received for WebSocket ID ${id}:`, message);
-      try {
-        const data = JSON.parse(message);
-        await wrappedCallback(data);
-      } catch (error) {
-        console.error(`❌ Error in callback for WebSocket ID ${id}:`, error);
-      }
-    });
-
-    socket.on("error", (error) => {
-      console.error(`❌ WebSocket error for ID ${id}:`, error);
-    });
-
-    socket.on("close", () => {
-      console.log(`🔌 WebSocket closed for ID: ${id}`);
-    });
-
-    this.listeners.set(id, { socket, callback: wrappedCallback });
-  }
-}