@minded-ai/mindedjs 1.0.95-beta-3 → 1.0.96-beta-1

package/src/platform/mindedConnectionTypes.ts

@@ -33,15 +33,6 @@ 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 = {
@@ -66,15 +57,6 @@ export type mindedConnectionSocketMessageTypeMap = {
   [mindedConnectionSocketMessageType.TIMER_CANCEL]: TimerCancelRequest;
   [mindedConnectionSocketMessageType.TIMER_TRIGGER]: TimerTriggerRequest;
   [mindedConnectionSocketMessageType.RESTORE_CHECKPOINT]: RestoreCheckpointRequest;
-  // 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 {
@@ -199,166 +181,6 @@ export interface TimerTriggerRequest extends BasemindedConnectionSocketMessage {
   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 {
-  lockAcquired?: 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;
-  }>;
-}
-
-// 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 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;
-  }>;
-}
-
 export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
   sessionId: string;
   checkpointId: string;
@@ -366,13 +188,4 @@ export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMess
 
 export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
   success?: boolean;
-}
-
-export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  checkpointId: string;
-}
-
-export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  success?: boolean;
-}
+}

package/src/playbooks/playbooks.ts

@@ -113,7 +113,7 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
   for (const directory of directories) {
     if (!fs.existsSync(directory)) {
-      logger.info({ message: `Playbooks directory does not exist: ${directory}` });
+      logger.info(`Playbooks directory does not exist: ${directory}`);
       continue;
     }
 
@@ -126,12 +126,12 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
         if (playbook && playbook.name && playbook.blocks) {
           playbooks.push(playbook);
-          logger.info({ message: `Loaded playbook: ${playbook.name} from ${file}` });
+          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
         } else {
-          logger.warn({ message: `Invalid playbook structure in ${file}` });
+          logger.warn(`Invalid playbook structure in ${file}`);
         }
       } catch (error) {
-        logger.error({ message: `Failed to load playbook file ${file}: ${error}` });
+        logger.error(`Failed to load playbook file ${file}: ${error}`);
       }
     }
   }

package/src/types/Agent.types.ts

@@ -29,8 +29,6 @@ export interface AgentInvokeParams {
   sessionId?: string;
   /** Optional name of the application triggering the agent in case of an app trigger */
   appName?: string;
-  /** Internal flag to bypass session processing check for recursive calls */
-  bypassSessionCheck?: boolean;
 }
 export interface HistoryStep {
   type: NodeType;

package/src/types/Flows.types.ts

@@ -11,6 +11,7 @@ export enum NodeType {
   APP_TOOL = 'appTool',
   PROMPT_NODE = 'promptNode',
   JUMP_TO_NODE = 'jumpToNode',
+  BROWSER_TASK = 'browserTask',
 }
 
 export enum EdgeType {

package/src/types/LangGraph.types.ts

@@ -29,13 +29,15 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => [],
       reducer: (a, b) => a.concat(b),
     }),
-    sessionId: Annotation<string>({
-      reducer: (a, b) => b || a,
-    }),
+    sessionId: Annotation<string>(),
     sessionType: Annotation<SessionType>({
       default: () => SessionType.TEXT,
       reducer: (a, b) => b || a,
     }),
+    overrideStartFromNodeId: Annotation<string | null>({
+      default: () => null,
+      reducer: (a, b) => b,
+    }),
   });
 
 // Default state annotation with any memory type

package/src/utils/logger.ts

@@ -12,7 +12,6 @@ export const logger = pino({
       colorize: true,
       crlf: true,
       translateTime: 'SYS:standard',
-      messageKey: 'message', // Use 'message' instead of default 'msg'
     },
   },
   formatters: {

package/src/voice/voiceSession.ts

@@ -235,13 +235,10 @@ export class VoiceSession {
       agentMessage.additional_kwargs = agentMessage.additional_kwargs || {};
       agentMessage.additional_kwargs.update = true;
       const currentNodeId = graphState.tasks[graphState.tasks.length - 1].name;
-      await this.agent.compiledGraph.updateState(
-        this.agent.getLangraphConfig(this.sessionId),
-        {
-          messages: [agentMessage],
-        },
-        currentNodeId,
-      );
+      await this.agent.compiledGraph.updateState(graphState.config, {
+        messages: [agentMessage],
+        overrideStartFromNodeId: currentNodeId,
+      });
     } else {
       logger.warn({ message: 'Agent message not found for correction', sessionId: this.sessionId, originalAgentResponse });
     }

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -1,94 +0,0 @@
-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 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({ message: '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

@@ -1,57 +0,0 @@
-import { BaseInterruptSessionManager, QueuedMessage } 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.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

@@ -1,155 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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({ 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();
-  }
-}