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

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,
@@ -31,7 +30,7 @@ export const addToolNode = async ({
     throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${toolNode.displayName}`);
+    logger.info({ message: `Executing tool node ${toolNode.displayName}` });
 
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,
@@ -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,17 +1,17 @@
 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 }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing trigger node ${node.displayName}`);
+    logger.info({ message: `Executing trigger node ${node.displayName}` });
     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/mindedConnection.ts

@@ -34,7 +34,7 @@ export class MindedConnection {
     }
   };
 
-  public awaitEmit = async <T, R>(event: MindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
+  public awaitEmit = async <T, R>(event: MindedConnectionSocketMessageType, message: T, timeoutMs: number = 10000): Promise<R> => {
     if (!this.socket) {
       throw new Error('Socket is not connected');
     }
@@ -75,43 +75,43 @@ export class MindedConnection {
 
       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({ message: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+          logger.info({ message: '\x1b[32mPress Ctrl+C to exit...' });
           resolve();
         }
       };
 
       // Connection event handlers
       this.socket.on('connect', () => {
-        logger.info('Socket connected, waiting for server setup...');
+        logger.info({ message: 'Socket connected, waiting for server setup...' });
         connected = true;
         checkReady();
       });
 
       // Listen for ready event from server
       this.socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-        logger.info('Server ready signal received', data);
+        logger.info({ message: 'Server ready signal received', data });
         ready = true;
         checkReady();
       });
 
       this.socket.on('connect_error', () => {
-        logger.error('Failed to connect to minded platform');
+        logger.error({ message: 'Failed to connect to minded platform' });
         reject(new Error('Failed to connect to minded platform'));
       });
 
       this.socket.on('disconnect', () => {
-        logger.info('Disconnected from local debugging socket');
+        logger.info({ message: 'Disconnected from local debugging socket' });
         connected = false;
         ready = false;
       });
 
       // Listen for error messages from the server
       this.socket.on('error', async (error: { message: string }) => {
-        logger.error({ msg: 'Server error:', error });
+        logger.error({ message: 'Server error:', error });
 
         if (error.message.includes('Invalid token')) {
-          logger.info('Invalid token');
+          logger.info({ message: 'Invalid token' });
 
           // Disconnect current socket
           if (this.socket?.connected) {
@@ -137,7 +137,7 @@ export class MindedConnection {
       // Handle process termination
       process.on('SIGINT', () => {
         if (this.socket?.connected) {
-          logger.info('\nDisconnecting...');
+          logger.info({ message: '\nDisconnecting...' });
           this.socket.disconnect();
         }
         process.exit(0);
@@ -155,16 +155,16 @@ export class MindedConnection {
 
   public disconnect() {
     if (!this.socket) {
-      logger.warn('No socket connection to disconnect');
+      logger.warn({ message: 'No socket connection to disconnect' });
       return;
     }
 
     if (this.socket.connected) {
-      logger.info('Disconnecting from Minded platform...');
+      logger.info({ message: 'Disconnecting from Minded platform...' });
       this.socket.disconnect();
       return;
     }
 
-    logger.warn('Socket is already disconnected');
+    logger.warn({ message: 'Socket is already disconnected' });
   }
 }

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;
+  }>;
+}

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(`Playbooks directory does not exist: ${directory}`);
+      logger.info({ message: `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(`Loaded playbook: ${playbook.name} from ${file}`);
+          logger.info({ message: `Loaded playbook: ${playbook.name} from ${file}` });
         } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
+          logger.warn({ message: `Invalid playbook structure in ${file}` });
         }
       } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
+        logger.error({ message: `Failed to load playbook file ${file}: ${error}` });
       }
     }
   }

package/src/types/Agent.types.ts

@@ -1,5 +1,6 @@
 import { AgentEventRequestPayloads, AgentEventResponsePayloads } from '../events/AgentEvents';
 import { LLMConfig } from './LLM.types';
+import { NodeType } from './Flows.types';
 
 export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (
   event: E,
@@ -28,19 +29,11 @@ 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 enum HistoryStepType {
-  APP_TRIGGER_NODE = 'appTriggerNode',
-  TRIGGER_NODE = 'triggerNode',
-  APP_ACTION_NODE = 'appActionNode',
-  CUSTOM_ACTION_NODE = 'customActionNode',
-  PROMPT_NODE = 'promptNode',
-  JUMP_TO_NODE = 'jumpToNode',
-}
-
 export interface HistoryStep {
-  type: HistoryStepType;
+  type: NodeType;
   step: number;
   raw: any;
   nodeId: string;
@@ -49,21 +42,25 @@ export interface HistoryStep {
 }
 
 export interface AppTriggerHistoryStep extends HistoryStep {
-  type: HistoryStepType.APP_TRIGGER_NODE;
+  type: NodeType.TRIGGER;
   appName: string;
 }
 
 export interface TriggerHistoryStep extends HistoryStep {
-  type: HistoryStepType.TRIGGER_NODE;
+  type: NodeType.TRIGGER;
 }
 
 export interface AppActionInvocationHistoryStep extends HistoryStep {
-  type: HistoryStepType.APP_ACTION_NODE;
+  type: NodeType.APP_TOOL;
   appName: string;
 }
 
 export interface CustomActionInvocationHistoryStep extends HistoryStep {
-  type: HistoryStepType.CUSTOM_ACTION_NODE;
+  type: NodeType.TOOL;
+}
+
+export interface JunctionHistoryStep extends HistoryStep {
+  type: NodeType.JUNCTION;
 }
 
 export enum SessionType {

package/src/types/LangGraph.types.ts

@@ -29,7 +29,9 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => [],
       reducer: (a, b) => a.concat(b),
     }),
-    sessionId: Annotation<string>(),
+    sessionId: Annotation<string>({
+      reducer: (a, b) => b || a,
+    }),
     sessionType: Annotation<SessionType>({
       default: () => SessionType.TEXT,
       reducer: (a, b) => b || a,

package/src/utils/logger.ts

@@ -12,6 +12,7 @@ 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

@@ -99,10 +99,10 @@ export class VoiceSession {
           },
           ...(this.voiceId
             ? {
-              tts: {
-                voice_id: this.voiceId,
-              },
-            }
+                tts: {
+                  voice_id: this.voiceId,
+                },
+              }
             : {}),
         } as ConversationInitiationClientData['conversation_config_override'],
       };
@@ -134,7 +134,11 @@ export class VoiceSession {
           }, data.ping_event.ping_ms);
           break;
         case 'user_transcript':
-          logger.debug({ message: 'User transcript received', sessionId: this.sessionId, data: data.user_transcription_event.user_transcript });
+          logger.debug({
+            message: 'User transcript received',
+            sessionId: this.sessionId,
+            data: data.user_transcription_event.user_transcript,
+          });
           if (this.onMessageCallback) {
             this.onMessageCallback(
               data.user_transcription_event.user_transcript,
@@ -189,7 +193,11 @@ export class VoiceSession {
           break;
         case 'agent_response_correction':
           try {
-            logger.debug({ message: 'Agent response correction received', sessionId: this.sessionId, data: data.agent_response_correction_event });
+            logger.debug({
+              message: 'Agent response correction received',
+              sessionId: this.sessionId,
+              data: data.agent_response_correction_event,
+            });
             await this.updateAgentResponse(
               data.agent_response_correction_event.original_agent_response,
               data.agent_response_correction_event.corrected_agent_response,