@langchain/langgraph 1.0.12 → 1.0.13

package/dist/graph/messages_annotation.d.cts

@@ -0,0 +1,112 @@
+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_messages29 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_messages29.MessageStructure<_langchain_core_messages29.MessageToolSet>, _langchain_core_messages29.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_messages29.MessageStructure<_langchain_core_messages29.MessageToolSet>, _langchain_core_messages29.MessageType>[], z.ZodTypeDef, BaseMessage<_langchain_core_messages29.MessageStructure<_langchain_core_messages29.MessageToolSet>, _langchain_core_messages29.MessageType>[]>, _langchain_core_utils_types0.InteropZodType<Messages>>;
+}, "strip", z.ZodTypeAny, {
+  messages: BaseMessage<_langchain_core_messages29.MessageStructure<_langchain_core_messages29.MessageToolSet>, _langchain_core_messages29.MessageType>[];
+}, {
+  messages: BaseMessage<_langchain_core_messages29.MessageStructure<_langchain_core_messages29.MessageToolSet>, _langchain_core_messages29.MessageType>[];
+}>;
+//#endregion
+export { MessagesAnnotation, MessagesZodMeta, MessagesZodState };
+//# sourceMappingURL=messages_annotation.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages_annotation.d.cts","names":["___web_js7","__annotation_js0","_langchain_core_utils_types0","__zod_meta_js0","BaseMessage","z","Messages","SchemaMeta","MessagesAnnotation","_langchain_core_messages29","MessageToolSet","MessageStructure","MessageType","BinaryOperatorAggregate","AnnotationRoot","MessagesZodMeta","MessagesZodState","ZodTypeDef","ZodType","InteropZodType","ReducedZodChannel","ZodTypeAny","ZodObject"],"sources":["../../src/graph/messages_annotation.d.ts"],"sourcesContent":["import { 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\").MessageToolSet>, 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\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, 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\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[];\n}, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[];\n}>;\n"],"mappings":";;;;;;;;;;;;;;;;;AAuCA;;;;;;;;;;AAgBA;;;;;;AAwCA;;;;;;;;;;;;;AAC4dE,cAzDvcM,kBAyDgbW,EAxD5YlB,cAwD4YkB,CAAAA;UAAchB,EAxD1OH,uBAwD0OG,CAxDzZC,WAwDyZD,CAxDxSM,0BAAAA,CAAlEE,gBAwD0WR,CAvDjdM,0BAAAA,CAD2JC,cAAAA,CAwDsTP,EAxD1VM,0BAAAA,CAAwFG,WAAAA,CAwDkQT,EAAAA,EAxDlPG,QAwDkPH,CAAAA;;;;;;;;;;;;;;;cAzC9bY,iBAAiBR,WAAWH,eAAeE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwC3CU,kBAAkBX,CAAAA,CAAEiB;YAC0anB,kBAA3ZE,CAAAA,CAAEa,QAAQd,YAAiHK,0BAAAA,CAAlEE,iBAK/GF,0BAAAA,CALmKC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,KAAgBP,CAAAA,CAAEY,YAAYb,YAAiHK,0BAAAA,CAAlEE,iBAAjDF,0BAAAA,CAAqGC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,MAA8EV,4BAAAA,CAAvBiB,eAAeb;YACxcD,CAAAA,CAAEgB;YACAjB,YAAiHK,0BAAAA,CAAlEE,iBADrCF,0BAAAA,CACyFC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA;;YAEvJR,YAAiHK,0BAAAA,CAAlEE,iBAFpCF,0BAAAA,CAEwFC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA"}

package/dist/graph/messages_annotation.d.ts

@@ -0,0 +1,112 @@
+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_messages26 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_messages26.MessageStructure<_langchain_core_messages26.MessageToolSet>, _langchain_core_messages26.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_messages26.MessageStructure<_langchain_core_messages26.MessageToolSet>, _langchain_core_messages26.MessageType>[], z.ZodTypeDef, BaseMessage<_langchain_core_messages26.MessageStructure<_langchain_core_messages26.MessageToolSet>, _langchain_core_messages26.MessageType>[]>, _langchain_core_utils_types0.InteropZodType<Messages>>;
+}, "strip", z.ZodTypeAny, {
+  messages: BaseMessage<_langchain_core_messages26.MessageStructure<_langchain_core_messages26.MessageToolSet>, _langchain_core_messages26.MessageType>[];
+}, {
+  messages: BaseMessage<_langchain_core_messages26.MessageStructure<_langchain_core_messages26.MessageToolSet>, _langchain_core_messages26.MessageType>[];
+}>;
+//#endregion
+export { MessagesAnnotation, MessagesZodMeta, MessagesZodState };
+//# sourceMappingURL=messages_annotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages_annotation.d.ts","names":["___web_js7","__annotation_js0","_langchain_core_utils_types0","__zod_meta_js0","BaseMessage","z","Messages","SchemaMeta","MessagesAnnotation","_langchain_core_messages26","MessageToolSet","MessageStructure","MessageType","BinaryOperatorAggregate","AnnotationRoot","MessagesZodMeta","MessagesZodState","ZodTypeDef","ZodType","InteropZodType","ReducedZodChannel","ZodTypeAny","ZodObject"],"sources":["../../src/graph/messages_annotation.d.ts"],"sourcesContent":["import { 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\").MessageToolSet>, 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\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, 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\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[];\n}, {\n    messages: BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[];\n}>;\n"],"mappings":";;;;;;;;;;;;;;;;;AAuCA;;;;;;;;;;AAgBA;;;;;;AAwCA;;;;;;;;;;;;;AAC4dE,cAzDvcM,kBAyDgbW,EAxD5YlB,cAwD4YkB,CAAAA;UAAchB,EAxD1OH,uBAwD0OG,CAxDzZC,WAwDyZD,CAxDxSM,0BAAAA,CAAlEE,gBAwD0WR,CAvDjdM,0BAAAA,CAD2JC,cAAAA,CAwDsTP,EAxD1VM,0BAAAA,CAAwFG,WAAAA,CAwDkQT,EAAAA,EAxDlPG,QAwDkPH,CAAAA;;;;;;;;;;;;;;;cAzC9bY,iBAAiBR,WAAWH,eAAeE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwC3CU,kBAAkBX,CAAAA,CAAEiB;YAC0anB,kBAA3ZE,CAAAA,CAAEa,QAAQd,YAAiHK,0BAAAA,CAAlEE,iBAK/GF,0BAAAA,CALmKC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,KAAgBP,CAAAA,CAAEY,YAAYb,YAAiHK,0BAAAA,CAAlEE,iBAAjDF,0BAAAA,CAAqGC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,MAA8EV,4BAAAA,CAAvBiB,eAAeb;YACxcD,CAAAA,CAAEgB;YACAjB,YAAiHK,0BAAAA,CAAlEE,iBADrCF,0BAAAA,CACyFC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA;;YAEvJR,YAAiHK,0BAAAA,CAAlEE,iBAFpCF,0BAAAA,CAEwFC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA"}

package/dist/graph/messages_annotation.js

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages_annotation.js","names":[],"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,EAAE;CAClB,CAAC,EACH,CAAC;;;;;;;;;;;;;;AAeF,MAAa,kBAAuD;CAClE,SAAS,EAAE,IAAI,sBAAsB;CACrC,iBAAiB,EAAE,gBAAgB,YAAY;CAC/C,eAAe,EAAE;CAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCD,MAAa,mBAAmB,EAAE,OAAO,EACvC,UAAU,cAAc,EAAE,QAAuB,EAAE,gBAAgB,EACpE,CAAC"}