@langchain/langgraph 1.0.12 → 1.0.13

package/dist/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":["Command","Interrupt","BaseLangGraphErrorFields","BaseLangGraphError","Error","GraphBubbleUp","GraphRecursionError","GraphValueError","GraphInterrupt","NodeInterrupt","ParentCommand","isParentCommand","isGraphBubbleUp","isGraphInterrupt","EmptyInputError","EmptyChannelError","InvalidUpdateError","MultipleSubgraphsError","UnreachableNodeError","RemoteException","getSubgraphsSeenSet"],"sources":["../src/errors.d.ts"],"sourcesContent":["import { Command, Interrupt } from \"./constants.js\";\nexport type BaseLangGraphErrorFields = {\n    lc_error_code?: \"GRAPH_RECURSION_LIMIT\" | \"INVALID_CONCURRENT_GRAPH_UPDATE\" | \"INVALID_GRAPH_NODE_RETURN_VALUE\" | \"MISSING_CHECKPOINTER\" | \"MULTIPLE_SUBGRAPHS\" | \"UNREACHABLE_NODE\";\n};\n/** @category Errors */\nexport declare class BaseLangGraphError extends Error {\n    lc_error_code?: string;\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n}\nexport declare class GraphBubbleUp extends BaseLangGraphError {\n    get is_bubble_up(): boolean;\n}\nexport declare class GraphRecursionError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class GraphValueError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class GraphInterrupt extends GraphBubbleUp {\n    interrupts: Interrupt[];\n    constructor(interrupts?: Interrupt[], fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/** Raised by a node to interrupt execution. */\nexport declare class NodeInterrupt extends GraphInterrupt {\n    constructor(message: any, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class ParentCommand extends GraphBubbleUp {\n    command: Command;\n    constructor(command: Command);\n    static get unminifiable_name(): string;\n}\nexport declare function isParentCommand(e?: unknown): e is ParentCommand;\nexport declare function isGraphBubbleUp(e?: unknown): e is GraphBubbleUp;\nexport declare function isGraphInterrupt(e?: unknown): e is GraphInterrupt;\nexport declare class EmptyInputError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class EmptyChannelError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class InvalidUpdateError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * @deprecated This exception type is no longer thrown.\n */\nexport declare class MultipleSubgraphsError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class UnreachableNodeError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * Exception raised when an error occurs in the remote graph.\n */\nexport declare class RemoteException extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * Used for subgraph detection.\n */\nexport declare const getSubgraphsSeenSet: () => any;\n"],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,77 @@
+import { Command, Interrupt } from "./constants.js";
+
+//#region src/errors.d.ts
+type BaseLangGraphErrorFields = {
+  lc_error_code?: "GRAPH_RECURSION_LIMIT" | "INVALID_CONCURRENT_GRAPH_UPDATE" | "INVALID_GRAPH_NODE_RETURN_VALUE" | "MISSING_CHECKPOINTER" | "MULTIPLE_SUBGRAPHS" | "UNREACHABLE_NODE";
+};
+/** @category Errors */
+declare class BaseLangGraphError extends Error {
+  lc_error_code?: string;
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+}
+declare class GraphBubbleUp extends BaseLangGraphError {
+  get is_bubble_up(): boolean;
+}
+declare class GraphRecursionError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class GraphValueError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class GraphInterrupt extends GraphBubbleUp {
+  interrupts: Interrupt[];
+  constructor(interrupts?: Interrupt[], fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+/** Raised by a node to interrupt execution. */
+declare class NodeInterrupt extends GraphInterrupt {
+  constructor(message: any, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class ParentCommand extends GraphBubbleUp {
+  command: Command;
+  constructor(command: Command);
+  static get unminifiable_name(): string;
+}
+declare function isParentCommand(e?: unknown): e is ParentCommand;
+declare function isGraphBubbleUp(e?: unknown): e is GraphBubbleUp;
+declare function isGraphInterrupt(e?: unknown): e is GraphInterrupt;
+declare class EmptyInputError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class EmptyChannelError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class InvalidUpdateError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+/**
+ * @deprecated This exception type is no longer thrown.
+ */
+declare class MultipleSubgraphsError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+declare class UnreachableNodeError extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+/**
+ * Exception raised when an error occurs in the remote graph.
+ */
+declare class RemoteException extends BaseLangGraphError {
+  constructor(message?: string, fields?: BaseLangGraphErrorFields);
+  static get unminifiable_name(): string;
+}
+/**
+ * Used for subgraph detection.
+ */
+declare const getSubgraphsSeenSet: () => any;
+//#endregion
+export { BaseLangGraphError, BaseLangGraphErrorFields, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":["Command","Interrupt","BaseLangGraphErrorFields","BaseLangGraphError","Error","GraphBubbleUp","GraphRecursionError","GraphValueError","GraphInterrupt","NodeInterrupt","ParentCommand","isParentCommand","isGraphBubbleUp","isGraphInterrupt","EmptyInputError","EmptyChannelError","InvalidUpdateError","MultipleSubgraphsError","UnreachableNodeError","RemoteException","getSubgraphsSeenSet"],"sources":["../src/errors.d.ts"],"sourcesContent":["import { Command, Interrupt } from \"./constants.js\";\nexport type BaseLangGraphErrorFields = {\n    lc_error_code?: \"GRAPH_RECURSION_LIMIT\" | \"INVALID_CONCURRENT_GRAPH_UPDATE\" | \"INVALID_GRAPH_NODE_RETURN_VALUE\" | \"MISSING_CHECKPOINTER\" | \"MULTIPLE_SUBGRAPHS\" | \"UNREACHABLE_NODE\";\n};\n/** @category Errors */\nexport declare class BaseLangGraphError extends Error {\n    lc_error_code?: string;\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n}\nexport declare class GraphBubbleUp extends BaseLangGraphError {\n    get is_bubble_up(): boolean;\n}\nexport declare class GraphRecursionError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class GraphValueError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class GraphInterrupt extends GraphBubbleUp {\n    interrupts: Interrupt[];\n    constructor(interrupts?: Interrupt[], fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/** Raised by a node to interrupt execution. */\nexport declare class NodeInterrupt extends GraphInterrupt {\n    constructor(message: any, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class ParentCommand extends GraphBubbleUp {\n    command: Command;\n    constructor(command: Command);\n    static get unminifiable_name(): string;\n}\nexport declare function isParentCommand(e?: unknown): e is ParentCommand;\nexport declare function isGraphBubbleUp(e?: unknown): e is GraphBubbleUp;\nexport declare function isGraphInterrupt(e?: unknown): e is GraphInterrupt;\nexport declare class EmptyInputError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class EmptyChannelError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class InvalidUpdateError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * @deprecated This exception type is no longer thrown.\n */\nexport declare class MultipleSubgraphsError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\nexport declare class UnreachableNodeError extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * Exception raised when an error occurs in the remote graph.\n */\nexport declare class RemoteException extends BaseLangGraphError {\n    constructor(message?: string, fields?: BaseLangGraphErrorFields);\n    static get unminifiable_name(): string;\n}\n/**\n * Used for subgraph detection.\n */\nexport declare const getSubgraphsSeenSet: () => any;\n"],"mappings":"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"}

package/dist/errors.js

@@ -0,0 +1,146 @@
+//#region src/errors.ts
+/** @category Errors */
+var BaseLangGraphError = class extends Error {
+	lc_error_code;
+	constructor(message, fields) {
+		let finalMessage = message ?? "";
+		if (fields?.lc_error_code) finalMessage = `${finalMessage}\n\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langgraph/${fields.lc_error_code}/\n`;
+		super(finalMessage);
+		this.lc_error_code = fields?.lc_error_code;
+	}
+};
+var GraphBubbleUp = class extends BaseLangGraphError {
+	get is_bubble_up() {
+		return true;
+	}
+};
+var GraphRecursionError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "GraphRecursionError";
+	}
+	static get unminifiable_name() {
+		return "GraphRecursionError";
+	}
+};
+var GraphValueError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "GraphValueError";
+	}
+	static get unminifiable_name() {
+		return "GraphValueError";
+	}
+};
+var GraphInterrupt = class extends GraphBubbleUp {
+	interrupts;
+	constructor(interrupts, fields) {
+		super(JSON.stringify(interrupts, null, 2), fields);
+		this.name = "GraphInterrupt";
+		this.interrupts = interrupts ?? [];
+	}
+	static get unminifiable_name() {
+		return "GraphInterrupt";
+	}
+};
+/** Raised by a node to interrupt execution. */
+var NodeInterrupt = class extends GraphInterrupt {
+	constructor(message, fields) {
+		super([{ value: message }], fields);
+		this.name = "NodeInterrupt";
+	}
+	static get unminifiable_name() {
+		return "NodeInterrupt";
+	}
+};
+var ParentCommand = class extends GraphBubbleUp {
+	command;
+	constructor(command) {
+		super();
+		this.name = "ParentCommand";
+		this.command = command;
+	}
+	static get unminifiable_name() {
+		return "ParentCommand";
+	}
+};
+function isParentCommand(e) {
+	return e !== void 0 && e.name === ParentCommand.unminifiable_name;
+}
+function isGraphBubbleUp(e) {
+	return e !== void 0 && e.is_bubble_up === true;
+}
+function isGraphInterrupt(e) {
+	return e !== void 0 && [GraphInterrupt.unminifiable_name, NodeInterrupt.unminifiable_name].includes(e.name);
+}
+var EmptyInputError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "EmptyInputError";
+	}
+	static get unminifiable_name() {
+		return "EmptyInputError";
+	}
+};
+var EmptyChannelError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "EmptyChannelError";
+	}
+	static get unminifiable_name() {
+		return "EmptyChannelError";
+	}
+};
+var InvalidUpdateError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "InvalidUpdateError";
+	}
+	static get unminifiable_name() {
+		return "InvalidUpdateError";
+	}
+};
+/**
+* @deprecated This exception type is no longer thrown.
+*/
+var MultipleSubgraphsError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "MultipleSubgraphError";
+	}
+	static get unminifiable_name() {
+		return "MultipleSubgraphError";
+	}
+};
+var UnreachableNodeError = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "UnreachableNodeError";
+	}
+	static get unminifiable_name() {
+		return "UnreachableNodeError";
+	}
+};
+/**
+* Exception raised when an error occurs in the remote graph.
+*/
+var RemoteException = class extends BaseLangGraphError {
+	constructor(message, fields) {
+		super(message, fields);
+		this.name = "RemoteException";
+	}
+	static get unminifiable_name() {
+		return "RemoteException";
+	}
+};
+/**
+* Used for subgraph detection.
+*/
+const getSubgraphsSeenSet = () => {
+	if (globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] === void 0) globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] = /* @__PURE__ */ new Set();
+	return globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")];
+};
+
+//#endregion
+export { BaseLangGraphError, EmptyChannelError, EmptyInputError, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt, ParentCommand, RemoteException, UnreachableNodeError, getSubgraphsSeenSet, isGraphBubbleUp, isGraphInterrupt, isParentCommand };
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import { Command, Interrupt } from \"./constants.js\";\n\n// When editing, make sure to update the index found here:\n// https://langchain-ai.github.io/langgraphjs/troubleshooting/errors/\nexport type BaseLangGraphErrorFields = {\n  lc_error_code?:\n    | \"GRAPH_RECURSION_LIMIT\"\n    | \"INVALID_CONCURRENT_GRAPH_UPDATE\"\n    | \"INVALID_GRAPH_NODE_RETURN_VALUE\"\n    | \"MISSING_CHECKPOINTER\"\n    | \"MULTIPLE_SUBGRAPHS\"\n    | \"UNREACHABLE_NODE\";\n};\n\n// TODO: Merge with base LangChain error class when we drop support for core@0.2.0\n/** @category Errors */\nexport class BaseLangGraphError extends Error {\n  lc_error_code?: string;\n\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    let finalMessage = message ?? \"\";\n    if (fields?.lc_error_code) {\n      finalMessage = `${finalMessage}\\n\\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langgraph/${fields.lc_error_code}/\\n`;\n    }\n    super(finalMessage);\n    this.lc_error_code = fields?.lc_error_code;\n  }\n}\n\nexport class GraphBubbleUp extends BaseLangGraphError {\n  get is_bubble_up() {\n    return true;\n  }\n}\n\nexport class GraphRecursionError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"GraphRecursionError\";\n  }\n\n  static get unminifiable_name() {\n    return \"GraphRecursionError\";\n  }\n}\n\nexport class GraphValueError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"GraphValueError\";\n  }\n\n  static get unminifiable_name() {\n    return \"GraphValueError\";\n  }\n}\n\nexport class GraphInterrupt extends GraphBubbleUp {\n  interrupts: Interrupt[];\n\n  constructor(interrupts?: Interrupt[], fields?: BaseLangGraphErrorFields) {\n    super(JSON.stringify(interrupts, null, 2), fields);\n    this.name = \"GraphInterrupt\";\n    this.interrupts = interrupts ?? [];\n  }\n\n  static get unminifiable_name() {\n    return \"GraphInterrupt\";\n  }\n}\n\n/** Raised by a node to interrupt execution. */\nexport class NodeInterrupt extends GraphInterrupt {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  constructor(message: any, fields?: BaseLangGraphErrorFields) {\n    super([{ value: message }], fields);\n    this.name = \"NodeInterrupt\";\n  }\n\n  static get unminifiable_name() {\n    return \"NodeInterrupt\";\n  }\n}\n\nexport class ParentCommand extends GraphBubbleUp {\n  command: Command;\n\n  constructor(command: Command) {\n    super();\n    this.name = \"ParentCommand\";\n    this.command = command;\n  }\n\n  static get unminifiable_name() {\n    return \"ParentCommand\";\n  }\n}\n\nexport function isParentCommand(e?: unknown): e is ParentCommand {\n  return (\n    e !== undefined &&\n    (e as ParentCommand).name === ParentCommand.unminifiable_name\n  );\n}\n\nexport function isGraphBubbleUp(e?: unknown): e is GraphBubbleUp {\n  return e !== undefined && (e as GraphBubbleUp).is_bubble_up === true;\n}\n\nexport function isGraphInterrupt(e?: unknown): e is GraphInterrupt {\n  return (\n    e !== undefined &&\n    [\n      GraphInterrupt.unminifiable_name,\n      NodeInterrupt.unminifiable_name,\n    ].includes((e as Error).name)\n  );\n}\n\nexport class EmptyInputError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"EmptyInputError\";\n  }\n\n  static get unminifiable_name() {\n    return \"EmptyInputError\";\n  }\n}\n\nexport class EmptyChannelError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"EmptyChannelError\";\n  }\n\n  static get unminifiable_name() {\n    return \"EmptyChannelError\";\n  }\n}\n\nexport class InvalidUpdateError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"InvalidUpdateError\";\n  }\n\n  static get unminifiable_name() {\n    return \"InvalidUpdateError\";\n  }\n}\n\n/**\n * @deprecated This exception type is no longer thrown.\n */\nexport class MultipleSubgraphsError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"MultipleSubgraphError\";\n  }\n\n  static get unminifiable_name() {\n    return \"MultipleSubgraphError\";\n  }\n}\n\nexport class UnreachableNodeError extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"UnreachableNodeError\";\n  }\n\n  static get unminifiable_name() {\n    return \"UnreachableNodeError\";\n  }\n}\n\n/**\n * Exception raised when an error occurs in the remote graph.\n */\nexport class RemoteException extends BaseLangGraphError {\n  constructor(message?: string, fields?: BaseLangGraphErrorFields) {\n    super(message, fields);\n    this.name = \"RemoteException\";\n  }\n\n  static get unminifiable_name() {\n    return \"RemoteException\";\n  }\n}\n\n/**\n * Used for subgraph detection.\n */\nexport const getSubgraphsSeenSet = () => {\n  if (\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (globalThis as any)[Symbol.for(\"LG_CHECKPOINT_SEEN_NS_SET\")] === undefined\n  ) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (globalThis as any)[Symbol.for(\"LG_CHECKPOINT_SEEN_NS_SET\")] = new Set();\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (globalThis as any)[Symbol.for(\"LG_CHECKPOINT_SEEN_NS_SET\")];\n};\n"],"mappings":";;AAgBA,IAAa,qBAAb,cAAwC,MAAM;CAC5C;CAEA,YAAY,SAAkB,QAAmC;EAC/D,IAAI,eAAe,WAAW;AAC9B,MAAI,QAAQ,cACV,gBAAe,GAAG,aAAa,+EAA+E,OAAO,cAAc;AAErI,QAAM,aAAa;AACnB,OAAK,gBAAgB,QAAQ;;;AAIjC,IAAa,gBAAb,cAAmC,mBAAmB;CACpD,IAAI,eAAe;AACjB,SAAO;;;AAIX,IAAa,sBAAb,cAAyC,mBAAmB;CAC1D,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,iBAAb,cAAoC,cAAc;CAChD;CAEA,YAAY,YAA0B,QAAmC;AACvE,QAAM,KAAK,UAAU,YAAY,MAAM,EAAE,EAAE,OAAO;AAClD,OAAK,OAAO;AACZ,OAAK,aAAa,cAAc,EAAE;;CAGpC,WAAW,oBAAoB;AAC7B,SAAO;;;;AAKX,IAAa,gBAAb,cAAmC,eAAe;CAEhD,YAAY,SAAc,QAAmC;AAC3D,QAAM,CAAC,EAAE,OAAO,SAAS,CAAC,EAAE,OAAO;AACnC,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,gBAAb,cAAmC,cAAc;CAC/C;CAEA,YAAY,SAAkB;AAC5B,SAAO;AACP,OAAK,OAAO;AACZ,OAAK,UAAU;;CAGjB,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,SAAgB,gBAAgB,GAAiC;AAC/D,QACE,MAAM,UACL,EAAoB,SAAS,cAAc;;AAIhD,SAAgB,gBAAgB,GAAiC;AAC/D,QAAO,MAAM,UAAc,EAAoB,iBAAiB;;AAGlE,SAAgB,iBAAiB,GAAkC;AACjE,QACE,MAAM,UACN,CACE,eAAe,mBACf,cAAc,kBACf,CAAC,SAAU,EAAY,KAAK;;AAIjC,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,oBAAb,cAAuC,mBAAmB;CACxD,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,qBAAb,cAAwC,mBAAmB;CACzD,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;;;;AAOX,IAAa,yBAAb,cAA4C,mBAAmB;CAC7D,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;AAIX,IAAa,uBAAb,cAA0C,mBAAmB;CAC3D,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;;;;AAOX,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YAAY,SAAkB,QAAmC;AAC/D,QAAM,SAAS,OAAO;AACtB,OAAK,OAAO;;CAGd,WAAW,oBAAoB;AAC7B,SAAO;;;;;;AAOX,MAAa,4BAA4B;AACvC,KAEG,WAAmB,OAAO,IAAI,4BAA4B,MAAM,OAGjE,CAAC,WAAmB,OAAO,IAAI,4BAA4B,oBAAI,IAAI,KAAK;AAG1E,QAAQ,WAAmB,OAAO,IAAI,4BAA4B"}

package/dist/func/index.cjs

@@ -0,0 +1,299 @@
+const require_last_value = require('../channels/last_value.cjs');
+const require_constants = require('../constants.cjs');
+const require_utils = require('../utils.cjs');
+const require_write = require('../pregel/write.cjs');
+const require_read = require('../pregel/read.cjs');
+const require_call = require('../pregel/call.cjs');
+const require_pregel_index = require('../pregel/index.cjs');
+const require_ephemeral_value = require('../channels/ephemeral_value.cjs');
+let _langchain_core_singletons = require("@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 (require_utils.isAsyncGeneratorFunction(func) || require_utils.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 require_call.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 (require_utils.isAsyncGeneratorFunction(func) || require_utils.isGeneratorFunction(func)) throw new Error("Generators are disallowed as entrypoints. For streaming responses, use config.write.");
+	const streamMode = "updates";
+	const bound = require_call.getRunnableForEntrypoint(name, func);
+	function isEntrypointFinal(value) {
+		return typeof value === "object" && value !== null && "__lg_type" in value && value.__lg_type === "__pregel_final";
+	}
+	const pluckReturnValue = new require_utils.RunnableCallable({
+		name: "pluckReturnValue",
+		func: (value) => {
+			return isEntrypointFinal(value) ? value.value : value;
+		}
+	});
+	const pluckSaveValue = new require_utils.RunnableCallable({
+		name: "pluckSaveValue",
+		func: (value) => {
+			return isEntrypointFinal(value) ? value.save : value;
+		}
+	});
+	const entrypointNode = new require_read.PregelNode({
+		bound,
+		triggers: [require_constants.START],
+		channels: [require_constants.START],
+		writers: [new require_write.ChannelWrite([{
+			channel: require_constants.END,
+			value: require_write.PASSTHROUGH,
+			mapper: pluckReturnValue
+		}, {
+			channel: require_constants.PREVIOUS,
+			value: require_write.PASSTHROUGH,
+			mapper: pluckSaveValue
+		}], [require_constants.TAG_HIDDEN])]
+	});
+	return new require_pregel_index.Pregel({
+		name,
+		checkpointer,
+		nodes: { [name]: entrypointNode },
+		channels: {
+			[require_constants.START]: new require_ephemeral_value.EphemeralValue(),
+			[require_constants.END]: new require_last_value.LastValue(),
+			[require_constants.PREVIOUS]: new require_last_value.LastValue()
+		},
+		inputChannels: require_constants.START,
+		outputChannels: require_constants.END,
+		streamChannels: require_constants.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() {
+	return _langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig().configurable?.[require_constants.CONFIG_KEY_PREVIOUS_STATE];
+}
+
+//#endregion
+exports.entrypoint = entrypoint;
+exports.getPreviousState = getPreviousState;
+exports.task = task;
+//# sourceMappingURL=index.cjs.map

package/dist/func/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["isAsyncGeneratorFunction","isGeneratorFunction","call","entrypoint","getRunnableForEntrypoint","RunnableCallable","PregelNode","START","ChannelWrite","END","PASSTHROUGH","PREVIOUS","TAG_HIDDEN","Pregel","EphemeralValue","LastValue","AsyncLocalStorageProviderSingleton","CONFIG_KEY_PREVIOUS_STATE"],"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;EAAW,GACjE;CAEN,MAAM,EAAE,MAAM,UAAU;AACxB,KAAIA,uCAAyB,KAAK,IAAIC,kCAAoB,KAAK,CAC7D,OAAM,IAAI,MACR,iFACD;CAGH,MAAM,cACJ,QAAQ,gBAGP,WAAW,UAAW,QAAQ,QAAwB;CAEzD,IAAI;AACJ,KAAI,OAAO,gBAAgB,UACzB,SAAQ,cAAc,EAAE,GAAG;KAE3B,SAAQ;AAGV,SAAQ,GAAG,SAAgB;AACzB,SAAOC,kBAAK;GAAE;GAAM;GAAM;GAAO;GAAO,EAAE,GAAG,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkNtD,MAAa,aAAa,SAASC,aACjC,eACA,MACA;CACA,MAAM,EAAE,MAAM,cAAc,OAAO,UACjC,OAAO,kBAAkB,WACrB;EAAE,MAAM;EAAe,cAAc;EAAW,OAAO;EAAW,GAClE;AACN,KAAIH,uCAAyB,KAAK,IAAIC,kCAAoB,KAAK,CAC7D,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,aAAa;CACnB,MAAM,QAAQG,sCAAyB,MAAM,KAAK;CAGlD,SAAS,kBACP,OAC4C;AAC5C,SACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,MAAM,cAAc;;CAKxB,MAAM,mBAAmB,IAAIC,+BAAiB;EAC5C,MAAM;EACN,OAAO,UAAmB;AACxB,UAAO,kBAAkB,MAAM,GAAG,MAAM,QAAQ;;EAEnD,CAAC;CAGF,MAAM,iBAAiB,IAAIA,+BAAiB;EAC1C,MAAM;EACN,OAAO,UAAmB;AACxB,UAAO,kBAAkB,MAAM,GAAG,MAAM,OAAO;;EAElD,CAAC;CAEF,MAAM,iBAAiB,IAAIC,wBAA+C;EACxE;EACA,UAAU,CAACC,wBAAM;EACjB,UAAU,CAACA,wBAAM;EACjB,SAAS,CACP,IAAIC,2BACF,CACE;GAAE,SAASC;GAAK,OAAOC;GAAa,QAAQ;GAAkB,EAC9D;GAAE,SAASC;GAAU,OAAOD;GAAa,QAAQ;GAAgB,CAClE,EACD,CAACE,6BAAW,CACb,CACF;EACF,CAAC;AAEF,QAAO,IAAIC,4BAUT;EACA;EACA;EACA,OAAO,GACJ,OAAO,gBACT;EACD,UAAU;IACPN,0BAAQ,IAAIO,wCAAwB;IACpCL,wBAAM,IAAIM,8BAAuC;IACjDJ,6BAAW,IAAII,8BAA0C;GAC3D;EACD,eAAeR;EACf,gBAAgBE;EAChB,gBAAgBA;EAChB;EACA;EACA;EACD,CAAC;;AAIJ,WAAW,QAAQ,SAAS,MAAqB,EAC/C,OACA,QAIiC;AACjC,QAAO;EAAE;EAAO;EAAM,WAAW;EAAkB;;;;;;;;;;;;;;;;;;;AAoBrD,SAAgB,mBAAmC;AAGjD,QADEO,8DAAmC,mBAAmB,CAC1C,eAAeC"}