@ai.ntellect/core 0.5.0 → 0.6.0

package/agent/index.ts

@@ -1,151 +0,0 @@
-import { LanguageModel } from "ai";
-import WebSocket from "ws";
-import { Interpreter } from "../llm/interpreter";
-import { MemoryManager } from "../llm/memory-manager";
-import { Orchestrator } from "../llm/orchestrator";
-import { CacheMemory } from "../memory/cache";
-import { PersistentMemory } from "../memory/persistent";
-import { CacheConfig, RedisCache } from "../services/cache";
-import { Workflow } from "../services/workflow";
-import { AgentEvent, MyContext, QueueCallbacks, SharedState } from "../types";
-import { createMainWorkflow } from "./workflow";
-
-export class Agent {
-  public readonly memoryManager: MemoryManager;
-  public readonly cache: RedisCache;
-  public readonly orchestrator: Orchestrator;
-  private listeners: Map<
-    string,
-    { socket: WebSocket; callback: (data: any) => Promise<void> }
-  > = new Map();
-  public readonly config: {
-    interpreters: Interpreter[];
-    orchestrator: Orchestrator;
-    memoryManager: {
-      model: LanguageModel;
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    maxIterations: number;
-  };
-
-  constructor(config: {
-    cache: CacheConfig;
-    interpreters: Interpreter[];
-    orchestrator: Orchestrator;
-    memoryManager: {
-      model: LanguageModel;
-      memory?: {
-        cache?: CacheMemory;
-        persistent?: PersistentMemory;
-      };
-    };
-    callbacks?: QueueCallbacks;
-    maxIterations: number;
-  }) {
-    this.cache = new RedisCache(config.cache);
-    this.config = config;
-
-    this.memoryManager = new MemoryManager({
-      model: config.memoryManager.model,
-      memory: {
-        cache: config.memoryManager.memory?.cache ?? undefined,
-        persistent: config.memoryManager.memory?.persistent ?? undefined,
-      },
-    });
-    this.orchestrator = config.orchestrator;
-    this.config.maxIterations = 3;
-  }
-
-  public async process(prompt: string, callbacks?: AgentEvent): Promise<any> {
-    console.log("🔄 Processing state:");
-    const agent = this;
-    const recentMessages = await this.cache.getRecentMessages();
-    const previousActions = await this.cache.getRecentPreviousActions(1);
-
-    const initialState: SharedState<MyContext> = {
-      messages: [...recentMessages, { role: "user", content: prompt }],
-      context: {
-        prompt,
-        processing: {
-          stop: false,
-        },
-        results: previousActions,
-      },
-    };
-
-    const mainWorkflow = createMainWorkflow(agent, prompt, callbacks);
-    const workflow = new Workflow<MyContext>(mainWorkflow);
-
-    await workflow.execute(
-      initialState,
-      mainWorkflow.entryNode,
-      async (state) => {
-        callbacks?.onMessage && (await callbacks.onMessage(state));
-      }
-    );
-  }
-
-  public getInterpreter(interpreters: Interpreter[], name: string) {
-    return interpreters.find((interpreter) => interpreter.name === name);
-  }
-
-  public addListener({
-    id,
-    url,
-    onSubscribe,
-    onMessage,
-  }: {
-    id: string;
-    url: string;
-    onSubscribe: () => string;
-    onMessage: (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 wrappedOnMessage = async (data: any) => {
-      await onMessage(data, this);
-    };
-
-    socket.on("open", () => {
-      console.log(`🔗 WebSocket connected for ID: ${id}`);
-
-      // Envoie le message d'abonnement si une factory est fournie
-      if (onSubscribe) {
-        const subscriptionMessage = onSubscribe();
-        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 wrappedOnMessage(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: wrappedOnMessage });
-  }
-}

package/agent/workflow/conditions.ts

@@ -1,16 +0,0 @@
-import { SharedState } from "../../types";
-
-export const hasActions = (state: SharedState<any>): boolean =>
-  !!state.context.actions && state.context.actions.length > 0;
-
-export const isNotStopped = (state: SharedState<any>): boolean =>
-  !state.context.processing?.stop;
-
-export const isInterpreterDefined = (state: SharedState<any>): boolean =>
-  !!state.context.interpreter;
-
-export const isResultsDefined = (state: SharedState<any>): boolean =>
-  !!state.context.results && state.context.results.length > 0;
-
-export const isStopped = (state: SharedState<any>): boolean =>
-  !!state.context.processing?.stop;

package/agent/workflow/handlers/interpreter.handler.ts

@@ -1,48 +0,0 @@
-import { Agent } from "../..";
-import { ActionData, MyContext, SharedState } from "../../../types";
-import { StateManager } from "../../../utils/state-manager";
-
-export const handleInterpreter = async (
-  sharedState: SharedState<MyContext>,
-  agent: Agent
-) => {
-  console.log("🔄 Interpreting actions");
-  const interpreter = agent.getInterpreter(
-    agent.config.interpreters,
-    sharedState.context.interpreter ?? ""
-  );
-
-  if (!interpreter) {
-    throw new Error("No interpreter found");
-  }
-
-  console.log("🎭 Selected Interpreter:", interpreter?.name);
-  (await interpreter?.process(sharedState, async (event: any) => {
-    console.log("🎭 Interpreter event:", event);
-
-    // Store message in recent messages
-    await agent.cache.storeMessage("assistant", event.response);
-  })) as { response: string };
-
-  const validatedActions = sharedState.context.actions?.map(
-    (action: ActionData) => ({
-      ...action,
-      name: action.name || "default", // Ensure name is always defined
-      parameters:
-        action.parameters?.map((param: { value: string }) => ({
-          ...param,
-          value: param.value ?? null,
-        })) ?? [],
-    })
-  );
-
-  return StateManager.updateState(sharedState, {
-    context: {
-      actions: validatedActions,
-      prompt: sharedState.context.prompt,
-      processing: {
-        stop: true,
-      },
-    },
-  });
-};

package/agent/workflow/handlers/memory.handler.ts

@@ -1,106 +0,0 @@
-import { Agent } from "../..";
-import { MemoryScope, MyContext, SharedState } from "../../../types";
-import { StateManager } from "../../../utils/state-manager";
-
-export const handleMemory = async (
-  sharedState: SharedState<MyContext>,
-  agent: Agent
-) => {
-  console.log("🔄 Storing memories");
-  const recentMessages = await agent.cache.getRecentMessages();
-
-  const updatedState = StateManager.updateState(sharedState, {
-    messages: recentMessages,
-  });
-
-  await agent.memoryManager.process(updatedState, {
-    onMemoriesGenerated: async (event) => {
-      if (event.memories.length === 0) {
-        return;
-      }
-      // Store memories after all processing is complete
-      await Promise.all([
-        // Store short-term memories in cache
-        ...event.memories
-          .filter((m: any) => m.type === "short-term")
-          .map(async (memoryItem: any) => {
-            await agent.cache.storeMemory(
-              memoryItem.data,
-              memoryItem.category,
-              memoryItem.tags,
-              memoryItem.ttl
-            );
-
-            const existingCacheMemories =
-              await agent.memoryManager.memory?.cache?.findSimilarActions(
-                memoryItem.data,
-                {
-                  similarityThreshold: 85,
-                  maxResults: 3,
-                  scope: MemoryScope.GLOBAL,
-                }
-              );
-
-            if (
-              existingCacheMemories?.length &&
-              existingCacheMemories.length > 0
-            ) {
-              console.log(
-                "⚠️ Similar memory already exists in cache:",
-                memoryItem.data
-              );
-              return;
-            }
-
-            await agent.memoryManager.memory?.cache?.createMemory({
-              query: memoryItem.queryForMemory,
-              data: memoryItem.data,
-              ttl: memoryItem.ttl, // Use TTL from LLM
-            });
-            console.log("✅ Memory stored in cache:", memoryItem.data);
-          }),
-
-        // Store long-term memories in persistent storage
-        ...event.memories
-          .filter((m: any) => m.type === "long-term")
-          .map(async (memoryItem: any) => {
-            if (!agent.memoryManager.memory?.persistent) {
-              return;
-            }
-
-            const existingPersistentMemories =
-              await agent.memoryManager.memory?.persistent?.findRelevantDocuments(
-                memoryItem.data,
-                {
-                  similarityThreshold: 85,
-                }
-              );
-
-            if (
-              existingPersistentMemories?.length &&
-              existingPersistentMemories.length > 0
-            ) {
-              console.log(
-                "⚠️ Similar memory already exists in persistent storage:",
-                memoryItem.data
-              );
-              return;
-            }
-
-            await agent.memoryManager.memory?.persistent?.createMemory({
-              query: memoryItem.queryForMemory,
-              data: memoryItem.data,
-              category: memoryItem.category,
-              tags: memoryItem.tags,
-              roomId: "global",
-              createdAt: new Date(),
-              id: crypto.randomUUID(),
-            });
-            console.log("✅ Memory stored in persistent storage:", memoryItem);
-          }),
-      ]);
-    },
-  });
-
-  return updatedState;
-};

package/agent/workflow/handlers/orchestrator.handler.ts

@@ -1,23 +0,0 @@
-import { Agent } from "../..";
-import { AgentEvent, MyContext, SharedState } from "../../../types";
-import { StateManager } from "../../../utils/state-manager";
-
-export const handleOrchestrator = async (
-  prompt: string,
-  sharedState: SharedState<MyContext>,
-  agent: Agent,
-  callbacks?: AgentEvent
-) => {
-  try {
-    const result = await agent.orchestrator.process(sharedState);
-
-    return StateManager.updateState(sharedState, {
-      context: {
-        ...result,
-      },
-    });
-  } catch (error) {
-    console.error("🔄 Start handler error:", error);
-    throw error;
-  }
-};

package/agent/workflow/handlers/queue.handler.ts

@@ -1,34 +0,0 @@
-import { Agent } from "../..";
-import { Queue } from "../../../services/queue";
-import { ActionData, AgentEvent, MyContext, SharedState } from "../../../types";
-import { QueueItemTransformer } from "../../../utils/queue-item-transformer";
-import { StateManager } from "../../../utils/state-manager";
-
-export const handleQueue = async (
-  sharedState: SharedState<MyContext>,
-  agent: Agent,
-  callbacks?: AgentEvent
-) => {
-  console.log("🔄 Queue actions:", sharedState.context.actions);
-  const queue = new Queue(agent.config.orchestrator.tools, callbacks);
-  const queueItems = QueueItemTransformer.transformActionsToQueueItems(
-    sharedState.context.actions as ActionData[]
-  );
-  if (!queueItems) {
-    throw new Error("No queue items found");
-  }
-  queue.add(queueItems);
-  const results = await queue.execute();
-  if (results) {
-    await agent.cache.storePreviousActions(crypto.randomUUID(), results);
-  }
-
-  return StateManager.updateState(sharedState, {
-    context: {
-      results,
-      processing: {
-        stop: false,
-      },
-    },
-  });
-};

package/agent/workflow/handlers/scheduler.handler.ts

@@ -1,61 +0,0 @@
-import { CoreMessage } from "ai";
-import { Agent } from "../..";
-import { MyContext, SharedState } from "../../../types";
-
-export const handleScheduler = async (
-  prompt: string,
-  sharedState: SharedState<MyContext>,
-  agent: Agent
-) => {
-  for (const action of sharedState.context.actions ?? []) {
-    if (action.scheduler?.isScheduled && action.scheduler?.cronExpression) {
-      await agent.agenda.scheduleRequest(
-        {
-          originalRequest: prompt,
-          cronExpression: action.scheduler.cronExpression,
-        },
-        {
-          onScheduled: (id) => {
-            console.log("🔄 Scheduled action:", id);
-          },
-          onExecuted: async (id, originalRequest) => {
-            console.log("🔄 Executed action:", id);
-
-            // Add context about when this request was scheduled
-            const contextualRequest = `You are a scheduler. 
-    You were asked to execute this request: ${originalRequest}\n 
-    Date of the request: ${new Date().toISOString()}\n
-    Act like if you know the request was scheduled.
-    Don't reschedule the same action. 
-    Just execute it.`;
-
-            const updatedSharedState = {
-              ...sharedState,
-              messages: [
-                {
-                  role: "user",
-                  content: contextualRequest,
-                },
-                ...(sharedState.messages ?? []),
-              ] as CoreMessage[],
-              context: {
-                ...sharedState.context,
-                originalRequest,
-              },
-            };
-
-            // Process the request as if it was just received
-            const result = await agent.orchestrator.process(updatedSharedState);
-
-            // Store the new actions in cache
-            if (result.actions.length > 0) {
-              await agent.cache.storePreviousActions(id, result.actions);
-            }
-          },
-        }
-      );
-    }
-  }
-
-  return sharedState;
-};

package/agent/workflow/index.ts

@@ -1,62 +0,0 @@
-import { Agent } from "..";
-import { MyContext, WorkflowDefinition } from "../../types";
-import {
-  hasActions,
-  isInterpreterDefined,
-  isNotStopped,
-  isResultsDefined,
-  isStopped,
-} from "./conditions";
-import { handleInterpreter } from "./handlers/interpreter.handler";
-import { handleMemory } from "./handlers/memory.handler";
-import { handleOrchestrator } from "./handlers/orchestrator.handler";
-import { handleQueue } from "./handlers/queue.handler";
-import { handleScheduler } from "./handlers/scheduler.handler";
-
-export const createMainWorkflow = (
-  agent: Agent,
-  prompt: string,
-  callbacks?: any
-): WorkflowDefinition<MyContext> => ({
-  name: "agentWorkflow", // Name of the graph
-  entryNode: "makeDecision", // Entry node
-  nodes: {
-    makeDecision: {
-      name: "makeDecision",
-      description: "Make a decision following the environment",
-      execute: async (state) =>
-        handleOrchestrator(prompt, state, agent, callbacks),
-      condition: (state) => isNotStopped(state), // Check if the agent is not stopped
-      next: ["checkEnvironment", "scheduleActions", "interpretResults"], // Next nodes to execute
-    },
-    checkEnvironment: {
-      name: "checkEnvironment", // Check the environment
-      description: "Check the environment for any actions to handle",
-      execute: async (state) => handleQueue(state, agent, callbacks),
-      condition: (state) => hasActions(state) && isNotStopped(state), // Check if there are actions to handle and the agent is not stopped
-      next: ["makeDecision"],
-    },
-    scheduleActions: {
-      name: "scheduleActions",
-      description: "Schedule actions for the future",
-      execute: async (state) => handleScheduler(prompt, state, agent),
-      condition: (state) => hasActions(state), // Check if there are actions to schedule
-    },
-    interpretResults: {
-      name: "interpretResults",
-      description: "Interpret the results of the actions",
-      execute: async (state) => handleInterpreter(state, agent),
-      condition: (state) =>
-        isInterpreterDefined(state) && // Check if interpreter is defined
-        isResultsDefined(state) && // Check if results are defined
-        isStopped(state), // Check if processing is stopped
-      next: ["saveMemory"],
-    },
-    saveMemory: {
-      name: "saveMemory",
-      description: "Save memory",
-      execute: async (state) => handleMemory(state, agent),
-      condition: (state) => isResultsDefined(state), // Check if results are defined
-    },
-  },
-});

package/dist/agent/index.d.ts

@@ -1,38 +0,0 @@
-import { LanguageModel } from "ai";
-import { Interpreter } from "../llm/interpreter";
-import { State } from "../llm/orchestrator/types";
-import { CacheMemory } from "../memory/cache";
-import { PersistentMemory } from "../memory/persistent";
-import { CacheConfig } from "../services/redis-cache";
-import { ActionSchema, QueueCallbacks } from "../types";
-export declare class Agent {
-    private readonly agent;
-    private readonly memoryManager;
-    private readonly cache;
-    private listeners;
-    private readonly config;
-    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;
-    });
-    process(state: State, callbacks?: QueueCallbacks): Promise<any>;
-    private getInterpreter;
-    addListener(id: string, url: string, subscriptionMessageFactory: () => string, callback: (data: any, agentContext: Agent) => Promise<void>): void;
-}

package/dist/agent/index.js

@@ -1,143 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = void 0;
-const ws_1 = __importDefault(require("ws"));
-const memory_manager_1 = require("../llm/memory-manager");
-const orchestrator_1 = require("../llm/orchestrator");
-const queue_1 = require("../services/queue");
-const redis_cache_1 = require("../services/redis-cache");
-const queue_item_transformer_1 = require("../utils/queue-item-transformer");
-class Agent {
-    constructor(config) {
-        this.listeners = new Map();
-        this.cache = new redis_cache_1.RedisCache(config.cache);
-        this.config = config;
-        this.agent = new orchestrator_1.AgentRuntime(config.orchestrator.model, config.orchestrator.tools, config.interpreters, config.cache, config.orchestrator.memory);
-        this.memoryManager = new memory_manager_1.MemoryManager({
-            model: config.memoryManager.model,
-            memory: {
-                cache: config.memoryManager.memory?.cache ?? undefined,
-                persistent: config.memoryManager.memory?.persistent ?? undefined,
-            },
-        });
-        this.config.maxIterations = 3;
-    }
-    async process(state, callbacks) {
-        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 queue_1.ActionQueueManager(this.config.orchestrator.tools, callbacks);
-            const queueItems = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(response.actions);
-            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,
-                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,
-            }));
-            console.log("\n📊 Final Analysis:", interpretationResult.response);
-            const finalState = {
-                ...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;
-    }
-    getInterpreter(interpreters, name) {
-        return interpreters.find((interpreter) => interpreter.name === name);
-    }
-    addListener(id, url, subscriptionMessageFactory, callback) {
-        if (this.listeners.has(id)) {
-            console.warn(`WebSocket with ID ${id} already exists.`);
-            return;
-        }
-        const socket = new ws_1.default(url);
-        const wrappedCallback = async (data) => {
-            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) => {
-            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 });
-    }
-}
-exports.Agent = Agent;