@langchain/langgraph 0.0.10-rc.1 → 0.0.11

package/README.md

@@ -10,12 +10,11 @@ It is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache B
 The current interface exposed is one inspired by [NetworkX](https://networkx.org/documentation/latest/).
 
 The main use is for adding **cycles** to your LLM application.
-Crucially, this is NOT a **DAG** framework.
+Crucially, LangGraph is NOT optimized for only **DAG** workflows.
 If you want to build a DAG, you should use just use [LangChain Expression Language](https://js.langchain.com/docs/expression_language/).
 
 Cycles are important for agent-like behaviors, where you call an LLM in a loop, asking it what action to take next.
 
-
 > Looking for the Python version? Click [here](https://github.com/langchain-ai/langgraph).
 
 ## Installation
@@ -24,18 +23,257 @@ Cycles are important for agent-like behaviors, where you call an LLM in a loop,
 npm install @langchain/langgraph
 ```
 
-## Quick Start
+## Quick start
+
+One of the central concepts of LangGraph is state. Each graph execution creates a state that is passed between nodes in the graph as they execute, and each node updates this internal state with its return value after it executes. The way that the graph updates its internal state is defined by either the type of graph chosen or a custom function.
+
+State in LangGraph can be pretty general, but to keep things simpler to start, we'll show off an example where the graph's state is limited to a list of chat messages using the built-in `MessageGraph` class. This is convenient when using LangGraph with LangChain chat models because we can return chat model output directly.
+
+First, install the LangChain OpenAI integration package:
+
+```shell
+npm i @langchain/openai
+```
+
+We also need to export some environment variables:
+
+```shell
+export OPENAI_API_KEY=sk-...
+```
+
+And now we're ready! The graph below contains a single node called `"oracle"` that executes a chat model, then returns the result:
+
+```ts
+import { ChatOpenAI } from "@langchain/openai";
+import { HumanMessage, BaseMessage, } from "@langchain/core/messages";
+import { END, MessageGraph } from "@langchain/langgraph";
+
+const model = new ChatOpenAI({ temperature: 0 });
+
+const graph = new MessageGraph();
+
+graph.addNode("oracle", async (state: BaseMessage[]) => {
+  return model.invoke(state);
+});
+
+graph.addEdge("oracle", END);
+
+graph.setEntryPoint("oracle");
+
+const runnable = graph.compile();
+```
+
+Let's run it!
+
+```ts
+// For Message graph, input should always be a message or list of messages.
+const res = await runnable.invoke(
+  new HumanMessage("What is 1 + 1?")
+);
+```
+
+```ts
+[
+  HumanMessage {
+    content: 'What is 1 + 1?',
+    additional_kwargs: {}
+  },
+  AIMessage {
+    content: '1 + 1 equals 2.',
+    additional_kwargs: { function_call: undefined, tool_calls: undefined }
+  }
+]
+```
+
+So what did we do here? Let's break it down step by step:
+
+1. First, we initialize our model and a `MessageGraph`.
+2. Next, we add a single node to the graph, called `"oracle"`, which simply calls the model with the given input.
+3. We add an edge from this `"oracle"` node to the special value `END`. This means that execution will end after current node.
+4. We set `"oracle"` as the entrypoint to the graph.
+5. We compile the graph, ensuring that no more modifications to it can be made.
+
+Then, when we execute the graph:
+
+1. LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, `"oracle"`.
+2. The `"oracle"` node executes, invoking the chat model.
+3. The chat model returns an `AIMessage`. LangGraph adds this to the state.
+4. Execution progresses to the special `END` value and outputs the final state.
+
+And as a result, we get a list of two chat messages as output.
+
+### Interaction with LCEL
+
+As an aside for those already familiar with LangChain - `addNode` actually takes any runnable as input. In the above example, the passed function is automatically converted, but we could also have passed the model directly:
+
+```ts
+graph.addNode("oracle", model);
+```
+
+In which case the `.invoke()` method will be called when the graph executes.
+
+Just make sure you are mindful of the fact that the input to the runnable is the entire current state. So this will fail:
+
+```ts
+// This will NOT work with MessageGraph!
+import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
+
+const prompt = ChatPromptTemplate.fromMessages([
+    ["system", "You are a helpful assistant who always speaks in pirate dialect"],
+    MessagesPlaceholder("messages"),
+]);
+
+const chain = prompt.pipe(model);
+
+// State is a list of messages, but our chain expects an object input:
+//
+// { messages: [] }
+//
+// Therefore, the graph will throw an exception when it executes here.
+graph.addNode("oracle", chain);
+```
+
+## Conditional edges
+
+Now, let's move onto something a little bit less trivial. Because math can be difficult for LLMs, let's allow the LLM to conditionally call a calculator node using tool calling.
+
+```bash
+npm i langchain @langchain/openai
+```
+
+We'll recreate our graph with an additional `"calculator"` that will take the result of the most recent message, if it is a math expression, and calculate the result.
+We'll also bind the calculator to the OpenAI model as a tool to allow the model to optionally use the tool if it deems necessary:
+
+```ts
+import {
+  ToolMessage,
+} from "@langchain/core/messages";
+import { Calculator } from "langchain/tools/calculator";
+import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
+
+const model = new ChatOpenAI({
+  temperature: 0,
+}).bind({
+  tools: [convertToOpenAITool(new Calculator())],
+  tool_choice: "auto",
+});
+
+const graph = new MessageGraph();
+
+graph.addNode("oracle", async (state: BaseMessage[]) => {
+  return model.invoke(state);
+});
+
+graph.addNode("calculator", async (state: BaseMessage[]) => {
+  const tool = new Calculator();
+  const toolCalls =
+    state[state.length - 1].additional_kwargs.tool_calls ?? [];
+  const calculatorCall = toolCalls.find(
+    (toolCall) => toolCall.function.name === "calculator"
+  );
+  if (calculatorCall === undefined) {
+    throw new Error("No calculator input found.");
+  }
+  const result = await tool.invoke(
+    JSON.parse(calculatorCall.function.arguments)
+  );
+  return new ToolMessage({
+    tool_call_id: calculatorCall.id,
+    content: result,
+  });
+});
+
+graph.addEdge("calculator", END);
+
+graph.setEntryPoint("oracle");
+```
+
+Now let's think - what do we want to have happen?
+
+- If the `"oracle"` node returns a message expecting a tool call, we want to execute the `"calculator"` node
+- If not, we can just end execution
+
+We can achieve this using **conditional edges**, which routes execution to a node based on the current state using a function.
+
+Here's what that looks like:
+
+```ts
+const router = (state: BaseMessage[]) => {
+  const toolCalls =
+    state[state.length - 1].additional_kwargs.tool_calls ?? [];
+  if (toolCalls.length) {
+    return "calculator";
+  } else {
+    return "end";
+  }
+};
+
+graph.addConditionalEdges("oracle", router, {
+  calculator: "calculator",
+  end: END,
+});
+```
+
+If the model output contains a tool call, we move to the `"calculator"` node. Otherwise, we end.
+
+Great! Now all that's left is to compile the graph and try it out. Math-related questions are routed to the calculator tool:
+
+```ts
+const runnable = graph.compile();
+const mathResponse = await runnable.invoke(new HumanMessage("What is 1 + 1?"));
+```
+
+```ts
+[
+  HumanMessage {
+    content: 'What is 1 + 1?',
+    additional_kwargs: {}
+  },
+  AIMessage {
+    content: '',
+    additional_kwargs: { function_call: undefined, tool_calls: [Array] }
+  },
+  ToolMessage {
+    content: '2',
+    name: undefined,
+    additional_kwargs: {},
+    tool_call_id: 'call_P7KWQoftVsj6fgsqKyolWp91'
+  }
+]
+```
+
+While conversational responses are outputted directly:
+
+```ts
+const otherResponse = await runnable.invoke(new HumanMessage("What is your name?"));
+```
+
+```ts
+[
+  HumanMessage {
+    content: 'What is your name?',
+    additional_kwargs: {}
+  },
+  AIMessage {
+    content: 'My name is Assistant. How can I assist you today?',
+    additional_kwargs: { function_call: undefined, tool_calls: undefined }
+  }
+]
+```
+
+## Cycles
+
+Now, let's go over a more general example with a cycle. We will recreate the [`AgentExecutor`](https://js.langchain.com/docs/modules/agents/concepts#agentexecutor) class from LangChain.
 
-Here we will go over an example of recreating the [`AgentExecutor`](https://js.langchain.com/docs/modules/agents/concepts#agentexecutor) class from LangChain.
 The benefits of creating it with LangGraph is that it is more modifiable.
 
-We will also want to install some LangChain packages:
+We will need to install some LangChain packages:
 
 ```shell
 npm install langchain @langchain/core @langchain/community @langchain/openai
 ```
 
-We also need to export some environment variables needed for our agent.
+We also need additional environment variables.
 
 ```shell
 export OPENAI_API_KEY=sk-...
@@ -52,7 +290,7 @@ export LANGCHAIN_ENDPOINT=https://api.langchain.com
 
 ### Set up the tools
 
-We will first define the tools we want to use.
+As above, we will first define the tools we want to use.
 For this simple example, we will use a built-in search tool via Tavily.
 However, it is really easy to create your own tools - see documentation [here](https://js.langchain.com/docs/modules/agents/tools/dynamic) on how to do that.
 
@@ -62,8 +300,7 @@ import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
 const tools = [new TavilySearchResults({ maxResults: 1 })];
 ```
 
-We can now wrap these tools in a simple ToolExecutor.
-This is a real simple class that takes in a ToolInvocation and calls that tool, returning the output.
+We can now wrap these tools in a ToolExecutor, which simply takes in a ToolInvocation and calls that tool, returning the output.
 
 A ToolInvocation is any type with `tool` and `toolInput` attribute.
 
@@ -71,25 +308,18 @@ A ToolInvocation is any type with `tool` and `toolInput` attribute.
 ```typescript
 import { ToolExecutor } from "@langchain/langgraph/prebuilt";
 
-const toolExecutor = new ToolExecutor({
-  tools
-});
+const toolExecutor = new ToolExecutor({ tools });
 ```
 
 ### Set up the model
 
 Now we need to load the chat model we want to use.
-Importantly, this should satisfy two criteria:
-
-1. It should work with messages. We will represent all agent state in the form of messages, so it needs to be able to work well with them.
-2. It should work with OpenAI function calling. This means it should either be an OpenAI model or a model that exposes a similar interface.
-
-Note: these model requirements are not requirements for using LangGraph - they are just requirements for this one example.
+This time, we'll use the older function calling interface. This walkthrough will use OpenAI, but we can choose any model that supports OpenAI function calling.
 
 ```typescript
 import { ChatOpenAI } from "@langchain/openai";
 
-// We will set streaming=True so that we can stream tokens
+// We will set streaming: true so that we can stream tokens
 // See the streaming section for more information on this.
 const model = new ChatOpenAI({
   temperature: 0,
@@ -113,9 +343,9 @@ const newModel = model.bind({
 
 ### Define the agent state
 
-The main type of graph in `langgraph` is the `StatefulGraph`.
+This time, we'll use the more general `StateGraph`.
 This graph is parameterized by a state object that it passes around to each node.
-Each node then returns operations to update that state.
+Remember that each node then returns operations to update that state.
 These operations can either SET specific attributes on the state (e.g. overwrite the existing values) or ADD to the existing attribute.
 Whether to set or add is denoted by annotating the state object you construct the graph with.
 
@@ -133,13 +363,17 @@ const agentState = {
     value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
     default: () => [],
   }
-}
+};
 ```
 
+You can think of the `MessageGraph` used in the initial example as a preconfigured version of this graph. The difference is that the state is directly a list of messages,
+instead of an object containing a key called `"messages"` whose value is a list of messages.
+The `MessageGraph` update step is similar to the one above where we always append the returned values of a node to the internal state.
+
 ### Define the nodes
 
 We now need to define a few different nodes in our graph.
-In `langgraph`, a node can be either a function or a [runnable](https://js.langchain.com/docs/expression_language/).
+In LangGraph, a node can be either a function or a [runnable](https://js.langchain.com/docs/expression_language/).
 There are two main nodes we need for this:
 
 1. The agent: responsible for deciding what (if any) actions to take.
@@ -160,6 +394,10 @@ Let's define the nodes, as well as a function to decide how what conditional edg
 ```typescript
 import { FunctionMessage } from "@langchain/core/messages";
 import { AgentAction } from "@langchain/core/agents";
+import {
+  ChatPromptTemplate,
+  MessagesPlaceholder
+} from "@langchain/core/prompts";
 
 // Define the function that determines whether to continue or not
 const shouldContinue = (state: { messages: Array<BaseMessage> }) => {
@@ -191,7 +429,7 @@ const _getAction = (state: { messages: Array<BaseMessage> }): AgentAction => {
   // We construct an AgentAction from the function_call
   return {
     tool: lastMessage.additional_kwargs.function_call.name,
-    toolInput: JSON.stringify(
+    toolInput: JSON.parse(
       lastMessage.additional_kwargs.function_call.arguments
     ),
     log: "",
@@ -200,11 +438,18 @@ const _getAction = (state: { messages: Array<BaseMessage> }): AgentAction => {
 
 // Define the function that calls the model
 const callModel = async (
-  state: { messages: Array<BaseMessage> },
-  config?: RunnableConfig
+  state: { messages: Array<BaseMessage> }
 ) => {
   const { messages } = state;
-  const response = await newModel.invoke(messages, config);
+  // You can use a prompt here to tweak model behavior.
+  // You can also just pass messages to the model directly.
+  const prompt = ChatPromptTemplate.fromMessages([
+    ["system", "You are a helpful assistant."],
+    new MessagesPlaceholder("messages"),
+  ]);
+  const response = await prompt
+    .pipe(newModel)
+    .invoke({ messages });
   // We return a list, because this will get added to the existing list
   return {
     messages: [response],
@@ -212,12 +457,11 @@ const callModel = async (
 };
 
 const callTool = async (
-  state: { messages: Array<BaseMessage> },
-  config?: RunnableConfig
+  state: { messages: Array<BaseMessage> }
 ) => {
   const action = _getAction(state);
   // We call the tool_executor and get back a response
-  const response = await toolExecutor.invoke(action, config);
+  const response = await toolExecutor.invoke(action);
   // We use the response to create a FunctionMessage
   const functionMessage = new FunctionMessage({
     content: response,
@@ -242,8 +486,8 @@ const workflow = new StateGraph({
 });
 
 // Define the two nodes we will cycle between
-workflow.addNode("agent", new RunnableLambda({ func: callModel }));
-workflow.addNode("action", new RunnableLambda({ func: callTool }));
+workflow.addNode("agent", callModel);
+workflow.addNode("action", callTool);
 
 // Set the entrypoint as `agent`
 // This means that this node is the first one called
@@ -251,23 +495,23 @@ workflow.setEntryPoint("agent");
 
 // We now add a conditional edge
 workflow.addConditionalEdges(
-// First, we define the start node. We use `agent`.
-// This means these are the edges taken after the `agent` node is called.
-"agent",
-// Next, we pass in the function that will determine which node is called next.
-shouldContinue,
-// Finally we pass in a mapping.
-// The keys are strings, and the values are other nodes.
-// END is a special node marking that the graph should finish.
-// What will happen is we will call `should_continue`, and then the output of that
-// will be matched against the keys in this mapping.
-// Based on which one it matches, that node will then be called.
-{
-  // If `tools`, then we call the tool node.
-  continue: "action",
-  // Otherwise we finish.
-  end: END
-}
+  // First, we define the start node. We use `agent`.
+  // This means these are the edges taken after the `agent` node is called.
+  "agent",
+  // Next, we pass in the function that will determine which node is called next.
+  shouldContinue,
+  // Finally we pass in a mapping.
+  // The keys are strings, and the values are other nodes.
+  // END is a special node marking that the graph should finish.
+  // What will happen is we will call `should_continue`, and then the output of that
+  // will be matched against the keys in this mapping.
+  // Based on which one it matches, that node will then be called.
+  {
+    // If `tools`, then we call the tool node.
+    continue: "action",
+    // Otherwise we finish.
+    end: END
+  }
 );
 
 // We now add a normal edge from `tools` to `agent`.
@@ -295,7 +539,7 @@ const inputs = {
 const result = await app.invoke(inputs);
 ```
 
-See a LangSmith trace of this run [here](https://smith.langchain.com/public/2562d46e-da94-4c9d-9b14-3759a26aec9b/r).
+See a LangSmith trace of this run [here](https://smith.langchain.com/public/144af8a3-b496-43aa-ba9d-f0d5894196e2/r).
 
 This may take a little bit - it's making a few calls behind the scenes.
 In order to start seeing some intermediate results as they happen, we can use streaming - see below for more information on that.
@@ -318,7 +562,13 @@ for await (const output of await app.stream(inputs)) {
 }
 ```
 
-See a LangSmith trace of this run [here](https://smith.langchain.com/public/9afacb13-b9dc-416e-abbe-6ed2a0811afe/r).
+See a LangSmith trace of this run [here](https://smith.langchain.com/public/968cd1bf-0db2-410f-a5b4-0e73066cf06e/r).
+
+## Running Examples
+
+You can find some more example notebooks of different use-cases in the `examples/` folder in this repo. These example notebooks use the [Deno runtime](https://deno.land/).
+
+To pull in environment variables, you can create a `.env` file at the **root** of this repo (not in the `examples/` folder itself).
 
 ## When to Use
 
@@ -338,19 +588,19 @@ All agent state is represented as a list of messages.
 This specifically uses OpenAI function calling.
 This is recommended agent executor for newer chat based models that support function calling.
 
-- [Getting Started Notebook](https://github.com/langchain-ai/langgraphjs/blob/main/examples/chat_agent_executor_with_function_calling/base.ipynb): Walks through creating this type of executor from scratch
+- [Getting Started Notebook](/examples/chat_agent_executor_with_function_calling/base.ipynb): Walks through creating this type of executor from scratch
 
 ### AgentExecutor
 
 This agent executor uses existing LangChain agents.
 
-- [Getting Started Notebook](https://github.com/langchain-ai/langgraphjs/blob/main/examples/agent_executor/base.ipynb): Walks through creating this type of executor from scratch
+- [Getting Started Notebook](/examples/agent_executor/base.ipynb): Walks through creating this type of executor from scratch
 
 ### Multi-agent Examples
 
-- [Multi-agent collaboration](https://github.com/langchain-ai/langgraphjs/blob/main/examples/multi_agent/multi-agent-collaboration.ipynb): how to create two agents that work together to accomplish a task
-- [Multi-agent with supervisor](https://github.com/langchain-ai/langgraphjs/blob/main/examples/multi_agent/agent_supervisor.ipynb): how to orchestrate individual agents by using an LLM as a "supervisor" to distribute work
-- [Hierarchical agent teams](https://github.com/langchain-ai/langgraphjs/blob/main/examples/multi_agent/hierarchical_agent_teams.ipynb): how to orchestrate "teams" of agents as nested graphs that can collaborate to solve a problem
+- [Multi-agent collaboration](/examples/multi_agent/multi_agent_collaboration.ipynb): how to create two agents that work together to accomplish a task
+- [Multi-agent with supervisor](/examples/multi_agent/agent_supervisor.ipynb): how to orchestrate individual agents by using an LLM as a "supervisor" to distribute work
+- [Hierarchical agent teams](/examples/multi_agent/hierarchical_agent_teams.ipynb): how to orchestrate "teams" of agents as nested graphs that can collaborate to solve a problem
 
 ## Documentation
 

package/dist/channels/base.cjs

@@ -37,19 +37,17 @@ async function createCheckpoint(checkpoint, channels) {
         channelVersions: { ...checkpoint.channelVersions },
         versionsSeen: { ...checkpoint.versionsSeen },
     };
-    for (const k in channels) {
-        if (newCheckpoint.channelValues[k] === undefined) {
-            try {
-                newCheckpoint.channelValues[k] = await channels[k].checkpoint();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const k of Object.keys(channels)) {
+        try {
+            newCheckpoint.channelValues[k] = await channels[k].checkpoint();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.name === EmptyChannelError.name) {
+                // no-op
             }
-            catch (error) {
-                if ("name" in error && error.name === EmptyChannelError.name) {
-                    // no-op
-                }
-                else {
-                    throw error; // Rethrow unexpected errors
-                }
+            else {
+                throw error; // Rethrow unexpected errors
             }
         }
     }

package/dist/channels/base.d.ts

@@ -1,11 +1,13 @@
 import { Checkpoint } from "../checkpoint/index.js";
-export declare abstract class BaseChannel<Value = unknown, Update = unknown, C = unknown> {
+export declare abstract class BaseChannel<Value = unknown, Update = unknown, // Expected type of the parameter `update` is called with.
+C = unknown> {
     /**
      * The name of the channel.
      */
     abstract lc_graph_name: string;
     /**
      * Return a new identical channel, optionally initialized from a checkpoint.
+     * Can be thought of as a "restoration" from a checkpoint which is a "snapshot" of the channel's state.
      *
      * @param {C | undefined} checkpoint
      * @param {C | undefined} initialValue

package/dist/channels/base.js

@@ -30,19 +30,17 @@ export async function createCheckpoint(checkpoint, channels) {
         channelVersions: { ...checkpoint.channelVersions },
         versionsSeen: { ...checkpoint.versionsSeen },
     };
-    for (const k in channels) {
-        if (newCheckpoint.channelValues[k] === undefined) {
-            try {
-                newCheckpoint.channelValues[k] = await channels[k].checkpoint();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const k of Object.keys(channels)) {
+        try {
+            newCheckpoint.channelValues[k] = await channels[k].checkpoint();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.name === EmptyChannelError.name) {
+                // no-op
             }
-            catch (error) {
-                if ("name" in error && error.name === EmptyChannelError.name) {
-                    // no-op
-                }
-                else {
-                    throw error; // Rethrow unexpected errors
-                }
+            else {
+                throw error; // Rethrow unexpected errors
             }
         }
     }

package/dist/channels/binop.cjs

@@ -36,8 +36,11 @@ class BinaryOperatorAggregate extends index_js_1.BaseChannel {
         this.initialValueFactory = initialValueFactory;
         this.value = initialValueFactory?.();
     }
-    empty(_) {
+    empty(checkpoint) {
         const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
         return empty;
     }
     update(values) {
@@ -61,7 +64,7 @@ class BinaryOperatorAggregate extends index_js_1.BaseChannel {
         return this.value;
     }
     checkpoint() {
-        if (!this.value) {
+        if (this.value === undefined) {
             throw new index_js_1.EmptyChannelError();
         }
         return this.value;

package/dist/channels/binop.d.ts

@@ -9,7 +9,7 @@ export declare class BinaryOperatorAggregate<Value> extends BaseChannel<Value, V
     operator: BinaryOperator<Value>;
     initialValueFactory?: () => Value;
     constructor(operator: BinaryOperator<Value>, initialValueFactory?: () => Value);
-    empty(_?: Value): BinaryOperatorAggregate<Value>;
+    empty(checkpoint?: Value): BinaryOperatorAggregate<Value>;
     update(values: Value[]): void;
     get(): Value;
     checkpoint(): Value;

package/dist/channels/binop.js

@@ -33,8 +33,11 @@ export class BinaryOperatorAggregate extends BaseChannel {
         this.initialValueFactory = initialValueFactory;
         this.value = initialValueFactory?.();
     }
-    empty(_) {
+    empty(checkpoint) {
         const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
         return empty;
     }
     update(values) {
@@ -58,7 +61,7 @@ export class BinaryOperatorAggregate extends BaseChannel {
         return this.value;
     }
     checkpoint() {
-        if (!this.value) {
+        if (this.value === undefined) {
             throw new EmptyChannelError();
         }
         return this.value;

package/dist/checkpoint/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheckpointSaver = exports.emptyCheckpoint = void 0;
+exports.BaseCheckpointSaver = exports.copyCheckpoint = exports.emptyCheckpoint = void 0;
 function emptyCheckpoint() {
     return {
         v: 1,
@@ -11,6 +11,16 @@ function emptyCheckpoint() {
     };
 }
 exports.emptyCheckpoint = emptyCheckpoint;
+function copyCheckpoint(checkpoint) {
+    return {
+        v: checkpoint.v,
+        ts: checkpoint.ts,
+        channelValues: { ...checkpoint.channelValues },
+        channelVersions: { ...checkpoint.channelVersions },
+        versionsSeen: { ...checkpoint.versionsSeen },
+    };
+}
+exports.copyCheckpoint = copyCheckpoint;
 class BaseCheckpointSaver {
     constructor() {
         Object.defineProperty(this, "at", {

package/dist/checkpoint/base.d.ts

@@ -35,6 +35,7 @@ export interface Checkpoint {
     versionsSeen: Record<string, Record<string, number>>;
 }
 export declare function emptyCheckpoint(): Checkpoint;
+export declare function copyCheckpoint(checkpoint: Checkpoint): Checkpoint;
 export declare const enum CheckpointAt {
     END_OF_STEP = "end_of_step",
     END_OF_RUN = "end_of_run"