@minded-ai/mindedjs 1.0.151-beta-1 → 2.0.0-beta1

package/src/agent.ts

@@ -28,14 +28,14 @@ import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
 import { InterruptPayload, InterruptSessionManager, InterruptType } from './interrupts/BaseInterruptSessionManager';
 import { createInterruptSessionManager } from './interrupts/interruptSessionManagerFactory';
-import { HumanMessage } from '@langchain/core/messages';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
 import { VoiceSession } from './voice/voiceSession';
 import { BaseVoiceMessage, OnVoiceAudioOut, VectorStoreQueryRequest, VectorStoreQueryResponse } from './platform/mindedConnectionTypes';
 import { PIIGateway, PIIGatewayInstance } from './platform/piiGateway';
 import { logger } from './utils/logger';
-import { loadPlaybooks, Playbook } from './playbooks/playbooks';
+import { combinePlaybooks, loadPlaybooks, Playbook } from './playbooks/playbooks';
 import { createTriggerHistoryStep } from './utils/history';
 import { timerHandlers } from './internalTools/timer';
 import { parseAttachments, combineContentWithAttachments } from './platform/utils/parseAttachments';
@@ -43,6 +43,7 @@ import { ToolExecutor, ToolExecutionRequest, ToolExecutionResponse } from './pla
 import { initLibraryActionsRunnerTools, loadFlows } from './utils/agentUtils';
 import { Document } from '@langchain/core/documents';
 import { getInitialState } from './types/LangGraph.types';
+import { compilePrompt } from './nodes/compilePrompt';
 
 type CreateAgentParams<Memory> = {
   memorySchema: z.ZodSchema;
@@ -423,7 +424,7 @@ export class Agent {
       // Try to acquire lock atomically (unless bypassing session check)
       if (!bypassSessionCheck && !(await this.interruptSessionManager.lock(sessionId))) {
         // Could not acquire lock, session is being processed - enqueue the message
-        logger.debug({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
+        logger.info({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
         await this.interruptSessionManager.enqueueMessage(sessionId, {
           triggerBody,
           triggerName,
@@ -441,11 +442,20 @@ export class Agent {
         state = getInitialState(this.memorySchema);
       }
 
-      // Initialize state update with defaults
-      let stateUpdate: Partial<State<z.infer<typeof this.memorySchema>>> = {
-        sessionId,
-        sessionType: SessionType.TEXT,
-      };
+      state.sessionId = sessionId;
+      state.sessionType = SessionType.TEXT;
+
+      // Add playbooks to messages
+      const combinedPlaybooks = combinePlaybooks(this.playbooks);
+      if (combinedPlaybooks) {
+        const compiledPrompt = compilePrompt(combinedPlaybooks, { memory: state.memory });
+        const systemMessage = new SystemMessage(compiledPrompt);
+        if (state.messages.length === 0 || state.messages[0].getType() === 'system') {
+          state.messages[0] = systemMessage;
+        } else {
+          state.messages.unshift(systemMessage);
+        }
+      }
 
       // Process special trigger types (dashboard/voice messages)
       if (triggerName === KnownTriggerNames.DASHBOARD_MESSAGE || triggerName === KnownTriggerNames.VOICE_MESSAGE) {
@@ -453,21 +463,14 @@ export class Agent {
         const attachmentsString = parseAttachments(triggerBody);
         const finalContent = combineContentWithAttachments(triggerBody.content || '', attachmentsString);
         if (finalContent) {
-          stateUpdate.messages = [new HumanMessage({ content: finalContent, id: uuidv4() })];
+          state.messages.push(new HumanMessage({ content: finalContent, id: uuidv4() }));
         }
         triggerBody.content = finalContent;
-        stateUpdate.sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
+        state.sessionType = triggerName === KnownTriggerNames.VOICE_MESSAGE ? SessionType.VOICE : SessionType.TEXT;
       }
 
-      // Merge current state with any updates we've made so far
-      const currentState = { ...state, ...stateUpdate } as State<z.infer<typeof this.memorySchema>>;
-
       // Emit trigger event and let handlers modify the state
-      const results = await this.emit(AgentEvents.TRIGGER_EVENT, {
-        triggerName,
-        triggerBody,
-        state: currentState,
-      });
+      const results = await this.emit(AgentEvents.TRIGGER_EVENT, { triggerName, triggerBody, state });
 
       // Process handler results
       const handlerResult = results.find((r) => r !== undefined);
@@ -477,18 +480,14 @@ export class Agent {
           await this.interruptSessionManager.release(sessionId);
           return;
         }
-        // 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 (!state.messages || state.messages.length === 0) {
         if (appName && triggerTypeToDefaultMessage[appName]?.[triggerName]) {
-          stateUpdate.messages = triggerTypeToDefaultMessage[appName][triggerName](triggerBody);
+          state.messages = triggerTypeToDefaultMessage[appName][triggerName](triggerBody);
         } else {
-          stateUpdate.messages = [new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() })];
+          state.messages = [new HumanMessage({ content: JSON.stringify(triggerBody), id: uuidv4() })];
         }
       }
 
@@ -501,13 +500,10 @@ export class Agent {
       const suffixes = Object.values(internalNodesSuffix);
       nodeToBeInvoked = nodeToBeInvoked.replace(new RegExp(suffixes.join('|'), 'g'), '');
 
-      // 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.history, nodeToBeInvoked, messageIds, triggerName, triggerBody, appName);
-        // History reducer expects an array or single item
-        stateUpdate.history = [historyStep];
-      }
+      // Create a history step
+      const messageIds = state.messages?.map((m) => m.id!) || [];
+      const historyStep = createTriggerHistoryStep(state.history, nodeToBeInvoked, messageIds, triggerName, triggerBody, appName);
+      state.history.push(historyStep);
 
       // 3) Handle interrupts/goto, else normal invoke
       let res;
@@ -519,30 +515,20 @@ export class Agent {
           // For HUMAN_IN_THE_LOOP, use resume with the state update
           res = await this.compiledGraph.invoke(
             new Command({
-              resume: { ...stateUpdate, goto: null },
+              resume: { ...state, goto: null },
             }),
             langgraphConfig,
           );
         } else if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
-          // 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];
-              }
-            });
+            state = updatedInterruptState;
           }
 
           // Then use update with the full object and empty resume
           res = await this.compiledGraph.invoke(
             new Command({
-              update: finalState,
+              update: state,
               resume: '',
             }),
             langgraphConfig,
@@ -552,7 +538,7 @@ export class Agent {
         res = await this.compiledGraph.invoke(
           new Command({
             update: {
-              ...stateUpdate,
+              ...state,
               goto: null, //reset the goto
             },
             goto: state.goto,
@@ -560,7 +546,7 @@ export class Agent {
           langgraphConfig,
         );
       } else {
-        res = await this.compiledGraph.invoke(stateUpdate, langgraphConfig);
+        res = await this.compiledGraph.invoke(state, langgraphConfig);
       }
       const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
       if (nextMessage) {
@@ -574,7 +560,7 @@ export class Agent {
         if (nextMessage.appName) {
           invokeParams.appName = nextMessage.appName;
         }
-        logger.debug({ msg: 'Invoking next message in the queue', invokeParams });
+        logger.info({ msg: 'Invoking next message in the queue', invokeParams });
         return await this.invoke(invokeParams);
       }
 
@@ -596,11 +582,6 @@ export class Agent {
       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;
       }
@@ -668,9 +649,7 @@ export class Agent {
   // Public API for registering event listeners
   public on<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
     event: E,
-    handler: (
-      payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[E],
-    ) => Promise<AgentEventResponsePayloads<z.infer<typeof this.memorySchema>>[E] | void>,
+    handler: (payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[E]) => Promise<AgentEventResponsePayloads[E] | void>,
   ): void {
     if (!this.eventHandlers[event]) {
       this.eventHandlers[event] = [];
@@ -683,7 +662,7 @@ export class Agent {
   public async emit<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
     event: E,
     payload: AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>[E],
-  ): Promise<AgentEventResponsePayloads<z.infer<typeof this.memorySchema>>[E][]> {
+  ): Promise<AgentEventResponsePayloads[E][]> {
     if (!this.eventHandlers[event]) {
       return [];
     }
@@ -843,16 +822,11 @@ export class Agent {
     const state = await this.compiledGraph.getState(this.getLangraphConfig(params.sessionId));
 
     // Emit voice session start event
-    const results = await this.emit(AgentEvents.VOICE_SESSION_START, {
+    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;
   }
 

package/src/edges/createLogicalRouter.ts

@@ -30,17 +30,12 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
         logger.debug({ msg: '[LogicalCondition] Evaluating condition', edge, sessionId: state.sessionId });
 
         // Emit ON_LOGICAL_CONDITION event
-        const onLogicalConditionRes = await agent.emit(AgentEvents.ON_LOGICAL_CONDITION, {
+        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 = `
@@ -96,7 +91,7 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
         });
 
         // Emit ON_LOGICAL_CONDITION_RESULT event
-        const onLogicalConditionResultRes = await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
+        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
           edge,
           state,
           condition: edge.condition,
@@ -104,14 +99,8 @@ 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 });
-        }
+        const goto = state.goto;
+        state.goto = null;
 
         if (goto) {
           logger.debug({ msg: `[Router] Jumping to node`, node: goto, sessionId: state.sessionId });
@@ -158,10 +147,6 @@ export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionE
 
         const onLogicalConditionResultHandlerResult = onLogicalConditionResultRes.find((r) => r !== undefined);
         let throwError = false;
-        if (onLogicalConditionResultHandlerResult && onLogicalConditionResultHandlerResult.state) {
-          state = { ...state, ...onLogicalConditionResultHandlerResult.state };
-          await agent.updateState({ sessionId: state.sessionId, state });
-        }
         throwError = onLogicalConditionResultHandlerResult?.throwError == true;
 
         // Continue to next edge instead of failing completely

package/src/events/AgentEvents.ts

@@ -42,26 +42,17 @@ export type AgentEventRequestPayloads<Memory> = {
   };
 };
 
-export type AgentEventResponsePayloads<Memory> = {
-  [AgentEvents.AI_MESSAGE]: {
-    state?: Partial<State<Memory>>;
-  };
+export type AgentEventResponsePayloads = {
+  [AgentEvents.AI_MESSAGE]: void;
   [AgentEvents.TRIGGER_EVENT]: {
     isQualified: boolean;
-    state?: Partial<State<Memory>>;
-  };
-  [AgentEvents.VOICE_SESSION_START]: {
-    state?: Partial<State<Memory>>;
   };
+  [AgentEvents.VOICE_SESSION_START]: void;
   [AgentEvents.ERROR]: {
     throwError: boolean;
-    state?: Partial<State<Memory>>;
-  };
-  [AgentEvents.ON_LOGICAL_CONDITION]: {
-    state?: Partial<State<Memory>>;
   };
+  [AgentEvents.ON_LOGICAL_CONDITION]: void;
   [AgentEvents.ON_LOGICAL_CONDITION_RESULT]: {
-    state?: Partial<State<Memory>>;
-    throwError?: boolean;
+    throwError: boolean;
   };
 };

package/src/internalTools/libraryActionRunnerTool.ts

@@ -42,7 +42,6 @@ const libraryActionRunnerToolCreator = (actionKey: string, nodeTitle: string): T
         const result = await libraryTool.default.execute({ input, state, agent });
 
         return {
-          state: result?.state,
           result: result?.result,
         };
       } catch (err) {

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -14,7 +14,7 @@ export type QueuedMessage = TriggerEvent;
 
 export interface InterruptPayload {
   type: InterruptType;
-  updateStateObject?: Partial<State>;
+  updateStateObject?: State;
   id?: string;
 }
 
@@ -57,20 +57,14 @@ export abstract class BaseInterruptSessionManager implements InterruptSessionMan
   protected abstract getQueuedMessages(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
 
   // Common implementation of checkQueueAndInterrupt
-  async checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean> {
+  async checkQueueAndInterrupt(sessionId: string, updateStateObject?: State): Promise<boolean> {
     if (await this.hasQueuedMessages(sessionId)) {
       logger.trace({ msg: 'graph has queued messagess, interrupting graph', sessionId });
 
       // 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,
-        };
+        interruptPayload.updateStateObject = updateStateObject;
       }
 
       throw new GraphInterrupt([

package/src/nodes/addAppToolNode.ts

@@ -12,6 +12,7 @@ import { createHistoryStep } from '../utils/history';
 import { Tool } from '../types/Tools.types';
 import { combinePlaybooks } from '../playbooks/playbooks';
 import { compilePrompt } from './compilePrompt';
+import { ToolMessage } from '@langchain/core/messages';
 
 export const addAppToolNode = async ({
   graph,
@@ -69,13 +70,15 @@ export const addAppToolNode = async ({
     User instructions for choosing tool parameters are:
         ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}`;
 
-    const compiledPrompt = compilePrompt(message, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
+    const compiledPrompt = compilePrompt(message, { memory: state.memory });
+    const systemMessage = new SystemMessage(compiledPrompt);
+    if (state.messages.length === 0 || state.messages[0].getType() === 'system') {
+      state.messages[0] = systemMessage;
+    } else {
+      state.messages.unshift(systemMessage);
+    }
 
-    const AIToolCallMessage = await llm
-      .bindTools([tool], {
-        tool_choice: tool.name,
-      })
-      .invoke([...state.messages, new SystemMessage(compiledPrompt)]);
+    const AIToolCallMessage = await llm.bindTools([tool], { tool_choice: tool.name }).invoke(state.messages);
     AIToolCallMessage.tool_calls[0].args = {
       ...AIToolCallMessage.tool_calls[0].args,
       ...cleanedParameters, //user set parameters have priority over ai generated parameters
@@ -86,10 +89,14 @@ export const addAppToolNode = async ({
         nodeType: NodeType.APP_TOOL,
       },
     };
-    return {
-      goto: null,
-      messages: [AIToolCallMessage, toolCallMessage],
-      history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
+
+    state.goto = null;
+    state.messages.push(AIToolCallMessage);
+    if (toolCallMessage instanceof ToolMessage) {
+      state.messages.push(toolCallMessage);
+    }
+    state.history.push(
+      createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
         type: NodeType.APP_TOOL,
         nodeId: node.name,
         nodeDisplayName: node.displayName!,
@@ -97,7 +104,8 @@ export const addAppToolNode = async ({
         appName: node.appName,
         messageIds: [AIToolCallMessage.tool_calls[0].id],
       }),
-    };
+    );
+    return state;
   };
   graph.addNode(node.name, callback);
 };

package/src/nodes/addBrowserTaskNode.ts

@@ -54,22 +54,26 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = z.object(schemaFields);
 
     // Create langchain tool
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: 'browser-task',
       description: node.prompt,
       schema: zodSchema,
     });
 
-    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-    const systemPrompt = combinedPlaybooks ? compilePrompt(combinedPlaybooks, { state, currentTime: new Date().toISOString() }) : '';
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks);
+    if (combinedPlaybooks) {
+      const compiledPrompt = compilePrompt(combinedPlaybooks, { memory: state.memory });
+      const systemMessage = new SystemMessage(compiledPrompt);
+      if (state.messages.length === 0 || state.messages[0].getType() === 'system') {
+        state.messages[0] = systemMessage;
+      } else {
+        state.messages.unshift(systemMessage);
+      }
+    }
 
     try {
       // Use LLM to generate tool call
-      const AIToolCallMessage: AIMessage = await llm
-        .bindTools([tool], {
-          tool_choice: tool.name,
-        })
-        .invoke([...state.messages, new SystemMessage(systemPrompt)]);
+      const AIToolCallMessage: AIMessage = await llm.bindTools([tool], { tool_choice: tool.name }).invoke(state.messages);
       await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
       if (!AIToolCallMessage.tool_calls || AIToolCallMessage.tool_calls.length === 0) {
         throw new Error('No tool calls generated by LLM');
@@ -141,16 +145,17 @@ ${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(i
         },
       });
 
-      return {
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.messages.push(toolCallingMessage);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.BROWSER_TASK,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
           raw: { taskId: session.sessionId, liveUrl: session.liveViewUrl, inputParams },
           messageIds: [toolCallingMessage.id!],
         }),
-        messages: [toolCallingMessage],
-      };
+      );
+      return state;
     } catch (error: any) {
       logger.error(`Error creating browser task node ${node.displayName}: ${error}`);
 
@@ -180,16 +185,17 @@ ${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(i
         },
       });
 
-      return {
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.messages.push(toolCallingMessage);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.BROWSER_TASK,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
           raw: error,
           messageIds: [errorMessageId],
         }),
-        messages: [toolCallingMessage],
-      };
+      );
+      return state;
     }
   };
   graph.addNode(node.name, callback);

package/src/nodes/addBrowserTaskRunNode.ts

@@ -33,7 +33,6 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
     const { sessionId, cdpUrl, keepAlive, hooks, outputSchema } = toolCallMindedMetadata;
 
     try {
-
       if (inputParams.error) {
         throw new Error(inputParams.error);
       }
@@ -112,16 +111,17 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
         },
       });
 
-      return {
-        messages: [toolMessage, updatedAIMessage],
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.messages.push(toolMessage, updatedAIMessage);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.BROWSER_TASK,
           nodeId: browserTaskNode.name,
           nodeDisplayName: browserTaskNode.displayName,
           raw: result,
           messageIds: [toolMessage.id!],
         }),
-      };
+      );
+      return state;
     } catch (error: any) {
       logger.error({ msg: 'Error executing browser task run node', error: error.toString() });
 
@@ -163,16 +163,17 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
         },
       });
 
-      return {
-        messages: [errorToolMessage, updatedAIMessage],
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.messages.push(errorToolMessage, updatedAIMessage);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.BROWSER_TASK,
           nodeId: browserTaskNode.name,
           nodeDisplayName: browserTaskNode.displayName,
           raw: error,
           messageIds: [],
         }),
-      };
+      );
+      return state;
     }
   };
 

package/src/nodes/addJumpToNode.ts

@@ -9,15 +9,16 @@ export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph;
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     logger.info({ msg: `Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}` });
     // No state modifications are necessary; control flow is handled via edges.
-    return {
-      goto: node.targetNodeId,
-      history: createHistoryStep<HistoryStep>(state.history, {
+    state.goto = node.targetNodeId;
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.JUMP_TO_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: '',
       }),
-    };
+    );
+    return state;
   };
 
   graph.addNode(node.name, callback);

package/src/nodes/addJunctionNode.ts

@@ -6,15 +6,16 @@ import { HistoryStep } from '../types/Agent.types';
 
 export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    return {
-      goto: null,
-      history: createHistoryStep<HistoryStep>(state.history, {
+    state.goto = null;
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.JUNCTION,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: '',
       }),
-    };
+    );
+    return state;
   };
   graph.addNode(node.name, callback);
 };