@minded-ai/mindedjs 1.0.19

package/test/cannot-stay-on-node/cannot-stay-on-node.test.ts

@@ -0,0 +1,201 @@
+import { expect } from 'chai';
+import { Agent } from '../../src/agent';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import { AgentEvents } from '../../src/events/AgentEvents';
+import { HumanMessage } from '@langchain/core/messages';
+
+const memorySchema = z.object({
+  success: z.boolean(),
+  alternative: z.boolean(),
+});
+
+describe('Cannot Stay On Node', function () {
+  this.timeout(10000); // Set timeout to 10 seconds for all tests in this suite
+
+  let agent: Agent;
+
+  beforeEach(() => {
+    const flowsPath = path.join(__dirname, 'flows');
+    const toolsPath = path.join(__dirname, 'tools');
+    agent = new Agent({
+      memorySchema,
+      config: {
+        flows: [flowsPath],
+        tools: [toolsPath],
+        llm: {
+          name: 'ChatOpenAI',
+          properties: {
+            model: 'gpt-4o-mini',
+          },
+        },
+      },
+      tools: [
+        {
+          name: 'successTool',
+          description: 'Success Tool that marks completion',
+          input: z.object({
+            name: z.string(),
+          }),
+          execute: async () => ({
+            memory: {
+              success: true,
+              alternative: false,
+            },
+          }),
+        },
+        {
+          name: 'alternativeTool',
+          description: 'Alternative Tool that marks alternative completion',
+          input: z.object({
+            name: z.string(),
+          }),
+          execute: async () => ({
+            memory: {
+              success: false,
+              alternative: true,
+            },
+          }),
+        },
+      ],
+    });
+
+    // Add trigger event handler
+    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+      if (triggerName === 'Trigger') {
+        return {
+          memory: {},
+          messages: [new HumanMessage(triggerBody.message)],
+        };
+      }
+    });
+  });
+
+  it('should NOT stay on node when explicitly requested to stay (canStayOnNode is false)', async function () {
+    this.timeout(20000);
+
+    const sessionId = uuidv4();
+
+    // First invocation - triggers the flow and reaches the human-in-the-loop pause
+    const result1 = await agent.invoke({
+      triggerBody: {
+        message: 'Initial input for processing',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should pause at human-in-the-loop, not reach any tool yet
+    expect(result1.memory.success).to.not.equal(true);
+    expect(result1.memory.alternative).to.not.equal(true);
+    expect(result1.messages).to.have.length.greaterThan(0);
+
+    // Second invocation - explicitly request to stay on the node
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message: 'You must stay at the node! Do not move to the next step. Stay here and continue processing on this same node.',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should NOT stay on the node - should move to one of the target nodes
+    // Since canStayOnNode is false, the router has no self-referencing edge option
+    expect(result2.memory.success || result2.memory.alternative).to.equal(true);
+  });
+
+  it('should move to success node when user requests main workflow', async function () {
+    this.timeout(20000);
+
+    const sessionId = uuidv4();
+
+    // First invocation - initial trigger
+    const result1 = await agent.invoke({
+      triggerBody: {
+        message: 'Start processing',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    expect(result1.memory.success).to.not.equal(true);
+    expect(result1.memory.alternative).to.not.equal(true);
+
+    // Second invocation - request main workflow
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message: 'Proceed with the main workflow',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should move to success node
+    expect(result2.memory.success).to.equal(true);
+    expect(result2.memory.alternative).to.equal(false);
+  });
+
+  it('should move to alternative node when user requests alternative approach', async function () {
+    this.timeout(20000);
+
+    const sessionId = uuidv4();
+
+    // First invocation - initial trigger
+    const result1 = await agent.invoke({
+      triggerBody: {
+        message: 'Begin workflow',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    expect(result1.memory.success).to.not.equal(true);
+    expect(result1.memory.alternative).to.not.equal(true);
+
+    // Second invocation - request alternative approach
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message: 'I want an alternative approach instead',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should move to alternative node
+    expect(result2.memory.success).to.equal(false);
+    expect(result2.memory.alternative).to.equal(true);
+  });
+
+  it('should force progression even with strong stay requests', async function () {
+    this.timeout(20000);
+
+    const sessionId = uuidv4();
+
+    // First invocation - initial trigger
+    const result1 = await agent.invoke({
+      triggerBody: {
+        message: 'Process this data',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    expect(result1.memory.success).to.not.equal(true);
+    expect(result1.memory.alternative).to.not.equal(true);
+
+    // Second invocation - very strong request to stay
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message:
+          'STAY! Do not proceed! You must remain on this current node and not move forward. Keep processing here. Do not go to any other node.',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should still be forced to move to one of the available target nodes
+    // because there's no self-referencing edge (canStayOnNode is false)
+    expect(result2.memory.success || result2.memory.alternative).to.equal(true);
+  });
+});

package/test/cannot-stay-on-node/flows/test-flow.yaml

@@ -0,0 +1,34 @@
+name: Cannot Stay On Node Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'promptNode'
+    name: 'ProcessingNode'
+    prompt: 'I have processed your input. Please provide your feedback or additional instructions.'
+    humanInTheLoop: true
+    # Note: canStayOnNode is NOT set to true
+
+  - type: 'tool'
+    name: 'Success'
+    toolName: 'successTool'
+
+  - type: 'tool'
+    name: 'Alternative'
+    toolName: 'alternativeTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'ProcessingNode'
+    type: 'stepForward'
+
+  - source: 'ProcessingNode'
+    target: 'Success'
+    type: 'promptCondition'
+    prompt: 'move to success node if the user wants to proceed with the main workflow'
+
+  - source: 'ProcessingNode'
+    target: 'Alternative'
+    type: 'promptCondition'
+    prompt: 'move to alternative node if the user wants an alternative approach'

package/test/human-in-the-loop-node/flows/test-flow.yaml

@@ -0,0 +1,23 @@
+name: Human In The Loop Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'promptNode'
+    name: 'ProcessingNode'
+    prompt: 'Process the user input and prepare for human review'
+    humanInTheLoop: true
+
+  - type: 'tool'
+    name: 'Success'
+    toolName: 'successTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'ProcessingNode'
+    type: 'stepForward'
+
+  - source: 'ProcessingNode'
+    target: 'Success'
+    type: 'stepForward'

package/test/human-in-the-loop-node/human-in-the-loop-node.test.ts

@@ -0,0 +1,92 @@
+import { expect } from 'chai';
+import { Agent } from '../../src/agent';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import { AgentEvents } from '../../src/events/AgentEvents';
+import { HumanMessage } from '@langchain/core/messages';
+
+const memorySchema = z.object({
+  success: z.boolean(),
+});
+
+describe('Human In The Loop Node', function () {
+  this.timeout(10000); // Set timeout to 10 seconds for all tests in this suite
+
+  let agent: Agent;
+
+  beforeEach(() => {
+    const flowsPath = path.join(__dirname, 'flows');
+    const toolsPath = path.join(__dirname, 'tools');
+    agent = new Agent({
+      memorySchema,
+      config: {
+        flows: [flowsPath],
+        tools: [toolsPath],
+        llm: {
+          name: 'ChatOpenAI',
+          properties: {
+            model: 'gpt-4.1',
+          },
+        },
+      },
+      tools: [
+        {
+          name: 'successTool',
+          description: 'Success Tool',
+          input: z.object({
+            name: z.string(),
+          }),
+          execute: async () => ({
+            memory: {
+              success: true,
+            },
+          }),
+        },
+      ],
+    });
+
+    // Add trigger event handler
+    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+      if (triggerName === 'Trigger') {
+        return {
+          memory: {},
+          messages: [new HumanMessage(triggerBody.message)],
+        };
+      }
+    });
+  });
+
+  it('should pause execution at human-in-the-loop node and resume after human input', async function () {
+    this.timeout(20000); // Set timeout to 20 seconds for this test
+
+    const sessionId = uuidv4();
+
+    // First invocation should execute the ProcessingNode and then pause at the human-in-the-loop node
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Initial user input for processing',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should pause execution at human-in-the-loop node, not reaching the success tool yet
+    expect(result.memory.success).to.not.equal(true);
+
+    // Verify that we have messages from the processing node
+    expect(result.messages).to.have.length.greaterThan(0);
+
+    // Second invocation should provide human input and continue to the Success node
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message: 'Human approval: proceed with the workflow',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should complete execution and reach the success tool
+    expect(result2.memory.success).to.equal(true);
+  });
+});

package/test/logical-edges/flows/logical-edge-test-flow.yaml

@@ -0,0 +1,24 @@
+name: Age Flow
+nodes:
+  - type: "trigger"
+    triggerType: "manual"
+    name: "AgeTrigger"
+  
+  - type: "tool"
+    name: "Adult Tool"
+    toolName: "adultTool"
+  
+  - type: "tool"
+    name: "Minor Tool"
+    toolName: "minorTool"
+
+edges:
+  - source: "AgeTrigger"
+    target: "Adult Tool"
+    type: "logicalCondition"
+    condition: "({ memory }) => memory.userAge >= 18"
+  
+  - source: "AgeTrigger"
+    target: "Minor Tool"
+    type: "logicalCondition"
+    condition: "({ memory }) => memory.userAge < 18" 

package/test/logical-edges/logical-edges.test.ts

@@ -0,0 +1,66 @@
+import { expect } from 'chai';
+import { Agent } from "../../src/agent";
+import { z } from "zod";
+import path from 'path';
+import { AgentEvents } from "../../src/events/AgentEvents";
+
+const memorySchema = z.object({
+  userAge: z.number(),
+  isMinor: z.boolean(),
+});
+
+describe('Logical Edges', () => {
+  const flowsPath = path.join(__dirname, 'flows');
+  const toolsPath = path.join(__dirname, 'tools');
+  const agent = new Agent({
+    memorySchema,
+    config: {
+      flows: [flowsPath],
+      tools: [toolsPath],
+      llm: {
+        name: 'ChatOpenAI',
+        properties: {
+          model: 'gpt-4.1'
+        }
+      }
+    },
+    tools: [
+      {
+        name: 'adultTool',
+        description: 'Adult Tool',
+        input: z.object({}),
+        execute: async () => ({ memory: { isMinor: false } }),
+      },
+      {
+        name: 'minorTool',
+        description: 'Minor Tool',
+        input: z.object({}),
+        execute: async () => ({ memory: { isMinor: true } }),
+      },
+    ],
+  });
+
+  agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerBody }) => {
+    return {
+      memory: triggerBody
+    }
+  });
+
+  it('should execute the Adult Tool', async function () {
+    this.timeout(10000); // Increase timeout to 10 seconds
+    const result = await agent.invoke({
+      triggerName: 'AgeTrigger',
+      triggerBody: { userAge: 25 },
+    });
+    expect(result.memory.isMinor).to.equal(false);
+  });
+
+  it('should execute the Minor Tool', async function () {
+    this.timeout(10000); // Increase timeout to 10 seconds
+    const result = await agent.invoke({
+      triggerName: 'AgeTrigger',
+      triggerBody: { userAge: 15 },
+    });
+    expect(result.memory.isMinor).to.equal(true);
+  });
+}); 

package/test/no-human-in-the-loop-node/flows/test-flow.yaml

@@ -0,0 +1,23 @@
+name: No Human In The Loop Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'promptNode'
+    name: 'ProcessingNode'
+    prompt: 'Process the user input and prepare for completion'
+    humanInTheLoop: false
+
+  - type: 'tool'
+    name: 'Success'
+    toolName: 'successTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'ProcessingNode'
+    type: 'stepForward'
+
+  - source: 'ProcessingNode'
+    target: 'Success'
+    type: 'stepForward'

package/test/no-human-in-the-loop-node/no-human-in-the-loop-node.test.ts

@@ -0,0 +1,80 @@
+import { expect } from 'chai';
+import { Agent } from '../../src/agent';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import { AgentEvents } from '../../src/events/AgentEvents';
+import { HumanMessage } from '@langchain/core/messages';
+
+const memorySchema = z.object({
+  success: z.boolean(),
+});
+
+describe('No Human In The Loop Node', function () {
+  this.timeout(10000); // Set timeout to 10 seconds for all tests in this suite
+
+  let agent: Agent;
+
+  beforeEach(() => {
+    const flowsPath = path.join(__dirname, 'flows');
+    const toolsPath = path.join(__dirname, 'tools');
+    agent = new Agent({
+      memorySchema,
+      config: {
+        flows: [flowsPath],
+        tools: [toolsPath],
+        llm: {
+          name: 'ChatOpenAI',
+          properties: {
+            model: 'gpt-4.1',
+          },
+        },
+      },
+      tools: [
+        {
+          name: 'successTool',
+          description: 'Success Tool',
+          input: z.object({
+            name: z.string(),
+          }),
+          execute: async () => ({
+            memory: {
+              success: true,
+            },
+          }),
+        },
+      ],
+    });
+
+    // Add trigger event handler
+    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+      if (triggerName === 'Trigger') {
+        return {
+          memory: {},
+          messages: [new HumanMessage(triggerBody.message)],
+        };
+      }
+    });
+  });
+
+  it('should complete execution without pausing when humanInTheLoop is false', async function () {
+    this.timeout(20000); // Set timeout to 20 seconds for this test
+
+    const sessionId = uuidv4();
+
+    // Single invocation should complete the entire flow without pausing
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Input for processing without human intervention',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should complete execution and reach the success tool in one go
+    expect(result.memory.success).to.equal(true);
+
+    // Verify that we have messages from both the processing node and the tool execution
+    expect(result.messages).to.have.length.greaterThan(0);
+  });
+});

package/test/prompt-edges/flows/test-flow.yaml

@@ -0,0 +1,24 @@
+name: Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'tool'
+    name: 'Success Tool'
+    toolName: 'successTool'
+
+  - type: 'tool'
+    name: 'Failure Tool'
+    toolName: 'failureTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'Success Tool'
+    type: 'promptCondition'
+    prompt: 'User name is Itay'
+
+  - source: 'Trigger'
+    target: 'Failure Tool'
+    type: 'promptCondition'
+    prompt: 'User name is not Itay'

package/test/prompt-edges/prompt-edges.test.ts

@@ -0,0 +1,90 @@
+import { expect } from 'chai';
+import { Agent } from '../../src/agent';
+import { z } from 'zod';
+import path from 'path';
+import { AgentEvents } from '../../src/events/AgentEvents';
+import { HumanMessage } from '@langchain/core/messages';
+
+const memorySchema = z.object({
+  userName: z.string(),
+});
+
+describe('Prompt Edges', () => {
+  let agent: Agent;
+
+  beforeEach(() => {
+    const flowsPath = path.join(__dirname, 'flows');
+    const toolsPath = path.join(__dirname, 'tools');
+    agent = new Agent({
+      memorySchema,
+      config: {
+        flows: [flowsPath],
+        tools: [toolsPath],
+        llm: {
+          name: 'ChatOpenAI',
+          properties: {
+            model: 'gpt-4.1'
+          }
+        }
+      },
+      tools: [
+        {
+          name: 'successTool',
+          description: 'Success Tool',
+          input: z.object({
+            userName: z.string(),
+          }),
+          execute: async ({ input }) => ({
+            memory: { userName: input.userName },
+          }),
+        },
+        {
+          name: 'failureTool',
+          description: 'Failure Tool',
+          input: z.object({
+            userName: z.string(),
+          }),
+          execute: async ({ input }) => ({
+            memory: { userName: input.userName },
+          }),
+        },
+      ],
+    });
+
+    // Add trigger event handler
+    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+      if (triggerName === 'Trigger') {
+        return {
+          memory: {},
+          messages: [new HumanMessage(triggerBody.message)],
+        };
+      }
+    });
+  });
+
+  it('should evaluate prompt condition edge correctly', async function () {
+    this.timeout(10000); // Increase timeout to 10 seconds
+
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Hi, my name is Itay',
+      },
+      triggerName: 'Trigger',
+    });
+
+    expect(result.memory.userName).to.equal('Itay');
+  });
+
+  it('should evaluate prompt condition edge correctly', async function () {
+    this.timeout(10000); // Increase timeout to 10 seconds
+
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Hi, my name is Ilan',
+      },
+      triggerName: 'Trigger',
+    });
+
+    expect(result.memory.userName).to.equal('Ilan');
+  });
+});

package/test/prompt-node/flows/test-flow.yaml

@@ -0,0 +1,24 @@
+name: Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'promptNode'
+    name: 'Prompt'
+    prompt: 'Ask the user for their name'
+    humanInTheLoop: true
+    canStayOnNode: true
+
+  - type: 'tool'
+    name: 'Success'
+    toolName: 'successTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'Prompt'
+    type: 'stepForward'
+
+  - source: 'Prompt'
+    target: 'Success'
+    type: 'stepForward'