@minded-ai/mindedjs 1.0.91 → 1.0.92-beta-2

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,157 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './InterruptSessionManager.types';
+import { 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 {
+  private mindedConnection: MindedConnection;
+
+  constructor(mindedConnection: MindedConnection) {
+    super();
+    this.mindedConnection = mindedConnection;
+  }
+
+  async isProcessed(sessionId: string): Promise<boolean> {
+    try {
+      const response = await this.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 this.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 this.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 this.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 this.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 this.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 this.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 this.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,17 @@
+import { InterruptSessionManager } from './InterruptSessionManager.types';
+import { MemoryInterruptSessionManager } from './MemoryInterruptSessionManager';
+import { MindedInterruptSessionManager } from './MindedInterruptSessionManager';
+import { MindedConnection } from '../platform/mindedConnection';
+import { getConfig } from '../platform/config';
+
+export function createInterruptSessionManager(mindedConnection: MindedConnection | null): InterruptSessionManager {
+  const { runLocally } = getConfig();
+  if (runLocally) {
+    return new MemoryInterruptSessionManager();
+  } else {
+    if (!mindedConnection) {
+      throw new Error('MindedConnection is required for platform interrupt session manager');
+    }
+    return new MindedInterruptSessionManager(mindedConnection);
+  }
+}

package/src/nodes/addAppToolNode.ts

@@ -1,4 +1,4 @@
-import { AppToolNode } from '../types/Flows.types';
+import { AppToolNode, NodeType } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { SystemMessage } from '@langchain/core/messages';
@@ -6,7 +6,7 @@ import { RunnableLike } from '@langchain/core/runnables';
 import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
 import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
-import { AppActionInvocationHistoryStep, HistoryStepType } from '../types/Agent.types';
+import { AppActionInvocationHistoryStep } from '../types/Agent.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
@@ -82,7 +82,7 @@ export const addAppToolNode = async ({
     return {
       messages: [AIToolCallMessage, toolCallMessage],
       history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
-        type: HistoryStepType.APP_ACTION_NODE,
+        type: NodeType.APP_TOOL,
         nodeId: node.name,
         nodeDisplayName: node.displayName!,
         raw: AIToolCallMessage.tool_calls[0],

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;
@@ -16,7 +17,7 @@ export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHu
     logger.info(`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

@@ -1,8 +1,8 @@
 import { RunnableLike } from '@langchain/core/runnables';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { JumpToNode } from '../types/Flows.types';
+import { JumpToNode, NodeType } from '../types/Flows.types';
 import { logger } from '../utils/logger';
-import { HistoryStepType, HistoryStep } from '../types/Agent.types';
+import { HistoryStep } from '../types/Agent.types';
 import { createHistoryStep } from '../utils/history';
 
 export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
@@ -11,7 +11,7 @@ export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph;
     // No state modifications are necessary; control flow is handled via edges.
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.JUMP_TO_NODE,
+        type: NodeType.JUMP_TO_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: '',

package/src/nodes/addJunctionNode.ts

@@ -0,0 +1,19 @@
+import { JunctionNode, NodeType } from '../types/Flows.types';
+import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
+import { RunnableLike } from '@langchain/core/runnables';
+import { createHistoryStep } from '../utils/history';
+import { HistoryStep } from '../types/Agent.types';
+
+export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
+  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    return {
+      history: createHistoryStep<HistoryStep>(state.history, {
+        type: NodeType.JUNCTION,
+        nodeId: node.name,
+        nodeDisplayName: node.displayName,
+        raw: '',
+      }),
+    };
+  };
+  graph.addNode(node.name, callback);
+};

package/src/nodes/addPromptNode.ts

@@ -1,5 +1,5 @@
 import { RunnableLike } from '@langchain/core/runnables';
-import { PromptNode } from '../types/Flows.types';
+import { NodeType, PromptNode } from '../types/Flows.types';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { z } from 'zod';
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
@@ -7,14 +7,14 @@ import { SystemMessage, AIMessage, ToolMessage } from '@langchain/core/messages'
 import { Tool } from '../types/Tools.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
-import { EmitSignature, HistoryStepType, HistoryStep } from '../types/Agent.types';
+import { EmitSignature, HistoryStep } from '../types/Agent.types';
 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 { createHistoryStep } from '../utils/history';
-
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -26,6 +26,7 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     logger.info(`Executing prompt node ${node.displayName}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
@@ -52,7 +53,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 +67,26 @@ 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
+            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+              messages: [
+                result,
+                toolResult,
+                new SystemMessage(
+                  '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!],
+                }),
+              ],
+            });
             const toolStateUpdate = extractToolStateResponse(toolResult);
             // Properly merge memory and other state updates
             stateUpdates = {
@@ -74,7 +95,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 +109,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,10 +143,9 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       console.log('AI Message', result.content);
     }
-
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.PROMPT_NODE,
+        type: NodeType.PROMPT_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: result.content,

package/src/nodes/addToolNode.ts

@@ -1,4 +1,4 @@
-import { ToolNode } from '../types/Flows.types';
+import { NodeType, ToolNode } from '../types/Flows.types';
 import { Tool } from '../types/Tools.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
@@ -10,7 +10,6 @@ import { Agent } from '../agent';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
-import { HistoryStepType } from '../types/Agent.types';
 
 export const addToolNode = async ({
   graph,
@@ -60,7 +59,7 @@ export const addToolNode = async ({
     return {
       messages: [AIToolCallMessage],
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.CUSTOM_ACTION_NODE,
+        type: NodeType.TOOL,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: AIToolCallMessage.tool_calls?.[0] || '',

package/src/nodes/addToolRunNode.ts

@@ -2,7 +2,7 @@ import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { RunnableLike } from '@langchain/core/runnables';
 import { Tool } from '../types/Tools.types';
 import { LLMProviders } from '../types/LLM.types';
-import { internalNodesSuffix, ToolNode } from '../types/Flows.types';
+import { internalNodesSuffix, NodeType, ToolNode } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { ToolMessage } from '@langchain/core/messages';
 import { z } from 'zod';
@@ -11,7 +11,6 @@ import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
-import { HistoryStepType } from '../types/Agent.types';
 
 type AddToolRunNodeParams = {
   graph: PreCompiledGraph;
@@ -61,7 +60,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
       ...toolStateUpdate,
       messages: updatedMessages,
       history: createHistoryStep<HistoryStep>(state.history, {
-        type: HistoryStepType.CUSTOM_ACTION_NODE,
+        type: NodeType.TOOL,
         nodeId: toolNode.name,
         nodeDisplayName: toolNode.displayName,
         raw: toolCallMessage,

package/src/nodes/addTriggerNode.ts

@@ -1,8 +1,8 @@
 import { RunnableLike } from '@langchain/core/runnables';
-import { TriggerNode, TriggerType } from '../types/Flows.types';
+import { NodeType, TriggerNode, TriggerType } from '../types/Flows.types';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { logger } from '../utils/logger';
-import { HistoryStep, HistoryStepType } from '../types/Agent.types';
+import { HistoryStep } from '../types/Agent.types';
 import { createHistoryStep } from '../utils/history';
 
 export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
@@ -11,7 +11,7 @@ export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph;
     if (node.triggerType === TriggerType.MANUAL) {
       return {
         history: createHistoryStep<HistoryStep>(state.history, {
-          type: HistoryStepType.TRIGGER_NODE,
+          type: NodeType.TRIGGER,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
           raw: '',

package/src/nodes/nodeFactory.ts

@@ -1,5 +1,4 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { JunctionNode, Node, NodeType } from '../types/Flows.types';
+import { Node, NodeType } from '../types/Flows.types';
 import { PreCompiledGraph } from '../types/LangGraph.types';
 import { Tool } from '../types/Tools.types';
 import { addToolNode } from './addToolNode';
@@ -11,11 +10,7 @@ import { addTriggerNode } from './addTriggerNode';
 import { LLMProviders } from '../types/LLM.types';
 import { Agent } from '../agent';
 import { addJumpToNode } from './addJumpToNode';
-
-const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
-  const callback: RunnableLike = async () => { };
-  graph.addNode(node.name, callback);
-};
+import { addJunctionNode } from './addJunctionNode';
 
 export const nodeFactory = ({
   graph,

package/src/platform/mindedConnectionTypes.ts

@@ -32,6 +32,15 @@ export enum MindedConnectionSocketMessageType {
   TIMER_RESET = 'timer-reset',
   TIMER_CANCEL = 'timer-cancel',
   TIMER_TRIGGER = 'timer-trigger',
+  // Interrupt Session Management
+  INTERRUPT_SESSION_IS_PROCESSED = 'interrupt-session-is-processed',
+  INTERRUPT_SESSION_LOCK = 'interrupt-session-lock',
+  INTERRUPT_SESSION_RELEASE = 'interrupt-session-release',
+  INTERRUPT_SESSION_ENQUEUE = 'interrupt-session-enqueue',
+  INTERRUPT_SESSION_DEQUEUE_ALL = 'interrupt-session-dequeue-all',
+  INTERRUPT_SESSION_DEQUEUE = 'interrupt-session-dequeue',
+  INTERRUPT_SESSION_HAS_MESSAGES = 'interrupt-session-has-messages',
+  INTERRUPT_SESSION_GET_MESSAGES = 'interrupt-session-get-messages',
 }
 
 export type MindedConnectionSocketMessageTypeMap = {
@@ -55,6 +64,15 @@ export type MindedConnectionSocketMessageTypeMap = {
   [MindedConnectionSocketMessageType.TIMER_RESET]: TimerResetRequest;
   [MindedConnectionSocketMessageType.TIMER_CANCEL]: TimerCancelRequest;
   [MindedConnectionSocketMessageType.TIMER_TRIGGER]: TimerTriggerRequest;
+  // Interrupt Session Management
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED]: InterruptSessionIsProcessedRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK]: InterruptSessionLockRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE]: InterruptSessionReleaseRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE]: InterruptSessionEnqueueRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL]: InterruptSessionDequeueAllRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE]: InterruptSessionDequeueRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES]: InterruptSessionHasMessagesRequest;
+  [MindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES]: InterruptSessionGetMessagesRequest;
 };
 
 export interface BaseMindedConnectionSocketMessage {
@@ -178,3 +196,85 @@ export interface TimerTriggerRequest extends BaseMindedConnectionSocketMessage {
   timerName: string;
   eventArgs: Record<string, any>;
 }
+
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionLockResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionReleaseRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+  message: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  };
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface InterruptSessionDequeueRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  } | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}