@langchain/langgraph 1.0.7 → 1.0.12

package/dist/graph/annotation.d.cts

@@ -1,116 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,116 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,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.js

@@ -1,99 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"annotation.js","names":["Annotation: AnnotationFunction"],"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,IAAI;;AAIf,WAAW,QAAmC,OAAU,IAAI,eAAe;AAE3E,SAAgB,WACd,SACmB;AACnB,KACE,OAAO,YAAY,YACnB,WACA,aAAa,WACb,QAAQ,QAER,QAAO,IAAI,wBAAwB,QAAQ,SAAS,QAAQ;AAE9D,KACE,OAAO,YAAY,YACnB,WACA,WAAW,WACX,QAAQ,MAER,QAAO,IAAI,wBAAwB,QAAQ,OAAO,QAAQ;AAG5D,QAAO,IAAI"}