@ai.ntellect/core 0.8.3 → 1.1.0

package/test/{graph → execution}/controller.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { z } from "zod";
-import { GraphController } from "../../graph/controller";
-import { GraphFlow } from "../../graph/index";
+import { GraphController } from "../../execution/controller";
+import { GraphFlow } from "../../execution/index";
 import { GraphContext, GraphNodeConfig } from "../../types";
 
 describe("GraphController", () => {

package/test/{graph → execution}/event-manager.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { EventEmitter } from "events";
 import { z } from "zod";
-import { GraphEventManager } from "../../graph/event-manager";
+import { GraphEventManager } from "../../execution/event-manager";
 
 describe("GraphEventManager", () => {
   const TestSchema = z.object({

package/test/{graph → execution}/index.test.ts

@@ -3,8 +3,8 @@ import chaiAsPromised from "chai-as-promised";
 import EventEmitter from "events";
 import sinon from "sinon";
 import { z } from "zod";
-import { GraphController } from "../../graph/controller";
-import { GraphFlow } from "../../graph/index";
+import { GraphController } from "../../execution/controller";
+import { GraphFlow } from "../../execution/index";
 import { GraphConfig, GraphContext, GraphNodeConfig } from "../../types";
 
 use(chaiAsPromised);
@@ -54,7 +54,7 @@ describe("GraphFlow", function () {
       name: "TestGraph",
       schema: TestSchema,
       nodes: [],
-      context: { value: 0 },
+      context: { value: 0, counter: 0, message: "" },
       eventEmitter: eventEmitter,
     });
   });
@@ -166,7 +166,10 @@ describe("GraphFlow", function () {
       await graph.execute("simpleNode", invalidContext as any);
       expect.fail("Should have thrown an error");
     } catch (error: any) {
-      expect(error.message).to.include("Expected number");
+      // Zod v4 changed validation error wording
+      expect(error.message).to.satisfy(
+        (msg: string) => msg.includes("Expected number") || msg.includes("Invalid input")
+      );
     }
   });
 
@@ -251,7 +254,7 @@ describe("GraphFlow", function () {
     const graph = new GraphFlow({
       name: "retryGraph",
       schema: TestSchema,
-      context: { value: 0 },
+      context: { value: 0, counter: 0, message: "" },
       nodes: [retryNode],
     });
 
@@ -291,7 +294,7 @@ describe("GraphFlow", function () {
       name: "TestGraph",
       schema: TestSchema,
       nodes: [nodeA, nodeB],
-      context: { value: 0 },
+      context: { value: 0, counter: 0, message: "" },
       entryNode: "A",
     };
 
@@ -322,8 +325,11 @@ describe("GraphFlow", function () {
       await graph.execute("test", { value: -1 });
       expect.fail("Should have thrown an error");
     } catch (error: any) {
-      expect(error.message).to.include(
-        "Number must be greater than or equal to 0"
+      // Zod v4 changed validation error wording
+      expect(error.message).to.satisfy(
+        (msg: string) =>
+          msg.includes("Number must be greater than or equal to 0") ||
+          msg.includes("Too small")
       );
     }
   });
@@ -388,7 +394,7 @@ describe("GraphFlow", function () {
             const newContext = { ...context, value: -1 };
             const validationResult = TestSchema.safeParse(newContext);
             if (!validationResult.success) {
-              throw new Error(validationResult.error.errors[0].message);
+              throw new Error(validationResult.error.issues[0].message);
             }
             graph["context"] = newContext;
           },
@@ -401,8 +407,11 @@ describe("GraphFlow", function () {
       await graph.execute("validationNode");
       throw new Error("Should have thrown an error");
     } catch (error: any) {
-      expect(error.message).to.include(
-        "Number must be greater than or equal to 0"
+      // Zod v4 changed validation error wording
+      expect(error.message).to.satisfy(
+        (msg: string) =>
+          msg.includes("Number must be greater than or equal to 0") ||
+          msg.includes("Too small")
       );
     }
   });
@@ -497,7 +506,7 @@ describe("GraphFlow", function () {
     const graph1 = new GraphFlow({
       name: "Graph1",
       schema: TestSchema,
-      context: { value: 0 },
+      context: { value: 0, counter: 0, message: "" },
       nodes: [],
     });
 
@@ -520,7 +529,7 @@ describe("GraphFlow", function () {
     const graph2 = new GraphFlow({
       name: "Graph2",
       schema: TestSchema,
-      context: { value: 0 },
+      context: { value: 0, counter: 0, message: "" },
       nodes: [],
     });
 
@@ -563,7 +572,7 @@ describe("GraphFlow", function () {
     const graph1 = new GraphFlow({
       name: "Graph1",
       schema: TestSchema,
-      context: { value: 1 },
+      context: { value: 1, counter: 0, message: "" },
       nodes: [],
     });
 
@@ -578,7 +587,7 @@ describe("GraphFlow", function () {
     const graph2 = new GraphFlow({
       name: "Graph2",
       schema: TestSchema,
-      context: { value: 3 },
+      context: { value: 3, counter: 0, message: "" },
       nodes: [],
     });
 

package/test/{graph → execution}/node.test.ts

@@ -3,9 +3,9 @@ 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 { GraphEventManager } from "../../execution/event-manager";
+import { GraphLogger } from "../../execution/logger";
+import { GraphNode } from "../../execution/node";
 import { IEventEmitter } from "../../interfaces";
 import { GraphContext } from "../../types";
 

package/test/{graph → execution}/observer.test.ts

@@ -1,8 +1,8 @@
 import { expect } from "chai";
 import { BehaviorSubject, Subject } from "rxjs";
 import { z } from "zod";
-import { GraphFlow } from "../../graph";
-import { GraphObserver } from "../../graph/observer";
+import { GraphFlow } from "../../execution";
+import { GraphObserver } from "../../execution/observer";
 import { GraphContext, GraphEvent, GraphNodeConfig } from "../../types";
 
 /**

package/test/execution/parallel.test.ts

@@ -0,0 +1,135 @@
+import { expect } from "chai";
+import { GraphFlow } from "../../execution";
+import { nodeRegistry } from "../../execution/registry";
+import { ParallelNodeConfig } from "../../execution/types.parallel";
+import { GraphContext } from "../../types";
+
+describe("Fork-Join Parallelism", () => {
+  beforeEach(() => {
+    // Nettoyer le registry avant chaque test
+    (nodeRegistry as any).executeFunctions.clear();
+    (nodeRegistry as any).nodeConfigs.clear();
+  });
+
+  it("should execute branches in parallel with Promise.all", async () => {
+    const executionTimes: number[] = [];
+    const startTime = Date.now();
+
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "A",
+        execute: async (ctx: any) => {
+          ctx.value = 1;
+        },
+        parallel: { enabled: true, joinNode: "C" },
+        next: ["B1", "B2", "B3"],
+      },
+      {
+        name: "B1",
+        execute: async (ctx: any) => {
+          const start = Date.now();
+          await new Promise(r => setTimeout(r, 100));
+          executionTimes.push(Date.now() - start);
+          ctx.results = [...(ctx.results || []), "B1"];
+        },
+      },
+      {
+        name: "B2",
+        execute: async (ctx: any) => {
+          const start = Date.now();
+          await new Promise(r => setTimeout(r, 50));
+          executionTimes.push(Date.now() - start);
+          ctx.results = [...(ctx.results || []), "B2"];
+        },
+      },
+      {
+        name: "B3",
+        execute: async (ctx: any) => {
+          const start = Date.now();
+          await new Promise(r => setTimeout(r, 150));
+          executionTimes.push(Date.now() - start);
+          ctx.results = [...(ctx.results || []), "B3"];
+        },
+      },
+      {
+        name: "C",
+        execute: async (ctx: any) => {
+          ctx.value = 2;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "fork-join-test",
+      schema: { parse: (ctx: any) => ctx } as any,
+      context: { value: 0, results: [] as string[] },
+      nodes: nodes,
+      entryNode: "A",
+    });
+
+    // Enregistrer les nodes
+    nodes.forEach(node => nodeRegistry.registerParallel(node));
+
+    const context = await graph.execute("A");
+
+    const totalTime = Date.now() - startTime;
+
+    expect(context.value).to.equal(2);
+    expect(context.results).to.have.length(3);
+    expect(context.results).to.include("B1");
+    expect(context.results).to.include("B2");
+    expect(context.results).to.include("B3");
+    
+    // Le temps total devrait être proche du max(100, 50, 150) = 150ms
+    // et non 100+50+150 = 300ms (séquentiel)
+    expect(totalTime).to.be.lessThan(250); // Marge de manœuvre
+  });
+
+  it("should merge contexts with deep-merge by default", async () => {
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "start",
+        execute: async (ctx: any) => {
+          ctx.base = "base";
+        },
+        parallel: { enabled: true, joinNode: "merge" },
+        next: ["branch1", "branch2"],
+      },
+      {
+        name: "branch1",
+        execute: async (ctx: any) => {
+          ctx.fromBranch1 = "value1";
+        },
+      },
+      {
+        name: "branch2",
+        execute: async (ctx: any) => {
+          ctx.fromBranch2 = "value2";
+        },
+      },
+      {
+        name: "merge",
+        execute: async (ctx: any) => {
+          ctx.merged = true;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "merge-test",
+      schema: { parse: (ctx: any) => ctx } as any,
+      context: {} as any,
+      nodes: nodes,
+      entryNode: "start",
+    });
+
+    nodes.forEach(node => nodeRegistry.registerParallel(node));
+
+    const context = await graph.execute("start");
+
+    expect(context.base).to.equal("base");
+    expect(context.fromBranch1).to.equal("value1");
+    expect(context.fromBranch2).to.equal("value2");
+    expect(context.merged).to.be.true;
+  });
+});

package/test/execution/plan-llm-integration.test.ts

@@ -0,0 +1,290 @@
+import { expect } from 'chai';
+import { z } from 'zod';
+import { GraphFlow } from '../../execution/index';
+import { ToolRegistry } from '../../execution/registry';
+import { generatePlan, PlanSchema, renderPlan } from '../../execution/planner';
+import { compilePlan } from '../../execution/compiler';
+
+// Read .env manually
+function loadEnv(): Record<string, string> {
+  try {
+    const fs = require('fs');
+    const content = fs.readFileSync('.env', 'utf-8');
+    const env: Record<string, string> = {};
+    content.split('\n').forEach((line: string) => {
+      const idx = line.indexOf('=');
+      if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    });
+    return env;
+  } catch {
+    return {};
+  }
+}
+
+// Real LLM call via Groq
+async function callGroq(prompt: string): Promise<string> {
+  const env = loadEnv();
+  const apiKey = env['GROQ_API_KEY'];
+  if (!apiKey) throw new Error('GROQ_API_KEY not found in .env');
+
+  const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: 'llama-3.1-8b-instant',
+      messages: [
+        { role: 'system', content: 'You are a workflow planner. Output valid JSON only.' },
+        { role: 'user', content: prompt },
+      ],
+      temperature: 0.1,
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`Groq API error: ${err}`);
+  }
+
+  const data = await response.json();
+  return data.choices[0].message.content;
+}
+
+// Real onchain tools using GraphFlow
+function createCheckBalanceTool() {
+  const g = new GraphFlow<any>({
+    name: 'check_balance',
+    context: { balance: 0, address: '' },
+    schema: z.object({ balance: z.number(), address: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [check_balance] Checking balance for ${ctx.address || 'default wallet'}`);
+        ctx.balance = 1.5; // Mock: 1.5 ETH
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createEstimateGasTool() {
+  const g = new GraphFlow<any>({
+    name: 'estimate_gas',
+    context: { gas: 0, to: '', amount: '' },
+    schema: z.object({ gas: z.number(), to: z.union([z.string(), z.number()]), amount: z.union([z.string(), z.number()]) }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [estimate_gas] Estimating gas for ${ctx.amount} ETH to ${ctx.to}`);
+        ctx.gas = 21000;
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createSendEthTool() {
+  const g = new GraphFlow<any>({
+    name: 'send_eth',
+    context: { txHash: '', to: '', amount: '' },
+    schema: z.object({ txHash: z.string(), to: z.union([z.string(), z.number()]), amount: z.union([z.string(), z.number()]) }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [send_eth] Sending ${ctx.amount} ETH to ${ctx.to}`);
+        ctx.txHash = '0xabc123...'; // Mock tx hash
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createGetTokenPriceTool() {
+  const g = new GraphFlow<any>({
+    name: 'get_token_price',
+    context: { price: 0, symbol: '' },
+    schema: z.object({ price: z.number(), symbol: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [get_token_price] Getting price for ${ctx.symbol}`);
+        ctx.price = 2500; // Mock: ETH price
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createSwapTokensTool() {
+  const g = new GraphFlow<any>({
+    name: 'swap_tokens',
+    context: { swapHash: '', from: '', to: '', amount: '' },
+    schema: z.object({ swapHash: z.string(), from: z.string(), to: z.string(), amount: z.union([z.string(), z.number()]) }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [swap_tokens] Swapping ${ctx.amount} ${ctx.from} to ${ctx.to}`);
+        ctx.swapHash = '0xdef456...';
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+describe('Plan → Compile → Execute (Real LLM + Onchain Use Cases)', function () {
+  this.timeout(60000); // LLM calls can take time
+
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+    registry.register({
+      name: 'check_balance',
+      description: 'Check wallet ETH balance',
+      graph: createCheckBalanceTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'estimate_gas',
+      description: 'Estimate gas for a transaction',
+      graph: createEstimateGasTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'send_eth',
+      description: 'Send ETH to an address',
+      graph: createSendEthTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'get_token_price',
+      description: 'Get current token price',
+      graph: createGetTokenPriceTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'swap_tokens',
+      description: 'Swap tokens on DEX',
+      graph: createSwapTokensTool(),
+      startNode: 'run',
+    });
+  });
+
+  it('USE CASE 1: Send ETH - should generate a valid plan and execute it', async () => {
+    console.log('\n=== USE CASE 1: Send 0.5 ETH to an address ===\n');
+
+    const plan = await generatePlan(
+      'Check my balance, estimate gas, then send 0.5 ETH to 0x1234567890abcdef',
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+    console.log('\n' + renderPlan(plan));
+
+    // Validate plan
+    const validated = PlanSchema.parse(plan);
+    expect(validated.goal).to.be.a('string');
+    expect(validated.steps.length).to.be.at.least(2);
+
+    // Validate against registry
+    const validation = registry.validateSteps(validated.steps);
+    expect(validation.valid).to.be.true;
+
+    // Compile and execute
+    const { graph, startNode } = compilePlan(plan, registry);
+    console.log(`\nExecuting from node: ${startNode}`);
+
+    const ctx = await graph.execute(startNode, {});
+    console.log('\nFinal context:', JSON.stringify(ctx, null, 2));
+
+    expect(ctx).to.be.an('object');
+    console.log('\n✅ USE CASE 1 COMPLETED\n');
+  });
+
+  it('USE CASE 2: Swap tokens - should generate a plan with price check', async () => {
+    console.log('\n=== USE CASE 2: Swap tokens with price check ===\n');
+
+    const plan = await generatePlan(
+      'Get ETH price, then swap 100 USDC to ETH',
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+    console.log('\n' + renderPlan(plan));
+
+    // Validate
+    const validated = PlanSchema.parse(plan);
+    expect(validated.steps).to.be.an('array').that.is.not.empty;
+
+    const validation = registry.validateSteps(validated.steps);
+    expect(validation.valid).to.be.true;
+
+    // Execute
+    const { graph, startNode } = compilePlan(plan, registry);
+    console.log(`\nExecuting from node: ${startNode}`);
+
+    const ctx = await graph.execute(startNode, {});
+    console.log('\nFinal context:', JSON.stringify(ctx, null, 2));
+
+    expect(ctx).to.be.an('object');
+    console.log('\n✅ USE CASE 2 COMPLETED\n');
+  });
+
+  it('USE CASE 3: Complex workflow - should handle multi-step onchain operations', async () => {
+    console.log('\n=== USE CASE 3: Complex workflow ===\n');
+
+    const plan = await generatePlan(
+      'Check balance, get ETH price, estimate gas, then send 0.1 ETH to 0xabc',
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+    console.log('\n' + renderPlan(plan));
+
+    // Validate
+    const validated = PlanSchema.parse(plan);
+    expect(validated.steps.length).to.be.at.least(3);
+
+    const validation = registry.validateSteps(validated.steps);
+    expect(validation.valid).to.be.true;
+
+    // Execute
+    const { graph, startNode } = compilePlan(plan, registry);
+    console.log(`\nExecuting from node: ${startNode}`);
+
+    const ctx = await graph.execute(startNode, {});
+    console.log('\nFinal context:', JSON.stringify(ctx, null, 2));
+
+    expect(ctx).to.be.an('object');
+    console.log('\n✅ USE CASE 3 COMPLETED\n');
+  });
+
+  it('Should reject plans with unknown tools', async () => {
+    const plan = {
+      goal: 'Hack something',
+      steps: [
+        { node: 'hack_the_planet', description: 'Unknown tool' },
+      ],
+    };
+
+    const validation = registry.validateSteps(plan.steps);
+    expect(validation.valid).to.be.false;
+    expect(validation.errors[0]).to.include('hack_the_planet');
+  });
+});