@ai.ntellect/core 0.7.1 → 0.7.4

package/dist/utils/generate-action-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-action-schema.js","sourceRoot":"","sources":["../../utils/generate-action-schema.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAGjB,MAAM,oBAAoB,GAAG,CAAC,MAAwB,EAAE,EAAE;IAC/D,OAAO,MAAM;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM;YAC/B,CAAC,CAAC,IAAA,uBAAe,EAAC,QAAQ,CAAC,MAAM,CAAC;YAClC,CAAC,CAAC,eAAe,CAAC;QACpB,OAAO,aAAa,KAAK,CAAC,IAAI,iBAAiB,SAAS,EAAE,CAAC;IAC7D,CAAC,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,CAAC;AAClB,CAAC,CAAC;AAVW,QAAA,oBAAoB,wBAU/B;AAEK,MAAM,eAAe,GAAG,CAAC,MAAiB,EAAU,EAAE;IAC3D,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC1C,MAAM,WAAW,GAAI,KAAa,CAAC,IAAI,CAAC,WAAW,CAAC;YACpD,MAAM,SAAS,GAAG,IAAA,uBAAe,EAAC,KAAkB,CAAC,CAAC;YACtD,OAAO,WAAW;gBAChB,CAAC,CAAC,GAAG,GAAG,KAAK,SAAS,OAAO,WAAW,EAAE;gBAC1C,CAAC,CAAC,GAAG,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,OAAO,aAAa,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAC5C,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,QAAQ,EAAE,CAAC;QACjC,OAAO,WAAW,IAAA,uBAAe,EAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;IACvD,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,UAAU,EAAE,CAAC;QACnC,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC,CAAC;AA9BW,QAAA,eAAe,mBA8B1B"}

package/dist/utils/header-builder.d.ts

@@ -0,0 +1,12 @@
+type HeaderValue = string | string[] | undefined;
+export declare class LLMHeaderBuilder {
+    private headers;
+    private _result;
+    constructor();
+    addHeader(key: string, value: HeaderValue): LLMHeaderBuilder;
+    valueOf(): string;
+    toString(): string;
+    static create(): LLMHeaderBuilder;
+}
+export {};
+//# sourceMappingURL=header-builder.d.ts.map

package/dist/utils/header-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-builder.d.ts","sourceRoot":"","sources":["../../utils/header-builder.ts"],"names":[],"mappings":"AAAA,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAEjD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,OAAO,CAAS;;IAOxB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,gBAAgB;IAiB5D,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,MAAM,IAAI,gBAAgB;CAGlC"}

package/dist/utils/header-builder.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMHeaderBuilder = void 0;
+class LLMHeaderBuilder {
+    constructor() {
+        this.headers = new Map();
+        this._result = "";
+    }
+    addHeader(key, value) {
+        if (Array.isArray(value)) {
+            this.headers.set(key, value.join("\n"));
+        }
+        else {
+            this.headers.set(key, value);
+        }
+        // Build result immediately
+        this._result = Array.from(this.headers.entries())
+            .filter(([_, value]) => value !== undefined)
+            .map(([key, value]) => `# ${key}: ${value}`)
+            .join("\n")
+            .trim();
+        return this;
+    }
+    valueOf() {
+        return this._result;
+    }
+    toString() {
+        return this._result;
+    }
+    static create() {
+        return new LLMHeaderBuilder();
+    }
+}
+exports.LLMHeaderBuilder = LLMHeaderBuilder;
+//# sourceMappingURL=header-builder.js.map

package/dist/utils/header-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-builder.js","sourceRoot":"","sources":["../../utils/header-builder.ts"],"names":[],"mappings":";;;AAEA,MAAa,gBAAgB;IAI3B;QACE,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,SAAS,CAAC,GAAW,EAAE,KAAkB;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;aAC9C,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;aAC3C,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,KAAK,EAAE,CAAC;aAC3C,IAAI,CAAC,IAAI,CAAC;aACV,IAAI,EAAE,CAAC;QAEV,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,gBAAgB,EAAE,CAAC;IAChC,CAAC;CACF;AArCD,4CAqCC"}

package/graph/event-manager.ts

@@ -72,9 +72,16 @@ export class GraphEventManager<T extends ZodSchema> {
     payload?: P,
     context?: GraphContext<T>
   ): void {
-    const event: GraphEvent<T> = { type, payload, timestamp: Date.now() };
+    // Éviter la double imbrication des événements
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+    };
+
+    // Émettre l'événement une seule fois
     this.eventSubject.next(event);
-    this.eventEmitter.emit(type, event);
+    this.eventEmitter.emit(type, payload);
   }
 
   /**

package/graph/node.ts

@@ -72,52 +72,41 @@ export class GraphNode<T extends ZodSchema> {
     const node = this.nodes.get(nodeName);
     if (!node) throw new Error(`Node "${nodeName}" not found.`);
 
-    this.logger.addLog(`🚀 Starting node "${nodeName}"`);
-    this.emitEvent("nodeStarted", { name: nodeName, context: { ...context } });
+    this.logger.addLog(`🚀 Starting node "${nodeName}`);
+    this.emitEvent("nodeStarted", { name: nodeName, context });
 
     try {
+      // Vérifier la condition avant d'exécuter
+      if (node.condition && !node.condition(context)) {
+        this.logger.addLog(
+          `⏭️ Skipping node "${nodeName}" - condition not met`
+        );
+        return;
+      }
+
       const contextProxy = new Proxy(context, {
         set: (target, prop, value) => {
           const oldValue = target[prop];
-          target[prop] = value;
+          if (oldValue === value) return true;
 
+          target[prop] = value;
           this.emitEvent("nodeStateChanged", {
             nodeName,
-            name: nodeName,
             property: prop.toString(),
             oldValue,
             newValue: value,
-            context: { ...target },
+            context: target,
           });
 
           return true;
         },
-        get: (target, prop) => {
-          return target[prop];
-        },
+        get: (target, prop) => target[prop],
       });
 
-      if (node.condition && !node.condition(contextProxy)) {
-        this.logger.addLog(
-          `⏭️ Skipping node "${nodeName}" - condition not met`
-        );
-        return;
-      }
-
-      if (node.inputs) {
-        await this.validateInputs(node, inputs, nodeName);
-      }
-
-      if (node.retry && node.retry.maxAttempts > 0) {
-        await this.executeWithRetry(node, contextProxy, inputs, nodeName);
-      } else {
-        await node.execute(contextProxy, inputs);
-      }
-
-      if (node.outputs) {
-        await this.validateOutputs(node, contextProxy, nodeName);
-      }
+      // Exécuter le nœud
+      await node.execute(contextProxy, inputs);
 
+      // Gérer la suite uniquement si pas déclenché par un événement
       if (!triggeredByEvent) {
         const nextNodes =
           typeof node.next === "function"
@@ -125,47 +114,20 @@ export class GraphNode<T extends ZodSchema> {
             : node.next || [];
 
         for (const nextNodeName of nextNodes) {
-          const nextNode = this.nodes.get(nextNodeName);
-          if (
-            nextNode &&
-            (!nextNode.condition || nextNode.condition(contextProxy))
-          ) {
-            await this.executeNode(
-              nextNodeName,
-              contextProxy,
-              undefined,
-              false
-            );
-          }
+          await this.executeNode(nextNodeName, context, undefined, false);
         }
       }
 
-      if (!triggeredByEvent) {
-        await this.handleEvents(node, nodeName, contextProxy);
-      }
-
       this.logger.addLog(`✅ Node "${nodeName}" executed successfully`);
-      this.emitEvent("nodeCompleted", {
-        name: nodeName,
-        context: { ...contextProxy },
-      });
-    } catch (error: any) {
-      const errorToThrow =
-        error instanceof Error
-          ? error
-          : new Error(error.message || "Unknown error");
-
+      this.emitEvent("nodeCompleted", { name: nodeName, context });
+    } catch (error) {
       this.logger.addLog(
-        `❌ Error in node "${nodeName}": ${errorToThrow.message}`
+        `❌ Error in node "${nodeName}": ${
+          error instanceof Error ? error.message : String(error)
+        }`
       );
-
-      this.emitEvent("nodeError", {
-        name: nodeName,
-        error: errorToThrow,
-        context,
-      });
-
-      throw errorToThrow;
+      this.emitEvent("nodeError", { name: nodeName, error, context });
+      throw error;
     }
   }
 

package/graph/observer.ts

@@ -6,6 +6,7 @@ import {
   firstValueFrom,
 } from "rxjs";
 import {
+  debounceTime,
   distinctUntilChanged,
   filter,
   map,
@@ -55,16 +56,23 @@ export class GraphObserver<T extends ZodSchema> {
     } = {}
   ): GraphObservable<T> {
     const baseObservable = new Observable<any>((subscriber) => {
-      const subscription = this.eventSubject
-        .pipe(
-          filter(
-            (event) =>
-              event.type === "nodeStateChanged" ||
-              event.type === "nodeStarted" ||
-              event.type === "nodeCompleted"
-          ),
+      // Combine les événements avec l'état actuel
+      const subscription = combineLatest([
+        this.eventSubject.pipe(
+          filter((event) => event.type === "nodeStateChanged"),
           map((event) => event.payload.context),
-          startWith(this.stateSubject.getValue()),
+          distinctUntilChanged(
+            (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
+          ),
+          debounceTime(options.debounce || 100)
+        ),
+        this.stateSubject,
+      ])
+        .pipe(
+          map(([eventContext, stateContext]) => ({
+            ...stateContext,
+            ...eventContext,
+          })),
           distinctUntilChanged(
             (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
           )

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf dist && tsc",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
     "test": "mocha -r ./node_modules/ts-node/register",
     "test:all": "mocha -r ./node_modules/ts-node/register 'test/**/*.test.ts'",
     "test:coverage": "nyc --reporter=text --reporter=html pnpm test",
@@ -24,10 +26,12 @@
   },
   "devDependencies": {
     "@types/chai": "^4.3.20",
+    "@types/chai-as-promised": "^8.0.1",
     "@types/mocha": "^10.0.10",
     "@types/node": "^20",
     "@types/sinon": "^17.0.3",
     "chai": "^4.5.0",
+    "chai-as-promised": "^8.0.1",
     "mocha": "^10.0.0",
     "nyc": "^17.1.0",
     "redis": "^4.6.13",

package/test/graph/event-manager.test.ts

@@ -0,0 +1,72 @@
+import { expect } from "chai";
+import { EventEmitter } from "events";
+import { z } from "zod";
+import { GraphEventManager } from "../../graph/event-manager";
+
+describe("GraphEventManager", () => {
+  const TestSchema = z.object({
+    counter: z.number(),
+    message: z.string(),
+  });
+
+  let eventManager: GraphEventManager<typeof TestSchema>;
+  let eventEmitter: EventEmitter;
+  let events: any[] = [];
+
+  beforeEach(() => {
+    events = [];
+    eventEmitter = new EventEmitter();
+    eventManager = new GraphEventManager(eventEmitter, new Map(), "test", {
+      counter: 0,
+      message: "Hello",
+    });
+  });
+
+  it("should emit events without duplication", () => {
+    const emittedEvents: any[] = [];
+    eventEmitter.on("test", (event) => emittedEvents.push(event));
+
+    eventManager.emitEvent("test", { data: "test" });
+
+    expect(emittedEvents).to.have.lengthOf(1);
+    expect(emittedEvents[0]).to.deep.equal({ data: "test" });
+  });
+
+  it("should handle nodeStateChanged events correctly", () => {
+    const stateChanges: any[] = [];
+    eventEmitter.on("nodeStateChanged", (event) => stateChanges.push(event));
+
+    eventManager.emitEvent("nodeStateChanged", {
+      nodeName: "test",
+      property: "counter",
+      oldValue: 0,
+      newValue: 1,
+      context: { counter: 1, message: "Hello" },
+    });
+
+    expect(stateChanges).to.have.lengthOf(1);
+    expect(stateChanges[0].nodeName).to.equal("test");
+    expect(stateChanges[0].context.counter).to.equal(1);
+  });
+
+  it("should setup and cleanup event listeners", () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      events: ["customEvent"],
+      execute: async () => {},
+    });
+
+    eventManager = new GraphEventManager(eventEmitter, nodes, "test", {
+      counter: 0,
+      message: "Hello",
+    });
+
+    eventManager.setupEventListeners();
+    expect(eventEmitter.listenerCount("customEvent")).to.equal(1);
+
+    // Réinitialiser les listeners
+    eventManager.setupEventListeners();
+    expect(eventEmitter.listenerCount("customEvent")).to.equal(1);
+  });
+});

package/test/graph/index.test.ts

@@ -37,7 +37,7 @@ type TestSchema = typeof TestSchema;
  * The tests use a simple numeric value-based context to demonstrate state changes
  * and a transaction-based event payload for testing event correlation.
  */
-describe("Graph", function () {
+describe("GraphFlow", function () {
   let graph: GraphFlow<TestSchema>;
   let eventEmitter: EventEmitter;
 
@@ -228,27 +228,32 @@ describe("Graph", function () {
    * - Context preservation between attempts
    * Essential for handling transient failures in workflows
    */
-  it("should retry a node execution when it fails", async function () {
-    let attemptCount = 0;
-    const retryNode: Node<TestSchema> = {
-      name: "retryNode",
-      retry: { maxAttempts: 3, delay: 0 },
-      execute: async (context) => {
-        attemptCount++;
-        if (attemptCount < 3) {
+  it("should retry a node execution when it fails", async () => {
+    let attempts = 0;
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async () => {
+        attempts++;
+        if (attempts < 3) {
           throw new Error("Temporary failure");
         }
-        context.value = (context.value ?? 0) + 1;
       },
-      next: [],
-    };
+      retry: {
+        maxAttempts: 3,
+        delay: 100,
+      },
+    });
 
-    graph.addNode(retryNode);
-    await graph.execute("retryNode");
+    const graph = new GraphFlow("test", {
+      name: "test",
+      schema: TestSchema,
+      context: { value: 0 },
+      nodes: Array.from(nodes.values()),
+    });
 
-    const context = graph.getContext();
-    expect(context.value).to.equal(1);
-    expect(attemptCount).to.equal(3);
+    await graph.execute("test");
+    expect(attempts).to.equal(3);
   });
 
   /**
@@ -294,27 +299,29 @@ describe("Graph", function () {
   /**
    * Tests input validation error handling
    */
-  it("should throw error when node input validation fails", async function () {
-    const nodeWithInput: Node<TestSchema, { amount: number }> = {
-      name: "inputNode",
-      inputs: z.object({
-        amount: z.number().min(0),
-      }),
-      execute: async (context, inputs: { amount: number }) => {
-        context.value = (context.value ?? 0) + inputs.amount;
-      },
-      next: [],
-    };
+  it("should throw error when node input validation fails", async () => {
+    const InputSchema = z.object({
+      value: z.number().min(0),
+    });
 
-    graph.addNode(nodeWithInput);
+    const graph = new GraphFlow("test", {
+      name: "test",
+      schema: TestSchema,
+      context: { value: 0 },
+      nodes: [
+        {
+          name: "test",
+          inputs: InputSchema,
+          execute: async () => {},
+        },
+      ],
+    });
 
     try {
-      await graph.execute("inputNode", { amount: -1 });
+      await graph.execute("test", { value: -1 });
       expect.fail("Should have thrown an error");
-    } catch (error) {
-      expect((error as Error).message).to.include(
-        "Number must be greater than or equal to 0"
-      );
+    } catch (error: any) {
+      expect(error.message).to.include("Number must be greater than or equal");
     }
   });
 

package/test/graph/node.test.ts

@@ -0,0 +1,197 @@
+import { expect, use } from "chai";
+import chaiAsPromised from "chai-as-promised";
+import { EventEmitter } from "events";
+import { BehaviorSubject, Subject } from "rxjs";
+import { z } from "zod";
+import { GraphEventManager } from "../../graph/event-manager";
+import { GraphLogger } from "../../graph/logger";
+import { GraphNode } from "../../graph/node";
+import { GraphContext } from "../../types";
+
+use(chaiAsPromised);
+
+describe("GraphNode", () => {
+  const TestSchema = z.object({
+    counter: z.number(),
+    message: z.string(),
+  });
+
+  type TestContext = GraphContext<typeof TestSchema>;
+
+  let node: GraphNode<typeof TestSchema>;
+  let eventManager: GraphEventManager<typeof TestSchema>;
+  let logger: GraphLogger;
+  let eventEmitter: EventEmitter;
+  let eventSubject: Subject<any>;
+  let stateSubject: BehaviorSubject<any>;
+  let events: any[] = [];
+
+  beforeEach(() => {
+    events = [];
+    eventEmitter = new EventEmitter();
+    eventSubject = new Subject();
+    stateSubject = new BehaviorSubject({ counter: 0, message: "Hello" });
+    logger = new GraphLogger("test", false);
+    eventManager = new GraphEventManager(eventEmitter, new Map(), "test", {
+      counter: 0,
+      message: "Hello",
+    });
+
+    // Capture des événements
+    eventSubject.subscribe((event) => events.push(event));
+
+    node = new GraphNode(
+      new Map(),
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+  });
+
+  it("should execute a simple node", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext) => {
+        context.counter++;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+
+    // Vérifier les événements émis
+    expect(events).to.have.lengthOf(3); // nodeStarted, nodeStateChanged, nodeCompleted
+    expect(events[0].type).to.equal("nodeStarted");
+    expect(events[1].type).to.equal("nodeStateChanged");
+    expect(events[2].type).to.equal("nodeCompleted");
+  });
+
+  it("should handle node condition", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      condition: (context: TestContext) => context.counter < 5,
+      execute: async (context: TestContext) => {
+        context.counter++;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Test avec condition vraie
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+    expect(events.some((e) => e.type === "nodeStateChanged")).to.be.true;
+
+    // Test avec condition fausse
+    events = [];
+    await node.executeNode("test", { counter: 5, message: "Hello" }, null);
+    expect(events.some((e) => e.type === "nodeStateChanged")).to.be.false;
+  });
+
+  it("should handle errors", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (_context: TestContext) => {
+        throw new Error("Test error");
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    try {
+      await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+      expect.fail("Should have thrown an error");
+    } catch (error: any) {
+      expect(error.message).to.equal("Test error");
+      const errorEvents = events.filter((e) => e.type === "nodeError");
+      expect(errorEvents).to.have.lengthOf(1);
+      expect(errorEvents[0].payload.error.message).to.equal("Test error");
+    }
+  });
+
+  it("should emit events exactly once per state change", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext) => {
+        context.counter++;
+        context.message = "Updated";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+
+    // Compter les occurrences de chaque type d'événement
+    const eventCounts = events.reduce((acc, event) => {
+      acc[event.type] = (acc[event.type] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    expect(eventCounts).to.deep.equal({
+      nodeStarted: 1,
+      nodeStateChanged: 2, // Un pour counter, un pour message
+      nodeCompleted: 1,
+    });
+
+    // Vérifier l'ordre des événements
+    expect(events.map((e) => e.type)).to.deep.equal([
+      "nodeStarted",
+      "nodeStateChanged", // counter
+      "nodeStateChanged", // message
+      "nodeCompleted",
+    ]);
+  });
+
+  it("should emit nodeStateChanged only for actual changes", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext) => {
+        context.counter = context.counter; // Même valeur
+        context.message = "New"; // Nouvelle valeur
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(1); // Seulement pour message
+    expect(stateChanges[0].payload.property).to.equal("message");
+  });
+});

package/tsconfig.json

@@ -2,14 +2,25 @@
   "compilerOptions": {
     "target": "es2016",
     "module": "commonjs",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "skipLibCheck": true,
     "baseUrl": ".",
     "outDir": "./dist",
-    "types": ["node", "mocha"]
+    "types": ["node", "mocha"],
+    "resolveJsonModule": true
   },
-  "include": ["src/**/*", "graph/**/*", "types/**/*", "interfaces/**/*"],
+  "include": [
+    "index.ts",
+    "modules/**/*",
+    "graph/**/*",
+    "types/**/*",
+    "interfaces/**/*",
+    "utils/**/*"
+  ],
   "exclude": ["node_modules", "dist", "test", "examples"]
 }