@langchain/langgraph 1.4.15 → 1.4.17

package/dist/index.d.ts

@@ -35,7 +35,7 @@ import { DeltaValue, DeltaValueInit } from "./state/values/delta.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 { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.js";
-import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.js";
+import { InferInterruptInputType, InferInterruptResumeType, InterruptOptions, 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";
@@ -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, 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/interrupt.cjs

@@ -2,6 +2,8 @@ const require_constants = require("./constants.cjs");
 const require_errors = require("./errors.cjs");
 const require_hash = require("./hash.cjs");
 let _langchain_core_singletons = require("@langchain/core/singletons");
+let _langchain_core_utils_json_schema = require("@langchain/core/utils/json_schema");
+let _langchain_core_utils_types = require("@langchain/core/utils/types");
 //#region src/interrupt.ts
 /**
 * Interrupts the execution of a graph node.
@@ -19,7 +21,10 @@ let _langchain_core_singletons = require("@langchain/core/singletons");
 * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
 *
 * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
-* @returns The `resume` value provided when the graph is re-invoked with a Command
+* @param options - Optional settings. `responseSchema` describes the expected resume value and is
+*   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.
+* @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by
+*   `responseSchema` when it is a Zod schema
 *
 * @example
 * ```typescript
@@ -45,32 +50,39 @@ let _langchain_core_singletons = require("@langchain/core/singletons");
 *
 * @throws {Error} If called outside the context of a graph
 * @throws {GraphInterrupt} When no resume value is available
+* @throws {ZodError} When the resume value does not match a Zod `responseSchema`
 */
-function interrupt(value) {
+function interrupt(value, options) {
 	const config = _langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig();
 	if (!config) throw new Error("Called interrupt() outside the context of a graph.");
 	const conf = config.configurable;
 	if (!conf) throw new Error("No configurable found in config");
 	if (!conf["__pregel_checkpointer"]) throw new require_errors.GraphValueError("No checkpointer set", { lc_error_code: "MISSING_CHECKPOINTER" });
+	const schema = options?.responseSchema;
+	const parseResume = (resume) => schema !== void 0 && (0, _langchain_core_utils_types.isInteropZodSchema)(schema) ? (0, _langchain_core_utils_types.interopParse)(schema, resume) : resume;
 	const scratchpad = conf[require_constants.CONFIG_KEY_SCRATCHPAD];
 	scratchpad.interruptCounter += 1;
 	const idx = scratchpad.interruptCounter;
 	if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {
-		conf[require_constants.CONFIG_KEY_SEND]?.([[require_constants.RESUME, scratchpad.resume]]);
-		return scratchpad.resume[idx];
+		const parsed = parseResume(scratchpad.resume[idx]);
+		conf[require_constants.CONFIG_KEY_SEND]?.([[require_constants.RESUME, scratchpad.resume.slice(0, idx + 1)]]);
+		return parsed;
 	}
 	if (scratchpad.nullResume !== void 0) {
 		if (scratchpad.resume.length !== idx) throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
 		const v = scratchpad.consumeNullResume();
+		const parsed = parseResume(v);
 		scratchpad.resume.push(v);
 		conf[require_constants.CONFIG_KEY_SEND]?.([[require_constants.RESUME, scratchpad.resume]]);
-		return v;
+		return parsed;
 	}
 	const ns = conf[require_constants.CONFIG_KEY_CHECKPOINT_NS]?.split("|");
-	throw new require_errors.GraphInterrupt([{
+	const pending = {
 		id: ns ? require_hash.XXH3(ns.join("|")) : void 0,
 		value
-	}]);
+	};
+	if (schema !== void 0) pending.response_schema = (0, _langchain_core_utils_json_schema.toJsonSchema)(schema);
+	throw new require_errors.GraphInterrupt([pending]);
 }
 //#endregion
 exports.interrupt = interrupt;

package/dist/interrupt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.cjs","names":["AsyncLocalStorageProviderSingleton","GraphValueError","CONFIG_KEY_SCRATCHPAD","CONFIG_KEY_SEND","RESUME","CONFIG_KEY_CHECKPOINT_NS","GraphInterrupt","XXH3"],"sources":["../src/interrupt.ts"],"sourcesContent":["import { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  BaseCheckpointSaver,\n  type PendingWrite,\n} from \"@langchain/langgraph-checkpoint\";\nimport { GraphInterrupt, GraphValueError } from \"./errors.js\";\nimport {\n  CONFIG_KEY_CHECKPOINT_NS,\n  CONFIG_KEY_SCRATCHPAD,\n  CONFIG_KEY_SEND,\n  CONFIG_KEY_CHECKPOINTER,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  RESUME,\n} from \"./constants.js\";\nimport { PregelScratchpad } from \"./pregel/types.js\";\nimport { XXH3 } from \"./hash.js\";\n\n/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @returns The `resume` value provided when the graph is re-invoked with a Command\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function interrupt<I = unknown, R = any>(value: I): R {\n  const config: RunnableConfig | undefined =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (!config) {\n    throw new Error(\"Called interrupt() outside the context of a graph.\");\n  }\n\n  const conf = config.configurable;\n  if (!conf) {\n    throw new Error(\"No configurable found in config\");\n  }\n\n  const checkpointer: BaseCheckpointSaver = conf[CONFIG_KEY_CHECKPOINTER];\n  if (!checkpointer) {\n    throw new GraphValueError(\"No checkpointer set\", {\n      lc_error_code: \"MISSING_CHECKPOINTER\",\n    });\n  }\n\n  // Track interrupt index\n  const scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD];\n  scratchpad.interruptCounter += 1;\n  const idx = scratchpad.interruptCounter;\n\n  // Find previous resume values\n  if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return scratchpad.resume[idx] as R;\n  }\n\n  // Find current resume value\n  if (scratchpad.nullResume !== undefined) {\n    if (scratchpad.resume.length !== idx) {\n      throw new Error(\n        `Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`\n      );\n    }\n    const v = scratchpad.consumeNullResume();\n    scratchpad.resume.push(v);\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return v as R;\n  }\n\n  // No resume value found\n  const ns: string[] | undefined = conf[CONFIG_KEY_CHECKPOINT_NS]?.split(\n    CHECKPOINT_NAMESPACE_SEPARATOR\n  );\n\n  const id = ns ? XXH3(ns.join(CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;\n  throw new GraphInterrupt([{ id, value }]);\n}\n\ntype FilterAny<X> =\n  (<T>() => T extends X ? 1 : 2) extends <\n    T,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  >() => T extends any ? 1 : 2\n    ? never\n    : X;\n\nexport type InferInterruptInputType<T> = T extends typeof interrupt<\n  infer I,\n  unknown\n>\n  ? I\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptInputType<T[K]> }[keyof T]\n    : unknown;\n\nexport type InferInterruptResumeType<\n  T,\n  TInner = false,\n> = T extends typeof interrupt<never, infer R>\n  ? TInner extends true\n    ? FilterAny<R>\n    : R\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T]\n    : unknown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,UAAgC,OAAa;CAC3D,MAAM,SACJA,2BAAAA,mCAAmC,mBAAmB;AACxD,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,qDAAqD;CAGvE,MAAM,OAAO,OAAO;AACpB,KAAI,CAAC,KACH,OAAM,IAAI,MAAM,kCAAkC;AAIpD,KAAI,CADsC,KAAA,yBAExC,OAAM,IAAIC,eAAAA,gBAAgB,uBAAuB,EAC/C,eAAe,wBAChB,CAAC;CAIJ,MAAM,aAA+B,KAAKC,kBAAAA;AAC1C,YAAW,oBAAoB;CAC/B,MAAM,MAAM,WAAW;AAGvB,KAAI,WAAW,OAAO,SAAS,KAAK,MAAM,WAAW,OAAO,QAAQ;AAClE,OAAKC,kBAAAA,mBAAmB,CAAC,CAACC,kBAAAA,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO,WAAW,OAAO;;AAI3B,KAAI,WAAW,eAAe,KAAA,GAAW;AACvC,MAAI,WAAW,OAAO,WAAW,IAC/B,OAAM,IAAI,MACR,2BAA2B,WAAW,OAAO,OAAO,OAAO,MAC5D;EAEH,MAAM,IAAI,WAAW,mBAAmB;AACxC,aAAW,OAAO,KAAK,EAAE;AACzB,OAAKD,kBAAAA,mBAAmB,CAAC,CAACC,kBAAAA,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO;;CAIT,MAAM,KAA2B,KAAKC,kBAAAA,2BAA2B,MAAA,IAEhE;AAGD,OAAM,IAAIC,eAAAA,eAAe,CAAC;EAAE,IADjB,KAAKC,aAAAA,KAAK,GAAG,KAAA,IAAoC,CAAC,GAAG,KAAA;EAChC;EAAO,CAAC,CAAC"}
+{"version":3,"file":"interrupt.cjs","names":["AsyncLocalStorageProviderSingleton","GraphValueError","CONFIG_KEY_SCRATCHPAD","CONFIG_KEY_SEND","RESUME","CONFIG_KEY_CHECKPOINT_NS","XXH3","GraphInterrupt"],"sources":["../src/interrupt.ts"],"sourcesContent":["import { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  type JSONSchema,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport {\n  type InteropZodType,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseCheckpointSaver,\n  type PendingWrite,\n} from \"@langchain/langgraph-checkpoint\";\nimport { GraphInterrupt, GraphValueError } from \"./errors.js\";\nimport {\n  CONFIG_KEY_CHECKPOINT_NS,\n  CONFIG_KEY_SCRATCHPAD,\n  CONFIG_KEY_SEND,\n  CONFIG_KEY_CHECKPOINTER,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  RESUME,\n  type Interrupt,\n} from \"./constants.js\";\nimport { PregelScratchpad } from \"./pregel/types.js\";\nimport { XXH3 } from \"./hash.js\";\n\nexport interface InterruptOptions {\n  /**\n   * Schema for the value expected when the graph is resumed, surfaced to\n   * clients on `Interrupt.response_schema` (as JSON Schema) so they can render\n   * a typed input form. A Zod schema also parses the resume value, and the\n   * parsed value is what `interrupt` returns; a JSON Schema object is passed\n   * through to clients without validating the resume value.\n   */\n  responseSchema?: InteropZodType | JSONSchema;\n}\n\n/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @param options - Optional settings. `responseSchema` describes the expected resume value and is\n *   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.\n * @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by\n *   `responseSchema` when it is a Zod schema\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n * @throws {ZodError} When the resume value does not match a Zod `responseSchema`\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function interrupt<I = unknown, R = any>(\n  value: I,\n  options?: InterruptOptions\n): R {\n  const config: RunnableConfig | undefined =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (!config) {\n    throw new Error(\"Called interrupt() outside the context of a graph.\");\n  }\n\n  const conf = config.configurable;\n  if (!conf) {\n    throw new Error(\"No configurable found in config\");\n  }\n\n  const checkpointer: BaseCheckpointSaver = conf[CONFIG_KEY_CHECKPOINTER];\n  if (!checkpointer) {\n    throw new GraphValueError(\"No checkpointer set\", {\n      lc_error_code: \"MISSING_CHECKPOINTER\",\n    });\n  }\n\n  const schema = options?.responseSchema;\n  const parseResume = (resume: unknown): R =>\n    (schema !== undefined && isInteropZodSchema(schema)\n      ? interopParse(schema, resume)\n      : resume) as R;\n\n  // Track interrupt index\n  const scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD];\n  scratchpad.interruptCounter += 1;\n  const idx = scratchpad.interruptCounter;\n\n  // Find previous resume values\n  if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {\n    const parsed = parseResume(scratchpad.resume[idx]);\n    // Persist only through the interrupt being consumed. Values past `idx` belong\n    // to later interrupts and may be unvalidated mapped resumes; a failing one must\n    // not become durable, or its retry can never replace it.\n    conf[CONFIG_KEY_SEND]?.([\n      [RESUME, scratchpad.resume.slice(0, idx + 1)] as PendingWrite,\n    ]);\n    return parsed;\n  }\n\n  // Find current resume value\n  if (scratchpad.nullResume !== undefined) {\n    if (scratchpad.resume.length !== idx) {\n      throw new Error(\n        `Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`\n      );\n    }\n    const v = scratchpad.consumeNullResume();\n    const parsed = parseResume(v);\n    scratchpad.resume.push(v);\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return parsed;\n  }\n\n  // No resume value found\n  const ns: string[] | undefined = conf[CONFIG_KEY_CHECKPOINT_NS]?.split(\n    CHECKPOINT_NAMESPACE_SEPARATOR\n  );\n\n  const id = ns ? XXH3(ns.join(CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;\n  const pending: Interrupt<I> = { id, value };\n  if (schema !== undefined) {\n    pending.response_schema = toJsonSchema(schema);\n  }\n  throw new GraphInterrupt([pending]);\n}\n\ntype FilterAny<X> =\n  (<T>() => T extends X ? 1 : 2) extends <\n    T,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  >() => T extends any ? 1 : 2\n    ? never\n    : X;\n\nexport type InferInterruptInputType<T> = T extends typeof interrupt<\n  infer I,\n  unknown\n>\n  ? I\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptInputType<T[K]> }[keyof T]\n    : unknown;\n\nexport type InferInterruptResumeType<\n  T,\n  TInner = false,\n> = T extends typeof interrupt<never, infer R>\n  ? TInner extends true\n    ? FilterAny<R>\n    : R\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T]\n    : unknown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,SAAgB,UACd,OACA,SACG;CACH,MAAM,SACJA,2BAAAA,mCAAmC,mBAAmB;AACxD,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,qDAAqD;CAGvE,MAAM,OAAO,OAAO;AACpB,KAAI,CAAC,KACH,OAAM,IAAI,MAAM,kCAAkC;AAIpD,KAAI,CADsC,KAAA,yBAExC,OAAM,IAAIC,eAAAA,gBAAgB,uBAAuB,EAC/C,eAAe,wBAChB,CAAC;CAGJ,MAAM,SAAS,SAAS;CACxB,MAAM,eAAe,WAClB,WAAW,KAAA,MAAA,GAAA,4BAAA,oBAAgC,OAAO,IAAA,GAAA,4BAAA,cAClC,QAAQ,OAAO,GAC5B;CAGN,MAAM,aAA+B,KAAKC,kBAAAA;AAC1C,YAAW,oBAAoB;CAC/B,MAAM,MAAM,WAAW;AAGvB,KAAI,WAAW,OAAO,SAAS,KAAK,MAAM,WAAW,OAAO,QAAQ;EAClE,MAAM,SAAS,YAAY,WAAW,OAAO,KAAK;AAIlD,OAAKC,kBAAAA,mBAAmB,CACtB,CAACC,kBAAAA,QAAQ,WAAW,OAAO,MAAM,GAAG,MAAM,EAAE,CAAC,CAC9C,CAAC;AACF,SAAO;;AAIT,KAAI,WAAW,eAAe,KAAA,GAAW;AACvC,MAAI,WAAW,OAAO,WAAW,IAC/B,OAAM,IAAI,MACR,2BAA2B,WAAW,OAAO,OAAO,OAAO,MAC5D;EAEH,MAAM,IAAI,WAAW,mBAAmB;EACxC,MAAM,SAAS,YAAY,EAAE;AAC7B,aAAW,OAAO,KAAK,EAAE;AACzB,OAAKD,kBAAAA,mBAAmB,CAAC,CAACC,kBAAAA,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO;;CAIT,MAAM,KAA2B,KAAKC,kBAAAA,2BAA2B,MAAA,IAEhE;CAGD,MAAM,UAAwB;EAAE,IADrB,KAAKC,aAAAA,KAAK,GAAG,KAAA,IAAoC,CAAC,GAAG,KAAA;EAC5B;EAAO;AAC3C,KAAI,WAAW,KAAA,EACb,SAAQ,mBAAA,GAAA,kCAAA,cAA+B,OAAO;AAEhD,OAAM,IAAIC,eAAAA,eAAe,CAAC,QAAQ,CAAC"}

package/dist/interrupt.d.cts

@@ -1,4 +1,17 @@
+import { JSONSchema } from "@langchain/core/utils/json_schema";
+import { InteropZodType } from "@langchain/core/utils/types";
+
 //#region src/interrupt.d.ts
+interface InterruptOptions {
+  /**
+   * Schema for the value expected when the graph is resumed, surfaced to
+   * clients on `Interrupt.response_schema` (as JSON Schema) so they can render
+   * a typed input form. A Zod schema also parses the resume value, and the
+   * parsed value is what `interrupt` returns; a JSON Schema object is passed
+   * through to clients without validating the resume value.
+   */
+  responseSchema?: InteropZodType | JSONSchema;
+}
 /**
  * Interrupts the execution of a graph node.
  * This function can be used to pause execution of a node, and return the value of the `resume`
@@ -15,7 +28,10 @@
  * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
  *
  * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
- * @returns The `resume` value provided when the graph is re-invoked with a Command
+ * @param options - Optional settings. `responseSchema` describes the expected resume value and is
+ *   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.
+ * @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by
+ *   `responseSchema` when it is a Zod schema
  *
  * @example
  * ```typescript
@@ -41,8 +57,9 @@
  *
  * @throws {Error} If called outside the context of a graph
  * @throws {GraphInterrupt} When no resume value is available
+ * @throws {ZodError} When the resume value does not match a Zod `responseSchema`
  */
-declare function interrupt<I = unknown, R = any>(value: I): R;
+declare function interrupt<I = unknown, R = any>(value: I, options?: InterruptOptions): R;
 type FilterAny<X> = (<T>() => T extends X ? 1 : 2) extends (<T>() => (T extends any ? 1 : 2)) ? never : X;
 type InferInterruptInputType<T> = T extends typeof interrupt<infer I, unknown> ? I : T extends {
   [key: string]: typeof interrupt<any, any>;
@@ -51,5 +68,5 @@ type InferInterruptResumeType<T, TInner = false> = T extends typeof interrupt<ne
   [key: string]: typeof interrupt<any, any>;
 } ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T] : unknown;
 //#endregion
-export { InferInterruptInputType, InferInterruptResumeType, interrupt };
+export { InferInterruptInputType, InferInterruptResumeType, InterruptOptions, interrupt };
 //# sourceMappingURL=interrupt.d.cts.map

package/dist/interrupt.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.d.cts","names":[],"sources":["../src/interrupt.ts"],"mappings":";;AA8DA;;;;;;;;;;;AAkDC;;;;;;;;;;;;;;;;;;AAUD;;;;;;;;;;;;;iBA5DgB,SAAA,sBAAA,CAAgC,KAAA,EAAO,CAAA,GAAI,CAAA;AAAA,KAoDtD,SAAA,gBACO,CAAA,SAAU,CAAA,6BAGb,CAAA,iCAEH,CAAA;AAAA,KAEM,uBAAA,MAA6B,CAAA,gBAAiB,SAAA,qBAItD,CAAA,GAEA,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,uBAAA,CAAwB,CAAA,CAAE,CAAA,WAAY,CAAA;AAAA,KAGlD,wBAAA,sBAGR,CAAA,gBAAiB,SAAA,mBACjB,MAAA,gBACE,SAAA,CAAU,CAAA,IACV,CAAA,GAEF,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,wBAAA,CAAyB,CAAA,CAAE,CAAA,iBAAkB,CAAA"}
+{"version":3,"file":"interrupt.d.cts","names":[],"sources":["../src/interrupt.ts"],"mappings":";;;;UA4BiB,gBAAA;;AAAjB;;;;;;EAQE,cAAA,GAAiB,cAAA,GAAiB,UAAA;AAAA;;AAmDpC;;;;;;;;;;;;;;;;;AAsEC;;;;;;;;;;;;;;;;;;AAUD;;;;;;;;;;;iBAhFgB,SAAA,sBAAA,CACd,KAAA,EAAO,CAAA,EACP,OAAA,GAAU,gBAAA,GACT,CAAA;AAAA,KAqEE,SAAA,gBACO,CAAA,SAAU,CAAA,6BAGb,CAAA,iCAEH,CAAA;AAAA,KAEM,uBAAA,MAA6B,CAAA,gBAAiB,SAAA,qBAItD,CAAA,GAEA,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,uBAAA,CAAwB,CAAA,CAAE,CAAA,WAAY,CAAA;AAAA,KAGlD,wBAAA,sBAGR,CAAA,gBAAiB,SAAA,mBACjB,MAAA,gBACE,SAAA,CAAU,CAAA,IACV,CAAA,GAEF,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,wBAAA,CAAyB,CAAA,CAAE,CAAA,iBAAkB,CAAA"}

package/dist/interrupt.d.ts

@@ -1,4 +1,17 @@
+import { JSONSchema } from "@langchain/core/utils/json_schema";
+import { InteropZodType } from "@langchain/core/utils/types";
+
 //#region src/interrupt.d.ts
+interface InterruptOptions {
+  /**
+   * Schema for the value expected when the graph is resumed, surfaced to
+   * clients on `Interrupt.response_schema` (as JSON Schema) so they can render
+   * a typed input form. A Zod schema also parses the resume value, and the
+   * parsed value is what `interrupt` returns; a JSON Schema object is passed
+   * through to clients without validating the resume value.
+   */
+  responseSchema?: InteropZodType | JSONSchema;
+}
 /**
  * Interrupts the execution of a graph node.
  * This function can be used to pause execution of a node, and return the value of the `resume`
@@ -15,7 +28,10 @@
  * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
  *
  * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
- * @returns The `resume` value provided when the graph is re-invoked with a Command
+ * @param options - Optional settings. `responseSchema` describes the expected resume value and is
+ *   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.
+ * @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by
+ *   `responseSchema` when it is a Zod schema
  *
  * @example
  * ```typescript
@@ -41,8 +57,9 @@
  *
  * @throws {Error} If called outside the context of a graph
  * @throws {GraphInterrupt} When no resume value is available
+ * @throws {ZodError} When the resume value does not match a Zod `responseSchema`
  */
-declare function interrupt<I = unknown, R = any>(value: I): R;
+declare function interrupt<I = unknown, R = any>(value: I, options?: InterruptOptions): R;
 type FilterAny<X> = (<T>() => T extends X ? 1 : 2) extends (<T>() => (T extends any ? 1 : 2)) ? never : X;
 type InferInterruptInputType<T> = T extends typeof interrupt<infer I, unknown> ? I : T extends {
   [key: string]: typeof interrupt<any, any>;
@@ -51,5 +68,5 @@ type InferInterruptResumeType<T, TInner = false> = T extends typeof interrupt<ne
   [key: string]: typeof interrupt<any, any>;
 } ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T] : unknown;
 //#endregion
-export { InferInterruptInputType, InferInterruptResumeType, interrupt };
+export { InferInterruptInputType, InferInterruptResumeType, InterruptOptions, interrupt };
 //# sourceMappingURL=interrupt.d.ts.map

package/dist/interrupt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.d.ts","names":[],"sources":["../src/interrupt.ts"],"mappings":";;AA8DA;;;;;;;;;;;AAkDC;;;;;;;;;;;;;;;;;;AAUD;;;;;;;;;;;;;iBA5DgB,SAAA,sBAAA,CAAgC,KAAA,EAAO,CAAA,GAAI,CAAA;AAAA,KAoDtD,SAAA,gBACO,CAAA,SAAU,CAAA,6BAGb,CAAA,iCAEH,CAAA;AAAA,KAEM,uBAAA,MAA6B,CAAA,gBAAiB,SAAA,qBAItD,CAAA,GAEA,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,uBAAA,CAAwB,CAAA,CAAE,CAAA,WAAY,CAAA;AAAA,KAGlD,wBAAA,sBAGR,CAAA,gBAAiB,SAAA,mBACjB,MAAA,gBACE,SAAA,CAAU,CAAA,IACV,CAAA,GAEF,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,wBAAA,CAAyB,CAAA,CAAE,CAAA,iBAAkB,CAAA"}
+{"version":3,"file":"interrupt.d.ts","names":[],"sources":["../src/interrupt.ts"],"mappings":";;;;UA4BiB,gBAAA;;AAAjB;;;;;;EAQE,cAAA,GAAiB,cAAA,GAAiB,UAAA;AAAA;;AAmDpC;;;;;;;;;;;;;;;;;AAsEC;;;;;;;;;;;;;;;;;;AAUD;;;;;;;;;;;iBAhFgB,SAAA,sBAAA,CACd,KAAA,EAAO,CAAA,EACP,OAAA,GAAU,gBAAA,GACT,CAAA;AAAA,KAqEE,SAAA,gBACO,CAAA,SAAU,CAAA,6BAGb,CAAA,iCAEH,CAAA;AAAA,KAEM,uBAAA,MAA6B,CAAA,gBAAiB,SAAA,qBAItD,CAAA,GAEA,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,uBAAA,CAAwB,CAAA,CAAE,CAAA,WAAY,CAAA;AAAA,KAGlD,wBAAA,sBAGR,CAAA,gBAAiB,SAAA,mBACjB,MAAA,gBACE,SAAA,CAAU,CAAA,IACV,CAAA,GAEF,CAAA;EAAA,CAAa,GAAA,kBAAqB,SAAA;AAAA,kBAClB,CAAA,GAAI,wBAAA,CAAyB,CAAA,CAAE,CAAA,iBAAkB,CAAA"}

package/dist/interrupt.js

@@ -2,6 +2,8 @@ import { CONFIG_KEY_CHECKPOINT_NS, CONFIG_KEY_SCRATCHPAD, CONFIG_KEY_SEND, RESUM
 import { GraphInterrupt, GraphValueError } from "./errors.js";
 import { XXH3 } from "./hash.js";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
+import { interopParse, isInteropZodSchema } from "@langchain/core/utils/types";
 //#region src/interrupt.ts
 /**
 * Interrupts the execution of a graph node.
@@ -19,7 +21,10 @@ import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.
 *
 * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
-* @returns The `resume` value provided when the graph is re-invoked with a Command
+* @param options - Optional settings. `responseSchema` describes the expected resume value and is
+*   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.
+* @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by
+*   `responseSchema` when it is a Zod schema
 *
 * @example
 * ```typescript
@@ -45,32 +50,39 @@ import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 *
 * @throws {Error} If called outside the context of a graph
 * @throws {GraphInterrupt} When no resume value is available
+* @throws {ZodError} When the resume value does not match a Zod `responseSchema`
 */
-function interrupt(value) {
+function interrupt(value, options) {
 	const config = AsyncLocalStorageProviderSingleton.getRunnableConfig();
 	if (!config) throw new Error("Called interrupt() outside the context of a graph.");
 	const conf = config.configurable;
 	if (!conf) throw new Error("No configurable found in config");
 	if (!conf["__pregel_checkpointer"]) throw new GraphValueError("No checkpointer set", { lc_error_code: "MISSING_CHECKPOINTER" });
+	const schema = options?.responseSchema;
+	const parseResume = (resume) => schema !== void 0 && isInteropZodSchema(schema) ? interopParse(schema, resume) : resume;
 	const scratchpad = conf[CONFIG_KEY_SCRATCHPAD];
 	scratchpad.interruptCounter += 1;
 	const idx = scratchpad.interruptCounter;
 	if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {
-		conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume]]);
-		return scratchpad.resume[idx];
+		const parsed = parseResume(scratchpad.resume[idx]);
+		conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume.slice(0, idx + 1)]]);
+		return parsed;
 	}
 	if (scratchpad.nullResume !== void 0) {
 		if (scratchpad.resume.length !== idx) throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
 		const v = scratchpad.consumeNullResume();
+		const parsed = parseResume(v);
 		scratchpad.resume.push(v);
 		conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume]]);
-		return v;
+		return parsed;
 	}
 	const ns = conf[CONFIG_KEY_CHECKPOINT_NS]?.split("|");
-	throw new GraphInterrupt([{
+	const pending = {
 		id: ns ? XXH3(ns.join("|")) : void 0,
 		value
-	}]);
+	};
+	if (schema !== void 0) pending.response_schema = toJsonSchema(schema);
+	throw new GraphInterrupt([pending]);
 }
 //#endregion
 export { interrupt };

package/dist/interrupt.js.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.js","names":[],"sources":["../src/interrupt.ts"],"sourcesContent":["import { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  BaseCheckpointSaver,\n  type PendingWrite,\n} from \"@langchain/langgraph-checkpoint\";\nimport { GraphInterrupt, GraphValueError } from \"./errors.js\";\nimport {\n  CONFIG_KEY_CHECKPOINT_NS,\n  CONFIG_KEY_SCRATCHPAD,\n  CONFIG_KEY_SEND,\n  CONFIG_KEY_CHECKPOINTER,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  RESUME,\n} from \"./constants.js\";\nimport { PregelScratchpad } from \"./pregel/types.js\";\nimport { XXH3 } from \"./hash.js\";\n\n/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @returns The `resume` value provided when the graph is re-invoked with a Command\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function interrupt<I = unknown, R = any>(value: I): R {\n  const config: RunnableConfig | undefined =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (!config) {\n    throw new Error(\"Called interrupt() outside the context of a graph.\");\n  }\n\n  const conf = config.configurable;\n  if (!conf) {\n    throw new Error(\"No configurable found in config\");\n  }\n\n  const checkpointer: BaseCheckpointSaver = conf[CONFIG_KEY_CHECKPOINTER];\n  if (!checkpointer) {\n    throw new GraphValueError(\"No checkpointer set\", {\n      lc_error_code: \"MISSING_CHECKPOINTER\",\n    });\n  }\n\n  // Track interrupt index\n  const scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD];\n  scratchpad.interruptCounter += 1;\n  const idx = scratchpad.interruptCounter;\n\n  // Find previous resume values\n  if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return scratchpad.resume[idx] as R;\n  }\n\n  // Find current resume value\n  if (scratchpad.nullResume !== undefined) {\n    if (scratchpad.resume.length !== idx) {\n      throw new Error(\n        `Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`\n      );\n    }\n    const v = scratchpad.consumeNullResume();\n    scratchpad.resume.push(v);\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return v as R;\n  }\n\n  // No resume value found\n  const ns: string[] | undefined = conf[CONFIG_KEY_CHECKPOINT_NS]?.split(\n    CHECKPOINT_NAMESPACE_SEPARATOR\n  );\n\n  const id = ns ? XXH3(ns.join(CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;\n  throw new GraphInterrupt([{ id, value }]);\n}\n\ntype FilterAny<X> =\n  (<T>() => T extends X ? 1 : 2) extends <\n    T,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  >() => T extends any ? 1 : 2\n    ? never\n    : X;\n\nexport type InferInterruptInputType<T> = T extends typeof interrupt<\n  infer I,\n  unknown\n>\n  ? I\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptInputType<T[K]> }[keyof T]\n    : unknown;\n\nexport type InferInterruptResumeType<\n  T,\n  TInner = false,\n> = T extends typeof interrupt<never, infer R>\n  ? TInner extends true\n    ? FilterAny<R>\n    : R\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T]\n    : unknown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,UAAgC,OAAa;CAC3D,MAAM,SACJ,mCAAmC,mBAAmB;AACxD,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,qDAAqD;CAGvE,MAAM,OAAO,OAAO;AACpB,KAAI,CAAC,KACH,OAAM,IAAI,MAAM,kCAAkC;AAIpD,KAAI,CADsC,KAAA,yBAExC,OAAM,IAAI,gBAAgB,uBAAuB,EAC/C,eAAe,wBAChB,CAAC;CAIJ,MAAM,aAA+B,KAAK;AAC1C,YAAW,oBAAoB;CAC/B,MAAM,MAAM,WAAW;AAGvB,KAAI,WAAW,OAAO,SAAS,KAAK,MAAM,WAAW,OAAO,QAAQ;AAClE,OAAK,mBAAmB,CAAC,CAAC,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO,WAAW,OAAO;;AAI3B,KAAI,WAAW,eAAe,KAAA,GAAW;AACvC,MAAI,WAAW,OAAO,WAAW,IAC/B,OAAM,IAAI,MACR,2BAA2B,WAAW,OAAO,OAAO,OAAO,MAC5D;EAEH,MAAM,IAAI,WAAW,mBAAmB;AACxC,aAAW,OAAO,KAAK,EAAE;AACzB,OAAK,mBAAmB,CAAC,CAAC,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO;;CAIT,MAAM,KAA2B,KAAK,2BAA2B,MAAA,IAEhE;AAGD,OAAM,IAAI,eAAe,CAAC;EAAE,IADjB,KAAK,KAAK,GAAG,KAAA,IAAoC,CAAC,GAAG,KAAA;EAChC;EAAO,CAAC,CAAC"}
+{"version":3,"file":"interrupt.js","names":[],"sources":["../src/interrupt.ts"],"sourcesContent":["import { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  type JSONSchema,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport {\n  type InteropZodType,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseCheckpointSaver,\n  type PendingWrite,\n} from \"@langchain/langgraph-checkpoint\";\nimport { GraphInterrupt, GraphValueError } from \"./errors.js\";\nimport {\n  CONFIG_KEY_CHECKPOINT_NS,\n  CONFIG_KEY_SCRATCHPAD,\n  CONFIG_KEY_SEND,\n  CONFIG_KEY_CHECKPOINTER,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  RESUME,\n  type Interrupt,\n} from \"./constants.js\";\nimport { PregelScratchpad } from \"./pregel/types.js\";\nimport { XXH3 } from \"./hash.js\";\n\nexport interface InterruptOptions {\n  /**\n   * Schema for the value expected when the graph is resumed, surfaced to\n   * clients on `Interrupt.response_schema` (as JSON Schema) so they can render\n   * a typed input form. A Zod schema also parses the resume value, and the\n   * parsed value is what `interrupt` returns; a JSON Schema object is passed\n   * through to clients without validating the resume value.\n   */\n  responseSchema?: InteropZodType | JSONSchema;\n}\n\n/**\n * Interrupts the execution of a graph node.\n * This function can be used to pause execution of a node, and return the value of the `resume`\n * input when the graph is re-invoked using `Command`.\n * Multiple interrupts can be called within a single node, and each will be handled sequentially.\n *\n * When an interrupt is called:\n * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.\n * 2. Otherwise, it throws a `GraphInterrupt` with the provided value\n * 3. The graph can be resumed by passing a `Command` with a `resume` value\n *\n * Because the `interrupt` function propagates by throwing a special `GraphInterrupt` error,\n * you should avoid using `try/catch` blocks around the `interrupt` function,\n * or if you do, ensure that the `GraphInterrupt` error is thrown again within your `catch` block.\n *\n * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value\n * @param options - Optional settings. `responseSchema` describes the expected resume value and is\n *   available in task.interrupts[].response_schema as JSON Schema; a Zod schema also validates the resume value.\n * @returns The `resume` value provided when the graph is re-invoked with a Command, parsed by\n *   `responseSchema` when it is a Zod schema\n *\n * @example\n * ```typescript\n * // Define a node that uses multiple interrupts\n * const nodeWithInterrupts = () => {\n *   // First interrupt - will pause execution and include {value: 1} in task values\n *   const answer1 = interrupt({ value: 1 });\n *\n *   // Second interrupt - only called after first interrupt is resumed\n *   const answer2 = interrupt({ value: 2 });\n *\n *   // Use the resume values\n *   return { myKey: answer1 + \" \" + answer2 };\n * };\n *\n * // Resume the graph after first interrupt\n * await graph.stream(new Command({ resume: \"answer 1\" }));\n *\n * // Resume the graph after second interrupt\n * await graph.stream(new Command({ resume: \"answer 2\" }));\n * // Final result: { myKey: \"answer 1 answer 2\" }\n * ```\n *\n * @throws {Error} If called outside the context of a graph\n * @throws {GraphInterrupt} When no resume value is available\n * @throws {ZodError} When the resume value does not match a Zod `responseSchema`\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function interrupt<I = unknown, R = any>(\n  value: I,\n  options?: InterruptOptions\n): R {\n  const config: RunnableConfig | undefined =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (!config) {\n    throw new Error(\"Called interrupt() outside the context of a graph.\");\n  }\n\n  const conf = config.configurable;\n  if (!conf) {\n    throw new Error(\"No configurable found in config\");\n  }\n\n  const checkpointer: BaseCheckpointSaver = conf[CONFIG_KEY_CHECKPOINTER];\n  if (!checkpointer) {\n    throw new GraphValueError(\"No checkpointer set\", {\n      lc_error_code: \"MISSING_CHECKPOINTER\",\n    });\n  }\n\n  const schema = options?.responseSchema;\n  const parseResume = (resume: unknown): R =>\n    (schema !== undefined && isInteropZodSchema(schema)\n      ? interopParse(schema, resume)\n      : resume) as R;\n\n  // Track interrupt index\n  const scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD];\n  scratchpad.interruptCounter += 1;\n  const idx = scratchpad.interruptCounter;\n\n  // Find previous resume values\n  if (scratchpad.resume.length > 0 && idx < scratchpad.resume.length) {\n    const parsed = parseResume(scratchpad.resume[idx]);\n    // Persist only through the interrupt being consumed. Values past `idx` belong\n    // to later interrupts and may be unvalidated mapped resumes; a failing one must\n    // not become durable, or its retry can never replace it.\n    conf[CONFIG_KEY_SEND]?.([\n      [RESUME, scratchpad.resume.slice(0, idx + 1)] as PendingWrite,\n    ]);\n    return parsed;\n  }\n\n  // Find current resume value\n  if (scratchpad.nullResume !== undefined) {\n    if (scratchpad.resume.length !== idx) {\n      throw new Error(\n        `Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`\n      );\n    }\n    const v = scratchpad.consumeNullResume();\n    const parsed = parseResume(v);\n    scratchpad.resume.push(v);\n    conf[CONFIG_KEY_SEND]?.([[RESUME, scratchpad.resume] as PendingWrite]);\n    return parsed;\n  }\n\n  // No resume value found\n  const ns: string[] | undefined = conf[CONFIG_KEY_CHECKPOINT_NS]?.split(\n    CHECKPOINT_NAMESPACE_SEPARATOR\n  );\n\n  const id = ns ? XXH3(ns.join(CHECKPOINT_NAMESPACE_SEPARATOR)) : undefined;\n  const pending: Interrupt<I> = { id, value };\n  if (schema !== undefined) {\n    pending.response_schema = toJsonSchema(schema);\n  }\n  throw new GraphInterrupt([pending]);\n}\n\ntype FilterAny<X> =\n  (<T>() => T extends X ? 1 : 2) extends <\n    T,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  >() => T extends any ? 1 : 2\n    ? never\n    : X;\n\nexport type InferInterruptInputType<T> = T extends typeof interrupt<\n  infer I,\n  unknown\n>\n  ? I\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptInputType<T[K]> }[keyof T]\n    : unknown;\n\nexport type InferInterruptResumeType<\n  T,\n  TInner = false,\n> = T extends typeof interrupt<never, infer R>\n  ? TInner extends true\n    ? FilterAny<R>\n    : R\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    T extends { [key: string]: typeof interrupt<any, any> }\n    ? { [K in keyof T]: InferInterruptResumeType<T[K], true> }[keyof T]\n    : unknown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,SAAgB,UACd,OACA,SACG;CACH,MAAM,SACJ,mCAAmC,mBAAmB;AACxD,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,qDAAqD;CAGvE,MAAM,OAAO,OAAO;AACpB,KAAI,CAAC,KACH,OAAM,IAAI,MAAM,kCAAkC;AAIpD,KAAI,CADsC,KAAA,yBAExC,OAAM,IAAI,gBAAgB,uBAAuB,EAC/C,eAAe,wBAChB,CAAC;CAGJ,MAAM,SAAS,SAAS;CACxB,MAAM,eAAe,WAClB,WAAW,KAAA,KAAa,mBAAmB,OAAO,GAC/C,aAAa,QAAQ,OAAO,GAC5B;CAGN,MAAM,aAA+B,KAAK;AAC1C,YAAW,oBAAoB;CAC/B,MAAM,MAAM,WAAW;AAGvB,KAAI,WAAW,OAAO,SAAS,KAAK,MAAM,WAAW,OAAO,QAAQ;EAClE,MAAM,SAAS,YAAY,WAAW,OAAO,KAAK;AAIlD,OAAK,mBAAmB,CACtB,CAAC,QAAQ,WAAW,OAAO,MAAM,GAAG,MAAM,EAAE,CAAC,CAC9C,CAAC;AACF,SAAO;;AAIT,KAAI,WAAW,eAAe,KAAA,GAAW;AACvC,MAAI,WAAW,OAAO,WAAW,IAC/B,OAAM,IAAI,MACR,2BAA2B,WAAW,OAAO,OAAO,OAAO,MAC5D;EAEH,MAAM,IAAI,WAAW,mBAAmB;EACxC,MAAM,SAAS,YAAY,EAAE;AAC7B,aAAW,OAAO,KAAK,EAAE;AACzB,OAAK,mBAAmB,CAAC,CAAC,QAAQ,WAAW,OAAO,CAAiB,CAAC;AACtE,SAAO;;CAIT,MAAM,KAA2B,KAAK,2BAA2B,MAAA,IAEhE;CAGD,MAAM,UAAwB;EAAE,IADrB,KAAK,KAAK,GAAG,KAAA,IAAoC,CAAC,GAAG,KAAA;EAC5B;EAAO;AAC3C,KAAI,WAAW,KAAA,EACb,SAAQ,kBAAkB,aAAa,OAAO;AAEhD,OAAM,IAAI,eAAe,CAAC,QAAQ,CAAC"}

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() {