@langchain/langgraph 1.0.12 → 1.0.13

package/dist/prebuilt/tool_node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_node.js","names":["tool"],"sources":["../../src/prebuilt/tool_node.ts"],"sourcesContent":["import {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isAIMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { isGraphInterrupt } from \"../errors.js\";\nimport { END, isCommand, Command, _isSend, Send } from \"../constants.js\";\n\nexport type ToolNodeOptions = {\n  name?: string;\n  tags?: string[];\n  handleToolErrors?: boolean;\n};\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n *\n * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<T = any> extends RunnableCallable<T, T> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  handleToolErrors = true;\n\n  trace = false;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({ name, tags, func: (input, config) => this.run(input, config) });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n      const output = await tool.invoke({ ...call, type: \"tool_call\" }, config);\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        status: \"success\",\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if (!this.handleToolErrors) throw e;\n\n      if (isGraphInterrupt(e)) {\n        // `NodeInterrupt` errors are a breakpoint to bring a human into the loop.\n        // As such, they are not recoverable by the agent and shouldn't be fed\n        // back. Instead, re-throw these errors even when `handleToolErrors = true`.\n        throw e;\n      }\n\n      return new ToolMessage({\n        status: \"error\",\n        content: `Error: ${e.message}\\n Please fix your mistakes.`,\n        name: call.name,\n        tool_call_id: call.id ?? \"\",\n      });\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  protected async run(input: unknown, config: RunnableConfig): Promise<T> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(input)) {\n      outputs = [await this.runTool(input.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(input)) {\n        messages = input;\n      } else if (isMessagesState(input)) {\n        messages = input.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (isAIMessage(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage == null || !isAIMessage(aiMessage)) {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(input) ? outputs : { messages: outputs }) as T;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => _isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(input) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as T;\n  }\n}\n\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport function toolsCondition(\n  state: BaseMessage[] | typeof MessagesAnnotation.State\n): \"tools\" | typeof END {\n  const message = Array.isArray(state)\n    ? state[state.length - 1]\n    : state.messages[state.messages.length - 1];\n\n  if (\n    message !== undefined &&\n    \"tool_calls\" in message &&\n    ((message as AIMessage).tool_calls?.length ?? 0) > 0\n  ) {\n    return \"tools\";\n  } else {\n    return END;\n  }\n}\n"],"mappings":"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"}

package/dist/pregel/algo.cjs

@@ -0,0 +1,565 @@
+const require_errors = require('../errors.cjs');
+const require_base = require('../channels/base.cjs');
+const require_constants = require('../constants.cjs');
+const require_hash = require('../hash.cjs');
+const require_io = require('./io.cjs');
+const require_types = require('./types.cjs');
+const require_index = require('./utils/index.cjs');
+const require_call = require('./call.cjs');
+let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
+let _langchain_core_runnables = require("@langchain/core/runnables");
+
+//#region src/pregel/algo.ts
+const increment = (current) => {
+	return current !== void 0 ? current + 1 : 1;
+};
+function triggersNextStep(updatedChannels, triggerToNodes) {
+	if (triggerToNodes == null) return false;
+	for (const chan of updatedChannels) if (triggerToNodes[chan]) return true;
+	return false;
+}
+function maxChannelMapVersion(channelVersions) {
+	let maxVersion;
+	for (const chan in channelVersions) {
+		if (!Object.prototype.hasOwnProperty.call(channelVersions, chan)) continue;
+		if (maxVersion == null) maxVersion = channelVersions[chan];
+		else maxVersion = (0, _langchain_langgraph_checkpoint.maxChannelVersion)(maxVersion, channelVersions[chan]);
+	}
+	return maxVersion;
+}
+function shouldInterrupt(checkpoint, interruptNodes, tasks) {
+	const nullVersion = require_index.getNullChannelVersion(checkpoint.channel_versions);
+	const seen = checkpoint.versions_seen[require_constants.INTERRUPT] ?? {};
+	let anyChannelUpdated = false;
+	if ((checkpoint.channel_versions[require_constants.START] ?? nullVersion) > (seen[require_constants.START] ?? nullVersion)) anyChannelUpdated = true;
+	else for (const chan in checkpoint.channel_versions) {
+		if (!Object.prototype.hasOwnProperty.call(checkpoint.channel_versions, chan)) continue;
+		if (checkpoint.channel_versions[chan] > (seen[chan] ?? nullVersion)) {
+			anyChannelUpdated = true;
+			break;
+		}
+	}
+	const anyTriggeredNodeInInterruptNodes = tasks.some((task) => interruptNodes === "*" ? !task.config?.tags?.includes(require_constants.TAG_HIDDEN) : interruptNodes.includes(task.name));
+	return anyChannelUpdated && anyTriggeredNodeInInterruptNodes;
+}
+function _localRead(checkpoint, channels, task, select, fresh = false) {
+	let updated = /* @__PURE__ */ new Set();
+	if (!Array.isArray(select)) {
+		for (const [c] of task.writes) if (c === select) {
+			updated = new Set([c]);
+			break;
+		}
+		updated = updated || /* @__PURE__ */ new Set();
+	} else updated = new Set(select.filter((c) => task.writes.some(([key, _]) => key === c)));
+	let values;
+	if (fresh && updated.size > 0) {
+		const localChannels = Object.fromEntries(Object.entries(channels).filter(([k, _]) => updated.has(k)));
+		const newCheckpoint = require_base.createCheckpoint(checkpoint, localChannels, -1);
+		const newChannels = require_base.emptyChannels(localChannels, newCheckpoint);
+		_applyWrites((0, _langchain_langgraph_checkpoint.copyCheckpoint)(newCheckpoint), newChannels, [task], void 0, void 0);
+		values = require_io.readChannels({
+			...channels,
+			...newChannels
+		}, select);
+	} else values = require_io.readChannels(channels, select);
+	return values;
+}
+function _localWrite(commit, processes, writes) {
+	for (const [chan, value] of writes) if ([require_constants.PUSH, require_constants.TASKS].includes(chan) && value != null) {
+		if (!require_constants._isSend(value)) throw new require_errors.InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
+		if (!(value.node in processes)) throw new require_errors.InvalidUpdateError(`Invalid node name "${value.node}" in Send packet`);
+	}
+	commit(writes);
+}
+const IGNORE = new Set([
+	require_constants.NO_WRITES,
+	require_constants.PUSH,
+	require_constants.RESUME,
+	require_constants.INTERRUPT,
+	require_constants.RETURN,
+	require_constants.ERROR
+]);
+function _applyWrites(checkpoint, channels, tasks, getNextVersion, triggerToNodes) {
+	tasks.sort((a, b) => {
+		const aPath = a.path?.slice(0, 3) || [];
+		const bPath = b.path?.slice(0, 3) || [];
+		for (let i = 0; i < Math.min(aPath.length, bPath.length); i += 1) {
+			if (aPath[i] < bPath[i]) return -1;
+			if (aPath[i] > bPath[i]) return 1;
+		}
+		return aPath.length - bPath.length;
+	});
+	const bumpStep = tasks.some((task) => task.triggers.length > 0);
+	const onlyChannels = require_base.getOnlyChannels(channels);
+	for (const task of tasks) {
+		checkpoint.versions_seen[task.name] ??= {};
+		for (const chan of task.triggers) if (chan in checkpoint.channel_versions) checkpoint.versions_seen[task.name][chan] = checkpoint.channel_versions[chan];
+	}
+	let maxVersion = maxChannelMapVersion(checkpoint.channel_versions);
+	const channelsToConsume = new Set(tasks.flatMap((task) => task.triggers).filter((chan) => !require_constants.RESERVED.includes(chan)));
+	let usedNewVersion = false;
+	for (const chan of channelsToConsume) if (chan in onlyChannels && onlyChannels[chan].consume()) {
+		if (getNextVersion !== void 0) {
+			checkpoint.channel_versions[chan] = getNextVersion(maxVersion);
+			usedNewVersion = true;
+		}
+	}
+	const pendingWritesByChannel = {};
+	for (const task of tasks) for (const [chan, val] of task.writes) if (IGNORE.has(chan)) {} else if (chan in onlyChannels) {
+		pendingWritesByChannel[chan] ??= [];
+		pendingWritesByChannel[chan].push(val);
+	}
+	if (maxVersion != null && getNextVersion != null) maxVersion = usedNewVersion ? getNextVersion(maxVersion) : maxVersion;
+	const updatedChannels = /* @__PURE__ */ new Set();
+	for (const [chan, vals] of Object.entries(pendingWritesByChannel)) if (chan in onlyChannels) {
+		const channel = onlyChannels[chan];
+		let updated;
+		try {
+			updated = channel.update(vals);
+		} catch (e) {
+			if (e.name === require_errors.InvalidUpdateError.unminifiable_name) {
+				const wrappedError = new require_errors.InvalidUpdateError(`Invalid update for channel "${chan}" with values ${JSON.stringify(vals)}: ${e.message}`);
+				wrappedError.lc_error_code = e.lc_error_code;
+				throw wrappedError;
+			} else throw e;
+		}
+		if (updated && getNextVersion !== void 0) {
+			checkpoint.channel_versions[chan] = getNextVersion(maxVersion);
+			if (channel.isAvailable()) updatedChannels.add(chan);
+		}
+	}
+	if (bumpStep) for (const chan in onlyChannels) {
+		if (!Object.prototype.hasOwnProperty.call(onlyChannels, chan)) continue;
+		const channel = onlyChannels[chan];
+		if (channel.isAvailable() && !updatedChannels.has(chan)) {
+			if (channel.update([]) && getNextVersion !== void 0) {
+				checkpoint.channel_versions[chan] = getNextVersion(maxVersion);
+				if (channel.isAvailable()) updatedChannels.add(chan);
+			}
+		}
+	}
+	if (bumpStep && !triggersNextStep(updatedChannels, triggerToNodes)) for (const chan in onlyChannels) {
+		if (!Object.prototype.hasOwnProperty.call(onlyChannels, chan)) continue;
+		const channel = onlyChannels[chan];
+		if (channel.finish() && getNextVersion !== void 0) {
+			checkpoint.channel_versions[chan] = getNextVersion(maxVersion);
+			if (channel.isAvailable()) updatedChannels.add(chan);
+		}
+	}
+	return updatedChannels;
+}
+function* candidateNodes(checkpoint, processes, extra) {
+	if (extra.updatedChannels != null && extra.triggerToNodes != null) {
+		const triggeredNodes = /* @__PURE__ */ new Set();
+		for (const channel of extra.updatedChannels) {
+			const nodeIds = extra.triggerToNodes[channel];
+			for (const id of nodeIds ?? []) triggeredNodes.add(id);
+		}
+		yield* [...triggeredNodes].sort();
+		return;
+	}
+	if ((() => {
+		for (const chan in checkpoint.channel_versions) if (checkpoint.channel_versions[chan] !== null) return false;
+		return true;
+	})()) return;
+	for (const name in processes) {
+		if (!Object.prototype.hasOwnProperty.call(processes, name)) continue;
+		yield name;
+	}
+}
+/**
+* Prepare the set of tasks that will make up the next Pregel step.
+* This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered
+* by edges).
+*/
+function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, config, forExecution, extra) {
+	const tasks = {};
+	const tasksChannel = channels[require_constants.TASKS];
+	if (tasksChannel?.isAvailable()) {
+		const len = tasksChannel.get().length;
+		for (let i = 0; i < len; i += 1) {
+			const task = _prepareSingleTask([require_constants.PUSH, i], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+			if (task !== void 0) tasks[task.id] = task;
+		}
+	}
+	for (const name of candidateNodes(checkpoint, processes, extra)) {
+		const task = _prepareSingleTask([require_constants.PULL, name], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+		if (task !== void 0) tasks[task.id] = task;
+	}
+	return tasks;
+}
+/**
+* Prepares a single task for the next Pregel step, given a task path, which
+* uniquely identifies a PUSH or PULL task within the graph.
+*/
+function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, channels, config, forExecution, extra) {
+	const { step, checkpointer, manager } = extra;
+	const configurable = config.configurable ?? {};
+	const parentNamespace = configurable.checkpoint_ns ?? "";
+	if (taskPath[0] === require_constants.PUSH && require_types.isCall(taskPath[taskPath.length - 1])) {
+		const call = taskPath[taskPath.length - 1];
+		const proc = require_call.getRunnableForFunc(call.name, call.func);
+		const triggers = [require_constants.PUSH];
+		const checkpointNamespace = parentNamespace === "" ? call.name : `${parentNamespace}${require_constants.CHECKPOINT_NAMESPACE_SEPARATOR}${call.name}`;
+		const id = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+			checkpointNamespace,
+			step.toString(),
+			call.name,
+			require_constants.PUSH,
+			taskPath[1],
+			taskPath[2]
+		]), checkpoint.id);
+		const taskCheckpointNamespace = `${checkpointNamespace}${require_constants.CHECKPOINT_NAMESPACE_END}${id}`;
+		const outputTaskPath = [...taskPath.slice(0, 3), true];
+		const metadata = {
+			langgraph_step: step,
+			langgraph_node: call.name,
+			langgraph_triggers: triggers,
+			langgraph_path: outputTaskPath,
+			langgraph_checkpoint_ns: taskCheckpointNamespace
+		};
+		if (forExecution) {
+			const writes = [];
+			return {
+				name: call.name,
+				input: call.input,
+				proc,
+				writes,
+				config: (0, _langchain_core_runnables.patchConfig)((0, _langchain_core_runnables.mergeConfigs)(config, {
+					metadata,
+					store: extra.store ?? config.store
+				}), {
+					runName: call.name,
+					callbacks: manager?.getChild(`graph:step:${step}`),
+					configurable: {
+						[require_constants.CONFIG_KEY_TASK_ID]: id,
+						[require_constants.CONFIG_KEY_SEND]: (writes_) => _localWrite((items) => writes.push(...items), processes, writes_),
+						[require_constants.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(checkpoint, channels, {
+							name: call.name,
+							writes,
+							triggers,
+							path: outputTaskPath
+						}, select_, fresh_),
+						[require_constants.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[require_constants.CONFIG_KEY_CHECKPOINTER],
+						[require_constants.CONFIG_KEY_CHECKPOINT_MAP]: {
+							...configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP],
+							[parentNamespace]: checkpoint.id
+						},
+						[require_constants.CONFIG_KEY_SCRATCHPAD]: _scratchpad({
+							pendingWrites: pendingWrites ?? [],
+							taskId: id,
+							currentTaskInput: call.input,
+							resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
+							namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+						}),
+						[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
+						checkpoint_id: void 0,
+						checkpoint_ns: taskCheckpointNamespace
+					}
+				}),
+				triggers,
+				retry_policy: call.retry,
+				cache_key: call.cache ? {
+					key: require_hash.XXH3((call.cache.keyFunc ?? JSON.stringify)([call.input])),
+					ns: [require_constants.CACHE_NS_WRITES, call.name ?? "__dynamic__"],
+					ttl: call.cache.ttl
+				} : void 0,
+				id,
+				path: outputTaskPath,
+				writers: []
+			};
+		} else return {
+			id,
+			name: call.name,
+			interrupts: [],
+			path: outputTaskPath
+		};
+	} else if (taskPath[0] === require_constants.PUSH) {
+		const index = typeof taskPath[1] === "number" ? taskPath[1] : parseInt(taskPath[1], 10);
+		if (!channels[require_constants.TASKS]?.isAvailable()) return;
+		const sends = channels[require_constants.TASKS].get();
+		if (index < 0 || index >= sends.length) return;
+		const packet = require_constants._isSendInterface(sends[index]) && !require_constants._isSend(sends[index]) ? new require_constants.Send(sends[index].node, sends[index].args) : sends[index];
+		if (!require_constants._isSendInterface(packet)) {
+			console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
+			return;
+		}
+		if (!(packet.node in processes)) {
+			console.warn(`Ignoring unknown node name ${packet.node} in pending sends.`);
+			return;
+		}
+		const triggers = [require_constants.PUSH];
+		const checkpointNamespace = parentNamespace === "" ? packet.node : `${parentNamespace}${require_constants.CHECKPOINT_NAMESPACE_SEPARATOR}${packet.node}`;
+		const taskId = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+			checkpointNamespace,
+			step.toString(),
+			packet.node,
+			require_constants.PUSH,
+			index.toString()
+		]), checkpoint.id);
+		const taskCheckpointNamespace = `${checkpointNamespace}${require_constants.CHECKPOINT_NAMESPACE_END}${taskId}`;
+		let metadata = {
+			langgraph_step: step,
+			langgraph_node: packet.node,
+			langgraph_triggers: triggers,
+			langgraph_path: taskPath.slice(0, 3),
+			langgraph_checkpoint_ns: taskCheckpointNamespace
+		};
+		if (forExecution) {
+			const proc = processes[packet.node];
+			const node = proc.getNode();
+			if (node !== void 0) {
+				if (proc.metadata !== void 0) metadata = {
+					...metadata,
+					...proc.metadata
+				};
+				const writes = [];
+				return {
+					name: packet.node,
+					input: packet.args,
+					proc: node,
+					subgraphs: proc.subgraphs,
+					writes,
+					config: (0, _langchain_core_runnables.patchConfig)((0, _langchain_core_runnables.mergeConfigs)(config, {
+						metadata,
+						tags: proc.tags,
+						store: extra.store ?? config.store
+					}), {
+						runName: packet.node,
+						callbacks: manager?.getChild(`graph:step:${step}`),
+						configurable: {
+							[require_constants.CONFIG_KEY_TASK_ID]: taskId,
+							[require_constants.CONFIG_KEY_SEND]: (writes_) => _localWrite((items) => writes.push(...items), processes, writes_),
+							[require_constants.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(checkpoint, channels, {
+								name: packet.node,
+								writes,
+								triggers,
+								path: taskPath
+							}, select_, fresh_),
+							[require_constants.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[require_constants.CONFIG_KEY_CHECKPOINTER],
+							[require_constants.CONFIG_KEY_CHECKPOINT_MAP]: {
+								...configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP],
+								[parentNamespace]: checkpoint.id
+							},
+							[require_constants.CONFIG_KEY_SCRATCHPAD]: _scratchpad({
+								pendingWrites: pendingWrites ?? [],
+								taskId,
+								currentTaskInput: packet.args,
+								resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
+								namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+							}),
+							[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
+							checkpoint_id: void 0,
+							checkpoint_ns: taskCheckpointNamespace
+						}
+					}),
+					triggers,
+					retry_policy: proc.retryPolicy,
+					cache_key: proc.cachePolicy ? {
+						key: require_hash.XXH3((proc.cachePolicy.keyFunc ?? JSON.stringify)([packet.args])),
+						ns: [
+							require_constants.CACHE_NS_WRITES,
+							proc.name ?? "__dynamic__",
+							packet.node
+						],
+						ttl: proc.cachePolicy.ttl
+					} : void 0,
+					id: taskId,
+					path: taskPath,
+					writers: proc.getWriters()
+				};
+			}
+		} else return {
+			id: taskId,
+			name: packet.node,
+			interrupts: [],
+			path: taskPath
+		};
+	} else if (taskPath[0] === require_constants.PULL) {
+		const name = taskPath[1].toString();
+		const proc = processes[name];
+		if (proc === void 0) return;
+		if (pendingWrites?.length) {
+			const checkpointNamespace = parentNamespace === "" ? name : `${parentNamespace}${require_constants.CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
+			const taskId = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+				checkpointNamespace,
+				step.toString(),
+				name,
+				require_constants.PULL,
+				name
+			]), checkpoint.id);
+			if (pendingWrites.some((w) => w[0] === taskId && w[1] !== require_constants.ERROR)) return;
+		}
+		const nullVersion = require_index.getNullChannelVersion(checkpoint.channel_versions);
+		if (nullVersion === void 0) return;
+		const seen = checkpoint.versions_seen[name] ?? {};
+		const trigger = proc.triggers.find((chan) => {
+			if (!channels[chan].isAvailable()) return false;
+			return (checkpoint.channel_versions[chan] ?? nullVersion) > (seen[chan] ?? nullVersion);
+		});
+		if (trigger !== void 0) {
+			const val = _procInput(proc, channels, forExecution);
+			if (val === void 0) return;
+			const checkpointNamespace = parentNamespace === "" ? name : `${parentNamespace}${require_constants.CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
+			const taskId = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+				checkpointNamespace,
+				step.toString(),
+				name,
+				require_constants.PULL,
+				[trigger]
+			]), checkpoint.id);
+			const taskCheckpointNamespace = `${checkpointNamespace}${require_constants.CHECKPOINT_NAMESPACE_END}${taskId}`;
+			let metadata = {
+				langgraph_step: step,
+				langgraph_node: name,
+				langgraph_triggers: [trigger],
+				langgraph_path: taskPath,
+				langgraph_checkpoint_ns: taskCheckpointNamespace
+			};
+			if (forExecution) {
+				const node = proc.getNode();
+				if (node !== void 0) {
+					if (proc.metadata !== void 0) metadata = {
+						...metadata,
+						...proc.metadata
+					};
+					const writes = [];
+					return {
+						name,
+						input: val,
+						proc: node,
+						subgraphs: proc.subgraphs,
+						writes,
+						config: (0, _langchain_core_runnables.patchConfig)((0, _langchain_core_runnables.mergeConfigs)(config, {
+							metadata,
+							tags: proc.tags,
+							store: extra.store ?? config.store
+						}), {
+							runName: name,
+							callbacks: manager?.getChild(`graph:step:${step}`),
+							configurable: {
+								[require_constants.CONFIG_KEY_TASK_ID]: taskId,
+								[require_constants.CONFIG_KEY_SEND]: (writes_) => _localWrite((items) => {
+									writes.push(...items);
+								}, processes, writes_),
+								[require_constants.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(checkpoint, channels, {
+									name,
+									writes,
+									triggers: [trigger],
+									path: taskPath
+								}, select_, fresh_),
+								[require_constants.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[require_constants.CONFIG_KEY_CHECKPOINTER],
+								[require_constants.CONFIG_KEY_CHECKPOINT_MAP]: {
+									...configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP],
+									[parentNamespace]: checkpoint.id
+								},
+								[require_constants.CONFIG_KEY_SCRATCHPAD]: _scratchpad({
+									pendingWrites: pendingWrites ?? [],
+									taskId,
+									currentTaskInput: val,
+									resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
+									namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+								}),
+								[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
+								checkpoint_id: void 0,
+								checkpoint_ns: taskCheckpointNamespace
+							}
+						}),
+						triggers: [trigger],
+						retry_policy: proc.retryPolicy,
+						cache_key: proc.cachePolicy ? {
+							key: require_hash.XXH3((proc.cachePolicy.keyFunc ?? JSON.stringify)([val])),
+							ns: [
+								require_constants.CACHE_NS_WRITES,
+								proc.name ?? "__dynamic__",
+								name
+							],
+							ttl: proc.cachePolicy.ttl
+						} : void 0,
+						id: taskId,
+						path: taskPath,
+						writers: proc.getWriters()
+					};
+				}
+			} else return {
+				id: taskId,
+				name,
+				interrupts: [],
+				path: taskPath
+			};
+		}
+	}
+}
+/**
+*  Function injected under CONFIG_KEY_READ in task config, to read current state.
+*  Used by conditional edges to read a copy of the state with reflecting the writes
+*  from that node only.
+*
+* @internal
+*/
+function _procInput(proc, channels, forExecution) {
+	let val;
+	if (typeof proc.channels === "object" && !Array.isArray(proc.channels)) {
+		val = {};
+		for (const [k, chan] of Object.entries(proc.channels)) if (proc.triggers.includes(chan)) try {
+			val[k] = require_io.readChannel(channels, chan, false);
+		} catch (e) {
+			if (e.name === require_errors.EmptyChannelError.unminifiable_name) return;
+			else throw e;
+		}
+		else if (chan in channels) try {
+			val[k] = require_io.readChannel(channels, chan, false);
+		} catch (e) {
+			if (e.name === require_errors.EmptyChannelError.unminifiable_name) continue;
+			else throw e;
+		}
+	} else if (Array.isArray(proc.channels)) {
+		let successfulRead = false;
+		for (const chan of proc.channels) try {
+			val = require_io.readChannel(channels, chan, false);
+			successfulRead = true;
+			break;
+		} catch (e) {
+			if (e.name === require_errors.EmptyChannelError.unminifiable_name) continue;
+			else throw e;
+		}
+		if (!successfulRead) return;
+	} else throw new Error(`Invalid channels type, expected list or dict, got ${proc.channels}`);
+	if (forExecution && proc.mapper !== void 0) val = proc.mapper(val);
+	return val;
+}
+function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, namespaceHash }) {
+	const nullResume = pendingWrites.find(([writeTaskId, chan]) => writeTaskId === require_constants.NULL_TASK_ID && chan === require_constants.RESUME)?.[2];
+	const scratchpad = {
+		callCounter: 0,
+		interruptCounter: -1,
+		resume: (() => {
+			const result = pendingWrites.filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === require_constants.RESUME).flatMap(([_writeTaskId, _chan, resume]) => resume);
+			if (resumeMap != null && namespaceHash in resumeMap) {
+				const mappedResume = resumeMap[namespaceHash];
+				result.push(mappedResume);
+			}
+			return result;
+		})(),
+		nullResume,
+		subgraphCounter: 0,
+		currentTaskInput,
+		consumeNullResume: () => {
+			if (scratchpad.nullResume) {
+				delete scratchpad.nullResume;
+				pendingWrites.splice(pendingWrites.findIndex(([writeTaskId, chan]) => writeTaskId === require_constants.NULL_TASK_ID && chan === require_constants.RESUME), 1);
+				return nullResume;
+			}
+		}
+	};
+	return scratchpad;
+}
+
+//#endregion
+exports._applyWrites = _applyWrites;
+exports._localRead = _localRead;
+exports._prepareNextTasks = _prepareNextTasks;
+exports._prepareSingleTask = _prepareSingleTask;
+exports.increment = increment;
+exports.shouldInterrupt = shouldInterrupt;
+//# sourceMappingURL=algo.cjs.map