它和 ToolNode 一起，构成"手搓 ReAct 三件套"：StateGraph + ToolNode + tools_condition。定义在 tool_node.py:1582，docstring 里就给了标准用法：

# tool_node.py:1582 docstring 示例
graph = StateGraph(State)
graph.add_node("llm", call_model)
graph.add_node("tools", ToolNode([my_tool]))
graph.add_conditional_edges(
    "llm",
    tools_condition,                         # ← 一行接上路由
    {"tools": "tools", "__end__": "__end__"},
)

函数体很短（tool_node.py:1648 起，即 docstring 之后）：

# tool_node.py:1648
def tools_condition(state, messages_key="messages") -> Literal["tools", "__end__"]:
    if isinstance(state, list):
        ai_message = state[-1]                                # 输入是消息列表
    elif (isinstance(state, dict) and (messages := state.get(messages_key, []))) or (
        messages := getattr(state, messages_key, [])):
        ai_message = messages[-1]                             # 输入是 dict / dataclass 状态
    else:
        raise ValueError(f"No messages found in input state to tool_edge: {state}")
    if hasattr(ai_message, "tool_calls") and len(ai_message.tool_calls) > 0:
        return "tools"                                        # 有 tool_calls → 去 tools
    return "__end__"                                          # 没有 → 结束

回到 ToolNode 里一个"校验"环节（D55 L05 里提过）。模型可能幻觉出一个不存在的工具名。tool_node.py:1268：

# tool_node.py:1268
def _validate_tool_call(self, call: ToolCall) -> ToolMessage | None:
    requested_tool = call["name"]
    if requested_tool not in self.tools_by_name:                  # 不在工具表里
        all_tool_names = list(self.tools_by_name.keys())
        content = INVALID_TOOL_NAME_ERROR_TEMPLATE.format(
            requested_tool=requested_tool,
            available_tools=", ".join(all_tool_names))            # 列出可用工具
        return ToolMessage(content, name=requested_tool,
                           tool_call_id=call["id"], status="error")
    return None                                                   # 工具存在 → 无需拦截
# INVALID_TOOL_NAME_ERROR_TEMPLATE (:108):
# "Error: {requested_tool} is not a valid tool, try one of [{available_tools}]."

这就是 ValidationNode（tool_validator.py:47）。它继承 RunnableCallable，也是个图节点，但和 ToolNode 的差别是：它 model_validate 参数，不 invoke 工具。

# tool_validator.py:47（类头 + docstring 要点）
class ValidationNode(RunnableCallable):
    """A node that validates all tools requests from the last AIMessage.
    This node does NOT actually run the tools, it only validates the tool calls,
    which is useful for extraction and other use cases where you need to generate
    structured output that conforms to a complex schema ..."""

tool_validator.py:116，把各种输入统一成"名字 → Pydantic 模型"：

# tool_validator.py:116
def __init__(self, schemas, *, format_error=None, name="validation", tags=None):
    super().__init__(self._func, None, name=name, tags=tags, trace=False)
    self._format_error = format_error or _default_format_error
    self.schemas_by_name: dict[str, type[BaseModel]] = {}
    for schema in schemas:
        if isinstance(schema, BaseTool):                          # ① 工具 → 用它的 args_schema
            if schema.args_schema is None:
                raise ValueError(f"Tool {schema.name} does not have an args_schema defined.")
            ...
            self.schemas_by_name[schema.name] = schema.args_schema
        elif isinstance(schema, type) and issubclass(schema, (BaseModel, BaseModelV1)):
            self.schemas_by_name[schema.__name__] = schema        # ② 直接是 Pydantic 类
        elif callable(schema):
            base_model = create_schema_from_function("Validation", schema)  # ③ 函数 → 推 schema
            self.schemas_by_name[schema.__name__] = base_model
        else:
            raise ValueError(f"Unsupported input to ValidationNode. ...")

核心 tool_validator.py:184：

# tool_validator.py:184
def _func(self, input, config):
    output_type, message = self._get_message(input)          # 取最后一条 AIMessage
    def run_one(call: ToolCall) -> ToolMessage:
        schema = self.schemas_by_name[call["name"]]
        try:
            if issubclass(schema, BaseModel):
                output = schema.model_validate(call["args"])  # ★ 校验参数（不执行工具！）
                content = output.model_dump_json()            # 合法 → 规整成 JSON
            elif issubclass(schema, BaseModelV1):
                output = schema.validate(call["args"]); content = output.json()
            ...
            return ToolMessage(content=content, name=call["name"], tool_call_id=call["id"])
        except (ValidationError, ValidationErrorV1) as e:
            return ToolMessage(                               # 不合法 → 错误消息
                content=self._format_error(e, call, schema),
                name=call["name"], tool_call_id=call["id"],
                additional_kwargs={"is_error": True})         # ★ 打上 is_error 标记
    with get_executor_for_config(config) as executor:
        outputs = [*executor.map(run_one, message.tool_calls)]  # 并行校验每个 call
        return outputs if output_type == "list" else {"messages": outputs}

ValidationNode 的威力在于配一个"重试路由"（tool_validator.py:47 docstring 里的完整例子）：

# tool_validator.py docstring 示例（re-prompt 循环）
builder.add_node("model", llm)
builder.add_node("validation", ValidationNode([SelectNumber]))
def should_validate(state) -> Literal["validation", "__end__"]:
    if state[-1].tool_calls: return "validation"      # 模型给了 tool_call → 去校验
    return END
builder.add_conditional_edges("model", should_validate)
def should_reprompt(state) -> Literal["model", "__end__"]:
    for msg in state[::-1]:
        if msg.type == "ai": return END               # 回溯到 AIMessage 都没错 → 结束
        if msg.additional_kwargs.get("is_error"): return "model"  # 有错 → 回模型重填
    return END
builder.add_conditional_edges("validation", should_reprompt)

✋ 10 分钟动手

# 1. 三段核心逐行读
sed -n '1648,1662p' libs/prebuilt/langgraph/prebuilt/tool_node.py       # tools_condition 主体
sed -n '1268,1280p' libs/prebuilt/langgraph/prebuilt/tool_node.py       # 幻觉工具校验
sed -n '184,221p'   libs/prebuilt/langgraph/prebuilt/tool_validator.py  # 校验 _func

# 2. 亲手看 ValidationNode 校验失败
python - <<'PY'
from langgraph.prebuilt import ValidationNode
from langchain_core.messages import AIMessage
from pydantic import BaseModel, field_validator
class SelectNumber(BaseModel):
    a: int
    @field_validator("a")
    def only_37(cls, v):
        if v != 37: raise ValueError("Only 37 is allowed")
        return v
node = ValidationNode([SelectNumber])
ai = AIMessage(content="", tool_calls=[{"name":"SelectNumber","args":{"a":5},"id":"1","type":"tool_call"}])
print(node.invoke([ai])[0].content)   # 看到 Only 37 is allowed + Respond after fixing...
PY