@minded-ai/mindedjs 1.0.95-beta-2 → 1.0.95

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -1,79 +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 {
-  lock(sessionId: string): void | Promise<void>;
-  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>;
-  tryLock(sessionId: string): boolean | Promise<boolean>;
-}
-
-export abstract class BaseInterruptSessionManager implements InterruptSessionManager {
-  // Abstract methods that subclasses must implement for queue management
-  abstract lock(sessionId: string): void | Promise<void>;
-  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 tryLock(sessionId: string): boolean | Promise<boolean>;
-
-  // 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();
-
-  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;
-  }
-
-  tryLock(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
-  }
-
-  // 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,172 +0,0 @@
-import { BaseInterruptSessionManager, QueuedMessage } from './BaseInterruptSessionManager';
-import * as mindedConnection from '../platform/mindedConnection';
-import {
-  mindedConnectionSocketMessageType,
-  InterruptSessionIsProcessedRequest,
-  InterruptSessionIsProcessedResponse,
-  InterruptSessionLockRequest,
-  InterruptSessionLockResponse,
-  InterruptSessionTryLockRequest,
-  InterruptSessionTryLockResponse,
-  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;
-    }
-  }
-
-  async tryLock(sessionId: string): Promise<boolean> {
-    try {
-      const response = await mindedConnection.awaitEmit<InterruptSessionTryLockRequest, InterruptSessionTryLockResponse>(
-        mindedConnectionSocketMessageType.INTERRUPT_SESSION_TRY_LOCK,
-        {
-          type: mindedConnectionSocketMessageType.INTERRUPT_SESSION_TRY_LOCK,
-          sessionId,
-        },
-      );
-      return response.lockAcquired ?? false;
-    } catch (error) {
-      console.error('Error trying to lock session:', error);
-      return false;
-    }
-  }
-
-  // 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();
-  }
-}