@langchain/langgraph 0.2.40 → 0.2.42

package/dist/channels/ephemeral_value.js

@@ -19,45 +19,46 @@ export class EphemeralValue extends BaseChannel {
             writable: true,
             value: void 0
         });
+        // value is an array so we don't misinterpret an update to undefined as no write
         Object.defineProperty(this, "value", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         this.guard = guard;
     }
     fromCheckpoint(checkpoint) {
         const empty = new EphemeralValue(this.guard);
         if (checkpoint) {
-            empty.value = checkpoint;
+            empty.value = [checkpoint];
         }
         return empty;
     }
     update(values) {
         if (values.length === 0) {
-            const updated = this.value !== undefined;
+            const updated = this.value.length > 0;
             // If there are no updates for this specific channel at the end of the step, wipe it.
-            this.value = undefined;
+            this.value = [];
             return updated;
         }
         if (values.length !== 1 && this.guard) {
             throw new InvalidUpdateError("EphemeralValue can only receive one value per step.");
         }
         // eslint-disable-next-line prefer-destructuring
-        this.value = values[values.length - 1];
+        this.value = [values[values.length - 1]];
         return true;
     }
     get() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
     checkpoint() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
 }

package/dist/channels/last_value.cjs

@@ -20,17 +20,18 @@ class LastValue extends base_js_1.BaseChannel {
             writable: true,
             value: "LastValue"
         });
+        // value is an array so we don't misinterpret an update to undefined as no write
         Object.defineProperty(this, "value", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
     }
     fromCheckpoint(checkpoint) {
         const empty = new LastValue();
         if (checkpoint) {
-            empty.value = checkpoint;
+            empty.value = [checkpoint];
         }
         return empty;
     }
@@ -44,20 +45,20 @@ class LastValue extends base_js_1.BaseChannel {
             });
         }
         // eslint-disable-next-line prefer-destructuring
-        this.value = values[values.length - 1];
+        this.value = [values[values.length - 1]];
         return true;
     }
     get() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new errors_js_1.EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
     checkpoint() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new errors_js_1.EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
 }
 exports.LastValue = LastValue;

package/dist/channels/last_value.d.ts

@@ -9,7 +9,7 @@ import { BaseChannel } from "./base.js";
  */
 export declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {
     lc_graph_name: string;
-    value?: Value;
+    value: [Value] | [];
     fromCheckpoint(checkpoint?: Value): this;
     update(values: Value[]): boolean;
     get(): Value;

package/dist/channels/last_value.js

@@ -17,17 +17,18 @@ export class LastValue extends BaseChannel {
             writable: true,
             value: "LastValue"
         });
+        // value is an array so we don't misinterpret an update to undefined as no write
         Object.defineProperty(this, "value", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
     }
     fromCheckpoint(checkpoint) {
         const empty = new LastValue();
         if (checkpoint) {
-            empty.value = checkpoint;
+            empty.value = [checkpoint];
         }
         return empty;
     }
@@ -41,19 +42,19 @@ export class LastValue extends BaseChannel {
             });
         }
         // eslint-disable-next-line prefer-destructuring
-        this.value = values[values.length - 1];
+        this.value = [values[values.length - 1]];
         return true;
     }
     get() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
     checkpoint() {
-        if (this.value === undefined) {
+        if (this.value.length === 0) {
             throw new EmptyChannelError();
         }
-        return this.value;
+        return this.value[0];
     }
 }

package/dist/constants.cjs

@@ -1,23 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCommand = exports.Command = exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.NULL_TASK_ID = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.SELF = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.RESUME = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_CHECKPOINT_NS = exports.CONFIG_KEY_SCRATCHPAD = exports.CONFIG_KEY_WRITES = exports.CONFIG_KEY_RESUME_VALUE = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = exports.MISSING = void 0;
-exports.MISSING = Symbol.for("__missing__");
+exports.isCommand = exports.Command = exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.NULL_TASK_ID = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.SELF = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.PREVIOUS = exports.RETURN = exports.NO_WRITES = exports.RESUME = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_CHECKPOINT_NS = exports.CONFIG_KEY_CHECKPOINT_ID = exports.CONFIG_KEY_PREVIOUS_STATE = exports.CONFIG_KEY_SCRATCHPAD = exports.CONFIG_KEY_RESUME_VALUE = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_CALL = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = exports.END = exports.START = void 0;
+/** Special reserved node name denoting the start of a graph. */
+exports.START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
+exports.END = "__end__";
 exports.INPUT = "__input__";
 exports.ERROR = "__error__";
 exports.CONFIG_KEY_SEND = "__pregel_send";
+/** config key containing function used to call a node (push task) */
+exports.CONFIG_KEY_CALL = "__pregel_call";
 exports.CONFIG_KEY_READ = "__pregel_read";
 exports.CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 exports.CONFIG_KEY_RESUMING = "__pregel_resuming";
 exports.CONFIG_KEY_TASK_ID = "__pregel_task_id";
 exports.CONFIG_KEY_STREAM = "__pregel_stream";
 exports.CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
-exports.CONFIG_KEY_WRITES = "__pregel_writes";
 exports.CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+/** config key containing state from previous invocation of graph for the given thread */
+exports.CONFIG_KEY_PREVIOUS_STATE = "__pregel_previous";
+exports.CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id";
 exports.CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 // this one is part of public API
 exports.CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
+/** Special channel reserved for graph interrupts */
 exports.INTERRUPT = "__interrupt__";
+/** Special channel reserved for graph resume */
 exports.RESUME = "__resume__";
+/** Special channel reserved for cases when a task exits without any writes */
+exports.NO_WRITES = "__no_writes__";
+/** Special channel reserved for graph return */
+exports.RETURN = "__return__";
+/** Special channel reserved for graph previous state */
+exports.PREVIOUS = "__previous__";
 exports.RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 exports.RECURSION_LIMIT_DEFAULT = 25;
 exports.TAG_HIDDEN = "langsmith:hidden";
@@ -29,24 +44,36 @@ exports.PULL = "__pregel_pull";
 exports.TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
 exports.NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
 exports.RESERVED = [
+    exports.TAG_HIDDEN,
+    exports.INPUT,
     exports.INTERRUPT,
     exports.RESUME,
     exports.ERROR,
+    exports.NO_WRITES,
     exports.TASKS,
+    // reserved config.configurable keys
     exports.CONFIG_KEY_SEND,
     exports.CONFIG_KEY_READ,
     exports.CONFIG_KEY_CHECKPOINTER,
+    exports.CONFIG_KEY_STREAM,
     exports.CONFIG_KEY_RESUMING,
     exports.CONFIG_KEY_TASK_ID,
-    exports.CONFIG_KEY_STREAM,
+    exports.CONFIG_KEY_CALL,
+    exports.CONFIG_KEY_RESUME_VALUE,
+    exports.CONFIG_KEY_SCRATCHPAD,
+    exports.CONFIG_KEY_PREVIOUS_STATE,
     exports.CONFIG_KEY_CHECKPOINT_MAP,
-    exports.INPUT,
+    exports.CONFIG_KEY_CHECKPOINT_NS,
+    exports.CONFIG_KEY_CHECKPOINT_ID,
 ];
 exports.CHECKPOINT_NAMESPACE_SEPARATOR = "|";
 exports.CHECKPOINT_NAMESPACE_END = ":";
 function _isSendInterface(x) {
     const operation = x;
-    return typeof operation.node === "string" && operation.args !== undefined;
+    return (operation !== null &&
+        operation !== undefined &&
+        typeof operation.node === "string" &&
+        operation.args !== undefined);
 }
 exports._isSendInterface = _isSendInterface;
 /**

package/dist/constants.d.ts

@@ -1,19 +1,34 @@
-export declare const MISSING: unique symbol;
+/** Special reserved node name denoting the start of a graph. */
+export declare const START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
+export declare const END = "__end__";
 export declare const INPUT = "__input__";
 export declare const ERROR = "__error__";
 export declare const CONFIG_KEY_SEND = "__pregel_send";
+/** config key containing function used to call a node (push task) */
+export declare const CONFIG_KEY_CALL = "__pregel_call";
 export declare const CONFIG_KEY_READ = "__pregel_read";
 export declare const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export declare const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export declare const CONFIG_KEY_TASK_ID = "__pregel_task_id";
 export declare const CONFIG_KEY_STREAM = "__pregel_stream";
 export declare const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
-export declare const CONFIG_KEY_WRITES = "__pregel_writes";
 export declare const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+/** config key containing state from previous invocation of graph for the given thread */
+export declare const CONFIG_KEY_PREVIOUS_STATE = "__pregel_previous";
+export declare const CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id";
 export declare const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 export declare const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
+/** Special channel reserved for graph interrupts */
 export declare const INTERRUPT = "__interrupt__";
+/** Special channel reserved for graph resume */
 export declare const RESUME = "__resume__";
+/** Special channel reserved for cases when a task exits without any writes */
+export declare const NO_WRITES = "__no_writes__";
+/** Special channel reserved for graph return */
+export declare const RETURN = "__return__";
+/** Special channel reserved for graph previous state */
+export declare const PREVIOUS = "__previous__";
 export declare const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export declare const RECURSION_LIMIT_DEFAULT = 25;
 export declare const TAG_HIDDEN = "langsmith:hidden";

package/dist/constants.js

@@ -1,20 +1,35 @@
-export const MISSING = Symbol.for("__missing__");
+/** Special reserved node name denoting the start of a graph. */
+export const START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
+export const END = "__end__";
 export const INPUT = "__input__";
 export const ERROR = "__error__";
 export const CONFIG_KEY_SEND = "__pregel_send";
+/** config key containing function used to call a node (push task) */
+export const CONFIG_KEY_CALL = "__pregel_call";
 export const CONFIG_KEY_READ = "__pregel_read";
 export const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export const CONFIG_KEY_TASK_ID = "__pregel_task_id";
 export const CONFIG_KEY_STREAM = "__pregel_stream";
 export const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
-export const CONFIG_KEY_WRITES = "__pregel_writes";
 export const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+/** config key containing state from previous invocation of graph for the given thread */
+export const CONFIG_KEY_PREVIOUS_STATE = "__pregel_previous";
+export const CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id";
 export const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 // this one is part of public API
 export const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
+/** Special channel reserved for graph interrupts */
 export const INTERRUPT = "__interrupt__";
+/** Special channel reserved for graph resume */
 export const RESUME = "__resume__";
+/** Special channel reserved for cases when a task exits without any writes */
+export const NO_WRITES = "__no_writes__";
+/** Special channel reserved for graph return */
+export const RETURN = "__return__";
+/** Special channel reserved for graph previous state */
+export const PREVIOUS = "__previous__";
 export const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export const RECURSION_LIMIT_DEFAULT = 25;
 export const TAG_HIDDEN = "langsmith:hidden";
@@ -26,24 +41,36 @@ export const PULL = "__pregel_pull";
 export const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
 export const NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
 export const RESERVED = [
+    TAG_HIDDEN,
+    INPUT,
     INTERRUPT,
     RESUME,
     ERROR,
+    NO_WRITES,
     TASKS,
+    // reserved config.configurable keys
     CONFIG_KEY_SEND,
     CONFIG_KEY_READ,
     CONFIG_KEY_CHECKPOINTER,
+    CONFIG_KEY_STREAM,
     CONFIG_KEY_RESUMING,
     CONFIG_KEY_TASK_ID,
-    CONFIG_KEY_STREAM,
+    CONFIG_KEY_CALL,
+    CONFIG_KEY_RESUME_VALUE,
+    CONFIG_KEY_SCRATCHPAD,
+    CONFIG_KEY_PREVIOUS_STATE,
     CONFIG_KEY_CHECKPOINT_MAP,
-    INPUT,
+    CONFIG_KEY_CHECKPOINT_NS,
+    CONFIG_KEY_CHECKPOINT_ID,
 ];
 export const CHECKPOINT_NAMESPACE_SEPARATOR = "|";
 export const CHECKPOINT_NAMESPACE_END = ":";
 export function _isSendInterface(x) {
     const operation = x;
-    return typeof operation.node === "string" && operation.args !== undefined;
+    return (operation !== null &&
+        operation !== undefined &&
+        typeof operation.node === "string" &&
+        operation.args !== undefined);
 }
 /**
  *

package/dist/errors.d.ts

@@ -32,9 +32,9 @@ export declare class ParentCommand extends GraphBubbleUp {
     constructor(command: Command);
     static get unminifiable_name(): string;
 }
-export declare function isParentCommand(e?: Error): e is ParentCommand;
-export declare function isGraphBubbleUp(e?: Error): e is GraphBubbleUp;
-export declare function isGraphInterrupt(e?: GraphInterrupt | Error): e is GraphInterrupt;
+export declare function isParentCommand(e?: unknown): e is ParentCommand;
+export declare function isGraphBubbleUp(e?: unknown): e is GraphBubbleUp;
+export declare function isGraphInterrupt(e?: unknown): e is GraphInterrupt;
 export declare class EmptyInputError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;

package/dist/func/index.cjs

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreviousState = exports.entrypoint = exports.task = void 0;
+const singletons_1 = require("@langchain/core/singletons");
+const index_js_1 = require("../pregel/index.cjs");
+const read_js_1 = require("../pregel/read.cjs");
+const constants_js_1 = require("../constants.cjs");
+const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
+const call_js_1 = require("../pregel/call.cjs");
+const last_value_js_1 = require("../channels/last_value.cjs");
+const utils_js_1 = require("../utils.cjs");
+/**
+ * Define a LangGraph task using the `task` function.
+ *
+ * !!! warning "Beta"
+ *     The Functional API is currently in beta and is subject to change.
+ *
+ * @beta
+ *
+ * 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;
+ * });
+ * ```
+ */
+function task(optionsOrName, func) {
+    const { name, retry } = typeof optionsOrName === "string"
+        ? { name: optionsOrName, retry: undefined }
+        : optionsOrName;
+    if ((0, utils_js_1.isAsyncGeneratorFunction)(func) || (0, utils_js_1.isGeneratorFunction)(func)) {
+        throw new Error("Generators are disallowed as tasks. For streaming responses, use config.write.");
+    }
+    return (...args) => {
+        return (0, call_js_1.call)({ func, name, retry }, ...args);
+    };
+}
+exports.task = task;
+/**
+ * Define a LangGraph workflow using the `entrypoint` function.
+ *
+ * !!! warning "Beta"
+ *     The Functional API is currently in beta and is subject to change.
+ *
+ * @beta
+ *
+ * ### 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)
+ * ```
+ */
+exports.entrypoint = function entrypoint(optionsOrName, func) {
+    const { name, checkpointer, store } = typeof optionsOrName === "string"
+        ? { name: optionsOrName, checkpointer: undefined, store: undefined }
+        : optionsOrName;
+    if ((0, utils_js_1.isAsyncGeneratorFunction)(func) || (0, utils_js_1.isGeneratorFunction)(func)) {
+        throw new Error("Generators are disallowed as entrypoints. For streaming responses, use config.write.");
+    }
+    const streamMode = "updates";
+    const bound = (0, call_js_1.getRunnableForEntrypoint)(name, func);
+    return new index_js_1.Pregel({
+        name,
+        checkpointer,
+        nodes: {
+            [name]: new read_js_1.PregelNode({
+                bound,
+                triggers: [constants_js_1.START],
+                channels: [constants_js_1.START],
+                writers: [],
+            }),
+        },
+        channels: {
+            [constants_js_1.START]: new ephemeral_value_js_1.EphemeralValue(),
+            [constants_js_1.END]: new last_value_js_1.LastValue(),
+            [constants_js_1.PREVIOUS]: new last_value_js_1.LastValue(),
+        },
+        inputChannels: constants_js_1.START,
+        outputChannels: constants_js_1.END,
+        streamChannels: constants_js_1.END,
+        streamMode,
+        store,
+    });
+};
+// documented by the EntrypointFunction interface
+exports.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}.
+ *
+ * !!! warning "Beta"
+ *     The Functional API is currently in beta and is subject to change.
+ *
+ * @beta
+ *
+ * @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;
+ * ```
+ */
+function getPreviousState() {
+    const config = singletons_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    return config.configurable?.[constants_js_1.CONFIG_KEY_PREVIOUS_STATE];
+}
+exports.getPreviousState = getPreviousState;