@minded-ai/mindedjs 1.0.93 → 1.0.95-beta-1

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,154 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './InterruptSessionManager.types';
+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<void> {
+    try {
+      await 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 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 './InterruptSessionManager.types';
+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/nodes/addAppToolNode.ts

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

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

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

package/src/nodes/addPromptNode.ts

@@ -14,7 +14,8 @@ 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,7 +148,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       console.log('AI Message', result.content);
     }
-
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.PROMPT_NODE,

package/src/nodes/addToolNode.ts

@@ -30,7 +30,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) => {
-    logger.info(`Executing tool node ${toolNode.displayName}`);
+    logger.info({ message: `Executing tool node ${toolNode.displayName}` });
 
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,

package/src/nodes/addTriggerNode.ts

@@ -7,7 +7,7 @@ import { createHistoryStep } from '../utils/history';
 
 export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing trigger node ${node.displayName}`);
+    logger.info({ message: `Executing trigger node ${node.displayName}` });
     if (node.triggerType === TriggerType.MANUAL) {
       return {
         history: createHistoryStep<HistoryStep>(state.history, {

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,43 +87,43 @@ 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({ message: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+        logger.info({ message: '\x1b[32mPress Ctrl+C to exit...' });
         resolve();
       }
     };
 
     // Connection event handlers
     socket.on('connect', () => {
-      logger.info('Socket connected, waiting for server setup...');
+      logger.info({ message: '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({ message: 'Server ready signal received', data });
       ready = true;
       checkReady();
     });
 
     socket.on('connect_error', () => {
-      logger.error('Failed to connect to minded platform');
+      logger.error({ message: '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({ message: 'Disconnected from local debugging socket' });
       connected = false;
       ready = false;
     });
 
     // Listen for error messages from the server
     socket.on('error', async (error: { message: string }) => {
-      logger.error({ msg: 'Server error:', error });
+      logger.error({ message: 'Server error:', error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info('Invalid token');
+        logger.info({ message: 'Invalid token' });
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -159,7 +149,7 @@ const connect = async (token: string): Promise<void> => {
     // Handle process termination
     process.on('SIGINT', () => {
       if (socket?.connected) {
-        logger.info('\nDisconnecting...');
+        logger.info({ message: '\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({ message: 'No socket connection to disconnect' });
     return;
   }
 
   if (socket.connected) {
-    logger.info('Disconnecting from Minded platform...');
+    logger.info({ message: 'Disconnecting from Minded platform...' });
     socket.disconnect();
     return;
   }
 
-  logger.warn('Socket is already disconnected');
+  logger.warn({ message: 'Socket is already disconnected' });
 };
 
 export const mindedConnection = {