@minded-ai/mindedjs 1.0.19

package/src/nodes/nodeFactory.ts

@@ -0,0 +1,65 @@
+import { RunnableLike } from '@langchain/core/runnables';
+import { AppToolNode, JunctionNode, Node, NodeType } from '../types/Flows.types';
+import { PreCompiledGraph } from '../types/LangGraph.types';
+import { Tool } from '../types/Tools.types';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { addTriggerNode } from './addTriggerNode';
+import { addToolNode } from './addToolNode';
+import { addPromptNode } from './addPromptNode';
+import { AgentEventRequestPayloads } from '../events/AgentEvents';
+import { EmitSignature } from '../types/Agent.types';
+
+const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
+  const callback: RunnableLike = async () => {};
+  graph.addNode(node.name, callback);
+};
+
+const addAppToolNode = ({
+  graph,
+  node,
+}: {
+  graph: PreCompiledGraph;
+  node: AppToolNode;
+  tools: Tool<any, any>[];
+  llm: BaseLanguageModel;
+}) => {
+  const callback: RunnableLike = async () => {
+    throw new Error('Not implemented');
+  };
+  graph.addNode(node.name, callback);
+};
+
+export const nodeFactory = ({
+  graph,
+  node,
+  tools,
+  llm,
+  emit,
+}: {
+  graph: PreCompiledGraph;
+  node: Node;
+  tools: Tool<any, any>[];
+  llm: BaseLanguageModel;
+  emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
+}) => {
+  const nodeType = node.type;
+  switch (nodeType) {
+    case NodeType.TRIGGER:
+      addTriggerNode({ graph, node });
+      break;
+    case NodeType.TOOL:
+      addToolNode({ graph, node, tools, llm });
+      break;
+    case NodeType.JUNCTION:
+      addJunctionNode({ graph, node });
+      break;
+    case NodeType.APP_TOOL:
+      addAppToolNode({ graph, node, tools, llm });
+      break;
+    case NodeType.PROMPT_NODE:
+      addPromptNode({ graph, node, tools, llm, emit });
+      break;
+    default:
+      throw new Error(`Unsupported node type: ${nodeType}`);
+  }
+};

package/src/platform/analytics.ts

@@ -0,0 +1,16 @@
+import { mindedRequest } from './mindedRequest';
+
+const track = async <T>({ event, data, token, sessionId }: { event: string; data: T; token: string; sessionId: string }) => {
+  await mindedRequest({
+    path: '/analytics/events',
+    method: 'POST',
+    body: { event, data, sessionId },
+    token,
+  });
+};
+
+export const analyticsFactory = ({ token, sessionId }: { token: string; sessionId: string }) => {
+  return {
+    track: <T>(event: string, data: T) => track<T>({ event, data, token, sessionId }),
+  };
+};

package/src/platform/mindedCheckpointSaver.ts

@@ -0,0 +1,74 @@
+import {
+  BaseCheckpointSaver,
+  CheckpointTuple,
+  Checkpoint,
+  CheckpointMetadata,
+  ChannelVersions,
+  PendingWrite,
+  CheckpointListOptions,
+} from '@langchain/langgraph-checkpoint';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import { mindedRequest } from './mindedRequest';
+
+export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
+  constructor(private token: string) {
+    super();
+  }
+
+  async getTuple(config: RunnableConfig<Record<string, any>>): Promise<CheckpointTuple | undefined> {
+    return await mindedRequest<CheckpointTuple | undefined, { config: RunnableConfig<Record<string, any>> }>({
+      path: '/checkpoint/get',
+      method: 'POST',
+      body: { config },
+      token: this.token,
+    });
+  }
+
+  async *list(config: RunnableConfig<Record<string, any>>, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple, any, any> {
+    const tuples = await mindedRequest<CheckpointTuple[], { config: RunnableConfig<Record<string, any>>; options?: CheckpointListOptions }>(
+      {
+        path: '/checkpoint/list',
+        method: 'POST',
+        body: { config, options },
+        token: this.token,
+      },
+    );
+
+    for (const tuple of tuples) {
+      yield tuple;
+    }
+  }
+
+  async put(
+    config: RunnableConfig<Record<string, any>>,
+    checkpoint: Checkpoint<string, string>,
+    metadata: CheckpointMetadata,
+    newVersions: ChannelVersions,
+  ): Promise<RunnableConfig<Record<string, any>>> {
+    const newConfig = await mindedRequest<
+      RunnableConfig<Record<string, any>>,
+      {
+        config: RunnableConfig<Record<string, any>>;
+        checkpoint: Checkpoint<string, string>;
+        metadata: CheckpointMetadata;
+        newVersions: ChannelVersions;
+      }
+    >({
+      path: '/checkpoint/put',
+      method: 'POST',
+      body: { config, checkpoint, metadata, newVersions },
+      token: this.token,
+    });
+
+    return newConfig;
+  }
+
+  async putWrites(config: RunnableConfig<Record<string, any>>, writes: PendingWrite[], taskId: string): Promise<void> {
+    await mindedRequest<void, { config: RunnableConfig<Record<string, any>>; writes: PendingWrite[]; taskId: string }>({
+      path: '/checkpoint/put-writes',
+      method: 'POST',
+      body: { config, writes, taskId },
+      token: this.token,
+    });
+  }
+}

package/src/platform/mindedConnection.ts

@@ -0,0 +1,106 @@
+import { io, Socket } from 'socket.io-client';
+import * as readline from 'readline';
+import { BaseMindedConnectionSocketMessage, MindedConnectionSocketMessageType } from './mindedConnectionTypes';
+
+export class MindedConnection {
+  private socket: Socket | null = null;
+  private rl: readline.Interface | null = null;
+  listeners: {
+    [key: string]: ((message: BaseMindedConnectionSocketMessage) => void)[]
+  } = {};
+
+  constructor() {
+    if (!process.env.MINDED_CONNECTION_TOKEN) {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+    }
+  }
+
+  private async getMindedToken(): Promise<string> {
+    const envToken = process.env.MINDED_CONNECTION_TOKEN;
+
+    if (envToken) {
+      return envToken;
+    }
+
+    return new Promise((resolve) => {
+      this.rl!.question('Enter your Minded connection token: ', (token: string) => {
+        resolve(token);
+      });
+    });
+  }
+
+  public on = (
+    event: MindedConnectionSocketMessageType,
+    callback: (message: BaseMindedConnectionSocketMessage) => void,
+  ) => {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+  };
+
+
+  public emit = (
+    event: MindedConnectionSocketMessageType,
+    message: BaseMindedConnectionSocketMessage,
+  ) => {
+    if (this.socket) {
+      this.socket.emit(event, message);
+    }
+  };
+
+
+  public start(): void {
+    this.getMindedToken().then(token => {
+      this.socket = io('http://localhost:8888', {
+        path: '/minded-connect',
+        query: {
+          token
+        }
+      });
+
+      // Connection event handlers
+      this.socket.on('connect', () => {
+        console.log('\x1b[32mConnection with Minded platform is live!\x1b[0m');
+        console.log('\x1b[36mPress Ctrl+C to exit.\x1b[0m');
+      });
+
+      this.socket.on('connect_error', () => {
+        console.error('Failed to connect to minded platform');
+      });
+
+      this.socket.on('disconnect', () => {
+        console.log('Disconnected from local debugging socket');
+
+      });
+
+      // Listen for error messages from the server
+      this.socket.on('error', (error: { message: string }) => {
+        console.error('Server error:', error.message);
+      });
+
+      // Listen for specific message types
+      this.socket.onAny((event, message) => {
+        if (this.listeners[event]) {
+          this.listeners[event].forEach((listener) => {
+            listener(message);
+          });
+        }
+      });
+
+      // Handle process termination
+      process.on('SIGINT', () => {
+        if (this.socket?.connected) {
+          console.log('\nDisconnecting...');
+          this.socket.disconnect();
+        }
+        process.exit(0);
+      });
+
+    });
+
+  }
+}

package/src/platform/mindedConnectionTypes.ts

@@ -0,0 +1,15 @@
+
+export enum MindedConnectionSocketMessageType {    
+  OnAppTrigger = 'on-app-trigger',
+}
+
+export interface BaseMindedConnectionSocketMessage {
+  type: MindedConnectionSocketMessageType;
+}
+
+export interface OnAppTrigger extends BaseMindedConnectionSocketMessage {  
+  name: string;
+  body: Record<string, any>;
+}
+
+

package/src/platform/mindedRequest.ts

@@ -0,0 +1,28 @@
+import axios from 'axios';
+const baseUrl = 'https://api.minded.com/sdk';
+
+type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+export const mindedRequest = async <Response, Request = object>({
+  path,
+  method,
+  body,
+  token,
+}: {
+  path: string;
+  method: Method;
+  body: Request;
+  token: string;
+}): Promise<Response> => {
+  const response = await axios({
+    method,
+    url: `${baseUrl}${path}`,
+    data: body,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  return response.data;
+};

package/src/types/Agent.types.ts

@@ -0,0 +1,10 @@
+import { AgentEventRequestPayloads, AgentEventResponsePayloads } from "../events/AgentEvents";
+import { LLMConfig } from "./LLM.types";
+
+export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (event: E, payload: AgentEventRequestPayloads<Memory>[E]) => Promise<(AgentEventResponsePayloads<Memory>[E])[]>;
+
+export type MindedSDKConfig = {
+  flows: string[];
+  llm: LLMConfig;
+  tools: string[];
+}

package/src/types/Flows.types.ts

@@ -0,0 +1,103 @@
+import { LLMConfig } from './LLM.types';
+export interface Position {
+  x: number;
+  y: number;
+}
+
+export enum NodeType {
+  TRIGGER = 'trigger',
+  JUNCTION = 'junction',
+  TOOL = 'tool',
+  APP_TOOL = 'appTool',
+  PROMPT_NODE = 'promptNode',
+}
+
+export enum EdgeType {
+  LOGICAL_CONDITION = 'logicalCondition',
+  PROMPT_CONDITION = 'promptCondition',
+  STEP_FORWARD = 'stepForward',
+}
+
+export interface BaseNode {
+  name: string;
+  type: NodeType;
+  position?: Position;
+  humanInTheLoop?: boolean;
+  canStayOnNode?: boolean;
+}
+
+export enum TriggerType {
+  APP = 'app',
+  WEBHOOK = 'webhook',
+  MANUAL = 'manual',
+}
+
+export interface BaseTriggerNode extends BaseNode {
+  type: NodeType.TRIGGER;
+}
+
+export interface AppTriggerNode extends BaseTriggerNode {
+  triggerType: TriggerType.APP;
+  appTriggerId: string;
+}
+
+export interface WebhookTriggerNode extends BaseTriggerNode {
+  triggerType: TriggerType.WEBHOOK;
+}
+
+export interface ManualTriggerNode extends BaseTriggerNode {
+  triggerType: TriggerType.MANUAL;
+}
+
+export interface PromptNode extends BaseNode {
+  type: NodeType.PROMPT_NODE;
+  prompt: string;
+  llmConfig?: LLMConfig;
+}
+
+export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode;
+
+export interface JunctionNode extends BaseNode {
+  type: NodeType.JUNCTION;
+}
+
+export interface ToolNode extends BaseNode {
+  type: NodeType.TOOL;
+  toolName: string;
+  prompt: string;
+}
+
+export interface AppToolNode extends BaseNode {
+  type: NodeType.APP_TOOL;
+  prompt: string;
+}
+
+export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode;
+
+export interface BaseEdge {
+  source: string;
+  target: string;
+  type: EdgeType;
+}
+
+export interface LogicalConditionEdge extends BaseEdge {
+  type: EdgeType.LOGICAL_CONDITION;
+  condition: string;
+}
+
+export interface PromptConditionEdge extends BaseEdge {
+  type: EdgeType.PROMPT_CONDITION;
+  prompt: string;
+}
+
+export interface StepForwardEdge extends BaseEdge {
+  type: EdgeType.STEP_FORWARD;
+}
+
+export type Edge = LogicalConditionEdge | PromptConditionEdge | StepForwardEdge;
+
+export interface Flow {
+  name: string;
+  nodes: Node[];
+  edges: Edge[];
+}

package/src/types/LLM.types.ts

@@ -0,0 +1,13 @@
+import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
+
+export type LLMConfig = {
+  name: string,
+  properties: Record<string, any>
+}
+
+export type LLMProvider = 'ChatOpenAI' | 'AzureChatOpenAI';
+
+export const LLMProviders = {
+  ChatOpenAI: ChatOpenAI,
+  AzureChatOpenAI: AzureChatOpenAI,
+}

package/src/types/LangGraph.types.ts

@@ -0,0 +1,25 @@
+import { BaseMessage } from '@langchain/core/messages';
+import { Annotation, CompiledStateGraph, StateGraph } from '@langchain/langgraph';
+
+export const stateAnnotation = Annotation.Root({
+  messages: Annotation<Array<BaseMessage>>({
+    default: () => [],
+    reducer: (a, b) => a.concat(b),
+  }),
+  memory: Annotation<any>({
+    default: () => ({}),
+    reducer: (a, b) => ({ ...a, ...b }),
+  }),
+
+  triggerMetadata: Annotation<{
+    name: string;
+    triggerBody: any;
+  } | null>,
+  interruptedNode: Annotation<string | null>({
+    default: () => null,
+    reducer: (a, b) => b,
+  }),
+});
+
+export type CompiledGraph = CompiledStateGraph<any, any, string>;
+export type PreCompiledGraph = StateGraph<any, any, string>;

package/src/types/Tools.types.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export interface Tool<Input extends z.ZodSchema, Memory> {
+  name: string;
+  description: string;
+  input: Input;
+  isGlobal?: boolean;
+  execute: ({ input, memory }: { input: z.infer<Input>; memory: Memory }) => Promise<{ memory?: Partial<Memory>, result?: any } | void>;
+}

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

@@ -0,0 +1,148 @@
+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,
+    });
+
+    // 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,
+    });
+
+    // 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,
+    });
+
+    // 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,
+    });
+
+    // 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,
+    });
+
+    // 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,
+    });
+
+    // 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

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