@minded-ai/mindedjs 1.0.19

package/src/agent.ts

@@ -0,0 +1,216 @@
+import { Flow, NodeType, Node } from './types/Flows.types';
+import { Tool } from './types/Tools.types';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { Command, StateGraph } from '@langchain/langgraph';
+import { MemorySaver, BaseCheckpointSaver } from '@langchain/langgraph';
+import { nodeFactory } from './nodes/nodeFactory';
+import { CompiledGraph, PreCompiledGraph, stateAnnotation } from './types/LangGraph.types';
+import { edgeFactory } from './edges/edgeFactory';
+import { AgentEventRequestPayloads, AgentEventResponsePayloads, AgentEvents } from './events/AgentEvents';
+import { z } from 'zod';
+
+import { MindedConnection } from './platform/mindedConnection';
+import { MindedConnectionSocketMessageType } from './platform/mindedConnectionTypes';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { MindedSDKConfig } from './types/Agent.types';
+import { createLlmInstance } from './llm/createLlmInstance';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+config({ path: resolve(__dirname, '../.env') });
+
+type CreateAgentParams<Memory> = {
+  memorySchema: z.ZodSchema;
+  config: MindedSDKConfig;
+  tools: Tool<any, Memory>[];
+  platformToken?: string;
+  memorySaver?: BaseCheckpointSaver;
+};
+export class Agent {
+  private memorySchema: z.ZodSchema;
+  private flows: Flow[];
+  private tools: Tool<any, any>[];
+  private platformToken?: string;
+  private llm: BaseLanguageModel;
+  private mindedConnection: MindedConnection | null = null;
+  // Langgraph memory saver. In memory for local development, Custom for Platform
+  private checkpointer: BaseCheckpointSaver;
+  // Langgraph compiled graph
+  private compiledGraph: CompiledGraph;
+
+  // Event handlers storage keyed by event name. Handlers can optionally return a value.
+  private eventHandlers: {
+    [K in keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>]?: Array<
+      (payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[K]) => any | Promise<any>
+    >;
+  } = {};
+
+  constructor(params: CreateAgentParams<z.infer<typeof this.memorySchema>>) {
+    const { config, tools, platformToken, memorySaver, memorySchema } = params;
+    this.memorySchema = memorySchema;
+    this.flows = this.loadFlowsFromDirectory(config.flows);
+    this.tools = tools;
+    this.platformToken = platformToken;
+    this.llm = createLlmInstance(config.llm);
+    this.checkpointer = memorySaver || new MemorySaver();
+    this.validate();
+    this.compiledGraph = this.initializeGraph();
+
+    if (process.env.NODE_ENV !== 'test' && process.env.NO_PLATFORM_CONNECT !== 'true') {
+      this.mindedConnection = new MindedConnection();
+      this.mindedConnection.start();
+      this.mindedConnection.on(MindedConnectionSocketMessageType.OnAppTrigger, (trigger) => {
+        console.log('Received trigger:', trigger);
+      });
+    }
+  }
+
+  private loadFlowsFromDirectory(flowsDirectories: string[]): Flow[] {
+    const flows: Flow[] = [];
+    for (const flowsDirectory of flowsDirectories) {
+      if (!fs.existsSync(flowsDirectory)) {
+        throw new Error(`Flows directory does not exist: ${flowsDirectory}`);
+      }
+
+      const files = fs.readdirSync(flowsDirectory);
+
+      for (const file of files) {
+        if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+          const filePath = path.join(flowsDirectory, file);
+          try {
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            const parsedFlow = yaml.load(fileContent) as Flow;
+
+            // Validate that the parsed flow has the required structure
+            if (!parsedFlow.name || !parsedFlow.nodes || !parsedFlow.edges) {
+              throw new Error(`Invalid flow structure in ${file}. Flow must have name, nodes, and edges.`);
+            }
+
+            flows.push(parsedFlow);
+          } catch (error) {
+            throw new Error(`Failed to parse flow file ${file}: ${error}`);
+          }
+        }
+      }
+
+      if (flows.length === 0) {
+        throw new Error(`No YAML flow files found in directory: ${flowsDirectory}`);
+      }
+    }
+
+    return flows;
+  }
+
+  private validate() {
+    if (this.flows.length === 0) {
+      throw new Error('No flows provided');
+    }
+  }
+
+  private initializeGraph(): CompiledGraph {
+    const nodes = this.flows.flatMap((flow) => flow.nodes);
+    const edges = this.flows.flatMap((flow) => flow.edges);
+
+    // Initialize the graph
+    const graph = new StateGraph(stateAnnotation).addNode('init', this.init.bind(this)).addEdge('__start__', 'init') as PreCompiledGraph;
+
+    // Add nodes and create nodes object
+    const nodesObject: { [key: string]: Node } = {};
+    nodes.forEach((node) => {
+      // Add to nodes object
+      nodesObject[node.name] = node;
+      // Add to graph
+      nodeFactory({
+        graph,
+        node,
+        tools: this.tools,
+        llm: this.llm,
+        emit: this.emit.bind(this),
+      });
+    });
+
+    // Add edges
+    edgeFactory({ graph, edges, nodes: nodesObject, llm: this.llm });
+    nodes.forEach((node) => {
+      if (node.type === NodeType.TRIGGER) {
+        graph.addEdge('__start__', node.name as any);
+      }
+    });
+
+    // Compile the graph
+    return graph.compile({ checkpointer: this.checkpointer }) as CompiledGraph;
+  }
+
+  private init(): typeof stateAnnotation.State {
+    return {
+      messages: [],
+      memory: {} as z.infer<typeof this.memorySchema>,
+      triggerMetadata: null,
+      interruptedNode: null,
+    };
+  }
+
+  public async invoke({ triggerBody, triggerName, sessionId }: { triggerBody: any; triggerName: string; sessionId?: string }) {
+    const session = sessionId || uuidv4();
+    const results = await this.emit(AgentEvents.TRIGGER_EVENT, {
+      triggerName,
+      triggerBody,
+    });
+    const handlerResult = results.find((r) => r !== undefined);
+    if (handlerResult === false) {
+      console.log(`Disqualified trigger ${triggerName}`);
+      throw new Error('Disqualified trigger');
+    }
+    const memoryUpdate = handlerResult?.memory || {};
+    const messages = handlerResult?.messages ?? [];
+    console.log(`Invoking trigger ${triggerName} with session ${session}`);
+    const config = { configurable: { thread_id: session, recursionLimit: 3 } };
+    const triggerNode = this.compiledGraph.builder.nodes[triggerName];
+    if (!triggerNode) {
+      throw new Error(`Trigger node not found: ${triggerName}`);
+    }
+    const state = await this.compiledGraph.getState(config);
+    // Resume interruption
+    if (state.tasks?.[0]?.interrupts?.length > 0) {
+      const res = await this.compiledGraph.invoke(
+        new Command({
+          resume: { memory: memoryUpdate, messages },
+        }),
+        config,
+      );
+      return res;
+    } else {
+      const res = await this.compiledGraph.invoke({ messages, memory: memoryUpdate }, config);
+      return res;
+    }
+  }
+
+  // Public API for registering event listeners
+  public on<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
+    event: E,
+    handler: (
+      payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[E],
+    ) => Promise<AgentEventResponsePayloads<z.infer<typeof this.memorySchema>>[E] | void>,
+  ): void {
+    if (!this.eventHandlers[event]) {
+      this.eventHandlers[event] = [];
+    }
+    // We can safely cast here since we ensured the array exists
+    (this.eventHandlers[event] as Array<typeof handler>).push(handler);
+  }
+
+  // Internal method to emit events to the registered listeners
+  private async emit<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
+    event: E,
+    payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[E],
+  ): Promise<AgentEventResponsePayloads<z.infer<typeof this.memorySchema>>[E][]> {
+    if (!this.eventHandlers[event]) {
+      return [];
+    }
+    const results = await Promise.all(this.eventHandlers[event]!.map(async (handler) => handler(payload)));
+    return results;
+  }
+}

package/src/edges/createDirectEdge.ts

@@ -0,0 +1,11 @@
+import { StepForwardEdge } from '../types/Flows.types';
+
+export const createDirectEdge = ({ edges }: { edges: StepForwardEdge[] }) => {
+  return async () => {
+    // For direct edges, we just return the target of the first edge
+    // since there's no conditional logic needed
+    const edge = edges[0];
+    console.log(`Executing edge ${JSON.stringify(edge)}`);
+    return edge.target;
+  };
+};

package/src/edges/createLogicalRouter.ts

@@ -0,0 +1,16 @@
+import { LogicalConditionEdge } from '../types/Flows.types';
+import { stateAnnotation } from '../types/LangGraph.types';
+
+export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }) => {
+  return async (state: typeof stateAnnotation.State) => {
+    console.log(`Executing logical router. Edges: ${JSON.stringify(edges)}`);
+    for (const edge of edges) {
+      const conditionFn = eval(edge.condition);
+      const result = await conditionFn({ memory: state.memory });
+      if (result) {
+        return edge.target;
+      }
+    }
+    return edges[0].source;
+  };
+};

package/src/edges/createPromptRouter.ts

@@ -0,0 +1,52 @@
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { z } from 'zod';
+import { PromptConditionEdge } from '../types/Flows.types';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { AIMessage } from '@langchain/core/messages';
+import { stateAnnotation } from '../types/LangGraph.types';
+
+export const createPromptRouter = ({ edges, llm }: { edges: PromptConditionEdge[]; llm: BaseLanguageModel }) => {
+  const agent = createReactAgent({
+    llm,
+    tools: [],
+    responseFormat: z.object({
+      nextNodeId: z.string(),
+      reasoning: z.string(),
+    }),
+  });
+  return async (state: typeof stateAnnotation.State) => {
+    console.log(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
+    const result = await agent.invoke({
+      messages: [
+        new AIMessage({
+          content: `You are a router that decides which node to take in a flow based on the current memory state, history and available node ids.
+
+Your task is to analyze the current memory state, history and available nodes and determine the most appropriate next node in the flow, the returned nodeId should be only the id without the prompt.
+
+
+Available nodes in the format of {nodeId}: {prompt}:
+${edges.map((edge) => `- ${edge.target}: ${edge.prompt}`).join('\n')}
+
+Current memory state:
+${JSON.stringify(state.memory)}
+
+Previous messages:
+${JSON.stringify(state.messages)}
+
+Based on the memory state and available nodes, determine the most appropriate next node id.
+      `,
+        }),
+      ],
+    });
+    try {
+      const nextNode = result.structuredResponse.nextNodeId;
+      console.log(`Next node: ${nextNode}`);
+      if (!nextNode) {
+        throw new Error('No next node id returned from router');
+      }
+      return nextNode;
+    } catch (e: any) {
+      throw new Error(`Failed to parse router response: ${result.structuredResponse}; Error: ${e.message}`);
+    }
+  };
+};

package/src/edges/edgeFactory.ts

@@ -0,0 +1,85 @@
+import { Edge, EdgeType, Node, PromptConditionEdge, LogicalConditionEdge, StepForwardEdge } from '../types/Flows.types';
+import { PreCompiledGraph } from '../types/LangGraph.types';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { createPromptRouter } from './createPromptRouter';
+import { createLogicalRouter } from './createLogicalRouter';
+import { createDirectEdge } from './createDirectEdge';
+import { addHumanInTheLoopNode, buildHumanInTheLoopNodeName } from '../nodes/addHumanInTheLoopNode';
+
+type EdgeProcessor<T extends Edge> = {
+  edges: T[];
+  router: (params: { edges: T[]; llm: BaseLanguageModel }) => any;
+};
+
+export const edgeFactory = ({
+  graph,
+  edges,
+  nodes,
+  llm,
+}: {
+  graph: PreCompiledGraph;
+  edges: Edge[];
+  nodes: Record<string, Node>;
+  llm: BaseLanguageModel;
+}) => {
+  /**
+   * Processes edges with enhanced node capabilities (humanInTheLoop, canStayOnNode)
+   * This elegant abstraction handles both prompt and logical edges uniformly
+   */
+  const processEdges = <T extends Edge>(edgeProcessor: EdgeProcessor<T>): void => {
+    const { edges: filteredEdges, router } = edgeProcessor;
+    const uniqueSources = [...new Set(filteredEdges.map((edge) => edge.source))];
+
+    uniqueSources.forEach((source) => {
+      const edgesForSource: T[] = [...filteredEdges.filter((edge) => edge.source === source)];
+      let effectiveSource = source;
+
+      // Handle human-in-the-loop enhancement
+      if (nodes[source]?.humanInTheLoop) {
+        addHumanInTheLoopNode({ graph, attachedToNodeName: source });
+        effectiveSource = buildHumanInTheLoopNodeName(source);
+      }
+
+      // Handle stay-on-node capability
+      if (nodes[source]?.canStayOnNode) {
+        const stayEdge = {
+          source,
+          target: source,
+          type: EdgeType.PROMPT_CONDITION,
+          prompt: 'stay at current node if still relevant',
+        } as T;
+
+        edgesForSource.push(stayEdge);
+      }
+
+      graph.addConditionalEdges(effectiveSource as any, router({ edges: edgesForSource, llm }));
+    });
+  };
+
+  // Direct edges - simple and straightforward
+  const directEdges = edges.filter((edge) => edge.type === EdgeType.STEP_FORWARD) as StepForwardEdge[];
+  if (directEdges.length > 0) {
+    processEdges({
+      edges: directEdges,
+      router: createDirectEdge,
+    });
+  }
+
+  // Prompt condition edges - enhanced with AI-driven routing
+  const promptEdges = edges.filter((edge) => edge.type === EdgeType.PROMPT_CONDITION) as PromptConditionEdge[];
+  if (promptEdges.length > 0) {
+    processEdges({
+      edges: promptEdges,
+      router: createPromptRouter,
+    });
+  }
+
+  // Logical condition edges - enhanced with programmatic routing
+  const logicalEdges = edges.filter((edge) => edge.type === EdgeType.LOGICAL_CONDITION) as LogicalConditionEdge[];
+  if (logicalEdges.length > 0) {
+    processEdges({
+      edges: logicalEdges,
+      router: createLogicalRouter,
+    });
+  }
+};

package/src/events/AgentEvents.ts

@@ -0,0 +1,22 @@
+import { BaseMessage } from '@langchain/core/messages';
+
+export enum AgentEvents {
+  AI_MESSAGE = 'AI_MESSAGE',
+  TRIGGER_EVENT = 'TRIGGER_EVENT',
+}
+
+export type AgentEventRequestPayloads<Memory> = {
+  [AgentEvents.AI_MESSAGE]: {
+    message: string;
+    memory: Memory;
+  };
+  [AgentEvents.TRIGGER_EVENT]: {
+    triggerName: string;
+    triggerBody: any;
+  };
+};
+
+export type AgentEventResponsePayloads<Memory> = {
+  [AgentEvents.AI_MESSAGE]: void;
+  [AgentEvents.TRIGGER_EVENT]: { messages?: BaseMessage[]; memory?: Memory } | false;
+};

package/src/events/index.ts

@@ -0,0 +1,3 @@
+import { AgentEvents } from './AgentEvents';
+
+export default AgentEvents;

package/src/index.ts

@@ -0,0 +1,22 @@
+import { Agent } from './agent';
+import events from './events';
+
+export { Agent, events };
+
+export type {
+  Flow,
+  Node,
+  Edge,
+  TriggerNode,
+  AppTriggerNode,
+  PromptNode,
+  PromptConditionEdge,
+  LogicalConditionEdge,
+  StepForwardEdge,
+  ManualTriggerNode,
+  JunctionNode,
+  ToolNode,
+  AppToolNode,
+} from './types/Flows.types';
+export { NodeType, TriggerType, EdgeType } from './types/Flows.types';
+export type { Tool } from './types/Tools.types';

package/src/llm/createLlmInstance.ts

@@ -0,0 +1,10 @@
+import { LLMConfig, LLMProviders, LLMProvider } from "../types/LLM.types";
+
+export const createLlmInstance = (llmConfig: LLMConfig) => {
+  const { name, properties } = llmConfig;
+  const LLMClass = LLMProviders[name as LLMProvider];
+  if (!LLMClass) {
+    throw new Error(`Unsupported LLM provider: ${name}`);
+  }
+  return new LLMClass(properties);
+};

package/src/nodes/addHumanInTheLoopNode.ts

@@ -0,0 +1,20 @@
+import { interrupt } from '@langchain/langgraph';
+import { PreCompiledGraph } from '../types/LangGraph.types';
+import { RunnableLike } from '@langchain/core/runnables';
+
+type AddHumanInTheLoopNodeParams = {
+  graph: PreCompiledGraph;
+  attachedToNodeName: string;
+};
+
+export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}_humanInTheLoop`;
+
+export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
+  const callback: RunnableLike = async () => {
+    console.log(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
+    const value = interrupt('input from human in the loop');
+    return value;
+  };
+  graph.addNode(`${attachedToNodeName}_humanInTheLoop`, callback);
+  graph.addEdge(attachedToNodeName as any, buildHumanInTheLoopNodeName(attachedToNodeName) as any);
+};

package/src/nodes/addPromptNode.ts

@@ -0,0 +1,66 @@
+import { RunnableLike } from '@langchain/core/runnables';
+import { PromptNode } from '../types/Flows.types';
+import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
+import { z } from 'zod';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { SystemMessage } from '@langchain/core/messages';
+import { Tool } from '../types/Tools.types';
+import { tool as langchainTool } from '@langchain/core/tools';
+import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
+import { EmitSignature } from '../types/Agent.types';
+import { createLlmInstance } from '../llm/createLlmInstance';
+
+type AddPromptNodeParams = {
+  graph: PreCompiledGraph;
+  node: PromptNode;
+  llm: BaseLanguageModel;
+  tools: Tool<any, any>[];
+  emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
+};
+
+export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPromptNodeParams) => {
+  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    console.log(`Executing prompt node ${node.name}`);
+    const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
+
+    const globalTools = tools
+      .filter((tool) => tool.isGlobal)
+      .map((tool) =>
+        langchainTool((input: z.infer<typeof tool.input>) => tool.execute({ input, memory: state.memory }), {
+          name: tool.name,
+          description: tool.description,
+          schema: tool.input,
+        }),
+      );
+
+    const agent = createReactAgent({
+      llm: llmToUse,
+      tools: globalTools,
+      responseFormat: z.object({
+        waitForUserResponse: z.boolean(),
+        done: z.boolean(),
+      }),
+    });
+    const message = `
+    - This is a node in a workflow.
+    - User instructions: ${node.prompt}
+    - Workflow memory: ${JSON.stringify(state.memory)}
+    - Conversation history: ${state.messages.map((message) => `${message.getType()}: ${message.content}`).join('\n')}
+    `;
+    const result = await agent.invoke({
+      messages: [new SystemMessage(message)],
+    });
+    const lastMessage = result.messages[result.messages.length - 1];
+    if (lastMessage.getType() === 'ai') {
+      await emit(AgentEvents.AI_MESSAGE, {
+        message: lastMessage.content as string,
+        memory: state.memory,
+      });
+    }
+    return {
+      messages: [lastMessage],
+    };
+  };
+  graph.addNode(node.name, callback);
+};

package/src/nodes/addToolNode.ts

@@ -0,0 +1,95 @@
+import { BaseLanguageModel } from "@langchain/core/language_models/base";
+import { ToolNode } from "../types/Flows.types";
+import { Tool } from "../types/Tools.types";
+import { tool as langchainTool } from "@langchain/core/tools";
+import { PreCompiledGraph, stateAnnotation } from "../types/LangGraph.types";
+import { AIMessage, BaseMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { RunnableLike } from "@langchain/core/runnables";
+import { z } from "zod";
+
+export const addToolNode = async <Memory>({
+  graph,
+  node,
+  tools,
+  llm,
+}: {
+  graph: PreCompiledGraph;
+  node: ToolNode;
+  tools: Tool<any, any>[];
+  llm: BaseLanguageModel;
+}) => {
+  const toolNode = node as ToolNode;
+  const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
+  if (!matchedTool) {
+    throw new Error(`Tool not found: ${toolNode.toolName}`);
+  }
+  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    try {
+      console.log(`Executing tool node ${toolNode.name}`);
+
+      const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
+        try {
+          const response = await matchedTool.execute({ input, memory: state.memory });
+          return response || {};
+        } catch (error) {
+          console.error('Error executing tool', error);
+          throw error;
+        }
+      };
+      const tool = langchainTool(executeWrapper, {
+        name: matchedTool.name,
+        description: matchedTool.description,
+        schema: matchedTool.input,
+      });
+      const prompt = `
+      Context:
+        messages: ${JSON.stringify(state.messages)}
+        workflow memory: ${JSON.stringify(state.memory)}
+      Instructions:
+        Call immediately tool ${tool.name}(...)
+        ${toolNode.prompt && `Tool execution instructions: ${toolNode.prompt}`}
+      `;
+      const toolCallingAgent = createReactAgent({
+        llm,
+        tools: [tool],
+      });
+      const response = await toolCallingAgent.invoke({ messages: [new SystemMessage(prompt)] });
+      const toolCallMessage = getLastToolCallMessage(response.messages);
+      const toolResponseMessage = getLastToolMessage(response.messages);
+      if (!toolCallMessage || !toolResponseMessage) {
+        throw new Error('Tool call or tool response message not found');
+      }
+      const toolMemory = extractToolMemoryResponse<Memory>(toolResponseMessage);
+      return { memory: toolMemory, messages: [toolCallMessage, toolResponseMessage] };
+    } catch (error) {
+      console.error('Error executing tool node', error);
+      throw error;
+    }
+  };
+  graph.addNode(node.name, callback);
+};
+
+const getLastToolCallMessage = (messages: BaseMessage[]): BaseMessage => {
+  const toolCallMessages = messages.filter((message) => (message as AIMessage).tool_calls?.length || 0 > 0);
+  const lastToolCallMessage = toolCallMessages[toolCallMessages.length - 1];
+  return lastToolCallMessage;
+};
+
+const getLastToolMessage = (messages: BaseMessage[]): ToolMessage => {
+  const toolMessages = messages.filter((message) => message.getType() === 'tool');
+  const lastToolMessage = toolMessages[toolMessages.length - 1];
+  return lastToolMessage as ToolMessage;
+};
+
+const extractToolMemoryResponse = <Memory>(toolMessage: ToolMessage): Partial<Memory> => {
+  try {
+    const parsed = JSON.parse(toolMessage.content as string);
+    if (typeof parsed === 'object' && parsed !== null && 'memory' in parsed) {
+      return parsed.memory;
+    }
+  } catch (error) {
+    console.error('Error parsing tool memory response', error);
+  }
+  return {};
+};

package/src/nodes/addTriggerNode.ts

@@ -0,0 +1,12 @@
+import { RunnableLike } from '@langchain/core/runnables';
+import { TriggerNode } from '../types/Flows.types';
+import { PreCompiledGraph } from '../types/LangGraph.types';
+
+export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
+  const callback: RunnableLike = async () => {
+    console.log(`Executing trigger node ${node.name}`);
+    return;
+  };
+
+  graph.addNode(node.name, callback);
+};