@langchain/langgraph 1.0.7 → 1.0.12

package/dist/func/index.js

@@ -1,298 +0,0 @@
-import { LastValue } from "../channels/last_value.js";
-import { CONFIG_KEY_PREVIOUS_STATE, END, PREVIOUS, START, TAG_HIDDEN } from "../constants.js";
-import { RunnableCallable, isAsyncGeneratorFunction, isGeneratorFunction } from "../utils.js";
-import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
-import { PregelNode } from "../pregel/read.js";
-import { call, getRunnableForEntrypoint } from "../pregel/call.js";
-import { Pregel } from "../pregel/index.js";
-import { EphemeralValue } from "../channels/ephemeral_value.js";
-import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
-
-//#region src/func/index.ts
-/**
-* Define a LangGraph task using the `task` function.
-*
-* Tasks can only be called from within an {@link entrypoint} or from within a StateGraph.
-* A task can be called like a regular function with the following differences:
-*
-* - When a checkpointer is enabled, the function inputs and outputs must be serializable.
-* - The wrapped function can only be called from within an entrypoint or StateGraph.
-* - Calling the function produces a promise. This makes it easy to parallelize tasks.
-*
-* @typeParam ArgsT - The type of arguments the task function accepts
-* @typeParam OutputT - The type of value the task function returns
-* @param optionsOrName - Either an {@link TaskOptions} object, or a string for the name of the task
-* @param func - The function that executes this task
-* @returns A proxy function that accepts the same arguments as the original and always returns the result as a Promise
-*
-* @example basic example
-* ```typescript
-* const addOne = task("add", async (a: number) => a + 1);
-*
-* const workflow = entrypoint("example", async (numbers: number[]) => {
-*   const promises = numbers.map(n => addOne(n));
-*   const results = await Promise.all(promises);
-*   return results;
-* });
-*
-* // Call the entrypoint
-* await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]
-* ```
-*
-* @example using a retry policy
-* ```typescript
-* const addOne = task({
-*     name: "add",
-*     retry: { maxAttempts: 3 }
-*   },
-*   async (a: number) => a + 1
-* );
-*
-* const workflow = entrypoint("example", async (numbers: number[]) => {
-*   const promises = numbers.map(n => addOne(n));
-*   const results = await Promise.all(promises);
-*   return results;
-* });
-* ```
-* @category Functional API
-*/
-function task(optionsOrName, func) {
-	const options = typeof optionsOrName === "string" ? {
-		name: optionsOrName,
-		retry: void 0,
-		cachePolicy: void 0
-	} : optionsOrName;
-	const { name, retry } = options;
-	if (isAsyncGeneratorFunction(func) || isGeneratorFunction(func)) throw new Error("Generators are disallowed as tasks. For streaming responses, use config.write.");
-	const cachePolicy = options.cachePolicy ?? ("cache" in options ? options.cache : void 0);
-	let cache;
-	if (typeof cachePolicy === "boolean") cache = cachePolicy ? {} : void 0;
-	else cache = cachePolicy;
-	return (...args) => {
-		return call({
-			func,
-			name,
-			retry,
-			cache
-		}, ...args);
-	};
-}
-/**
-* Define a LangGraph workflow using the `entrypoint` function.
-*
-* ### Function signature
-*
-* The wrapped function must accept at most **two parameters**. The first parameter
-* is the input to the function. The second (optional) parameter is a
-* {@link LangGraphRunnableConfig} object. If you wish to pass multiple parameters to
-* the function, you can pass them as an object.
-*
-* ### Helper functions
-*
-* #### Streaming
-* To write data to the "custom" stream, use the {@link getWriter} function, or the
-* {@link LangGraphRunnableConfig.writer} property.
-*
-* #### State management
-* The {@link getPreviousState} function can be used to access the previous state
-* that was returned from the last invocation of the entrypoint on the same thread id.
-*
-* If you wish to save state other than the return value, you can use the
-* {@link entrypoint.final} function.
-*
-* @typeParam InputT - The type of input the entrypoint accepts
-* @typeParam OutputT - The type of output the entrypoint produces
-* @param optionsOrName - Either an {@link EntrypointOptions} object, or a string for the name of the entrypoint
-* @param func - The function that executes this entrypoint
-* @returns A {@link Pregel} instance that can be run to execute the workflow
-*
-* @example Using entrypoint and tasks
-* ```typescript
-* import { task, entrypoint } from "@langchain/langgraph";
-* import { MemorySaver } from "@langchain/langgraph-checkpoint";
-* import { interrupt, Command } from "@langchain/langgraph";
-*
-* const composeEssay = task("compose", async (topic: string) => {
-*   await new Promise(r => setTimeout(r, 1000)); // Simulate slow operation
-*   return `An essay about ${topic}`;
-* });
-*
-* const reviewWorkflow = entrypoint({
-*   name: "review",
-*   checkpointer: new MemorySaver()
-* }, async (topic: string) => {
-*   const essay = await composeEssay(topic);
-*   const humanReview = await interrupt({
-*     question: "Please provide a review",
-*     essay
-*   });
-*   return {
-*     essay,
-*     review: humanReview
-*   };
-* });
-*
-* // Example configuration for the workflow
-* const config = {
-*   configurable: {
-*     thread_id: "some_thread"
-*   }
-* };
-*
-* // Topic for the essay
-* const topic = "cats";
-*
-* // Stream the workflow to generate the essay and await human review
-* for await (const result of reviewWorkflow.stream(topic, config)) {
-*   console.log(result);
-* }
-*
-* // Example human review provided after the interrupt
-* const humanReview = "This essay is great.";
-*
-* // Resume the workflow with the provided human review
-* for await (const result of reviewWorkflow.stream(new Command({ resume: humanReview }), config)) {
-*   console.log(result);
-* }
-* ```
-*
-* @example Accessing the previous return value
-* ```typescript
-* import { entrypoint, getPreviousState } from "@langchain/langgraph";
-* import { MemorySaver } from "@langchain/langgraph-checkpoint";
-*
-* const accumulator = entrypoint({
-*   name: "accumulator",
-*   checkpointer: new MemorySaver()
-* }, async (input: string) => {
-*   const previous = getPreviousState<number>();
-*   return previous !== undefined ? `${previous } ${input}` : input;
-* });
-*
-* const config = {
-*   configurable: {
-*     thread_id: "some_thread"
-*   }
-* };
-* await accumulator.invoke("hello", config); // returns "hello"
-* await accumulator.invoke("world", config); // returns "hello world"
-* ```
-*
-* @example Using entrypoint.final to save a value
-* ```typescript
-* import { entrypoint, getPreviousState } from "@langchain/langgraph";
-* import { MemorySaver } from "@langchain/langgraph-checkpoint";
-*
-* const myWorkflow = entrypoint({
-*   name: "accumulator",
-*   checkpointer: new MemorySaver()
-* }, async (num: number) => {
-*   const previous = getPreviousState<number>();
-*
-*   // This will return the previous value to the caller, saving
-*   // 2 * num to the checkpoint, which will be used in the next invocation
-*   // for the `previous` parameter.
-*   return entrypoint.final({
-*     value: previous ?? 0,
-*     save: 2 * num
-*   });
-* });
-*
-* const config = {
-*   configurable: {
-*     thread_id: "some_thread"
-*   }
-* };
-*
-* await myWorkflow.invoke(3, config); // 0 (previous was undefined)
-* await myWorkflow.invoke(1, config); // 6 (previous was 3 * 2 from the previous invocation)
-* ```
-* @category Functional API
-*/
-const entrypoint = function entrypoint$1(optionsOrName, func) {
-	const { name, checkpointer, store, cache } = typeof optionsOrName === "string" ? {
-		name: optionsOrName,
-		checkpointer: void 0,
-		store: void 0
-	} : optionsOrName;
-	if (isAsyncGeneratorFunction(func) || isGeneratorFunction(func)) throw new Error("Generators are disallowed as entrypoints. For streaming responses, use config.write.");
-	const streamMode = "updates";
-	const bound = getRunnableForEntrypoint(name, func);
-	function isEntrypointFinal(value) {
-		return typeof value === "object" && value !== null && "__lg_type" in value && value.__lg_type === "__pregel_final";
-	}
-	const pluckReturnValue = new RunnableCallable({
-		name: "pluckReturnValue",
-		func: (value) => {
-			return isEntrypointFinal(value) ? value.value : value;
-		}
-	});
-	const pluckSaveValue = new RunnableCallable({
-		name: "pluckSaveValue",
-		func: (value) => {
-			return isEntrypointFinal(value) ? value.save : value;
-		}
-	});
-	const entrypointNode = new PregelNode({
-		bound,
-		triggers: [START],
-		channels: [START],
-		writers: [new ChannelWrite([{
-			channel: END,
-			value: PASSTHROUGH,
-			mapper: pluckReturnValue
-		}, {
-			channel: PREVIOUS,
-			value: PASSTHROUGH,
-			mapper: pluckSaveValue
-		}], [TAG_HIDDEN])]
-	});
-	return new Pregel({
-		name,
-		checkpointer,
-		nodes: { [name]: entrypointNode },
-		channels: {
-			[START]: new EphemeralValue(),
-			[END]: new LastValue(),
-			[PREVIOUS]: new LastValue()
-		},
-		inputChannels: START,
-		outputChannels: END,
-		streamChannels: END,
-		streamMode,
-		store,
-		cache
-	});
-};
-entrypoint.final = function final({ value, save }) {
-	return {
-		value,
-		save,
-		__lg_type: "__pregel_final"
-	};
-};
-/**
-* A helper utility function for use with the functional API that returns the previous
-* state from the checkpoint from the last invocation of the current thread.
-*
-* This function allows workflows to access state that was saved in previous runs
-* using {@link entrypoint.final}.
-*
-* @typeParam StateT - The type of the state that was previously saved
-* @returns The previous saved state from the last invocation of the current thread
-*
-* @example
-* ```typescript
-* const previousState = getPreviousState<{ counter: number }>();
-* const newCount = (previousState?.counter ?? 0) + 1;
-* ```
-* @category Functional API
-*/
-function getPreviousState() {
-	const config = AsyncLocalStorageProviderSingleton.getRunnableConfig();
-	return config.configurable?.[CONFIG_KEY_PREVIOUS_STATE];
-}
-
-//#endregion
-export { entrypoint, getPreviousState, task };
-//# sourceMappingURL=index.js.map

package/dist/func/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["cache: CachePolicy | undefined","entrypoint","config: LangGraphRunnableConfig"],"sources":["../../src/func/index.ts"],"sourcesContent":["import {\n  BaseCache,\n  BaseCheckpointSaver,\n  BaseStore,\n} from \"@langchain/langgraph-checkpoint\";\nimport { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport { Pregel } from \"../pregel/index.js\";\nimport { PregelNode } from \"../pregel/read.js\";\nimport {\n  CONFIG_KEY_PREVIOUS_STATE,\n  END,\n  PREVIOUS,\n  START,\n  TAG_HIDDEN,\n} from \"../constants.js\";\nimport { EphemeralValue } from \"../channels/ephemeral_value.js\";\nimport { call, getRunnableForEntrypoint } from \"../pregel/call.js\";\nimport type { CachePolicy, RetryPolicy } from \"../pregel/utils/index.js\";\nimport { LastValue } from \"../channels/last_value.js\";\nimport {\n  EntrypointFinal,\n  EntrypointReturnT,\n  EntrypointFinalSaveT,\n  EntrypointFunc,\n  TaskFunc,\n} from \"./types.js\";\nimport { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\nimport {\n  RunnableCallable,\n  isAsyncGeneratorFunction,\n  isGeneratorFunction,\n} from \"../utils.js\";\nimport { ChannelWrite, PASSTHROUGH } from \"../pregel/write.js\";\n\n/**\n * Options for the {@link task} function\n */\nexport interface TaskOptions {\n  /**\n   * The name of the task, analogous to the node name in {@link StateGraph}.\n   */\n  name: string;\n  /**\n   * The retry policy for the task. Configures how many times and under what conditions\n   * the task should be retried if it fails.\n   */\n  retry?: RetryPolicy;\n\n  /**\n   * The cache policy for the task. Configures how the task should be cached.\n   */\n  cachePolicy?: CachePolicy;\n}\n\n/**\n * Define a LangGraph task using the `task` function.\n *\n * Tasks can only be called from within an {@link entrypoint} or from within a StateGraph.\n * A task can be called like a regular function with the following differences:\n *\n * - When a checkpointer is enabled, the function inputs and outputs must be serializable.\n * - The wrapped function can only be called from within an entrypoint or StateGraph.\n * - Calling the function produces a promise. This makes it easy to parallelize tasks.\n *\n * @typeParam ArgsT - The type of arguments the task function accepts\n * @typeParam OutputT - The type of value the task function returns\n * @param optionsOrName - Either an {@link TaskOptions} object, or a string for the name of the task\n * @param func - The function that executes this task\n * @returns A proxy function that accepts the same arguments as the original and always returns the result as a Promise\n *\n * @example basic example\n * ```typescript\n * const addOne = task(\"add\", async (a: number) => a + 1);\n *\n * const workflow = entrypoint(\"example\", async (numbers: number[]) => {\n *   const promises = numbers.map(n => addOne(n));\n *   const results = await Promise.all(promises);\n *   return results;\n * });\n *\n * // Call the entrypoint\n * await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]\n * ```\n *\n * @example using a retry policy\n * ```typescript\n * const addOne = task({\n *     name: \"add\",\n *     retry: { maxAttempts: 3 }\n *   },\n *   async (a: number) => a + 1\n * );\n *\n * const workflow = entrypoint(\"example\", async (numbers: number[]) => {\n *   const promises = numbers.map(n => addOne(n));\n *   const results = await Promise.all(promises);\n *   return results;\n * });\n * ```\n * @category Functional API\n */\nexport function task<ArgsT extends unknown[], OutputT>(\n  optionsOrName: TaskOptions | string,\n  func: TaskFunc<ArgsT, OutputT>\n): (...args: ArgsT) => Promise<OutputT> {\n  const options =\n    typeof optionsOrName === \"string\"\n      ? { name: optionsOrName, retry: undefined, cachePolicy: undefined }\n      : optionsOrName;\n\n  const { name, retry } = options;\n  if (isAsyncGeneratorFunction(func) || isGeneratorFunction(func)) {\n    throw new Error(\n      \"Generators are disallowed as tasks. For streaming responses, use config.write.\"\n    );\n  }\n\n  const cachePolicy =\n    options.cachePolicy ??\n    // `cache` was mistakingly used as an alias for `cachePolicy` in v0.3.x,\n    // TODO: remove in 1.x\n    (\"cache\" in options ? (options.cache as CachePolicy) : undefined);\n\n  let cache: CachePolicy | undefined;\n  if (typeof cachePolicy === \"boolean\") {\n    cache = cachePolicy ? {} : undefined;\n  } else {\n    cache = cachePolicy;\n  }\n\n  return (...args: ArgsT) => {\n    return call({ func, name, retry, cache }, ...args);\n  };\n}\n\n/**\n * Options for the {@link entrypoint} function\n */\nexport type EntrypointOptions = {\n  /**\n   * The name of the {@link entrypoint}, analogous to the node name in {@link StateGraph}.\n   * This name is used for logging, debugging, and checkpoint identification.\n   */\n  name: string;\n  /**\n   * The checkpointer for the {@link entrypoint}. Used to save and restore state between\n   * invocations of the workflow.\n   */\n  checkpointer?: BaseCheckpointSaver;\n  /**\n   * The store for the {@link entrypoint}. Used to persist data across workflow runs.\n   */\n  store?: BaseStore;\n\n  /**\n   * The cache for the {@link entrypoint}. Used to cache values between workflow runs.\n   */\n  cache?: BaseCache;\n};\n\n/**\n * Type declaration for the entrypoint function with its properties\n * @category Functional API\n */\nexport interface EntrypointFunction {\n  <InputT, OutputT>(\n    optionsOrName: EntrypointOptions | string,\n    func: EntrypointFunc<InputT, OutputT>\n  ): Pregel<\n    Record<string, PregelNode<InputT, EntrypointReturnT<OutputT>>>,\n    {\n      [START]: EphemeralValue<InputT>;\n      [END]: LastValue<EntrypointReturnT<OutputT>>;\n      [PREVIOUS]: LastValue<EntrypointFinalSaveT<OutputT>>;\n    },\n    Record<string, unknown>,\n    InputT,\n    EntrypointReturnT<OutputT>,\n    // Because the update type is an return type union of tasks + entrypoint,\n    // thus we can't type it properly.\n    any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    Awaited<EntrypointReturnT<OutputT>>\n  >;\n\n  /**\n   * A helper utility for use with the functional API that returns a value to the caller,\n   * as well as a separate state value to persist to the checkpoint. This allows workflows\n   * to maintain state between runs while returning different values to the caller.\n   *\n   * @typeParam ValueT - The type of the value to return to the caller\n   * @typeParam SaveT - The type of the state to save to the checkpoint\n   * @param options.value - The value to return to the caller\n   * @param options.save - The value to save to the checkpoint\n   * @returns An object with the value and save properties\n   *\n   * @example\n   * ```typescript\n   * return entrypoint.final({\n   *   value: \"result for caller\",\n   *   save: { counter: currentCount + 1 }\n   * });\n   * ```\n   */\n  final<ValueT, SaveT>(options: {\n    value?: ValueT;\n    save?: SaveT;\n  }): EntrypointFinal<ValueT, SaveT>;\n}\n\n/**\n * Define a LangGraph workflow using the `entrypoint` function.\n *\n * ### Function signature\n *\n * The wrapped function must accept at most **two parameters**. The first parameter\n * is the input to the function. The second (optional) parameter is a\n * {@link LangGraphRunnableConfig} object. If you wish to pass multiple parameters to\n * the function, you can pass them as an object.\n *\n * ### Helper functions\n *\n * #### Streaming\n * To write data to the \"custom\" stream, use the {@link getWriter} function, or the\n * {@link LangGraphRunnableConfig.writer} property.\n *\n * #### State management\n * The {@link getPreviousState} function can be used to access the previous state\n * that was returned from the last invocation of the entrypoint on the same thread id.\n *\n * If you wish to save state other than the return value, you can use the\n * {@link entrypoint.final} function.\n *\n * @typeParam InputT - The type of input the entrypoint accepts\n * @typeParam OutputT - The type of output the entrypoint produces\n * @param optionsOrName - Either an {@link EntrypointOptions} object, or a string for the name of the entrypoint\n * @param func - The function that executes this entrypoint\n * @returns A {@link Pregel} instance that can be run to execute the workflow\n *\n * @example Using entrypoint and tasks\n * ```typescript\n * import { task, entrypoint } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n * import { interrupt, Command } from \"@langchain/langgraph\";\n *\n * const composeEssay = task(\"compose\", async (topic: string) => {\n *   await new Promise(r => setTimeout(r, 1000)); // Simulate slow operation\n *   return `An essay about ${topic}`;\n * });\n *\n * const reviewWorkflow = entrypoint({\n *   name: \"review\",\n *   checkpointer: new MemorySaver()\n * }, async (topic: string) => {\n *   const essay = await composeEssay(topic);\n *   const humanReview = await interrupt({\n *     question: \"Please provide a review\",\n *     essay\n *   });\n *   return {\n *     essay,\n *     review: humanReview\n *   };\n * });\n *\n * // Example configuration for the workflow\n * const config = {\n *   configurable: {\n *     thread_id: \"some_thread\"\n *   }\n * };\n *\n * // Topic for the essay\n * const topic = \"cats\";\n *\n * // Stream the workflow to generate the essay and await human review\n * for await (const result of reviewWorkflow.stream(topic, config)) {\n *   console.log(result);\n * }\n *\n * // Example human review provided after the interrupt\n * const humanReview = \"This essay is great.\";\n *\n * // Resume the workflow with the provided human review\n * for await (const result of reviewWorkflow.stream(new Command({ resume: humanReview }), config)) {\n *   console.log(result);\n * }\n * ```\n *\n * @example Accessing the previous return value\n * ```typescript\n * import { entrypoint, getPreviousState } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * const accumulator = entrypoint({\n *   name: \"accumulator\",\n *   checkpointer: new MemorySaver()\n * }, async (input: string) => {\n *   const previous = getPreviousState<number>();\n *   return previous !== undefined ? `${previous } ${input}` : input;\n * });\n *\n * const config = {\n *   configurable: {\n *     thread_id: \"some_thread\"\n *   }\n * };\n * await accumulator.invoke(\"hello\", config); // returns \"hello\"\n * await accumulator.invoke(\"world\", config); // returns \"hello world\"\n * ```\n *\n * @example Using entrypoint.final to save a value\n * ```typescript\n * import { entrypoint, getPreviousState } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * const myWorkflow = entrypoint({\n *   name: \"accumulator\",\n *   checkpointer: new MemorySaver()\n * }, async (num: number) => {\n *   const previous = getPreviousState<number>();\n *\n *   // This will return the previous value to the caller, saving\n *   // 2 * num to the checkpoint, which will be used in the next invocation\n *   // for the `previous` parameter.\n *   return entrypoint.final({\n *     value: previous ?? 0,\n *     save: 2 * num\n *   });\n * });\n *\n * const config = {\n *   configurable: {\n *     thread_id: \"some_thread\"\n *   }\n * };\n *\n * await myWorkflow.invoke(3, config); // 0 (previous was undefined)\n * await myWorkflow.invoke(1, config); // 6 (previous was 3 * 2 from the previous invocation)\n * ```\n * @category Functional API\n */\nexport const entrypoint = function entrypoint<InputT, OutputT>(\n  optionsOrName: EntrypointOptions | string,\n  func: EntrypointFunc<InputT, OutputT>\n) {\n  const { name, checkpointer, store, cache } =\n    typeof optionsOrName === \"string\"\n      ? { name: optionsOrName, checkpointer: undefined, store: undefined }\n      : optionsOrName;\n  if (isAsyncGeneratorFunction(func) || isGeneratorFunction(func)) {\n    throw new Error(\n      \"Generators are disallowed as entrypoints. For streaming responses, use config.write.\"\n    );\n  }\n  const streamMode = \"updates\";\n  const bound = getRunnableForEntrypoint(name, func);\n\n  // Helper to check if a value is an EntrypointFinal\n  function isEntrypointFinal(\n    value: unknown\n  ): value is EntrypointFinal<unknown, unknown> {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"__lg_type\" in value &&\n      value.__lg_type === \"__pregel_final\"\n    );\n  }\n\n  // Helper function to pluck the return value from EntrypointFinal or passthrough\n  const pluckReturnValue = new RunnableCallable({\n    name: \"pluckReturnValue\",\n    func: (value: unknown) => {\n      return isEntrypointFinal(value) ? value.value : value;\n    },\n  });\n\n  // Helper function to pluck the save value from EntrypointFinal or passthrough\n  const pluckSaveValue = new RunnableCallable({\n    name: \"pluckSaveValue\",\n    func: (value: unknown) => {\n      return isEntrypointFinal(value) ? value.save : value;\n    },\n  });\n\n  const entrypointNode = new PregelNode<InputT, EntrypointReturnT<OutputT>>({\n    bound,\n    triggers: [START],\n    channels: [START],\n    writers: [\n      new ChannelWrite(\n        [\n          { channel: END, value: PASSTHROUGH, mapper: pluckReturnValue },\n          { channel: PREVIOUS, value: PASSTHROUGH, mapper: pluckSaveValue },\n        ],\n        [TAG_HIDDEN]\n      ),\n    ],\n  });\n\n  return new Pregel<\n    Record<string, PregelNode<InputT, EntrypointReturnT<OutputT>>>, // node types\n    {\n      [START]: EphemeralValue<InputT>;\n      [END]: LastValue<EntrypointReturnT<OutputT>>;\n      [PREVIOUS]: LastValue<EntrypointFinalSaveT<OutputT>>;\n    }, // channel types\n    Record<string, unknown>, // configurable types\n    InputT, // input type\n    EntrypointReturnT<OutputT> // output type\n  >({\n    name,\n    checkpointer,\n    nodes: {\n      [name]: entrypointNode,\n    },\n    channels: {\n      [START]: new EphemeralValue<InputT>(),\n      [END]: new LastValue<EntrypointReturnT<OutputT>>(),\n      [PREVIOUS]: new LastValue<EntrypointFinalSaveT<OutputT>>(),\n    },\n    inputChannels: START,\n    outputChannels: END,\n    streamChannels: END,\n    streamMode,\n    store,\n    cache,\n  });\n} as EntrypointFunction;\n\n// documented by the EntrypointFunction interface\nentrypoint.final = function final<ValueT, SaveT>({\n  value,\n  save,\n}: {\n  value?: ValueT;\n  save?: SaveT;\n}): EntrypointFinal<ValueT, SaveT> {\n  return { value, save, __lg_type: \"__pregel_final\" };\n};\n\n/**\n * A helper utility function for use with the functional API that returns the previous\n * state from the checkpoint from the last invocation of the current thread.\n *\n * This function allows workflows to access state that was saved in previous runs\n * using {@link entrypoint.final}.\n *\n * @typeParam StateT - The type of the state that was previously saved\n * @returns The previous saved state from the last invocation of the current thread\n *\n * @example\n * ```typescript\n * const previousState = getPreviousState<{ counter: number }>();\n * const newCount = (previousState?.counter ?? 0) + 1;\n * ```\n * @category Functional API\n */\nexport function getPreviousState<StateT>(): StateT {\n  const config: LangGraphRunnableConfig =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  return config.configurable?.[CONFIG_KEY_PREVIOUS_STATE] as StateT;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,SAAgB,KACd,eACA,MACsC;CACtC,MAAM,UACJ,OAAO,kBAAkB,WACrB;EAAE,MAAM;EAAe,OAAO;EAAW,aAAa;KACtD;CAEN,MAAM,EAAE,MAAM,UAAU;AACxB,KAAI,yBAAyB,SAAS,oBAAoB,MACxD,OAAM,IAAI,MACR;CAIJ,MAAM,cACJ,QAAQ,gBAGP,WAAW,UAAW,QAAQ,QAAwB;CAEzD,IAAIA;AACJ,KAAI,OAAO,gBAAgB,UACzB,SAAQ,cAAc,KAAK;KAE3B,SAAQ;AAGV,SAAQ,GAAG,SAAgB;AACzB,SAAO,KAAK;GAAE;GAAM;GAAM;GAAO;KAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkNjD,MAAa,aAAa,SAASC,aACjC,eACA,MACA;CACA,MAAM,EAAE,MAAM,cAAc,OAAO,UACjC,OAAO,kBAAkB,WACrB;EAAE,MAAM;EAAe,cAAc;EAAW,OAAO;KACvD;AACN,KAAI,yBAAyB,SAAS,oBAAoB,MACxD,OAAM,IAAI,MACR;CAGJ,MAAM,aAAa;CACnB,MAAM,QAAQ,yBAAyB,MAAM;CAG7C,SAAS,kBACP,OAC4C;AAC5C,SACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,MAAM,cAAc;;CAKxB,MAAM,mBAAmB,IAAI,iBAAiB;EAC5C,MAAM;EACN,OAAO,UAAmB;AACxB,UAAO,kBAAkB,SAAS,MAAM,QAAQ;;;CAKpD,MAAM,iBAAiB,IAAI,iBAAiB;EAC1C,MAAM;EACN,OAAO,UAAmB;AACxB,UAAO,kBAAkB,SAAS,MAAM,OAAO;;;CAInD,MAAM,iBAAiB,IAAI,WAA+C;EACxE;EACA,UAAU,CAAC;EACX,UAAU,CAAC;EACX,SAAS,CACP,IAAI,aACF,CACE;GAAE,SAAS;GAAK,OAAO;GAAa,QAAQ;KAC5C;GAAE,SAAS;GAAU,OAAO;GAAa,QAAQ;MAEnD,CAAC;;AAKP,QAAO,IAAI,OAUT;EACA;EACA;EACA,OAAO,GACJ,OAAO;EAEV,UAAU;IACP,QAAQ,IAAI;IACZ,MAAM,IAAI;IACV,WAAW,IAAI;;EAElB,eAAe;EACf,gBAAgB;EAChB,gBAAgB;EAChB;EACA;EACA;;;AAKJ,WAAW,QAAQ,SAAS,MAAqB,EAC/C,OACA,QAIiC;AACjC,QAAO;EAAE;EAAO;EAAM,WAAW;;;;;;;;;;;;;;;;;;;;AAoBnC,SAAgB,mBAAmC;CACjD,MAAMC,SACJ,mCAAmC;AACrC,QAAO,OAAO,eAAe"}

package/dist/func/types.d.cts

@@ -1,64 +0,0 @@
-import { LangGraphRunnableConfig } from "../pregel/runnable_types.cjs";
-
-//#region src/func/types.d.ts
-
-/**
- * Allows the entrypoint function to return a value to the caller, as well as a separate state value to persist to the checkpoint
- */
-type EntrypointFinal<ValueT, SaveT> = {
-  /**
-   * The value to return to the caller
-   */
-  value?: ValueT;
-  /**
-   * The value to save to the checkpoint
-   */
-  save?: SaveT;
-  __lg_type: "__pregel_final";
-};
-/**
- * Checks if a value is an EntrypointFinal - use this instead of `instanceof`, as value may have been deserialized
- * @param value The value to check
- * @returns Whether the value is an EntrypointFinal
- */
-
-/**
- * The return type of an entrypoint function.
- */
-type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;
-/**
- * The value to be saved when a function returns an EntrypointFinal.
- */
-type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;
-/**
- * The value to be returned when a function returns an EntrypointFinal.
- */
-
-/**
- * Checks if an AsyncGenerator exists in the ES target/lib that we're compiling to.
- *
- * This is necessary because `tsc --init` targets ES2016 by default, which doesn't include AsyncGenerators.
- *
- * This works because when `skipLibCheck` is true (and it is in the default `tsconfig.json` created by `tsc --init`),
- * TypeScript will replace any unresolved library types with `any`. So, when `AsyncGenerator` doesn't exist, this checks
- * if `any` extends `object`, which it doesn't. When that happens, this type resolves to the `false` literal, and we can
- * use it in the type predicates below to skip over the AsyncGenerator-specific logic.
- *
- * If we didn't have this, then the types below would be checking if the user's function extends `any` in place of the
- * `AsyncGenerator` type, and the type predicate would branch to `never`, disallowing any valid function from being passed
- * to `task` or `entrypoint`.
- */
-type AsyncGeneratorExists = AsyncGenerator<unknown, unknown, unknown> extends object ? true : false;
-/**
- * Matches valid function signatures for entrypoints. Disallows generator functions.
- */
-type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
-? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;
-/**
- * Matches valid function signatures for tasks. Disallows generator functions.
- */
-type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [never] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
-? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;
-//#endregion
-export { EntrypointFinal, EntrypointFinalSaveT, EntrypointFunc, EntrypointReturnT, TaskFunc };
-//# sourceMappingURL=types.d.cts.map

package/dist/func/types.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.cts","names":["LangGraphRunnableConfig","EntrypointFinal","ValueT","SaveT","isEntrypointFinal","EntrypointReturnT","OutputT","Promise","EntrypointFinalSaveT","EntrypointFinalValueT","AsyncGeneratorExists","AsyncGenerator","EntrypointFunc","InputT","Generator","TaskFunc","ArgsT"],"sources":["../../src/func/types.d.ts"],"sourcesContent":["import { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\n/**\n * Allows the entrypoint function to return a value to the caller, as well as a separate state value to persist to the checkpoint\n */\nexport type EntrypointFinal<ValueT, SaveT> = {\n    /**\n     * The value to return to the caller\n     */\n    value?: ValueT;\n    /**\n     * The value to save to the checkpoint\n     */\n    save?: SaveT;\n    __lg_type: \"__pregel_final\";\n};\n/**\n * Checks if a value is an EntrypointFinal - use this instead of `instanceof`, as value may have been deserialized\n * @param value The value to check\n * @returns Whether the value is an EntrypointFinal\n */\nexport declare function isEntrypointFinal<ValueT, SaveT>(value: unknown): value is EntrypointFinal<ValueT, SaveT>;\n/**\n * The return type of an entrypoint function.\n */\nexport type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;\n/**\n * The value to be saved when a function returns an EntrypointFinal.\n */\nexport type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;\n/**\n * The value to be returned when a function returns an EntrypointFinal.\n */\nexport type EntrypointFinalValueT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, infer SaveT> | Promise<EntrypointFinal<infer ValueT, infer SaveT>> ? EntrypointFinal<ValueT, SaveT> : OutputT;\n/**\n * Checks if an AsyncGenerator exists in the ES target/lib that we're compiling to.\n *\n * This is necessary because `tsc --init` targets ES2016 by default, which doesn't include AsyncGenerators.\n *\n * This works because when `skipLibCheck` is true (and it is in the default `tsconfig.json` created by `tsc --init`),\n * TypeScript will replace any unresolved library types with `any`. So, when `AsyncGenerator` doesn't exist, this checks\n * if `any` extends `object`, which it doesn't. When that happens, this type resolves to the `false` literal, and we can\n * use it in the type predicates below to skip over the AsyncGenerator-specific logic.\n *\n * If we didn't have this, then the types below would be checking if the user's function extends `any` in place of the\n * `AsyncGenerator` type, and the type predicate would branch to `never`, disallowing any valid function from being passed\n * to `task` or `entrypoint`.\n */\ntype AsyncGeneratorExists = AsyncGenerator<unknown, unknown, unknown> extends object ? true : false;\n/**\n * Matches valid function signatures for entrypoints. Disallows generator functions.\n */\nexport type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist\n ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;\n/**\n * Matches valid function signatures for tasks. Disallows generator functions.\n */\nexport type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [\n    never\n] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist\n ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;\nexport {};\n"],"mappings":";;;;;;AAIA;AAA2B,KAAfC,eAAe,CAAA,MAAA,EAAA,KAAA,CAAA,GAAA;;;;EAoBfI,KAAAA,CAAAA,EAhBAH,MAgBAG;EAAiB;;;MAA6EJ,CAAAA,EAZ/FE,KAY+FF;WAARM,EAAAA,gBAAAA;;;;AAIlG;;;;;;;AAA6JD,KAJjJD,iBAIiJC,CAAAA,OAAAA,CAAAA,GAJpHA,OAIoHA,SAJpGL,eAIoGK,CAAAA,KAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAJ3DC,OAI2DD,CAJnDL,eAImDK,CAAAA,KAAAA,OAAAA,EAAAA,OAAAA,CAAAA,CAAAA,GAJTJ,MAISI,GAJAA,OAIAA;;AAI4C;AAmBzM;AAA0B,KAvBdE,oBAuBc,CAAA,OAAA,CAAA,GAvBkBF,OAuBlB,SAvBkCL,eAuBlC,CAAA,OAAA,EAAA,KAAA,MAAA,CAAA,GAvB0EM,OAuB1E,CAvBkFN,eAuBlF,CAAA,OAAA,EAAA,KAAA,MAAA,CAAA,CAAA,GAvB2HE,KAuB3H,GAvBmIG,OAuBnI;;;;;;;;;;;;;;;;;;AAK1B;KATKI,oBAAAA,GAAuBC,cASR,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,SAAA,MAAA,GAAA,IAAA,GAAA,KAAA;;;;AAGjBL,KARSM,cAQTN,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,CAR4CA,OAQ5CA,CAAAA,SAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAR6EO,MAQ7EP,EAAAA,MAAAA,EAR6FN,uBAQ7FM,EAAAA,GAAAA,KAAAA,GARiII,oBAQjIJ,SAAAA,IAAAA,CAAAA;AAAAA,EAPAA,OAOgBK,SAPAA,cAOAA,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAPoDL,OAOpDK,SAPoEG,SAOpEH,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAP2HE,MAO3HF,EAAAA,MAAAA,EAP2IX,uBAO3IW,EAAAA,GAPuKL,OAOvKK,GAPiLL,OAOjLK,SAPiMG,SAOjMH,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAPwPE,MAOxPF,EAAAA,MAAAA,EAPwQX,uBAOxQW,EAAAA,GAPoSL,OAOpSK;;;;AAAuIL,KAH9IS,QAG8IT,CAAAA,cAAAA,OAAAA,EAAAA,EAAAA,OAAAA,CAAAA,GAAAA,CAHhGA,OAGgGA,CAAAA,SAAAA,MAAUA,QAAgBQ,IAAAA,EADtKE,KACsKF,EAAAA,GAAAA,KAAAA,GADpJJ,oBACoJI,SAAAA,IAAAA,CAAAA;AAAAA,EAAjLR,OAA0OU,SAA1NL,cAA0NK,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAtKV,OAAsKU,SAAtJF,SAAsJE,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAA7FA,KAA6FA,EAAAA,GAAnFV,OAAmFU,GAAzEV,OAAyEU,SAAzDF,SAAyDE,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAAAA,KAAAA,EAAAA,GAAUV,OAAVU"}

package/dist/func/types.d.ts

@@ -1,64 +0,0 @@
-import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
-
-//#region src/func/types.d.ts
-
-/**
- * Allows the entrypoint function to return a value to the caller, as well as a separate state value to persist to the checkpoint
- */
-type EntrypointFinal<ValueT, SaveT> = {
-  /**
-   * The value to return to the caller
-   */
-  value?: ValueT;
-  /**
-   * The value to save to the checkpoint
-   */
-  save?: SaveT;
-  __lg_type: "__pregel_final";
-};
-/**
- * Checks if a value is an EntrypointFinal - use this instead of `instanceof`, as value may have been deserialized
- * @param value The value to check
- * @returns Whether the value is an EntrypointFinal
- */
-
-/**
- * The return type of an entrypoint function.
- */
-type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;
-/**
- * The value to be saved when a function returns an EntrypointFinal.
- */
-type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;
-/**
- * The value to be returned when a function returns an EntrypointFinal.
- */
-
-/**
- * Checks if an AsyncGenerator exists in the ES target/lib that we're compiling to.
- *
- * This is necessary because `tsc --init` targets ES2016 by default, which doesn't include AsyncGenerators.
- *
- * This works because when `skipLibCheck` is true (and it is in the default `tsconfig.json` created by `tsc --init`),
- * TypeScript will replace any unresolved library types with `any`. So, when `AsyncGenerator` doesn't exist, this checks
- * if `any` extends `object`, which it doesn't. When that happens, this type resolves to the `false` literal, and we can
- * use it in the type predicates below to skip over the AsyncGenerator-specific logic.
- *
- * If we didn't have this, then the types below would be checking if the user's function extends `any` in place of the
- * `AsyncGenerator` type, and the type predicate would branch to `never`, disallowing any valid function from being passed
- * to `task` or `entrypoint`.
- */
-type AsyncGeneratorExists = AsyncGenerator<unknown, unknown, unknown> extends object ? true : false;
-/**
- * Matches valid function signatures for entrypoints. Disallows generator functions.
- */
-type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
-? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;
-/**
- * Matches valid function signatures for tasks. Disallows generator functions.
- */
-type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [never] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
-? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;
-//#endregion
-export { EntrypointFinal, EntrypointFinalSaveT, EntrypointFunc, EntrypointReturnT, TaskFunc };
-//# sourceMappingURL=types.d.ts.map

package/dist/func/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":["LangGraphRunnableConfig","EntrypointFinal","ValueT","SaveT","isEntrypointFinal","EntrypointReturnT","OutputT","Promise","EntrypointFinalSaveT","EntrypointFinalValueT","AsyncGeneratorExists","AsyncGenerator","EntrypointFunc","InputT","Generator","TaskFunc","ArgsT"],"sources":["../../src/func/types.d.ts"],"sourcesContent":["import { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\n/**\n * Allows the entrypoint function to return a value to the caller, as well as a separate state value to persist to the checkpoint\n */\nexport type EntrypointFinal<ValueT, SaveT> = {\n    /**\n     * The value to return to the caller\n     */\n    value?: ValueT;\n    /**\n     * The value to save to the checkpoint\n     */\n    save?: SaveT;\n    __lg_type: \"__pregel_final\";\n};\n/**\n * Checks if a value is an EntrypointFinal - use this instead of `instanceof`, as value may have been deserialized\n * @param value The value to check\n * @returns Whether the value is an EntrypointFinal\n */\nexport declare function isEntrypointFinal<ValueT, SaveT>(value: unknown): value is EntrypointFinal<ValueT, SaveT>;\n/**\n * The return type of an entrypoint function.\n */\nexport type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;\n/**\n * The value to be saved when a function returns an EntrypointFinal.\n */\nexport type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;\n/**\n * The value to be returned when a function returns an EntrypointFinal.\n */\nexport type EntrypointFinalValueT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, infer SaveT> | Promise<EntrypointFinal<infer ValueT, infer SaveT>> ? EntrypointFinal<ValueT, SaveT> : OutputT;\n/**\n * Checks if an AsyncGenerator exists in the ES target/lib that we're compiling to.\n *\n * This is necessary because `tsc --init` targets ES2016 by default, which doesn't include AsyncGenerators.\n *\n * This works because when `skipLibCheck` is true (and it is in the default `tsconfig.json` created by `tsc --init`),\n * TypeScript will replace any unresolved library types with `any`. So, when `AsyncGenerator` doesn't exist, this checks\n * if `any` extends `object`, which it doesn't. When that happens, this type resolves to the `false` literal, and we can\n * use it in the type predicates below to skip over the AsyncGenerator-specific logic.\n *\n * If we didn't have this, then the types below would be checking if the user's function extends `any` in place of the\n * `AsyncGenerator` type, and the type predicate would branch to `never`, disallowing any valid function from being passed\n * to `task` or `entrypoint`.\n */\ntype AsyncGeneratorExists = AsyncGenerator<unknown, unknown, unknown> extends object ? true : false;\n/**\n * Matches valid function signatures for entrypoints. Disallows generator functions.\n */\nexport type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist\n ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;\n/**\n * Matches valid function signatures for tasks. Disallows generator functions.\n */\nexport type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [\n    never\n] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist\n ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;\nexport {};\n"],"mappings":";;;;;;AAIA;AAA2B,KAAfC,eAAe,CAAA,MAAA,EAAA,KAAA,CAAA,GAAA;;;;EAoBfI,KAAAA,CAAAA,EAhBAH,MAgBAG;EAAiB;;;MAA6EJ,CAAAA,EAZ/FE,KAY+FF;WAARM,EAAAA,gBAAAA;;;;AAIlG;;;;;;;AAA6JD,KAJjJD,iBAIiJC,CAAAA,OAAAA,CAAAA,GAJpHA,OAIoHA,SAJpGL,eAIoGK,CAAAA,KAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAJ3DC,OAI2DD,CAJnDL,eAImDK,CAAAA,KAAAA,OAAAA,EAAAA,OAAAA,CAAAA,CAAAA,GAJTJ,MAISI,GAJAA,OAIAA;;AAI4C;AAmBzM;AAA0B,KAvBdE,oBAuBc,CAAA,OAAA,CAAA,GAvBkBF,OAuBlB,SAvBkCL,eAuBlC,CAAA,OAAA,EAAA,KAAA,MAAA,CAAA,GAvB0EM,OAuB1E,CAvBkFN,eAuBlF,CAAA,OAAA,EAAA,KAAA,MAAA,CAAA,CAAA,GAvB2HE,KAuB3H,GAvBmIG,OAuBnI;;;;;;;;;;;;;;;;;;AAK1B;KATKI,oBAAAA,GAAuBC,cASR,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,SAAA,MAAA,GAAA,IAAA,GAAA,KAAA;;;;AAGjBL,KARSM,cAQTN,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,CAR4CA,OAQ5CA,CAAAA,SAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAR6EO,MAQ7EP,EAAAA,MAAAA,EAR6FN,uBAQ7FM,EAAAA,GAAAA,KAAAA,GARiII,oBAQjIJ,SAAAA,IAAAA,CAAAA;AAAAA,EAPAA,OAOgBK,SAPAA,cAOAA,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAPoDL,OAOpDK,SAPoEG,SAOpEH,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAP2HE,MAO3HF,EAAAA,MAAAA,EAP2IX,uBAO3IW,EAAAA,GAPuKL,OAOvKK,GAPiLL,OAOjLK,SAPiMG,SAOjMH,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,KAAAA,EAPwPE,MAOxPF,EAAAA,MAAAA,EAPwQX,uBAOxQW,EAAAA,GAPoSL,OAOpSK;;;;AAAuIL,KAH9IS,QAG8IT,CAAAA,cAAAA,OAAAA,EAAAA,EAAAA,OAAAA,CAAAA,GAAAA,CAHhGA,OAGgGA,CAAAA,SAAAA,MAAUA,QAAgBQ,IAAAA,EADtKE,KACsKF,EAAAA,GAAAA,KAAAA,GADpJJ,oBACoJI,SAAAA,IAAAA,CAAAA;AAAAA,EAAjLR,OAA0OU,SAA1NL,cAA0NK,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAtKV,OAAsKU,SAAtJF,SAAsJE,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAA7FA,KAA6FA,EAAAA,GAAnFV,OAAmFU,GAAzEV,OAAyEU,SAAzDF,SAAyDE,CAAAA,OAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAAA,KAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAAAA,KAAAA,EAAAA,GAAUV,OAAVU"}

package/dist/graph/annotation.cjs

@@ -1,101 +0,0 @@
-const require_binop = require('../channels/binop.cjs');
-const require_last_value = require('../channels/last_value.cjs');
-
-//#region src/graph/annotation.ts
-/**
-* Should not be instantiated directly. See {@link Annotation}.
-*/
-var AnnotationRoot = class {
-	lc_graph_name = "AnnotationRoot";
-	spec;
-	constructor(s) {
-		this.spec = s;
-	}
-};
-/**
-* Helper that instantiates channels within a StateGraph state.
-*
-* Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
-* 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
-* 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
-*
-* @example
-* ```ts
-* import { StateGraph, Annotation } from "@langchain/langgraph";
-*
-* // Define a state with a single string key named "currentOutput"
-* const SimpleAnnotation = Annotation.Root({
-*   currentOutput: Annotation<string>,
-* });
-*
-* const graphBuilder = new StateGraph(SimpleAnnotation);
-*
-* // A node in the graph that returns an object with a "currentOutput" key
-* // replaces the value in the state. You can get the state type as shown below:
-* const myNode = (state: typeof SimpleAnnotation.State) => {
-*   return {
-*     currentOutput: "some_new_value",
-*   };
-* }
-*
-* const graph = graphBuilder
-*   .addNode("myNode", myNode)
-*   ...
-*   .compile();
-* ```
-*
-* @example
-* ```ts
-* import { type BaseMessage, AIMessage } from "@langchain/core/messages";
-* import { StateGraph, Annotation } from "@langchain/langgraph";
-*
-* // Define a state with a single key named "messages" that will
-* // combine a returned BaseMessage or arrays of BaseMessages
-* const AnnotationWithReducer = Annotation.Root({
-*   messages: Annotation<BaseMessage[]>({
-*     // Different types are allowed for updates
-*     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
-*       if (Array.isArray(right)) {
-*         return left.concat(right);
-*       }
-*       return left.concat([right]);
-*     },
-*     default: () => [],
-*   }),
-* });
-*
-* const graphBuilder = new StateGraph(AnnotationWithReducer);
-*
-* // A node in the graph that returns an object with a "messages" key
-* // will update the state by combining the existing value with the returned one.
-* const myNode = (state: typeof AnnotationWithReducer.State) => {
-*   return {
-*     messages: [new AIMessage("Some new response")],
-*   };
-* };
-*
-* const graph = graphBuilder
-*   .addNode("myNode", myNode)
-*   ...
-*   .compile();
-* ```
-* @namespace
-* @property Root
-* Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
-*/
-const Annotation = function(annotation) {
-	if (annotation) return getChannel(annotation);
-	else return new require_last_value.LastValue();
-};
-Annotation.Root = (sd) => new AnnotationRoot(sd);
-function getChannel(reducer) {
-	if (typeof reducer === "object" && reducer && "reducer" in reducer && reducer.reducer) return new require_binop.BinaryOperatorAggregate(reducer.reducer, reducer.default);
-	if (typeof reducer === "object" && reducer && "value" in reducer && reducer.value) return new require_binop.BinaryOperatorAggregate(reducer.value, reducer.default);
-	return new require_last_value.LastValue();
-}
-
-//#endregion
-exports.Annotation = Annotation;
-exports.AnnotationRoot = AnnotationRoot;
-exports.getChannel = getChannel;
-//# sourceMappingURL=annotation.cjs.map

package/dist/graph/annotation.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"annotation.cjs","names":["Annotation: AnnotationFunction","LastValue","BinaryOperatorAggregate"],"sources":["../../src/graph/annotation.ts"],"sourcesContent":["import { RunnableLike } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { BinaryOperator, BinaryOperatorAggregate } from \"../channels/binop.js\";\nimport { LastValue } from \"../channels/last_value.js\";\n\nexport type SingleReducer<ValueType, UpdateType = ValueType> =\n  | {\n      reducer: BinaryOperator<ValueType, UpdateType>;\n      default?: () => ValueType;\n    }\n  | {\n      /**\n       * @deprecated Use `reducer` instead\n       */\n      value: BinaryOperator<ValueType, UpdateType>;\n      default?: () => ValueType;\n    }\n  | null;\n\nexport interface StateDefinition {\n  [key: string]: BaseChannel | (() => BaseChannel);\n}\n\ntype ExtractValueType<C> = C extends BaseChannel\n  ? C[\"ValueType\"]\n  : C extends () => BaseChannel\n  ? ReturnType<C>[\"ValueType\"]\n  : never;\n\ntype ExtractUpdateType<C> = C extends BaseChannel\n  ? C[\"UpdateType\"]\n  : C extends () => BaseChannel\n  ? ReturnType<C>[\"UpdateType\"]\n  : never;\n\nexport type StateType<SD extends StateDefinition> = {\n  [key in keyof SD]: ExtractValueType<SD[key]>;\n};\n\nexport type UpdateType<SD extends StateDefinition> = {\n  [key in keyof SD]?: ExtractUpdateType<SD[key]>;\n};\n\nexport type NodeType<SD extends StateDefinition> = RunnableLike<\n  StateType<SD>,\n  UpdateType<SD> | Partial<StateType<SD>>\n>;\n\n/** @ignore */\nexport interface AnnotationFunction {\n  <ValueType>(): LastValue<ValueType>;\n  <ValueType, UpdateType = ValueType>(\n    annotation: SingleReducer<ValueType, UpdateType>\n  ): BinaryOperatorAggregate<ValueType, UpdateType>;\n  Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;\n}\n\n/**\n * Should not be instantiated directly. See {@link Annotation}.\n */\nexport class AnnotationRoot<SD extends StateDefinition> {\n  lc_graph_name = \"AnnotationRoot\";\n\n  declare State: StateType<SD>;\n\n  declare Update: UpdateType<SD>;\n\n  declare Node: NodeType<SD>;\n\n  spec: SD;\n\n  constructor(s: SD) {\n    this.spec = s;\n  }\n}\n\n/**\n * Helper that instantiates channels within a StateGraph state.\n *\n * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:\n * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.\n * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.\n *\n * @example\n * ```ts\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single string key named \"currentOutput\"\n * const SimpleAnnotation = Annotation.Root({\n *   currentOutput: Annotation<string>,\n * });\n *\n * const graphBuilder = new StateGraph(SimpleAnnotation);\n *\n * // A node in the graph that returns an object with a \"currentOutput\" key\n * // replaces the value in the state. You can get the state type as shown below:\n * const myNode = (state: typeof SimpleAnnotation.State) => {\n *   return {\n *     currentOutput: \"some_new_value\",\n *   };\n * }\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n *\n * @example\n * ```ts\n * import { type BaseMessage, AIMessage } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const AnnotationWithReducer = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     // Different types are allowed for updates\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(AnnotationWithReducer);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof AnnotationWithReducer.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n * @namespace\n * @property Root\n * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.\n */\nexport const Annotation: AnnotationFunction = function <\n  ValueType,\n  UpdateType = ValueType\n>(\n  annotation?: SingleReducer<ValueType, UpdateType>\n): BaseChannel<ValueType, UpdateType> {\n  if (annotation) {\n    return getChannel<ValueType, UpdateType>(annotation);\n  } else {\n    // @ts-expect-error - Annotation without reducer\n    return new LastValue<ValueType>();\n  }\n} as AnnotationFunction;\n\nAnnotation.Root = <S extends StateDefinition>(sd: S) => new AnnotationRoot(sd);\n\nexport function getChannel<V, U = V>(\n  reducer: SingleReducer<V, U>\n): BaseChannel<V, U> {\n  if (\n    typeof reducer === \"object\" &&\n    reducer &&\n    \"reducer\" in reducer &&\n    reducer.reducer\n  ) {\n    return new BinaryOperatorAggregate(reducer.reducer, reducer.default);\n  }\n  if (\n    typeof reducer === \"object\" &&\n    reducer &&\n    \"value\" in reducer &&\n    reducer.value\n  ) {\n    return new BinaryOperatorAggregate(reducer.value, reducer.default);\n  }\n  // @ts-expect-error - Annotation without reducer\n  return new LastValue<V>();\n}\n"],"mappings":";;;;;;;AA4DA,IAAa,iBAAb,MAAwD;CACtD,gBAAgB;CAQhB;CAEA,YAAY,GAAO;AACjB,OAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EhB,MAAaA,aAAiC,SAI5C,YACoC;AACpC,KAAI,WACF,QAAO,WAAkC;KAGzC,QAAO,IAAIC;;AAIf,WAAW,QAAmC,OAAU,IAAI,eAAe;AAE3E,SAAgB,WACd,SACmB;AACnB,KACE,OAAO,YAAY,YACnB,WACA,aAAa,WACb,QAAQ,QAER,QAAO,IAAIC,sCAAwB,QAAQ,SAAS,QAAQ;AAE9D,KACE,OAAO,YAAY,YACnB,WACA,WAAW,WACX,QAAQ,MAER,QAAO,IAAIA,sCAAwB,QAAQ,OAAO,QAAQ;AAG5D,QAAO,IAAID"}