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

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({ 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

@@ -76,7 +76,7 @@ export const addAppToolNode = async ({
     const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
     AIToolCallMessage.additional_kwargs = {
       mindedMetadata: {
-        nodeType: NodeType.APP_TOOL
+        nodeType: NodeType.APP_TOOL,
       },
     };
     return {

package/src/nodes/addBrowserTaskNode.ts

@@ -92,7 +92,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = z.object(schemaFields);
 
     // Create langchain tool
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: 'browser-task',
       description: node.prompt,
       schema: zodSchema,
@@ -171,6 +171,7 @@ ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
+            nodeDisplayName: node.displayName,
             taskId,
             liveUrl: taskDetails.live_url,
           },
@@ -208,6 +209,7 @@ ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
+            nodeDisplayName: node.displayName,
             error: error.message,
           },
         },

package/src/nodes/addBrowserTaskRunNode.ts

@@ -26,15 +26,13 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
     if (!toolCallObj.tool_calls) {
       throw new Error('Tool call not found');
     }
-
     const toolCall = toolCallObj.tool_calls[0];
     const { taskId, ...inputParams } = toolCall.args;
-
-    if (!taskId) {
-      throw new Error('Task ID not found in tool call arguments');
-    }
-
     try {
+      if (!taskId) {
+        throw new Error('Task ID not found in tool call arguments');
+      }
+
       // Wait for task completion
       const completedTask = await waitForCompletion(taskId);
       logger.debug({ msg: 'Browser task completed', taskId, output: completedTask.output });
@@ -53,6 +51,7 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
+            nodeDisplayName: browserTaskNode.displayName,
             taskId,
             steps: completedTask.steps,
             inputParams: inputParams,
@@ -69,6 +68,7 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
           ...toolCallObj.additional_kwargs,
           mindedMetadata: {
             ...toolCallObj.additional_kwargs?.mindedMetadata,
+            nodeDisplayName: browserTaskNode.displayName,
             steps: completedTask.steps,
             status: 'completed',
           },
@@ -101,6 +101,7 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
+            nodeDisplayName: browserTaskNode.displayName,
             taskId,
             error: error.message,
             inputParams: inputParams,
@@ -117,6 +118,7 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
           ...toolCallObj.additional_kwargs,
           mindedMetadata: {
             ...toolCallObj.additional_kwargs?.mindedMetadata,
+            nodeDisplayName: browserTaskNode.displayName,
             status: 'failed',
             error: error.message,
           },

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,7 +7,7 @@ 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,

package/src/nodes/addPromptNode.ts

@@ -14,7 +14,7 @@ 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';
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -26,7 +26,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
@@ -50,9 +51,9 @@ 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` : ''}
     `;
-
+    // await wait(5000);
     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
@@ -67,6 +68,29 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             // 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,7 +99,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 +113,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 +147,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, {

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);
@@ -54,7 +55,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/platform/mindedConnection.ts

@@ -1,8 +1,5 @@
 import { io, Socket } from 'socket.io-client';
-import {
-  mindedConnectionSocketMessageType,
-  mindedConnectionSocketMessageTypeMap,
-} from './mindedConnectionTypes';
+import { mindedConnectionSocketMessageType, mindedConnectionSocketMessageTypeMap } from './mindedConnectionTypes';
 import { stringify } from 'flatted';
 import { getConfig } from './config';
 import { logger } from '../utils/logger';
@@ -28,20 +25,13 @@ export const on = <E extends keyof mindedConnectionSocketMessageTypeMap>(
   listeners[event].push(callback);
 };
 
-export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(
-  event: E,
-  message: mindedConnectionSocketMessageTypeMap[E]
-) => {
+export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(event: E, message: mindedConnectionSocketMessageTypeMap[E]) => {
   if (socket) {
     socket.emit(event, message);
   }
 };
 
-export const awaitEmit = async <T, R>(
-  event: mindedConnectionSocketMessageType,
-  message: T,
-  timeoutMs: number = 5000
-): Promise<R> => {
+export const awaitEmit = async <T, R>(event: mindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
   if (!socket) {
     throw new Error('Socket is not connected');
   }
@@ -97,33 +87,33 @@ const connect = async (token: string): Promise<void> => {
 
     const checkReady = () => {
       if (connected && ready) {
-        logger.info('\x1b[32mConnection with Minded platform is ready!\x1b[0m');
-        logger.info('\x1b[32mPress Ctrl+C to exit...');
+        logger.info({ msg: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+        logger.info({ msg: '\x1b[32mPress Ctrl+C to exit...' });
         resolve();
       }
     };
 
     // Connection event handlers
     socket.on('connect', () => {
-      logger.info('Socket connected, waiting for server setup...');
+      logger.info({ msg: 'Socket connected, waiting for server setup...' });
       connected = true;
       checkReady();
     });
 
     // Listen for ready event from server
     socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-      logger.info('Server ready signal received', data);
+      logger.info({ msg: 'Server ready signal received', data });
       ready = true;
       checkReady();
     });
 
     socket.on('connect_error', () => {
-      logger.error('Failed to connect to minded platform');
+      logger.error({ msg: 'Failed to connect to minded platform' });
       reject(new Error('Failed to connect to minded platform'));
     });
 
     socket.on('disconnect', () => {
-      logger.info('Disconnected from local debugging socket');
+      logger.info({ msg: 'Disconnected from local debugging socket' });
       connected = false;
       ready = false;
     });
@@ -133,7 +123,7 @@ const connect = async (token: string): Promise<void> => {
       logger.error({ msg: 'Server error:', error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info('Invalid token');
+        logger.info({ msg: 'Invalid token' });
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -152,14 +142,14 @@ const connect = async (token: string): Promise<void> => {
           listener(message, callback);
         });
       } else {
-        console.warn({ message: 'No listeners found for event', event });
+        console.warn({ msg: 'No listeners found for event', event });
       }
     });
 
     // Handle process termination
     process.on('SIGINT', () => {
       if (socket?.connected) {
-        logger.info('\nDisconnecting...');
+        logger.info({ msg: '\nDisconnecting...' });
         socket.disconnect();
       }
       process.exit(0);
@@ -177,17 +167,17 @@ export const start = async (): Promise<void> => {
 
 export const disconnect = () => {
   if (!socket) {
-    logger.warn('No socket connection to disconnect');
+    logger.warn({ msg: 'No socket connection to disconnect' });
     return;
   }
 
   if (socket.connected) {
-    logger.info('Disconnecting from Minded platform...');
+    logger.info({ msg: 'Disconnecting from Minded platform...' });
     socket.disconnect();
     return;
   }
 
-  logger.warn('Socket is already disconnected');
+  logger.warn({ msg: 'Socket is already disconnected' });
 };
 
 export const mindedConnection = {