@langchain/langgraph 1.0.6 → 1.0.12

package/dist/graph/messages_annotation.d.cts

@@ -1,112 +0,0 @@
-import { BinaryOperatorAggregate } from "../channels/binop.cjs";
-import { ReducedZodChannel, SchemaMeta } from "./zod/meta.cjs";
-import { AnnotationRoot } from "./annotation.cjs";
-import { Messages } from "./message.cjs";
-import * as _langchain_core_utils_types0 from "@langchain/core/utils/types";
-import * as _langchain_core_messages0 from "@langchain/core/messages";
-import { BaseMessage } from "@langchain/core/messages";
-import { z } from "zod/v3";
-
-//#region src/graph/messages_annotation.d.ts
-
-/**
- * Prebuilt state annotation that combines returned messages.
- * Can handle standard messages and special modifiers like {@link RemoveMessage}
- * instances.
- *
- * Specifically, importing and using the prebuilt MessagesAnnotation like this:
- *
- * @example
- * ```ts
- * import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
- *
- * const graph = new StateGraph(MessagesAnnotation)
- *   .addNode(...)
- *   ...
- * ```
- *
- * Is equivalent to initializing your state manually like this:
- *
- * @example
- * ```ts
- * import { BaseMessage } from "@langchain/core/messages";
- * import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
- *
- * export const StateAnnotation = Annotation.Root({
- *   messages: Annotation<BaseMessage[]>({
- *     reducer: messagesStateReducer,
- *     default: () => [],
- *   }),
- * });
- *
- * const graph = new StateGraph(StateAnnotation)
- *   .addNode(...)
- *   ...
- * ```
- */
-declare const MessagesAnnotation: AnnotationRoot<{
-  messages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[], Messages>;
-}>;
-/**
- * Prebuilt schema meta for Zod state definition.
- *
- * @example
- * ```ts
- * import { z } from "zod/v4-mini";
- * import { MessagesZodState, StateGraph } from "@langchain/langgraph";
- *
- * const AgentState = z.object({
- *   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),
- * });
- * ```
- */
-declare const MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>;
-/**
- * Prebuilt state object that uses Zod to combine returned messages.
- * This utility is synonymous with the `MessagesAnnotation` annotation,
- * but uses Zod as the way to express messages state.
- *
- * You can use import and use this prebuilt schema like this:
- *
- * @example
- * ```ts
- * import { MessagesZodState, StateGraph } from "@langchain/langgraph";
- *
- * const graph = new StateGraph(MessagesZodState)
- *   .addNode(...)
- *   ...
- * ```
- *
- * Which is equivalent to initializing the schema object manually like this:
- *
- * @example
- * ```ts
- * import { z } from "zod";
- * import type { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
- * import { StateGraph, messagesStateReducer } from "@langchain/langgraph";
- * import "@langchain/langgraph/zod";
- *
- * const AgentState = z.object({
- *   messages: z
- *     .custom<BaseMessage[]>()
- *     .default(() => [])
- *     .langgraph.reducer(
- *        messagesStateReducer,
- *        z.custom<BaseMessageLike | BaseMessageLike[]>()
- *     ),
- * });
- * const graph = new StateGraph(AgentState)
- *   .addNode(...)
- *   ...
- * ```
- */
-declare const MessagesZodState: z.ZodObject<{
-  messages: ReducedZodChannel<z.ZodType<BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[], z.ZodTypeDef, BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[]>, _langchain_core_utils_types0.InteropZodType<Messages>>;
-}, "strip", z.ZodTypeAny, {
-  messages: BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[];
-}, {
-  messages: BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[];
-}>;
-//#endregion
-export { MessagesAnnotation, MessagesZodMeta, MessagesZodState };
-//# sourceMappingURL=messages_annotation.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"messages_annotation.d.cts","names":["___web_js0","__annotation_js0","_langchain_core_utils_types0","__zod_meta_js0","BaseMessage","z","Messages","SchemaMeta","MessagesAnnotation","_langchain_core_messages0","MessageStructure","MessageType","BinaryOperatorAggregate","AnnotationRoot","MessagesZodMeta","MessagesZodState","ZodTypeDef","ZodType","InteropZodType","ReducedZodChannel","ZodTypeAny","ZodObject"],"sources":["../../src/graph/messages_annotation.d.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport { Messages } from \"./message.js\";\nimport { SchemaMeta } from \"./zod/meta.js\";\n/**\n * Prebuilt state annotation that combines returned messages.\n * Can handle standard messages and special modifiers like {@link RemoveMessage}\n * instances.\n *\n * Specifically, importing and using the prebuilt MessagesAnnotation like this:\n *\n * @example\n * ```ts\n * import { MessagesAnnotation, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Is equivalent to initializing your state manually like this:\n *\n * @example\n * ```ts\n * import { BaseMessage } from \"@langchain/core/messages\";\n * import { Annotation, StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n *\n * export const StateAnnotation = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: messagesStateReducer,\n *     default: () => [],\n *   }),\n * });\n *\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport declare const MessagesAnnotation: import(\"./annotation.js\").AnnotationRoot<{\n    messages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n}>;\n/**\n * Prebuilt schema meta for Zod state definition.\n *\n * @example\n * ```ts\n * import { z } from \"zod/v4-mini\";\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const AgentState = z.object({\n *   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),\n * });\n * ```\n */\nexport declare const MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>;\n/**\n * Prebuilt state object that uses Zod to combine returned messages.\n * This utility is synonymous with the `MessagesAnnotation` annotation,\n * but uses Zod as the way to express messages state.\n *\n * You can use import and use this prebuilt schema like this:\n *\n * @example\n * ```ts\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesZodState)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Which is equivalent to initializing the schema object manually like this:\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import type { BaseMessage, BaseMessageLike } from \"@langchain/core/messages\";\n * import { StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n * import \"@langchain/langgraph/zod\";\n *\n * const AgentState = z.object({\n *   messages: z\n *     .custom<BaseMessage[]>()\n *     .default(() => [])\n *     .langgraph.reducer(\n *        messagesStateReducer,\n *        z.custom<BaseMessageLike | BaseMessageLike[]>()\n *     ),\n * });\n * const graph = new StateGraph(AgentState)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport declare const MessagesZodState: z.ZodObject<{\n    messages: import(\"./zod/meta.js\").ReducedZodChannel<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[]>, import(\"@langchain/core/utils/types\").InteropZodType<Messages>>;\n}, \"strip\", z.ZodTypeAny, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[];\n}, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[];\n}>;\n"],"mappings":";;;;;;;;;;;;;;;;AAwCA;;;;;;;;;AAgBA;;;;;;AAwCA;;;;;;;;;;;;;;;AAG6ES,cA3DxDD,kBA2D6FG,gBAAAA,CAAAA;UAApGP,yBAAAA,CA1D4CA,WA0D5CA,CAzDZK,yBAAAA,CADuGC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,CA0DhJP,EAAAA,EA1DgKE,QA0DhKF,CAAAA;;;;;;;;;;;;;;;cA3COU,iBAAiBP,WAAWH,eAAeE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwC3CS,kBAAkBV,CAAAA,CAAEgB;8BACehB,CAAAA,CAAEY,QAAQb,YAKhEK,yBAAAA,CAL+GC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,KAAgBN,CAAAA,CAAEW,YAAYZ,YAAFK,yBAAAA,CAAiDC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,MAA8ET,4BAAAA,CAAvBgB,eAAeZ;YAClWD,CAAAA,CAAEe;YACAhB,YADUK,yBAAAA,CACqCC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA;;YAEpGP,YAFWK,yBAAAA,CAEoCC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA"}

package/dist/graph/messages_annotation.d.ts

@@ -1,112 +0,0 @@
-import { BinaryOperatorAggregate } from "../channels/binop.js";
-import { ReducedZodChannel, SchemaMeta } from "./zod/meta.js";
-import { AnnotationRoot } from "./annotation.js";
-import { Messages } from "./message.js";
-import * as _langchain_core_messages1 from "@langchain/core/messages";
-import { BaseMessage } from "@langchain/core/messages";
-import * as _langchain_core_utils_types0 from "@langchain/core/utils/types";
-import { z } from "zod/v3";
-
-//#region src/graph/messages_annotation.d.ts
-
-/**
- * Prebuilt state annotation that combines returned messages.
- * Can handle standard messages and special modifiers like {@link RemoveMessage}
- * instances.
- *
- * Specifically, importing and using the prebuilt MessagesAnnotation like this:
- *
- * @example
- * ```ts
- * import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
- *
- * const graph = new StateGraph(MessagesAnnotation)
- *   .addNode(...)
- *   ...
- * ```
- *
- * Is equivalent to initializing your state manually like this:
- *
- * @example
- * ```ts
- * import { BaseMessage } from "@langchain/core/messages";
- * import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
- *
- * export const StateAnnotation = Annotation.Root({
- *   messages: Annotation<BaseMessage[]>({
- *     reducer: messagesStateReducer,
- *     default: () => [],
- *   }),
- * });
- *
- * const graph = new StateGraph(StateAnnotation)
- *   .addNode(...)
- *   ...
- * ```
- */
-declare const MessagesAnnotation: AnnotationRoot<{
-  messages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[], Messages>;
-}>;
-/**
- * Prebuilt schema meta for Zod state definition.
- *
- * @example
- * ```ts
- * import { z } from "zod/v4-mini";
- * import { MessagesZodState, StateGraph } from "@langchain/langgraph";
- *
- * const AgentState = z.object({
- *   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),
- * });
- * ```
- */
-declare const MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>;
-/**
- * Prebuilt state object that uses Zod to combine returned messages.
- * This utility is synonymous with the `MessagesAnnotation` annotation,
- * but uses Zod as the way to express messages state.
- *
- * You can use import and use this prebuilt schema like this:
- *
- * @example
- * ```ts
- * import { MessagesZodState, StateGraph } from "@langchain/langgraph";
- *
- * const graph = new StateGraph(MessagesZodState)
- *   .addNode(...)
- *   ...
- * ```
- *
- * Which is equivalent to initializing the schema object manually like this:
- *
- * @example
- * ```ts
- * import { z } from "zod";
- * import type { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
- * import { StateGraph, messagesStateReducer } from "@langchain/langgraph";
- * import "@langchain/langgraph/zod";
- *
- * const AgentState = z.object({
- *   messages: z
- *     .custom<BaseMessage[]>()
- *     .default(() => [])
- *     .langgraph.reducer(
- *        messagesStateReducer,
- *        z.custom<BaseMessageLike | BaseMessageLike[]>()
- *     ),
- * });
- * const graph = new StateGraph(AgentState)
- *   .addNode(...)
- *   ...
- * ```
- */
-declare const MessagesZodState: z.ZodObject<{
-  messages: ReducedZodChannel<z.ZodType<BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[], z.ZodTypeDef, BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[]>, _langchain_core_utils_types0.InteropZodType<Messages>>;
-}, "strip", z.ZodTypeAny, {
-  messages: BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[];
-}, {
-  messages: BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[];
-}>;
-//#endregion
-export { MessagesAnnotation, MessagesZodMeta, MessagesZodState };
-//# sourceMappingURL=messages_annotation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"messages_annotation.d.ts","names":["___web_js0","__annotation_js0","_langchain_core_utils_types0","__zod_meta_js0","BaseMessage","z","Messages","SchemaMeta","MessagesAnnotation","_langchain_core_messages1","MessageStructure","MessageType","BinaryOperatorAggregate","AnnotationRoot","MessagesZodMeta","MessagesZodState","ZodTypeDef","ZodType","InteropZodType","ReducedZodChannel","ZodTypeAny","ZodObject"],"sources":["../../src/graph/messages_annotation.d.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport { Messages } from \"./message.js\";\nimport { SchemaMeta } from \"./zod/meta.js\";\n/**\n * Prebuilt state annotation that combines returned messages.\n * Can handle standard messages and special modifiers like {@link RemoveMessage}\n * instances.\n *\n * Specifically, importing and using the prebuilt MessagesAnnotation like this:\n *\n * @example\n * ```ts\n * import { MessagesAnnotation, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Is equivalent to initializing your state manually like this:\n *\n * @example\n * ```ts\n * import { BaseMessage } from \"@langchain/core/messages\";\n * import { Annotation, StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n *\n * export const StateAnnotation = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: messagesStateReducer,\n *     default: () => [],\n *   }),\n * });\n *\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport declare const MessagesAnnotation: import(\"./annotation.js\").AnnotationRoot<{\n    messages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n}>;\n/**\n * Prebuilt schema meta for Zod state definition.\n *\n * @example\n * ```ts\n * import { z } from \"zod/v4-mini\";\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const AgentState = z.object({\n *   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),\n * });\n * ```\n */\nexport declare const MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>;\n/**\n * Prebuilt state object that uses Zod to combine returned messages.\n * This utility is synonymous with the `MessagesAnnotation` annotation,\n * but uses Zod as the way to express messages state.\n *\n * You can use import and use this prebuilt schema like this:\n *\n * @example\n * ```ts\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesZodState)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Which is equivalent to initializing the schema object manually like this:\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import type { BaseMessage, BaseMessageLike } from \"@langchain/core/messages\";\n * import { StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n * import \"@langchain/langgraph/zod\";\n *\n * const AgentState = z.object({\n *   messages: z\n *     .custom<BaseMessage[]>()\n *     .default(() => [])\n *     .langgraph.reducer(\n *        messagesStateReducer,\n *        z.custom<BaseMessageLike | BaseMessageLike[]>()\n *     ),\n * });\n * const graph = new StateGraph(AgentState)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport declare const MessagesZodState: z.ZodObject<{\n    messages: import(\"./zod/meta.js\").ReducedZodChannel<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[]>, import(\"@langchain/core/utils/types\").InteropZodType<Messages>>;\n}, \"strip\", z.ZodTypeAny, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[];\n}, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[];\n}>;\n"],"mappings":";;;;;;;;;;;;;;;;AAwCA;;;;;;;;;AAgBA;;;;;;AAwCA;;;;;;;;;;;;;;;AAG6ES,cA3DxDD,kBA2D6FG,gBAAAA,CAAAA;UAApGP,yBAAAA,CA1D4CA,WA0D5CA,CAzDZK,yBAAAA,CADuGC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,CA0DhJP,EAAAA,EA1DgKE,QA0DhKF,CAAAA;;;;;;;;;;;;;;;cA3COU,iBAAiBP,WAAWH,eAAeE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwC3CS,kBAAkBV,CAAAA,CAAEgB;8BACehB,CAAAA,CAAEY,QAAQb,YAKhEK,yBAAAA,CAL+GC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,KAAgBN,CAAAA,CAAEW,YAAYZ,YAAFK,yBAAAA,CAAiDC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA,MAA8ET,4BAAAA,CAAvBgB,eAAeZ;YAClWD,CAAAA,CAAEe;YACAhB,YADUK,yBAAAA,CACqCC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA;;YAEpGP,YAFWK,yBAAAA,CAEoCC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA"}

package/dist/graph/messages_annotation.js

@@ -1,107 +0,0 @@
-import { Annotation } from "./annotation.js";
-import { withLangGraph } from "./zod/meta.js";
-import { messagesStateReducer } from "./message.js";
-import { z } from "zod/v3";
-
-//#region src/graph/messages_annotation.ts
-/**
-* Prebuilt state annotation that combines returned messages.
-* Can handle standard messages and special modifiers like {@link RemoveMessage}
-* instances.
-*
-* Specifically, importing and using the prebuilt MessagesAnnotation like this:
-*
-* @example
-* ```ts
-* import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
-*
-* const graph = new StateGraph(MessagesAnnotation)
-*   .addNode(...)
-*   ...
-* ```
-*
-* Is equivalent to initializing your state manually like this:
-*
-* @example
-* ```ts
-* import { BaseMessage } from "@langchain/core/messages";
-* import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
-*
-* export const StateAnnotation = Annotation.Root({
-*   messages: Annotation<BaseMessage[]>({
-*     reducer: messagesStateReducer,
-*     default: () => [],
-*   }),
-* });
-*
-* const graph = new StateGraph(StateAnnotation)
-*   .addNode(...)
-*   ...
-* ```
-*/
-const MessagesAnnotation = Annotation.Root({ messages: Annotation({
-	reducer: messagesStateReducer,
-	default: () => []
-}) });
-/**
-* Prebuilt schema meta for Zod state definition.
-*
-* @example
-* ```ts
-* import { z } from "zod/v4-mini";
-* import { MessagesZodState, StateGraph } from "@langchain/langgraph";
-*
-* const AgentState = z.object({
-*   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),
-* });
-* ```
-*/
-const MessagesZodMeta = {
-	reducer: { fn: messagesStateReducer },
-	jsonSchemaExtra: { langgraph_type: "messages" },
-	default: () => []
-};
-/**
-* Prebuilt state object that uses Zod to combine returned messages.
-* This utility is synonymous with the `MessagesAnnotation` annotation,
-* but uses Zod as the way to express messages state.
-*
-* You can use import and use this prebuilt schema like this:
-*
-* @example
-* ```ts
-* import { MessagesZodState, StateGraph } from "@langchain/langgraph";
-*
-* const graph = new StateGraph(MessagesZodState)
-*   .addNode(...)
-*   ...
-* ```
-*
-* Which is equivalent to initializing the schema object manually like this:
-*
-* @example
-* ```ts
-* import { z } from "zod";
-* import type { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
-* import { StateGraph, messagesStateReducer } from "@langchain/langgraph";
-* import "@langchain/langgraph/zod";
-*
-* const AgentState = z.object({
-*   messages: z
-*     .custom<BaseMessage[]>()
-*     .default(() => [])
-*     .langgraph.reducer(
-*        messagesStateReducer,
-*        z.custom<BaseMessageLike | BaseMessageLike[]>()
-*     ),
-* });
-* const graph = new StateGraph(AgentState)
-*   .addNode(...)
-*   ...
-* ```
-*/
-const MessagesZodState = z.object({ messages: withLangGraph(z.custom(), MessagesZodMeta) });
-
-//#endregion
-export { MessagesAnnotation, MessagesZodMeta, MessagesZodState };
-//# sourceMappingURL=messages_annotation.js.map

package/dist/graph/messages_annotation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages_annotation.js","names":["MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>"],"sources":["../../src/graph/messages_annotation.ts"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport { Annotation } from \"./annotation.js\";\nimport { Messages, messagesStateReducer } from \"./message.js\";\nimport { SchemaMeta, withLangGraph } from \"./zod/meta.js\";\n\n/**\n * Prebuilt state annotation that combines returned messages.\n * Can handle standard messages and special modifiers like {@link RemoveMessage}\n * instances.\n *\n * Specifically, importing and using the prebuilt MessagesAnnotation like this:\n *\n * @example\n * ```ts\n * import { MessagesAnnotation, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Is equivalent to initializing your state manually like this:\n *\n * @example\n * ```ts\n * import { BaseMessage } from \"@langchain/core/messages\";\n * import { Annotation, StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n *\n * export const StateAnnotation = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: messagesStateReducer,\n *     default: () => [],\n *   }),\n * });\n *\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport const MessagesAnnotation = Annotation.Root({\n  messages: Annotation<BaseMessage[], Messages>({\n    reducer: messagesStateReducer,\n    default: () => [],\n  }),\n});\n\n/**\n * Prebuilt schema meta for Zod state definition.\n *\n * @example\n * ```ts\n * import { z } from \"zod/v4-mini\";\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const AgentState = z.object({\n *   messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),\n * });\n * ```\n */\nexport const MessagesZodMeta: SchemaMeta<BaseMessage[], Messages> = {\n  reducer: { fn: messagesStateReducer },\n  jsonSchemaExtra: { langgraph_type: \"messages\" },\n  default: () => [],\n};\n\n/**\n * Prebuilt state object that uses Zod to combine returned messages.\n * This utility is synonymous with the `MessagesAnnotation` annotation,\n * but uses Zod as the way to express messages state.\n *\n * You can use import and use this prebuilt schema like this:\n *\n * @example\n * ```ts\n * import { MessagesZodState, StateGraph } from \"@langchain/langgraph\";\n *\n * const graph = new StateGraph(MessagesZodState)\n *   .addNode(...)\n *   ...\n * ```\n *\n * Which is equivalent to initializing the schema object manually like this:\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import type { BaseMessage, BaseMessageLike } from \"@langchain/core/messages\";\n * import { StateGraph, messagesStateReducer } from \"@langchain/langgraph\";\n * import \"@langchain/langgraph/zod\";\n *\n * const AgentState = z.object({\n *   messages: z\n *     .custom<BaseMessage[]>()\n *     .default(() => [])\n *     .langgraph.reducer(\n *        messagesStateReducer,\n *        z.custom<BaseMessageLike | BaseMessageLike[]>()\n *     ),\n * });\n * const graph = new StateGraph(AgentState)\n *   .addNode(...)\n *   ...\n * ```\n */\nexport const MessagesZodState = z.object({\n  messages: withLangGraph(z.custom<BaseMessage[]>(), MessagesZodMeta),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,qBAAqB,WAAW,KAAK,EAChD,UAAU,WAAoC;CAC5C,SAAS;CACT,eAAe;;;;;;;;;;;;;;;AAiBnB,MAAaA,kBAAuD;CAClE,SAAS,EAAE,IAAI;CACf,iBAAiB,EAAE,gBAAgB;CACnC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CjB,MAAa,mBAAmB,EAAE,OAAO,EACvC,UAAU,cAAc,EAAE,UAAyB"}