@langchain/langgraph 1.0.12 → 1.0.14

package/dist/graph/annotation.d.cts

@@ -0,0 +1,116 @@
+import { BaseChannel } from "../channels/base.cjs";
+import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.cjs";
+import { LastValue } from "../channels/last_value.cjs";
+import { RunnableLike } from "../pregel/runnable_types.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,gBALwB,CAAA,CAAA,CAAA,GAKFC,CALE,SAKQT,WALR,GAKsBS,CALtB,CAAA,WAAA,CAAA,GAKuCA,CALvC,UAAA,GAAA,GAKuDT,WALvD,IAKqEU,UALrE,CAKgFD,CALhF,CAAA,CAAA,WAAA,CAAA,GAAA,KAAA;AAE7B,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;AAAgC,KAOvCM,UAPuC,CAAA,WAOjBC,eAPiB,CAAA,GAAA,UAE9CC,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

@@ -0,0 +1,116 @@
+import { BaseChannel } from "../channels/base.js";
+import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.js";
+import { LastValue } from "../channels/last_value.js";
+import { RunnableLike } from "../pregel/runnable_types.js";
+
+//#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.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"annotation.d.ts","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,gBALwB,CAAA,CAAA,CAAA,GAKFC,CALE,SAKQT,WALR,GAKsBS,CALtB,CAAA,WAAA,CAAA,GAKuCA,CALvC,UAAA,GAAA,GAKuDT,WALvD,IAKqEU,UALrE,CAKgFD,CALhF,CAAA,CAAA,WAAA,CAAA,GAAA,KAAA;AAE7B,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;AAAgC,KAOvCM,UAPuC,CAAA,WAOjBC,eAPiB,CAAA,GAAA,UAE9CC,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.js

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

package/dist/graph/annotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation.js","names":[],"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,MAAa,aAAiC,SAI5C,YACoC;AACpC,KAAI,WACF,QAAO,WAAkC,WAAW;KAGpD,QAAO,IAAI,WAAsB;;AAIrC,WAAW,QAAmC,OAAU,IAAI,eAAe,GAAG;AAE9E,SAAgB,WACd,SACmB;AACnB,KACE,OAAO,YAAY,YACnB,WACA,aAAa,WACb,QAAQ,QAER,QAAO,IAAI,wBAAwB,QAAQ,SAAS,QAAQ,QAAQ;AAEtE,KACE,OAAO,YAAY,YACnB,WACA,WAAW,WACX,QAAQ,MAER,QAAO,IAAI,wBAAwB,QAAQ,OAAO,QAAQ,QAAQ;AAGpE,QAAO,IAAI,WAAc"}