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

package/src/nodes/addPromptNode.ts

@@ -9,7 +9,6 @@ import { tool as langchainTool } from '@langchain/core/tools';
 import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
 import { EmitSignature, 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 { combinePlaybooks } from '../playbooks/playbooks';
@@ -41,343 +40,152 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }),
       );
 
-    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-
     // Get edges for the current node and format them
     const edges = agent.flows?.flatMap((flow: any) => flow.edges) || [];
     const nodeEdges = edges.filter((edge: any) => edge.source === node.name);
     const currentPromptNode = getCurrentPromptNode(node, nodeEdges);
-    const systemMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
-    const compiledPrompt = compilePrompt(systemMessage, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
-
-    // Check if we should use the agentic loop (only when humanInTheLoop is true)
-    const useAgenticLoop = node.humanInTheLoop === true;
-
-    /**
-     * When humanInTheLoop is true: Run an agentic loop that continues invoking the LLM
-     * after tool calls until we get a final AI message without tool calls.
-     *
-     * When humanInTheLoop is false: Return immediately after tool execution without
-     * additional LLM invocations.
-     */
-    let allMessages: any[] = [];
-    let allHistory: any[] = [];
-    let accumulatedStateUpdates = {};
-    let currentMessages = [...state.messages];
-    let finalAIMessage: AIMessage | null = null;
-    let loopCount = 0;
-    const MAX_LOOP_ITERATIONS = 10;
 
-    while (true) {
-      loopCount++;
+    let finalMessage = currentPromptNode;
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks);
+    if (combinedPlaybooks) {
+      finalMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
+    }
+    const compiledPrompt = compilePrompt(finalMessage, { 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);
+    }
 
-      // Break if we've reached the maximum number of iterations
-      if (loopCount > MAX_LOOP_ITERATIONS) {
-        logger.warn({
-          msg: '[Model] Reached maximum loop iterations, breaking agentic loop',
-          loopCount,
+    const startTime = Date.now();
+    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke(state.messages);
+    const endTime = Date.now();
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    logger.debug({
+      msg: '[Model] Model execution time',
+      executionTimeMs: endTime - startTime,
+      sessionId: state.sessionId,
+      node: node.displayName,
+    });
+    // Check if the result contains tool calls
+    if (result.tool_calls && result.tool_calls.length > 0) {
+      // Execute the tools
+      const toolResults = [];
+
+      for (const toolCall of result.tool_calls) {
+        const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
+        logger.info({
+          msg: `[Model] Calling tool inside prompt node`,
+          tool: matchedTool?.name,
           sessionId: state.sessionId,
           node: node.displayName,
         });
-        break;
-      }
-      const startTime = Date.now();
-
-      const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke([new SystemMessage(compiledPrompt), ...currentMessages]);
-
-      // Always pass accumulated state to interrupt manager
-      // Pass the accumulated messages from this prompt node execution
-      // If empty, pass undefined to avoid empty state updates
-      const interruptState =
-        allMessages.length > 0 || allHistory.length > 0
-          ? {
-              messages: allMessages,
-              history: allHistory,
-            }
-          : undefined;
-      await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, interruptState);
-
-      const endTime = Date.now();
-
-      logger.debug({
-        msg: '[Model] Model execution time',
-        executionTimeMs: endTime - startTime,
-        sessionId: state.sessionId,
-        node: node.displayName,
-      });
-
-      // Check if the result contains tool calls
-      if (result.tool_calls && result.tool_calls.length > 0) {
-        // Add the tool call message
-        allMessages.push(result);
-        allHistory.push(
-          createHistoryStep<HistoryStep>(state.history, {
-            type: NodeType.TOOL,
-            nodeId: node.name,
-            nodeDisplayName: node.displayName,
-            raw: result,
-            messageIds: [result.id!],
-          }),
-        );
-
-        // Execute the tools
-        // Track how many tool responses we've added for validation
-        const toolResponseStartIndex = allMessages.length;
-
-        // Ensure we process ALL tool calls, even if some fail
-        for (const toolCall of result.tool_calls) {
-          const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
-          logger.info({
-            msg: `[Model] Calling tool inside prompt node`,
-            tool: matchedTool?.name || toolCall.name,
-            toolCallId: toolCall.id,
-            sessionId: state.sessionId,
-            node: node.displayName,
-          });
-
-          if (matchedTool) {
-            try {
-              // Invoke the LangChain tool directly
-              const toolStartTime = Date.now();
-              const toolResult = await matchedTool.invoke(toolCall);
-              const toolEndTime = Date.now();
-
-              logger.debug({
-                msg: `[Tool] Tool result inside prompt node`,
-                tool: matchedTool?.name,
-                result: toolResult,
-                executionTimeMs: toolEndTime - toolStartTime,
-                sessionId: state.sessionId,
-                node: node.displayName,
-              });
-
-              // Add the tool result directly to allMessages
-              allMessages.push(toolResult);
-
-              // Check for queue after tool call
-              const systemMessageId = uuidv4();
-              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
-                messages: [
-                  ...allMessages,
-                  new SystemMessage({
-                    id: systemMessageId,
-                    content:
-                      'you called tool when the user send a new message, Consider calling the function again after user message is processed',
-                  }),
-                ],
-                history: [
-                  ...allHistory,
-                  createHistoryStep<HistoryStep>(state.history, {
-                    type: NodeType.TOOL,
-                    nodeId: node.name,
-                    nodeDisplayName: node.displayName,
-                    raw: toolResult,
-                    messageIds: [toolResult.id!, systemMessageId],
-                  }),
-                ],
-              });
-
-              const toolStateUpdate = extractToolStateResponse(toolResult);
-              // Properly merge memory and other state updates
-              accumulatedStateUpdates = {
-                ...accumulatedStateUpdates,
-                ...toolStateUpdate,
-                memory: { ...(accumulatedStateUpdates as any).memory, ...(toolStateUpdate as any).memory },
-              };
-
-              allHistory.push(
-                createHistoryStep<HistoryStep>(state.history, {
-                  type: NodeType.TOOL,
-                  nodeId: node.name,
-                  nodeDisplayName: node.displayName,
-                  raw: toolResult,
-                  messageIds: [toolResult.id!],
+        if (matchedTool) {
+          try {
+            // Invoke the LangChain tool directly
+            const startTime = Date.now();
+            const toolResult = await matchedTool.invoke(toolCall);
+            const endTime = Date.now();
+            logger.debug({
+              msg: `[Tool] Tool result inside prompt node`,
+              tool: matchedTool?.name,
+              result: toolResult,
+              executionTimeMs: endTime - startTime,
+              sessionId: state.sessionId,
+              node: node.displayName,
+            });
+            //check for queue after tool call
+            const systemMessageId = uuidv4();
+
+            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+              messages: [
+                result,
+                toolResult,
+                new SystemMessage({
+                  id: systemMessageId,
+                  content:
+                    'you called tool when the user send a new message, Consider calling the function again after user message is processed',
                 }),
-              );
-            } catch (err: any) {
-              if (err?.name === 'GraphInterrupt') throw err;
-              logger.error({
-                msg: `[Tool] Error executing tool inside prompt node`,
-                tool: toolCall.name,
-                err,
-                sessionId: state.sessionId,
-                node: node.displayName,
-              });
-              const errorMessage = new ToolMessage({
-                content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
-                tool_call_id: toolCall.id!,
-              });
-
-              // Add the error message directly to allMessages
-              allMessages.push(errorMessage);
-
-              // Check for queue after tool error
-              const errorSystemMessageId = uuidv4();
-              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
-                messages: [
-                  ...allMessages,
-                  new SystemMessage({
-                    id: errorSystemMessageId,
-                    content: 'Tool execution failed. Consider handling the error or calling another function if needed.',
-                  }),
-                ],
-                history: [
-                  ...allHistory,
-                  createHistoryStep<HistoryStep>(state.history, {
-                    type: NodeType.TOOL,
-                    nodeId: node.name,
-                    nodeDisplayName: node.displayName,
-                    raw: errorMessage,
-                    messageIds: [errorMessage.id!, errorSystemMessageId],
-                  }),
-                ],
-              });
-              allHistory.push(
+              ],
+              history: [
                 createHistoryStep<HistoryStep>(state.history, {
                   type: NodeType.TOOL,
                   nodeId: node.name,
                   nodeDisplayName: node.displayName,
-                  raw: errorMessage,
-                  messageIds: [errorMessage.id!],
+                  raw: toolResult,
+                  messageIds: [toolResult.id!, systemMessageId],
                 }),
-              );
-            }
-          } else {
+              ],
+            });
+            toolResults.push(toolResult);
+          } catch (err: any) {
+            if (err?.name === 'GraphInterrupt') throw err;
             logger.error({
-              msg: `[Tool] Model called tool but it was not found inside prompt node`,
+              msg: `[Tool] Error executing tool inside prompt node`,
               tool: toolCall.name,
-              toolCallId: toolCall.id,
+              err,
               sessionId: state.sessionId,
               node: node.displayName,
             });
-
-            // IMPORTANT: Create an error message for the missing tool with the correct tool_call_id
-            const missingToolMessage = new ToolMessage({
-              content: JSON.stringify({ error: `Tool '${toolCall.name}' not found` }),
-              tool_call_id: toolCall.id!, // This MUST match the tool_call_id from the AI message
-              name: toolCall.name,
+            const errorMessage = new ToolMessage({
+              content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+              tool_call_id: toolCall.id!,
             });
-
-            allMessages.push(missingToolMessage);
-            allHistory.push(
-              createHistoryStep<HistoryStep>(state.history, {
-                type: NodeType.TOOL,
-                nodeId: node.name,
-                nodeDisplayName: node.displayName,
-                raw: missingToolMessage,
-                messageIds: [missingToolMessage.id!],
-              }),
-            );
+            toolResults.push(errorMessage);
           }
-        }
-
-        // Validate that we have responses for ALL tool calls
-        const toolResponseCount = allMessages.length - toolResponseStartIndex;
-        if (toolResponseCount !== result.tool_calls.length) {
+        } else {
           logger.error({
-            msg: '[Model] Tool response count mismatch',
-            expectedCount: result.tool_calls.length,
-            actualCount: toolResponseCount,
-            toolCallIds: result.tool_calls.map((tc) => tc.id),
+            msg: `[Tool] Model called tool but it was not found inside prompt node`,
+            tool: toolCall.name,
             sessionId: state.sessionId,
             node: node.displayName,
           });
         }
-
-        // If humanInTheLoop is false, return immediately after tool execution
-        if (!useAgenticLoop) {
-          return {
-            ...accumulatedStateUpdates,
-            messages: allMessages,
-            history: allHistory,
-          };
-        }
-
-        // Otherwise, prepare for next iteration
-        // allMessages now contains all the new messages from this iteration
-        currentMessages = [...state.messages, ...allMessages];
-
-        // Continue the loop to see what the model wants to do next
-        continue;
-      } else {
-        // We got an AI message without tool calls - this is our final response
-        finalAIMessage = result;
-        break;
       }
-    }
-
-    // Process the final AI message if we have one
-    if (finalAIMessage) {
-      // Update state so AI_MESSAGE will get the latest state
-      const stateForAIMessage = structuredClone(state);
-      stateForAIMessage.goto = null;
-      stateForAIMessage.messages.push(...allMessages, finalAIMessage);
 
-      let aiMessageStateUpdate: any = { goto: null };
-      let messagesToReturn = [...allMessages, finalAIMessage];
-
-      if (finalAIMessage.getType() === 'ai') {
-        logger.info({
-          msg: `[Model] Response`,
-          content: finalAIMessage.content,
-          sessionId: state.sessionId,
-          node: node.displayName,
-        });
-
-        const results = await emit(AgentEvents.AI_MESSAGE, {
-          message: finalAIMessage.content as string,
-          state: stateForAIMessage,
-        });
-
-        const handlerResult = results.find((r) => r !== undefined);
-        if (handlerResult && handlerResult.state) {
-          aiMessageStateUpdate = { ...aiMessageStateUpdate, ...handlerResult.state };
-
-          // If the handler returned modified messages, use those instead
-          if (handlerResult.state.messages) {
-            messagesToReturn = [...allMessages, ...handlerResult.state.messages];
-          }
-        }
-      }
-
-      allHistory.push(
+      state.messages.push(result, ...toolResults);
+      state.history.push(
         createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.PROMPT_NODE,
+          type: NodeType.TOOL,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
-          raw: finalAIMessage.content,
-          messageIds: [finalAIMessage.id!],
+          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!],
+          }),
+        ),
       );
-
-      // Return all accumulated state updates and messages
-      return {
-        ...accumulatedStateUpdates,
-        ...aiMessageStateUpdate,
-        messages: messagesToReturn,
-        history: allHistory,
-      };
+      return state;
     }
 
-    // If we hit the loop limit without a final AI message, return what we have
-    if (loopCount > MAX_LOOP_ITERATIONS && allMessages.length > 0) {
-      logger.warn({
-        msg: '[Model] Returning accumulated messages after hitting loop limit',
-        messageCount: allMessages.length,
-        sessionId: state.sessionId,
-        node: node.displayName,
-      });
+    // Model text response
+    state.goto = null;
+    state.messages.push(result);
 
-      return {
-        ...accumulatedStateUpdates,
-        goto: null,
-        messages: allMessages,
-        history: allHistory,
-      };
+    if (result.getType() === 'ai') {
+      logger.info({ msg: `[Model] Response`, content: result.content, sessionId: state.sessionId, node: node.displayName });
+      await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state });
     }
 
-    // This should only be reached in unexpected cases
-    throw new Error('Unexpected state: no messages generated in prompt node');
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
+        type: NodeType.PROMPT_NODE,
+        nodeId: node.name,
+        nodeDisplayName: node.displayName,
+        raw: result.content,
+        messageIds: [result.id!],
+      }),
+    );
+
+    return state;
   };
   graph.addNode(node.name, callback);
 };

package/src/nodes/addToolNode.ts

@@ -40,31 +40,45 @@ export const addToolNode = async ({
       schema: matchedTool.input,
     });
 
-    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-    const systemPrompt = combinedPlaybooks
-      ? compilePrompt(combinedPlaybooks, { memory: state.memory, system: { currentTime: new Date().toISOString() } })
-      : '';
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks);
+    const toolPrompt = node.prompt;
+
+    let finalMessage = toolPrompt;
+    if (combinedPlaybooks) {
+      if (toolPrompt) {
+        finalMessage = combinedPlaybooks + '\n\n' + toolPrompt;
+      } else {
+        finalMessage = combinedPlaybooks;
+      }
+    }
+    if (finalMessage) {
+      const compiledPrompt = compilePrompt(finalMessage, { 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 startTime = Date.now();
-    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);
     const endTime = Date.now();
     logger.debug({ msg: '[Tool] Model execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
     await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    return {
-      goto: null,
-      messages: [AIToolCallMessage],
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.TOOL,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: AIToolCallMessage.tool_calls?.[0] || '',
-        messageIds: [AIToolCallMessage.id!],
-      }),
-    };
+    state.goto = null;
+    state.messages.push(AIToolCallMessage);
+
+    const historyMsg = createHistoryStep<HistoryStep>(state.history, {
+      type: NodeType.TOOL,
+      nodeId: node.name,
+      nodeDisplayName: node.displayName,
+      raw: AIToolCallMessage.tool_calls?.[0] || '',
+      messageIds: [AIToolCallMessage.id!],
+    });
+    state.history.push(historyMsg);
+
+    return state;
   };
   graph.addNode(node.name, callback);
 };

package/src/nodes/addToolRunNode.ts

@@ -4,13 +4,12 @@ import { Tool } from '../types/Tools.types';
 import { LLMProviders } from '../types/LLM.types';
 import { internalNodesSuffix, NodeType, ToolNode } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
-import { ToolMessage } from '@langchain/core/messages';
 import { z } from 'zod';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
+import { createHistoryStep } from '../utils/history';
+import { ToolMessage } from '@langchain/core/messages';
 
 type AddToolRunNodeParams = {
   graph: PreCompiledGraph;
@@ -37,7 +36,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
         const response = await matchedTool.execute({ input, state, agent });
         const endTime = Date.now();
         logger.debug({ msg: '[Tool] Tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
-        return response || {};
+        return response as ToolMessage;
       } catch (err) {
         logger.error({ message: '[Tool] Error executing tool', err, node: toolNode.displayName });
         throw err;
@@ -54,25 +53,26 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
       throw new Error('Tool call not found');
     }
     const toolCallMessage = await tool.invoke(toolCallObj.tool_calls[0]);
-    const toolStateUpdate = extractToolStateResponse(toolCallMessage as ToolMessage);
 
-    // Push the toolCallMessage into the messages array from toolStateUpdate
-    const updatedMessages = [toolCallMessage, ...(toolStateUpdate.messages || [])];
+    // Add the tool message to the state
+    state.messages.push(toolCallMessage);
 
-    // Return the full state update from the tool with the updated messages
-
-    return {
-      goto: null,
-      ...toolStateUpdate,
-      messages: updatedMessages,
-      history: createHistoryStep<HistoryStep>(state.history, {
+    // Add history step
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.TOOL,
         nodeId: toolNode.name,
         nodeDisplayName: toolNode.displayName,
         raw: toolCallMessage,
         messageIds: [toolCallObj.tool_calls[0].id],
       }),
-    };
+    );
+
+    // Clear goto if it was set
+    state.goto = null;
+
+    // Return the entire modified state
+    return state;
   };
 
   graph.addNode(buildToolRunNodeName(attachedToNodeName), callback);

package/src/nodes/addTriggerNode.ts

@@ -9,18 +9,18 @@ export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph;
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     logger.debug({ msg: `[Trigger] Executing trigger node`, node: node.displayName });
     if (node.triggerType === TriggerType.MANUAL) {
-      return {
-        goto: null,
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.goto = null;
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.TRIGGER,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
           raw: '',
           messageIds: [],
         }),
-      };
+      );
     }
-    return {};
+    return state;
   };
 
   graph.addNode(node.name, callback);

package/src/nodes/compilePrompt.ts

@@ -6,6 +6,9 @@ import { logger } from '../utils/logger';
  */
 export function compilePrompt(prompt: string, params: Record<string, any> = {}): string {
   try {
+    // Define system parameters
+    params.system = { currentTime: new Date().toISOString() };
+
     // First, render with EJS
     let compiledPrompt = ejs.render(prompt, params);
 

package/src/platform/mindedCheckpointSaver.ts

@@ -49,21 +49,21 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
     // Re-serialize and deserialize metadata to restore class information
     const metadata = tuple.metadata
       ? (() => {
-        const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-        return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-      })()
+          const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
+          return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
+        })()
       : undefined;
 
     // Re-serialize and deserialize pending writes to restore class information
     const pendingWrites: CheckpointPendingWrite[] = tuple.pendingWrites
       ? await Promise.all(
-        tuple.pendingWrites.map(async (write) => {
-          const [taskId, channel, value] = write;
-          const [valueType, serializedValue] = this.serde.dumpsTyped(value);
-          const deserializedValue = await this.serde.loadsTyped(valueType, serializedValue);
-          return [taskId, channel, deserializedValue] as CheckpointPendingWrite;
-        }),
-      )
+          tuple.pendingWrites.map(async (write) => {
+            const [taskId, channel, value] = write;
+            const [valueType, serializedValue] = this.serde.dumpsTyped(value);
+            const deserializedValue = await this.serde.loadsTyped(valueType, serializedValue);
+            return [taskId, channel, deserializedValue] as CheckpointPendingWrite;
+          }),
+        )
       : [];
 
     return {
@@ -93,9 +93,9 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
       // Re-serialize and deserialize metadata to restore class information
       const metadata = tuple.metadata
         ? (() => {
-          const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-          return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-        })()
+            const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
+            return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
+          })()
         : undefined;
 
       yield {