@minded-ai/mindedjs 1.0.19

package/test/prompt-node/prompt-node.test.ts

@@ -0,0 +1,86 @@
+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('Prompt 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 execute a multi-stage prompt node with onMessage callback', async function () {
+    this.timeout(20000); // Set timeout to 10 seconds for all tests in this suite
+
+    const sessionId = uuidv4();
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Hi there',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    // Should pause execution at prompt node
+    expect(result.memory.success).to.not.equal(true);
+
+    // Should resume execution at success node
+    const result2 = await agent.invoke({
+      triggerBody: {
+        message: 'Itay',
+      },
+      triggerName: 'Trigger',
+      sessionId,
+    });
+
+    expect(result2.memory.success).to.equal(true);
+  });
+});

package/test/setup.ts

@@ -0,0 +1,5 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load environment variables from .env file
+config({ path: resolve(__dirname, '../.env') });

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

@@ -0,0 +1,14 @@
+name: Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+  - type: 'tool'
+    name: 'Test Tool'
+    toolName: 'testTool'
+
+edges:
+  - source: 'Trigger'
+    target: 'Test Tool'
+    type: 'stepForward'

package/test/tool-node/tool-node.test.ts

@@ -0,0 +1,67 @@
+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({
+  processed: z.boolean(),
+});
+
+describe('Tool 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: 'testTool',
+          description: 'Test Tool',
+          input: z.object({
+            test: z.string(),
+          }),
+          execute: async () => ({
+            memory: { processed: 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 execute tool with correct input', async () => {
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Test message',
+      },
+      triggerName: 'Trigger',
+    });
+
+    expect(result.memory.processed).to.equal(true);
+  });
+});

package/test/trigger/flows/test-flow.yaml

@@ -0,0 +1,7 @@
+name: Test Flow
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'Trigger'
+
+edges: []

package/test/trigger/trigger.test.ts

@@ -0,0 +1,57 @@
+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({
+  success: z.boolean(),
+});
+
+describe('Trigger Node', () => {
+  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: [],
+    });
+    // Add trigger event handler
+    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+      if (triggerName === 'Trigger') {
+        return {
+          memory: { success: true },
+          messages: [new HumanMessage(triggerBody.message)],
+        };
+      }
+    });
+  });
+
+  it('should properly transform trigger input', async function () {
+    this.timeout(10000); // Increase timeout to 10 seconds
+
+    const result = await agent.invoke({
+      triggerBody: {
+        message: 'Test message',
+      },
+      triggerName: 'Trigger',
+    });
+
+    expect(result.messages).to.have.lengthOf(1);
+    expect(result.messages[0].content).to.equal('Test message');
+    expect(result.memory.success).to.equal(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}