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

package/src/platform/mindedConnection.ts

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

package/src/platform/mindedConnectionTypes.ts

@@ -42,6 +42,15 @@ export enum mindedConnectionSocketMessageType {
   SDK_VERSION_MISMATCH = 'sdk-version-mismatch', // Browser Task
   CREATE_BROWSER_SESSION = 'create-browser-session',
   INVOKE_BROWSER_TASK = 'invoke-browser-task',
+  // 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 = {
@@ -73,6 +82,15 @@ export type mindedConnectionSocketMessageTypeMap = {
   [mindedConnectionSocketMessageType.UPDATE_STATE]: UpdateStateRequest;
   [mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION]: CreateBrowserSessionRequest;
   [mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK]: InvokeBrowserTaskRequest;
+  // 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 {
@@ -206,6 +224,175 @@ 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;
+}
+
+export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
 export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
   sessionId: string;
   checkpointId: string;

package/src/playbooks/playbooks.ts

@@ -1,7 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
-import * as ejs from 'ejs';
 import * as mindedConnection from '../platform/mindedConnection';
 import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
 import { getConfig } from '../platform/config';
@@ -14,6 +13,26 @@ export type Playbook = {
   blocks: OutputBlockData[];
 };
 
+/**
+ * Decode HTML entities in a string
+ */
+function decodeHtmlEntities(text: string): string {
+  const entities: Record<string, string> = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+    '&apos;': "'",
+    '&#x27;': "'",
+    '&#x2F;': '/',
+    '&#x60;': '`',
+    '&#x3D;': '=',
+  };
+
+  return text.replace(/&[#\w]+;/g, (entity) => entities[entity] || entity);
+}
+
 /**
  * Convert EditorJS blocks to markdown
  */
@@ -29,11 +48,13 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
           case 'header': {
             const level = block.data?.level || 1;
             const headerPrefix = '#'.repeat(level);
-            return `${headerPrefix} ${block.data?.text || ''}`;
+            const text = block.data?.text || '';
+            return `${headerPrefix} ${decodeHtmlEntities(text)}`;
           }
 
           case 'paragraph': {
-            return block.data?.text || '';
+            const text = block.data?.text || '';
+            return decodeHtmlEntities(text);
           }
 
           case 'list': {
@@ -41,10 +62,11 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
             const style = block.data?.style || 'unordered';
             return items
               .map((item: string, index: number) => {
+                const decodedItem = decodeHtmlEntities(item);
                 if (style === 'ordered') {
-                  return `${index + 1}. ${item}`;
+                  return `${index + 1}. ${decodedItem}`;
                 } else {
-                  return `- ${item}`;
+                  return `- ${decodedItem}`;
                 }
               })
               .join('\n');
@@ -52,13 +74,13 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
 
           case 'quote': {
             const text = block.data?.text || '';
-            const caption = block.data?.caption ? `\n*${block.data.caption}*` : '';
-            return `> ${text}${caption}`;
+            const caption = block.data?.caption ? `\n*${decodeHtmlEntities(block.data.caption)}*` : '';
+            return `> ${decodeHtmlEntities(text)}${caption}`;
           }
 
           case 'code': {
             const code = block.data?.code || '';
-            return `\`\`\`\n${code}\n\`\`\``;
+            return `\`\`\`\n${decodeHtmlEntities(code)}\n\`\`\``;
           }
 
           case 'delimiter': {
@@ -71,7 +93,7 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
           }
         }
       } catch (error) {
-        logger.error({ message: 'Error converting EditorJS blocks to markdown', error, block });
+        logger.error({ msg: 'Error converting EditorJS blocks to markdown', error, block });
         throw error;
       }
     })
@@ -113,7 +135,7 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
   for (const directory of directories) {
     if (!fs.existsSync(directory)) {
-      logger.info(`Playbooks directory does not exist: ${directory}`);
+      logger.info({ msg: `Playbooks directory does not exist: ${directory}` });
       continue;
     }
 
@@ -126,12 +148,12 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
         if (playbook && playbook.name && playbook.blocks) {
           playbooks.push(playbook);
-          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
+          logger.info({ msg: `Loaded playbook: ${playbook.name} from ${file}` });
         } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
+          logger.warn({ msg: `Invalid playbook structure in ${file}` });
         }
       } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
+        logger.error({ msg: `Failed to load playbook file ${file}: ${error}` });
       }
     }
   }
@@ -159,9 +181,9 @@ function getAllYamlFiles(dir: string): string[] {
 }
 
 /**
- * Compile playbooks into a single string with EJS and placeholders
+ * Combine playbooks into a single string
  */
-export function compilePlaybooks(playbooks: Playbook[], params: Record<string, any> = {}): string {
+export function combinePlaybooks(playbooks: Playbook[]): string {
   if (playbooks.length === 0) {
     return '';
   }
@@ -173,37 +195,5 @@ export function compilePlaybooks(playbooks: Playbook[], params: Record<string, a
   });
 
   const combinedPlaybooks = sections.join('\n\n');
-
-  try {
-    // First, render with EJS
-    let compiledPlaybooks = ejs.render(combinedPlaybooks, params);
-
-    // Then, replace placeholders in {} format
-    compiledPlaybooks = replacePlaceholders(compiledPlaybooks, params);
-
-    return compiledPlaybooks;
-  } catch (error) {
-    logger.error({ message: 'Error compiling playbooks', error });
-    return combinedPlaybooks; // Return uncompiled if there's an error
-  }
-}
-
-/**
- * Replace placeholders in {key} format
- */
-function replacePlaceholders(text: string, params: Record<string, any>): string {
-  return text.replace(/\{([^}]+)\}/g, (match, key) => {
-    const keys = key.split('.');
-    let value: any = params;
-
-    for (const k of keys) {
-      if (value && typeof value === 'object' && k in value) {
-        value = value[k];
-      } else {
-        return match; // Return original if key not found
-      }
-    }
-
-    return String(value);
-  });
+  return combinedPlaybooks;
 }

package/src/types/Agent.types.ts

@@ -29,6 +29,8 @@ 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/LangGraph.types.ts

@@ -30,7 +30,9 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => [],
       reducer: (a, b) => a.concat(b),
     }),
-    sessionId: Annotation<string>(),
+    sessionId: Annotation<string>({
+      reducer: (a, b) => b || a,
+    }),
     goto: Annotation<string | null | undefined>({
       default: () => null,
       reducer: (a, b) => b,

package/src/voice/voiceSession.ts

@@ -8,6 +8,7 @@ import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
 import { v4 as uuidv4 } from 'uuid';
 import { logger } from '../utils/logger';
 import { SessionType } from '../types/Agent.types';
+import { QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH } from '../interrupts/BaseInterruptSessionManager';
 
 /**
  * Voice Conversation class for managing individual ElevenLabs voice conversations
@@ -157,6 +158,12 @@ export class VoiceSession {
           break;
         case 'interruption':
           logger.debug({ msg: '[Voice] Received interruption' });
+          if (await this.agent.interruptSessionManager.isProcessed(this.sessionId)) {
+            await this.agent.interruptSessionManager.enqueueMessage(this.sessionId, {
+              triggerBody: {},
+              triggerName: QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH,
+            });
+          }
           this.onInterruptionCallback?.();
           // Send interruption event to dashboard if connected
           if (getConfig().dashboardConnected) {
@@ -225,9 +232,10 @@ export class VoiceSession {
   }
 
   private async updateAgentResponse(originalAgentResponse: string, correctedAgentResponse: string): Promise<void> {
+    const cleanedOriginalAgentResponse = originalAgentResponse.replace('... ', '');
     const graphState = await this.agent.compiledGraph.getState(this.agent.getLangraphConfig(this.sessionId));
     const agentMessage: AIMessage | null = graphState.values.messages.find(
-      (message: BaseMessage) => message.content === originalAgentResponse && message instanceof AIMessage,
+      (message: BaseMessage) => message.content === cleanedOriginalAgentResponse && message instanceof AIMessage,
     );
     if (agentMessage) {
       agentMessage.content = correctedAgentResponse;
@@ -252,19 +260,6 @@ export class VoiceSession {
     this.elevenLabsSocket?.close();
   }
 
-  /* 
-   * Escalate the voice session
-   * @param parameters - The parameters to escalate the voice session. Parameters will be handeled differently according to the VOIP provider.
-   */
-  public escalate(parameters: any): void {
-    mindedConnection.emit(mindedConnectionSocketMessageType.VOICE_ESCALATE, {
-      type: mindedConnectionSocketMessageType.VOICE_ESCALATE,
-      sessionId: this.sessionId,
-      timestamp: Date.now(),
-      parameters,
-    });
-  }
-
   /*
    * Set callback for audio data in base64 format
    * @param callback - The callback to handle the audio data