@minded-ai/mindedjs 1.0.91 → 1.0.92-beta-3

package/src/edges/createLogicalRouter.ts

@@ -11,8 +11,8 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
     logger.debug(`Evaluating logical conditions for ${edges.length} edges`);
 
     // Separate regular conditions from "else" conditions
-    const regularEdges = edges.filter(edge => edge.condition.trim() !== 'else');
-    const elseEdges = edges.filter(edge => edge.condition.trim() === 'else');
+    const regularEdges = edges.filter((edge) => edge.condition.trim() !== 'else');
+    const elseEdges = edges.filter((edge) => edge.condition.trim() === 'else');
 
     // First, evaluate all regular conditions
     for (const edge of regularEdges) {
@@ -59,17 +59,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
+          logger.info({ message: `Condition matched for edge ${edge.source} → ${edge.target}` });
           return edge.target;
         }
-
       } catch (error) {
         // Provide detailed error information back to the customer
         const errorMessage = error instanceof Error ? error.message : String(error);
         const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
 
         logger.error({
-          msg: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
+          message: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -84,15 +83,15 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // If no regular conditions matched, check for "else" conditions
     if (elseEdges.length > 0) {
-      logger.info(`No regular conditions matched, evaluating ${elseEdges.length} else condition(s)`);
+      logger.info({ message: `No regular conditions matched, evaluating ${elseEdges.length} else condition(s)` });
       // Return the first "else" condition's target
       const elseEdge = elseEdges[0];
-      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
+      logger.info({ message: `Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`, edge: elseEdge });
       return elseEdge.target;
     }
 
     // If no conditions matched or all failed, return to the source node
-    logger.info('No conditions matched');
+    logger.info({ message: 'No conditions matched' });
     return null;
   };
 };

package/src/edges/createPromptRouter.ts

@@ -70,11 +70,11 @@ export const createPromptRouter = ({
   currentNodeName?: string;
 }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
+    logger.info({ message: `Executing prompt router. Edges: ${JSON.stringify(edges)}` });
 
     // If canStayInCurrentNode is true and there are no edges, return current node immediately
     if (canStayInCurrentNode && edges.length === 0 && currentNodeName) {
-      logger.info(`No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}`);
+      logger.info({ message: `No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}` });
       return currentNodeName;
     }
 
@@ -174,13 +174,14 @@ export const createPromptRouter = ({
 
         const decision = validatedResponse.nextNodeId === currentNodeName ? 'stay in current node' : validatedResponse.nextNodeId;
         const reasoning = includeReasoning && 'reasoning' in validatedResponse ? ` - Reasoning: ${validatedResponse.reasoning}` : '';
-        logger.info({ msg: `Router decision: ${decision}`, reasoning });
+        logger.info({ message: `Router decision: ${decision}`, reasoning });
 
         return validatedResponse.nextNodeId;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         logger.warn({
           message: `Prompt router attempt ${attempts} failed`,
+          edge: edges,
           error: lastError.message,
           attempt: attempts,
           maxRetries,

package/src/edges/edgeFactory.ts

@@ -49,7 +49,7 @@ export const edgeFactory = ({
         if (result) {
           return result;
         } else {
-          logger.debug('No logical conditions matched, continuing to prompt conditions');
+          logger.debug({ message: 'No logical conditions matched, continuing to prompt conditions' });
         }
       }
 
@@ -69,7 +69,7 @@ export const edgeFactory = ({
 
       // Fallback: stay at current source node
       const source = originalNode?.name || sourceNode;
-      logger.info(`No conditions matched, returning to source: ${source}`);
+      logger.info({ message: `No conditions matched, returning to source: ${source}` });
       return source;
     };
   };

package/src/index.ts

@@ -36,7 +36,6 @@ export {
 } from './types/Flows.types';
 export type { Tool, ToolExecuteInput } from './types/Tools.types';
 export {
-  HistoryStepType,
   HistoryStep,
   TriggerHistoryStep,
   AppActionInvocationHistoryStep,

package/src/interrupts/InterruptSessionManager.types.ts

@@ -0,0 +1,80 @@
+import { State } from '../types/LangGraph.types';
+import { GraphInterrupt } from '@langchain/langgraph';
+import { logger } from '../utils/logger';
+
+export enum InterruptType {
+  NEW_TRIGGERS = 'NEW_TRIGGERS',
+  HUMAN_IN_THE_LOOP = 'HUMAN_IN_THE_LOOP',
+}
+
+export interface QueuedMessage {
+  triggerBody: any;
+  triggerName: string;
+  appName?: string;
+}
+
+// export interface UpdateStateObject {
+//   memory: any;
+//   messages: any[];
+//   history: any[];
+//   sessionId: string;
+//   sessionType: SessionType;
+// }
+export interface InterruptPayload {
+  type: InterruptType.NEW_TRIGGERS;
+  updateStateObject?: Partial<State>;
+  id?: string;
+}
+
+export interface InterruptSessionManager {
+  isProcessed(sessionId: string): boolean | Promise<boolean>;
+  lock(sessionId: string): void | Promise<void>;
+  release(sessionId: string): void | Promise<void>;
+  enqueueMessage(sessionId: string, message: QueuedMessage): void | Promise<void>;
+  dequeueAll(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
+  dequeue(sessionId: string): QueuedMessage | null | Promise<QueuedMessage | null>;
+  checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean>;
+}
+
+export abstract class BaseInterruptSessionManager implements InterruptSessionManager {
+  // Abstract methods that subclasses must implement for queue management
+  abstract isProcessed(sessionId: string): boolean | Promise<boolean>;
+  abstract lock(sessionId: string): void | Promise<void>;
+  abstract release(sessionId: string): void | Promise<void>;
+  abstract enqueueMessage(sessionId: string, message: QueuedMessage): void | Promise<void>;
+  abstract dequeueAll(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
+  abstract dequeue(sessionId: string): QueuedMessage | null | Promise<QueuedMessage | null>;
+
+  // Abstract method to check if queue has messages - this is the only queue-specific part
+  protected abstract hasQueuedMessages(sessionId: string): boolean | Promise<boolean>;
+  protected abstract getQueuedMessages(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
+
+  // Common implementation of checkQueueAndInterrupt
+  async checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean> {
+    if (await this.hasQueuedMessages(sessionId)) {
+      const queue = await this.getQueuedMessages(sessionId);
+      logger.trace({ message: 'graph has queued messagess, interrupting graph', sessionId, queue });
+
+      // Interrupt the graph with NEW_TRIGGERS flag and optional updateStateObject
+      const interruptPayload: InterruptPayload = { type: InterruptType.NEW_TRIGGERS };
+      if (updateStateObject) {
+        interruptPayload.updateStateObject = {
+          messages: updateStateObject.messages,
+          memory: updateStateObject.memory,
+          history: updateStateObject.history,
+          sessionId: updateStateObject.sessionId,
+          sessionType: updateStateObject.sessionType,
+        };
+      }
+
+      throw new GraphInterrupt([
+        {
+          value: interruptPayload,
+          when: 'during',
+          resumable: true,
+        },
+      ]);
+    }
+    return false;
+  }
+}

package/src/interrupts/MemoryInterruptSessionManager.ts

@@ -0,0 +1,56 @@
+import { State } from '../types/LangGraph.types';
+import { logger } from '../utils/logger';
+import { BaseInterruptSessionManager, QueuedMessage, InterruptType, InterruptPayload } from './InterruptSessionManager.types';
+import { GraphInterrupt, interrupt } from '@langchain/langgraph';
+import { v4 as uuidv4 } from 'uuid';
+
+export class MemoryInterruptSessionManager extends BaseInterruptSessionManager {
+  private sessionProcessing: Map<string, boolean> = new Map();
+  private sessionMessageQueues: Map<string, QueuedMessage[]> = new Map();
+
+  isProcessed(sessionId: string): boolean {
+    return this.sessionProcessing.get(sessionId) || false;
+  }
+
+  lock(sessionId: string): void {
+    this.sessionProcessing.set(sessionId, true);
+  }
+
+  release(sessionId: string): void {
+    this.sessionProcessing.set(sessionId, false);
+  }
+
+  enqueueMessage(sessionId: string, message: QueuedMessage): void {
+    if (!this.sessionMessageQueues.has(sessionId)) {
+      this.sessionMessageQueues.set(sessionId, []);
+    }
+    this.sessionMessageQueues.get(sessionId)!.push(message);
+  }
+
+  dequeueAll(sessionId: string): QueuedMessage[] {
+    const messages = this.sessionMessageQueues.get(sessionId) || [];
+    const result = [...messages];
+    this.sessionMessageQueues.set(sessionId, []);
+    return result;
+  }
+
+  dequeue(sessionId: string): QueuedMessage | null {
+    const messages = this.sessionMessageQueues.get(sessionId) || [];
+    if (messages.length === 0) {
+      return null;
+    }
+    const firstMessage = messages.shift()!;
+    this.sessionMessageQueues.set(sessionId, messages);
+    return firstMessage;
+  }
+
+  // Implementation of abstract methods from BaseInterruptSessionManager
+  protected hasQueuedMessages(sessionId: string): boolean {
+    const queue = this.sessionMessageQueues.get(sessionId) || [];
+    return queue.length > 0;
+  }
+
+  protected getQueuedMessages(sessionId: string): QueuedMessage[] {
+    return this.sessionMessageQueues.get(sessionId) || [];
+  }
+}

package/src/interrupts/MindedInterruptSessionManager.ts

@@ -0,0 +1,157 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './InterruptSessionManager.types';
+import { MindedConnection } from '../platform/mindedConnection';
+import {
+  MindedConnectionSocketMessageType,
+  InterruptSessionIsProcessedRequest,
+  InterruptSessionIsProcessedResponse,
+  InterruptSessionLockRequest,
+  InterruptSessionLockResponse,
+  InterruptSessionReleaseRequest,
+  InterruptSessionReleaseResponse,
+  InterruptSessionEnqueueRequest,
+  InterruptSessionEnqueueResponse,
+  InterruptSessionDequeueAllRequest,
+  InterruptSessionDequeueAllResponse,
+  InterruptSessionDequeueRequest,
+  InterruptSessionDequeueResponse,
+  InterruptSessionHasMessagesRequest,
+  InterruptSessionHasMessagesResponse,
+  InterruptSessionGetMessagesRequest,
+  InterruptSessionGetMessagesResponse,
+} from '../platform/mindedConnectionTypes';
+
+export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
+  private mindedConnection: MindedConnection;
+
+  constructor(mindedConnection: MindedConnection) {
+    super();
+    this.mindedConnection = mindedConnection;
+  }
+
+  async isProcessed(sessionId: string): Promise<boolean> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionIsProcessedRequest, InterruptSessionIsProcessedResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED,
+          sessionId,
+        },
+      );
+      return response.isProcessed ?? false;
+    } catch (error) {
+      console.error('Error checking if session is processed:', error);
+      return false;
+    }
+  }
+
+  async lock(sessionId: string): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionLockRequest, InterruptSessionLockResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+          sessionId,
+        },
+      );
+    } catch (error) {
+      console.error('Error locking session:', error);
+      throw error;
+    }
+  }
+
+  async release(sessionId: string): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionReleaseRequest, InterruptSessionReleaseResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE,
+          sessionId,
+        },
+      );
+    } catch (error) {
+      console.error('Error releasing session:', error);
+      throw error;
+    }
+  }
+
+  async enqueueMessage(sessionId: string, message: QueuedMessage): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionEnqueueRequest, InterruptSessionEnqueueResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE,
+          sessionId,
+          message,
+        },
+      );
+    } catch (error) {
+      console.error('Error enqueuing message:', error);
+      throw error;
+    }
+  }
+
+  async dequeueAll(sessionId: string): Promise<QueuedMessage[]> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionDequeueAllRequest, InterruptSessionDequeueAllResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL,
+          sessionId,
+        },
+      );
+      return response.messages ?? [];
+    } catch (error) {
+      console.error('Error dequeuing all messages:', error);
+      return [];
+    }
+  }
+
+  async dequeue(sessionId: string): Promise<QueuedMessage | null> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionDequeueRequest, InterruptSessionDequeueResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE,
+          sessionId,
+        },
+      );
+      return response.message ?? null;
+    } catch (error) {
+      console.error('Error dequeuing message:', error);
+      return null;
+    }
+  }
+
+  // Implementation of abstract methods from BaseInterruptSessionManager
+  protected async hasQueuedMessages(sessionId: string): Promise<boolean> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionHasMessagesRequest, InterruptSessionHasMessagesResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES,
+          sessionId,
+        },
+      );
+      return response.hasMessages ?? false;
+    } catch (error) {
+      console.error('Error checking if session has messages:', error);
+      return false;
+    }
+  }
+
+  protected async getQueuedMessages(sessionId: string): Promise<QueuedMessage[]> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionGetMessagesRequest, InterruptSessionGetMessagesResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES,
+          sessionId,
+        },
+      );
+      return response.messages ?? [];
+    } catch (error) {
+      console.error('Error getting queued messages:', error);
+      return [];
+    }
+  }
+}

package/src/interrupts/interruptSessionManagerFactory.ts

@@ -0,0 +1,20 @@
+import { InterruptSessionManager } from './InterruptSessionManager.types';
+import { MemoryInterruptSessionManager } from './MemoryInterruptSessionManager';
+import { MindedInterruptSessionManager } from './MindedInterruptSessionManager';
+import { MindedConnection } from '../platform/mindedConnection';
+import { getConfig } from '../platform/config';
+import { logger } from '../utils/logger';
+
+export function createInterruptSessionManager(mindedConnection: MindedConnection | null): InterruptSessionManager {
+  const { runLocally } = getConfig();
+  if (runLocally) {
+    logger.info({ message: 'Using memory interrupt session manager' });
+    return new MemoryInterruptSessionManager();
+  } else {
+    if (!mindedConnection) {
+      throw new Error('MindedConnection is required for platform interrupt session manager');
+    }
+    logger.info({ message: 'Using Minded interrupt session manager' });
+    return new MindedInterruptSessionManager(mindedConnection);
+  }
+}

package/src/nodes/addAppToolNode.ts

@@ -1,4 +1,4 @@
-import { AppToolNode } from '../types/Flows.types';
+import { AppToolNode, NodeType } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { SystemMessage } from '@langchain/core/messages';
@@ -6,7 +6,7 @@ import { RunnableLike } from '@langchain/core/runnables';
 import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
 import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
-import { AppActionInvocationHistoryStep, HistoryStepType } from '../types/Agent.types';
+import { AppActionInvocationHistoryStep } from '../types/Agent.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
@@ -26,7 +26,7 @@ export const addAppToolNode = async ({
   const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
   const appRunnerTool = getAppActionRunnerTool(node.displayName!);
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${appRunnerTool.name}`);
+    logger.info({ message: `Executing tool node ${appRunnerTool.name}` });
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {
@@ -82,7 +82,7 @@ export const addAppToolNode = async ({
     return {
       messages: [AIToolCallMessage, toolCallMessage],
       history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
-        type: HistoryStepType.APP_ACTION_NODE,
+        type: NodeType.APP_TOOL,
         nodeId: node.name,
         nodeDisplayName: node.displayName!,
         raw: AIToolCallMessage.tool_calls[0],

package/src/nodes/addHumanInTheLoopNode.ts

@@ -3,6 +3,7 @@ import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { RunnableLike } from '@langchain/core/runnables';
 import { logger } from '../utils/logger';
 import { internalNodesSuffix } from '../types/Flows.types';
+import { InterruptType } from '../interrupts/InterruptSessionManager.types';
 
 type AddHumanInTheLoopNodeParams = {
   graph: PreCompiledGraph;
@@ -13,10 +14,10 @@ export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${i
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
+    logger.info({ message: `Executing "human in the loop" node for the attached node${attachedToNodeName}` });
 
     if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt('input from human in the loop');
+      const value = interrupt({ type: InterruptType.HUMAN_IN_THE_LOOP });
       return value;
     }
   };

package/src/nodes/addJumpToNode.ts

@@ -1,17 +1,17 @@
 import { RunnableLike } from '@langchain/core/runnables';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { JumpToNode } from '../types/Flows.types';
+import { JumpToNode, NodeType } from '../types/Flows.types';
 import { logger } from '../utils/logger';
-import { HistoryStepType, HistoryStep } from '../types/Agent.types';
+import { HistoryStep } from '../types/Agent.types';
 import { createHistoryStep } from '../utils/history';
 
 export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
+    logger.info({ message: `Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}` });
     // No state modifications are necessary; control flow is handled via edges.
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.JUMP_TO_NODE,
+        type: NodeType.JUMP_TO_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: '',

package/src/nodes/addJunctionNode.ts

@@ -0,0 +1,19 @@
+import { JunctionNode, NodeType } from '../types/Flows.types';
+import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
+import { RunnableLike } from '@langchain/core/runnables';
+import { createHistoryStep } from '../utils/history';
+import { HistoryStep } from '../types/Agent.types';
+
+export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
+  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    return {
+      history: createHistoryStep<HistoryStep>(state.history, {
+        type: NodeType.JUNCTION,
+        nodeId: node.name,
+        nodeDisplayName: node.displayName,
+        raw: '',
+      }),
+    };
+  };
+  graph.addNode(node.name, callback);
+};

package/src/nodes/addPromptNode.ts

@@ -1,5 +1,5 @@
 import { RunnableLike } from '@langchain/core/runnables';
-import { PromptNode } from '../types/Flows.types';
+import { NodeType, PromptNode } from '../types/Flows.types';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { z } from 'zod';
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
@@ -7,14 +7,15 @@ import { SystemMessage, AIMessage, ToolMessage } 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, HistoryStepType, HistoryStep } from '../types/Agent.types';
+import { EmitSignature, HistoryStep } from '../types/Agent.types';
 import { createLlmInstance } from '../llm/createLlmInstance';
 import extractToolStateResponse from '../utils/extractStateMemoryResponse';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
-
+import { v4 as uuidv4 } from 'uuid';
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -26,7 +27,8 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt node ${node.displayName}`);
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    logger.info({ message: `Executing prompt node ${node.displayName}` });
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -52,7 +54,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     `;
 
     const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([...state.messages, new SystemMessage(message)]);
-
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     // Check if the result contains tool calls
     if (result.tool_calls && result.tool_calls.length > 0) {
       // Execute the tools
@@ -66,6 +68,30 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
           try {
             // Invoke the LangChain tool directly
             const toolResult = await matchedTool.invoke(toolCall);
+            console.log('after invoke?');
+            //check for queue after tool call
+            const systemMessageId = uuidv4();
+
+            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+              messages: [
+                result,
+                toolResult,
+                new SystemMessage({
+                  id: systemMessageId,
+                  content:
+                    'you called tool when the user send a new message, Consider calling the function again after user message is processed',
+                }),
+              ],
+              history: [
+                createHistoryStep<HistoryStep>(state.history, {
+                  type: NodeType.TOOL,
+                  nodeId: node.name,
+                  nodeDisplayName: node.displayName,
+                  raw: toolResult,
+                  messageIds: [toolResult.id!, systemMessageId],
+                }),
+              ],
+            });
             const toolStateUpdate = extractToolStateResponse(toolResult);
             // Properly merge memory and other state updates
             stateUpdates = {
@@ -74,7 +100,8 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
               memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
             };
             toolResults.push(toolResult);
-          } catch (error) {
+          } catch (error: any) {
+            if (error?.name === 'GraphInterrupt') throw error;
             logger.error({ msg: `Error executing tool ${toolCall.name}:`, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
@@ -87,10 +114,30 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }
       }
 
+      // await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+
       // Return the tool call message and tool results with state updates spread at top level
       return {
         ...stateUpdates,
         messages: [result, ...toolResults],
+        history: [
+          createHistoryStep<HistoryStep>(state.history, {
+            type: NodeType.TOOL,
+            nodeId: node.name,
+            nodeDisplayName: node.displayName,
+            raw: result,
+            messageIds: [result.id!],
+          }),
+          ...toolResults.map((toolResult) =>
+            createHistoryStep<HistoryStep>(state.history, {
+              type: NodeType.TOOL,
+              nodeId: node.name,
+              nodeDisplayName: node.displayName,
+              raw: toolResult,
+              messageIds: [toolResult.id!],
+            }),
+          ),
+        ],
       };
     }
 
@@ -101,10 +148,9 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       console.log('AI Message', result.content);
     }
-
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.PROMPT_NODE,
+        type: NodeType.PROMPT_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: result.content,