@langchain/langgraph 0.4.8 → 1.0.0-alpha.0

package/dist/func/types.d.cts

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

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

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

package/dist/func/types.d.ts

@@ -1,36 +1,39 @@
 import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
+
+//#region src/func/types.d.ts
+
 /**
  * Allows the entrypoint function to return a value to the caller, as well as a separate state value to persist to the checkpoint
  */
-export type EntrypointFinal<ValueT, SaveT> = {
-    /**
-     * The value to return to the caller
-     */
-    value?: ValueT;
-    /**
-     * The value to save to the checkpoint
-     */
-    save?: SaveT;
-    __lg_type: "__pregel_final";
+type EntrypointFinal<ValueT, SaveT> = {
+  /**
+   * The value to return to the caller
+   */
+  value?: ValueT;
+  /**
+   * The value to save to the checkpoint
+   */
+  save?: SaveT;
+  __lg_type: "__pregel_final";
 };
 /**
  * Checks if a value is an EntrypointFinal - use this instead of `instanceof`, as value may have been deserialized
  * @param value The value to check
  * @returns Whether the value is an EntrypointFinal
  */
-export declare function isEntrypointFinal<ValueT, SaveT>(value: unknown): value is EntrypointFinal<ValueT, SaveT>;
+
 /**
  * The return type of an entrypoint function.
  */
-export type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;
+type EntrypointReturnT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, unknown> | Promise<EntrypointFinal<infer ValueT, unknown>> ? ValueT : OutputT;
 /**
  * The value to be saved when a function returns an EntrypointFinal.
  */
-export type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;
+type EntrypointFinalSaveT<OutputT> = OutputT extends EntrypointFinal<unknown, infer SaveT> | Promise<EntrypointFinal<unknown, infer SaveT>> ? SaveT : OutputT;
 /**
  * The value to be returned when a function returns an EntrypointFinal.
  */
-export type EntrypointFinalValueT<OutputT> = OutputT extends EntrypointFinal<infer ValueT, infer SaveT> | Promise<EntrypointFinal<infer ValueT, infer SaveT>> ? EntrypointFinal<ValueT, SaveT> : OutputT;
+
 /**
  * Checks if an AsyncGenerator exists in the ES target/lib that we're compiling to.
  *
@@ -49,11 +52,13 @@ type AsyncGeneratorExists = AsyncGenerator<unknown, unknown, unknown> extends ob
 /**
  * Matches valid function signatures for entrypoints. Disallows generator functions.
  */
-export type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;
+type EntrypointFunc<InputT, OutputT> = [OutputT] extends never ? (input: InputT, config: LangGraphRunnableConfig) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
+? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (input: InputT, config: LangGraphRunnableConfig) => OutputT;
 /**
  * Matches valid function signatures for tasks. Disallows generator functions.
  */
-export type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [
-    never
-] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true ? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;
-export {};
+type TaskFunc<ArgsT extends unknown[], OutputT> = [OutputT] extends [never] ? (...args: ArgsT) => never : AsyncGeneratorExists extends true // only check if it may be an AsyncGenerator when those actually exist
+? OutputT extends AsyncGenerator<unknown, unknown, unknown> ? never : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT : OutputT extends Generator<unknown, unknown, unknown> ? never : (...args: ArgsT) => OutputT;
+//#endregion
+export { EntrypointFinal, EntrypointFinalSaveT, EntrypointFunc, EntrypointReturnT, TaskFunc };
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/graph/annotation.cjs

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

package/dist/graph/annotation.cjs.map

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

package/dist/graph/annotation.d.cts

@@ -0,0 +1,116 @@
+import { BaseChannel } from "../channels/base.cjs";
+import { RunnableLike } from "../pregel/runnable_types.cjs";
+import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.cjs";
+import { LastValue } from "../channels/last_value.cjs";
+
+//#region src/graph/annotation.d.ts
+type SingleReducer<ValueType, UpdateType = ValueType> = {
+  reducer: BinaryOperator<ValueType, UpdateType>;
+  default?: () => ValueType;
+} | {
+  /**
+   * @deprecated Use `reducer` instead
+   */
+  value: BinaryOperator<ValueType, UpdateType>;
+  default?: () => ValueType;
+} | null;
+interface StateDefinition {
+  [key: string]: BaseChannel | (() => BaseChannel);
+}
+type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends (() => BaseChannel) ? ReturnType<C>["ValueType"] : never;
+type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends (() => BaseChannel) ? ReturnType<C>["UpdateType"] : never;
+type StateType<SD extends StateDefinition> = { [key in keyof SD]: ExtractValueType<SD[key]> };
+type UpdateType<SD extends StateDefinition> = { [key in keyof SD]?: ExtractUpdateType<SD[key]> };
+type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;
+/** @ignore */
+interface AnnotationFunction {
+  <ValueType>(): LastValue<ValueType>;
+  <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
+  Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
+}
+/**
+ * Should not be instantiated directly. See {@link Annotation}.
+ */
+declare class AnnotationRoot<SD extends StateDefinition> {
+  lc_graph_name: string;
+  State: StateType<SD>;
+  Update: UpdateType<SD>;
+  Node: NodeType<SD>;
+  spec: SD;
+  constructor(s: SD);
+}
+/**
+ * Helper that instantiates channels within a StateGraph state.
+ *
+ * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
+ * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
+ * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
+ *
+ * @example
+ * ```ts
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single string key named "currentOutput"
+ * const SimpleAnnotation = Annotation.Root({
+ *   currentOutput: Annotation<string>,
+ * });
+ *
+ * const graphBuilder = new StateGraph(SimpleAnnotation);
+ *
+ * // A node in the graph that returns an object with a "currentOutput" key
+ * // replaces the value in the state. You can get the state type as shown below:
+ * const myNode = (state: typeof SimpleAnnotation.State) => {
+ *   return {
+ *     currentOutput: "some_new_value",
+ *   };
+ * }
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { type BaseMessage, AIMessage } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const AnnotationWithReducer = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     // Different types are allowed for updates
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(AnnotationWithReducer);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof AnnotationWithReducer.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ * @namespace
+ * @property Root
+ * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
+ */
+declare const Annotation: AnnotationFunction;
+//#endregion
+export { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType };
+//# sourceMappingURL=annotation.d.cts.map

package/dist/graph/annotation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation.d.cts","names":["RunnableLike","BaseChannel","BinaryOperator","BinaryOperatorAggregate","LastValue","SingleReducer","ValueType","UpdateType","StateDefinition","ExtractValueType","C","ReturnType","ExtractUpdateType","StateType","SD","key","NodeType","Partial","AnnotationFunction","S","AnnotationRoot","Annotation","getChannel","V","U"],"sources":["../../src/graph/annotation.d.ts"],"sourcesContent":["import { RunnableLike } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { BinaryOperator, BinaryOperatorAggregate } from \"../channels/binop.js\";\nimport { LastValue } from \"../channels/last_value.js\";\nexport type SingleReducer<ValueType, UpdateType = ValueType> = {\n    reducer: BinaryOperator<ValueType, UpdateType>;\n    default?: () => ValueType;\n} | {\n    /**\n     * @deprecated Use `reducer` instead\n     */\n    value: BinaryOperator<ValueType, UpdateType>;\n    default?: () => ValueType;\n} | null;\nexport interface StateDefinition {\n    [key: string]: BaseChannel | (() => BaseChannel);\n}\ntype ExtractValueType<C> = C extends BaseChannel ? C[\"ValueType\"] : C extends () => BaseChannel ? ReturnType<C>[\"ValueType\"] : never;\ntype ExtractUpdateType<C> = C extends BaseChannel ? C[\"UpdateType\"] : C extends () => BaseChannel ? ReturnType<C>[\"UpdateType\"] : never;\nexport type StateType<SD extends StateDefinition> = {\n    [key in keyof SD]: ExtractValueType<SD[key]>;\n};\nexport type UpdateType<SD extends StateDefinition> = {\n    [key in keyof SD]?: ExtractUpdateType<SD[key]>;\n};\nexport type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;\n/** @ignore */\nexport interface AnnotationFunction {\n    <ValueType>(): LastValue<ValueType>;\n    <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;\n    Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;\n}\n/**\n * Should not be instantiated directly. See {@link Annotation}.\n */\nexport declare class AnnotationRoot<SD extends StateDefinition> {\n    lc_graph_name: string;\n    State: StateType<SD>;\n    Update: UpdateType<SD>;\n    Node: NodeType<SD>;\n    spec: SD;\n    constructor(s: SD);\n}\n/**\n * Helper that instantiates channels within a StateGraph state.\n *\n * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:\n * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.\n * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.\n *\n * @example\n * ```ts\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single string key named \"currentOutput\"\n * const SimpleAnnotation = Annotation.Root({\n *   currentOutput: Annotation<string>,\n * });\n *\n * const graphBuilder = new StateGraph(SimpleAnnotation);\n *\n * // A node in the graph that returns an object with a \"currentOutput\" key\n * // replaces the value in the state. You can get the state type as shown below:\n * const myNode = (state: typeof SimpleAnnotation.State) => {\n *   return {\n *     currentOutput: \"some_new_value\",\n *   };\n * }\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n *\n * @example\n * ```ts\n * import { type BaseMessage, AIMessage } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const AnnotationWithReducer = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     // Different types are allowed for updates\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(AnnotationWithReducer);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof AnnotationWithReducer.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n * @namespace\n * @property Root\n * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.\n */\nexport declare const Annotation: AnnotationFunction;\nexport declare function getChannel<V, U = V>(reducer: SingleReducer<V, U>): BaseChannel<V, U>;\nexport {};\n"],"mappings":";;;;;;KAIYK,sCAAsCC;WACrCJ,eAAeI,WAAWC;EAD3BF,OAAAA,CAAAA,EAAAA,GAAAA,GAEQC,SAFK;CAAA,GAAA;;;;OACZJ,EAMFA,cANEA,CAMaI,SANbJ,EAMwBK,UANxBL,CAAAA;SACOI,CAAAA,EAAAA,GAAAA,GAMAA,SANAA;QAKMA;AAAWC,UAGpBC,eAAAA,CAHoBD;MAA1BL,EAAAA,MAAAA,CAAAA,EAIQD,WAJRC,GAAAA,CAAAA,GAAAA,GAI6BD,WAJ7BC,CAAAA;;KAMNO,sBAAsBC,UAAUT,cAAcS,iBAAiBA,iBAAgBT,eAAcU,WAAWD;AAH7G,KAIKE,iBAJ2B,CAAA,CAAA,CAAA,GAIJF,CAJI,SAIMT,WAJN,GAIoBS,CAJpB,CAAA,YAAA,CAAA,GAIsCA,CAJtC,UAAA,GAAA,GAIsDT,WAJtD,IAIoEU,UAJpE,CAI+ED,CAJ/E,CAAA,CAAA,YAAA,CAAA,GAAA,KAAA;AAAA,KAKpBG,SALoB,CAAA,WAKCL,eALD,CAAA,GAAA,UACbP,MAKDa,EALCb,GAKIQ,gBALJR,CAKqBa,EALrBb,CAKwBc,GALxBd,CAAAA,CAAAA;KAOPM,sBAAsBC,6BAL7BC,MAMaK,EANbL,IAMmBG,iBANH,CAMqBE,EANrB,CAMwBC,GANxB,CAAA,CAAA,EAAA;AAAML,KAQfM,QAReN,CAAAA,WAQKF,eARLE,CAAAA,GAQwBV,YARxBU,CAQqCG,SARrCH,CAQ+CI,EAR/CJ,CAAAA,EAQoDH,UARpDG,CAQ+DI,EAR/DJ,CAAAA,GAQqEO,OARrEP,CAQ6EG,SAR7EH,CAQuFI,EARvFJ,CAAAA,CAAAA,CAAAA;;AAAwBA,UAUlCQ,kBAAAA,CAVkCR;YAAiBA,CAAAA,EAAAA,EAWjDN,SAXiDM,CAWvCJ,SAXuCI,CAAAA;YAAgBT,EAAAA,aAYvDK,SAZuDL,CAAAA,CAAAA,UAAAA,EAYhCI,aAZgCJ,CAYlBK,SAZkBL,EAYPM,UAZON,CAAAA,CAAAA,EAYOE,uBAZPF,CAY+BK,SAZ/BL,EAY0CM,UAZ1CN,CAAAA;MAAyBS,EAAAA,CAAAA,UAaxFF,eAbwFE,CAAAA,CAAAA,EAAAA,EAanES,CAbmET,EAAAA,GAa7DU,cAb6DV,CAa9CS,CAb8CT,CAAAA;;;AAAD;;AAChFA,cAiBPU,cAjBOV,CAAAA,WAiBmBF,eAjBnBE,CAAAA,CAAAA;eAAUT,EAAAA,MAAAA;OAAcS,EAmBzCG,SAnByCH,CAmB/BI,EAnB+BJ,CAAAA;QAAkBA,EAoB1DH,UApB0DG,CAoB/CI,EApB+CJ,CAAAA;MAAgBT,EAqB5Ee,QArB4Ef,CAqBnEa,EArBmEb,CAAAA;MAAyBS,EAsBrGI,EAtBqGJ;aAAXC,CAAAA,CAAAA,EAuBjFG,EAvBiFH;;AACpG;;;;;;;;AAGA;;;;;;;;AAGA;;;;;;;;;;;;AAEA;;;;;;;;;;;;;;;;AAQA;;;;;;;;;;;;AA+EA;;;;;;;;;;;;;;;cAAqBU,YAAYH"}

package/dist/graph/annotation.d.ts

@@ -1,45 +1,43 @@
-import { RunnableLike } from "../pregel/runnable_types.js";
 import { BaseChannel } from "../channels/base.js";
+import { RunnableLike } from "../pregel/runnable_types.js";
 import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.js";
 import { LastValue } from "../channels/last_value.js";
-export type SingleReducer<ValueType, UpdateType = ValueType> = {
-    reducer: BinaryOperator<ValueType, UpdateType>;
-    default?: () => ValueType;
+
+//#region src/graph/annotation.d.ts
+type SingleReducer<ValueType, UpdateType = ValueType> = {
+  reducer: BinaryOperator<ValueType, UpdateType>;
+  default?: () => ValueType;
 } | {
-    /**
-     * @deprecated Use `reducer` instead
-     */
-    value: BinaryOperator<ValueType, UpdateType>;
-    default?: () => ValueType;
+  /**
+   * @deprecated Use `reducer` instead
+   */
+  value: BinaryOperator<ValueType, UpdateType>;
+  default?: () => ValueType;
 } | null;
-export interface StateDefinition {
-    [key: string]: BaseChannel | (() => BaseChannel);
+interface StateDefinition {
+  [key: string]: BaseChannel | (() => BaseChannel);
 }
-type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends () => BaseChannel ? ReturnType<C>["ValueType"] : never;
-type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends () => BaseChannel ? ReturnType<C>["UpdateType"] : never;
-export type StateType<SD extends StateDefinition> = {
-    [key in keyof SD]: ExtractValueType<SD[key]>;
-};
-export type UpdateType<SD extends StateDefinition> = {
-    [key in keyof SD]?: ExtractUpdateType<SD[key]>;
-};
-export type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;
+type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends (() => BaseChannel) ? ReturnType<C>["ValueType"] : never;
+type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends (() => BaseChannel) ? ReturnType<C>["UpdateType"] : never;
+type StateType<SD extends StateDefinition> = { [key in keyof SD]: ExtractValueType<SD[key]> };
+type UpdateType<SD extends StateDefinition> = { [key in keyof SD]?: ExtractUpdateType<SD[key]> };
+type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;
 /** @ignore */
-export interface AnnotationFunction {
-    <ValueType>(): LastValue<ValueType>;
-    <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
-    Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
+interface AnnotationFunction {
+  <ValueType>(): LastValue<ValueType>;
+  <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
+  Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
 }
 /**
  * Should not be instantiated directly. See {@link Annotation}.
  */
-export declare class AnnotationRoot<SD extends StateDefinition> {
-    lc_graph_name: string;
-    State: StateType<SD>;
-    Update: UpdateType<SD>;
-    Node: NodeType<SD>;
-    spec: SD;
-    constructor(s: SD);
+declare class AnnotationRoot<SD extends StateDefinition> {
+  lc_graph_name: string;
+  State: StateType<SD>;
+  Update: UpdateType<SD>;
+  Node: NodeType<SD>;
+  spec: SD;
+  constructor(s: SD);
 }
 /**
  * Helper that instantiates channels within a StateGraph state.
@@ -112,6 +110,7 @@ export declare class AnnotationRoot<SD extends StateDefinition> {
  * @property Root
  * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
  */
-export declare const Annotation: AnnotationFunction;
-export declare function getChannel<V, U = V>(reducer: SingleReducer<V, U>): BaseChannel<V, U>;
-export {};
+declare const Annotation: AnnotationFunction;
+//#endregion
+export { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType };
+//# sourceMappingURL=annotation.d.ts.map