@langchain/langgraph 1.3.6 → 1.4.0

package/dist/index.d.cts

@@ -1,5 +1,7 @@
 import { BaseChannel } from "./channels/base.cjs";
-import { COMMAND_SYMBOL, Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, Overwrite, OverwriteValue, START, Send, isCommand, isInterrupted } from "./constants.cjs";
+import { TimeoutPolicy } from "./pregel/utils/timeout.cjs";
+import { COMMAND_SYMBOL, Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, Overwrite, OverwriteValue, START, Send, SendOptions, isCommand, isInterrupted } from "./constants.cjs";
+import { DeltaChannel, DeltaReducer } from "./channels/delta.cjs";
 import { BinaryOperator, BinaryOperatorAggregate } from "./channels/binop.cjs";
 import { AnyValue } from "./channels/any_value.cjs";
 import { LastValue } from "./channels/last_value.cjs";
@@ -8,6 +10,7 @@ import { EphemeralValue } from "./channels/ephemeral_value.cjs";
 import { NamedBarrierValue } from "./channels/named_barrier_value.cjs";
 import { Topic } from "./channels/topic.cjs";
 import { UntrackedValueChannel } from "./channels/untracked_value.cjs";
+import { RunControl } from "./pregel/runtime.cjs";
 import { ExecutionInfo, LangGraphRunnableConfig, Runtime, ServerInfo } from "./pregel/runnable_types.cjs";
 import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.cjs";
 import { CachePolicy, RetryPolicy } from "./pregel/utils/index.cjs";
@@ -24,22 +27,22 @@ import { createValuesTransformer } from "./stream/transformers/values.cjs";
 import { CreateGraphRunStreamOptions, GraphRunStream, SubgraphRunStream, createGraphRunStream } from "./stream/run-stream.cjs";
 import { ChatModelStreamImpl } from "./stream/index.cjs";
 import { Pregel } from "./pregel/index.cjs";
-import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.cjs";
-import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.cjs";
-import { InferWriterType, writer } from "./writer.cjs";
+import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeError, NodeInterrupt, NodeTimeoutError, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isNodeError, isNodeTimeoutError, isParentCommand } from "./errors.cjs";
 import { isSerializableSchema, isStandardSchema } from "./state/types.cjs";
 import { ReducedValue, ReducedValueInit } from "./state/values/reduced.cjs";
 import { UntrackedValue, UntrackedValueInit } from "./state/values/untracked.cjs";
 import { AnyStateSchema, InferStateSchemaUpdate, InferStateSchemaValue, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition } from "./state/schema.cjs";
 import { ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ExtractStateType, ExtractUpdateType, GraphNode, GraphNodeReturnValue, GraphNodeTypes, StateDefinitionInit, StateGraphInit, StateGraphOptions, ToStateDefinition } from "./graph/types.cjs";
-import { CompiledStateGraph, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphNodeSpec } from "./graph/state.cjs";
-import { Messages, REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/messages_reducer.cjs";
+import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.cjs";
+import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.cjs";
+import { InferWriterType, writer } from "./writer.cjs";
+import { CompiledStateGraph, NodePolicyOptions, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphNodeSpec } from "./graph/state.cjs";
+import { Messages, REMOVE_ALL_MESSAGES, messagesDeltaReducer, messagesStateReducer } from "./graph/messages_reducer.cjs";
 import { MessageGraph, pushMessage } from "./graph/message.cjs";
-import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.cjs";
 import { EntrypointOptions, TaskOptions, entrypoint, getPreviousState, task } from "./func/index.cjs";
 import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.cjs";
 import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter.cjs";
 import { MessagesValue } from "./state/prebuilt/messages.cjs";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.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";
-export { AddNodeOptions, AgentStatus, Annotation, AnnotationRoot, AnyStateSchema, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, CachePolicy, ChatModelStream, ChatModelStreamImpl, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandInstance, CommandParams, CompiledGraph, CompiledGraphType, CompiledStateGraph, ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ConvertToProtocolEventOptions, CreateGraphRunStreamOptions, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, Namespace, NamespaceMatchType, NativeStreamTransformer, NodeInterrupt, NodeSpec, NodeType, Operation, OperationResults, Overwrite, OverwriteValue, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, ProtocolEvent, PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, RetryPolicy, Runtime, START, STREAM_EVENTS_V3_MODES, SearchOperation, Send, ServerInfo, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateDefinitionInit, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphInit, StateGraphInputError, StateGraphNodeSpec, StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, StateSnapshot, StateType, StreamChannel, StreamEmitter, StreamMode, StreamOutputMap, StreamTransformer, SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, SubgraphRunStream, TaskOptions, ToStateDefinition, ToolCallStatus, ToolCallStream, ToolsEventData, Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, UpdateType, UpdatesEventData, UsageInfo, WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { AddNodeOptions, AgentStatus, Annotation, AnnotationRoot, AnyStateSchema, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, CachePolicy, ChatModelStream, ChatModelStreamImpl, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandInstance, CommandParams, CompiledGraph, CompiledGraphType, CompiledStateGraph, ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ConvertToProtocolEventOptions, CreateGraphRunStreamOptions, DeltaChannel, DeltaReducer, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, Namespace, NamespaceMatchType, NativeStreamTransformer, NodeError, NodeInterrupt, NodePolicyOptions, NodeSpec, NodeTimeoutError, NodeType, Operation, OperationResults, Overwrite, OverwriteValue, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, ProtocolEvent, PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, RetryPolicy, RunControl, Runtime, START, STREAM_EVENTS_V3_MODES, SearchOperation, Send, SendOptions, ServerInfo, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateDefinitionInit, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphInit, StateGraphInputError, StateGraphNodeSpec, StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, StateSnapshot, StateType, StreamChannel, StreamEmitter, StreamMode, StreamOutputMap, StreamTransformer, SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, SubgraphRunStream, TaskOptions, TimeoutPolicy, ToStateDefinition, ToolCallStatus, ToolCallStream, ToolsEventData, Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, UpdateType, UpdatesEventData, UsageInfo, WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isInterrupted, isNativeTransformer, isNodeError, isNodeTimeoutError, isParentCommand, isSerializableSchema, isStandardSchema, messagesDeltaReducer, messagesStateReducer, pushMessage, task, writer };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { BaseChannel } from "./channels/base.js";
-import { COMMAND_SYMBOL, Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, Overwrite, OverwriteValue, START, Send, isCommand, isInterrupted } from "./constants.js";
+import { TimeoutPolicy } from "./pregel/utils/timeout.js";
+import { COMMAND_SYMBOL, Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, Overwrite, OverwriteValue, START, Send, SendOptions, isCommand, isInterrupted } from "./constants.js";
+import { DeltaChannel, DeltaReducer } from "./channels/delta.js";
 import { BinaryOperator, BinaryOperatorAggregate } from "./channels/binop.js";
 import { AnyValue } from "./channels/any_value.js";
 import { LastValue } from "./channels/last_value.js";
@@ -8,6 +10,7 @@ import { EphemeralValue } from "./channels/ephemeral_value.js";
 import { NamedBarrierValue } from "./channels/named_barrier_value.js";
 import { Topic } from "./channels/topic.js";
 import { UntrackedValueChannel } from "./channels/untracked_value.js";
+import { RunControl } from "./pregel/runtime.js";
 import { ExecutionInfo, LangGraphRunnableConfig, Runtime, ServerInfo } from "./pregel/runnable_types.js";
 import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.js";
 import { CachePolicy, RetryPolicy } from "./pregel/utils/index.js";
@@ -24,22 +27,22 @@ import { createValuesTransformer } from "./stream/transformers/values.js";
 import { CreateGraphRunStreamOptions, GraphRunStream, SubgraphRunStream, createGraphRunStream } from "./stream/run-stream.js";
 import { ChatModelStreamImpl } from "./stream/index.js";
 import { Pregel } from "./pregel/index.js";
-import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.js";
-import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.js";
-import { InferWriterType, writer } from "./writer.js";
+import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeError, NodeInterrupt, NodeTimeoutError, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isNodeError, isNodeTimeoutError, isParentCommand } from "./errors.js";
 import { isSerializableSchema, isStandardSchema } from "./state/types.js";
 import { ReducedValue, ReducedValueInit } from "./state/values/reduced.js";
 import { UntrackedValue, UntrackedValueInit } from "./state/values/untracked.js";
 import { AnyStateSchema, InferStateSchemaUpdate, InferStateSchemaValue, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition } from "./state/schema.js";
 import { ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ExtractStateType, ExtractUpdateType, GraphNode, GraphNodeReturnValue, GraphNodeTypes, StateDefinitionInit, StateGraphInit, StateGraphOptions, ToStateDefinition } from "./graph/types.js";
-import { CompiledStateGraph, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphNodeSpec } from "./graph/state.js";
-import { Messages, REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/messages_reducer.js";
+import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.js";
+import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.js";
+import { InferWriterType, writer } from "./writer.js";
+import { CompiledStateGraph, NodePolicyOptions, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphNodeSpec } from "./graph/state.js";
+import { Messages, REMOVE_ALL_MESSAGES, messagesDeltaReducer, messagesStateReducer } from "./graph/messages_reducer.js";
 import { MessageGraph, pushMessage } from "./graph/message.js";
-import { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.js";
 import { EntrypointOptions, TaskOptions, entrypoint, getPreviousState, task } from "./func/index.js";
 import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.js";
 import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter.js";
 import { MessagesValue } from "./state/prebuilt/messages.js";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.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";
-export { AddNodeOptions, AgentStatus, Annotation, AnnotationRoot, AnyStateSchema, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, CachePolicy, ChatModelStream, ChatModelStreamImpl, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandInstance, CommandParams, CompiledGraph, CompiledGraphType, CompiledStateGraph, ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ConvertToProtocolEventOptions, CreateGraphRunStreamOptions, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, Namespace, NamespaceMatchType, NativeStreamTransformer, NodeInterrupt, NodeSpec, NodeType, Operation, OperationResults, Overwrite, OverwriteValue, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, ProtocolEvent, PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, RetryPolicy, Runtime, START, STREAM_EVENTS_V3_MODES, SearchOperation, Send, ServerInfo, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateDefinitionInit, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphInit, StateGraphInputError, StateGraphNodeSpec, StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, StateSnapshot, StateType, StreamChannel, StreamEmitter, StreamMode, StreamOutputMap, StreamTransformer, SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, SubgraphRunStream, TaskOptions, ToStateDefinition, ToolCallStatus, ToolCallStream, ToolsEventData, Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, UpdateType, UpdatesEventData, UsageInfo, WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { AddNodeOptions, AgentStatus, Annotation, AnnotationRoot, AnyStateSchema, AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, CachePolicy, ChatModelStream, ChatModelStreamImpl, Checkpoint, CheckpointMetadata, CheckpointTuple, Command, CommandInstance, CommandParams, CompiledGraph, CompiledGraphType, CompiledStateGraph, ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ConvertToProtocolEventOptions, CreateGraphRunStreamOptions, DeltaChannel, DeltaReducer, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleChannelSubscriptionOptions, MultipleSubgraphsError, NameSpacePath, NamedBarrierValue, Namespace, NamespaceMatchType, NativeStreamTransformer, NodeError, NodeInterrupt, NodePolicyOptions, NodeSpec, NodeTimeoutError, NodeType, Operation, OperationResults, Overwrite, OverwriteValue, ParentCommand, Pregel, PregelNode, PregelOptions, PregelParams, ProtocolEvent, PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, RetryPolicy, RunControl, Runtime, START, STREAM_EVENTS_V3_MODES, SearchOperation, Send, SendOptions, ServerInfo, SingleChannelSubscriptionOptions, SingleReducer, StateDefinition, StateDefinitionInit, StateGraph, StateGraphAddNodeOptions, StateGraphArgs, StateGraphArgsWithInputOutputSchemas, StateGraphArgsWithStateSchema, StateGraphInit, StateGraphInputError, StateGraphNodeSpec, StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, StateSnapshot, StateType, StreamChannel, StreamEmitter, StreamMode, StreamOutputMap, StreamTransformer, SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, SubgraphRunStream, TaskOptions, TimeoutPolicy, ToStateDefinition, ToolCallStatus, ToolCallStream, ToolsEventData, Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, UpdateType, UpdatesEventData, UsageInfo, WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isInterrupted, isNativeTransformer, isNodeError, isNodeTimeoutError, isParentCommand, isSerializableSchema, isStandardSchema, messagesDeltaReducer, messagesStateReducer, pushMessage, task, writer };

package/dist/index.js

@@ -1,10 +1,11 @@
 import { initializeAsyncLocalStorageSingleton } from "./node.js";
 import { COMMAND_SYMBOL, Command, CommandInstance, END, INTERRUPT, Overwrite, START, Send, isCommand, isInterrupted } from "./constants.js";
-import { BaseLangGraphError, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand } from "./errors.js";
+import { BaseLangGraphError, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeError, NodeInterrupt, NodeTimeoutError, ParentCommand, RemoteException, StateGraphInputError, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isNodeError, isNodeTimeoutError, isParentCommand } from "./errors.js";
 import { BaseChannel } from "./channels/base.js";
 import { BinaryOperatorAggregate } from "./channels/binop.js";
 import { Annotation } from "./graph/annotation.js";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
+import { RunControl } from "./pregel/runtime.js";
 import { STREAM_EVENTS_V3_MODES, convertToProtocolEvent, isCheckpointEnvelope } from "./stream/convert.js";
 import { StreamChannel } from "./stream/stream-channel.js";
 import { createLifecycleTransformer, filterLifecycleEntries } from "./stream/transformers/lifecycle.js";
@@ -18,11 +19,12 @@ import { interrupt } from "./interrupt.js";
 import { Graph } from "./graph/graph.js";
 import { isSerializableSchema, isStandardSchema } from "./state/types.js";
 import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter.js";
+import { DeltaChannel } from "./channels/delta.js";
 import { UntrackedValueChannel } from "./channels/untracked_value.js";
 import { ReducedValue } from "./state/values/reduced.js";
 import { UntrackedValue } from "./state/values/untracked.js";
 import { StateSchema } from "./state/schema.js";
-import { REMOVE_ALL_MESSAGES, messagesStateReducer } from "./graph/messages_reducer.js";
+import { REMOVE_ALL_MESSAGES, messagesDeltaReducer, messagesStateReducer } from "./graph/messages_reducer.js";
 import { MessagesValue } from "./state/prebuilt/messages.js";
 import { CompiledStateGraph, StateGraph } from "./graph/state.js";
 import { MessageGraph, pushMessage } from "./graph/message.js";
@@ -33,6 +35,6 @@ import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, InMemoryStore, Memor
 //#region src/index.ts
 initializeAsyncLocalStorageSingleton();
 //#endregion
-export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, COMMAND_SYMBOL, ChatModelStreamImpl, Command, CommandInstance, CompiledStateGraph, END, EmptyChannelError, EmptyInputError, StreamChannel as EventLog, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleSubgraphsError, NodeInterrupt, Overwrite, ParentCommand, REMOVE_ALL_MESSAGES, ReducedValue, RemoteException, START, STREAM_EVENTS_V3_MODES, Send, StateGraph, StateGraphInputError, StateSchema, StreamChannel, SubgraphRunStream, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, COMMAND_SYMBOL, ChatModelStreamImpl, Command, CommandInstance, CompiledStateGraph, DeltaChannel, END, EmptyChannelError, EmptyInputError, StreamChannel as EventLog, Graph, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleSubgraphsError, NodeError, NodeInterrupt, NodeTimeoutError, Overwrite, ParentCommand, REMOVE_ALL_MESSAGES, ReducedValue, RemoteException, RunControl, START, STREAM_EVENTS_V3_MODES, Send, StateGraph, StateGraphInputError, StateSchema, StreamChannel, SubgraphRunStream, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCheckpointEnvelope, isCommand, isGraphBubbleUp, isGraphDrained, isGraphInterrupt, isInterrupted, isNativeTransformer, isNodeError, isNodeTimeoutError, isParentCommand, isSerializableSchema, isStandardSchema, messagesDeltaReducer, messagesStateReducer, pushMessage, task, writer };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\nimport { initializeAsyncLocalStorageSingleton } from \"./node.js\";\n\n// Initialize global async local storage instance for tracing\ninitializeAsyncLocalStorageSingleton();\n\nexport * from \"./web.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,sCAAsC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\nimport { initializeAsyncLocalStorageSingleton } from \"./node.js\";\n\n// Initialize global async local storage instance for tracing\ninitializeAsyncLocalStorageSingleton();\n\nexport * from \"./web.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,sCAAsC"}

package/dist/prebuilt/react_agent_executor.d.cts

@@ -9,8 +9,8 @@ import { Messages } from "../graph/messages_reducer.cjs";
 import { MessagesAnnotation } from "../graph/messages_annotation.cjs";
 import { ToolNode } from "./tool_node.cjs";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
 import { Runnable, RunnableBinding, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
+import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
 import * as _langchain_core_messages0 from "@langchain/core/messages";
 import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";

package/dist/pregel/algo.cjs

@@ -53,7 +53,13 @@ function _localRead(checkpoint, channels, task, select, fresh = false) {
 	let values;
 	if (fresh && updated.size > 0) {
 		const localChannels = Object.fromEntries(Object.entries(channels).filter(([k, _]) => updated.has(k)));
-		const newCheckpoint = require_base.createCheckpoint(checkpoint, localChannels, -1);
+		const channelsToSnapshot = /* @__PURE__ */ new Set();
+		for (const k in localChannels) {
+			if (!Object.prototype.hasOwnProperty.call(localChannels, k)) continue;
+			const ch = localChannels[k];
+			if (require_base.isDeltaChannel(ch) && ch.isAvailable()) channelsToSnapshot.add(k);
+		}
+		const newCheckpoint = require_base.createCheckpoint(checkpoint, localChannels, -1, { channelsToSnapshot });
 		const newChannels = require_base.emptyChannels(localChannels, newCheckpoint);
 		_applyWrites((0, _langchain_langgraph_checkpoint.copyCheckpoint)(newCheckpoint), newChannels, [task], void 0, void 0);
 		values = require_io.readChannels({
@@ -76,26 +82,34 @@ const IGNORE = new Set([
 	require_constants.RESUME,
 	require_constants.INTERRUPT,
 	require_constants.RETURN,
-	require_constants.ERROR
+	require_constants.ERROR,
+	require_constants.ERROR_SOURCE_NODE
 ]);
+const RESERVED_SET = new Set(require_constants.RESERVED);
 function _applyWrites(checkpoint, channels, tasks, getNextVersion, triggerToNodes) {
+	const pathCache = /* @__PURE__ */ new Map();
+	for (const task of tasks) pathCache.set(task, task.path?.slice(0, 3) || []);
 	tasks.sort((a, b) => {
-		const aPath = a.path?.slice(0, 3) || [];
-		const bPath = b.path?.slice(0, 3) || [];
+		const aPath = pathCache.get(a);
+		const bPath = pathCache.get(b);
 		for (let i = 0; i < Math.min(aPath.length, bPath.length); i += 1) {
 			if (aPath[i] < bPath[i]) return -1;
 			if (aPath[i] > bPath[i]) return 1;
 		}
 		return aPath.length - bPath.length;
 	});
-	const bumpStep = tasks.some((task) => task.triggers.length > 0);
 	const onlyChannels = require_base.getOnlyChannels(channels);
+	let bumpStep = false;
+	const channelsToConsume = /* @__PURE__ */ new Set();
 	for (const task of tasks) {
+		if (task.triggers.length > 0) bumpStep = true;
 		checkpoint.versions_seen[task.name] ??= {};
-		for (const chan of task.triggers) if (chan in checkpoint.channel_versions) checkpoint.versions_seen[task.name][chan] = checkpoint.channel_versions[chan];
+		for (const chan of task.triggers) {
+			if (chan in checkpoint.channel_versions) checkpoint.versions_seen[task.name][chan] = checkpoint.channel_versions[chan];
+			if (!RESERVED_SET.has(chan)) channelsToConsume.add(chan);
+		}
 	}
 	let maxVersion = maxChannelMapVersion(checkpoint.channel_versions);
-	const channelsToConsume = new Set(tasks.flatMap((task) => task.triggers).filter((chan) => !require_constants.RESERVED.includes(chan)));
 	let usedNewVersion = false;
 	for (const chan of channelsToConsume) if (chan in onlyChannels && onlyChannels[chan].consume()) {
 		if (getNextVersion !== void 0) {
@@ -167,22 +181,53 @@ function* candidateNodes(checkpoint, processes, extra) {
 	}
 }
 /**
+* Build an index over pendingWrites for O(1) lookups.
+*
+* @internal Exported for benchmarks and regression tests only.
+*/
+function _indexPendingWrites(pendingWrites) {
+	let nullResume;
+	const resumeByTaskId = /* @__PURE__ */ new Map();
+	const successfulWriteTaskIds = /* @__PURE__ */ new Set();
+	if (pendingWrites) for (const [tid, chan, val] of pendingWrites) {
+		if (tid === "00000000-0000-0000-0000-000000000000" && chan === "__resume__" && nullResume === void 0) nullResume = val;
+		if (chan === "__resume__" && tid !== "00000000-0000-0000-0000-000000000000") {
+			let arr = resumeByTaskId.get(tid);
+			if (!arr) {
+				arr = [];
+				resumeByTaskId.set(tid, arr);
+			}
+			arr.push(val);
+		}
+		if (chan !== "__error__") successfulWriteTaskIds.add(tid);
+	}
+	return {
+		nullResume,
+		resumeByTaskId,
+		successfulWriteTaskIds
+	};
+}
+/**
 * Prepare the set of tasks that will make up the next Pregel step.
 * This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered
 * by edges).
 */
 function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, config, forExecution, extra) {
 	const tasks = {};
+	const indexedExtra = extra.pendingWritesIndex ? extra : {
+		...extra,
+		pendingWritesIndex: _indexPendingWrites(pendingWrites)
+	};
 	const tasksChannel = channels[require_constants.TASKS];
 	if (tasksChannel?.isAvailable()) {
 		const len = tasksChannel.get().length;
 		for (let i = 0; i < len; i += 1) {
-			const task = _prepareSingleTask([require_constants.PUSH, i], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+			const task = _prepareSingleTask([require_constants.PUSH, i], checkpoint, pendingWrites, processes, channels, config, forExecution, indexedExtra);
 			if (task !== void 0) tasks[task.id] = task;
 		}
 	}
-	for (const name of candidateNodes(checkpoint, processes, extra)) {
-		const task = _prepareSingleTask([require_constants.PULL, name], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+	for (const name of candidateNodes(checkpoint, processes, indexedExtra)) {
+		const task = _prepareSingleTask([require_constants.PULL, name], checkpoint, pendingWrites, processes, channels, config, forExecution, indexedExtra);
 		if (task !== void 0) tasks[task.id] = task;
 	}
 	return tasks;
@@ -259,7 +304,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 								taskId: id,
 								currentTaskInput: call.input,
 								resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-								namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+								namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+								pendingWritesIndex: extra.pendingWritesIndex
 							}),
 							[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 							checkpoint_id: void 0,
@@ -277,7 +323,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 				} : void 0,
 				id,
 				path: outputTaskPath,
-				writers: []
+				writers: [],
+				timeout: call.timeout
 			};
 		} else return {
 			id,
@@ -290,7 +337,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 		if (!channels["__pregel_tasks"]?.isAvailable()) return;
 		const sends = channels[require_constants.TASKS].get();
 		if (index < 0 || index >= sends.length) return;
-		const packet = require_constants._isSendInterface(sends[index]) && !require_constants._isSend(sends[index]) ? new require_constants.Send(sends[index].node, sends[index].args) : sends[index];
+		const packet = require_constants._isSendInterface(sends[index]) && !require_constants._isSend(sends[index]) ? new require_constants.Send(sends[index].node, sends[index].args, sends[index].timeout !== void 0 ? { timeout: sends[index].timeout } : void 0) : sends[index];
 		if (!require_constants._isSendInterface(packet)) {
 			console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
 			return;
@@ -367,7 +414,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 									taskId,
 									currentTaskInput: packet.args,
 									resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-									namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+									namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+									pendingWritesIndex: extra.pendingWritesIndex
 								}),
 								[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 								checkpoint_id: void 0,
@@ -389,7 +437,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 					} : void 0,
 					id: taskId,
 					path: taskPath,
-					writers: proc.getWriters()
+					writers: proc.getWriters(),
+					timeout: packet.timeout ?? proc.timeout
 				};
 			}
 		} else return {
@@ -411,7 +460,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 				require_constants.PULL,
 				name
 			]), checkpoint.id);
-			if (pendingWrites.some((w) => w[0] === taskId && w[1] !== "__error__")) return;
+			if (extra.pendingWritesIndex ? extra.pendingWritesIndex.successfulWriteTaskIds.has(taskId) : pendingWrites.some((w) => w[0] === taskId && w[1] !== "__error__")) return;
 		}
 		const nullVersion = require_index.getNullChannelVersion(checkpoint.channel_versions);
 		if (nullVersion === void 0) return;
@@ -491,7 +540,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 										taskId,
 										currentTaskInput: val,
 										resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-										namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+										namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+										pendingWritesIndex: extra.pendingWritesIndex
 									}),
 									[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 									checkpoint_id: void 0,
@@ -513,7 +563,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 						} : void 0,
 						id: taskId,
 						path: taskPath,
-						writers: proc.getWriters()
+						writers: proc.getWriters(),
+						timeout: proc.timeout
 					};
 				}
 			} else return {
@@ -526,6 +577,115 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 	}
 }
 /**
+* Prepare an immediate node-level error handler task for a failed task.
+*
+* The handler runs only after the failed node's retry policy is exhausted (the
+* runner schedules it once a non-bubble-up error settles). It is prepared like
+* a PUSH task targeting the auto-generated handler node, receives the failed
+* node's input, and is injected with a {@link NodeError} under
+* {@link CONFIG_KEY_NODE_ERROR} so the handler can inspect the failure
+* provenance (and route via `Command({ goto })`).
+*
+* @internal
+*/
+function _prepareNodeErrorHandlerTask(failedTask, handlerNodeName, error, checkpoint, pendingWrites, processes, channels, config, extra) {
+	const { step, checkpointer, manager } = extra;
+	const proc = processes[handlerNodeName];
+	if (proc === void 0) return;
+	const node = proc.getNode();
+	if (node === void 0) return;
+	const configurable = config.configurable ?? {};
+	const parentNamespace = configurable.checkpoint_ns ?? "";
+	const triggers = [require_constants.PUSH];
+	const checkpointNamespace = parentNamespace === "" ? handlerNodeName : `${parentNamespace}|${handlerNodeName}`;
+	const taskId = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+		checkpointNamespace,
+		step.toString(),
+		handlerNodeName,
+		require_constants.PUSH,
+		"node_error_handler",
+		failedTask.id
+	]), checkpoint.id);
+	const taskCheckpointNamespace = `${checkpointNamespace}:${taskId}`;
+	const taskPath = [
+		require_constants.PUSH,
+		String(failedTask.name),
+		handlerNodeName,
+		false
+	];
+	let metadata = {
+		langgraph_step: step,
+		langgraph_node: handlerNodeName,
+		langgraph_triggers: triggers,
+		langgraph_path: taskPath,
+		langgraph_checkpoint_ns: taskCheckpointNamespace,
+		checkpoint_ns: taskCheckpointNamespace
+	};
+	if (proc.metadata !== void 0) metadata = {
+		...metadata,
+		...proc.metadata
+	};
+	const writes = [];
+	const executionInfo = {
+		checkpointId: checkpoint.id,
+		checkpointNs: taskCheckpointNamespace,
+		taskId,
+		threadId: configurable.thread_id,
+		runId: config.runId != null ? String(config.runId) : void 0,
+		nodeAttempt: 1
+	};
+	return {
+		name: handlerNodeName,
+		input: failedTask.input,
+		proc: node,
+		subgraphs: proc.subgraphs,
+		writes,
+		config: {
+			...(0, _langchain_core_runnables.patchConfig)((0, _langchain_core_runnables.mergeConfigs)(config, {
+				metadata,
+				tags: proc.tags,
+				store: extra.store ?? config.store
+			}), {
+				runName: handlerNodeName,
+				callbacks: manager?.getChild(`graph:step:${step}`),
+				configurable: {
+					[require_constants.CONFIG_KEY_TASK_ID]: taskId,
+					[require_constants.CONFIG_KEY_SEND]: (writes_) => _localWrite((items) => writes.push(...items), processes, writes_),
+					[require_constants.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(checkpoint, channels, {
+						name: handlerNodeName,
+						writes,
+						triggers,
+						path: taskPath
+					}, select_, fresh_),
+					[require_constants.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable["__pregel_checkpointer"],
+					[require_constants.CONFIG_KEY_CHECKPOINT_MAP]: {
+						...configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP],
+						[parentNamespace]: checkpoint.id
+					},
+					[require_constants.CONFIG_KEY_SCRATCHPAD]: _scratchpad({
+						pendingWrites: pendingWrites ?? [],
+						taskId,
+						currentTaskInput: failedTask.input,
+						resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
+						namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+					}),
+					[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
+					[require_constants.CONFIG_KEY_NODE_ERROR]: new require_errors.NodeError(String(failedTask.name), error),
+					checkpoint_id: void 0,
+					checkpoint_ns: taskCheckpointNamespace
+				}
+			}),
+			executionInfo
+		},
+		triggers,
+		retry_policy: proc.retryPolicy,
+		cache_key: void 0,
+		id: taskId,
+		path: taskPath,
+		writers: proc.getWriters()
+	};
+}
+/**
 *  Function injected under CONFIG_KEY_READ in task config, to read current state.
 *  Used by conditional edges to read a copy of the state with reflecting the writes
 *  from that node only.
@@ -581,13 +741,13 @@ function sanitizeUntrackedValuesInSend(packet, channels) {
 	}
 	return new require_constants.Send(packet.node, sanitizedArg);
 }
-function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, namespaceHash }) {
-	const nullResume = pendingWrites.find(([writeTaskId, chan]) => writeTaskId === "00000000-0000-0000-0000-000000000000" && chan === "__resume__")?.[2];
+function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, namespaceHash, pendingWritesIndex }) {
+	const nullResume = pendingWritesIndex ? pendingWritesIndex.nullResume : pendingWrites.find(([writeTaskId, chan]) => writeTaskId === "00000000-0000-0000-0000-000000000000" && chan === "__resume__")?.[2];
 	const scratchpad = {
 		callCounter: 0,
 		interruptCounter: -1,
 		resume: (() => {
-			const result = pendingWrites.filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === "__resume__").flatMap(([_writeTaskId, _chan, resume]) => resume);
+			const result = pendingWritesIndex ? (pendingWritesIndex.resumeByTaskId.get(taskId) ?? []).flat() : pendingWrites.filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === "__resume__").flatMap(([_writeTaskId, _chan, resume]) => resume);
 			if (resumeMap != null && namespaceHash in resumeMap) {
 				const mappedResume = resumeMap[namespaceHash];
 				result.push(mappedResume);
@@ -611,6 +771,7 @@ function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, names
 exports._applyWrites = _applyWrites;
 exports._localRead = _localRead;
 exports._prepareNextTasks = _prepareNextTasks;
+exports._prepareNodeErrorHandlerTask = _prepareNodeErrorHandlerTask;
 exports._prepareSingleTask = _prepareSingleTask;
 exports.increment = increment;
 exports.sanitizeUntrackedValuesInSend = sanitizeUntrackedValuesInSend;