@minded-ai/mindedjs 1.0.91-beta-1 → 1.0.92-beta-2

package/src/interrupts/InterruptSessionManager.types.ts

@@ -0,0 +1,79 @@
+import { State } from '../types/LangGraph.types';
+import { GraphInterrupt } from '@langchain/langgraph';
+
+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);
+      console.log({ message: 'Interrupting graph', sessionId, queue, updateStateObject });
+
+      // 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;
+  }
+}

package/src/interrupts/MemoryInterruptSessionManager.ts

@@ -0,0 +1,56 @@
+import { State } from '../types/LangGraph.types';
+import { logger } from '../utils/logger';
+import { BaseInterruptSessionManager, QueuedMessage, InterruptType, InterruptPayload } from './InterruptSessionManager.types';
+import { GraphInterrupt, interrupt } from '@langchain/langgraph';
+import { v4 as uuidv4 } from 'uuid';
+
+export class MemoryInterruptSessionManager extends BaseInterruptSessionManager {
+  private sessionProcessing: Map<string, boolean> = new Map();
+  private sessionMessageQueues: Map<string, QueuedMessage[]> = new Map();
+
+  isProcessed(sessionId: string): boolean {
+    return this.sessionProcessing.get(sessionId) || false;
+  }
+
+  lock(sessionId: string): void {
+    this.sessionProcessing.set(sessionId, true);
+  }
+
+  release(sessionId: string): void {
+    this.sessionProcessing.set(sessionId, false);
+  }
+
+  enqueueMessage(sessionId: string, message: QueuedMessage): void {
+    if (!this.sessionMessageQueues.has(sessionId)) {
+      this.sessionMessageQueues.set(sessionId, []);
+    }
+    this.sessionMessageQueues.get(sessionId)!.push(message);
+  }
+
+  dequeueAll(sessionId: string): QueuedMessage[] {
+    const messages = this.sessionMessageQueues.get(sessionId) || [];
+    const result = [...messages];
+    this.sessionMessageQueues.set(sessionId, []);
+    return result;
+  }
+
+  dequeue(sessionId: string): QueuedMessage | null {
+    const messages = this.sessionMessageQueues.get(sessionId) || [];
+    if (messages.length === 0) {
+      return null;
+    }
+    const firstMessage = messages.shift()!;
+    this.sessionMessageQueues.set(sessionId, messages);
+    return firstMessage;
+  }
+
+  // Implementation of abstract methods from BaseInterruptSessionManager
+  protected hasQueuedMessages(sessionId: string): boolean {
+    const queue = this.sessionMessageQueues.get(sessionId) || [];
+    return queue.length > 0;
+  }
+
+  protected getQueuedMessages(sessionId: string): QueuedMessage[] {
+    return this.sessionMessageQueues.get(sessionId) || [];
+  }
+}

package/src/interrupts/MindedInterruptSessionManager.ts

@@ -0,0 +1,157 @@
+import { BaseInterruptSessionManager, QueuedMessage } from './InterruptSessionManager.types';
+import { MindedConnection } from '../platform/mindedConnection';
+import {
+  MindedConnectionSocketMessageType,
+  InterruptSessionIsProcessedRequest,
+  InterruptSessionIsProcessedResponse,
+  InterruptSessionLockRequest,
+  InterruptSessionLockResponse,
+  InterruptSessionReleaseRequest,
+  InterruptSessionReleaseResponse,
+  InterruptSessionEnqueueRequest,
+  InterruptSessionEnqueueResponse,
+  InterruptSessionDequeueAllRequest,
+  InterruptSessionDequeueAllResponse,
+  InterruptSessionDequeueRequest,
+  InterruptSessionDequeueResponse,
+  InterruptSessionHasMessagesRequest,
+  InterruptSessionHasMessagesResponse,
+  InterruptSessionGetMessagesRequest,
+  InterruptSessionGetMessagesResponse,
+} from '../platform/mindedConnectionTypes';
+
+export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
+  private mindedConnection: MindedConnection;
+
+  constructor(mindedConnection: MindedConnection) {
+    super();
+    this.mindedConnection = mindedConnection;
+  }
+
+  async isProcessed(sessionId: string): Promise<boolean> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionIsProcessedRequest, InterruptSessionIsProcessedResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED,
+          sessionId,
+        },
+      );
+      return response.isProcessed ?? false;
+    } catch (error) {
+      console.error('Error checking if session is processed:', error);
+      return false;
+    }
+  }
+
+  async lock(sessionId: string): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionLockRequest, InterruptSessionLockResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK,
+          sessionId,
+        },
+      );
+    } catch (error) {
+      console.error('Error locking session:', error);
+      throw error;
+    }
+  }
+
+  async release(sessionId: string): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionReleaseRequest, InterruptSessionReleaseResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE,
+          sessionId,
+        },
+      );
+    } catch (error) {
+      console.error('Error releasing session:', error);
+      throw error;
+    }
+  }
+
+  async enqueueMessage(sessionId: string, message: QueuedMessage): Promise<void> {
+    try {
+      await this.mindedConnection.awaitEmit<InterruptSessionEnqueueRequest, InterruptSessionEnqueueResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE,
+          sessionId,
+          message,
+        },
+      );
+    } catch (error) {
+      console.error('Error enqueuing message:', error);
+      throw error;
+    }
+  }
+
+  async dequeueAll(sessionId: string): Promise<QueuedMessage[]> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionDequeueAllRequest, InterruptSessionDequeueAllResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL,
+          sessionId,
+        },
+      );
+      return response.messages ?? [];
+    } catch (error) {
+      console.error('Error dequeuing all messages:', error);
+      return [];
+    }
+  }
+
+  async dequeue(sessionId: string): Promise<QueuedMessage | null> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionDequeueRequest, InterruptSessionDequeueResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE,
+          sessionId,
+        },
+      );
+      return response.message ?? null;
+    } catch (error) {
+      console.error('Error dequeuing message:', error);
+      return null;
+    }
+  }
+
+  // Implementation of abstract methods from BaseInterruptSessionManager
+  protected async hasQueuedMessages(sessionId: string): Promise<boolean> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionHasMessagesRequest, InterruptSessionHasMessagesResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES,
+          sessionId,
+        },
+      );
+      return response.hasMessages ?? false;
+    } catch (error) {
+      console.error('Error checking if session has messages:', error);
+      return false;
+    }
+  }
+
+  protected async getQueuedMessages(sessionId: string): Promise<QueuedMessage[]> {
+    try {
+      const response = await this.mindedConnection.awaitEmit<InterruptSessionGetMessagesRequest, InterruptSessionGetMessagesResponse>(
+        MindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES,
+        {
+          type: MindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES,
+          sessionId,
+        },
+      );
+      return response.messages ?? [];
+    } catch (error) {
+      console.error('Error getting queued messages:', error);
+      return [];
+    }
+  }
+}

package/src/interrupts/interruptSessionManagerFactory.ts

@@ -0,0 +1,17 @@
+import { InterruptSessionManager } from './InterruptSessionManager.types';
+import { MemoryInterruptSessionManager } from './MemoryInterruptSessionManager';
+import { MindedInterruptSessionManager } from './MindedInterruptSessionManager';
+import { MindedConnection } from '../platform/mindedConnection';
+import { getConfig } from '../platform/config';
+
+export function createInterruptSessionManager(mindedConnection: MindedConnection | null): InterruptSessionManager {
+  const { runLocally } = getConfig();
+  if (runLocally) {
+    return new MemoryInterruptSessionManager();
+  } else {
+    if (!mindedConnection) {
+      throw new Error('MindedConnection is required for platform interrupt session manager');
+    }
+    return new MindedInterruptSessionManager(mindedConnection);
+  }
+}

package/src/nodes/addHumanInTheLoopNode.ts

@@ -3,6 +3,7 @@ import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { RunnableLike } from '@langchain/core/runnables';
 import { logger } from '../utils/logger';
 import { internalNodesSuffix } from '../types/Flows.types';
+import { InterruptType } from '../interrupts/InterruptSessionManager.types';
 
 type AddHumanInTheLoopNodeParams = {
   graph: PreCompiledGraph;
@@ -16,7 +17,7 @@ export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHu
     logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
 
     if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt('input from human in the loop');
+      const value = interrupt({ type: InterruptType.HUMAN_IN_THE_LOOP });
       return value;
     }
   };

package/src/nodes/addPromptNode.ts

@@ -14,7 +14,7 @@ import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
-
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -26,6 +26,7 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     logger.info(`Executing prompt node ${node.displayName}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
@@ -52,7 +53,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     `;
 
     const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([...state.messages, new SystemMessage(message)]);
-
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     // Check if the result contains tool calls
     if (result.tool_calls && result.tool_calls.length > 0) {
       // Execute the tools
@@ -66,6 +67,26 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
           try {
             // Invoke the LangChain tool directly
             const toolResult = await matchedTool.invoke(toolCall);
+            console.log('after invoke?');
+            //check for queue after tool call
+            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+              messages: [
+                result,
+                toolResult,
+                new SystemMessage(
+                  'you called tool when the user send a new message, Consider calling the function again after user message is processed',
+                ),
+              ],
+              history: [
+                createHistoryStep<HistoryStep>(state.history, {
+                  type: NodeType.TOOL,
+                  nodeId: node.name,
+                  nodeDisplayName: node.displayName,
+                  raw: toolResult,
+                  messageIds: [toolResult.id!],
+                }),
+              ],
+            });
             const toolStateUpdate = extractToolStateResponse(toolResult);
             // Properly merge memory and other state updates
             stateUpdates = {
@@ -74,7 +95,8 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
               memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
             };
             toolResults.push(toolResult);
-          } catch (error) {
+          } catch (error: any) {
+            if (error?.name === 'GraphInterrupt') throw error;
             logger.error({ msg: `Error executing tool ${toolCall.name}:`, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
@@ -87,10 +109,30 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }
       }
 
+      // await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+
       // Return the tool call message and tool results with state updates spread at top level
       return {
         ...stateUpdates,
         messages: [result, ...toolResults],
+        history: [
+          createHistoryStep<HistoryStep>(state.history, {
+            type: NodeType.TOOL,
+            nodeId: node.name,
+            nodeDisplayName: node.displayName,
+            raw: result,
+            messageIds: [result.id!],
+          }),
+          ...toolResults.map((toolResult) =>
+            createHistoryStep<HistoryStep>(state.history, {
+              type: NodeType.TOOL,
+              nodeId: node.name,
+              nodeDisplayName: node.displayName,
+              raw: toolResult,
+              messageIds: [toolResult.id!],
+            }),
+          ),
+        ],
       };
     }
 
@@ -101,7 +143,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       console.log('AI Message', result.content);
     }
-
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.PROMPT_NODE,

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';

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/types/Agent.types.ts

@@ -29,18 +29,9 @@ 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',
-  JUNCTION_NODE = 'junctionNode',
-}
-
 export interface HistoryStep {
   type: NodeType;
   step: number;

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,