@minded-ai/mindedjs 1.0.28 → 1.0.30

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

@@ -1,92 +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({
-  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',
-      appName: 'test',
-    });
-
-    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',
-      appName: 'test',
-    });
-
-    expect(result.memory.userName).to.equal('Ilan');
-  });
-});

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

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

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

@@ -1,88 +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('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: sessionId,
-      appName: 'test',
-    });
-
-    // 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: sessionId,
-      appName: 'test',
-    });
-
-    expect(result2.memory.success).to.equal(true);
-  });
-});

package/test/setup.ts

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

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

@@ -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';
-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',
-      appName: 'test',
-    });
-
-    expect(result.memory.processed).to.equal(true);
-  });
-});

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

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

package/test/trigger/trigger.test.ts

@@ -1,185 +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';
-import { Tool } from '../../src/types/Tools.types';
-type Memory = z.infer<typeof memorySchema>;
-
-const memorySchema = z.object({
-  success: z.boolean(),
-});
-
-
-const schema = z.object({
-  orderId: z.string(),
-  customerName: z.string(),
-});
-
-const testTool: Tool<typeof schema, Memory> = {
-  name: 'testTool',
-  description: 'Test tool',
-  input: schema,
-  execute: async ({ triggerInvocations }) => {
-    expect(triggerInvocations).to.have.lengthOf(1);
-  },
-};
-
-describe('Trigger Node', () => {
-  let agent: Agent;
-
-  it('should add trigger invocation to history', async function () {
-    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: [testTool],
-    });
-    await agent.invoke({
-      triggerBody: {
-        message: 'Test message',
-      },
-      triggerName: 'Trigger',
-      appName: 'test',
-    });
-
-  });
-
-  it('should properly transform trigger input', async function () {
-    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)],
-        };
-      }
-    });
-    this.timeout(10000); // Increase timeout to 10 seconds
-
-    const result = await agent.invoke({
-      triggerBody: {
-        message: 'Test message',
-      },
-      triggerName: 'Trigger',
-      appName: 'test',
-    });
-
-    expect(result.messages).to.have.lengthOf(1);
-    expect(result.messages[0].content).to.equal('Test message');
-    expect(result.memory.success).to.equal(true);
-  });
-
-  it('should add trigger invocation to tool calls', async function () {
-    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: [testTool],
-    });
-
-    await agent.invoke({
-      triggerBody: {
-        message: 'Test message',
-      },
-      triggerName: 'Trigger',
-      appName: 'test',
-    });
-  });
-
-  it('should add human message for Slack triggers', async function () {
-    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: [],
-    });
-
-    const slackResult = await agent.invoke({
-      triggerBody: {
-        text: 'Hello from Slack'
-      },
-      triggerName: 'New Direct Message (Instant)',
-      appName: 'Slack',
-    });
-
-    expect(slackResult.messages).to.have.lengthOf(1);
-    expect(slackResult.messages[0].content).to.equal('Hello from Slack');
-  });
-
-  it('should not add messages for triggers without default message injection', async function () {
-    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: [],
-    });
-
-    const otherResult = await agent.invoke({
-      triggerBody: {
-        text: 'Hello from other app'
-      },
-      triggerName: 'SomeOtherTrigger',
-      appName: 'OtherApp',
-    });
-
-    expect(otherResult.messages).to.have.lengthOf(0);
-  });
-});

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "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"]
-}