@minded-ai/mindedjs 1.0.28 → 1.0.30

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

@@ -1,154 +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(),
-  stayCount: z.number().optional(),
-});
-
-describe('Can 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: {
-        tools: [toolsPath],
-        flows: [flowsPath],
-        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,
-            },
-          }),
-        },
-      ],
-    });
-
-    // Add trigger event handler
-    agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
-      if (triggerName === 'Trigger') {
-        return {
-          memory: {},
-          messages: [new HumanMessage(triggerBody.message)],
-        };
-      }
-    });
-  });
-
-  it('should stay on the same node multiple times when instructed to stay, then continue', async function () {
-    this.timeout(20000); // Set timeout to 40 seconds for this test
-
-    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: sessionId,
-      appName: 'test',
-    });
-
-    // Should pause at human-in-the-loop, not reach success tool yet
-    expect(result1.memory.success).to.not.equal(true);
-    expect(result1.messages).to.have.length.greaterThan(0);
-
-    // Second invocation - provide "stay" instruction
-    const result2 = await agent.invoke({
-      triggerBody: {
-        message: 'stay',
-      },
-      triggerName: 'Trigger',
-      sessionId: sessionId,
-      appName: 'test',
-    });
-
-    // Should stay on the node, pause again, not reach success tool
-    expect(result2.memory.success).to.not.equal(true);
-    expect(result2.messages).to.have.length.greaterThan(0);
-
-    // Third invocation - provide another "stay" instruction
-    const result3 = await agent.invoke({
-      triggerBody: {
-        message: 'stay',
-      },
-      triggerName: 'Trigger',
-      sessionId: sessionId,
-      appName: 'test',
-    });
-
-    // Should still stay on the node, pause again
-    expect(result3.memory.success).to.not.equal(true);
-    expect(result3.messages).to.have.length.greaterThan(0);
-
-    // Fourth invocation - provide "continue" instruction
-    const result4 = await agent.invoke({
-      triggerBody: {
-        message: 'continue',
-      },
-      triggerName: 'Trigger',
-      sessionId: sessionId,
-      appName: 'test',
-    });
-
-    // Should now move to success tool and complete
-    expect(result4.memory.success).to.equal(true);
-  });
-
-  it('should move to next node immediately when instructed to continue', async function () {
-    this.timeout(20000); // Set timeout to 20 seconds for this test
-
-    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: sessionId,
-      appName: 'test',
-    });
-
-    // Should pause at human-in-the-loop, not reach success tool yet
-    expect(result1.memory.success).to.not.equal(true);
-    expect(result1.messages).to.have.length.greaterThan(0);
-
-    // Second invocation - provide "continue" instruction
-    const result2 = await agent.invoke({
-      triggerBody: {
-        message: 'continue',
-      },
-      triggerName: 'Trigger',
-      sessionId: sessionId,
-      appName: 'test',
-    });
-
-    // Should now move to success tool and complete
-    expect(result2.memory.success).to.equal(true);
-  });
-});

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

@@ -1,25 +0,0 @@
-name: Can Stay On Node Test Flow
-nodes:
-  - type: 'trigger'
-    triggerType: 'manual'
-    name: 'Trigger'
-
-  - type: 'promptNode'
-    name: 'DecisionNode'
-    prompt: 'I have processed your input. Would you like me to continue to the next step, or should I stay on this node for further processing? Please respond with "continue" to move forward or "stay" to remain here for additional analysis.'
-    canStayOnNode: true
-    humanInTheLoop: true
-
-  - type: 'tool'
-    name: 'Success'
-    toolName: 'successTool'
-
-edges:
-  - source: 'Trigger'
-    target: 'DecisionNode'
-    type: 'stepForward'
-
-  - source: 'DecisionNode'
-    target: 'Success'
-    type: 'promptCondition'
-    prompt: 'move to success node if the user wants to continue or if processing is complete'

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

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

@@ -1,34 +0,0 @@
-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/checkpoint-saver/minded-checkpoint-saver-list.test.ts

@@ -1,140 +0,0 @@
-import { expect } from 'chai';
-import { describe, it, beforeEach, afterEach } from 'mocha';
-import * as sinon from 'sinon';
-import { MindedCheckpointSaver } from '../../src/platform/mindedCheckpointSaver';
-import { Checkpoint, CheckpointTuple, CheckpointMetadata, emptyCheckpoint, CheckpointListOptions } from '@langchain/langgraph-checkpoint';
-import { RunnableConfig } from '@langchain/core/runnables';
-import { HumanMessage, AIMessage, SystemMessage } from '@langchain/core/messages';
-import { MindedConnection } from '../../src/platform/mindedConnection';
-import { MindedConnectionSocketMessageType } from '../../src/platform/mindedConnectionTypes';
-
-describe('MindedCheckpointSaver - List Method', function () {
-  let checkpointSaver: MindedCheckpointSaver;
-  let mindedConnection: MindedConnection;
-  let awaitEmitStub: sinon.SinonStub;
-
-  beforeEach(() => {
-    mindedConnection = new MindedConnection();
-    checkpointSaver = new MindedCheckpointSaver(mindedConnection);
-    awaitEmitStub = sinon.stub(mindedConnection, 'awaitEmit');
-  });
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  describe('list', () => {
-    it('should deserialize multiple checkpoints with different message types', async () => {
-      // Create original checkpoints with proper class instances
-      const checkpoint1: Checkpoint = {
-        ...emptyCheckpoint(),
-        id: 'checkpoint-1',
-        channel_values: {
-          messages: [new HumanMessage('First message')],
-        },
-      };
-
-      const checkpoint2: Checkpoint = {
-        ...emptyCheckpoint(),
-        id: 'checkpoint-2',
-        channel_values: {
-          messages: [new SystemMessage('System prompt'), new AIMessage('AI response')],
-        },
-      };
-
-      const metadata1: CheckpointMetadata = {
-        source: 'input',
-        step: 1,
-        writes: {},
-        parents: {},
-      };
-
-      const metadata2: CheckpointMetadata = {
-        source: 'loop',
-        step: 2,
-        writes: {},
-        parents: {},
-      };
-
-      // Simulate JSON serialization (what happens during HTTP transport)
-      const jsonCheckpoint1 = JSON.parse(JSON.stringify(checkpoint1));
-      const jsonCheckpoint2 = JSON.parse(JSON.stringify(checkpoint2));
-      const jsonMetadata1 = JSON.parse(JSON.stringify(metadata1));
-      const jsonMetadata2 = JSON.parse(JSON.stringify(metadata2));
-
-      const mockServerResponse = {
-        checkpoints: [
-          {
-            config: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } },
-            checkpoint: jsonCheckpoint1,
-            metadata: jsonMetadata1,
-            parentConfig: undefined,
-          },
-          {
-            config: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-2' } },
-            checkpoint: jsonCheckpoint2,
-            metadata: jsonMetadata2,
-            parentConfig: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } },
-          },
-        ],
-      };
-
-      // Mock the awaitEmit response
-      awaitEmitStub.resolves(mockServerResponse);
-
-      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
-      const options: CheckpointListOptions = { limit: 10 };
-
-      const results: CheckpointTuple[] = [];
-      for await (const tuple of checkpointSaver.list(config, options)) {
-        results.push(tuple);
-      }
-
-      // Verify the awaitEmit was called correctly
-      expect(awaitEmitStub.calledOnce).to.equal(true);
-      expect(awaitEmitStub.firstCall.args[0]).to.equal(MindedConnectionSocketMessageType.CHECKPOINT_LIST);
-      expect(awaitEmitStub.firstCall.args[1]).to.deep.equal({
-        type: MindedConnectionSocketMessageType.CHECKPOINT_LIST,
-        config,
-        options,
-      });
-
-      // Verify we got the correct number of results
-      expect(results).to.have.length(2);
-
-      // Verify first checkpoint - JSON objects should be restored to proper classes
-      const result1 = results[0];
-      expect(result1.checkpoint.id).to.equal('checkpoint-1');
-      expect(result1.metadata?.source).to.equal('input');
-      const messages1 = result1.checkpoint.channel_values.messages as any[];
-      expect(messages1).to.have.length(1);
-      expect(messages1[0]).to.be.instanceOf(HumanMessage);
-      expect(messages1[0].content).to.equal('First message');
-
-      // Verify second checkpoint - JSON objects should be restored to proper classes
-      const result2 = results[1];
-      expect(result2.checkpoint.id).to.equal('checkpoint-2');
-      expect(result2.metadata?.source).to.equal('loop');
-      expect(result2.parentConfig).to.deep.equal({ configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } });
-      const messages2 = result2.checkpoint.channel_values.messages as any[];
-      expect(messages2).to.have.length(2);
-      expect(messages2[0]).to.be.instanceOf(SystemMessage);
-      expect(messages2[1]).to.be.instanceOf(AIMessage);
-      expect(messages2[0].content).to.equal('System prompt');
-      expect(messages2[1].content).to.equal('AI response');
-    });
-
-    it('should handle empty checkpoint list', async () => {
-      awaitEmitStub.resolves({ checkpoints: [] });
-
-      const config: RunnableConfig = { configurable: { thread_id: 'empty-thread' } };
-
-      const results: CheckpointTuple[] = [];
-      for await (const tuple of checkpointSaver.list(config)) {
-        results.push(tuple);
-      }
-
-      expect(results).to.have.length(0);
-    });
-  });
-});

package/test/checkpoint-saver/minded-checkpoint-saver.test.ts

@@ -1,100 +0,0 @@
-import { expect } from 'chai';
-import { describe, it, beforeEach, afterEach } from 'mocha';
-import * as sinon from 'sinon';
-import { MindedCheckpointSaver } from '../../src/platform/mindedCheckpointSaver';
-import { Checkpoint, CheckpointMetadata, emptyCheckpoint } from '@langchain/langgraph-checkpoint';
-import { RunnableConfig } from '@langchain/core/runnables';
-import { HumanMessage, AIMessage } from '@langchain/core/messages';
-import { MindedConnection } from '../../src/platform/mindedConnection';
-import { MindedConnectionSocketMessageType } from '../../src/platform/mindedConnectionTypes';
-
-describe('MindedCheckpointSaver', function () {
-  let checkpointSaver: MindedCheckpointSaver;
-  let mindedConnection: MindedConnection;
-  let awaitEmitStub: sinon.SinonStub;
-
-  beforeEach(() => {
-    mindedConnection = new MindedConnection();
-    checkpointSaver = new MindedCheckpointSaver(mindedConnection);
-    awaitEmitStub = sinon.stub(mindedConnection, 'awaitEmit');
-  });
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  describe('getTuple', () => {
-    it('should deserialize checkpoint and metadata correctly', async () => {
-      // First, let's create proper objects and see what the serializer produces
-      const originalHumanMessage = new HumanMessage('Hello');
-      const originalAIMessage = new AIMessage('Hi there!');
-
-      // Create a checkpoint with these messages
-      const originalCheckpoint: Checkpoint = {
-        ...emptyCheckpoint(),
-        id: 'test-checkpoint-id',
-        channel_values: {
-          messages: [originalHumanMessage, originalAIMessage],
-        },
-      };
-
-      const originalMetadata: CheckpointMetadata = {
-        source: 'input',
-        step: 1,
-        writes: {},
-        parents: {},
-      };
-
-      // Simulate what happens when these objects go through JSON serialization (HTTP transport)
-      // This is what the server would actually return - plain JSON objects without class info
-      const jsonSerializedCheckpoint = JSON.parse(JSON.stringify(originalCheckpoint));
-      const jsonSerializedMetadata = JSON.parse(JSON.stringify(originalMetadata));
-
-      const mockServerResponse = {
-        tuple: {
-          config: { configurable: { thread_id: 'test-thread' } },
-          checkpoint: jsonSerializedCheckpoint,
-          metadata: jsonSerializedMetadata,
-          parentConfig: undefined,
-          pendingWrites: [],
-        },
-      };
-
-      // Mock the awaitEmit response
-      awaitEmitStub.resolves(mockServerResponse);
-
-      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
-      const result = await checkpointSaver.getTuple(config);
-
-      // Verify the awaitEmit was called correctly
-      expect(awaitEmitStub.calledOnce).to.equal(true);
-      expect(awaitEmitStub.firstCall.args[0]).to.equal(MindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE);
-      expect(awaitEmitStub.firstCall.args[1]).to.deep.equal({
-        type: MindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE,
-        config,
-      });
-
-      // Verify the result structure
-      expect(result).to.not.equal(undefined);
-      expect(result!.config).to.deep.equal(mockServerResponse.tuple.config);
-      expect(result!.checkpoint.id).to.equal('test-checkpoint-id');
-
-      // This is the key test - the JSON objects should be restored to proper classes
-      const messages = result!.checkpoint.channel_values.messages as any[];
-      expect(messages).to.have.length(2);
-      expect(messages[0]).to.be.instanceOf(HumanMessage);
-      expect(messages[1]).to.be.instanceOf(AIMessage);
-      expect(messages[0].content).to.equal('Hello');
-      expect(messages[1].content).to.equal('Hi there!');
-    });
-
-    it('should return undefined when server returns no tuple', async () => {
-      awaitEmitStub.resolves({ tuple: undefined });
-
-      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
-      const result = await checkpointSaver.getTuple(config);
-
-      expect(result).to.equal(undefined);
-    });
-  });
-});