@langchain/langgraph 1.0.14 → 1.1.0

package/dist/state/adapter.d.ts

@@ -0,0 +1,33 @@
+import { SerializableSchema } from "./types.js";
+
+//#region src/state/adapter.d.ts
+
+/**
+ * Get the JSON schema from a SerializableSchema.
+ */
+declare function getJsonSchemaFromSchema(schema: SerializableSchema | unknown): Record<string, unknown> | undefined;
+/**
+ * Detect if a schema has a default value by validating `undefined`.
+ *
+ * Uses the Standard Schema `~standard.validate` API to detect defaults.
+ * If the schema accepts `undefined` and returns a value, that value is the default.
+ *
+ * This approach is library-agnostic and works with any Standard Schema compliant
+ * library (Zod, Valibot, ArkType, etc.) without needing to introspect internals.
+ *
+ * @param schema - The schema to check for a default value.
+ * @returns A factory function returning the default, or undefined if no default exists.
+ *
+ * @example
+ * ```ts
+ * const getter = getSchemaDefaultGetter(z.string().default("hello"));
+ * getter?.(); // "hello"
+ *
+ * const noDefault = getSchemaDefaultGetter(z.string());
+ * noDefault; // undefined
+ * ```
+ */
+declare function getSchemaDefaultGetter(schema: SerializableSchema | unknown): (() => unknown) | undefined;
+//#endregion
+export { getJsonSchemaFromSchema, getSchemaDefaultGetter };
+//# sourceMappingURL=adapter.d.ts.map

package/dist/state/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","names":["SerializableSchema","getJsonSchemaFromSchema","Record","getSchemaDefaultGetter"],"sources":["../../src/state/adapter.d.ts"],"sourcesContent":["/**\n * Adapter utilities for working with Standard Schema.\n */\nimport type { SerializableSchema } from \"./types.js\";\n/**\n * Get the JSON schema from a SerializableSchema.\n */\nexport declare function getJsonSchemaFromSchema(schema: SerializableSchema | unknown): Record<string, unknown> | undefined;\n/**\n * Detect if a schema has a default value by validating `undefined`.\n *\n * Uses the Standard Schema `~standard.validate` API to detect defaults.\n * If the schema accepts `undefined` and returns a value, that value is the default.\n *\n * This approach is library-agnostic and works with any Standard Schema compliant\n * library (Zod, Valibot, ArkType, etc.) without needing to introspect internals.\n *\n * @param schema - The schema to check for a default value.\n * @returns A factory function returning the default, or undefined if no default exists.\n *\n * @example\n * ```ts\n * const getter = getSchemaDefaultGetter(z.string().default(\"hello\"));\n * getter?.(); // \"hello\"\n *\n * const noDefault = getSchemaDefaultGetter(z.string());\n * noDefault; // undefined\n * ```\n */\nexport declare function getSchemaDefaultGetter(schema: SerializableSchema | unknown): (() => unknown) | undefined;\n"],"mappings":";;;;;;;AAO6F,iBAArEC,uBAAAA,CAAqE,MAAA,EAArCD,kBAAqC,GAAA,OAAA,CAAA,EAANE,MAAM,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;AAsB7F;;;;;;;;;;;;;;;;;;;;;iBAAwBC,sBAAAA,SAA+BH"}

package/dist/state/adapter.js

@@ -0,0 +1,52 @@
+import { isStandardJSONSchema, isStandardSchema } from "./types.js";
+
+//#region src/state/adapter.ts
+/**
+* Get the JSON schema from a SerializableSchema.
+*/
+function getJsonSchemaFromSchema(schema) {
+	if (isStandardJSONSchema(schema)) try {
+		return schema["~standard"].jsonSchema.input({ target: "draft-07" });
+	} catch {
+		return;
+	}
+}
+/**
+* Detect if a schema has a default value by validating `undefined`.
+*
+* Uses the Standard Schema `~standard.validate` API to detect defaults.
+* If the schema accepts `undefined` and returns a value, that value is the default.
+*
+* This approach is library-agnostic and works with any Standard Schema compliant
+* library (Zod, Valibot, ArkType, etc.) without needing to introspect internals.
+*
+* @param schema - The schema to check for a default value.
+* @returns A factory function returning the default, or undefined if no default exists.
+*
+* @example
+* ```ts
+* const getter = getSchemaDefaultGetter(z.string().default("hello"));
+* getter?.(); // "hello"
+*
+* const noDefault = getSchemaDefaultGetter(z.string());
+* noDefault; // undefined
+* ```
+*/
+function getSchemaDefaultGetter(schema) {
+	if (schema == null) return;
+	if (!isStandardSchema(schema)) return;
+	try {
+		const result = schema["~standard"].validate(void 0);
+		if (result && typeof result === "object" && !("then" in result && typeof result.then === "function")) {
+			const syncResult = result;
+			if (!syncResult.issues) {
+				const defaultValue = syncResult.value;
+				return () => defaultValue;
+			}
+		}
+	} catch {}
+}
+
+//#endregion
+export { getJsonSchemaFromSchema, getSchemaDefaultGetter };
+//# sourceMappingURL=adapter.js.map

package/dist/state/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":[],"sources":["../../src/state/adapter.ts"],"sourcesContent":["/**\n * Adapter utilities for working with Standard Schema.\n */\nimport type { SerializableSchema } from \"./types.js\";\nimport { isStandardJSONSchema, isStandardSchema } from \"./types.js\";\n\n/**\n * Get the JSON schema from a SerializableSchema.\n */\nexport function getJsonSchemaFromSchema(\n  schema: SerializableSchema | unknown\n): Record<string, unknown> | undefined {\n  if (isStandardJSONSchema(schema)) {\n    try {\n      const standard = schema[\"~standard\"];\n      return standard.jsonSchema.input({ target: \"draft-07\" });\n    } catch {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Detect if a schema has a default value by validating `undefined`.\n *\n * Uses the Standard Schema `~standard.validate` API to detect defaults.\n * If the schema accepts `undefined` and returns a value, that value is the default.\n *\n * This approach is library-agnostic and works with any Standard Schema compliant\n * library (Zod, Valibot, ArkType, etc.) without needing to introspect internals.\n *\n * @param schema - The schema to check for a default value.\n * @returns A factory function returning the default, or undefined if no default exists.\n *\n * @example\n * ```ts\n * const getter = getSchemaDefaultGetter(z.string().default(\"hello\"));\n * getter?.(); // \"hello\"\n *\n * const noDefault = getSchemaDefaultGetter(z.string());\n * noDefault; // undefined\n * ```\n */\nexport function getSchemaDefaultGetter(\n  schema: SerializableSchema | unknown\n): (() => unknown) | undefined {\n  if (schema == null) {\n    return undefined;\n  }\n\n  if (!isStandardSchema(schema)) {\n    return undefined;\n  }\n\n  try {\n    const result = schema[\"~standard\"].validate(undefined);\n\n    // Handle sync result (not a Promise)\n    // Default values are always synchronous - async validation only happens\n    // with async refinements, which don't affect default value resolution.\n    if (\n      result &&\n      typeof result === \"object\" &&\n      !(\"then\" in result && typeof result.then === \"function\")\n    ) {\n      const syncResult = result as { issues?: unknown; value?: unknown };\n      if (!syncResult.issues) {\n        const defaultValue = syncResult.value;\n        return () => defaultValue;\n      }\n    }\n  } catch {\n    // Validation threw - no default\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;AASA,SAAgB,wBACd,QACqC;AACrC,KAAI,qBAAqB,OAAO,CAC9B,KAAI;AAEF,SADiB,OAAO,aACR,WAAW,MAAM,EAAE,QAAQ,YAAY,CAAC;SAClD;AACN;;;;;;;;;;;;;;;;;;;;;;;;AA2BN,SAAgB,uBACd,QAC6B;AAC7B,KAAI,UAAU,KACZ;AAGF,KAAI,CAAC,iBAAiB,OAAO,CAC3B;AAGF,KAAI;EACF,MAAM,SAAS,OAAO,aAAa,SAAS,OAAU;AAKtD,MACE,UACA,OAAO,WAAW,YAClB,EAAE,UAAU,UAAU,OAAO,OAAO,SAAS,aAC7C;GACA,MAAM,aAAa;AACnB,OAAI,CAAC,WAAW,QAAQ;IACtB,MAAM,eAAe,WAAW;AAChC,iBAAa;;;SAGX"}

package/dist/state/index.cjs

@@ -0,0 +1,8 @@
+const require_types = require('./types.cjs');
+const require_adapter = require('./adapter.cjs');
+const require_reduced = require('./values/reduced.cjs');
+const require_untracked = require('./values/untracked.cjs');
+const require_schema = require('./schema.cjs');
+const require_messages = require('./prebuilt/messages.cjs');
+require('./prebuilt/index.cjs');
+require('./values/index.cjs');

package/dist/state/index.js

@@ -0,0 +1,10 @@
+import { isSerializableSchema, isStandardSchema } from "./types.js";
+import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./adapter.js";
+import { ReducedValue } from "./values/reduced.js";
+import { UntrackedValue } from "./values/untracked.js";
+import { StateSchema } from "./schema.js";
+import { MessagesValue } from "./prebuilt/messages.js";
+import "./prebuilt/index.js";
+import "./values/index.js";
+
+export {  };

package/dist/state/prebuilt/index.cjs

@@ -0,0 +1 @@
+const require_messages = require('./messages.cjs');

package/dist/state/prebuilt/index.js

@@ -0,0 +1,3 @@
+import { MessagesValue } from "./messages.js";
+
+export {  };

package/dist/state/prebuilt/messages.cjs

@@ -0,0 +1,19 @@
+const require_reduced = require('../values/reduced.cjs');
+const require_messages_reducer = require('../../graph/messages_reducer.cjs');
+let zod_v4 = require("zod/v4");
+
+//#region src/state/prebuilt/messages.ts
+const messagesValueSchema = zod_v4.z.custom().default(() => []);
+const messagesInputSchema = zod_v4.z.custom();
+const MessagesValue = new require_reduced.ReducedValue(messagesValueSchema, {
+	inputSchema: messagesInputSchema,
+	reducer: require_messages_reducer.messagesStateReducer,
+	jsonSchemaExtra: {
+		langgraph_type: "messages",
+		description: "A list of chat messages"
+	}
+});
+
+//#endregion
+exports.MessagesValue = MessagesValue;
+//# sourceMappingURL=messages.cjs.map

package/dist/state/prebuilt/messages.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.cjs","names":["z","ReducedValue","messagesStateReducer"],"sources":["../../../src/state/prebuilt/messages.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v4\";\n\nimport { ReducedValue } from \"../values/reduced.js\";\nimport {\n  messagesStateReducer,\n  type Messages,\n} from \"../../graph/messages_reducer.js\";\n\nconst messagesValueSchema = z.custom<BaseMessage[]>().default(() => []);\nconst messagesInputSchema = z.custom<Messages>();\n\nexport const MessagesValue = new ReducedValue(\n  // Value schema: array of BaseMessage\n  messagesValueSchema,\n  {\n    // Input schema: accepts flexible message types\n    inputSchema: messagesInputSchema,\n    // Use the existing messagesStateReducer\n    reducer: messagesStateReducer,\n    // JSON schema extras for Studio\n    jsonSchemaExtra: {\n      langgraph_type: \"messages\",\n      description: \"A list of chat messages\",\n    },\n  }\n);\n"],"mappings":";;;;;AASA,MAAM,sBAAsBA,SAAE,QAAuB,CAAC,cAAc,EAAE,CAAC;AACvE,MAAM,sBAAsBA,SAAE,QAAkB;AAEhD,MAAa,gBAAgB,IAAIC,6BAE/B,qBACA;CAEE,aAAa;CAEb,SAASC;CAET,iBAAiB;EACf,gBAAgB;EAChB,aAAa;EACd;CACF,CACF"}

package/dist/state/prebuilt/messages.d.cts

@@ -0,0 +1,10 @@
+import { ReducedValue } from "../values/reduced.cjs";
+import { Messages } from "../../graph/messages_reducer.cjs";
+import * as _langchain_core_messages44 from "@langchain/core/messages";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/state/prebuilt/messages.d.ts
+declare const MessagesValue: ReducedValue<BaseMessage<_langchain_core_messages44.MessageStructure<_langchain_core_messages44.MessageToolSet>, _langchain_core_messages44.MessageType>[], Messages>;
+//#endregion
+export { MessagesValue };
+//# sourceMappingURL=messages.d.cts.map

package/dist/state/prebuilt/messages.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.cts","names":["BaseMessage","ReducedValue","Messages","MessagesValue","_langchain_core_messages44","MessageToolSet","MessageStructure","MessageType"],"sources":["../../../src/state/prebuilt/messages.d.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\nimport { ReducedValue } from \"../values/reduced.js\";\nimport { type Messages } from \"../../graph/messages_reducer.js\";\nexport declare const MessagesValue: ReducedValue<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n"],"mappings":";;;;;;cAGqBG,eAAeF,aAAaD,YAAiHI,0BAAAA,CAAlEE,iBAAiIF,0BAAAA,CAA7EC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,KAAgBL"}

package/dist/state/prebuilt/messages.d.ts

@@ -0,0 +1,10 @@
+import { ReducedValue } from "../values/reduced.js";
+import { Messages } from "../../graph/messages_reducer.js";
+import * as _langchain_core_messages44 from "@langchain/core/messages";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/state/prebuilt/messages.d.ts
+declare const MessagesValue: ReducedValue<BaseMessage<_langchain_core_messages44.MessageStructure<_langchain_core_messages44.MessageToolSet>, _langchain_core_messages44.MessageType>[], Messages>;
+//#endregion
+export { MessagesValue };
+//# sourceMappingURL=messages.d.ts.map

package/dist/state/prebuilt/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","names":["BaseMessage","ReducedValue","Messages","MessagesValue","_langchain_core_messages44","MessageToolSet","MessageStructure","MessageType"],"sources":["../../../src/state/prebuilt/messages.d.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\nimport { ReducedValue } from \"../values/reduced.js\";\nimport { type Messages } from \"../../graph/messages_reducer.js\";\nexport declare const MessagesValue: ReducedValue<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n"],"mappings":";;;;;;cAGqBG,eAAeF,aAAaD,YAAiHI,0BAAAA,CAAlEE,iBAAiIF,0BAAAA,CAA7EC,cAAAA,GAApCD,0BAAAA,CAAwFG,WAAAA,KAAgBL"}

package/dist/state/prebuilt/messages.js

@@ -0,0 +1,19 @@
+import { ReducedValue } from "../values/reduced.js";
+import { messagesStateReducer } from "../../graph/messages_reducer.js";
+import { z } from "zod/v4";
+
+//#region src/state/prebuilt/messages.ts
+const messagesValueSchema = z.custom().default(() => []);
+const messagesInputSchema = z.custom();
+const MessagesValue = new ReducedValue(messagesValueSchema, {
+	inputSchema: messagesInputSchema,
+	reducer: messagesStateReducer,
+	jsonSchemaExtra: {
+		langgraph_type: "messages",
+		description: "A list of chat messages"
+	}
+});
+
+//#endregion
+export { MessagesValue };
+//# sourceMappingURL=messages.js.map

package/dist/state/prebuilt/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","names":[],"sources":["../../../src/state/prebuilt/messages.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v4\";\n\nimport { ReducedValue } from \"../values/reduced.js\";\nimport {\n  messagesStateReducer,\n  type Messages,\n} from \"../../graph/messages_reducer.js\";\n\nconst messagesValueSchema = z.custom<BaseMessage[]>().default(() => []);\nconst messagesInputSchema = z.custom<Messages>();\n\nexport const MessagesValue = new ReducedValue(\n  // Value schema: array of BaseMessage\n  messagesValueSchema,\n  {\n    // Input schema: accepts flexible message types\n    inputSchema: messagesInputSchema,\n    // Use the existing messagesStateReducer\n    reducer: messagesStateReducer,\n    // JSON schema extras for Studio\n    jsonSchemaExtra: {\n      langgraph_type: \"messages\",\n      description: \"A list of chat messages\",\n    },\n  }\n);\n"],"mappings":";;;;;AASA,MAAM,sBAAsB,EAAE,QAAuB,CAAC,cAAc,EAAE,CAAC;AACvE,MAAM,sBAAsB,EAAE,QAAkB;AAEhD,MAAa,gBAAgB,IAAI,aAE/B,qBACA;CAEE,aAAa;CAEb,SAAS;CAET,iBAAiB;EACf,gBAAgB;EAChB,aAAa;EACd;CACF,CACF"}

package/dist/state/schema.cjs

@@ -0,0 +1,171 @@
+const require_binop = require('../channels/binop.cjs');
+const require_last_value = require('../channels/last_value.cjs');
+const require_types = require('./types.cjs');
+const require_adapter = require('./adapter.cjs');
+const require_untracked_value = require('../channels/untracked_value.cjs');
+require('../channels/index.cjs');
+const require_reduced = require('./values/reduced.cjs');
+const require_untracked = require('./values/untracked.cjs');
+
+//#region src/state/schema.ts
+const STATE_SCHEMA_SYMBOL = Symbol.for("langgraph.state.state_schema");
+/**
+* StateSchema provides a unified API for defining LangGraph state schemas.
+*
+* @example
+* ```ts
+* import { z } from "zod";
+* import { StateSchema, ReducedValue, MessagesValue } from "@langchain/langgraph";
+*
+* const AgentState = new StateSchema({
+*   // Prebuilt messages value
+*   messages: MessagesValue,
+*   // Basic LastValue channel from any standard schema
+*   currentStep: z.string(),
+*   // LastValue with native default
+*   count: z.number().default(0),
+*   // ReducedValue for fields needing reducers
+*   history: new ReducedValue(
+*     z.array(z.string()).default(() => []),
+*     {
+*       inputSchema: z.string(),
+*       reducer: (current, next) => [...current, next],
+*     }
+*   ),
+* });
+*
+* // Extract types
+* type State = typeof AgentState.State;
+* type Update = typeof AgentState.Update;
+*
+* // Use in StateGraph
+* const graph = new StateGraph(AgentState);
+* ```
+*/
+var StateSchema = class {
+	/**
+	* Symbol for runtime identification.
+	* @internal Used by isInstance for runtime type checking
+	*/
+	[STATE_SCHEMA_SYMBOL] = true;
+	constructor(init) {
+		this.init = init;
+		this.init = init;
+	}
+	/**
+	* Get the channel definitions for use with StateGraph.
+	* This converts the StateSchema fields into BaseChannel instances.
+	*/
+	getChannels() {
+		const channels = {};
+		for (const [key, value] of Object.entries(this.init)) if (require_reduced.ReducedValue.isInstance(value)) {
+			const defaultGetter = require_adapter.getSchemaDefaultGetter(value.valueSchema);
+			channels[key] = new require_binop.BinaryOperatorAggregate(value.reducer, defaultGetter);
+		} else if (require_untracked.UntrackedValue.isInstance(value)) {
+			const defaultGetter = value.schema ? require_adapter.getSchemaDefaultGetter(value.schema) : void 0;
+			channels[key] = new require_untracked_value.UntrackedValueChannel({
+				guard: value.guard,
+				initialValueFactory: defaultGetter
+			});
+		} else if (require_types.isStandardSchema(value)) channels[key] = new require_last_value.LastValue(require_adapter.getSchemaDefaultGetter(value));
+		else throw new Error(`Invalid state field "${key}": must be a schema, ReducedValue, UntrackedValue, or ManagedValue`);
+		return channels;
+	}
+	/**
+	* Get the JSON schema for the full state type.
+	* Used by Studio and API for schema introspection.
+	*/
+	getJsonSchema() {
+		const properties = {};
+		const required = [];
+		for (const [key, value] of Object.entries(this.init)) {
+			let fieldSchema;
+			if (require_reduced.ReducedValue.isInstance(value)) {
+				fieldSchema = require_adapter.getJsonSchemaFromSchema(value.valueSchema);
+				if (fieldSchema && value.jsonSchemaExtra) fieldSchema = {
+					...fieldSchema,
+					...value.jsonSchemaExtra
+				};
+			} else if (require_untracked.UntrackedValue.isInstance(value)) fieldSchema = value.schema ? require_adapter.getJsonSchemaFromSchema(value.schema) : void 0;
+			else if (require_types.isStandardSchema(value)) fieldSchema = require_adapter.getJsonSchemaFromSchema(value);
+			if (fieldSchema) {
+				properties[key] = fieldSchema;
+				let hasDefault = false;
+				if (require_reduced.ReducedValue.isInstance(value)) hasDefault = require_adapter.getSchemaDefaultGetter(value.valueSchema) !== void 0;
+				else if (require_untracked.UntrackedValue.isInstance(value)) hasDefault = value.schema ? require_adapter.getSchemaDefaultGetter(value.schema) !== void 0 : false;
+				else hasDefault = require_adapter.getSchemaDefaultGetter(value) !== void 0;
+				if (!hasDefault) required.push(key);
+			}
+		}
+		return {
+			type: "object",
+			properties,
+			required: required.length > 0 ? required : void 0
+		};
+	}
+	/**
+	* Get the JSON schema for the update/input type.
+	* All fields are optional in updates.
+	*/
+	getInputJsonSchema() {
+		const properties = {};
+		for (const [key, value] of Object.entries(this.init)) {
+			let fieldSchema;
+			if (require_reduced.ReducedValue.isInstance(value)) fieldSchema = require_adapter.getJsonSchemaFromSchema(value.inputSchema);
+			else if (require_untracked.UntrackedValue.isInstance(value)) fieldSchema = value.schema ? require_adapter.getJsonSchemaFromSchema(value.schema) : void 0;
+			else if (require_types.isStandardSchema(value)) fieldSchema = require_adapter.getJsonSchemaFromSchema(value);
+			if (fieldSchema) properties[key] = fieldSchema;
+		}
+		return {
+			type: "object",
+			properties
+		};
+	}
+	/**
+	* Get the list of channel keys (excluding managed values).
+	*/
+	getChannelKeys() {
+		return Object.entries(this.init).map(([key]) => key);
+	}
+	/**
+	* Get all keys (channels + managed values).
+	*/
+	getAllKeys() {
+		return Object.keys(this.init);
+	}
+	/**
+	* Validate input data against the schema.
+	* This validates each field using its corresponding schema.
+	*
+	* @param data - The input data to validate
+	* @returns The validated data with coerced types
+	*/
+	async validateInput(data) {
+		if (data == null || typeof data !== "object") return data;
+		const result = {};
+		for (const [key, value] of Object.entries(data)) {
+			const fieldDef = this.init[key];
+			if (fieldDef === void 0) {
+				result[key] = value;
+				continue;
+			}
+			let schema;
+			if (require_reduced.ReducedValue.isInstance(fieldDef)) schema = fieldDef.inputSchema;
+			else if (require_untracked.UntrackedValue.isInstance(fieldDef)) schema = fieldDef.schema;
+			else if (require_types.isStandardSchema(fieldDef)) schema = fieldDef;
+			if (schema) {
+				const validationResult = await schema["~standard"].validate(value);
+				if (validationResult.issues) throw new Error(`Validation failed for field "${key}": ${JSON.stringify(validationResult.issues)}`);
+				result[key] = validationResult.value;
+			} else result[key] = value;
+		}
+		return result;
+	}
+	static isInstance(value) {
+		return typeof value === "object" && value !== null && STATE_SCHEMA_SYMBOL in value && value[STATE_SCHEMA_SYMBOL] === true;
+	}
+};
+
+//#endregion
+exports.StateSchema = StateSchema;
+//# sourceMappingURL=schema.cjs.map

package/dist/state/schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.cjs","names":["ReducedValue","getSchemaDefaultGetter","BinaryOperatorAggregate","UntrackedValue","UntrackedValueChannel","isStandardSchema","LastValue","getJsonSchemaFromSchema"],"sources":["../../src/state/schema.ts"],"sourcesContent":["import type { JSONSchema } from \"@langchain/core/utils/json_schema\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nimport type { RunnableLike } from \"../pregel/runnable_types.js\";\nimport {\n  BaseChannel,\n  LastValue,\n  BinaryOperatorAggregate,\n} from \"../channels/index.js\";\nimport { UntrackedValueChannel } from \"../channels/untracked_value.js\";\n\nimport type { SerializableSchema } from \"./types.js\";\nimport { isStandardSchema } from \"./types.js\";\nimport { getJsonSchemaFromSchema, getSchemaDefaultGetter } from \"./adapter.js\";\nimport { ReducedValue } from \"./values/reduced.js\";\nimport { UntrackedValue } from \"./values/untracked.js\";\n\nconst STATE_SCHEMA_SYMBOL = Symbol.for(\"langgraph.state.state_schema\");\n\n/**\n * Maps a single StateSchema field definition to its corresponding Channel type.\n *\n * This utility type inspects the type of the field and returns an appropriate\n * `BaseChannel` type, parameterized with the state \"value\" and \"input\" types according to the field's shape.\n *\n * Rules:\n * - If the field (`F`) is a `ReducedValue<V, I>`, the channel will store values of type `V`\n *   and accept input of type `I`.\n * - If the field is a `UntrackedValue<V>`, the channel will store and accept values of type `V`.\n * - If the field is a `SerializableSchema<I, O>`, the channel will store values of type `O`\n *   (the schema's output/validated value) and accept input of type `I`.\n * - For all other types, a generic `BaseChannel<unknown, unknown>` is used as fallback.\n *\n * @template F - The StateSchema field type to map to a Channel type.\n *\n * @example\n * ```typescript\n * type MyField = ReducedValue<number, string>;\n * type ChannelType = StateSchemaFieldToChannel<MyField>;\n * // ChannelType is BaseChannel<number, string>\n * ```\n */\nexport type StateSchemaFieldToChannel<F> = F extends ReducedValue<\n  infer V,\n  infer I\n>\n  ? BaseChannel<V, I>\n  : F extends UntrackedValue<infer V>\n  ? BaseChannel<V, V>\n  : F extends SerializableSchema<infer I, infer O>\n  ? BaseChannel<O, I>\n  : BaseChannel<unknown, unknown>;\n\n/**\n * Converts a StateSchema \"init\" object (field map) into a strongly-typed\n * State Definition object, where each key is mapped to its channel type.\n *\n * This utility type is used internally to create the shape of the state channels for a given schema,\n * substituting each field with the result of `StateSchemaFieldToChannel`.\n *\n * If you define a state schema as:\n * ```typescript\n * const fields = {\n *   a: ReducedValue<number, string>(),\n *   b: UntrackedValue<boolean>(),\n *   c: SomeSerializableSchemaType, // SerializableSchema<in, out>\n * }\n * ```\n * then `StateSchemaFieldsToStateDefinition<typeof fields>` yields:\n * ```typescript\n * {\n *   a: BaseChannel<number, string>;\n *   b: BaseChannel<boolean, boolean>;\n *   c: BaseChannel<typeof schema's output type, typeof schema's input type>;\n * }\n * ```\n *\n * @template TInit - The mapping of field names to StateSchema field types.\n * @returns An object type mapping keys to channel types.\n *\n * @see StateSchemaFieldToChannel\n */\nexport type StateSchemaFieldsToStateDefinition<TInit extends StateSchemaInit> =\n  {\n    [K in keyof TInit]: StateSchemaFieldToChannel<TInit[K]>;\n  };\n\n/**\n * Valid field types for StateSchema.\n * Either a LangGraph state value type or a raw schema (e.g., Zod schema).\n */\nexport type StateSchemaField<Input = unknown, Output = Input> =\n  | ReducedValue<Input, Output>\n  | UntrackedValue<Output>\n  | SerializableSchema<Input, Output>;\n\n/**\n * Init object for StateSchema constructor.\n * Uses `any` to allow variance in generic types (e.g., ReducedValue<string, string[]>).\n */\nexport type StateSchemaInit = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: StateSchemaField<any, any>;\n};\n\n/**\n * Infer the State type from a StateSchemaInit.\n * This is the type of the full state object.\n *\n * - ReducedValue<Value, Input> → Value (the stored type)\n * - UntrackedValue<Value> → Value\n * - SerializableSchema<Input, Output> → Output (the validated type)\n */\nexport type InferStateSchemaValue<TInit extends StateSchemaInit> = {\n  [K in keyof TInit]: TInit[K] extends { ValueType: infer TValue }\n    ? TValue\n    : TInit[K] extends UntrackedValue<infer TValue>\n    ? TValue\n    : TInit[K] extends SerializableSchema<unknown, infer TOutput>\n    ? TOutput\n    : never;\n};\n\n/**\n * Infer the Update type from a StateSchemaInit.\n * This is the type for partial updates to state.\n *\n * - ReducedValue<Value, Input> → Input (the reducer input type)\n * - UntrackedValue<Value> → Value\n * - SerializableSchema<Input, Output> → Input (what you provide)\n */\nexport type InferStateSchemaUpdate<TInit extends StateSchemaInit> = {\n  [K in keyof TInit]?: TInit[K] extends { InputType: infer TInput }\n    ? TInput\n    : TInit[K] extends UntrackedValue<infer TValue>\n    ? TValue\n    : TInit[K] extends SerializableSchema<infer TInput, unknown>\n    ? TInput\n    : never;\n};\n\n/**\n * StateSchema provides a unified API for defining LangGraph state schemas.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import { StateSchema, ReducedValue, MessagesValue } from \"@langchain/langgraph\";\n *\n * const AgentState = new StateSchema({\n *   // Prebuilt messages value\n *   messages: MessagesValue,\n *   // Basic LastValue channel from any standard schema\n *   currentStep: z.string(),\n *   // LastValue with native default\n *   count: z.number().default(0),\n *   // ReducedValue for fields needing reducers\n *   history: new ReducedValue(\n *     z.array(z.string()).default(() => []),\n *     {\n *       inputSchema: z.string(),\n *       reducer: (current, next) => [...current, next],\n *     }\n *   ),\n * });\n *\n * // Extract types\n * type State = typeof AgentState.State;\n * type Update = typeof AgentState.Update;\n *\n * // Use in StateGraph\n * const graph = new StateGraph(AgentState);\n * ```\n */\nexport class StateSchema<TInit extends StateSchemaInit> {\n  /**\n   * Symbol for runtime identification.\n   * @internal Used by isInstance for runtime type checking\n   */\n  // @ts-expect-error - Symbol is read via `in` operator in isInstance\n  private readonly [STATE_SCHEMA_SYMBOL] = true;\n\n  /**\n   * Type declaration for the full state type.\n   * Use: `typeof myState.State`\n   */\n  declare State: InferStateSchemaValue<TInit>;\n\n  /**\n   * Type declaration for the update type.\n   * Use: `typeof myState.Update`\n   */\n  declare Update: InferStateSchemaUpdate<TInit>;\n\n  /**\n   * Type declaration for node functions.\n   * Use: `typeof myState.Node` to type node functions outside the graph builder.\n   *\n   * @example\n   * ```typescript\n   * const AgentState = new StateSchema({\n   *   count: z.number().default(0),\n   * });\n   *\n   * const myNode: typeof AgentState.Node = (state) => {\n   *   return { count: state.count + 1 };\n   * };\n   * ```\n   */\n  declare Node: RunnableLike<\n    InferStateSchemaValue<TInit>,\n    InferStateSchemaUpdate<TInit>\n  >;\n\n  constructor(readonly init: TInit) {\n    this.init = init;\n  }\n\n  /**\n   * Get the channel definitions for use with StateGraph.\n   * This converts the StateSchema fields into BaseChannel instances.\n   */\n  getChannels(): Record<string, BaseChannel> {\n    const channels: Record<string, BaseChannel> = {};\n\n    for (const [key, value] of Object.entries(this.init)) {\n      if (ReducedValue.isInstance(value)) {\n        // ReducedValue -> BinaryOperatorAggregate\n        const defaultGetter = getSchemaDefaultGetter(value.valueSchema);\n        channels[key] = new BinaryOperatorAggregate(\n          value.reducer,\n          defaultGetter\n        );\n      } else if (UntrackedValue.isInstance(value)) {\n        // UntrackedValue -> UntrackedValueChannel\n        const defaultGetter = value.schema\n          ? getSchemaDefaultGetter(value.schema)\n          : undefined;\n        channels[key] = new UntrackedValueChannel({\n          guard: value.guard,\n          initialValueFactory: defaultGetter,\n        });\n      } else if (isStandardSchema(value)) {\n        // Plain schema -> LastValue channel\n        const defaultGetter = getSchemaDefaultGetter(value);\n        channels[key] = new LastValue(defaultGetter);\n      } else {\n        throw new Error(\n          `Invalid state field \"${key}\": must be a schema, ReducedValue, UntrackedValue, or ManagedValue`\n        );\n      }\n    }\n\n    return channels;\n  }\n\n  /**\n   * Get the JSON schema for the full state type.\n   * Used by Studio and API for schema introspection.\n   */\n  getJsonSchema(): JSONSchema {\n    const properties: Record<string, JSONSchema> = {};\n    const required: string[] = [];\n\n    for (const [key, value] of Object.entries(this.init)) {\n      let fieldSchema: JSONSchema | undefined;\n\n      if (ReducedValue.isInstance(value)) {\n        fieldSchema = getJsonSchemaFromSchema(value.valueSchema) as JSONSchema;\n        if (fieldSchema && value.jsonSchemaExtra) {\n          fieldSchema = { ...fieldSchema, ...value.jsonSchemaExtra };\n        }\n      } else if (UntrackedValue.isInstance(value)) {\n        fieldSchema = value.schema\n          ? (getJsonSchemaFromSchema(value.schema) as JSONSchema)\n          : undefined;\n      } else if (isStandardSchema(value)) {\n        fieldSchema = getJsonSchemaFromSchema(value) as JSONSchema;\n      }\n\n      if (fieldSchema) {\n        properties[key] = fieldSchema;\n\n        // Field is required if it doesn't have a default\n        let hasDefault = false;\n        if (ReducedValue.isInstance(value)) {\n          hasDefault = getSchemaDefaultGetter(value.valueSchema) !== undefined;\n        } else if (UntrackedValue.isInstance(value)) {\n          hasDefault = value.schema\n            ? getSchemaDefaultGetter(value.schema) !== undefined\n            : false;\n        } else {\n          hasDefault = getSchemaDefaultGetter(value) !== undefined;\n        }\n\n        if (!hasDefault) {\n          required.push(key);\n        }\n      }\n    }\n\n    return {\n      type: \"object\",\n      properties,\n      required: required.length > 0 ? required : undefined,\n    };\n  }\n\n  /**\n   * Get the JSON schema for the update/input type.\n   * All fields are optional in updates.\n   */\n  getInputJsonSchema(): JSONSchema {\n    const properties: Record<string, JSONSchema> = {};\n\n    for (const [key, value] of Object.entries(this.init)) {\n      let fieldSchema: JSONSchema | undefined;\n\n      if (ReducedValue.isInstance(value)) {\n        // Use input schema for updates\n        fieldSchema = getJsonSchemaFromSchema(value.inputSchema) as JSONSchema;\n      } else if (UntrackedValue.isInstance(value)) {\n        fieldSchema = value.schema\n          ? (getJsonSchemaFromSchema(value.schema) as JSONSchema)\n          : undefined;\n      } else if (isStandardSchema(value)) {\n        fieldSchema = getJsonSchemaFromSchema(value) as JSONSchema;\n      }\n\n      if (fieldSchema) {\n        properties[key] = fieldSchema;\n      }\n    }\n\n    return {\n      type: \"object\",\n      properties,\n    };\n  }\n\n  /**\n   * Get the list of channel keys (excluding managed values).\n   */\n  getChannelKeys(): string[] {\n    return Object.entries(this.init).map(([key]) => key);\n  }\n\n  /**\n   * Get all keys (channels + managed values).\n   */\n  getAllKeys(): string[] {\n    return Object.keys(this.init);\n  }\n\n  /**\n   * Validate input data against the schema.\n   * This validates each field using its corresponding schema.\n   *\n   * @param data - The input data to validate\n   * @returns The validated data with coerced types\n   */\n  async validateInput<T>(data: T): Promise<T> {\n    if (data == null || typeof data !== \"object\") {\n      return data;\n    }\n\n    const result: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(data)) {\n      const fieldDef = this.init[key];\n\n      if (fieldDef === undefined) {\n        // Unknown field, pass through\n        result[key] = value;\n        continue;\n      }\n\n      // Get the schema to use for validation\n      let schema: StandardSchemaV1 | undefined;\n\n      if (ReducedValue.isInstance(fieldDef)) {\n        schema = fieldDef.inputSchema;\n      } else if (UntrackedValue.isInstance(fieldDef)) {\n        schema = fieldDef.schema;\n      } else if (isStandardSchema(fieldDef)) {\n        schema = fieldDef;\n      }\n\n      if (schema) {\n        // Validate using standard schema\n        const validationResult = await schema[\"~standard\"].validate(value);\n        if (validationResult.issues) {\n          throw new Error(\n            `Validation failed for field \"${key}\": ${JSON.stringify(\n              validationResult.issues\n            )}`\n          );\n        }\n        result[key] = validationResult.value;\n      } else {\n        // No schema or not a standard schema, pass through\n        result[key] = value;\n      }\n    }\n\n    return result as T;\n  }\n\n  /**\n   * Type guard to check if a value is a StateSchema instance.\n   *\n   * @param value - The value to check.\n   * @returns True if the value is a StateSchema instance with the correct runtime tag.\n   */\n  static isInstance<TInit extends StateSchemaInit>(\n    value: StateSchema<TInit>\n  ): value is StateSchema<TInit>;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static isInstance(value: unknown): value is StateSchema<any>;\n\n  static isInstance<TInit extends StateSchemaInit>(\n    value: unknown\n  ): value is StateSchema<TInit> {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      STATE_SCHEMA_SYMBOL in value &&\n      value[STATE_SCHEMA_SYMBOL] === true\n    );\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStateSchema = StateSchema<any>;\n"],"mappings":"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"}

package/dist/state/schema.d.cts

@@ -0,0 +1,208 @@
+import { BaseChannel } from "../channels/base.cjs";
+import { RunnableLike } from "../pregel/runnable_types.cjs";
+import { SerializableSchema } from "./types.cjs";
+import { ReducedValue } from "./values/reduced.cjs";
+import { UntrackedValue } from "./values/untracked.cjs";
+import { JSONSchema } from "@langchain/core/utils/json_schema";
+
+//#region src/state/schema.d.ts
+declare const STATE_SCHEMA_SYMBOL: unique symbol;
+/**
+ * Maps a single StateSchema field definition to its corresponding Channel type.
+ *
+ * This utility type inspects the type of the field and returns an appropriate
+ * `BaseChannel` type, parameterized with the state "value" and "input" types according to the field's shape.
+ *
+ * Rules:
+ * - If the field (`F`) is a `ReducedValue<V, I>`, the channel will store values of type `V`
+ *   and accept input of type `I`.
+ * - If the field is a `UntrackedValue<V>`, the channel will store and accept values of type `V`.
+ * - If the field is a `SerializableSchema<I, O>`, the channel will store values of type `O`
+ *   (the schema's output/validated value) and accept input of type `I`.
+ * - For all other types, a generic `BaseChannel<unknown, unknown>` is used as fallback.
+ *
+ * @template F - The StateSchema field type to map to a Channel type.
+ *
+ * @example
+ * ```typescript
+ * type MyField = ReducedValue<number, string>;
+ * type ChannelType = StateSchemaFieldToChannel<MyField>;
+ * // ChannelType is BaseChannel<number, string>
+ * ```
+ */
+type StateSchemaFieldToChannel<F> = F extends ReducedValue<infer V, infer I> ? BaseChannel<V, I> : F extends UntrackedValue<infer V> ? BaseChannel<V, V> : F extends SerializableSchema<infer I, infer O> ? BaseChannel<O, I> : BaseChannel<unknown, unknown>;
+/**
+ * Converts a StateSchema "init" object (field map) into a strongly-typed
+ * State Definition object, where each key is mapped to its channel type.
+ *
+ * This utility type is used internally to create the shape of the state channels for a given schema,
+ * substituting each field with the result of `StateSchemaFieldToChannel`.
+ *
+ * If you define a state schema as:
+ * ```typescript
+ * const fields = {
+ *   a: ReducedValue<number, string>(),
+ *   b: UntrackedValue<boolean>(),
+ *   c: SomeSerializableSchemaType, // SerializableSchema<in, out>
+ * }
+ * ```
+ * then `StateSchemaFieldsToStateDefinition<typeof fields>` yields:
+ * ```typescript
+ * {
+ *   a: BaseChannel<number, string>;
+ *   b: BaseChannel<boolean, boolean>;
+ *   c: BaseChannel<typeof schema's output type, typeof schema's input type>;
+ * }
+ * ```
+ *
+ * @template TInit - The mapping of field names to StateSchema field types.
+ * @returns An object type mapping keys to channel types.
+ *
+ * @see StateSchemaFieldToChannel
+ */
+type StateSchemaFieldsToStateDefinition<TInit extends StateSchemaInit> = { [K in keyof TInit]: StateSchemaFieldToChannel<TInit[K]> };
+/**
+ * Valid field types for StateSchema.
+ * Either a LangGraph state value type or a raw schema (e.g., Zod schema).
+ */
+type StateSchemaField<Input = unknown, Output = Input> = ReducedValue<Input, Output> | UntrackedValue<Output> | SerializableSchema<Input, Output>;
+/**
+ * Init object for StateSchema constructor.
+ * Uses `any` to allow variance in generic types (e.g., ReducedValue<string, string[]>).
+ */
+type StateSchemaInit = {
+  [key: string]: StateSchemaField<any, any>;
+};
+/**
+ * Infer the State type from a StateSchemaInit.
+ * This is the type of the full state object.
+ *
+ * - ReducedValue<Value, Input> → Value (the stored type)
+ * - UntrackedValue<Value> → Value
+ * - SerializableSchema<Input, Output> → Output (the validated type)
+ */
+type InferStateSchemaValue<TInit extends StateSchemaInit> = { [K in keyof TInit]: TInit[K] extends {
+  ValueType: infer TValue;
+} ? TValue : TInit[K] extends UntrackedValue<infer TValue> ? TValue : TInit[K] extends SerializableSchema<unknown, infer TOutput> ? TOutput : never };
+/**
+ * Infer the Update type from a StateSchemaInit.
+ * This is the type for partial updates to state.
+ *
+ * - ReducedValue<Value, Input> → Input (the reducer input type)
+ * - UntrackedValue<Value> → Value
+ * - SerializableSchema<Input, Output> → Input (what you provide)
+ */
+type InferStateSchemaUpdate<TInit extends StateSchemaInit> = { [K in keyof TInit]?: TInit[K] extends {
+  InputType: infer TInput;
+} ? TInput : TInit[K] extends UntrackedValue<infer TValue> ? TValue : TInit[K] extends SerializableSchema<infer TInput, unknown> ? TInput : never };
+/**
+ * StateSchema provides a unified API for defining LangGraph state schemas.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { StateSchema, ReducedValue, MessagesValue } from "@langchain/langgraph";
+ *
+ * const AgentState = new StateSchema({
+ *   // Prebuilt messages value
+ *   messages: MessagesValue,
+ *   // Basic LastValue channel from any standard schema
+ *   currentStep: z.string(),
+ *   // LastValue with native default
+ *   count: z.number().default(0),
+ *   // ReducedValue for fields needing reducers
+ *   history: new ReducedValue(
+ *     z.array(z.string()).default(() => []),
+ *     {
+ *       inputSchema: z.string(),
+ *       reducer: (current, next) => [...current, next],
+ *     }
+ *   ),
+ * });
+ *
+ * // Extract types
+ * type State = typeof AgentState.State;
+ * type Update = typeof AgentState.Update;
+ *
+ * // Use in StateGraph
+ * const graph = new StateGraph(AgentState);
+ * ```
+ */
+declare class StateSchema<TInit extends StateSchemaInit> {
+  readonly init: TInit;
+  /**
+   * Symbol for runtime identification.
+   * @internal Used by isInstance for runtime type checking
+   */
+  private readonly [STATE_SCHEMA_SYMBOL];
+  /**
+   * Type declaration for the full state type.
+   * Use: `typeof myState.State`
+   */
+  State: InferStateSchemaValue<TInit>;
+  /**
+   * Type declaration for the update type.
+   * Use: `typeof myState.Update`
+   */
+  Update: InferStateSchemaUpdate<TInit>;
+  /**
+   * Type declaration for node functions.
+   * Use: `typeof myState.Node` to type node functions outside the graph builder.
+   *
+   * @example
+   * ```typescript
+   * const AgentState = new StateSchema({
+   *   count: z.number().default(0),
+   * });
+   *
+   * const myNode: typeof AgentState.Node = (state) => {
+   *   return { count: state.count + 1 };
+   * };
+   * ```
+   */
+  Node: RunnableLike<InferStateSchemaValue<TInit>, InferStateSchemaUpdate<TInit>>;
+  constructor(init: TInit);
+  /**
+   * Get the channel definitions for use with StateGraph.
+   * This converts the StateSchema fields into BaseChannel instances.
+   */
+  getChannels(): Record<string, BaseChannel>;
+  /**
+   * Get the JSON schema for the full state type.
+   * Used by Studio and API for schema introspection.
+   */
+  getJsonSchema(): JSONSchema;
+  /**
+   * Get the JSON schema for the update/input type.
+   * All fields are optional in updates.
+   */
+  getInputJsonSchema(): JSONSchema;
+  /**
+   * Get the list of channel keys (excluding managed values).
+   */
+  getChannelKeys(): string[];
+  /**
+   * Get all keys (channels + managed values).
+   */
+  getAllKeys(): string[];
+  /**
+   * Validate input data against the schema.
+   * This validates each field using its corresponding schema.
+   *
+   * @param data - The input data to validate
+   * @returns The validated data with coerced types
+   */
+  validateInput<T>(data: T): Promise<T>;
+  /**
+   * Type guard to check if a value is a StateSchema instance.
+   *
+   * @param value - The value to check.
+   * @returns True if the value is a StateSchema instance with the correct runtime tag.
+   */
+  static isInstance<TInit extends StateSchemaInit>(value: StateSchema<TInit>): value is StateSchema<TInit>;
+  static isInstance(value: unknown): value is StateSchema<any>;
+}
+type AnyStateSchema = StateSchema<any>;
+//#endregion
+export { AnyStateSchema, InferStateSchemaUpdate, InferStateSchemaValue, StateSchema, StateSchemaField, StateSchemaFieldsToStateDefinition, StateSchemaInit };
+//# sourceMappingURL=schema.d.cts.map