@minded-ai/mindedjs 2.0.2 → 2.0.4-beta-1

package/src/agent.ts

@@ -489,8 +489,8 @@ export class Agent {
       if (handlerResult) {
         if (!handlerResult.isQualified) {
           logger.debug({ message: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
-          await this.interruptSessionManager.release(sessionId);
-          return;
+          // Process any queued messages even when disqualified
+          return await this.processQueuedMessages(sessionId);
         }
       }
 
@@ -541,26 +541,10 @@ export class Agent {
       } else {
         res = await this.compiledGraph.invoke(state, langgraphConfig);
       }
-      const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
-      if (nextMessage) {
-        // Dequeue the first message and process it recursively
-        // Recursively process the next message with bypass flag
-        const invokeParams: AgentInvokeParams = {
-          triggerBody: nextMessage.triggerBody,
-          triggerName: nextMessage.triggerName,
-          bypassSessionCheck: true,
-        };
-        if (nextMessage.appName) {
-          invokeParams.appName = nextMessage.appName;
-        }
-        logger.debug({ msg: 'Invoking next message in the queue', invokeParams });
-        return await this.invoke(invokeParams);
-      }
-
-      // Release the session lock
-      await this.interruptSessionManager.release(sessionId);
 
-      return res;
+      // Process any queued messages before returning
+      const queueResult = await this.processQueuedMessages(sessionId);
+      return queueResult !== undefined ? queueResult : res;
     } catch (err) {
       logger.error({ msg: '[Trigger] Error', err, sessionId });
 
@@ -946,4 +930,65 @@ export class Agent {
   public onEnd(): void {
     mindedConnection.disconnect();
   }
+
+  /**
+   * Process any queued messages for a session.
+   * If a message is found, it will be processed recursively.
+   * If no messages are found, checks if the graph was interrupted and resumes if needed.
+   * Only releases the lock when there's nothing left to process.
+   *
+   * @param sessionId - The session ID to check for queued messages
+   * @returns The result of processing the next message or resuming the graph, or undefined if nothing to process
+   */
+  private async processQueuedMessages(sessionId: string): Promise<any> {
+    const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
+    if (nextMessage) {
+      // Dequeue the first message and process it recursively
+      const invokeParams: AgentInvokeParams = {
+        triggerBody: nextMessage.triggerBody,
+        triggerName: nextMessage.triggerName,
+        bypassSessionCheck: true,
+      };
+      if (nextMessage.appName) {
+        invokeParams.appName = nextMessage.appName;
+      }
+      logger.debug({
+        msg: 'Invoking next message in the queue',
+        invokeParams,
+      });
+
+      return await this.invoke(invokeParams);
+    }
+
+    // No more messages in queue - check if we need to resume an interrupted graph
+    const langgraphConfig = this.getLangraphConfig(sessionId);
+    const langgraphState = await this.compiledGraph.getState(langgraphConfig);
+    const lastTask = langgraphState.tasks[langgraphState.tasks.length - 1];
+    const hasInterrupt = lastTask?.interrupts?.length > 0;
+
+    if (hasInterrupt) {
+      const interruptValue = lastTask!.interrupts[0].value as InterruptPayload;
+      if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
+        // Graph was interrupted by new triggers - resume it
+        logger.debug({ msg: 'Resuming interrupted graph after processing queued messages', sessionId });
+
+        const state = langgraphState.values as State<any>;
+        const resumeResult = await this.compiledGraph.invoke(
+          new Command({
+            update: state,
+            resume: '',
+          }),
+          langgraphConfig,
+        );
+
+        // After resuming, check again for queued messages (recursive)
+        const queueResult = await this.processQueuedMessages(sessionId);
+        return queueResult !== undefined ? queueResult : resumeResult;
+      }
+    }
+
+    // No more messages and no interrupt to resume - release the session lock
+    await this.interruptSessionManager.release(sessionId);
+    return undefined;
+  }
 }

package/src/platform/mindedConnection.ts

@@ -81,13 +81,16 @@ const getSdkVersion = (): string => {
   }
 };
 
-const connect = async (token: string): Promise<void> => {
+const connect = async (token: string, retryCount: number = 0): Promise<void> => {
   const { isDeployed, baseUrl, env } = getConfig();
-  logger.info(`Connecting to Minded platform: ${baseUrl}`);
+  const maxRetries = isDeployed ? 3 : 0;
+
+  logger.info(`Connecting to Minded platform: ${baseUrl}${retryCount > 0 ? ` (retry ${retryCount}/${maxRetries})` : ''}`);
+
   return new Promise<void>((resolve, reject) => {
     socket = io(baseUrl, {
       path: '/minded-connect',
-      transports: ["websocket"],
+      transports: ['websocket'],
       query: {
         isDeployedAgent: isDeployed,
         token,
@@ -121,9 +124,32 @@ const connect = async (token: string): Promise<void> => {
       checkReady();
     });
 
-    socket.on('connect_error', (err) => {
-      logger.error({ msg: 'Failed to connect to minded platform', err: err.message });
-      reject(new Error('Failed to connect to minded platform'));
+    socket.on('connect_error', async (err) => {
+      // If we're in cloud mode and haven't exhausted retries, try again
+      if (isDeployed && retryCount < maxRetries) {
+        logger.info({ msg: `Retrying connection in ${(retryCount + 1) * 2} seconds...` });
+
+        // Disconnect current socket
+        if (socket?.connected) {
+          socket.disconnect();
+        }
+        socket = null;
+
+        // Wait with exponential backoff
+        await wait((retryCount + 1) * 2000);
+
+        // Retry connection
+        try {
+          await connect(token, retryCount + 1);
+          resolve();
+        } catch (retryErr) {
+          reject(retryErr);
+        }
+      } else {
+        // No more retries or not in cloud mode
+        logger.error({ msg: 'Failed to connect to minded platform', err });
+        reject(new Error('Failed to connect to minded platform'));
+      }
     });
 
     socket.on('disconnect', () => {
@@ -144,8 +170,8 @@ const connect = async (token: string): Promise<void> => {
           socket.disconnect();
         }
 
-        // Get new token and reconnect
-        await connect(token);
+        // Get new token and reconnect (start fresh with retry count 0)
+        await connect(token, 0);
       }
     });