@minded-ai/mindedjs 1.0.102 → 1.0.103-beta-1

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -0,0 +1,94 @@
+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>;
+  /**
+   * Atomically attempts to acquire a lock for the given session.
+   * This method should only succeed if the session is not already being processed.
+   *
+   * @param sessionId - The session ID to lock
+   * @returns true if the lock was successfully acquired, false if the session is already locked
+   */
+  lock(sessionId: string): boolean | Promise<boolean>;
+  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>;
+  /**
+   * Atomically attempts to acquire a lock for the given session.
+   * This method should only succeed if the session is not already being processed.
+   * Implementations must ensure this operation is atomic to prevent race conditions.
+   *
+   * @param sessionId - The session ID to lock
+   * @returns true if the lock was successfully acquired, false if the session is already locked
+   */
+  abstract lock(sessionId: string): boolean | Promise<boolean>;
+  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)) {
+      logger.trace({ message: 'graph has queued messagess, interrupting graph', sessionId });
+
+      // 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,57 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './BaseInterruptSessionManager';
+
+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): boolean {
+    const isCurrentlyProcessed = this.sessionProcessing.get(sessionId) || false;
+    if (isCurrentlyProcessed) {
+      return false; // Could not acquire lock
+    }
+    this.sessionProcessing.set(sessionId, true);
+    return true; // Successfully acquired lock
+  }
+
+  release(sessionId: string): void {
+    this.sessionProcessing.delete(sessionId);
+  }
+
+  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,155 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './BaseInterruptSessionManager';
+import * as 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 {
+  constructor() {
+    super();
+  }
+
+  async isProcessed(sessionId: string): Promise<boolean> {
+    try {
+      const response = await 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<boolean> {
+    try {
+      const response = await mindedConnection.awaitEmit<InterruptSessionLockRequest, InterruptSessionLockResponse>(
+        mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+        {
+          type: mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+          sessionId,
+        },
+      );
+      return response.lockAcquired ?? false;
+    } catch (error) {
+      console.error('Error locking session:', error);
+      return false;
+    }
+  }
+
+  async release(sessionId: string): Promise<void> {
+    try {
+      await 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 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 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 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 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 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 './BaseInterruptSessionManager';
+import { MemoryInterruptSessionManager } from './MemoryInterruptSessionManager';
+import { MindedInterruptSessionManager } from './MindedInterruptSessionManager';
+import * as mindedConnection from '../platform/mindedConnection';
+import { getConfig } from '../platform/config';
+import { logger } from '../utils/logger';
+
+export function createInterruptSessionManager(): InterruptSessionManager {
+  const { runLocally } = getConfig();
+  if (runLocally) {
+    logger.info({ message: 'Using memory interrupt session manager' });
+    return new MemoryInterruptSessionManager();
+  } else {
+    if (!mindedConnection.isConnected()) {
+      throw new Error('MindedConnection is required for platform interrupt session manager');
+    }
+    logger.info({ message: 'Using Minded interrupt session manager' });
+    return new MindedInterruptSessionManager();
+  }
+}

package/src/llm/createLlmInstance.ts

@@ -1,5 +1,4 @@
-import { LLMConfig, LLMProviders, LLMProvider } from '../types/LLM.types';
-import { createParallelWrapper, BaseParallelChatFields } from '../platform/models/parallelWrapper';
+import { LLMConfig, LLMProviders, LLMProvider } from "../types/LLM.types";
 
 export const createLlmInstance = (llmConfig: LLMConfig) => {
   const { name, properties } = llmConfig;
@@ -7,27 +6,5 @@ export const createLlmInstance = (llmConfig: LLMConfig) => {
   if (!LLMClass) {
     throw new Error(`Unsupported LLM provider: ${name}`);
   }
-
-  // Create the base LLM instance
-  const llmInstance = new LLMClass(properties);
-
-  // Check if parallel configuration is present
-  const hasParallelConfig = properties.numParallelRequests && properties.numParallelRequests > 1;
-
-  // For MindedChatOpenAI, parallel functionality is handled on the backend
-  if (name === 'MindedChatOpenAI') {
-    return llmInstance;
-  }
-
-  // For other LLM providers, apply client-side parallel wrapper if configured
-  if (hasParallelConfig) {
-    const parallelOptions: BaseParallelChatFields = {
-      numParallelRequests: properties.numParallelRequests,
-      logTimings: properties.logTimings,
-    };
-
-    return createParallelWrapper(llmInstance, parallelOptions);
-  }
-
-  return llmInstance;
+  return new LLMClass(properties);
 };

package/src/nodes/addAppToolNode.ts

@@ -26,14 +26,14 @@ 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.debug({ msg: `[Node] Executing tool node`, node: appRunnerTool.name });
+    logger.info({ message: `Executing tool node ${appRunnerTool.name}` });
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {
         const response = await appRunnerTool.execute({ input, state, agent });
         return response || {};
       } catch (error) {
-        logger.error({ msg: `[Node] Error executing tool`, error, node: node.name });
+        logger.error({ msg: 'Error executing tool', error });
         throw error;
       }
     };
@@ -75,12 +75,11 @@ export const addAppToolNode = async ({
     };
     const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
     AIToolCallMessage.additional_kwargs = {
-      mindedMetadata: {
-        nodeType: NodeType.APP_TOOL
+      appActionInvocation: {
+        nodeTitle: node.name,
       },
     };
     return {
-      goto: null,
       messages: [AIToolCallMessage, toolCallMessage],
       history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
         type: NodeType.APP_TOOL,

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/BaseInterruptSessionManager';
 
 type AddHumanInTheLoopNodeParams = {
   graph: PreCompiledGraph;
@@ -13,10 +14,9 @@ export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${i
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Waiting for human input`, 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

@@ -7,10 +7,9 @@ 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 {
-      goto: null,
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.JUMP_TO_NODE,
         nodeId: node.name,

package/src/nodes/addJunctionNode.ts

@@ -7,7 +7,6 @@ import { HistoryStep } from '../types/Agent.types';
 export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     return {
-      goto: null,
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.JUNCTION,
         nodeId: node.name,

package/src/nodes/addPromptNode.ts

@@ -14,6 +14,9 @@ import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
+import { wait } from '../utils/wait';
+import { sendPlaceholderMessage } from '../internalTools/sendPlaceholderMessage';
+import { v4 as uuidv4 } from 'uuid';
 
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
@@ -23,10 +26,12 @@ type AddPromptNodeParams = {
   emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
   agent: Agent;
 };
+let shouldWait = true;
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Executing prompt node`, 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
@@ -50,9 +55,18 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
     ${compiledPlaybooks ? `# General guidelines:\n${compiledPlaybooks}\n\n` : ''}
     `;
+    if (true) {
+      logger.info({ msg: `waiting 15 seconds` });
+      shouldWait = false;
 
+      await sendPlaceholderMessage({ sessionId: state.sessionId, message: 'just a moment please... ' });
+      await wait(10000);
+      logger.info({ msg: `done waiting 15 seconds` });
+    } else {
+      logger.info({ msg: `not waiting` });
+    }
     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
@@ -61,12 +75,34 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
 
       for (const toolCall of result.tool_calls) {
         const matchedTool = globalTools.find((t) => t.name === toolCall.name);
-        logger.info({ msg: `[Model] Calling tool`, tool: matchedTool?.name });
+        logger.info({ msg: `Model called tool ${matchedTool?.name}` });
         if (matchedTool) {
           try {
             // Invoke the LangChain tool directly
             const toolResult = await matchedTool.invoke(toolCall);
-            logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult });
+            //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 = {
@@ -75,8 +111,9 @@ 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) {
-            logger.error({ msg: `[Tool] Error executing tool`, tool: toolCall.name, 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) }),
               tool_call_id: toolCall.id!,
@@ -84,14 +121,34 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             toolResults.push(errorMessage);
           }
         } else {
-          logger.error({ msg: `[Tool] Model called tool but it was not found`, tool: toolCall.name });
+          logger.error({ msg: `Model tried to call tool ${toolCall.name} but it was not found` });
         }
       }
 
+      // 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!],
+            }),
+          ),
+        ],
       };
     }
 
@@ -100,11 +157,9 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         message: result.content as string,
         state,
       });
-      logger.info({ msg: `[Model] Response`, content: result.content });
+      console.log('AI Message', result.content);
     }
-
     return {
-      goto: null,
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.PROMPT_NODE,
         nodeId: node.name,

package/src/nodes/addToolNode.ts

@@ -30,8 +30,8 @@ export const addToolNode = async ({
     throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Executing tool node`, node: toolNode.displayName });
-
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    logger.info({ message: `Executing tool node ${toolNode.displayName}` });
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,
       description: matchedTool.description,
@@ -56,9 +56,9 @@ export const addToolNode = async ({
         tool_choice: tool.name,
       })
       .invoke([...state.messages, new SystemMessage(prompt)]);
-
+    logger.info({ message: 'after llm tool invoke' });
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     return {
-      goto: null,
       messages: [AIToolCallMessage],
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.TOOL,

package/src/nodes/addToolRunNode.ts

@@ -23,6 +23,7 @@ type AddToolRunNodeParams = {
 
 export const buildToolRunNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.TOOL_RUN}`;
 
+//you never want to interrupt here because of new triggers, as this node depends on the last message to be the tool call from the addToolNode, interrupting will add human message here
 export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName, agent }: AddToolRunNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
@@ -35,7 +36,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
         const response = await matchedTool.execute({ input, state, agent });
         return response || {};
       } catch (error) {
-        logger.error({ msg: '[Tool] Error executing tool', error, node: toolNode.displayName });
+        logger.error({ msg: 'Error executing tool', error });
         throw error;
       }
     };
@@ -54,11 +55,8 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
 
     // Push the toolCallMessage into the messages array from toolStateUpdate
     const updatedMessages = [toolCallMessage, ...((toolStateUpdate as any).messages || [])];
-
     // Return the full state update from the tool with the updated messages
-
     return {
-      goto: null,
       ...toolStateUpdate,
       messages: updatedMessages,
       history: createHistoryStep<HistoryStep>(state.history, {

package/src/nodes/addTriggerNode.ts

@@ -7,10 +7,9 @@ import { createHistoryStep } from '../utils/history';
 
 export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Trigger] Executing trigger node`, node: node.displayName });
+    logger.info({ message: `Executing trigger node ${node.displayName}` });
     if (node.triggerType === TriggerType.MANUAL) {
       return {
-        goto: null,
         history: createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.TRIGGER,
           nodeId: node.name,

package/src/nodes/nodeFactory.ts

@@ -11,7 +11,6 @@ import { LLMProviders } from '../types/LLM.types';
 import { Agent } from '../agent';
 import { addJumpToNode } from './addJumpToNode';
 import { addJunctionNode } from './addJunctionNode';
-import { addBrowserTaskNode } from './addBrowserTaskNode';
 
 export const nodeFactory = ({
   graph,
@@ -48,10 +47,7 @@ export const nodeFactory = ({
     case NodeType.JUMP_TO_NODE:
       addJumpToNode({ graph, node });
       break;
-    case NodeType.BROWSER_TASK:
-      addBrowserTaskNode({ graph, node, agent, llm });
-      break;
     default:
       throw new Error(`Unsupported node type: ${nodeType}`);
   }
-};
+};