@langchain/langgraph 0.4.8 → 1.0.0-alpha.0

package/dist/index.cjs

@@ -1,33 +1,110 @@
-"use strict";
-/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentTaskInput = exports.getPreviousState = exports.getConfig = exports.getWriter = exports.getStore = exports.interrupt = void 0;
-const async_local_storage_js_1 = require("./setup/async_local_storage.cjs");
-// Initialize global async local storage instance for tracing
-(0, async_local_storage_js_1.initializeAsyncLocalStorageSingleton)();
-__exportStar(require("./web.cjs"), exports);
-var interrupt_js_1 = require("./interrupt.cjs");
-Object.defineProperty(exports, "interrupt", { enumerable: true, get: function () { return interrupt_js_1.interrupt; } });
-var config_js_1 = require("./pregel/utils/config.cjs");
-Object.defineProperty(exports, "getStore", { enumerable: true, get: function () { return config_js_1.getStore; } });
-Object.defineProperty(exports, "getWriter", { enumerable: true, get: function () { return config_js_1.getWriter; } });
-Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_js_1.getConfig; } });
-var index_js_1 = require("./func/index.cjs");
-Object.defineProperty(exports, "getPreviousState", { enumerable: true, get: function () { return index_js_1.getPreviousState; } });
-var config_js_2 = require("./pregel/utils/config.cjs");
-Object.defineProperty(exports, "getCurrentTaskInput", { enumerable: true, get: function () { return config_js_2.getCurrentTaskInput; } });
-//# sourceMappingURL=index.js.map
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_async_local_storage = require('./setup/async_local_storage.cjs');
+const require_errors = require('./errors.cjs');
+const require_base = require('./channels/base.cjs');
+const require_binop = require('./channels/binop.cjs');
+const require_annotation = require('./graph/annotation.cjs');
+const require_constants = require('./constants.cjs');
+const require_config = require('./pregel/utils/config.cjs');
+const require_graph = require('./graph/graph.cjs');
+const require_state = require('./graph/state.cjs');
+const require_message = require('./graph/message.cjs');
+const require_index = require('./func/index.cjs');
+const require_messages_annotation = require('./graph/messages_annotation.cjs');
+require('./web.cjs');
+const require_interrupt = require('./interrupt.cjs');
+const __langchain_langgraph_checkpoint = require_rolldown_runtime.__toESM(require("@langchain/langgraph-checkpoint"));
+
+//#region src/index.ts
+require_async_local_storage.initializeAsyncLocalStorageSingleton();
+
+//#endregion
+exports.Annotation = require_annotation.Annotation;
+Object.defineProperty(exports, 'AsyncBatchedStore', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.AsyncBatchedStore;
+  }
+});
+exports.BaseChannel = require_base.BaseChannel;
+Object.defineProperty(exports, 'BaseCheckpointSaver', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.BaseCheckpointSaver;
+  }
+});
+exports.BaseLangGraphError = require_errors.BaseLangGraphError;
+Object.defineProperty(exports, 'BaseStore', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.BaseStore;
+  }
+});
+exports.BinaryOperatorAggregate = require_binop.BinaryOperatorAggregate;
+exports.Command = require_constants.Command;
+exports.CompiledStateGraph = require_state.CompiledStateGraph;
+exports.END = require_constants.END;
+exports.EmptyChannelError = require_errors.EmptyChannelError;
+exports.EmptyInputError = require_errors.EmptyInputError;
+exports.Graph = require_graph.Graph;
+exports.GraphBubbleUp = require_errors.GraphBubbleUp;
+exports.GraphInterrupt = require_errors.GraphInterrupt;
+exports.GraphRecursionError = require_errors.GraphRecursionError;
+exports.GraphValueError = require_errors.GraphValueError;
+exports.INTERRUPT = require_constants.INTERRUPT;
+Object.defineProperty(exports, 'InMemoryStore', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.InMemoryStore;
+  }
+});
+exports.InvalidUpdateError = require_errors.InvalidUpdateError;
+Object.defineProperty(exports, 'MemorySaver', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.MemorySaver;
+  }
+});
+exports.MessageGraph = require_message.MessageGraph;
+exports.MessagesAnnotation = require_messages_annotation.MessagesAnnotation;
+exports.MessagesZodMeta = require_messages_annotation.MessagesZodMeta;
+exports.MessagesZodState = require_messages_annotation.MessagesZodState;
+exports.MultipleSubgraphsError = require_errors.MultipleSubgraphsError;
+exports.NodeInterrupt = require_errors.NodeInterrupt;
+exports.ParentCommand = require_errors.ParentCommand;
+exports.REMOVE_ALL_MESSAGES = require_message.REMOVE_ALL_MESSAGES;
+exports.RemoteException = require_errors.RemoteException;
+exports.START = require_constants.START;
+exports.Send = require_constants.Send;
+exports.StateGraph = require_state.StateGraph;
+exports.UnreachableNodeError = require_errors.UnreachableNodeError;
+exports.addMessages = require_message.messagesStateReducer;
+Object.defineProperty(exports, 'copyCheckpoint', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.copyCheckpoint;
+  }
+});
+Object.defineProperty(exports, 'emptyCheckpoint', {
+  enumerable: true,
+  get: function () {
+    return __langchain_langgraph_checkpoint.emptyCheckpoint;
+  }
+});
+exports.entrypoint = require_index.entrypoint;
+exports.getConfig = require_config.getConfig;
+exports.getCurrentTaskInput = require_config.getCurrentTaskInput;
+exports.getPreviousState = require_index.getPreviousState;
+exports.getStore = require_config.getStore;
+exports.getSubgraphsSeenSet = require_errors.getSubgraphsSeenSet;
+exports.getWriter = require_config.getWriter;
+exports.interrupt = require_interrupt.interrupt;
+exports.isCommand = require_constants.isCommand;
+exports.isGraphBubbleUp = require_errors.isGraphBubbleUp;
+exports.isGraphInterrupt = require_errors.isGraphInterrupt;
+exports.isInterrupted = require_constants.isInterrupted;
+exports.isParentCommand = require_errors.isParentCommand;
+exports.messagesStateReducer = require_message.messagesStateReducer;
+exports.task = require_index.task;
+exports.typedNode = require_state.typedNode;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["initializeAsyncLocalStorageSingleton"],"sources":["../src/index.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\nimport { initializeAsyncLocalStorageSingleton } from \"./setup/async_local_storage.js\";\n\n// Initialize global async local storage instance for tracing\ninitializeAsyncLocalStorageSingleton();\n\nexport * from \"./web.js\";\n\nexport { interrupt } from \"./interrupt.js\";\nexport { getStore, getWriter, getConfig } from \"./pregel/utils/config.js\";\nexport { getPreviousState } from \"./func/index.js\";\nexport { getCurrentTaskInput } from \"./pregel/utils/config.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAKAA"}

package/dist/index.d.cts

@@ -0,0 +1,25 @@
+import { BaseChannel } from "./channels/base.cjs";
+import { LangGraphRunnableConfig, Runtime } from "./pregel/runnable_types.cjs";
+import { BinaryOperator, BinaryOperatorAggregate } from "./channels/binop.cjs";
+import { LastValue } from "./channels/last_value.cjs";
+import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.cjs";
+import { RetryPolicy } from "./pregel/utils/index.cjs";
+import { PregelNode } from "./pregel/read.cjs";
+import { Command, CommandParams, END, INTERRUPT, Interrupt, START, Send, isCommand, isInterrupted } from "./constants.cjs";
+import { GetStateOptions, MultipleChannelSubscriptionOptions, PregelOptions, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from "./pregel/types.cjs";
+import { Pregel } from "./pregel/index.cjs";
+import { CompiledGraph, Graph } from "./graph/graph.cjs";
+import { CompiledStateGraph, StateGraph, StateGraphArgs, typedNode } from "./graph/state.cjs";
+import { MessageGraph, Messages, REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/message.cjs";
+import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.cjs";
+import { AnyValue } from "./channels/any_value.cjs";
+import { DynamicBarrierValue, WaitForNames } from "./channels/dynamic_barrier_value.cjs";
+import { NamedBarrierValue } from "./channels/named_barrier_value.cjs";
+import { Topic } from "./channels/topic.cjs";
+import { EphemeralValue } from "./channels/ephemeral_value.cjs";
+import { EntrypointOptions, TaskOptions, entrypoint, getPreviousState, task } from "./func/index.cjs";
+import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.cjs";
+import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, Checkpoint, CheckpointMetadata, CheckpointTuple, GetOperation, InMemoryStore, Item, ListNamespacesOperation, MatchCondition, MemorySaver, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchOperation, copyCheckpoint, emptyCheckpoint } from "./web.cjs";
+import { interrupt } from "./interrupt.cjs";
+import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.cjs";
+export { Annotation, AnnotationRoot, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandParams, CompiledGraph, CompiledStateGraph, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, Interrupt, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, NamespaceMatchType, NodeInterrupt, NodeType, Operation, OperationResults, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, PutOperation, REMOVE_ALL_MESSAGES, RemoteException, RetryPolicy, Runtime, START, SearchOperation, Send, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateGraph, StateGraphArgs, StateSnapshot, StateType, StreamMode, StreamOutputMap, TaskOptions, Topic, UnreachableNodeError, UpdateType, WaitForNames, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getPreviousState, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, messagesStateReducer, task, typedNode };

package/dist/index.d.ts

@@ -1,5 +1,25 @@
-export * from "./web.js";
-export { interrupt } from "./interrupt.js";
-export { getStore, getWriter, getConfig } from "./pregel/utils/config.js";
-export { getPreviousState } from "./func/index.js";
-export { getCurrentTaskInput } from "./pregel/utils/config.js";
+import { BaseChannel } from "./channels/base.js";
+import { LangGraphRunnableConfig, Runtime } from "./pregel/runnable_types.js";
+import { BinaryOperator, BinaryOperatorAggregate } from "./channels/binop.js";
+import { LastValue } from "./channels/last_value.js";
+import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.js";
+import { RetryPolicy } from "./pregel/utils/index.js";
+import { PregelNode } from "./pregel/read.js";
+import { Command, CommandParams, END, INTERRUPT, Interrupt, START, Send, isCommand, isInterrupted } from "./constants.js";
+import { GetStateOptions, MultipleChannelSubscriptionOptions, PregelOptions, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from "./pregel/types.js";
+import { Pregel } from "./pregel/index.js";
+import { CompiledGraph, Graph } from "./graph/graph.js";
+import { CompiledStateGraph, StateGraph, StateGraphArgs, typedNode } from "./graph/state.js";
+import { MessageGraph, Messages, REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/message.js";
+import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.js";
+import { AnyValue } from "./channels/any_value.js";
+import { DynamicBarrierValue, WaitForNames } from "./channels/dynamic_barrier_value.js";
+import { NamedBarrierValue } from "./channels/named_barrier_value.js";
+import { Topic } from "./channels/topic.js";
+import { EphemeralValue } from "./channels/ephemeral_value.js";
+import { EntrypointOptions, TaskOptions, entrypoint, getPreviousState, task } from "./func/index.js";
+import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.js";
+import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, Checkpoint, CheckpointMetadata, CheckpointTuple, GetOperation, InMemoryStore, Item, ListNamespacesOperation, MatchCondition, MemorySaver, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchOperation, copyCheckpoint, emptyCheckpoint } from "./web.js";
+import { interrupt } from "./interrupt.js";
+import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
+export { Annotation, AnnotationRoot, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandParams, CompiledGraph, CompiledStateGraph, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, Interrupt, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, NamespaceMatchType, NodeInterrupt, NodeType, Operation, OperationResults, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, PutOperation, REMOVE_ALL_MESSAGES, RemoteException, RetryPolicy, Runtime, START, SearchOperation, Send, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateGraph, StateGraphArgs, StateSnapshot, StateType, StreamMode, StreamOutputMap, TaskOptions, Topic, UnreachableNodeError, UpdateType, WaitForNames, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getPreviousState, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, messagesStateReducer, task, typedNode };

package/dist/index.js

@@ -1,10 +1,21 @@
-/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
 import { initializeAsyncLocalStorageSingleton } from "./setup/async_local_storage.js";
-// Initialize global async local storage instance for tracing
+import { BaseLangGraphError, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.js";
+import { BaseChannel } from "./channels/base.js";
+import { BinaryOperatorAggregate } from "./channels/binop.js";
+import { Annotation } from "./graph/annotation.js";
+import { Command, END, INTERRUPT, START, Send, isCommand, isInterrupted } from "./constants.js";
+import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
+import { Graph } from "./graph/graph.js";
+import { CompiledStateGraph, StateGraph, typedNode } from "./graph/state.js";
+import { MessageGraph, REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/message.js";
+import { entrypoint, getPreviousState, task } from "./func/index.js";
+import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.js";
+import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, InMemoryStore, MemorySaver, copyCheckpoint, emptyCheckpoint } from "./web.js";
+import { interrupt } from "./interrupt.js";
+
+//#region src/index.ts
 initializeAsyncLocalStorageSingleton();
-export * from "./web.js";
-export { interrupt } from "./interrupt.js";
-export { getStore, getWriter, getConfig } from "./pregel/utils/config.js";
-export { getPreviousState } from "./func/index.js";
-export { getCurrentTaskInput } from "./pregel/utils/config.js";
+
+//#endregion
+export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, Command, CompiledStateGraph, END, EmptyChannelError, EmptyInputError, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesZodMeta, MessagesZodState, MultipleSubgraphsError, NodeInterrupt, ParentCommand, REMOVE_ALL_MESSAGES, RemoteException, START, Send, StateGraph, UnreachableNodeError, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getPreviousState, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, messagesStateReducer, task, typedNode };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAE1C,OAAO,EAAE,oCAAoC,EAAE,MAAM,gCAAgC,CAAC;AAEtF,6DAA6D;AAC7D,oCAAoC,EAAE,CAAC;AAEvC,cAAc,UAAU,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\nimport { initializeAsyncLocalStorageSingleton } from \"./setup/async_local_storage.js\";\n\n// Initialize global async local storage instance for tracing\ninitializeAsyncLocalStorageSingleton();\n\nexport * from \"./web.js\";\n\nexport { interrupt } from \"./interrupt.js\";\nexport { getStore, getWriter, getConfig } from \"./pregel/utils/config.js\";\nexport { getPreviousState } from \"./func/index.js\";\nexport { getCurrentTaskInput } from \"./pregel/utils/config.js\";\n"],"mappings":";;;;;;;;;;;;;;;;AAKA"}

package/dist/interrupt.cjs

@@ -1,88 +1,82 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interrupt = interrupt;
-const singletons_1 = require("@langchain/core/singletons");
-const errors_js_1 = require("./errors.cjs");
-const constants_js_1 = require("./constants.cjs");
-const hash_js_1 = require("./hash.cjs");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_errors = require('./errors.cjs');
+const require_constants = require('./constants.cjs');
+const require_hash = require('./hash.cjs');
+const __langchain_core_singletons = require_rolldown_runtime.__toESM(require("@langchain/core/singletons"));
+
+//#region src/interrupt.ts
 /**
- * Interrupts the execution of a graph node.
- * This function can be used to pause execution of a node, and return the value of the `resume`
- * input when the graph is re-invoked using `Command`.
- * Multiple interrupts can be called within a single node, and each will be handled sequentially.
- *
- * When an interrupt is called:
- * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
- * 2. Otherwise, it throws a `GraphInterrupt` with the provided value
- * 3. The graph can be resumed by passing a `Command` with a `resume` value
- *
- * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,
- * you should avoid using `try/catch` blocks around the `interrupt` function,
- * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
- *
- * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
- * @returns The `resume` value provided when the graph is re-invoked with a Command
- *
- * @example
- * ```typescript
- * // Define a node that uses multiple interrupts
- * const nodeWithInterrupts = () => {
- *   // First interrupt - will pause execution and include {value: 1} in task values
- *   const answer1 = interrupt({ value: 1 });
- *
- *   // Second interrupt - only called after first interrupt is resumed
- *   const answer2 = interrupt({ value: 2 });
- *
- *   // Use the resume values
- *   return { myKey: answer1 + " " + answer2 };
- * };
- *
- * // Resume the graph after first interrupt
- * await graph.stream(new Command({ resume: "answer 1" }));
- *
- * // Resume the graph after second interrupt
- * await graph.stream(new Command({ resume: "answer 2" }));
- * // Final result: { myKey: "answer 1 answer 2" }
- * ```
- *
- * @throws {Error} If called outside the context of a graph
- * @throws {GraphInterrupt} When no resume value is available
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+* Interrupts the execution of a graph node.
+* This function can be used to pause execution of a node, and return the value of the `resume`
+* input when the graph is re-invoked using `Command`.
+* Multiple interrupts can be called within a single node, and each will be handled sequentially.
+*
+* When an interrupt is called:
+* 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
+* 2. Otherwise, it throws a `GraphInterrupt` with the provided value
+* 3. The graph can be resumed by passing a `Command` with a `resume` value
+*
+* Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,
+* you should avoid using `try/catch` blocks around the `interrupt` function,
+* or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
+*
+* @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
+* @returns The `resume` value provided when the graph is re-invoked with a Command
+*
+* @example
+* ```typescript
+* // Define a node that uses multiple interrupts
+* const nodeWithInterrupts = () => {
+*   // First interrupt - will pause execution and include {value: 1} in task values
+*   const answer1 = interrupt({ value: 1 });
+*
+*   // Second interrupt - only called after first interrupt is resumed
+*   const answer2 = interrupt({ value: 2 });
+*
+*   // Use the resume values
+*   return { myKey: answer1 + " " + answer2 };
+* };
+*
+* // Resume the graph after first interrupt
+* await graph.stream(new Command({ resume: "answer 1" }));
+*
+* // Resume the graph after second interrupt
+* await graph.stream(new Command({ resume: "answer 2" }));
+* // Final result: { myKey: "answer 1 answer 2" }
+* ```
+*
+* @throws {Error} If called outside the context of a graph
+* @throws {GraphInterrupt} When no resume value is available
+*/
 function interrupt(value) {
-    const config = singletons_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
-    if (!config) {
-        throw new Error("Called interrupt() outside the context of a graph.");
-    }
-    const conf = config.configurable;
-    if (!conf) {
-        throw new Error("No configurable found in config");
-    }
-    const checkpointer = conf[constants_js_1.CONFIG_KEY_CHECKPOINTER];
-    if (!checkpointer)
-        throw new errors_js_1.GraphValueError("No checkpointer set");
-    // Track interrupt index
-    const scratchpad = conf[constants_js_1.CONFIG_KEY_SCRATCHPAD];
-    scratchpad.interruptCounter += 1;
-    const idx = scratchpad.interruptCounter;
-    // Find previous resume values
-    if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {
-        conf[constants_js_1.CONFIG_KEY_SEND]?.([[constants_js_1.RESUME, scratchpad.resume]]);
-        return scratchpad.resume[idx];
-    }
-    // Find current resume value
-    if (scratchpad.nullResume !== undefined) {
-        if (scratchpad.resume.length !== idx) {
-            throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
-        }
-        const v = scratchpad.consumeNullResume();
-        scratchpad.resume.push(v);
-        conf[constants_js_1.CONFIG_KEY_SEND]?.([[constants_js_1.RESUME, scratchpad.resume]]);
-        return v;
-    }
-    // No resume value found
-    const ns = conf[constants_js_1.CONFIG_KEY_CHECKPOINT_NS]?.split(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR);
-    const id = ns ? (0, hash_js_1.XXH3)(ns.join(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;
-    throw new errors_js_1.GraphInterrupt([{ id, value }]);
+	const config = __langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig();
+	if (!config) throw new Error("Called interrupt() outside the context of a graph.");
+	const conf = config.configurable;
+	if (!conf) throw new Error("No configurable found in config");
+	const checkpointer = conf[require_constants.CONFIG_KEY_CHECKPOINTER];
+	if (!checkpointer) throw new require_errors.GraphValueError("No checkpointer set");
+	const scratchpad = conf[require_constants.CONFIG_KEY_SCRATCHPAD];
+	scratchpad.interruptCounter += 1;
+	const idx = scratchpad.interruptCounter;
+	if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {
+		conf[require_constants.CONFIG_KEY_SEND]?.([[require_constants.RESUME, scratchpad.resume]]);
+		return scratchpad.resume[idx];
+	}
+	if (scratchpad.nullResume !== void 0) {
+		if (scratchpad.resume.length !== idx) throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
+		const v = scratchpad.consumeNullResume();
+		scratchpad.resume.push(v);
+		conf[require_constants.CONFIG_KEY_SEND]?.([[require_constants.RESUME, scratchpad.resume]]);
+		return v;
+	}
+	const ns = conf[require_constants.CONFIG_KEY_CHECKPOINT_NS]?.split(require_constants.CHECKPOINT_NAMESPACE_SEPARATOR);
+	const id = ns ? require_hash.XXH3(ns.join(require_constants.CHECKPOINT_NAMESPACE_SEPARATOR)) : void 0;
+	throw new require_errors.GraphInterrupt([{
+		id,
+		value
+	}]);
 }
-//# sourceMappingURL=interrupt.js.map
+
+//#endregion
+exports.interrupt = interrupt;
+//# sourceMappingURL=interrupt.cjs.map

package/dist/interrupt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.cjs","names":["config: RunnableConfig | undefined","AsyncLocalStorageProviderSingleton","checkpointer: BaseCheckpointSaver","CONFIG_KEY_CHECKPOINTER","GraphValueError","scratchpad: PregelScratchpad","CONFIG_KEY_SCRATCHPAD","CONFIG_KEY_SEND","RESUME","ns: string[] | undefined","CONFIG_KEY_CHECKPOINT_NS","CHECKPOINT_NAMESPACE_SEPARATOR","XXH3","GraphInterrupt"],"sources":["../src/interrupt.ts"],"sourcesContent":["import { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  BaseCheckpointSaver,\n  type PendingWrite,\n} from \"@langchain/langgraph-checkpoint\";\nimport { GraphInterrupt, GraphValueError } from \"./errors.js\";\nimport {\n  CONFIG_KEY_CHECKPOINT_NS,\n  CONFIG_KEY_SCRATCHPAD,\n  CONFIG_KEY_SEND,\n  CONFIG_KEY_CHECKPOINTER,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  RESUME,\n} from \"./constants.js\";\nimport { PregelScratchpad } from \"./pregel/types.js\";\nimport { XXH3 } from \"./hash.js\";\n\n/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @returns The `resume` value provided when the graph is re-invoked with a Command\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function interrupt<I = unknown, R = any>(value: I): R {\n  const config: RunnableConfig | undefined =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (!config) {\n    throw new Error(\"Called interrupt() outside the context of a graph.\");\n  }\n\n  const conf = config.configurable;\n  if (!conf) {\n    throw new Error(\"No configurable found in config\");\n  }\n\n  const checkpointer: BaseCheckpointSaver = conf[CONFIG_KEY_CHECKPOINTER];\n  if (!checkpointer) throw new GraphValueError(\"No checkpointer set\");\n\n  // Track interrupt index\n  const scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD];\n  scratchpad.interruptCounter += 1;\n  const idx = scratchpad.interruptCounter;\n\n  // Find previous resume values\n  if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return scratchpad.resume[idx] as R;\n  }\n\n  // Find current resume value\n  if (scratchpad.nullResume !== undefined) {\n    if (scratchpad.resume.length !== idx) {\n      throw new Error(\n        `Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`\n      );\n    }\n    const v = scratchpad.consumeNullResume();\n    scratchpad.resume.push(v);\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return v as R;\n  }\n\n  // No resume value found\n  const ns: string[] | undefined = conf[CONFIG_KEY_CHECKPOINT_NS]?.split(\n    CHECKPOINT_NAMESPACE_SEPARATOR\n  );\n\n  const id = ns ? XXH3(ns.join(CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;\n  throw new GraphInterrupt([{ id, value }]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,UAAgC,OAAa;CAC3D,MAAMA,SACJC,+DAAmC;AACrC,KAAI,CAAC,OACH,OAAM,IAAI,MAAM;CAGlB,MAAM,OAAO,OAAO;AACpB,KAAI,CAAC,KACH,OAAM,IAAI,MAAM;CAGlB,MAAMC,eAAoC,KAAKC;AAC/C,KAAI,CAAC,aAAc,OAAM,IAAIC,+BAAgB;CAG7C,MAAMC,aAA+B,KAAKC;AAC1C,YAAW,oBAAoB;CAC/B,MAAM,MAAM,WAAW;AAGvB,KAAI,WAAW,OAAO,SAAS,KAAK,MAAM,WAAW,OAAO,QAAQ;AAClE,OAAKC,qCAAmB,CAAC,CAACC,0BAAQ,WAAW;AAC7C,SAAO,WAAW,OAAO;;AAI3B,KAAI,WAAW,eAAe,QAAW;AACvC,MAAI,WAAW,OAAO,WAAW,IAC/B,OAAM,IAAI,MACR,2BAA2B,WAAW,OAAO,OAAO,OAAO;EAG/D,MAAM,IAAI,WAAW;AACrB,aAAW,OAAO,KAAK;AACvB,OAAKD,qCAAmB,CAAC,CAACC,0BAAQ,WAAW;AAC7C,SAAO;;CAIT,MAAMC,KAA2B,KAAKC,6CAA2B,MAC/DC;CAGF,MAAM,KAAK,KAAKC,kBAAK,GAAG,KAAKD,qDAAmC;AAChE,OAAM,IAAIE,8BAAe,CAAC;EAAE;EAAI"}

package/dist/interrupt.d.cts

@@ -0,0 +1,49 @@
+//#region src/interrupt.d.ts
+/**
+ * Interrupts the execution of a graph node.
+ * This function can be used to pause execution of a node, and return the value of the `resume`
+ * input when the graph is re-invoked using `Command`.
+ * Multiple interrupts can be called within a single node, and each will be handled sequentially.
+ *
+ * When an interrupt is called:
+ * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
+ * 2. Otherwise, it throws a `GraphInterrupt` with the provided value
+ * 3. The graph can be resumed by passing a `Command` with a `resume` value
+ *
+ * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,
+ * you should avoid using `try/catch` blocks around the `interrupt` function,
+ * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
+ *
+ * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
+ * @returns The `resume` value provided when the graph is re-invoked with a Command
+ *
+ * @example
+ * ```typescript
+ * // Define a node that uses multiple interrupts
+ * const nodeWithInterrupts = () => {
+ *   // First interrupt - will pause execution and include {value: 1} in task values
+ *   const answer1 = interrupt({ value: 1 });
+ *
+ *   // Second interrupt - only called after first interrupt is resumed
+ *   const answer2 = interrupt({ value: 2 });
+ *
+ *   // Use the resume values
+ *   return { myKey: answer1 + " " + answer2 };
+ * };
+ *
+ * // Resume the graph after first interrupt
+ * await graph.stream(new Command({ resume: "answer 1" }));
+ *
+ * // Resume the graph after second interrupt
+ * await graph.stream(new Command({ resume: "answer 2" }));
+ * // Final result: { myKey: "answer 1 answer 2" }
+ * ```
+ *
+ * @throws {Error} If called outside the context of a graph
+ * @throws {GraphInterrupt} When no resume value is available
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare function interrupt<I = unknown, R = any>(value: I): R;
+//#endregion
+export { interrupt };
+//# sourceMappingURL=interrupt.d.cts.map

package/dist/interrupt.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.cts","names":["interrupt","I","R"],"sources":["../src/interrupt.d.ts"],"sourcesContent":["/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @returns The `resume` value provided when the graph is re-invoked with a Command\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function interrupt<I = unknown, R = any>(value: I): R;\n"],"mappings":";;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwBA,uCAAuCC,IAAIC"}

package/dist/interrupt.d.ts

@@ -1,3 +1,4 @@
+//#region src/interrupt.d.ts
 /**
  * Interrupts the execution of a graph node.
  * This function can be used to pause execution of a node, and return the value of the `resume`
@@ -41,4 +42,8 @@
  * @throws {Error} If called outside the context of a graph
  * @throws {GraphInterrupt} When no resume value is available
  */
-export declare function interrupt<I = unknown, R = any>(value: I): R;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare function interrupt<I = unknown, R = any>(value: I): R;
+//#endregion
+export { interrupt };
+//# sourceMappingURL=interrupt.d.ts.map

package/dist/interrupt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.ts","names":["interrupt","I","R"],"sources":["../src/interrupt.d.ts"],"sourcesContent":["/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @returns The `resume` value provided when the graph is re-invoked with a Command\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function interrupt<I = unknown, R = any>(value: I): R;\n"],"mappings":";;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwBA,uCAAuCC,IAAIC"}