@minded-ai/mindedjs 1.0.80-beta.8 → 1.0.80

package/src/agent.ts

@@ -1,4 +1,4 @@
-import { Flow, NodeType, Node, EdgeType, KnownTriggerNames, TriggerType, VoiceTriggerNode } from './types/Flows.types';
+import { Flow, NodeType, Node, EdgeType, KnownTriggerNames, TriggerType, VoiceTriggerNode, internalNodesSuffix } from './types/Flows.types';
 
 import { Tool } from './types/Tools.types';
 import { v4 as uuidv4 } from 'uuid';
@@ -15,7 +15,15 @@ import { InvokeMessage, MindedConnectionSocketMessageType } from './platform/min
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
-import { AgentInvokeParams, FlowHistoryType, MindedSDKConfig, SessionType, TriggerInvocationHistory } from './types/Agent.types';
+import {
+  AgentInvokeParams,
+  AppTrigggerHistoryStep,
+  TriggerHistoryStep,
+  HistoryStepType,
+  MindedSDKConfig,
+  SessionType,
+  HistoryStep,
+} from './types/Agent.types';
 import { createLlmInstance } from './llm/createLlmInstance';
 import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
@@ -27,6 +35,7 @@ import { BaseVoiceMessage, OnVoiceAudioOut } from './platform/mindedConnectionTy
 import { PIIGateway, PIIGatewayInstance } from './platform/piiGateway';
 import { logger } from './utils/logger';
 import { loadPlaybooks, Playbook } from './playbooks/playbooks';
+import { createHistoryStep } from './utils/history';
 
 type CreateAgentParams<Memory> = {
   memorySchema: z.ZodSchema;
@@ -58,7 +67,7 @@ export class Agent {
   private memorySchema: z.ZodSchema;
   private flows!: Flow[];
   public tools!: Tool<any, any>[];
-  public llm!: BaseLanguageModel;
+  private llm!: BaseLanguageModel;
   public mindedConnection: MindedConnection | null = null;
   // Langgraph memory saver. In memory for local development, Custom for Platform
   private checkpointer!: BaseCheckpointSaver;
@@ -89,6 +98,7 @@ export class Agent {
 
   private initialized = false;
   private initPromise: Promise<void> | null = null;
+  private startingNodeId: string | null = null;
   public voiceSessions: Map<string, VoiceSession> = new Map();
 
   /**
@@ -284,10 +294,12 @@ export class Agent {
     // Add edge from start to first node if no triggers exist
     const hasTrigger = nodes.some((node) => node.type === NodeType.TRIGGER && node.triggerType !== TriggerType.MANUAL);
     if (!hasTrigger && nodes.length > 0) {
+      this.startingNodeId = nodes[0].name;
       graph.addEdge('__start__', nodes[0].name as any);
     } else {
       nodes.forEach((node) => {
         if (node.type === NodeType.TRIGGER && node.triggerType !== TriggerType.MANUAL) {
+          this.startingNodeId = node.name;
           graph.addEdge('__start__', node.name as any);
         }
       });
@@ -322,7 +334,6 @@ export class Agent {
       memory: initialMemory,
       triggerMetadata: null,
       history: [],
-      triggerInvocations: [] as Array<TriggerInvocationHistory>,
       sessionId: state.sessionId || uuidv4(), // Preserve existing sessionId or generate new one
       sessionType: state.sessionType || SessionType.TEXT,
     };
@@ -335,6 +346,33 @@ export class Agent {
     return initialState;
   }
 
+  private createTriggerHistoryStep(
+    currentHistory: HistoryStep[],
+    nodeId: string,
+    messageIds: string[],
+    triggerName: string,
+    triggerBody: any,
+    appName?: string,
+  ): HistoryStep {
+    const baseStep = {
+      nodeId: nodeId,
+      nodeDisplayName: triggerName,
+      raw: triggerBody,
+      messageIds,
+    } as HistoryStep;
+
+    return appName
+      ? createHistoryStep<AppTrigggerHistoryStep>(currentHistory, {
+          ...baseStep,
+          type: HistoryStepType.APP_TRIGGER_NODE,
+          appName,
+        })
+      : createHistoryStep<TriggerHistoryStep>(currentHistory, {
+          ...baseStep,
+          type: HistoryStepType.TRIGGER_NODE,
+        });
+  }
+
   /**
    * Invoke a trigger to start agent execution with the specified parameters.
    *
@@ -364,69 +402,83 @@ export class Agent {
    * ```
    */
   public async invoke({ triggerBody, triggerName, sessionId, appName }: AgentInvokeParams) {
-    await this.waitForInitialization();
-    let messages: Array<BaseMessage> = [];
-    let memoryUpdate = {};
-    let sessionType: SessionType = SessionType.TEXT;
     sessionId = sessionId ?? uuidv4();
-    if (triggerName === KnownTriggerNames.DASHBOARD_MESSAGE || triggerName === KnownTriggerNames.VOICE_MESSAGE) {
-      if (!triggerBody.content) {
-        throw new Error(`Trigger body content is required for ${JSON.stringify(triggerBody)}`);
-      }
-      messages.push(new HumanMessage(triggerBody.content));
-      sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
-    } else {
-      const results = await this.emit(AgentEvents.TRIGGER_EVENT, {
-        triggerName,
-        triggerBody,
-        sessionId,
-      });
-      if (results.length === 0) {
-        if (appName) {
-          messages = triggerTypeToDefaultMessage[appName]?.[triggerName]?.(triggerBody) ?? [new HumanMessage(JSON.stringify(triggerBody))];
-        } else {
-          messages = [new HumanMessage(JSON.stringify(triggerBody))];
+    try {
+      await this.waitForInitialization();
+      let messages: Array<BaseMessage> = [];
+      let memoryUpdate = {};
+      let sessionType: SessionType = SessionType.TEXT;
+      if (triggerName === KnownTriggerNames.DASHBOARD_MESSAGE || triggerName === KnownTriggerNames.VOICE_MESSAGE) {
+        if (!triggerBody.content) {
+          throw new Error(`Trigger body content is required for ${JSON.stringify(triggerBody)}`);
         }
+        messages = [new HumanMessage({ content: triggerBody.content, id: uuidv4() })];
+        sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
       } else {
-        const handlerResult = results.find((r) => r !== undefined);
-        if (handlerResult) {
-          if (!handlerResult.isQualified) {
-            logger.info(`Trigger ${triggerName} was disqualified`);
-            return;
+        const results = await this.emit(AgentEvents.TRIGGER_EVENT, {
+          triggerName,
+          triggerBody,
+          sessionId,
+        });
+        if (results.length === 0) {
+          if (appName) {
+            messages = triggerTypeToDefaultMessage[appName]?.[triggerName]?.(triggerBody) ?? [
+              new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() }),
+            ];
+          } else {
+            messages = [new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() })];
+          }
+        } else {
+          const handlerResult = results.find((r) => r !== undefined);
+          if (handlerResult) {
+            if (!handlerResult.isQualified) {
+              logger.info(`Trigger ${triggerName} was disqualified`);
+              return;
+            }
+            memoryUpdate = handlerResult.memory || {};
+            messages = handlerResult.messages ?? [];
+            sessionId = handlerResult.sessionId ?? sessionId;
           }
-          memoryUpdate = handlerResult.memory || {};
-          messages = handlerResult.messages ?? [];
-          sessionId = handlerResult.sessionId ?? sessionId;
         }
       }
-    }
 
-    const triggerInvocation = { appName, triggerName, triggerBody };
-    const history = [
-      {
-        type: FlowHistoryType.TRIGGER_INVOCATION,
-        ...triggerInvocation,
-      },
-    ];
-    logger.info(`Invoking trigger ${triggerName} with session ${sessionId}`);
-    const langraphConfig = this.getLangraphConfig(sessionId || uuidv4());
-    const state = await this.compiledGraph.getState(langraphConfig);
-    let res;
-    // Resume interruption
-    if (state.tasks?.[0]?.interrupts?.length > 0) {
-      res = await this.compiledGraph.invoke(
-        new Command({
-          resume: { memory: memoryUpdate, messages, history, triggerInvocations: [triggerInvocation], sessionId, sessionType },
-        }),
-        langraphConfig,
-      );
-    } else {
-      res = await this.compiledGraph.invoke(
-        { messages, memory: memoryUpdate, history, triggerInvocations: [triggerInvocation], sessionId, sessionType },
-        langraphConfig,
+      logger.info(`Invoking trigger ${triggerName} with session ${sessionId}`);
+      const langraphConfig = this.getLangraphConfig(sessionId || uuidv4());
+      const state = await this.compiledGraph.getState(langraphConfig);
+      const suffixes = Object.values(internalNodesSuffix);
+      let nodeToBeInvoked = state.next.length > 0 ? state.next[0] : this.startingNodeId!;
+      nodeToBeInvoked = nodeToBeInvoked.replace(new RegExp(suffixes.join('|'), 'g'), '');
+      const historyStep = this.createTriggerHistoryStep(
+        state.values.history,
+        nodeToBeInvoked,
+        messages.map((m) => m.id!),
+        triggerName,
+        triggerBody,
+        appName,
       );
+
+      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,
+        );
+      } else {
+        res = await this.compiledGraph.invoke(
+          { messages, memory: memoryUpdate, history: historyStep, sessionId, sessionType },
+          langraphConfig,
+        );
+      }
+      return res;
+    } catch (error) {
+      logger.error({ message: 'Invoke error', error, 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;
     }
-    return res;
   }
 
   /**
@@ -450,7 +502,7 @@ export class Agent {
    *     memory: Memory;                  // Initial memory state (from your schema defaults)
    *     triggerInvocations: Array<...>;  // Empty array - no triggers invoked yet
    *     triggerMetadata: null;           // No trigger metadata initially
-   *     history: FlowHistory[];          // Empty array - no flow history yet
+   *     history: HistoryStep[];          // Empty array - no flow history yet
    *     sessionId: string;               // Session identifier (generated or provided)
    *     sessionType: SessionType;        // Type of session (TEXT, VOICE, etc.)
    *   }
@@ -479,7 +531,7 @@ export class Agent {
    *     memory: Memory;                    // Current memory state (your defined memory schema)
    *     triggerInvocations: Array<...>;    // Trigger invocation history
    *     triggerMetadata: {...} | null;     // Current trigger metadata
-   *     history: FlowHistory[];            // Flow execution history
+   *     history: HistoryStep[];            // Flow execution history with detailed step information
    *     sessionId: string;                 // Session identifier
    *   }
    * }

package/src/edges/createLogicalRouter.ts

@@ -10,12 +10,7 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
   return async (state: typeof stateAnnotation.State) => {
     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');
-
-    // First, evaluate all regular conditions
-    for (const edge of regularEdges) {
+    for (const edge of edges) {
       try {
         // Customer is responsible for providing valid JavaScript syntax
         // We execute their condition in a sandboxed VM with timeout protection
@@ -58,11 +53,12 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
           new Promise((_, reject) => setTimeout(() => reject(new Error('Condition execution timeout')), CONDITION_TIMEOUT)),
         ]);
 
-        if (result === true) {
+        if (result) {
           logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
           return edge.target;
         }
 
+        logger.debug(`Condition not matched for edge ${edge.source} → ${edge.target}`);
       } catch (error) {
         // Provide detailed error information back to the customer
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -82,17 +78,8 @@ 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)`);
-      // Return the first "else" condition's target
-      const elseEdge = elseEdges[0];
-      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
-      return elseEdge.target;
-    }
-
     // If no conditions matched or all failed, return to the source node
-    logger.info('No conditions matched');
-    return null;
+    logger.info(`No conditions matched, returning to source: ${edges[0].source}`);
+    return edges[0].source;
   };
 };

package/src/edges/edgeFactory.ts

@@ -46,7 +46,7 @@ export const edgeFactory = ({
       if (edgesBySource.logical.length > 0) {
         const logicalRouter = createLogicalRouter({ edges: edgesBySource.logical });
         const result = await logicalRouter(state);
-        if (result) {
+        if (result && result !== edgesBySource.logical[0].source) {
           return result;
         } else {
           logger.debug('No logical conditions matched, continuing to prompt conditions');
@@ -68,9 +68,7 @@ export const edgeFactory = ({
       }
 
       // Fallback: stay at current source node
-      const source = originalNode?.name || sourceNode;
-      logger.info(`No conditions matched, returning to source: ${source}`);
-      return source;
+      return sourceNode;
     };
   };
 

package/src/events/AgentEvents.ts

@@ -1,29 +1,31 @@
 import { BaseMessage } from '@langchain/core/messages';
-import { FlowHistory } from '../types/Agent.types';
-import { createStateAnnotation } from '../types/LangGraph.types';
+import { HistoryStep } from '../types/Agent.types';
+import { State } from '../types/LangGraph.types';
 
 export enum AgentEvents {
   INIT = 'INIT',
   AI_MESSAGE = 'AI_MESSAGE',
   TRIGGER_EVENT = 'TRIGGER_EVENT',
+  ERROR = 'ERROR',
 }
 
-// Helper type to get the state type with proper memory typing
-type StateWithMemory<Memory> = ReturnType<typeof createStateAnnotation<Memory>>['State'];
-
 export type AgentEventRequestPayloads<Memory> = {
   [AgentEvents.INIT]: {
-    state: StateWithMemory<Memory>;
+    state: State<Memory>;
   };
   [AgentEvents.AI_MESSAGE]: {
     message: string;
-    state: StateWithMemory<Memory>;
+    state: State<Memory>;
   };
   [AgentEvents.TRIGGER_EVENT]: {
     triggerName: string;
     triggerBody: any;
     sessionId?: string;
   };
+  [AgentEvents.ERROR]: {
+    error: Error;
+    state?: State<Memory>;
+  };
 };
 
 export type AgentEventResponsePayloads<Memory> = {
@@ -33,7 +35,8 @@ export type AgentEventResponsePayloads<Memory> = {
     isQualified: boolean;
     messages?: BaseMessage[];
     memory?: Memory;
-    history?: FlowHistory[];
+    history?: HistoryStep[];
     sessionId?: string;
   };
+  [AgentEvents.ERROR]: void;
 };

package/src/index.ts

@@ -35,7 +35,14 @@ export {
   KnownTriggerNames,
 } from './types/Flows.types';
 export type { Tool, ToolExecuteInput } from './types/Tools.types';
-export { FlowHistoryType, FlowHistory, TriggerInvocationHistory, AppActionInvocationHistory, SessionType } from './types/Agent.types';
+export {
+  HistoryStepType,
+  HistoryStep,
+  TriggerHistoryStep,
+  AppActionInvocationHistoryStep,
+  CustomActionInvocationHistoryStep,
+  SessionType,
+} from './types/Agent.types';
 export type { AgentInvokeParams, MindedSDKConfig } from './types/Agent.types';
 export type { Environment } from './types/Platform.types';
 export type { State } from './types/LangGraph.types';

package/src/nodes/addAppToolNode.ts

@@ -6,10 +6,11 @@ import { RunnableLike } from '@langchain/core/runnables';
 import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
 import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
-import { FlowHistoryType } from '../types/Agent.types';
+import { AppActionInvocationHistoryStep, HistoryStepType } from '../types/Agent.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
+import { createHistoryStep } from '../utils/history';
 
 export const addAppToolNode = async ({
   graph,
@@ -80,7 +81,14 @@ export const addAppToolNode = async ({
     };
     return {
       messages: [AIToolCallMessage, toolCallMessage],
-      history: [{ type: FlowHistoryType.APP_ACTION_INVOCATION, nodeTitle: node.displayName }],
+      history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
+        type: HistoryStepType.APP_ACTION_NODE,
+        nodeId: node.name,
+        nodeDisplayName: node.displayName!,
+        raw: AIToolCallMessage.tool_calls[0],
+        appName: node.appName,
+        messageIds: [AIToolCallMessage.id!],
+      }),
     };
   };
   graph.addNode(node.name, callback);

package/src/nodes/addHumanInTheLoopNode.ts

@@ -2,13 +2,14 @@ import { interrupt } from '@langchain/langgraph';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { RunnableLike } from '@langchain/core/runnables';
 import { logger } from '../utils/logger';
+import { internalNodesSuffix } from '../types/Flows.types';
 
 type AddHumanInTheLoopNodeParams = {
   graph: PreCompiledGraph;
   attachedToNodeName: string;
 };
 
-export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}_humanInTheLoop`;
+export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.HUMAN_IN_THE_LOOP}`;
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
@@ -19,6 +20,6 @@ export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHu
       return value;
     }
   };
-  graph.addNode(`${attachedToNodeName}_humanInTheLoop`, callback);
+  graph.addNode(buildHumanInTheLoopNodeName(attachedToNodeName), callback);
   graph.addEdge(attachedToNodeName as any, buildHumanInTheLoopNodeName(attachedToNodeName) as any);
 };

package/src/nodes/addJumpToNode.ts

@@ -3,19 +3,13 @@ import { PreCompiledGraph } from '../types/LangGraph.types';
 import { JumpToNode } from '../types/Flows.types';
 import { logger } from '../utils/logger';
 
-export const addJumpToNode = async ({
-  graph,
-  node,
-}: {
-  graph: PreCompiledGraph;
-  node: JumpToNode;
-}) => {
+export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
   const callback: RunnableLike = async () => {
-    logger.info(`Executing jump node ${node.name} – jumping to ${node.targetNodeId}`);
+    logger.info(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
     // No state modifications are necessary; control flow is handled via edges.
     return;
   };
 
   graph.addNode(node.name, callback);
   graph.addEdge(node.name as any, node.targetNodeId as any);
-}; 
+};

package/src/nodes/addPromptNode.ts

@@ -7,12 +7,13 @@ import { SystemMessage, AIMessage, ToolMessage } from '@langchain/core/messages'
 import { Tool } from '../types/Tools.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
-import { EmitSignature } from '../types/Agent.types';
+import { EmitSignature, HistoryStepType, HistoryStep } from '../types/Agent.types';
 import { createLlmInstance } from '../llm/createLlmInstance';
 import extractToolStateResponse from '../utils/extractStateMemoryResponse';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
+import { createHistoryStep } from '../utils/history';
 
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
@@ -25,7 +26,7 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt node ${node.name}`);
+    logger.info(`Executing prompt node ${node.displayName}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -102,6 +103,13 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     }
 
     return {
+      history: createHistoryStep<HistoryStep>(state.history, {
+        type: HistoryStepType.PROMPT_NODE,
+        nodeId: node.name,
+        nodeDisplayName: node.displayName,
+        raw: result.content,
+        messageIds: [result.id!],
+      }),
       messages: [result],
     };
   };

package/src/nodes/addToolNode.ts

@@ -28,7 +28,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.name}`);
+    logger.info(`Executing tool node ${toolNode.displayName}`);
 
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,

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 { ToolNode } from '../types/Flows.types';
+import { internalNodesSuffix, ToolNode } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { ToolMessage } from '@langchain/core/messages';
 import { z } from 'zod';
@@ -19,7 +19,7 @@ type AddToolRunNodeParams = {
   agent: Agent;
 };
 
-export const buildToolRunNodeName = (nodeName: string) => `${nodeName}_toolRun`;
+export const buildToolRunNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.TOOL_RUN}`;
 
 export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName, agent }: AddToolRunNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {

package/src/nodes/addTriggerNode.ts

@@ -5,7 +5,7 @@ import { logger } from '../utils/logger';
 
 export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
   const callback: RunnableLike = async () => {
-    logger.info(`Executing trigger node ${node.name}`);
+    logger.info(`Executing trigger node ${node.displayName}`);
     return;
   };
 

package/src/types/Agent.types.ts

@@ -30,26 +30,40 @@ export interface AgentInvokeParams {
   appName?: string;
 }
 
-export enum FlowHistoryType {
-  TRIGGER_INVOCATION = 'triggerInvocation',
-  APP_ACTION_INVOCATION = 'appActionInvocation',
+export enum HistoryStepType {
+  APP_TRIGGER_NODE = 'appTriggerNode',
+  TRIGGER_NODE = 'triggerNode',
+  APP_ACTION_NODE = 'appActionNode',
+  CUSTOM_ACTION_NODE = 'customActionNode',
+  PROMPT_NODE = 'promptNode',
 }
 
-export interface FlowHistory {
-  type: FlowHistoryType;
+export interface HistoryStep {
+  type: HistoryStepType;
+  step: number;
+  raw: any;
+  nodeId: string;
+  nodeDisplayName: string;
+  messageIds?: string[];
 }
 
-export interface TriggerInvocationHistory extends FlowHistory {
-  type: FlowHistoryType.TRIGGER_INVOCATION;
-  appName?: string;
-  triggerName: string;
-  triggerBody: any;
+export interface AppTrigggerHistoryStep extends HistoryStep {
+  type: HistoryStepType.APP_TRIGGER_NODE;
+  appName: string;
 }
 
-export interface AppActionInvocationHistory extends FlowHistory {
-  type: FlowHistoryType.APP_ACTION_INVOCATION;
-  nodeTitle: string;
-};
+export interface TriggerHistoryStep extends HistoryStep {
+  type: HistoryStepType.TRIGGER_NODE;
+}
+
+export interface AppActionInvocationHistoryStep extends HistoryStep {
+  type: HistoryStepType.APP_ACTION_NODE;
+  appName: string;
+}
+
+export interface CustomActionInvocationHistoryStep extends HistoryStep {
+  type: HistoryStepType.CUSTOM_ACTION_NODE;
+}
 
 export enum SessionType {
   VOICE = 'voice',

package/src/types/Flows.types.ts

@@ -25,7 +25,7 @@ export interface BaseNode {
   position?: Position;
   humanInTheLoop?: boolean;
   canStayOnNode?: boolean;
-  displayName?: string;
+  displayName: string;
 }
 
 export enum TriggerType {
@@ -177,3 +177,8 @@ export enum KnownTriggerNames {
   DASHBOARD_MESSAGE = 'dashboard_message',
   VOICE_MESSAGE = 'voice_message',
 }
+
+export enum internalNodesSuffix {
+  HUMAN_IN_THE_LOOP = '_humanInTheLoop',
+  TOOL_RUN = '_toolRun',
+}

package/src/types/LangGraph.types.ts

@@ -1,6 +1,6 @@
 import { BaseMessage } from '@langchain/core/messages';
 import { Annotation, CompiledStateGraph, StateGraph } from '@langchain/langgraph';
-import { FlowHistory, SessionType, TriggerInvocationHistory } from './Agent.types';
+import { HistoryStep, SessionType } from './Agent.types';
 
 export const createStateAnnotation = <Memory = any>() =>
   Annotation.Root({
@@ -25,15 +25,7 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => ({} as Memory),
       reducer: (a, b) => ({ ...a, ...b }),
     }),
-    triggerInvocations: Annotation<Array<TriggerInvocationHistory>>({
-      default: () => [],
-      reducer: (a, b) => a.concat(b),
-    }),
-    triggerMetadata: Annotation<{
-      name: string;
-      triggerBody: any;
-    } | null>,
-    history: Annotation<Array<FlowHistory>>({
+    history: Annotation<Array<HistoryStep>>({
       default: () => [],
       reducer: (a, b) => a.concat(b),
     }),

package/src/utils/history.ts

@@ -0,0 +1,9 @@
+import { HistoryStep } from '../types/Agent.types';
+
+export const createHistoryStep = <T extends HistoryStep>(currentHistory: HistoryStep[], stepPayload: Omit<T, 'step'>): HistoryStep => {
+  const lastHistoryStep = currentHistory?.[currentHistory?.length - 1];
+  return {
+    ...stepPayload,
+    step: lastHistoryStep?.step + 1 || 0,
+  } as HistoryStep;
+};