@minded-ai/mindedjs 1.0.93 → 1.0.95-beta-1

package/dist/types/LangGraph.types.js

@@ -31,7 +31,9 @@ const createStateAnnotation = () => langgraph_1.Annotation.Root({
         default: () => [],
         reducer: (a, b) => a.concat(b),
     }),
-    sessionId: (0, langgraph_1.Annotation)(),
+    sessionId: (0, langgraph_1.Annotation)({
+        reducer: (a, b) => b || a,
+    }),
     sessionType: (0, langgraph_1.Annotation)({
         default: () => Agent_types_1.SessionType.TEXT,
         reducer: (a, b) => b || a,

package/dist/types/LangGraph.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"LangGraph.types.js","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":";;;AACA,oDAAkF;AAClF,+CAAyD;AAElD,MAAM,qBAAqB,GAAG,GAAiB,EAAE,CACtD,sBAAU,CAAC,IAAI,CAAC;IACd,QAAQ,EAAE,IAAA,sBAAU,EAAqB;QACvC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,EAAE;;YACrC,MAAM,GAAG,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;YAC9B,KAAK,MAAM,OAAO,IAAI,WAAW,EAAE,CAAC;gBAClC,IAAI,MAAA,OAAO,CAAC,iBAAiB,0CAAE,MAAM,EAAE,CAAC;oBACtC,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC;oBAChE,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;wBACjB,GAAG,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;oBACvC,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACpB,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;KACF,CAAC;IACF,MAAM,EAAE,IAAA,sBAAU,EAAS;QACzB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAa,CAAA;QAC7B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,OAAO,EAAE,IAAA,sBAAU,EAAqB;QACtC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,SAAS,EAAE,IAAA,sBAAU,GAAU;IAC/B,WAAW,EAAE,IAAA,sBAAU,EAAc;QACnC,OAAO,EAAE,GAAG,EAAE,CAAC,yBAAW,CAAC,IAAI;QAC/B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;KAC1B,CAAC;CACH,CAAC,CAAC;AAhCQ,QAAA,qBAAqB,yBAgC7B;AAEL,gDAAgD;AACnC,QAAA,eAAe,GAAG,IAAA,6BAAqB,GAAE,CAAC"}
+{"version":3,"file":"LangGraph.types.js","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":";;;AACA,oDAAkF;AAClF,+CAAyD;AAElD,MAAM,qBAAqB,GAAG,GAAiB,EAAE,CACtD,sBAAU,CAAC,IAAI,CAAC;IACd,QAAQ,EAAE,IAAA,sBAAU,EAAqB;QACvC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,EAAE;;YACrC,MAAM,GAAG,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;YAC9B,KAAK,MAAM,OAAO,IAAI,WAAW,EAAE,CAAC;gBAClC,IAAI,MAAA,OAAO,CAAC,iBAAiB,0CAAE,MAAM,EAAE,CAAC;oBACtC,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC;oBAChE,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;wBACjB,GAAG,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;oBACvC,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACpB,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;KACF,CAAC;IACF,MAAM,EAAE,IAAA,sBAAU,EAAS;QACzB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAa,CAAA;QAC7B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,OAAO,EAAE,IAAA,sBAAU,EAAqB;QACtC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,SAAS,EAAE,IAAA,sBAAU,EAAS;QAC5B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;KAC1B,CAAC;IACF,WAAW,EAAE,IAAA,sBAAU,EAAc;QACnC,OAAO,EAAE,GAAG,EAAE,CAAC,yBAAW,CAAC,IAAI;QAC/B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;KAC1B,CAAC;CACH,CAAC,CAAC;AAlCQ,QAAA,qBAAqB,yBAkC7B;AAEL,gDAAgD;AACnC,QAAA,eAAe,GAAG,IAAA,6BAAqB,GAAE,CAAC"}

package/dist/utils/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,uCAgBjB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,uCAiBjB,CAAC"}

package/dist/utils/logger.js

@@ -17,6 +17,7 @@ exports.logger = (0, pino_1.default)({
             colorize: true,
             crlf: true,
             translateTime: 'SYS:standard',
+            messageKey: 'message', // Use 'message' instead of default 'msg'
         },
     },
     formatters: {

package/dist/utils/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AACxB,oDAA4B;AAC5B,gBAAM,CAAC,MAAM,EAAE,CAAC;AAEhB,gDAAgD;AACnC,QAAA,MAAM,GAAG,IAAA,cAAI,EAAC;IACzB,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,MAAM;IACtC,IAAI,EAAE,IAAI;IACV,SAAS,EAAE;QACT,MAAM,EAAE,aAAa;QACrB,OAAO,EAAE;YACP,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,aAAa,EAAE,cAAc;SAC9B;KACF;IACD,UAAU,EAAE;QACV,KAAK,CAAC,KAAK;YACT,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAC1B,CAAC;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AACxB,oDAA4B;AAC5B,gBAAM,CAAC,MAAM,EAAE,CAAC;AAEhB,gDAAgD;AACnC,QAAA,MAAM,GAAG,IAAA,cAAI,EAAC;IACzB,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,MAAM;IACtC,IAAI,EAAE,IAAI;IACV,SAAS,EAAE;QACT,MAAM,EAAE,aAAa;QACrB,OAAO,EAAE;YACP,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,aAAa,EAAE,cAAc;YAC7B,UAAU,EAAE,SAAS,EAAE,yCAAyC;SACjE;KACF;IACD,UAAU,EAAE;QACV,KAAK,CAAC,KAAK;YACT,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAC1B,CAAC;KACF;CACF,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minded-ai/mindedjs",
-  "version": "1.0.93",
+  "version": "1.0.95-beta-1",
   "description": "MindedJS is a TypeScript library for building agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -65,4 +65,4 @@
     "uuid": "^11.1.0",
     "ws": "^8.15.1"
   }
-}
+}

package/src/agent.ts

@@ -11,10 +11,7 @@ import { edgeFactory } from './edges/edgeFactory';
 import { AgentEventRequestPayloads, AgentEventResponsePayloads, AgentEvents } from './events/AgentEvents';
 import { z } from 'zod';
 import * as mindedConnection from './platform/mindedConnection';
-import {
-  InvokeMessage,
-  mindedConnectionSocketMessageType,
-} from './platform/mindedConnectionTypes';
+import { InvokeMessage, mindedConnectionSocketMessageType } from './platform/mindedConnectionTypes';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
@@ -29,6 +26,8 @@ import {
 import { createLlmInstance } from './llm/createLlmInstance';
 import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
+import { InterruptSessionManager, InterruptType } from './interrupts/InterruptSessionManager.types';
+import { createInterruptSessionManager } from './interrupts/interruptSessionManagerFactory';
 import { BaseMessage, HumanMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
@@ -46,6 +45,7 @@ type CreateAgentParams<Memory> = {
   tools: Tool<any, Memory>[];
   platformToken?: string;
   memorySaver?: BaseCheckpointSaver;
+  interruptSessionManager?: InterruptSessionManager;
 };
 
 /**
@@ -78,6 +78,8 @@ export class Agent {
 
   // Langgraph memory saver. In memory for local development, Custom for Platform
   private checkpointer!: BaseCheckpointSaver;
+  // Interrupt session manager. In memory for local development, Custom for Platform
+  public interruptSessionManager!: InterruptSessionManager;
   // Langgraph compiled graph
   public compiledGraph!: CompiledGraph;
   // Cache for secrets to avoid repeated API calls
@@ -148,13 +150,14 @@ export class Agent {
 
   private async init(params: CreateAgentParams<z.infer<typeof this.memorySchema>>): Promise<void> {
     try {
-      const { config, tools, memorySaver } = params;
+      const { config, tools, memorySaver, interruptSessionManager } = params;
       const { runLocally } = getConfig();
       if (!runLocally) {
         await mindedConnection.start();
 
         // Initialize PII gateway
         this._piiGateway = new PIIGateway();
+
         mindedConnection.on(mindedConnectionSocketMessageType.INVOKE, async (message, callback) => {
           const invokeMessage = message as InvokeMessage;
           const result = await this.invoke({
@@ -165,13 +168,14 @@ export class Agent {
           });
           callback(result);
         });
+
+        mindedConnection.on(mindedConnectionSocketMessageType.RESTORE_CHECKPOINT, async (restoreCheckpointMessage, callback) => {
+          await this.restoreCheckpoint(restoreCheckpointMessage.sessionId, restoreCheckpointMessage.checkpointId);
+          callback({ success: true });
+        });
       }
 
-      const [, flows, playbooks] = await Promise.all([
-        this.loadSecrets(),
-        this.loadFlows(config.flows),
-        loadPlaybooks(config.playbooks),
-      ]);
+      const [, flows, playbooks] = await Promise.all([this.loadSecrets(), this.loadFlows(config.flows), loadPlaybooks(config.playbooks)]);
 
       this.playbooks = playbooks;
       this.flows = flows;
@@ -179,6 +183,7 @@ export class Agent {
       const appActionsRunnerTools = this.initAppActionsRunnerTools();
       this.tools = [...tools, ...appActionsRunnerTools];
       this.checkpointer = memorySaver || createCheckpointSaver();
+      this.interruptSessionManager = interruptSessionManager || createInterruptSessionManager();
 
       // call here methods that needs environment variables to be loaded
       this.llm = createLlmInstance(config.llm);
@@ -407,10 +412,26 @@ export class Agent {
    * });
    * ```
    */
-  public async invoke({ triggerBody, triggerName, sessionId, appName }: AgentInvokeParams) {
+  public async invoke({ triggerBody, triggerName, sessionId, appName, bypassSessionCheck }: AgentInvokeParams): Promise<any> {
     sessionId = sessionId ?? uuidv4();
     try {
       await this.waitForInitialization();
+
+      // Check if session is already being processed (unless bypassing)
+      if (!bypassSessionCheck && (await this.interruptSessionManager.isProcessed(sessionId))) {
+        // Enqueue the raw message and return
+        logger.info({ message: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
+        await this.interruptSessionManager.enqueueMessage(sessionId, {
+          triggerBody,
+          triggerName,
+          appName,
+        });
+        return;
+      }
+
+      // Lock the session for processing
+      await this.interruptSessionManager.lock(sessionId);
+
       let messages: Array<BaseMessage> = [];
       let memoryUpdate = {};
       let sessionType: SessionType = SessionType.TEXT;
@@ -438,7 +459,8 @@ export class Agent {
           const handlerResult = results.find((r) => r !== undefined);
           if (handlerResult) {
             if (!handlerResult.isQualified) {
-              logger.info(`Trigger ${triggerName} was disqualified`);
+              logger.info({ message: `Trigger ${triggerName} was disqualified` });
+              await this.interruptSessionManager.release(sessionId);
               return;
             }
             memoryUpdate = handlerResult.memory || {};
@@ -465,22 +487,95 @@ export class Agent {
 
       let res;
       // Resume interruption
-      if (state.tasks?.[0]?.interrupts?.length > 0) {
-        res = await this.compiledGraph.invoke(
-          new Command({
-            resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType },
-          }),
-          langraphConfig,
-        );
+      if (state.tasks && state.tasks.length > 0) {
+        const lastTask = state.tasks[state.tasks.length - 1];
+        if (lastTask?.interrupts?.length > 0) {
+          const interrupt = lastTask.interrupts[0];
+          const interruptValue = (interrupt as any).value;
+
+          if (interruptValue?.type === InterruptType.HUMAN_IN_THE_LOOP) {
+            // For HUMAN_IN_THE_LOOP, use resume with the full object
+            res = await this.compiledGraph.invoke(
+              new Command({
+                resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType },
+              }),
+              langraphConfig,
+            );
+          } else if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
+            // For NEW_TRIGGERS, check if there's an updateStateObject to apply first
+            const finalState = { memory: memoryUpdate, messages, history: [historyStep], sessionId, sessionType };
+            if (interruptValue.updateStateObject) {
+              finalState.messages = [...interruptValue.updateStateObject.messages, ...messages];
+              finalState.history = [...(interruptValue.updateStateObject.history || []), historyStep];
+              //add handlers for other state fields as needed
+            }
+
+            // Then use update with the full object and empty resume
+            res = await this.compiledGraph.invoke(
+              new Command({
+                update: finalState,
+                resume: '',
+              }),
+              langraphConfig,
+            );
+          }
+        } else {
+          res = await this.compiledGraph.invoke(
+            { messages, memory: memoryUpdate, history: historyStep, sessionId, sessionType },
+            langraphConfig,
+          );
+        }
       } else {
         res = await this.compiledGraph.invoke(
           { messages, memory: memoryUpdate, history: historyStep, sessionId, sessionType },
           langraphConfig,
         );
       }
+
+      // Check if graph was interrupted with NEW_TRIGGERS flag
+      const finalState = await this.compiledGraph.getState(langraphConfig);
+      if (finalState.tasks && finalState.tasks.length > 0) {
+        const lastTask = finalState.tasks[finalState.tasks.length - 1];
+        if (lastTask?.interrupts?.length > 0) {
+          const interrupt = lastTask.interrupts[0];
+          const interruptValue = (interrupt as any).value;
+
+          if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
+            // Dequeue the first message and process it recursively
+            const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
+            if (nextMessage) {
+              // Recursively process the next message with bypass flag
+              const invokeParams: AgentInvokeParams = {
+                triggerBody: nextMessage.triggerBody,
+                triggerName: nextMessage.triggerName,
+                sessionId: sessionId,
+                bypassSessionCheck: true,
+              };
+              if (nextMessage.appName) {
+                invokeParams.appName = nextMessage.appName;
+              }
+              logger.info({ message: 'Invoking next message in the queue', invokeParams });
+              return await this.invoke(invokeParams);
+            }
+          }
+        }
+      }
+
+      // Release the session lock
+      await this.interruptSessionManager.release(sessionId);
+
       return res;
     } catch (error: any) {
-      logger.error({ message: 'Invoke error', errorMessage: error.message, sessionId });
+      logger.error({
+        message: 'Invoke error',
+        errorMessage: error.message,
+        stack: error.stack,
+        sessionId,
+      });
+
+      // Release the session lock on error
+      await this.interruptSessionManager.release(sessionId);
+
       const state = await this.compiledGraph.getState(this.getLangraphConfig(sessionId));
       this.emit(AgentEvents.ERROR, { error: error instanceof Error ? error : new Error(JSON.stringify(error)), state: state.values });
       throw error;
@@ -683,8 +778,6 @@ export class Agent {
     (this.eventHandlers[event] as Array<typeof handler>).push(handler);
   }
 
-
-
   // Internal method to emit events to the registered listeners
   private async emit<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
     event: E,
@@ -712,7 +805,7 @@ export class Agent {
     // Skip secret loading in local development
     const { runLocally } = getConfig();
     if (runLocally) {
-      logger.info('Running locally - skipping secret loading');
+      logger.info({ message: 'Running locally - skipping secret loading' });
       return {};
     }
     if (!mindedConnection.isConnected()) {
@@ -753,12 +846,12 @@ export class Agent {
     }
   }
 
-  public getLangraphConfig(sessionId: string): { configurable: { thread_id: string; recursionLimit: number } } {
-    return { configurable: { thread_id: sessionId, recursionLimit: 3 } };
+  public getLangraphConfig(sessionId: string, checkpointId?: string) {
+    return { configurable: { thread_id: sessionId, recursionLimit: 3, checkpoint_id: checkpointId } };
   }
 
   private setupVoice(): void {
-    logger.info('Setting up voice');
+    logger.info({ message: 'Setting up voice' });
     if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is required');
     }
@@ -847,4 +940,20 @@ export class Agent {
       });
     }
   }
+
+  /*
+   To be used by the Lambda wrapper to restore checkpoints
+  */
+  public async restoreCheckpoint(sessionId: string, checkpointId: string): Promise<void> {
+    logger.info({ message: 'Restoring checkpoint', sessionId, checkpointId });
+    const langraphConfig = this.getLangraphConfig(sessionId, checkpointId);
+    await this.compiledGraph.invoke(
+      new Command({
+        resume: {
+          sessionId,
+        },
+      }),
+      langraphConfig,
+    );
+  }
 }

package/src/cli/index.ts

@@ -19,7 +19,7 @@ function setToken(token: string): void {
   if (!fs.existsSync(envPath)) {
     // Create .env file with the token
     fs.writeFileSync(envPath, tokenLine + '\n');
-    logger.info(`Created ${envPath} and added token`);
+    logger.info({ message: `Created ${envPath} and added token` });
   } else {
     // Read existing .env file
     const envContent = fs.readFileSync(envPath, 'utf8');
@@ -29,12 +29,12 @@ function setToken(token: string): void {
       // Replace existing token
       const updatedContent = envContent.replace(/MINDED_CONNECTION_TOKEN=.*/, tokenLine);
       fs.writeFileSync(envPath, updatedContent);
-      logger.info(`Updated MINDED_CONNECTION_TOKEN in ${envPath}`);
+      logger.info({ message: `Updated MINDED_CONNECTION_TOKEN in ${envPath}` });
     } else {
       // Append token to existing file
       const newContent = envContent.endsWith('\n') ? envContent + tokenLine + '\n' : envContent + '\n' + tokenLine + '\n';
       fs.writeFileSync(envPath, newContent);
-      logger.info(`Added MINDED_CONNECTION_TOKEN to ${envPath}`);
+      logger.info({ message: `Added MINDED_CONNECTION_TOKEN to ${envPath}` });
     }
   }
 }
@@ -44,7 +44,7 @@ function generateLambdaHandler(): void {
 
   // Check if minded.json exists
   if (!fs.existsSync(mindedConfigPath)) {
-    logger.error('minded.json not found in the current directory');
+    logger.error({ message: 'minded.json not found in the current directory' });
     process.exit(1);
   }
 
@@ -54,14 +54,14 @@ function generateLambdaHandler(): void {
     const configContent = fs.readFileSync(mindedConfigPath, 'utf8');
     mindedConfig = JSON.parse(configContent);
   } catch (error) {
-    logger.error('Failed to read or parse minded.json:', error);
+    logger.error({ message: 'Failed to read or parse minded.json:', error });
     process.exit(1);
   }
 
   // Get the agent path
   const agentPath = mindedConfig.agent;
   if (!agentPath) {
-    logger.error('No agent path found in minded.json');
+    logger.error({ message: 'No agent path found in minded.json' });
     process.exit(1);
   }
 
@@ -91,7 +91,7 @@ function generateLambdaHandler(): void {
   }
 
   if (!templateContent) {
-    logger.error('Could not find Lambda handler template file');
+    logger.error({ message: 'Could not find Lambda handler template file' });
     process.exit(1);
   }
 
@@ -102,10 +102,10 @@ function generateLambdaHandler(): void {
     // Write the Lambda handler to index.ts at the root
     const outputPath = path.join(process.cwd(), 'index.ts');
     fs.writeFileSync(outputPath, templateContent);
-    logger.info(`Generated Lambda handler at ${outputPath}`);
+    logger.info({ message: `Generated Lambda handler at ${outputPath}` });
 
     // Compile the index.ts file using TypeScript
-    logger.info('Compiling the Lambda handler...');
+    logger.info({ message: 'Compiling the Lambda handler...' });
 
     try {
       // Read tsconfig.json to get the outDir
@@ -138,7 +138,7 @@ function generateLambdaHandler(): void {
         cwd: process.cwd(),
       });
 
-      logger.info(`Successfully compiled Lambda handler to ${outDir}/index.js`);
+      logger.info({ message: `Successfully compiled Lambda handler to ${outDir}/index.js` });
     } catch (compileError) {
       logger.error({ message: 'Failed to compile Lambda handler', error: compileError });
     }
@@ -155,14 +155,14 @@ function main() {
   if (command === 'token') {
     const token = args[1];
     if (!token) {
-      logger.error('Please provide a token');
+      logger.error({ message: 'Please provide a token' });
       process.exit(1);
     }
     setToken(token);
   } else if (command === 'generate-lambda-ts-handler') {
     generateLambdaHandler();
   } else {
-    logger.error('Unknown command. Available commands: token, generate-lambda-ts-handler');
+    logger.error({ message: 'Unknown command. Available commands: token, generate-lambda-ts-handler' });
     process.exit(1);
   }
 }

package/src/edges/createDirectEdge.ts

@@ -5,7 +5,7 @@ export const createDirectEdge = (edge: StepForwardEdge) => {
   return async () => {
     // For direct edges, we just return the target of the first edge
     // since there's no conditional logic needed
-    logger.info(`Executing edge ${JSON.stringify(edge)}`);
+    logger.info({ message: `Executing edge ${JSON.stringify(edge)}` });
     return edge.target;
   };
 };

package/src/edges/createLogicalRouter.ts

@@ -11,8 +11,8 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
     logger.debug(`Evaluating logical conditions for ${edges.length} edges`);
 
     // Separate regular conditions from "else" conditions
-    const regularEdges = edges.filter(edge => edge.condition.trim() !== 'else');
-    const elseEdges = edges.filter(edge => edge.condition.trim() === 'else');
+    const regularEdges = edges.filter((edge) => edge.condition.trim() !== 'else');
+    const elseEdges = edges.filter((edge) => edge.condition.trim() === 'else');
 
     // First, evaluate all regular conditions
     for (const edge of regularEdges) {
@@ -59,17 +59,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
+          logger.info({ message: `Condition matched for edge ${edge.source} → ${edge.target}` });
           return edge.target;
         }
-
       } catch (error) {
         // Provide detailed error information back to the customer
         const errorMessage = error instanceof Error ? error.message : String(error);
         const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
 
         logger.error({
-          msg: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
+          message: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -84,15 +83,15 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // If no regular conditions matched, check for "else" conditions
     if (elseEdges.length > 0) {
-      logger.info(`No regular conditions matched, evaluating ${elseEdges.length} else condition(s)`);
+      logger.info({ message: `No regular conditions matched, evaluating ${elseEdges.length} else condition(s)` });
       // Return the first "else" condition's target
       const elseEdge = elseEdges[0];
-      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
+      logger.info({ message: `Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`, edge: elseEdge });
       return elseEdge.target;
     }
 
     // If no conditions matched or all failed, return to the source node
-    logger.info('No conditions matched');
+    logger.info({ message: 'No conditions matched' });
     return null;
   };
 };

package/src/edges/createPromptRouter.ts

@@ -70,11 +70,11 @@ export const createPromptRouter = ({
   currentNodeName?: string;
 }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
+    logger.info({ message: `Executing prompt router. Edges: ${JSON.stringify(edges)}` });
 
     // If canStayInCurrentNode is true and there are no edges, return current node immediately
     if (canStayInCurrentNode && edges.length === 0 && currentNodeName) {
-      logger.info(`No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}`);
+      logger.info({ message: `No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}` });
       return currentNodeName;
     }
 
@@ -174,13 +174,14 @@ export const createPromptRouter = ({
 
         const decision = validatedResponse.nextNodeId === currentNodeName ? 'stay in current node' : validatedResponse.nextNodeId;
         const reasoning = includeReasoning && 'reasoning' in validatedResponse ? ` - Reasoning: ${validatedResponse.reasoning}` : '';
-        logger.info({ msg: `Router decision: ${decision}`, reasoning });
+        logger.info({ message: `Router decision: ${decision}`, reasoning });
 
         return validatedResponse.nextNodeId;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         logger.warn({
           message: `Prompt router attempt ${attempts} failed`,
+          edge: edges,
           error: lastError.message,
           attempt: attempts,
           maxRetries,

package/src/edges/edgeFactory.ts

@@ -49,7 +49,7 @@ export const edgeFactory = ({
         if (result) {
           return result;
         } else {
-          logger.debug('No logical conditions matched, continuing to prompt conditions');
+          logger.debug({ message: 'No logical conditions matched, continuing to prompt conditions' });
         }
       }
 
@@ -69,7 +69,7 @@ export const edgeFactory = ({
 
       // Fallback: stay at current source node
       const source = originalNode?.name || sourceNode;
-      logger.info(`No conditions matched, returning to source: ${source}`);
+      logger.info({ message: `No conditions matched, returning to source: ${source}` });
       return source;
     };
   };

package/src/interrupts/InterruptSessionManager.types.ts

@@ -0,0 +1,80 @@
+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>;
+  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>;
+}
+
+export abstract class BaseInterruptSessionManager implements InterruptSessionManager {
+  // Abstract methods that subclasses must implement for queue management
+  abstract isProcessed(sessionId: string): boolean | Promise<boolean>;
+  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 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)) {
+      const queue = await this.getQueuedMessages(sessionId);
+      logger.trace({ message: 'graph has queued messagess, interrupting graph', sessionId, queue });
+
+      // 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;
+  }
+}