@minded-ai/mindedjs 1.0.29 → 1.0.30

package/test/edge-priority/edge-priority.test.ts

@@ -1,182 +0,0 @@
-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({
-  result: z.string().optional(),
-  userAge: z.number().optional(),
-  userName: z.string().optional(),
-});
-
-const createTestAgent = (flowsPath: string) => {
-  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: 'stepForwardTool',
-        description: 'Step Forward Tool',
-        input: z.object({
-          message: z.string(),
-        }),
-        execute: async () => ({
-          memory: { result: 'stepForward' },
-        }),
-      },
-      {
-        name: 'logicalTool',
-        description: 'Logical Tool',
-        input: z.object({
-          message: z.string(),
-        }),
-        execute: async () => ({
-          memory: { result: 'logical' },
-        }),
-      },
-      {
-        name: 'promptTool',
-        description: 'Prompt Tool',
-        input: z.object({
-          message: z.string(),
-        }),
-        execute: async () => ({
-          memory: { result: 'prompt' },
-        }),
-      },
-    ],
-  });
-
-  // Add trigger event handler
-  agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
-    if (triggerName === 'TestTrigger') {
-      return {
-        memory: triggerBody.memory || {},
-        messages: [new HumanMessage(triggerBody.message)],
-      };
-    }
-  });
-
-  return agent;
-};
-
-describe('Edge Priority Logic', () => {
-  describe('All 3 Edge Types (Step Forward > Logical > Prompt)', () => {
-    let agent: Agent;
-
-    beforeEach(() => {
-      const flowsPath = path.join(__dirname, 'flows/all-three-edges');
-      agent = createTestAgent(flowsPath);
-    });
-
-    it('should prioritize step forward over logical and prompt', async function () {
-      this.timeout(20000);
-
-      const result = await agent.invoke({
-        triggerBody: {
-          message: 'Test message',
-          memory: { userAge: 25, userName: 'Test' }, // Satisfies logical condition
-        },
-        triggerName: 'TestTrigger',
-      });
-
-      // Step forward should win regardless of other conditions
-      expect(result.memory.result).to.equal('stepForward');
-    });
-  });
-
-  describe('Logical + Prompt Edges (Logical > Prompt)', () => {
-    let agent: Agent;
-
-    beforeEach(() => {
-      const flowsPath = path.join(__dirname, 'flows/logical-prompt-edges');
-      agent = createTestAgent(flowsPath);
-    });
-
-    it('should prioritize logical over prompt when logical condition is met', async function () {
-      this.timeout(20000);
-
-      const result = await agent.invoke({
-        triggerBody: {
-          message: 'Test message',
-          memory: { userAge: 25 }, // Satisfies logical condition (age >= 18)
-        },
-        triggerName: 'TestTrigger',
-      });
-
-      expect(result.memory.result).to.equal('logical');
-    });
-
-    it('should fall back to prompt when logical condition is not met', async function () {
-      this.timeout(20000);
-
-      const result = await agent.invoke({
-        triggerBody: {
-          message: 'Test message',
-          memory: { userAge: 15 }, // Does not satisfy logical condition (age < 18)
-        },
-        triggerName: 'TestTrigger',
-      });
-
-      expect(result.memory.result).to.equal('prompt');
-    });
-  });
-
-  describe('Step Forward + Prompt Edges (Step Forward > Prompt)', () => {
-    let agent: Agent;
-
-    beforeEach(() => {
-      const flowsPath = path.join(__dirname, 'flows/stepforward-prompt-edges');
-      agent = createTestAgent(flowsPath);
-    });
-
-    it('should prioritize step forward over prompt', async function () {
-      this.timeout(20000);
-
-      const result = await agent.invoke({
-        triggerBody: {
-          message: 'Test message',
-          memory: { userName: 'TestUser' }, // Would satisfy prompt condition
-        },
-        triggerName: 'TestTrigger',
-      });
-
-      expect(result.memory.result).to.equal('stepForward');
-    });
-  });
-
-  describe('Step Forward + Logical Edges (Step Forward > Logical)', () => {
-    let agent: Agent;
-
-    beforeEach(() => {
-      const flowsPath = path.join(__dirname, 'flows/stepforward-logical-edges');
-      agent = createTestAgent(flowsPath);
-    });
-
-    it('should prioritize step forward over logical', async function () {
-      this.timeout(20000);
-
-      const result = await agent.invoke({
-        triggerBody: {
-          message: 'Test message',
-          memory: { userAge: 25 }, // Would satisfy logical condition
-        },
-        triggerName: 'TestTrigger',
-      });
-
-      expect(result.memory.result).to.equal('stepForward');
-    });
-  });
-});

package/test/edge-priority/flows/all-three-edges/test-flow.yaml

@@ -1,35 +0,0 @@
-name: All Three Edges Priority Test
-nodes:
-  - type: 'trigger'
-    triggerType: 'manual'
-    name: 'TestTrigger'
-
-  - type: 'tool'
-    name: 'Step Forward Tool'
-    toolName: 'stepForwardTool'
-
-  - type: 'tool'
-    name: 'Logical Tool'
-    toolName: 'logicalTool'
-
-  - type: 'tool'
-    name: 'Prompt Tool'
-    toolName: 'promptTool'
-
-edges:
-  # Prompt condition edge (Priority 3)
-  - source: 'TestTrigger'
-    target: 'Prompt Tool'
-    type: 'promptCondition'
-    prompt: 'User wants to use prompt tool'
-
-  # Step forward edge (Priority 1 - should win)
-  - source: 'TestTrigger'
-    target: 'Step Forward Tool'
-    type: 'stepForward'
-
-  # Logical condition edge (Priority 2)
-  - source: 'TestTrigger'
-    target: 'Logical Tool'
-    type: 'logicalCondition'
-    condition: '({ memory }) => memory.userAge >= 18'

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

@@ -1,26 +0,0 @@
-name: Logical + Prompt Edges Priority Test
-nodes:
-  - type: 'trigger'
-    triggerType: 'manual'
-    name: 'TestTrigger'
-
-  - type: 'tool'
-    name: 'Logical Tool'
-    toolName: 'logicalTool'
-
-  - type: 'tool'
-    name: 'Prompt Tool'
-    toolName: 'promptTool'
-
-edges:
-  # Prompt condition edge (Priority 3 - fallback when logical fails)
-  - source: 'TestTrigger'
-    target: 'Prompt Tool'
-    type: 'promptCondition'
-    prompt: 'User wants to use prompt tool'
-
-  # Logical condition edge (Priority 2 - should win when condition met)
-  - source: 'TestTrigger'
-    target: 'Logical Tool'
-    type: 'logicalCondition'
-    condition: '({ memory }) => memory.userAge >= 18'

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

@@ -1,25 +0,0 @@
-name: Step Forward + Logical Edges Priority Test
-nodes:
-  - type: 'trigger'
-    triggerType: 'manual'
-    name: 'TestTrigger'
-
-  - type: 'tool'
-    name: 'Step Forward Tool'
-    toolName: 'stepForwardTool'
-
-  - type: 'tool'
-    name: 'Logical Tool'
-    toolName: 'logicalTool'
-
-edges:
-  # Logical condition edge (Priority 2)
-  - source: 'TestTrigger'
-    target: 'Logical Tool'
-    type: 'logicalCondition'
-    condition: '({ memory }) => memory.userAge >= 18'
-
-  # Step forward edge (Priority 1 - should win)
-  - source: 'TestTrigger'
-    target: 'Step Forward Tool'
-    type: 'stepForward'

package/test/edge-priority/flows/stepforward-prompt-edges/test-flow.yaml

@@ -1,25 +0,0 @@
-name: Step Forward + Prompt Edges Priority Test
-nodes:
-  - type: 'trigger'
-    triggerType: 'manual'
-    name: 'TestTrigger'
-
-  - type: 'tool'
-    name: 'Step Forward Tool'
-    toolName: 'stepForwardTool'
-
-  - type: 'tool'
-    name: 'Prompt Tool'
-    toolName: 'promptTool'
-
-edges:
-  # Prompt condition edge (Priority 3)
-  - source: 'TestTrigger'
-    target: 'Prompt Tool'
-    type: 'promptCondition'
-    prompt: 'User wants to use prompt tool'
-
-  # Step forward edge (Priority 1 - should win)
-  - source: 'TestTrigger'
-    target: 'Step Forward Tool'
-    type: 'stepForward'

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

@@ -1,23 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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: sessionId,
-      appName: 'test',
-    });
-
-    // 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: sessionId,
-      appName: 'test',
-    });
-
-    // 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

@@ -1,24 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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({
-      triggerBody: { userAge: 25 },
-      triggerName: 'AgeTrigger',
-      appName: 'test',
-    });
-    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({
-      triggerBody: { userAge: 15 },
-      triggerName: 'AgeTrigger',
-      appName: 'test',
-    });
-    expect(result.memory.isMinor).to.equal(true);
-  });
-}); 

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

@@ -1,23 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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: sessionId,
-      appName: 'test',
-    });
-
-    // 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

@@ -1,24 +0,0 @@
-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'