@minded-ai/mindedjs 1.0.139 → 1.0.141

package/docs/platform/sso.md

@@ -0,0 +1,27 @@
+# SSO (Single Sign-On)
+
+## Overview
+
+The Minded platform supports SAML-based Single Sign-On (SSO) as an **enterprise feature** for authentication. This allows organizations to integrate their existing identity provider (IdP) with the Minded platform for seamless and secure user authentication.
+
+## Configuration
+
+Setting up SSO involves exchanging configuration details between Minded (as the Service Provider) and your organization's Identity Provider.
+
+### From Minded (Service Provider → IdP)
+
+When initiating SSO setup, Minded will provide the following configuration details:
+
+- **Identifier (Entity ID)**: A unique identifier for the Minded platform as a service provider
+- **Reply URL**: The endpoint where your IdP will send SAML responses after authentication
+
+### From Customer (IdP → Service Provider)
+
+Once SSO is configured on your organization's side, you will need to provide Minded with:
+
+- **Identity Provider (IdP) metadata**: XML metadata file containing your IdP's configuration
+- **SAML signing certificates**: Certificates used to verify the authenticity of SAML assertions
+
+## Support
+
+To setup SSO configuration please contact the Minded support team.

package/docs/sdk/agent-api.md

@@ -49,7 +49,7 @@ async updateState({
 - `state` (Partial<State>): An object containing the state properties to update. Can include:
   - `messages`: Array of messages to add or update
   - `memory`: Partial memory object to merge with existing memory
-  - `overrideStartFromNodeId`: Node ID to override the next execution point
+  - `goto`: Node ID to override the next execution point
   - Any other state properties defined in your agent
 
 #### Usage Examples
@@ -156,7 +156,7 @@ await agent.updateState({
      sessionId: voiceSessionId,
      state: {
        messages: [correctedMessage],
-       overrideStartFromNodeId: currentNodeId,
+       goto: currentNodeId,
      },
    });
    ```
@@ -214,7 +214,7 @@ const graphState = await agent.compiledGraph.getState(agent.getLangraphConfig(se
 // Update state with LangGraph API
 await agent.compiledGraph.updateState(agent.getLangraphConfig(sessionId), {
   messages: [newMessage],
-  overrideStartFromNodeId: 'specific-node',
+  goto: 'specific-node',
 });
 ```
 

package/docs/sdk/events.md

@@ -207,6 +207,9 @@ The three common patterns are:
   memory?: Memory,            // Optional initial memory state
   history?: HistoryStep[],    // Optional history steps to include
   sessionId?: string,         // Optional session continuity identifier
+  state?: {
+    goto?: string,            // Optional: jump to a specific node ID
+  }
 }
 ```
 
@@ -292,6 +295,27 @@ agent.on(events.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
 });
 ```
 
+#### Dynamic Flow Control with goto
+
+```typescript
+agent.on(events.TRIGGER_EVENT, async ({ triggerName, triggerBody, state }) => {
+  // Check condition and jump to specific node
+  if (triggerBody.priority === 'high') {
+    return {
+      isQualified: true,
+      state: {
+        ...state,
+        goto: 'high-priority-handler', // Jump to specific node
+      },
+    };
+  }
+
+  return { isQualified: true };
+});
+```
+
+> **Note:** The jump occurs only when the current invocation completes and the next one begins. The agent will finish executing the current node before jumping to the specified node.
+
 ### Common Use Cases
 
 - **Input Validation**: Ensure trigger data meets requirements before processing
@@ -302,7 +326,7 @@ agent.on(events.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
 
 ## ERROR
 
-The `ERROR` event is emitted when an error occurs during agent execution. This event allows you to handle errors gracefully, log them for debugging, or implement custom error recovery logic.
+The `ERROR` event is emitted when an error occurs during agent execution. This event allows you to handle errors gracefully, log them for debugging, implement custom error recovery logic, or control whether the error should be thrown onwards.
 
 ### Input Structure
 
@@ -320,9 +344,15 @@ The `ERROR` event is emitted when an error occurs during agent execution. This e
 
 ### Handler Return Value
 
-- **Return type**: `void`
-- **Purpose**: Handlers are used for side effects like error logging, notifications, or recovery actions
-- **Note**: Return values are ignored
+```typescript
+{
+  throwError: boolean;           // Whether to throw the error onwards and stop the agent run
+  state?: Partial<State<Memory>>; // Optional state updates to apply
+}
+```
+
+- **throwError**: When set to `true`, the error will be thrown onwards and the agent run will stop. If `false` or not returned, the error is caught and the agent continues.
+- **state**: Optional partial state updates to apply before continuing or throwing
 
 ### Usage Example
 
@@ -335,13 +365,12 @@ const agent = new Agent({
   tools,
 });
 
-// Listen to errors
+// Listen to errors and control error flow
 agent.on(events.ERROR, async ({ error, state }) => {
   console.error('Agent error occurred:', error.message);
   console.error('Error stack:', error.stack);
   console.log('Session ID:', state.sessionId);
   console.log('Current memory:', state.memory);
-  console.log('Messages at error:', state.messages.length);
 
   // Log to external service
   await logger.error({
@@ -352,26 +381,49 @@ agent.on(events.ERROR, async ({ error, state }) => {
     memory: state.memory,
   });
 
-  // Notify monitoring system
-  await notificationService.alert({
-    type: 'agent_error',
-    error: error.message,
-    sessionId: state.sessionId,
-  });
+  // Handle recoverable vs non-recoverable errors
+  if (error.message.includes('rate limit')) {
+    // Recoverable error - update state and continue
+    return {
+      throwError: false, // Don't stop the agent
+      state: {
+        memory: {
+          ...state.memory,
+          errorRecovered: true,
+          lastError: error.message,
+        },
+      },
+    };
+  }
+
+  // Critical error - stop the agent
+  if (error.message.includes('authentication failed')) {
+    await notificationService.alert({
+      type: 'critical_error',
+      error: error.message,
+      sessionId: state.sessionId,
+    });
+
+    return {
+      throwError: true, // Stop the agent run
+    };
+  }
 
-  // Send error response to user (if needed)
-  await sendErrorMessageToUser('Something went wrong. Please try again.', state.sessionId);
+  // Default: let the error be handled normally
+  return { throwError: false };
 });
 ```
 
 ### Common Use Cases
 
 - **Error Logging**: Record errors for debugging and monitoring with full context
+- **Error Recovery**: Implement custom recovery logic by returning `throwError: false` and updating state
+- **Critical Error Handling**: Stop agent execution for unrecoverable errors with `throwError: true`
 - **User Notifications**: Provide graceful error messages to users
 - **Monitoring & Alerting**: Integrate with monitoring systems for error tracking
-- **Error Recovery**: Implement custom recovery logic or fallback behaviors
 - **Session Management**: Clean up or reset sessions that encountered errors
 - **Analytics**: Track error patterns and frequencies for system improvement
+- **Graceful Degradation**: Continue execution with fallback behavior for non-critical errors
 
 ## ON_LOGICAL_CONDITION
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minded-ai/mindedjs",
-  "version": "1.0.139",
+  "version": "1.0.141",
   "description": "MindedJS is a TypeScript library for building agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -67,4 +67,4 @@
     "zod": "^3.25.74",
     "zod-to-json-schema": "^3.24.6"
   }
-}
+}

package/src/agent.ts

@@ -26,9 +26,9 @@ import { AgentInvokeParams, MindedSDKConfig, SessionType } from './types/Agent.t
 import { createLlmInstance } from './llm/createLlmInstance';
 import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
-import { InterruptSessionManager, InterruptType } from './interrupts/BaseInterruptSessionManager';
+import { InterruptPayload, InterruptSessionManager, InterruptType } from './interrupts/BaseInterruptSessionManager';
 import { createInterruptSessionManager } from './interrupts/interruptSessionManagerFactory';
-import { BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { HumanMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
 import { VoiceSession } from './voice/voiceSession';
@@ -417,96 +417,105 @@ export class Agent {
         return;
       }
       // Session lock acquired, proceed with processing
-
-      let messages: Array<BaseMessage> = [];
-      let memoryUpdate = {};
-      let sessionType: SessionType = SessionType.TEXT;
-
       const langraphConfig = this.getLangraphConfig(sessionId);
+      const state = await this.compiledGraph.getState(langraphConfig);
 
-      let state = await this.compiledGraph.getState(langraphConfig);
+      // Initialize state update with defaults
+      let stateUpdate: Partial<State<z.infer<typeof this.memorySchema>>> = {
+        sessionId,
+        sessionType: SessionType.TEXT,
+      };
 
+      // Process special trigger types (dashboard/voice messages)
       if (triggerName === KnownTriggerNames.DASHBOARD_MESSAGE || triggerName === KnownTriggerNames.VOICE_MESSAGE) {
-        // Parse attachments if present
+        // Parse attachments and create message
         const attachmentsString = parseAttachments(triggerBody);
         const finalContent = combineContentWithAttachments(triggerBody.content || '', attachmentsString);
         if (finalContent) {
-          messages = [new HumanMessage({ content: finalContent, id: uuidv4() })];
+          stateUpdate.messages = [new HumanMessage({ content: finalContent, id: uuidv4() })];
         }
         triggerBody.content = finalContent;
-        sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
+        stateUpdate.sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
       }
 
-      // Trigger event
+      // Merge current state with any updates we've made so far
+      const currentState = { ...state.values, ...stateUpdate };
+
+      // Emit trigger event and let handlers modify the state
       const results = await this.emit(AgentEvents.TRIGGER_EVENT, {
         triggerName,
         triggerBody,
-        state: state.values,
+        state: currentState,
       });
-      if (results.length === 0) {
-        if (appName) {
-          messages =
-            messages.length > 0
-              ? messages
-              : triggerTypeToDefaultMessage[appName]?.[triggerName]?.(triggerBody) ?? [
-                new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() }),
-              ];
-        } else {
-          messages = messages.length > 0 ? messages : [new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() })];
+
+      // Process handler results
+      const handlerResult = results.find((r) => r !== undefined);
+      if (handlerResult) {
+        if (!handlerResult.isQualified) {
+          logger.debug({ message: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
+          await this.interruptSessionManager.release(sessionId);
+          return;
         }
-      } else {
-        const handlerResult = results.find((r) => r !== undefined);
-        if (handlerResult) {
-          if (!handlerResult.isQualified) {
-            logger.trace({ message: '[Trigger] Disqualified', triggerName, sessionId });
-            await this.interruptSessionManager.release(sessionId);
-            return;
-          }
-          memoryUpdate = handlerResult.memory || {};
-          messages = handlerResult.messages ?? (messages.length > 0 ? messages : []);
+        // Merge handler's state updates
+        if (handlerResult.state) {
+          stateUpdate = { ...stateUpdate, ...handlerResult.state };
+        }
+      }
+
+      // If no messages were set by handler or initial processing, create default message
+      if (!stateUpdate.messages || stateUpdate.messages.length === 0) {
+        if (appName && triggerTypeToDefaultMessage[appName]?.[triggerName]) {
+          stateUpdate.messages = triggerTypeToDefaultMessage[appName][triggerName](triggerBody);
+        } else {
+          stateUpdate.messages = [new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() })];
         }
       }
 
-      logger.info({ msg: '[Trigger] Received', triggerName, sessionId });
-      state = await this.compiledGraph.getState(langraphConfig);
+      logger.info({ msg: '[Trigger] Received', triggerName, triggerBody, sessionId });
 
       // 2) Decide how to invoke: resume/update/goto/normal
-      let nodeToBeInvoked = state.next?.length > 0 ? state.values.overrideStartFromNodeId ?? state.next[0] : this.startingNodeId;
+      let nodeToBeInvoked = state.next.length > 0 ? (state.values.goto ? state.values.goto : state.next[0]) : this.startingNodeId;
       if (!nodeToBeInvoked) throw new Error('No node to be invoked');
 
       const suffixes = Object.values(internalNodesSuffix);
       nodeToBeInvoked = nodeToBeInvoked.replace(new RegExp(suffixes.join('|'), 'g'), '');
 
-      const historyStep = createTriggerHistoryStep(
-        state.values.history,
-        nodeToBeInvoked,
-        messages.map((m) => m.id!),
-        triggerName,
-        triggerBody,
-        appName,
-      );
+      // Create a history step if not provided by the handler
+      if (!stateUpdate.history) {
+        const messageIds = stateUpdate.messages?.map((m) => m.id!) || [];
+        const historyStep = createTriggerHistoryStep(state.values.history, nodeToBeInvoked, messageIds, triggerName, triggerBody, appName);
+        // History reducer expects an array or single item
+        stateUpdate.history = [historyStep];
+      }
 
       // 3) Handle interrupts/goto, else normal invoke
       let res;
       const lastTask = state.tasks[state.tasks.length - 1];
       const hasInterrupt = lastTask?.interrupts?.length > 0;
       if (hasInterrupt) {
-        const interruptValue = (lastTask!.interrupts[0] as any).value;
-        if (interruptValue?.type === InterruptType.HUMAN_IN_THE_LOOP) {
-          // For HUMAN_IN_THE_LOOP, use resume with the full object
+        const interruptValue = lastTask!.interrupts[0].value as InterruptPayload;
+        if (interruptValue.type === InterruptType.HUMAN_IN_THE_LOOP) {
+          // For HUMAN_IN_THE_LOOP, use resume with the state update
           res = await this.compiledGraph.invoke(
             new Command({
-              resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType, overrideStartFromNodeId: null },
+              resume: { ...stateUpdate, goto: null },
             }),
             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
+          // For NEW_TRIGGERS, merge with updateStateObject if present
+          const finalState: any = { ...stateUpdate };
+          const updatedInterruptState = interruptValue.updateStateObject;
+          if (updatedInterruptState) {
+            // Merge messages and history using the reducers' logic
+            finalState.messages = [...(updatedInterruptState.messages || []), ...(stateUpdate.messages || [])];
+            finalState.history = [...(updatedInterruptState.history || []), ...(stateUpdate.history || [])];
+            // Merge other fields from updateStateObject
+            Object.keys(updatedInterruptState).forEach((key) => {
+              if (key !== 'messages' && key !== 'history') {
+                finalState[key] = updatedInterruptState[key as keyof typeof updatedInterruptState];
+              }
+            });
           }
 
           // Then use update with the full object and empty resume
@@ -518,26 +527,19 @@ export class Agent {
             langraphConfig,
           );
         }
-      } else if (state.values.overrideStartFromNodeId) {
+      } else if (state.values.goto) {
         res = await this.compiledGraph.invoke(
           new Command({
             update: {
-              overrideStartFromNodeId: null, //reset the overrideStartFromNodeId
-              messages,
-              memory: memoryUpdate,
-              history: historyStep,
-              sessionId,
-              sessionType,
+              ...stateUpdate,
+              goto: null, //reset the goto
             },
-            goto: state.values.overrideStartFromNodeId,
+            goto: state.values.goto,
           }),
           langraphConfig,
         );
       } else {
-        res = await this.compiledGraph.invoke(
-          { messages, memory: memoryUpdate, history: historyStep, sessionId, sessionType },
-          langraphConfig,
-        );
+        res = await this.compiledGraph.invoke(stateUpdate, langraphConfig);
       }
       const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
       if (nextMessage) {
@@ -566,8 +568,24 @@ export class Agent {
       await this.interruptSessionManager.release(sessionId);
 
       const state = await this.compiledGraph.getState(this.getLangraphConfig(sessionId));
-      this.emit(AgentEvents.ERROR, { error: err instanceof Error ? err : new Error(JSON.stringify(err)), state: state.values });
-      throw err;
+      const results = await this.emit(AgentEvents.ERROR, {
+        error: err instanceof Error ? err : new Error(JSON.stringify(err)),
+        state: state.values,
+      });
+      const handlerResult = results.find((r) => r !== undefined);
+      let throwError = handlerResult === undefined;
+      if (handlerResult) {
+        // Merge handler's state updates
+        if (handlerResult.state) {
+          handlerResult.state = { ...state.values, ...handlerResult.state };
+          await this.compiledGraph.updateState(this.getLangraphConfig(sessionId), handlerResult.state);
+        }
+        // If one handler returns throwError, we throw the error
+        throwError = throwError || handlerResult.throwError;
+      }
+      if (throwError) {
+        throw err;
+      }
     }
   }
 
@@ -801,12 +819,19 @@ export class Agent {
 
     this.voiceSessions.set(params.sessionId, voiceSession);
 
+    const state = await this.compiledGraph.getState(this.getLangraphConfig(params.sessionId));
+
     // Emit voice session start event
-    await this.emit(AgentEvents.VOICE_SESSION_START, {
-      sessionId: params.sessionId,
+    const results = await this.emit(AgentEvents.VOICE_SESSION_START, {
       metadata: params.metadata,
+      state: state.values as State<z.infer<typeof this.memorySchema>>,
     });
 
+    const handlerResult = results.find((r) => r !== undefined);
+    if (handlerResult && handlerResult.state) {
+      await this.compiledGraph.updateState(this.getLangraphConfig(params.sessionId), handlerResult.state);
+    }
+
     return voiceSession;
   }
 
@@ -852,6 +877,7 @@ export class Agent {
       return { error: 'Failed to execute tool' };
     }
   }
+
   public async getCurrentNode(sessionId: string) {
     const langConfig = this.getLangraphConfig(sessionId);
     const currentNodeId = (await this.compiledGraph.getState(langConfig))?.tasks?.[0]?.name;

package/src/edges/createLogicalRouter.ts

@@ -13,7 +13,7 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
     logger.debug({ msg: `[Router] Evaluating logical conditions for ${edges.length} edges` });
 
     if (state.goto) {
-      console.log('Jumping to node', state.goto);
+      logger.debug({ msg: `[Router] Jumping to node`, node: state.goto });
       return state.goto;
     }
 
@@ -30,12 +30,17 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
         logger.debug({ msg: '[LogicalCondition] Evaluating condition', edge });
 
         // Emit ON_LOGICAL_CONDITION event
-        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION, {
+        const onLogicalConditionRes = await agent.emit(AgentEvents.ON_LOGICAL_CONDITION, {
           edge,
           state,
           condition: edge.condition,
         });
 
+        const handlerResult = onLogicalConditionRes.find((r) => r !== undefined);
+        if (handlerResult && handlerResult.state) {
+          state = { ...state, ...handlerResult.state };
+        }
+
         // Customer is responsible for providing valid JavaScript syntax
         // We execute their condition in a sandboxed VM with timeout protection
         const conditionCode = `
@@ -90,7 +95,7 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
         });
 
         // Emit ON_LOGICAL_CONDITION_RESULT event
-        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
+        const onLogicalConditionResultRes = await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
           edge,
           state,
           condition: edge.condition,
@@ -98,6 +103,21 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
           executionTimeMs: executionTime,
         });
 
+        let goto = null;
+        const onLogicalConditionResultHandlerResult = onLogicalConditionResultRes.find((r) => r !== undefined);
+        if (onLogicalConditionResultHandlerResult && onLogicalConditionResultHandlerResult.state) {
+          state = { ...state, ...onLogicalConditionResultHandlerResult.state };
+          goto = state.goto;
+          state.goto = null;
+        }
+
+        await agent.updateState({ sessionId: state.sessionId, state });
+
+        if (goto) {
+          logger.debug({ msg: `[Router] Jumping to node`, node: goto });
+          return goto;
+        }
+
         if (booleanResult) {
           if (edge.source == edge.target) {
             logger.info({ msg: `[Router] Stay at node ${edge.source}`, node: edge.source, condition: edge.condition });
@@ -128,7 +148,7 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
         });
 
         // Emit ON_LOGICAL_CONDITION_RESULT event with error
-        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
+        const onLogicalConditionResultRes = await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
           edge,
           state,
           condition: edge.condition,
@@ -137,8 +157,20 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
           error: errorObj,
         });
 
+        const onLogicalConditionResultHandlerResult = onLogicalConditionResultRes.find((r) => r !== undefined);
+        let throwError = false;
+        if (onLogicalConditionResultHandlerResult && onLogicalConditionResultHandlerResult.state) {
+          state = { ...state, ...onLogicalConditionResultHandlerResult.state };
+        }
+        throwError = onLogicalConditionResultHandlerResult?.throwError == true;
+
+        await agent.updateState({ sessionId: state.sessionId, state });
+
         // Continue to next edge instead of failing completely
         // This allows other conditions to be evaluated even if one fails
+        if (throwError) {
+          throw errorObj;
+        }
         continue;
       }
     }

package/src/events/AgentEvents.ts

@@ -1,7 +1,6 @@
-import { BaseMessage } from '@langchain/core/messages';
-import { HistoryStep } from '../types/Agent.types';
 import { State } from '../types/LangGraph.types';
 import { LogicalConditionEdge } from '../types/Flows.types';
+import { TriggerEvent } from '../types/Agent.types';
 
 export enum AgentEvents {
   AI_MESSAGE = 'AI_MESSAGE',
@@ -17,18 +16,16 @@ export type AgentEventRequestPayloads<Memory> = {
     message: string;
     state: State<Memory>;
   };
-  [AgentEvents.TRIGGER_EVENT]: {
-    triggerName: string;
-    triggerBody: any;
+  [AgentEvents.TRIGGER_EVENT]: TriggerEvent & {
     state: State<Memory>;
   };
   [AgentEvents.VOICE_SESSION_START]: {
-    sessionId: string;
     metadata?: Record<string, any>;
+    state: State<Memory>;
   };
   [AgentEvents.ERROR]: {
     error: Error;
-    state?: State<Memory>;
+    state: State<Memory>;
   };
   [AgentEvents.ON_LOGICAL_CONDITION]: {
     edge: LogicalConditionEdge;
@@ -46,16 +43,25 @@ export type AgentEventRequestPayloads<Memory> = {
 };
 
 export type AgentEventResponsePayloads<Memory> = {
-  [AgentEvents.AI_MESSAGE]: void;
+  [AgentEvents.AI_MESSAGE]: {
+    state?: Partial<State<Memory>>;
+  };
   [AgentEvents.TRIGGER_EVENT]: {
     isQualified: boolean;
-    messages?: BaseMessage[];
-    memory?: Memory;
-    history?: HistoryStep[];
-    sessionId?: string;
-  };
-  [AgentEvents.VOICE_SESSION_START]: void;
-  [AgentEvents.ERROR]: void;
-  [AgentEvents.ON_LOGICAL_CONDITION]: void;
-  [AgentEvents.ON_LOGICAL_CONDITION_RESULT]: void;
+    state?: Partial<State<Memory>>;
+  };
+  [AgentEvents.VOICE_SESSION_START]: {
+    state?: Partial<State<Memory>>;
+  };
+  [AgentEvents.ERROR]: {
+    throwError: boolean;
+    state?: Partial<State<Memory>>;
+  };
+  [AgentEvents.ON_LOGICAL_CONDITION]: {
+    state?: Partial<State<Memory>>;
+  };
+  [AgentEvents.ON_LOGICAL_CONDITION_RESULT]: {
+    state?: Partial<State<Memory>>;
+    throwError?: boolean;
+  };
 };

package/src/index.ts

@@ -75,6 +75,7 @@ export {
   AppTriggerHistoryStep,
   CustomActionInvocationHistoryStep,
   SessionType,
+  TriggerEvent,
 } from './types/Agent.types';
 export type { AgentInvokeParams, MindedSDKConfig } from './types/Agent.types';
 export type { Environment } from './types/Platform.types';

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -1,6 +1,7 @@
 import { State } from '../types/LangGraph.types';
 import { GraphInterrupt } from '@langchain/langgraph';
 import { logger } from '../utils/logger';
+import { TriggerEvent } from '../types/Agent.types';
 
 export enum InterruptType {
   NEW_TRIGGERS = 'NEW_TRIGGERS',
@@ -9,13 +10,10 @@ export enum InterruptType {
 
 export const QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH = 'QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH';
 
-export interface QueuedMessage {
-  triggerBody: any;
-  triggerName: string;
-  appName?: string;
-}
+export type QueuedMessage = TriggerEvent;
+
 export interface InterruptPayload {
-  type: InterruptType.NEW_TRIGGERS;
+  type: InterruptType;
   updateStateObject?: Partial<State>;
   id?: string;
 }