@langchain/langgraph 0.4.9 → 1.0.0-alpha.1

package/dist/func/index.js

@@ -1,294 +1,298 @@
-import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
-import { Pregel } from "../pregel/index.js";
-import { PregelNode } from "../pregel/read.js";
-import { CONFIG_KEY_PREVIOUS_STATE, END, PREVIOUS, START, TAG_HIDDEN, } from "../constants.js";
-import { EphemeralValue } from "../channels/ephemeral_value.js";
-import { call, getRunnableForEntrypoint } from "../pregel/call.js";
 import { LastValue } from "../channels/last_value.js";
-import { RunnableCallable, isAsyncGeneratorFunction, isGeneratorFunction, } from "../utils.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;
- * });
- * ```
- */
-export function task(optionsOrName, func) {
-    const options = typeof optionsOrName === "string"
-        ? { name: optionsOrName, retry: undefined, cachePolicy: undefined }
-        : 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` was mistakingly used as an alias for `cachePolicy` in v0.3.x,
-        // TODO: remove in 1.x
-        ("cache" in options ? options.cache : undefined);
-    let cache;
-    if (typeof cachePolicy === "boolean") {
-        cache = cachePolicy ? {} : undefined;
-    }
-    else {
-        cache = cachePolicy;
-    }
-    return (...args) => {
-        return call({ func, name, retry, cache }, ...args);
-    };
+* 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)
- * ```
- */
-export const entrypoint = function entrypoint(optionsOrName, func) {
-    const { name, checkpointer, store, cache } = typeof optionsOrName === "string"
-        ? { name: optionsOrName, checkpointer: undefined, store: undefined }
-        : 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);
-    // Helper to check if a value is an EntrypointFinal
-    function isEntrypointFinal(value) {
-        return (typeof value === "object" &&
-            value !== null &&
-            "__lg_type" in value &&
-            value.__lg_type === "__pregel_final");
-    }
-    // Helper function to pluck the return value from EntrypointFinal or passthrough
-    const pluckReturnValue = new RunnableCallable({
-        name: "pluckReturnValue",
-        func: (value) => {
-            return isEntrypointFinal(value) ? value.value : value;
-        },
-    });
-    // Helper function to pluck the save value from EntrypointFinal or passthrough
-    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,
-    });
+* 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
+	});
 };
-// documented by the EntrypointFunction interface
-entrypoint.final = function final({ value, save, }) {
-    return { value, save, __lg_type: "__pregel_final" };
+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;
- * ```
- */
-export function getPreviousState() {
-    const config = AsyncLocalStorageProviderSingleton.getRunnableConfig();
-    return config.configurable?.[CONFIG_KEY_PREVIOUS_STATE];
+* 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 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/func/index.ts"],"names":[],"mappings":"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"}
+{"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 value - The value to return to the caller\n   * @param 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"}