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

package/src/agent.ts

@@ -36,6 +36,8 @@ import {
 import { createLlmInstance } from './llm/createLlmInstance';
 import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
+import { InterruptSessionManager, InterruptType } from './interrupts/BaseInterruptSessionManager';
+import { createInterruptSessionManager } from './interrupts/interruptSessionManagerFactory';
 import { BaseMessage, HumanMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
@@ -55,6 +57,7 @@ type CreateAgentParams<Memory> = {
   tools: Tool<any, Memory>[];
   platformToken?: string;
   memorySaver?: BaseCheckpointSaver;
+  interruptSessionManager?: InterruptSessionManager;
 };
 
 /**
@@ -87,6 +90,8 @@ export class Agent {
 
   // Langgraph memory saver. In memory for local development, Custom for Platform
   private checkpointer!: BaseCheckpointSaver;
+  // Interrupt session manager. In memory for local development, Custom for Platform
+  public interruptSessionManager!: InterruptSessionManager;
   // Langgraph compiled graph
   public compiledGraph!: CompiledGraph;
   // Cache for secrets to avoid repeated API calls
@@ -157,7 +162,7 @@ export class Agent {
 
   private async init(params: CreateAgentParams<z.infer<typeof this.memorySchema>>): Promise<void> {
     try {
-      const { config, tools, memorySaver } = params;
+      const { config, tools, memorySaver, interruptSessionManager } = params;
       const { runLocally } = getConfig();
       if (!runLocally) {
         await mindedConnection.start();
@@ -196,6 +201,7 @@ export class Agent {
       const libraryActionsRunnerTools = this.initLibraryActionsRunnerTools();
       this.tools = [...tools, ...appActionsRunnerTools, ...libraryActionsRunnerTools];
       this.checkpointer = memorySaver || createCheckpointSaver();
+      this.interruptSessionManager = interruptSessionManager || createInterruptSessionManager();
 
       // call here methods that needs environment variables to be loaded
       this.llm = createLlmInstance(config.llm);
@@ -387,6 +393,10 @@ export class Agent {
     // Try to parse empty object through the schema to apply default values
     // If parsing fails due to required fields without defaults, use empty object as fallback
     const parseResult = this.memorySchema.safeParse({});
+    if (!parseResult.success) {
+      logger.error({ msg: 'Failed to parse memory schema', error: parseResult.error });
+      throw new Error('Failed to parse memory schema');
+    }
     const initialMemory = parseResult.success ? parseResult.data : {};
 
     const initialState = {
@@ -426,14 +436,14 @@ export class Agent {
 
     return appName
       ? createHistoryStep<AppTriggerHistoryStep>(currentHistory, {
-        ...baseStep,
-        type: NodeType.TRIGGER,
-        appName,
-      })
+          ...baseStep,
+          type: NodeType.TRIGGER,
+          appName,
+        })
       : createHistoryStep<TriggerHistoryStep>(currentHistory, {
-        ...baseStep,
-        type: NodeType.TRIGGER,
-      });
+          ...baseStep,
+          type: NodeType.TRIGGER,
+        });
   }
 
   /**
@@ -464,10 +474,24 @@ export class Agent {
    * });
    * ```
    */
-  public async invoke({ triggerBody, triggerName, sessionId, appName }: AgentInvokeParams) {
+  public async invoke({ triggerBody, triggerName, sessionId, appName, bypassSessionCheck }: AgentInvokeParams): Promise<any> {
     sessionId = sessionId ?? uuidv4();
     try {
       await this.waitForInitialization();
+
+      // Try to acquire lock atomically (unless bypassing session check)
+      if (!bypassSessionCheck && !(await this.interruptSessionManager.lock(sessionId))) {
+        // Could not acquire lock, session is being processed - enqueue the message
+        logger.info({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
+        await this.interruptSessionManager.enqueueMessage(sessionId, {
+          triggerBody,
+          triggerName,
+          appName,
+        });
+        return;
+      }
+      // Session lock acquired, proceed with processing
+
       let messages: Array<BaseMessage> = [];
       let memoryUpdate = {};
       let sessionType: SessionType = SessionType.TEXT;
@@ -503,7 +527,8 @@ export class Agent {
           const handlerResult = results.find((r) => r !== undefined);
           if (handlerResult) {
             if (!handlerResult.isQualified) {
-              logger.debug({ msg: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
+              logger.info({ message: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
+              await this.interruptSessionManager.release(sessionId);
               return;
             }
             memoryUpdate = handlerResult.memory || {};
@@ -536,13 +561,37 @@ export class Agent {
 
       let res;
       // Resume interruption
-      if (state.tasks?.[0]?.interrupts?.length > 0) {
-        res = await this.compiledGraph.invoke(
-          new Command({
-            resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType },
-          }),
-          langraphConfig,
-        );
+      if (state.tasks?.[state.tasks.length - 1]?.interrupts?.length > 0) {
+        const lastTask = state.tasks[state.tasks.length - 1];
+        const interrupt = lastTask.interrupts[0];
+        const interruptValue = (interrupt as any).value;
+
+        if (interruptValue?.type === InterruptType.HUMAN_IN_THE_LOOP) {
+          // For HUMAN_IN_THE_LOOP, use resume with the full object
+          res = await this.compiledGraph.invoke(
+            new Command({
+              resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType, overrideStartFromNodeId: null },
+            }),
+            langraphConfig,
+          );
+        } else if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
+          // For NEW_TRIGGERS, check if there's an updateStateObject to apply first
+          const finalState = { memory: memoryUpdate, messages, history: [historyStep], sessionId, sessionType };
+          if (interruptValue.updateStateObject) {
+            finalState.messages = [...interruptValue.updateStateObject.messages, ...messages];
+            finalState.history = [...(interruptValue.updateStateObject.history || []), historyStep];
+            //add handlers for other state fields as needed
+          }
+
+          // Then use update with the full object and empty resume
+          res = await this.compiledGraph.invoke(
+            new Command({
+              update: finalState,
+              resume: '',
+            }),
+            langraphConfig,
+          );
+        }
       } else if (state.values.overrideStartFromNodeId) {
         res = await this.compiledGraph.invoke(
           new Command({
@@ -564,6 +613,26 @@ export class Agent {
           langraphConfig,
         );
       }
+      const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
+      if (nextMessage) {
+        // Dequeue the first message and process it recursively
+        // Recursively process the next message with bypass flag
+        const invokeParams: AgentInvokeParams = {
+          triggerBody: nextMessage.triggerBody,
+          triggerName: nextMessage.triggerName,
+          sessionId: sessionId,
+          bypassSessionCheck: true,
+        };
+        if (nextMessage.appName) {
+          invokeParams.appName = nextMessage.appName;
+        }
+        logger.info({ msg: 'Invoking next message in the queue', invokeParams });
+        return await this.invoke(invokeParams);
+      }
+
+      // Release the session lock
+      await this.interruptSessionManager.release(sessionId);
+
       return res;
     } catch (error: any) {
       logger.error({
@@ -572,6 +641,10 @@ export class Agent {
         stack: error.stack,
         sessionId,
       });
+
+      // Release the session lock on error
+      await this.interruptSessionManager.release(sessionId);
+
       const state = await this.compiledGraph.getState(this.getLangraphConfig(sessionId));
       this.emit(AgentEvents.ERROR, { error: error instanceof Error ? error : new Error(JSON.stringify(error)), state: state.values });
       throw error;
@@ -763,7 +836,7 @@ export class Agent {
       // Hangup / end session handler
       connection.on(mindedConnectionSocketMessageType.VOICE_SESSION_END, (message) => {
         const hangup = message as BaseVoiceMessage;
-        logger.debug({ message: '[Voice] Dashboard eneded voice session', sessionId: hangup.sessionId });
+        logger.debug({ msg: '[Voice] Dashboard eneded voice session', sessionId: hangup.sessionId });
         const voiceSession = this.voiceSessions.get(hangup.sessionId);
         if (voiceSession) {
           voiceSession.hangup();
@@ -812,7 +885,8 @@ export class Agent {
       voiceId: voiceTrigger.voiceId,
     });
     await voiceSession.init();
-    logger.debug({ message: '[Voice] Voice session initialized', sessionId: params.sessionId });
+    logger.debug({ msg: '[Voice] Voice session initialized', sessionId: params.sessionId });
+
     this.voiceSessions.set(params.sessionId, voiceSession);
 
     // Emit voice session start event

package/src/cli/index.ts

@@ -19,7 +19,7 @@ function setToken(token: string): void {
   if (!fs.existsSync(envPath)) {
     // Create .env file with the token
     fs.writeFileSync(envPath, tokenLine + '\n');
-    logger.info(`Created ${envPath} and added token`);
+    logger.info({ msg: `Created ${envPath} and added token` });
   } else {
     // Read existing .env file
     const envContent = fs.readFileSync(envPath, 'utf8');
@@ -29,12 +29,12 @@ function setToken(token: string): void {
       // Replace existing token
       const updatedContent = envContent.replace(/MINDED_CONNECTION_TOKEN=.*/, tokenLine);
       fs.writeFileSync(envPath, updatedContent);
-      logger.info(`Updated MINDED_CONNECTION_TOKEN in ${envPath}`);
+      logger.info({ msg: `Updated MINDED_CONNECTION_TOKEN in ${envPath}` });
     } else {
       // Append token to existing file
       const newContent = envContent.endsWith('\n') ? envContent + tokenLine + '\n' : envContent + '\n' + tokenLine + '\n';
       fs.writeFileSync(envPath, newContent);
-      logger.info(`Added MINDED_CONNECTION_TOKEN to ${envPath}`);
+      logger.info({ msg: `Added MINDED_CONNECTION_TOKEN to ${envPath}` });
     }
   }
 }
@@ -44,7 +44,7 @@ function generateLambdaHandler(): void {
 
   // Check if minded.json exists
   if (!fs.existsSync(mindedConfigPath)) {
-    logger.error('minded.json not found in the current directory');
+    logger.error({ msg: 'minded.json not found in the current directory' });
     process.exit(1);
   }
 
@@ -54,14 +54,14 @@ function generateLambdaHandler(): void {
     const configContent = fs.readFileSync(mindedConfigPath, 'utf8');
     mindedConfig = JSON.parse(configContent);
   } catch (error) {
-    logger.error('Failed to read or parse minded.json:', error);
+    logger.error({ msg: 'Failed to read or parse minded.json:', error });
     process.exit(1);
   }
 
   // Get the agent path
   const agentPath = mindedConfig.agent;
   if (!agentPath) {
-    logger.error('No agent path found in minded.json');
+    logger.error({ msg: 'No agent path found in minded.json' });
     process.exit(1);
   }
 
@@ -91,7 +91,7 @@ function generateLambdaHandler(): void {
   }
 
   if (!templateContent) {
-    logger.error('Could not find Lambda handler template file');
+    logger.error({ msg: 'Could not find Lambda handler template file' });
     process.exit(1);
   }
 
@@ -102,10 +102,10 @@ function generateLambdaHandler(): void {
     // Write the Lambda handler to index.ts at the root
     const outputPath = path.join(process.cwd(), 'index.ts');
     fs.writeFileSync(outputPath, templateContent);
-    logger.info(`Generated Lambda handler at ${outputPath}`);
+    logger.info({ msg: `Generated Lambda handler at ${outputPath}` });
 
     // Compile the index.ts file using TypeScript
-    logger.info('Compiling the Lambda handler...');
+    logger.info({ msg: 'Compiling the Lambda handler...' });
 
     try {
       // Read tsconfig.json to get the outDir
@@ -138,12 +138,12 @@ function generateLambdaHandler(): void {
         cwd: process.cwd(),
       });
 
-      logger.info(`Successfully compiled Lambda handler to ${outDir}/index.js`);
+      logger.info({ msg: `Successfully compiled Lambda handler to ${outDir}/index.js` });
     } catch (compileError) {
-      logger.error({ message: 'Failed to compile Lambda handler', error: compileError });
+      logger.error({ msg: 'Failed to compile Lambda handler', error: compileError });
     }
   } catch (error) {
-    logger.error({ message: 'Failed to generate Lambda handler', error: error });
+    logger.error({ msg: 'Failed to generate Lambda handler', error: error });
     process.exit(1);
   }
 }
@@ -155,14 +155,14 @@ function main() {
   if (command === 'token') {
     const token = args[1];
     if (!token) {
-      logger.error('Please provide a token');
+      logger.error({ msg: 'Please provide a token' });
       process.exit(1);
     }
     setToken(token);
   } else if (command === 'generate-lambda-ts-handler') {
     generateLambdaHandler();
   } else {
-    logger.error('Unknown command. Available commands: token, generate-lambda-ts-handler');
+    logger.error({ msg: 'Unknown command. Available commands: token, generate-lambda-ts-handler' });
     process.exit(1);
   }
 }

package/src/edges/edgeFactory.ts

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

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -0,0 +1,96 @@
+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 const QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH = 'QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH';
+
+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({ msg: '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,63 @@
+import { BaseInterruptSessionManager, QueuedMessage, QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH } 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);
+
+    // If the dequeued message has the special trigger name, recursively dequeue the next one
+    if (firstMessage.triggerName === QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH) {
+      return this.dequeue(sessionId);
+    }
+
+    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,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

@@ -69,7 +69,7 @@ export const addAppToolNode = async ({
     User instructions for choosing tool parameters are:
         ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}`;
 
-    const compiledPrompt = compilePrompt(message, { state, currentTime: new Date().toISOString() });
+    const compiledPrompt = compilePrompt(message, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
 
     const AIToolCallMessage = await llm
       .bindTools([tool], {