Using zod 4.0 results in TypeScript error `not assignable to parameter of type 'never'`

[froitag]

Checked other resources

• I added a very descriptive title to this issue.
• I searched the LangGraph.js documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.
• I am sure that this is a bug in LangGraph.js rather than my code.
• The bug is not resolved by updating to the latest stable version of LangGraph (or the specific integration package).

Example Code

import "@langchain/langgraph/zod";
import { StateGraph } from "@langchain/langgraph";
import { z } from "zod";

const AgentState = z.object({
	question: z.string(),
	answer: z.string().min(1),
});

const graph = new StateGraph(AgentState);

Error Message and Stack Trace (if applicable)

No overload matches this call.
  The last overload gave the following error.
    Argument of type 'ZodObject<{ question: ZodString; answer: ZodString; }, $strip>' is not assignable to parameter of type 'never'.ts(2769)
state.d.ts(142, 5): The last overload is declared here.

Description

Trying to use the latest zod release (4.0) in a StateGraph results in the famous not assignable to parameter of type 'never' typescript error.

It seems that running the code doesn't produce a runtime error. But validation (via import "@langchain/langgraph/zod") doesn't seem to happen either.

System Info

• @langchain/langgraph: 0.4.0
• zod: 4.0.11
• Package manager: bun

[gabrielNi729]

Same here. Seems only work with Annotation constructor params.

[dqbd]

Hello! Can you try the following:

1. Use import { z } from "zod/v4"; instead of import { z } from "zod";
2. Adding overrides to package.json to force Zod 4 across all packages.

[danielmahon]

Adding the override works, and the typings seem to work, but there is no validation:

// package.json snippet
"dependencies": {
	"zod": "^4.0.17"
},
"overrides": {
	"zod": "$zod"
},

// state.ts
import type { BaseMessage } from '@langchain/core/messages';
import { MessagesZodMeta } from '@langchain/langgraph';
import { withLangGraph } from '@langchain/langgraph/zod';
import z from 'zod/v4';

export const GraphState = z.strictObject({
	messages: withLangGraph(z.custom<BaseMessage[]>(), MessagesZodMeta),
	progress: withLangGraph(z.number(), {
		default: () => 0,
		reducer: {
			schema: z.number().min(0).max(100),
			fn: (prev, next) => {
				console.log('prev', prev); // prev 0
				console.log('next', next); // next 1000
				return prev + next;
			},
		},
	}),
});

export const ConfigState = z.strictObject({
	userId: z.string(),
});

	const progressNode: GraphNode = async (_state, _config) => {
		return {
			progress: 1_000,
		};
	};

In this case there are no type errors but also no validation errors, where I would expect it to fail because the value is higher than the schemas max

Manual validation works:

const ProgressSchema = z.number().min(0).max(100);
const NextProgressSchema = z.number().min(0).max(1_000);

export const GraphState = z.strictObject({
	messages: withLangGraph(z.custom<BaseMessage[]>(), MessagesZodMeta),
	progress: withLangGraph(ProgressSchema, {
		default: () => 0,
		reducer: {
			schema: NextProgressSchema,
			fn: (prev, next) => {
				const validatedNext = NextProgressSchema.parse(next);
				console.log('prev', prev); // prev 0
				console.log('next', validatedNext); // next 1000
				return ProgressSchema.parse(prev + validatedNext); // correctly throws error expecting <= 100
			},
		},
	}),
});