@langchain/langgraph 1.4.16 → 1.4.17

package/dist/callbacks.cjs

@@ -0,0 +1,29 @@
+let _langchain_core_callbacks_base = require("@langchain/core/callbacks/base");
+//#region src/callbacks.ts
+const GRAPH_CALLBACK_HANDLER = Symbol.for("langgraph.graph_callback_handler");
+/**
+* Extend this class and pass an instance through `callbacks` to observe graph
+* interrupts and resumes. Lifecycle methods are always awaited, including when
+* other callbacks run in the background. Set `raiseError` to propagate errors.
+*
+* @example
+* ```ts
+* class Observer extends GraphCallbackHandler {
+*   handleInterrupt(event: GraphInterruptEvent) {
+*     console.log(event.runId, event.interrupts);
+*   }
+* }
+* const observed = graph.withConfig({ callbacks: [new Observer()] });
+* ```
+*/
+var GraphCallbackHandler = class extends _langchain_core_callbacks_base.BaseCallbackHandler {
+	name = "GraphCallbackHandler";
+	[GRAPH_CALLBACK_HANDLER] = true;
+	static isInstance(value) {
+		return typeof value === "object" && value !== null && GRAPH_CALLBACK_HANDLER in value && value[GRAPH_CALLBACK_HANDLER] === true;
+	}
+};
+//#endregion
+exports.GraphCallbackHandler = GraphCallbackHandler;
+
+//# sourceMappingURL=callbacks.cjs.map

package/dist/callbacks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.cjs","names":["BaseCallbackHandler"],"sources":["../src/callbacks.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"@langchain/core/callbacks/base\";\nimport type { Interrupt } from \"./constants.js\";\n\nconst GRAPH_CALLBACK_HANDLER = Symbol.for(\"langgraph.graph_callback_handler\");\n\n/** Loop status at a graph lifecycle transition. */\nexport type GraphLifecycleStatus =\n  | \"pending\"\n  | \"done\"\n  | \"interrupt_before\"\n  | \"interrupt_after\"\n  | \"out_of_steps\"\n  | \"draining\";\n\n/** A graph execution resumed from a checkpoint. */\nexport interface GraphResumeEvent {\n  readonly runId: string | undefined;\n  readonly status: GraphLifecycleStatus;\n  readonly checkpointId: string;\n  readonly checkpointNs: readonly string[];\n}\n\n/** The root graph paused. Static interrupts can have an empty payload list. */\nexport interface GraphInterruptEvent extends GraphResumeEvent {\n  readonly interrupts: readonly Interrupt[];\n}\n\nexport type GraphLifecycleEvent = GraphInterruptEvent | GraphResumeEvent;\n\n/**\n * Extend this class and pass an instance through `callbacks` to observe graph\n * interrupts and resumes. Lifecycle methods are always awaited, including when\n * other callbacks run in the background. Set `raiseError` to propagate errors.\n *\n * @example\n * ```ts\n * class Observer extends GraphCallbackHandler {\n *   handleInterrupt(event: GraphInterruptEvent) {\n *     console.log(event.runId, event.interrupts);\n *   }\n * }\n * const observed = graph.withConfig({ callbacks: [new Observer()] });\n * ```\n */\nexport class GraphCallbackHandler extends BaseCallbackHandler {\n  name = \"GraphCallbackHandler\";\n\n  readonly [GRAPH_CALLBACK_HANDLER] = true;\n\n  static isInstance(value: unknown): value is GraphCallbackHandler {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      GRAPH_CALLBACK_HANDLER in value &&\n      value[GRAPH_CALLBACK_HANDLER] === true\n    );\n  }\n\n  /** Called for root interrupts, before the terminal chain callback. */\n  handleInterrupt?(event: GraphInterruptEvent): void | Promise<void>;\n\n  /** Called before execution continues, including in resumed subgraphs. */\n  handleResume?(event: GraphResumeEvent): void | Promise<void>;\n}\n"],"mappings":";;AAGA,MAAM,yBAAyB,OAAO,IAAI,mCAAmC;;;;;;;;;;;;;;;;AAyC7E,IAAa,uBAAb,cAA0CA,+BAAAA,oBAAoB;CAC5D,OAAO;CAEP,CAAU,0BAA0B;CAEpC,OAAO,WAAW,OAA+C;AAC/D,SACE,OAAO,UAAU,YACjB,UAAU,QACV,0BAA0B,SAC1B,MAAM,4BAA4B"}

package/dist/callbacks.d.cts

@@ -0,0 +1,46 @@
+import { Interrupt } from "./constants.cjs";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+
+//#region src/callbacks.d.ts
+declare const GRAPH_CALLBACK_HANDLER: unique symbol;
+/** Loop status at a graph lifecycle transition. */
+type GraphLifecycleStatus = "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps" | "draining";
+/** A graph execution resumed from a checkpoint. */
+interface GraphResumeEvent {
+  readonly runId: string | undefined;
+  readonly status: GraphLifecycleStatus;
+  readonly checkpointId: string;
+  readonly checkpointNs: readonly string[];
+}
+/** The root graph paused. Static interrupts can have an empty payload list. */
+interface GraphInterruptEvent extends GraphResumeEvent {
+  readonly interrupts: readonly Interrupt[];
+}
+type GraphLifecycleEvent = GraphInterruptEvent | GraphResumeEvent;
+/**
+ * Extend this class and pass an instance through `callbacks` to observe graph
+ * interrupts and resumes. Lifecycle methods are always awaited, including when
+ * other callbacks run in the background. Set `raiseError` to propagate errors.
+ *
+ * @example
+ * ```ts
+ * class Observer extends GraphCallbackHandler {
+ *   handleInterrupt(event: GraphInterruptEvent) {
+ *     console.log(event.runId, event.interrupts);
+ *   }
+ * }
+ * const observed = graph.withConfig({ callbacks: [new Observer()] });
+ * ```
+ */
+declare class GraphCallbackHandler extends BaseCallbackHandler {
+  name: string;
+  readonly [GRAPH_CALLBACK_HANDLER] = true;
+  static isInstance(value: unknown): value is GraphCallbackHandler;
+  /** Called for root interrupts, before the terminal chain callback. */
+  handleInterrupt?(event: GraphInterruptEvent): void | Promise<void>;
+  /** Called before execution continues, including in resumed subgraphs. */
+  handleResume?(event: GraphResumeEvent): void | Promise<void>;
+}
+//#endregion
+export { GraphCallbackHandler, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphResumeEvent };
+//# sourceMappingURL=callbacks.d.cts.map

package/dist/callbacks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.cts","names":[],"sources":["../src/callbacks.ts"],"mappings":";;;;cAGM,sBAAA;;KAGM,oBAAA;;UASK,gBAAA;EAAA,SACN,KAAA;EAAA,SACA,MAAA,EAAQ,oBAAA;EAAA,SACR,YAAA;EAAA,SACA,YAAA;AAAA;;UAIM,mBAAA,SAA4B,gBAAA;EAAA,SAClC,UAAA,WAAqB,SAAA;AAAA;AAAA,KAGpB,mBAAA,GAAsB,mBAAA,GAAsB,gBAAA;;;;;;;;;AAJxD;;;;;;;cAqBa,oBAAA,SAA6B,mBAAA;EACxC,IAAA;EAAA,UAEU,sBAAA;EAAA,OAEH,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,oBAAA;;EAU5C,eAAA,CAAA,CAAiB,KAAA,EAAO,mBAAA,UAA6B,OAAA;EAhCiB;EAmCtE,YAAA,CAAA,CAAc,KAAA,EAAO,gBAAA,UAA0B,OAAA;AAAA"}

package/dist/callbacks.d.ts

@@ -0,0 +1,46 @@
+import { Interrupt } from "./constants.js";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+
+//#region src/callbacks.d.ts
+declare const GRAPH_CALLBACK_HANDLER: unique symbol;
+/** Loop status at a graph lifecycle transition. */
+type GraphLifecycleStatus = "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps" | "draining";
+/** A graph execution resumed from a checkpoint. */
+interface GraphResumeEvent {
+  readonly runId: string | undefined;
+  readonly status: GraphLifecycleStatus;
+  readonly checkpointId: string;
+  readonly checkpointNs: readonly string[];
+}
+/** The root graph paused. Static interrupts can have an empty payload list. */
+interface GraphInterruptEvent extends GraphResumeEvent {
+  readonly interrupts: readonly Interrupt[];
+}
+type GraphLifecycleEvent = GraphInterruptEvent | GraphResumeEvent;
+/**
+ * Extend this class and pass an instance through `callbacks` to observe graph
+ * interrupts and resumes. Lifecycle methods are always awaited, including when
+ * other callbacks run in the background. Set `raiseError` to propagate errors.
+ *
+ * @example
+ * ```ts
+ * class Observer extends GraphCallbackHandler {
+ *   handleInterrupt(event: GraphInterruptEvent) {
+ *     console.log(event.runId, event.interrupts);
+ *   }
+ * }
+ * const observed = graph.withConfig({ callbacks: [new Observer()] });
+ * ```
+ */
+declare class GraphCallbackHandler extends BaseCallbackHandler {
+  name: string;
+  readonly [GRAPH_CALLBACK_HANDLER] = true;
+  static isInstance(value: unknown): value is GraphCallbackHandler;
+  /** Called for root interrupts, before the terminal chain callback. */
+  handleInterrupt?(event: GraphInterruptEvent): void | Promise<void>;
+  /** Called before execution continues, including in resumed subgraphs. */
+  handleResume?(event: GraphResumeEvent): void | Promise<void>;
+}
+//#endregion
+export { GraphCallbackHandler, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphResumeEvent };
+//# sourceMappingURL=callbacks.d.ts.map

package/dist/callbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.ts","names":[],"sources":["../src/callbacks.ts"],"mappings":";;;;cAGM,sBAAA;;KAGM,oBAAA;;UASK,gBAAA;EAAA,SACN,KAAA;EAAA,SACA,MAAA,EAAQ,oBAAA;EAAA,SACR,YAAA;EAAA,SACA,YAAA;AAAA;;UAIM,mBAAA,SAA4B,gBAAA;EAAA,SAClC,UAAA,WAAqB,SAAA;AAAA;AAAA,KAGpB,mBAAA,GAAsB,mBAAA,GAAsB,gBAAA;;;;;;;;;AAJxD;;;;;;;cAqBa,oBAAA,SAA6B,mBAAA;EACxC,IAAA;EAAA,UAEU,sBAAA;EAAA,OAEH,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,oBAAA;;EAU5C,eAAA,CAAA,CAAiB,KAAA,EAAO,mBAAA,UAA6B,OAAA;EAhCiB;EAmCtE,YAAA,CAAA,CAAc,KAAA,EAAO,gBAAA,UAA0B,OAAA;AAAA"}

package/dist/callbacks.js

@@ -0,0 +1,29 @@
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+//#region src/callbacks.ts
+const GRAPH_CALLBACK_HANDLER = Symbol.for("langgraph.graph_callback_handler");
+/**
+* Extend this class and pass an instance through `callbacks` to observe graph
+* interrupts and resumes. Lifecycle methods are always awaited, including when
+* other callbacks run in the background. Set `raiseError` to propagate errors.
+*
+* @example
+* ```ts
+* class Observer extends GraphCallbackHandler {
+*   handleInterrupt(event: GraphInterruptEvent) {
+*     console.log(event.runId, event.interrupts);
+*   }
+* }
+* const observed = graph.withConfig({ callbacks: [new Observer()] });
+* ```
+*/
+var GraphCallbackHandler = class extends BaseCallbackHandler {
+	name = "GraphCallbackHandler";
+	[GRAPH_CALLBACK_HANDLER] = true;
+	static isInstance(value) {
+		return typeof value === "object" && value !== null && GRAPH_CALLBACK_HANDLER in value && value[GRAPH_CALLBACK_HANDLER] === true;
+	}
+};
+//#endregion
+export { GraphCallbackHandler };
+
+//# sourceMappingURL=callbacks.js.map

package/dist/callbacks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.js","names":[],"sources":["../src/callbacks.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"@langchain/core/callbacks/base\";\nimport type { Interrupt } from \"./constants.js\";\n\nconst GRAPH_CALLBACK_HANDLER = Symbol.for(\"langgraph.graph_callback_handler\");\n\n/** Loop status at a graph lifecycle transition. */\nexport type GraphLifecycleStatus =\n  | \"pending\"\n  | \"done\"\n  | \"interrupt_before\"\n  | \"interrupt_after\"\n  | \"out_of_steps\"\n  | \"draining\";\n\n/** A graph execution resumed from a checkpoint. */\nexport interface GraphResumeEvent {\n  readonly runId: string | undefined;\n  readonly status: GraphLifecycleStatus;\n  readonly checkpointId: string;\n  readonly checkpointNs: readonly string[];\n}\n\n/** The root graph paused. Static interrupts can have an empty payload list. */\nexport interface GraphInterruptEvent extends GraphResumeEvent {\n  readonly interrupts: readonly Interrupt[];\n}\n\nexport type GraphLifecycleEvent = GraphInterruptEvent | GraphResumeEvent;\n\n/**\n * Extend this class and pass an instance through `callbacks` to observe graph\n * interrupts and resumes. Lifecycle methods are always awaited, including when\n * other callbacks run in the background. Set `raiseError` to propagate errors.\n *\n * @example\n * ```ts\n * class Observer extends GraphCallbackHandler {\n *   handleInterrupt(event: GraphInterruptEvent) {\n *     console.log(event.runId, event.interrupts);\n *   }\n * }\n * const observed = graph.withConfig({ callbacks: [new Observer()] });\n * ```\n */\nexport class GraphCallbackHandler extends BaseCallbackHandler {\n  name = \"GraphCallbackHandler\";\n\n  readonly [GRAPH_CALLBACK_HANDLER] = true;\n\n  static isInstance(value: unknown): value is GraphCallbackHandler {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      GRAPH_CALLBACK_HANDLER in value &&\n      value[GRAPH_CALLBACK_HANDLER] === true\n    );\n  }\n\n  /** Called for root interrupts, before the terminal chain callback. */\n  handleInterrupt?(event: GraphInterruptEvent): void | Promise<void>;\n\n  /** Called before execution continues, including in resumed subgraphs. */\n  handleResume?(event: GraphResumeEvent): void | Promise<void>;\n}\n"],"mappings":";;AAGA,MAAM,yBAAyB,OAAO,IAAI,mCAAmC;;;;;;;;;;;;;;;;AAyC7E,IAAa,uBAAb,cAA0C,oBAAoB;CAC5D,OAAO;CAEP,CAAU,0BAA0B;CAEpC,OAAO,WAAW,OAA+C;AAC/D,SACE,OAAO,UAAU,YACjB,UAAU,QACV,0BAA0B,SAC1B,MAAM,4BAA4B"}

package/dist/index.cjs

@@ -6,6 +6,7 @@ const require_base = require("./channels/base.cjs");
 const require_binop = require("./channels/binop.cjs");
 const require_annotation = require("./graph/annotation.cjs");
 const require_config = require("./pregel/utils/config.cjs");
+const require_callbacks = require("./callbacks.cjs");
 const require_runtime = require("./pregel/runtime.cjs");
 const require_convert = require("./stream/convert.cjs");
 const require_stream_channel = require("./stream/stream-channel.cjs");
@@ -78,6 +79,7 @@ exports.EmptyInputError = require_errors.EmptyInputError;
 exports.EventLog = require_stream_channel.StreamChannel;
 exports.Graph = require_graph.Graph;
 exports.GraphBubbleUp = require_errors.GraphBubbleUp;
+exports.GraphCallbackHandler = require_callbacks.GraphCallbackHandler;
 exports.GraphDrained = require_errors.GraphDrained;
 exports.GraphInterrupt = require_errors.GraphInterrupt;
 exports.GraphRecursionError = require_errors.GraphRecursionError;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["initializeAsyncLocalStorageSingleton"],"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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKAA,aAAAA,sCAAsC"}
+{"version":3,"file":"index.cjs","names":["initializeAsyncLocalStorageSingleton"],"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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKAA,aAAAA,sCAAsC"}

package/dist/index.d.cts

@@ -45,5 +45,6 @@ import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/m
 import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter.cjs";
 import { MessagesDeltaValue, MessagesValue } from "./state/prebuilt/messages.cjs";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.cjs";
+import { GraphCallbackHandler, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphResumeEvent } from "./callbacks.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, DeltaChannel, DeltaReducer, DeltaValue, DeltaValueInit, 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, InterruptOptions, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesDeltaValue, 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 };
+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, DeltaValue, DeltaValueInit, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphCallbackHandler, GraphDrained, GraphInterrupt, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphResumeEvent, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptOptions, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesDeltaValue, 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

@@ -45,5 +45,6 @@ import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/m
 import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter.js";
 import { MessagesDeltaValue, MessagesValue } from "./state/prebuilt/messages.js";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
+import { GraphCallbackHandler, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphResumeEvent } from "./callbacks.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, DeltaChannel, DeltaReducer, DeltaValue, DeltaValueInit, 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, InterruptOptions, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesDeltaValue, 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 };
+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, DeltaValue, DeltaValueInit, DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, EntrypointOptions, EphemeralValue, StreamChannel as EventLog, ExecutionInfo, ExtractStateType, ExtractUpdateType, GetOperation, GetStateOptions, Graph, GraphBubbleUp, GraphCallbackHandler, GraphDrained, GraphInterrupt, GraphInterruptEvent, GraphLifecycleEvent, GraphLifecycleStatus, GraphNode, GraphNodeReturnValue, GraphNodeTypes, GraphRecursionError, GraphResumeEvent, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InferExtensions, InferInterruptInputType, InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, InferWriterType, Interrupt, InterruptOptions, InterruptPayload, InvalidUpdateError, Item, LangGraphRunnableConfig, LastValue, LifecycleCause, LifecycleData, LifecycleEntry, LifecycleProjection, LifecycleTransformerOptions, ListNamespacesOperation, MatchCondition, MemorySaver, MessageGraph, Messages, MessagesAnnotation, MessagesDeltaValue, 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

@@ -5,6 +5,7 @@ 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 { GraphCallbackHandler } from "./callbacks.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";
@@ -36,6 +37,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, DeltaChannel, DeltaValue, END, EmptyChannelError, EmptyInputError, StreamChannel as EventLog, Graph, GraphBubbleUp, GraphDrained, GraphInterrupt, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesDeltaValue, 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 };
+export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, COMMAND_SYMBOL, ChatModelStreamImpl, Command, CommandInstance, CompiledStateGraph, DeltaChannel, DeltaValue, END, EmptyChannelError, EmptyInputError, StreamChannel as EventLog, Graph, GraphBubbleUp, GraphCallbackHandler, GraphDrained, GraphInterrupt, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesDeltaValue, 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/pregel/callbacks.cjs

@@ -0,0 +1,25 @@
+const require_callbacks = require("../callbacks.cjs");
+//#region src/pregel/callbacks.ts
+function getGraphCallbackDispatcher(manager) {
+	const handlers = manager?.handlers.filter(require_callbacks.GraphCallbackHandler.isInstance);
+	if (!handlers?.length) return void 0;
+	return async (events) => {
+		while (events?.length) {
+			const event = events.shift();
+			for (const handler of handlers) {
+				const method = "interrupts" in event ? "handleInterrupt" : "handleResume";
+				try {
+					if ("interrupts" in event) await handler.handleInterrupt?.(event);
+					else await handler.handleResume?.(event);
+				} catch (error) {
+					(handler.raiseError ? console.error : console.warn)(`Error in handler ${handler.constructor.name}, ${method}: ${error}`);
+					if (handler.raiseError) throw error;
+				}
+			}
+		}
+	};
+}
+//#endregion
+exports.getGraphCallbackDispatcher = getGraphCallbackDispatcher;
+
+//# sourceMappingURL=callbacks.cjs.map

package/dist/pregel/callbacks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.cjs","names":["GraphCallbackHandler"],"sources":["../../src/pregel/callbacks.ts"],"sourcesContent":["import type { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  GraphCallbackHandler,\n  type GraphLifecycleEvent,\n} from \"../callbacks.js\";\n\nexport function getGraphCallbackDispatcher(\n  manager: CallbackManagerForChainRun | undefined\n) {\n  const handlers = manager?.handlers.filter(GraphCallbackHandler.isInstance);\n  if (!handlers?.length) return undefined;\n\n  return async (events: GraphLifecycleEvent[] | undefined) => {\n    while (events?.length) {\n      const event = events.shift()!;\n      for (const handler of handlers) {\n        const method =\n          \"interrupts\" in event ? \"handleInterrupt\" : \"handleResume\";\n        try {\n          if (\"interrupts\" in event) {\n            await handler.handleInterrupt?.(event);\n          } else {\n            await handler.handleResume?.(event);\n          }\n        } catch (error) {\n          (handler.raiseError ? console.error : console.warn)(\n            `Error in handler ${handler.constructor.name}, ${method}: ${error}`\n          );\n          if (handler.raiseError) throw error;\n        }\n      }\n    }\n  };\n}\n"],"mappings":";;AAMA,SAAgB,2BACd,SACA;CACA,MAAM,WAAW,SAAS,SAAS,OAAOA,kBAAAA,qBAAqB,WAAW;AAC1E,KAAI,CAAC,UAAU,OAAQ,QAAO,KAAA;AAE9B,QAAO,OAAO,WAA8C;AAC1D,SAAO,QAAQ,QAAQ;GACrB,MAAM,QAAQ,OAAO,OAAO;AAC5B,QAAK,MAAM,WAAW,UAAU;IAC9B,MAAM,SACJ,gBAAgB,QAAQ,oBAAoB;AAC9C,QAAI;AACF,SAAI,gBAAgB,MAClB,OAAM,QAAQ,kBAAkB,MAAM;SAEtC,OAAM,QAAQ,eAAe,MAAM;aAE9B,OAAO;AACd,MAAC,QAAQ,aAAa,QAAQ,QAAQ,QAAQ,MAC5C,oBAAoB,QAAQ,YAAY,KAAK,IAAI,OAAO,IAAI,QAC7D;AACD,SAAI,QAAQ,WAAY,OAAM"}

package/dist/pregel/callbacks.js

@@ -0,0 +1,25 @@
+import { GraphCallbackHandler } from "../callbacks.js";
+//#region src/pregel/callbacks.ts
+function getGraphCallbackDispatcher(manager) {
+	const handlers = manager?.handlers.filter(GraphCallbackHandler.isInstance);
+	if (!handlers?.length) return void 0;
+	return async (events) => {
+		while (events?.length) {
+			const event = events.shift();
+			for (const handler of handlers) {
+				const method = "interrupts" in event ? "handleInterrupt" : "handleResume";
+				try {
+					if ("interrupts" in event) await handler.handleInterrupt?.(event);
+					else await handler.handleResume?.(event);
+				} catch (error) {
+					(handler.raiseError ? console.error : console.warn)(`Error in handler ${handler.constructor.name}, ${method}: ${error}`);
+					if (handler.raiseError) throw error;
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { getGraphCallbackDispatcher };
+
+//# sourceMappingURL=callbacks.js.map

package/dist/pregel/callbacks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.js","names":[],"sources":["../../src/pregel/callbacks.ts"],"sourcesContent":["import type { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  GraphCallbackHandler,\n  type GraphLifecycleEvent,\n} from \"../callbacks.js\";\n\nexport function getGraphCallbackDispatcher(\n  manager: CallbackManagerForChainRun | undefined\n) {\n  const handlers = manager?.handlers.filter(GraphCallbackHandler.isInstance);\n  if (!handlers?.length) return undefined;\n\n  return async (events: GraphLifecycleEvent[] | undefined) => {\n    while (events?.length) {\n      const event = events.shift()!;\n      for (const handler of handlers) {\n        const method =\n          \"interrupts\" in event ? \"handleInterrupt\" : \"handleResume\";\n        try {\n          if (\"interrupts\" in event) {\n            await handler.handleInterrupt?.(event);\n          } else {\n            await handler.handleResume?.(event);\n          }\n        } catch (error) {\n          (handler.raiseError ? console.error : console.warn)(\n            `Error in handler ${handler.constructor.name}, ${method}: ${error}`\n          );\n          if (handler.raiseError) throw error;\n        }\n      }\n    }\n  };\n}\n"],"mappings":";;AAMA,SAAgB,2BACd,SACA;CACA,MAAM,WAAW,SAAS,SAAS,OAAO,qBAAqB,WAAW;AAC1E,KAAI,CAAC,UAAU,OAAQ,QAAO,KAAA;AAE9B,QAAO,OAAO,WAA8C;AAC1D,SAAO,QAAQ,QAAQ;GACrB,MAAM,QAAQ,OAAO,OAAO;AAC5B,QAAK,MAAM,WAAW,UAAU;IAC9B,MAAM,SACJ,gBAAgB,QAAQ,oBAAoB;AAC9C,QAAI;AACF,SAAI,gBAAgB,MAClB,OAAM,QAAQ,kBAAkB,MAAM;SAEtC,OAAM,QAAQ,eAAe,MAAM;aAE9B,OAAO;AACd,MAAC,QAAQ,aAAa,QAAQ,QAAQ,QAAQ,MAC5C,oBAAoB,QAAQ,YAAY,KAAK,IAAI,OAAO,IAAI,QAC7D;AACD,SAAI,QAAQ,WAAY,OAAM"}

package/dist/pregel/index.cjs

@@ -6,6 +6,7 @@ const require_config = require("./utils/config.cjs");
 const require_utils = require("../utils.cjs");
 const require_write = require("./write.cjs");
 const require_read = require("./read.cjs");
+const require_callbacks = require("./callbacks.cjs");
 const require_runtime = require("./runtime.cjs");
 const require_io = require("./io.cjs");
 const require_index = require("./utils/index.cjs");
@@ -1061,6 +1062,7 @@ var Pregel = class extends PartialRunnable {
 		config.control ??= new require_runtime.RunControl();
 		const callbackManagerOptions = { tracerInheritableMetadata: _getTracingMetadataDefaults(config) };
 		const runManager = await (await _langchain_core_callbacks_manager.CallbackManager._configureSync(config?.callbacks, void 0, config?.tags, void 0, config?.metadata, void 0, callbackManagerOptions))?.handleChainStart(this.toJSON(), require_index._coerceToDict(input, "input"), runId, void 0, void 0, void 0, config?.runName ?? this.getName());
+		const dispatchGraphCallbacks = require_callbacks.getGraphCallbackDispatcher(runManager);
 		const channelSpecs = require_base.getOnlyChannels(this.channels);
 		let loop;
 		let loopError;
@@ -1088,6 +1090,7 @@ var Pregel = class extends PartialRunnable {
 					interruptAfter,
 					interruptBefore,
 					manager: runManager,
+					hasGraphCallbacks: dispatchGraphCallbacks !== void 0,
 					debug: this.debug,
 					triggerToNodes: this.triggerToNodes,
 					durability
@@ -1104,7 +1107,8 @@ var Pregel = class extends PartialRunnable {
 					loop,
 					runner,
 					debug,
-					config
+					config,
+					emitLifecycleEvents: dispatchGraphCallbacks
 				});
 				if (durability === "sync") await Promise.all(loop?.checkpointerPromises ?? []);
 			} catch (e) {
@@ -1199,10 +1203,11 @@ var Pregel = class extends PartialRunnable {
 		return chunks;
 	}
 	async _runLoop(params) {
-		const { loop, runner, debug, config } = params;
+		const { loop, runner, debug, config, emitLifecycleEvents } = params;
 		let tickError;
 		try {
 			while (await loop.tick({ inputKeys: this.inputChannels })) {
+				if (emitLifecycleEvents) await emitLifecycleEvents(loop.lifecycleEvents);
 				for (const { task } of await loop._matchCachedWrites()) loop._outputWrites(task.id, task.writes, true);
 				if (debug) require_debug.printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
 				if (debug) require_debug.printStepTasks(loop.step, Object.values(loop.tasks));
@@ -1230,6 +1235,7 @@ var Pregel = class extends PartialRunnable {
 			if (!await loop.finishAndHandleError(tickError)) throw e;
 		} finally {
 			if (tickError === void 0) await loop.finishAndHandleError();
+			if (emitLifecycleEvents) await emitLifecycleEvents(loop.lifecycleEvents);
 		}
 	}
 	async clearCache() {