@ai.ntellect/core 0.8.1 → 0.8.3

package/graph/node.ts

@@ -86,7 +86,6 @@ export class GraphNode<T extends ZodSchema> {
   public async executeNode(
     nodeName: string,
     context: GraphContext<T>,
-    params: any,
     triggeredByEvent: boolean = false
   ): Promise<void> {
     const node = this.nodes.get(nodeName);
@@ -120,11 +119,11 @@ export class GraphNode<T extends ZodSchema> {
         },
       });
 
-      if (node.condition && !node.condition(contextProxy, params)) {
+      if (node.condition && !node.condition(contextProxy)) {
         return;
       }
 
-      await this.executeWithRetry(node, contextProxy, nodeName, params);
+      await this.executeWithRetry(node, contextProxy, nodeName);
       this.emitEvent("nodeCompleted", { name: nodeName, context: nodeContext });
 
       if (!triggeredByEvent && node.next) {
@@ -151,7 +150,7 @@ export class GraphNode<T extends ZodSchema> {
 
         // Sinon, exécuter les autres nœuds valides
         for (const nextNode of validNextNodes) {
-          await this.executeNode(nextNode.name, context, undefined, false);
+          await this.executeNode(nextNode.name, context, false);
         }
       }
     } catch (error) {
@@ -164,34 +163,6 @@ export class GraphNode<T extends ZodSchema> {
     }
   }
 
-  /**
-   * Validates the params for a node using its schema
-   * @param node - The node whose params need validation
-   * @param params - The input data to validate
-   * @param nodeName - The name of the node (for error messages)
-   * @throws Error if validation fails
-   * @private
-   */
-  private async validateParams(
-    node: GraphNodeConfig<T, any>,
-    params: any,
-    nodeName: string
-  ): Promise<void> {
-    // Si pas de schéma de validation ou si le schéma est optionnel, accepter n'importe quels params
-    if (!node.params || node.params.isOptional?.()) return;
-
-    // Vérifier les params uniquement si un schéma est défini et non optionnel
-    if (!params) {
-      throw new Error(`Params required for node "${nodeName}"`);
-    }
-
-    try {
-      return node.params.parse(params);
-    } catch (error: any) {
-      throw error;
-    }
-  }
-
   /**
    * Executes a node with retry logic
    * @param node - The node to execute
@@ -205,19 +176,14 @@ export class GraphNode<T extends ZodSchema> {
   private async executeWithRetry(
     node: GraphNodeConfig<T, any>,
     contextProxy: GraphContext<T>,
-    nodeName: string,
-    params?: NodeParams
+    nodeName: string
   ): Promise<void> {
     let attempts = 0;
     let lastError: Error = new Error("Unknown error");
 
     while (attempts < (node.retry?.maxAttempts || 1)) {
       try {
-        if (node.params) {
-          await this.validateParams(node, params, nodeName);
-        }
-
-        await node.execute(contextProxy, params, {
+        await node.execute(contextProxy, {
           eventEmitter: this.eventEmitter,
         });
         return;

package/graph/observer.ts

@@ -125,17 +125,47 @@ export class GraphObserver<T extends ZodSchema> {
 
   /**
    * Waits for correlated events to occur and validates them using a correlation function
+   * @param eventTypes - Array of event types to wait for
+   * @param timeoutMs - Timeout in milliseconds
+   * @param correlationFn - Function to validate event correlation
+   * @returns Promise that resolves with the correlated events
    */
   waitForCorrelatedEvents(
     eventTypes: string[],
     timeoutMs: number,
     correlationFn: (events: GraphEvent<T>[]) => boolean
   ): Promise<GraphEvent<T>[]> {
-    return this.eventManager.waitForCorrelatedEvents(
-      eventTypes,
-      timeoutMs,
-      correlationFn
-    );
+    return new Promise((resolve, reject) => {
+      const events: GraphEvent<T>[] = [];
+      const timeout = setTimeout(() => {
+        reject(
+          new Error(
+            `Timeout waiting for correlated events: ${eventTypes.join(", ")}`
+          )
+        );
+      }, timeoutMs);
+
+      const subscription = this.eventSubject
+        .pipe(
+          filter((event) => eventTypes.includes(event.type)),
+          takeUntil(this.destroySubject)
+        )
+        .subscribe({
+          next: (event) => {
+            events.push(event);
+            if (events.length === eventTypes.length && correlationFn(events)) {
+              clearTimeout(timeout);
+              subscription.unsubscribe();
+              resolve(events);
+            }
+          },
+          error: (error) => {
+            clearTimeout(timeout);
+            subscription.unsubscribe();
+            reject(error);
+          },
+        });
+    });
   }
 
   /**

package/modules/agent/agent.ts

@@ -1,3 +1,4 @@
+import { GraphContext } from "@/types";
 import { GraphFlow } from "../../graph/index";
 import {
   AgentConfig,
@@ -51,31 +52,29 @@ export class Agent {
    * @returns {GraphFlow<typeof AgentContextSchema>} The configured workflow
    */
   private setupWorkflow(): GraphFlow<typeof AgentContextSchema> {
-    return new GraphFlow("assistant", {
+    return new GraphFlow({
       name: "assistant",
       schema: AgentContextSchema,
       context: {
         input: { raw: "" },
         actions: [],
         response: "",
-        executedActions: [],
       },
       nodes: [
         {
           name: "process",
-          execute: async (context) => {
+          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
             const agentContext = context as unknown as AgentContext;
             const decision = await this.executor.makeDecision(agentContext);
             context.actions = decision.actions;
             context.response = decision.response;
           },
-          next: (context) => (context.actions.length > 0 ? ["execute"] : []),
+          next: (context: GraphContext<typeof AgentContextSchema>) =>
+            context.actions.length > 0 ? ["execute"] : [],
         },
         {
           name: "execute",
-          execute: async (context) => {
-            console.log(`Executing actions:`);
-            console.log(context.actions);
+          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
             const timestamp = new Date().toISOString();
             context.knowledge = `Date: ${timestamp}\n${JSON.stringify(
               context.actions
@@ -97,7 +96,7 @@ export class Agent {
    * @returns {Promise<AgentContext>} The resulting context after processing
    */
   public async process(input: string): Promise<AgentContext> {
-    await this.workflow.execute("process", undefined, {
+    await this.workflow.execute("process", {
       input: { raw: input },
       actions: [],
       response: "",

package/modules/agent/generic-assistant.ts

@@ -1,3 +1,4 @@
+import { GraphContext } from "@/types";
 import { GraphFlow } from "../../graph/index";
 import {
   AgentConfig,
@@ -41,7 +42,7 @@ export class Agent {
   }
 
   private setupWorkflow(): GraphFlow<typeof AgentContextSchema> {
-    return new GraphFlow("assistant", {
+    return new GraphFlow({
       name: "assistant",
       schema: AgentContextSchema,
       context: {
@@ -53,17 +54,18 @@ export class Agent {
       nodes: [
         {
           name: "process",
-          execute: async (context) => {
+          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
             const agentContext = context as unknown as AgentContext;
             const decision = await this.executor.makeDecision(agentContext);
             context.actions = decision.actions;
             context.response = decision.response;
           },
-          next: (context) => (context.actions.length > 0 ? ["execute"] : []),
+          next: (context: GraphContext<typeof AgentContextSchema>) =>
+            context.actions.length > 0 ? ["execute"] : [],
         },
         {
           name: "execute",
-          execute: async (context) => {
+          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
             console.log(`Executing actions:`);
             console.log(context.actions);
 
@@ -79,7 +81,7 @@ export class Agent {
   }
 
   public async process(input: string): Promise<AgentContext> {
-    await this.workflow.execute("process", undefined, {
+    await this.workflow.execute("process", {
       input: { raw: input },
       actions: [],
       response: "",

package/modules/agent/generic-executor.ts

@@ -10,6 +10,7 @@ import {
 import { BaseAgent } from "./base";
 import { AgentExecutor } from "./base/executor";
 import { LLMFactory } from "./llm-factory";
+import { PromptBuilder } from "./prompt-builder";
 
 /**
  * Generic executor that handles the interaction between the agent and LLM
@@ -96,6 +97,33 @@ ${graph
       .join("\n\n");
   }
 
+  private async buildSystemPrompt(context: AgentContext): Promise<string> {
+    return new PromptBuilder()
+      .addSection("ROLE", this.agent.getRole())
+      .addSection("GOAL", this.agent.getGoal())
+      .addSection("BACKSTORY", this.agent.getBackstory())
+      .addSection(
+        "RECENT ACTIONS (check this before deciding what to do)",
+        context.knowledge || "None"
+      )
+      .addSection(
+        "AVAILABLE ACTIONS (only if you need)",
+        this.generateActionSchema()
+      )
+      .addSection(
+        "INSTRUCTIONS",
+        `
+- Never take actions if an recent action matches the user's input
+- If you need to take actions, structure parameters according to the action's schema
+- If goal is achieved, explain that you achieved for examples:
+  - "I have achieved the goal"
+  - "I have done what I needed to do"
+  - "I have completed the task"
+      `
+      )
+      .build(context);
+  }
+
   /**
    * Makes a decision based on the current context using the LLM
    * @param {AgentContext} context - The context to base the decision on
@@ -107,50 +135,16 @@ ${graph
       chalk.dim("Analyzing context and available actions...")
     );
 
-    const memories = await this.agent.recall(context.input.raw);
-    if (memories.length > 0) {
-      this.log("info", chalk.dim("Retrieved relevant memories:"));
-      memories.forEach((m) => this.log("info", chalk.dim(`- ${m.content}`)));
-
-      context.knowledge =
-        (context.knowledge || "") +
-        "\n" +
-        memories.map((m) => m.content).join("\n");
-    }
-
-    const systemPrompt = `
-      ## ROLE
-      ${this.agent.getRole()}
-
-      ## GOAL
-      ${this.agent.getGoal()}
-
-      ## BACKSTORY
-      ${this.agent.getBackstory()}
-
-      ## RECENT ACTIONS
-      ${context.knowledge ? `${context.knowledge}\n` : "None"}
-     
-      ## AVAILABLE ACTIONS
-      ${this.generateActionSchema()}
-
-      ## INSTRUCTIONS
-      - Analyze the user input and what you have done (if no action is needed, just return an empty array)
-      - Choose appropriate actions based on their parameters
-      - Structure parameters according to the action's schema
-      - Look at the goal and the actions you have done, if you have achieved the goal, STOP
-    `;
+    const systemPrompt = await this.buildSystemPrompt(context);
 
+    console.log({ systemPrompt });
     this.log("info", chalk.dim("Generating response..."));
 
     const result = await this.llm.generate(
       {
         system: systemPrompt,
-        user: `User input: ${context.input.raw}
-        Actions you have already done: ${
-          context.executedActions
-            ?.map((a) => `\n- ${a.name} => ${JSON.stringify(a.result)}`)
-            .join("") || "None"
+        user: `User sent you this message at ${new Date().toISOString()}\n${
+          context.input.raw
         }`,
       },
       z.object({
@@ -168,7 +162,6 @@ ${graph
         response: z.string(),
       })
     );
-
     if (result.object.actions.length > 0) {
       this.log("success", chalk.green("Decided to take actions:"));
       result.object.actions.forEach(
@@ -239,7 +232,7 @@ ${graph
       // Execute with merged context
       const result = await workflow.execute(
         startNode,
-        undefined,
+
         workflowContext
       );
 

package/package.json

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

package/test/graph/controller.test.ts

@@ -2,21 +2,29 @@ import { expect } from "chai";
 import { z } from "zod";
 import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
-import { GraphNodeConfig } from "../../types";
+import { GraphContext, GraphNodeConfig } from "../../types";
 
 describe("GraphController", () => {
   const TestSchema = z.object({
     counter: z.number(),
     message: z.string(),
+    value: z.number().optional(),
+    prefix: z.string().optional(),
   });
 
   const createTestGraph = (name: string): GraphFlow<typeof TestSchema> => {
     const nodes: GraphNodeConfig<typeof TestSchema>[] = [
       {
         name: "start",
-        execute: async (context, params) => {
-          context.counter = params?.value ?? 0;
-          context.message = params?.prefix ? `${params.prefix}-${name}` : name;
+        execute: async (context) => {
+          if (context.value !== undefined) {
+            context.counter = context.value;
+          }
+          if (context.prefix) {
+            context.message = `${context.prefix}-${name}`;
+          } else {
+            context.message = name;
+          }
         },
       },
       {
@@ -27,7 +35,7 @@ describe("GraphController", () => {
       },
     ];
 
-    return new GraphFlow(name, {
+    return new GraphFlow({
       name,
       nodes,
       schema: TestSchema,
@@ -36,23 +44,21 @@ describe("GraphController", () => {
   };
 
   describe("Sequential Execution", () => {
-    it("should execute graphs sequentially with different params and params", async () => {
+    it("should execute graphs sequentially with different contexts", async () => {
       const graph1 = createTestGraph("graph1");
       const graph2 = createTestGraph("graph2");
       const graph3 = createTestGraph("graph3");
 
-      const params = [{ value: 10 }, { value: 20 }, { value: 30 }];
-
-      const params2 = [
-        { prefix: "test1" },
-        { prefix: "test2" },
-        { prefix: "test3" },
+      const contexts = [
+        { value: 10, prefix: "test1" },
+        { value: 20, prefix: "test2" },
+        { value: 30, prefix: "test3" },
       ];
 
       const results = await GraphController.executeSequential(
         [graph1, graph2, graph3],
         ["start", "start", "start"],
-        params.map((value, i) => ({ ...value, prefix: params2[i].prefix }))
+        contexts
       );
 
       expect(results).to.have.length(3);
@@ -66,7 +72,7 @@ describe("GraphController", () => {
       expect(results[0].nodeName).to.equal("start");
     });
 
-    it("should handle missing params and params gracefully", async () => {
+    it("should handle missing contexts gracefully", async () => {
       const graph1 = createTestGraph("graph1");
       const graph2 = createTestGraph("graph2");
 
@@ -89,7 +95,7 @@ describe("GraphController", () => {
         createTestGraph(`graph${i + 1}`)
       );
 
-      const params = Array.from({ length: 5 }, (_, i) => ({
+      const contexts = Array.from({ length: 5 }, (_, i) => ({
         value: (i + 1) * 10,
         prefix: `test${i + 1}`,
       }));
@@ -106,7 +112,7 @@ describe("GraphController", () => {
         graphs,
         Array(5).fill("start"),
         2,
-        params
+        contexts
       );
       const executionTime = Date.now() - startTime;
 
@@ -119,7 +125,7 @@ describe("GraphController", () => {
     });
 
     it("should handle errors in parallel execution", async () => {
-      const errorGraph = new GraphFlow("errorGraph", {
+      const errorGraph = new GraphFlow({
         name: "errorGraph",
         nodes: [
           {
@@ -188,4 +194,43 @@ describe("GraphController", () => {
       ]);
     });
   });
+
+  it("should wait for correlated events", async function () {
+    const graph = new GraphFlow({
+      name: "test",
+      schema: TestSchema,
+      nodes: [
+        {
+          name: "correlatedEventsNode",
+          when: {
+            events: ["eventA", "eventB"],
+            timeout: 1000,
+            strategy: {
+              type: "correlate",
+              correlation: (events) => {
+                const eventA = events.find((e) => e.type === "eventA");
+                const eventB = events.find((e) => e.type === "eventB");
+                return eventA?.payload?.id === eventB?.payload?.id;
+              },
+            },
+          },
+          execute: async (context: GraphContext<typeof TestSchema>) => {
+            context.message = "Correlated events received";
+          },
+        },
+      ],
+      context: { value: 0, counter: 0, message: "" },
+    });
+
+    const execution = graph.execute("correlatedEventsNode");
+
+    // Émettre les événements corrélés
+    setTimeout(() => {
+      graph.emit("eventA", { id: "123", status: "completed" });
+      graph.emit("eventB", { id: "123", status: "available" });
+    }, 100);
+
+    await execution;
+    expect(graph.getContext().message).to.equal("Correlated events received");
+  });
 });