@ai.ntellect/core 1.0.0 → 1.1.1

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');
+  });
+});

package/test/execution/plan-real-onchain.test.ts

@@ -0,0 +1,226 @@
+import { expect } from 'chai';
+import { z } from 'zod';
+import { createPublicClient, createWalletClient, http, parseEther, formatEther } from 'viem';
+import { sepolia } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+import { GraphFlow } from '../../execution/index';
+import { ToolRegistry } from '../../execution/registry';
+import { generatePlan, PlanSchema, renderPlan } from '../../execution/planner';
+import { compilePlan } from '../../execution/compiler';
+
+// Load env
+function loadEnv() {
+  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;
+}
+
+const env = loadEnv();
+const RPC_URL = env['RPC_URL'];
+const PRIVATE_KEY_1 = env['PRIVATE_KEY_1'];
+
+// Real viem clients
+const publicClient = createPublicClient({ chain: sepolia, transport: http(RPC_URL) });
+const account = privateKeyToAccount(PRIVATE_KEY_1 as `0x${string}`);
+const walletClient = createWalletClient({ account, chain: sepolia, transport: http(RPC_URL) });
+
+// Real LLM call via Groq
+async function callGroq(prompt: string): Promise<string> {
+  const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${env['GROQ_API_KEY']}`,
+    },
+    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) throw new Error(`Groq API error: ${await response.text()}`);
+  return (await response.json()).choices[0].message.content;
+}
+
+// Real onchain tools
+function createRealCheckBalanceTool() {
+  const g = new GraphFlow<any>({
+    name: 'check_balance',
+    context: { balance: '', address: '' },
+    schema: z.object({ balance: z.string(), address: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        const address = ctx.address || account.address;
+        console.log(`  [check_balance] Checking real balance for ${address}`);
+        const balance = await publicClient.getBalance({ address });
+        ctx.balance = formatEther(balance);
+        ctx.address = address;
+        console.log(`  [check_balance] Balance: ${ctx.balance} ETH`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createRealEstimateGasTool() {
+  const g = new GraphFlow<any>({
+    name: 'estimate_gas',
+    context: { gas: 0, to: '', amount: '' },
+    schema: z.object({ gas: z.number(), to: z.string(), amount: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [estimate_gas] Estimating gas for ${ctx.amount} ETH to ${ctx.to}`);
+        const gas = await publicClient.estimateGas({
+          account,
+          to: ctx.to,
+          value: parseEther(ctx.amount || '0.001'),
+        });
+        ctx.gas = Number(gas);
+        console.log(`  [estimate_gas] Estimated gas: ${ctx.gas}`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createRealSendEthTool() {
+  const g = new GraphFlow<any>({
+    name: 'send_eth',
+    context: { txHash: '', to: '', amount: '', balance: '' },
+    schema: z.object({ txHash: z.string(), to: z.string(), amount: z.string(), balance: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [send_eth] Sending REAL ${ctx.amount} ETH to ${ctx.to}`);
+        const hash = await walletClient.sendTransaction({
+          to: ctx.to,
+          value: parseEther(ctx.amount || '0.001'),
+        });
+        ctx.txHash = hash;
+        console.log(`  [send_eth] TX sent: ${hash}`);
+        console.log(`  [send_eth] View: https://sepolia.etherscan.io/tx/${hash}`);
+
+        // Wait for confirmation
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        console.log(`  [send_eth] Confirmed! Block: ${receipt.blockNumber}`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+describe('Plan → Compile → Execute (REAL Onchain + LLM)', function () {
+  this.timeout(120000); // Onchain + LLM calls take time
+
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+    registry.register({
+      name: 'check_balance',
+      description: 'Check wallet ETH balance on Sepolia',
+      graph: createRealCheckBalanceTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'estimate_gas',
+      description: 'Estimate gas for a transaction on Sepolia',
+      graph: createRealEstimateGasTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'send_eth',
+      description: 'Send ETH to an address on Sepolia',
+      graph: createRealSendEthTool(),
+      startNode: 'run',
+    });
+  });
+
+  it('USE CASE 1 (REAL): Check balance + Send 0.001 ETH to another wallet', async () => {
+    console.log('\n=== USE CASE 1 (REAL): Send 0.001 ETH to STUDENT_2 ===\n');
+
+    const plan = await generatePlan(
+      `Check my balance, estimate gas, then send 0.001 ETH to ${env['STUDENT_2']}`,
+      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 REAL onchain
+    const { graph, startNode } = compilePlan(plan, registry);
+    console.log(`\nExecuting REAL onchain plan from node: ${startNode}`);
+
+    const ctx = await graph.execute(startNode, {});
+    console.log('\nFinal context:', JSON.stringify(ctx, null, 2));
+
+    expect(ctx.txHash).to.be.a('string');
+    expect(ctx.txHash).to.include('0x');
+    console.log('\n✅ USE CASE 1 COMPLETED - REAL TX SENT!\n');
+    console.log(`   TX: https://sepolia.etherscan.io/tx/${ctx.txHash}`);
+  });
+
+  it('USE CASE 2 (REAL): Just check balance', async () => {
+    console.log('\n=== USE CASE 2 (REAL): Check balance ===\n');
+
+    const plan = await generatePlan(
+      'Check my wallet balance on Sepolia',
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+
+    const { graph, startNode } = compilePlan(plan, registry);
+    const ctx = await graph.execute(startNode, {});
+
+    console.log('\nBalance:', ctx.balance, 'ETH');
+    expect(ctx.balance).to.be.a('string');
+    console.log('\n✅ USE CASE 2 COMPLETED\n');
+  });
+
+  it('USE CASE 3 (REAL): Estimate gas without sending', async () => {
+    console.log('\n=== USE CASE 3 (REAL): Estimate gas ===\n');
+
+    const plan = await generatePlan(
+      `Estimate gas to send 0.001 ETH to ${env['STUDENT_3']}`,
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+
+    const { graph, startNode } = compilePlan(plan, registry);
+    const ctx = await graph.execute(startNode, {});
+
+    console.log('\nEstimated gas:', ctx.gas);
+    expect(ctx.gas).to.be.a('number').above(21000);
+    console.log('\n✅ USE CASE 3 COMPLETED\n');
+  });
+});

package/test/execution/send-api.test.ts

@@ -0,0 +1,121 @@
+import { expect } from "chai";
+import { GraphFlow } from "../../execution";
+import { nodeRegistry } from "../../execution/registry";
+import { ParallelNodeConfig } from "../../execution/types.parallel";
+
+describe("Send API (Fan-out dynamique)", () => {
+  beforeEach(() => {
+    (nodeRegistry as any).executeFunctions.clear();
+    (nodeRegistry as any).nodeConfigs.clear();
+  });
+
+  it("should fan-out to dynamic number of branches", async () => {
+    const items = ["item1", "item2", "item3"];
+    let processedCount = 0;
+
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "start",
+        execute: async (ctx: any) => {
+          ctx.processed = [];
+        },
+        send: (ctx: any) => {
+          return ctx.items.map((item: string, i: number) => ({
+            to: "processItem",
+            input: { currentItem: item, index: i },
+            branchId: `item_${i}`,
+          }));
+        },
+        parallel: { enabled: true, joinNode: "done" },
+      },
+      {
+        name: "processItem",
+        execute: async (ctx: any) => {
+          ctx.processed.push(`Processed: ${ctx.currentItem}`);
+        },
+      },
+      {
+        name: "done",
+        execute: async (ctx: any) => {
+          ctx.finished = true;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "send-api-test",
+      schema: { parse: (ctx: any) => ctx } as any,
+      context: { items, processed: [] as string[] },
+      nodes: nodes,
+      entryNode: "start",
+    });
+
+    nodes.forEach(node => nodeRegistry.registerParallel(node));
+
+    const context = await graph.execute("start");
+
+    expect(context.processed).to.have.length(3);
+    expect(context.finished).to.be.true;
+    expect(context.processed[0]).to.include("item1");
+    expect(context.processed[1]).to.include("item2");
+    expect(context.processed[2]).to.include("item3");
+  });
+
+  it("should use reducers for state merge", async () => {
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "start",
+        execute: async (ctx: any) => {
+          ctx.results = [];
+        },
+        send: (ctx: any) => {
+          return [
+            { to: "addOne", input: { value: "A" } },
+            { to: "addTwo", input: { value: "B" } },
+          ];
+        },
+        parallel: { enabled: true, joinNode: "merge" },
+        reducers: [
+          {
+            key: "results",
+            reducer: (acc: string[], val: string) => [...acc, val],
+            initial: [],
+          },
+        ],
+      },
+      {
+        name: "addOne",
+        execute: async (ctx: any) => {
+          ctx.results.push(ctx.value);
+        },
+      },
+      {
+        name: "addTwo",
+        execute: async (ctx: any) => {
+          ctx.results.push(ctx.value);
+        },
+      },
+      {
+        name: "merge",
+        execute: async (ctx: any) => {
+          ctx.merged = true;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "reducer-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.results).to.have.length(2);
+    expect(context.merged).to.be.true;
+  });
+});