@ai.ntellect/core 0.4.1 → 0.5.0

package/llm/orchestrator/index.ts

@@ -1,30 +1,17 @@
-import { LanguageModelV1 } from "ai";
+import { generateObject, LanguageModelV1 } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionQueueManager } from "../../services/queue";
-import { CacheConfig, RedisCache } from "../../services/redis-cache";
-import { TaskScheduler } from "../../services/scheduler";
-import {
-  ActionSchema,
-  GenerateObjectResponse,
-  MemoryScope,
-  QueueCallbacks,
-} from "../../types";
-import { generateObject } from "../../utils/generate-object";
+import { ActionSchema, MemoryScope, MyContext, SharedState } from "../../types";
 import { LLMHeaderBuilder } from "../../utils/header-builder";
 import { injectActions } from "../../utils/inject-actions";
 import { Interpreter } from "../interpreter";
 import { orchestratorInstructions } from "./context";
-import { State } from "./types";
 
-export class AgentRuntime {
+export class Orchestrator {
   private readonly model: LanguageModelV1;
   private readonly tools: ActionSchema[];
   private readonly interpreters: Interpreter[];
-  private readonly queueManager: ActionQueueManager;
-  private readonly scheduler: TaskScheduler;
-  private readonly cache: RedisCache;
   private memory?: {
     persistent?: PersistentMemory;
     cache?: CacheMemory;
@@ -34,23 +21,18 @@ export class AgentRuntime {
     model: LanguageModelV1,
     tools: ActionSchema[],
     interpreters: Interpreter[],
-    redisConfig: CacheConfig,
     memory?: {
       persistent?: PersistentMemory;
       cache?: CacheMemory;
-    },
-    callbacks?: QueueCallbacks
+    }
   ) {
     this.model = model;
     this.tools = tools;
     this.interpreters = interpreters;
-    this.queueManager = new ActionQueueManager(tools, callbacks);
     this.memory = memory;
-    this.cache = new RedisCache(redisConfig);
-    this.scheduler = new TaskScheduler(this, this.cache);
   }
 
-  private async buildContext(state: State): Promise<string> {
+  private async buildContext(state: SharedState<MyContext>): Promise<string> {
     console.log("🧠 Building context with RAG and CAG...");
     const context = LLMHeaderBuilder.create();
 
@@ -65,18 +47,10 @@ export class AgentRuntime {
     // Add tools to context
     context.addHeader("TOOLS", injectActions(this.tools));
 
-    // Add previous actions if any
-    if (state.previousActions?.length) {
-      context.addHeader(
-        "PREVIOUS_ACTIONS",
-        JSON.stringify(state.previousActions)
-      );
-    }
-
     // Get recent similar actions (CAG)
-    if (this.memory?.cache) {
+    if (this.memory?.cache && state.messages) {
       const cacheMemories = await this.memory.cache.findSimilarActions(
-        state.currentContext,
+        state.messages[state.messages.length - 1].content.toString(),
         {
           similarityThreshold: 80,
           maxResults: 3,
@@ -90,10 +64,10 @@ export class AgentRuntime {
     }
 
     // Get relevant knowledge (RAG)
-    if (this.memory?.persistent) {
+    if (this.memory?.persistent && state.messages) {
       const persistentMemory =
         await this.memory.persistent.findRelevantDocuments(
-          state.currentContext,
+          state.messages[state.messages.length - 1].content.toString(),
           {
             similarityThreshold: 80,
           }
@@ -109,15 +83,25 @@ export class AgentRuntime {
 
     // Add available interpreters
     context.addHeader(
-      "AVAILABLE_INTERPRETERS",
+      "INTERPRETERS (choose one)",
       JSON.stringify(this.interpreters.map((i) => i.name))
+        .replace("[", "")
+        .replace("]", "")
     );
-    console.log("Context built with memories", context.toString());
     return context.toString();
   }
 
-  async process(state: State): Promise<{
-    shouldContinue: boolean;
+  async process(
+    state: SharedState<MyContext>,
+    callbacks?: {
+      onStart?: () => void;
+      onFinish?: (event: any) => void;
+    }
+  ): Promise<{
+    processing: {
+      stop: boolean;
+      stopReason?: string;
+    };
     actions: Array<{
       name: string;
       parameters: Array<{
@@ -126,37 +110,40 @@ export class AgentRuntime {
       }>;
       scheduler?: {
         isScheduled: boolean;
-        scheduledAtInC?: string;
-        interval?: string;
+        cronExpression?: string;
         reason?: string;
       };
     }>;
-    socialResponse?: {
-      shouldRespond: boolean;
-      response?: string;
-      isPartialResponse?: boolean;
-    };
-    interpreter?: string;
+    response: string;
+    interpreter?: string | null;
     results?: string;
   }> {
-    console.log("🔄 Processing state:");
-    console.dir(state, { depth: null });
-    if (state.previousActions?.length) {
-      console.log(
-        "📊 Previous actions:",
-        state.previousActions
-          .map((a) => (typeof a === "string" ? a : a.name))
-          .join(", ")
-      );
-    }
+    if (callbacks?.onStart) callbacks.onStart();
 
     const context = await this.buildContext(state);
+    let prompt = LLMHeaderBuilder.create();
+    if (state.messages) {
+      prompt.addHeader(
+        "REQUEST",
+        state.messages[state.messages.length - 1].content.toString()
+      );
+
+      if (state.messages.length > 1) {
+        prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
+      }
+    }
+    if (state.context.results) {
+      prompt.addHeader("ACTIONS_DONE", JSON.stringify(state.context.results));
+    }
 
-    console.log("\n🧠 Generating response from LLM...");
-    const response = await generateObject<GenerateObjectResponse>({
+    console.log("\n🧠 Generating response from Orchestrator...");
+    const response = await generateObject({
       model: this.model,
       schema: z.object({
-        shouldContinue: z.boolean(),
+        processing: z.object({
+          stop: z.boolean(),
+          reason: z.string(),
+        }),
         actions: z.array(
           z.object({
             name: z.string(),
@@ -166,67 +153,40 @@ export class AgentRuntime {
                 value: z.any(),
               })
             ),
-            scheduler: z
-              .object({
-                isScheduled: z.boolean(),
-                cronExpression: z.string().optional(),
-                reason: z.string().optional(),
-              })
-              .optional(),
+            scheduler: z.object({
+              isScheduled: z.boolean(),
+              cronExpression: z.string(),
+              reason: z.string(),
+            }),
           })
         ),
-        socialResponse: z
-          .object({
-            shouldRespond: z.boolean(),
-            response: z.string().optional(),
-            isPartialResponse: z.boolean().optional(),
-          })
-          .optional(),
-        interpreter: z.string().optional(),
+        response: z.string(),
+        interpreter: z.string().or(z.null()),
       }),
-      prompt: state.currentContext,
       system: context.toString(),
       temperature: 0,
+      prompt: prompt.toString(),
     });
     console.log("🔄 Orchestrator response:");
     console.dir(response.object, { depth: null });
 
     // Force shouldContinue to false if no actions are planned
     if (response.object.actions.length === 0) {
-      response.object.shouldContinue = false;
-      console.log("⚠️ No actions planned, forcing shouldContinue to false");
+      response.object.processing.stop = true;
+      console.log("⚠️ No actions planned, forcing isProcessing to false");
     }
 
     // Handle social interactions and actions in a single block
-    if (response.object.socialResponse?.shouldRespond) {
+    if (response.object.response) {
       console.log("\n💬 Processing social response");
-      if (response.object.socialResponse.response) {
-        console.log("📢 Response:", response.object.socialResponse.response);
+      if (response.object.response) {
+        console.log("📢 Response:", response.object.response);
         // Ensure all parameters have a value property
       }
     }
 
-    // Handle scheduled actions
-    for (const action of response.object.actions) {
-      if (action.scheduler?.isScheduled) {
-        await this.scheduler.scheduleRequest({
-          originalRequest: state.currentContext,
-          cronExpression: action.scheduler.cronExpression,
-        });
-      }
-    }
-
-    // Store actions in Redis cache
-    if (response.object.actions.length > 0) {
-      const requestId = crypto.randomUUID();
-      await this.cache.storePreviousActions(requestId, response.object.actions);
-    }
-
-    // Store message in recent messages
-    await this.cache.storeRecentMessage(state.currentContext, {
-      socialResponse: response.object.socialResponse,
-    });
+    if (callbacks?.onFinish) callbacks.onFinish(response.object);
 
-    return response.object;
+    return response.object as any;
   }
 }

package/llm/orchestrator/types.ts

@@ -1,11 +1,11 @@
+import { CoreMessage } from "ai";
 import { QueueResult } from "../../types";
 
 export interface State {
   currentContext: string;
   previousActions: (string | QueueResult)[];
-  reward?: number;
-  userRequest?: string;
   results?: string;
+  recentMessages: CoreMessage[];
 }
 
 export interface Action {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -16,7 +16,9 @@
     "@ai-sdk/openai": "1.0.6",
     "@types/node-cron": "^3.0.11",
     "ai": "^3.0.0",
+    "chalk": "^5.4.1",
     "ethers": "^6.13.5",
+    "ioredis": "^5.4.2",
     "langchain": "^0.3.11",
     "node-cron": "^3.0.3",
     "readline": "^1.3.0",

package/script.js

@@ -0,0 +1,167 @@
+// Dimensions de l'espace SVG
+const width = 800;
+const height = 600;
+
+// Exemple de données pour les nœuds et les arêtes
+const nodes = [
+  { id: "fetchData", name: "Fetch Data", group: 1, selected: false },
+  { id: "analyzeData", name: "Analyze Data", group: 1, selected: false },
+  { id: "sendAlert", name: "Send Alert", group: 1, selected: false },
+];
+
+const links = [
+  { source: "fetchData", target: "analyzeData" },
+  { source: "analyzeData", target: "sendAlert" },
+];
+
+// Simulation de force
+const simulation = d3
+  .forceSimulation(nodes)
+  .force(
+    "link",
+    d3.forceLink(links).id((d) => d.id)
+  )
+  .force("charge", d3.forceManyBody().strength(-300))
+  .force("center", d3.forceCenter(width / 2, height / 2));
+
+// Créer le conteneur SVG
+const svg = d3.select("#graph").attr("width", width).attr("height", height);
+
+// Groupes pour liens et nœuds
+const linkGroup = svg
+  .append("g")
+  .attr("class", "links")
+  .attr("stroke", "#999")
+  .attr("stroke-opacity", 0.6);
+
+const nodeGroup = svg.append("g").attr("class", "nodes");
+
+// Fonction pour mettre à jour le graphe
+function updateGraph() {
+  // Mettre à jour les liens
+  const link = linkGroup.selectAll("line").data(links);
+
+  link
+    .enter()
+    .append("line")
+    .attr("stroke-width", 2)
+    .merge(link)
+    .attr("x1", (d) => d.source.x)
+    .attr("y1", (d) => d.source.y)
+    .attr("x2", (d) => d.target.x)
+    .attr("y2", (d) => d.target.y);
+
+  link.exit().remove();
+
+  // Mettre à jour les nœuds
+  const node = nodeGroup.selectAll("circle").data(nodes, (d) => d.id);
+
+  node.exit().remove();
+
+  const nodeEnter = node
+    .enter()
+    .append("circle")
+    .attr("r", 20)
+    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"))
+    .attr("stroke", "#fff")
+    .attr("stroke-width", 1.5)
+    .call(
+      d3
+        .drag()
+        .on("start", dragstarted)
+        .on("drag", dragged)
+        .on("end", dragended)
+    )
+    .on("click", nodeClicked);
+
+  nodeEnter
+    .merge(node)
+    .attr("cx", (d) => d.x)
+    .attr("cy", (d) => d.y)
+    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"));
+
+  // Ajouter des labels
+  const label = nodeGroup.selectAll("text").data(nodes);
+
+  label.exit().remove();
+
+  label
+    .enter()
+    .append("text")
+    .attr("dy", 4)
+    .attr("dx", 25)
+    .merge(label)
+    .attr("x", (d) => d.x)
+    .attr("y", (d) => d.y)
+    .text((d) => d.name);
+
+  simulation.on("tick", () => {
+    link
+      .attr("x1", (d) => d.source.x)
+      .attr("y1", (d) => d.source.y)
+      .attr("x2", (d) => d.target.x)
+      .attr("y2", (d) => d.target.y);
+
+    node.attr("cx", (d) => d.x).attr("cy", (d) => d.y);
+
+    label.attr("x", (d) => d.x + 25).attr("y", (d) => d.y);
+  });
+
+  updateWorkflowOrder();
+}
+
+// Fonction pour mettre à jour l'ordre du workflow
+function updateWorkflowOrder() {
+  const selectedNodes = nodes.filter((node) => node.selected);
+  if (selectedNodes.length > 0) {
+    workflowOrder = selectedNodes.map((node) => node.name);
+  } else {
+    const startNode = nodes.find(
+      (node) => !links.some((link) => link.target === node.id)
+    );
+
+    if (!startNode) {
+      workflowOrder = [];
+      console.log("Workflow Order: []");
+      return;
+    }
+
+    workflowOrder = [];
+    let currentNode = startNode;
+    while (currentNode) {
+      workflowOrder.push(currentNode.name);
+      const nextLink = links.find((link) => link.source === currentNode.id);
+      currentNode = nextLink
+        ? nodes.find((node) => node.id === nextLink.target)
+        : null;
+    }
+  }
+  console.log("Workflow Order:", workflowOrder);
+}
+
+// Gestion de la sélection multiple
+function nodeClicked(event, node) {
+  node.selected = !node.selected;
+  updateGraph();
+}
+
+// Gestion du drag & drop
+function dragstarted(event, d) {
+  if (!event.active) simulation.alphaTarget(0.3).restart();
+  d.fx = d.x;
+  d.fy = d.y;
+}
+
+function dragged(event, d) {
+  d.fx = event.x;
+  d.fy = event.y;
+}
+
+function dragended(event, d) {
+  if (!event.active) simulation.alphaTarget(0);
+  d.fx = null;
+  d.fy = null;
+}
+
+// Initialisation
+updateGraph();

package/services/{scheduler.ts → agenda.ts}

@@ -1,6 +1,6 @@
 import cron from "node-cron";
-import { AgentRuntime } from "../llm/orchestrator";
-import { RedisCache } from "./redis-cache";
+import { Orchestrator } from "../llm/orchestrator";
+import { RedisCache } from "./cache";
 
 interface ScheduledRequest {
   id: string;
@@ -10,24 +10,30 @@ interface ScheduledRequest {
   createdAt: Date;
 }
 
-export class TaskScheduler {
+export class Agenda {
   private scheduledRequests: Map<string, ScheduledRequest> = new Map();
   private cronJobs: Map<string, cron.ScheduledTask> = new Map();
-  private readonly agentRuntime: AgentRuntime;
+  private readonly orchestrator: Orchestrator;
   private readonly cache: RedisCache;
 
-  constructor(agentRuntime: AgentRuntime, cache: RedisCache) {
-    this.agentRuntime = agentRuntime;
+  constructor(orchestrator: Orchestrator, cache: RedisCache) {
+    this.orchestrator = orchestrator;
     this.cache = cache;
   }
 
   /**
    * Schedule a new request to be processed later
    */
-  async scheduleRequest(request: {
-    originalRequest: string;
-    cronExpression: string;
-  }): Promise<string> {
+  async scheduleRequest(
+    request: {
+      originalRequest: string;
+      cronExpression: string;
+    },
+    callbacks?: {
+      onScheduled?: (id: string) => void;
+      onExecuted?: (id: string, originalRequest: string) => void;
+    }
+  ): Promise<string> {
     const id = crypto.randomUUID();
 
     const scheduledRequest: ScheduledRequest = {
@@ -42,6 +48,9 @@ export class TaskScheduler {
     const cronJob = cron.schedule(request.cronExpression, async () => {
       await this.executeScheduledRequest(scheduledRequest);
 
+      if (callbacks?.onExecuted)
+        callbacks.onExecuted(id, scheduledRequest.originalRequest);
+
       if (!scheduledRequest.isRecurring) {
         this.cancelScheduledRequest(id);
       }
@@ -51,9 +60,7 @@ export class TaskScheduler {
     this.scheduledRequests.set(id, scheduledRequest);
     this.cronJobs.set(id, cronJob);
 
-    console.log(
-      `✅ Request scheduled with cron expression: ${request.cronExpression}`
-    );
+    if (callbacks?.onScheduled) callbacks.onScheduled(id);
 
     return id;
   }
@@ -67,28 +74,6 @@ export class TaskScheduler {
     try {
       console.log(`🔄 Executing scheduled request from ${request.createdAt}`);
 
-      // Récupérer les actions précédentes du cache
-      const previousActions = await this.cache.getPreviousActions(request.id);
-
-      // Add context about when this request was scheduled
-      const contextualRequest = `You are a scheduler. 
-        You were asked to execute this request: ${request.originalRequest}\n 
-        Date of the request: ${request.createdAt.toISOString()}\n
-        Act like if you know the request was scheduled.
-        Don't reschedule the same action. 
-        Just execute it.`;
-
-      // Process the request as if it was just received
-      const result = await this.agentRuntime.process({
-        currentContext: contextualRequest,
-        previousActions,
-      });
-
-      // Store the new actions in cache
-      if (result.actions.length > 0) {
-        await this.cache.storePreviousActions(request.id, result.actions);
-      }
-
       console.log(`✅ Scheduled request executed successfully`);
     } catch (error) {
       console.error(`❌ Failed to execute scheduled request:`, error);