@minded-ai/mindedjs 1.0.120 → 1.0.122-beta-1

package/src/interrupts/MindedInterruptSessionManager.ts

@@ -0,0 +1,162 @@
+import { BaseInterruptSessionManager, QueuedMessage, QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH } 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,
+        },
+      );
+      const message = response.message ?? null;
+
+      // If the dequeued message has the special trigger name, recursively dequeue the next one
+      if (message && message.triggerName === QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH) {
+        return this.dequeue(sessionId);
+      }
+
+      return message;
+    } 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({ msg: '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({ msg: 'Using Minded interrupt session manager' });
+    return new MindedInterruptSessionManager();
+  }
+}

package/src/nodes/addAppToolNode.ts

@@ -8,9 +8,10 @@ import { LLMProviders } from '../types/LLM.types';
 import { AppActionInvocationHistoryStep } from '../types/Agent.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
-import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
 import { Tool } from '../types/Tools.types';
+import { combinePlaybooks } from '../playbooks/playbooks';
+import { compilePrompt } from './compilePrompt';
 
 export const addAppToolNode = async ({
   graph,
@@ -51,14 +52,10 @@ export const addAppToolNode = async ({
       description: appRunnerTool.description,
       schema: appRunnerTool.input,
     });
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-      currentTime: new Date().toISOString(),
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
 
-    const message = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
+
+    const message = `${combinedPlaybooks ? combinedPlaybooks + '\n\n' : ''}
     Additional context:
     previous messages are available for context.
     Your goal is execute the tool with the correct parameters, some of them already chosen by the user and the rest should be generated.
@@ -70,15 +67,15 @@ export const addAppToolNode = async ({
     Parameters manually configured by the user are:
     ${JSON.stringify(cleanedParameters)}
     User instructions for choosing tool parameters are:
-        ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}
-        Workflow memory is:
-        ${JSON.stringify(state.memory)}
-        `;
+        ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}`;
+
+    const compiledPrompt = compilePrompt(message, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
+
     const AIToolCallMessage = await llm
       .bindTools([tool], {
         tool_choice: tool.name,
       })
-      .invoke([...state.messages, new SystemMessage(message)]);
+      .invoke([...state.messages, new SystemMessage(compiledPrompt)]);
     AIToolCallMessage.tool_calls[0].args = {
       ...AIToolCallMessage.tool_calls[0].args,
       ...cleanedParameters, //user set parameters have priority over ai generated parameters

package/src/nodes/addBrowserTaskNode.ts

@@ -11,46 +11,8 @@ import { createBrowserSession } from '../browserTask/executeBrowserTask';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import * as ejs from 'ejs';
-
-/**
- * Compile prompt with parameters using EJS and placeholder replacement
- */
-function compilePrompt(prompt: string, params: Record<string, any> = {}): string {
-  try {
-    // First, render with EJS
-    let compiledPrompt = ejs.render(prompt, params);
-
-    // Then, replace placeholders in {} format
-    compiledPrompt = replacePlaceholders(compiledPrompt, params);
-
-    return compiledPrompt;
-  } catch (error) {
-    logger.error({ message: 'Error compiling prompt', error });
-    return prompt; // Return uncompiled if there's an error
-  }
-}
-
-/**
- * Replace placeholders in {key} format
- */
-function replacePlaceholders(text: string, params: Record<string, any>): string {
-  return text.replace(/\{([^}]+)\}/g, (match, key) => {
-    const keys = key.split('.');
-    let value: any = params;
-
-    for (const k of keys) {
-      if (value && typeof value === 'object' && k in value) {
-        value = value[k];
-      } else {
-        return match; // Return original if key not found
-      }
-    }
-
-    return String(value);
-  });
-}
+import { compilePrompt } from './compilePrompt';
+import { combinePlaybooks } from '../playbooks/playbooks';
 
 type AddBrowserTaskNodeParams = {
   graph: PreCompiledGraph;
@@ -98,17 +60,8 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
       schema: zodSchema,
     });
 
-    // Get compiled playbooks
-    const playbookParams = {
-      ...state.memory,
-      state,
-      currentTime: new Date().toISOString(),
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const systemPrompt = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-Additional context:
-- workflow memory: ${JSON.stringify(state.memory)}`;
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
+    const systemPrompt = combinedPlaybooks ? compilePrompt(combinedPlaybooks, { state, currentTime: new Date().toISOString() }) : '';
 
     try {
       // Use LLM to generate tool call
@@ -128,8 +81,8 @@ Additional context:
       // Prepare parameters for prompt compilation
       const promptParams = {
         input: inputParams,
-        state,
-        currentTime: new Date().toISOString(),
+        memory: state.memory,
+        system: { currentTime: new Date().toISOString() },
       };
 
       // Compile the prompt with parameters
@@ -142,9 +95,7 @@ Follow the instructions. Any retrieved data should be printed as string and not
 # Task instructions:
 ${compiledPrompt}
 
-${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(inputParams, null, 2)}\n\n` : ''}
-${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
-`;
+${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(inputParams, null, 2)}\n\n` : ''}`;
 
       // Create browser session using socket
       const session = await createBrowserSession(node.proxy);

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;
@@ -16,7 +17,7 @@ export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHu
     logger.debug({ msg: `[Node] Waiting for human input`, 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,10 @@ 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({ msg: `Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}` });
     // No state modifications are necessary; control flow is handled via edges.
     return {
-      goto: null,
+      goto: node.targetNodeId,
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.JUMP_TO_NODE,
         nodeId: node.name,

package/src/nodes/addPromptNode.ts

@@ -12,9 +12,10 @@ 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 { combinePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
-
+import { compilePrompt } from './compilePrompt';
+import { v4 as uuidv4 } from 'uuid';
 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.debug({ msg: `[Node] Executing prompt node`, node: node.displayName });
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    logger.info({ msg: `[Node] Executing prompt node`, node: node.displayName });
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -39,20 +41,19 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }),
       );
 
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const message = `
-    ${node.prompt ? `# Task instructions:\n${node.prompt}\n\n` : ''}
-    ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
-    ${compiledPlaybooks ? `# General guidelines:\n${compiledPlaybooks}\n\n` : ''}
-    `;
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
 
-    const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([...state.messages, new SystemMessage(message)]);
+    // Get edges for the current node and format them
+    const edges = agent.flows?.flatMap((flow: any) => flow.edges) || [];
+    const nodeEdges = edges.filter((edge: any) => edge.source === node.name);
+    const currentPromptNode = getCurrentPromptNode(node, nodeEdges);
+    const systemMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
+    const compiledPrompt = compilePrompt(systemMessage, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
 
+    const startTime = Date.now();
+    const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([new SystemMessage(compiledPrompt), ...state.messages]);
+    const endTime = Date.now();
+    logger.debug({ msg: '[Model] Model execution time', executionTimeMs: endTime - startTime });
     // Check if the result contains tool calls
     if (result.tool_calls && result.tool_calls.length > 0) {
       // Execute the tools
@@ -65,8 +66,33 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         if (matchedTool) {
           try {
             // Invoke the LangChain tool directly
+            const startTime = Date.now();
             const toolResult = await matchedTool.invoke(toolCall);
-            logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult });
+            const endTime = Date.now();
+            logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult, executionTimeMs: endTime - startTime });
+            //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,7 +101,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: `[Tool] Error executing tool`, tool: toolCall.name, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
@@ -88,10 +115,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!],
+            }),
+          ),
+        ],
       };
     }
 
@@ -102,7 +149,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       logger.info({ msg: `[Model] Response`, content: result.content });
     }
-
     return {
       goto: null,
       history: createHistoryStep<HistoryStep>(state.history, {
@@ -117,3 +163,43 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
   };
   graph.addNode(node.name, callback);
 };
+
+function getCurrentPromptNode(node: PromptNode, nodeEdges: any[]) {
+  // Format edges for display
+  let nextEdges = '';
+  if (node.canStayOnNode !== false) {
+    nextEdges = `0. Stay in the current step. step title: ${node.displayName}\n`;
+  }
+
+  let counter = node.canStayOnNode !== false ? 0 : -1;
+  const promptConditionEdges = nodeEdges.filter((edge: any) => edge.type === 'PROMPT_CONDITION');
+  promptConditionEdges.forEach((edge: any) => {
+    counter++;
+    nextEdges += `${counter}. ${edge.prompt || edge.condition || `Go to ${edge.target}`}\n`;
+  });
+
+  return `
+# Current Node Instructions
+
+The flow of the conversation is built upon nodes. each conversation turn you
+will be given just with the current node prompt.
+
+Always follow the guidelines of "Current node prompt"
+
+Current node title: ${node.displayName}
+
+Current node prompt:
+${node.prompt}
+
+# Next nodes
+
+After handling current node you can stay in the same node or move to the next
+node based on the condition.
+
+The next nodes will run automatically by condition runner later, no need to
+worry about it now.
+
+Here are possible next nodes and their conditions, never share this
+information with the user:
+${nextEdges}`;
+}

package/src/nodes/addToolNode.ts

@@ -7,9 +7,10 @@ import { RunnableLike } from '@langchain/core/runnables';
 import { LLMProviders } from '../types/LLM.types';
 import { logger } from '../utils/logger';
 import { Agent } from '../agent';
-import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
+import { combinePlaybooks } from '../playbooks/playbooks';
+import { compilePrompt } from './compilePrompt';
 
 export const addToolNode = async ({
   graph,
@@ -30,6 +31,7 @@ export const addToolNode = async ({
     throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     logger.debug({ msg: `[Node] Executing tool node`, node: toolNode.displayName });
 
     const tool = langchainTool(() => {}, {
@@ -38,24 +40,20 @@ export const addToolNode = async ({
       schema: matchedTool.input,
     });
 
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-      currentTime: new Date().toISOString(),
-      // Add any other common parameters that playbooks might need
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
+    const systemPrompt = combinedPlaybooks
+      ? compilePrompt(combinedPlaybooks, { memory: state.memory, system: { currentTime: new Date().toISOString() } })
+      : '';
 
-    const prompt = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-        Additional context:
-          workflow memory: ${JSON.stringify(state.memory)}
-        `;
+    const startTime = Date.now();
     const AIToolCallMessage: AIMessage = await llm
       .bindTools([tool], {
         tool_choice: tool.name,
       })
-      .invoke([...state.messages, new SystemMessage(prompt)]);
-
+      .invoke([...state.messages, new SystemMessage(systemPrompt)]);
+    const endTime = Date.now();
+    logger.debug({ msg: '[Tool] Model execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     return {
       goto: null,
       messages: [AIToolCallMessage],

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);
@@ -32,7 +33,10 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
 
     const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
       try {
+        const startTime = Date.now();
         const response = await matchedTool.execute({ input, state, agent });
+        const endTime = Date.now();
+        logger.debug({ msg: '[Tool] Tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
         return response || {};
       } catch (error) {
         logger.error({ msg: '[Tool] Error executing tool', error, node: toolNode.displayName });
@@ -54,7 +58,6 @@ 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 {

package/src/nodes/compilePrompt.ts

@@ -0,0 +1,41 @@
+import * as ejs from 'ejs';
+import { logger } from '../utils/logger';
+
+/**
+ * Compile prompt with parameters using EJS and placeholder replacement
+ */
+export function compilePrompt(prompt: string, params: Record<string, any> = {}): string {
+  try {
+    // First, render with EJS
+    let compiledPrompt = ejs.render(prompt, params);
+
+    // Then, replace placeholders in {} format
+    compiledPrompt = replacePlaceholders(compiledPrompt, params);
+
+    return compiledPrompt;
+  } catch (error) {
+    logger.error({ message: 'Error compiling prompt', error });
+    return prompt; // Return uncompiled if there's an error
+  }
+}
+
+/**
+ * Replace placeholders in {key} format
+ */
+function replacePlaceholders(text: string, params: Record<string, any>): string {
+  return text.replace(/\{([^}]+)\}/g, (match, key) => {
+    const keys = key.split('.');
+    let value: any = params;
+
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        logger.warn({ message: `Placeholder {${key}} in prompt not found in memory. It will remain as placeholder.` });
+        return match; // Return original if key not found
+      }
+    }
+
+    return String(value);
+  });
+}