LangChain中间件详解

LangChain版本1.2.9

概述

在 Agent 执行的每一步中实现精细控制与自定义

Middleware（中间件）为开发者提供了一种机制，用于更精确地控制 Agent 内部的执行流程。它在以下场景中尤为有用：

行为追踪：通过日志记录、数据分析和调试手段监控 Agent 的运行状态。
内容转换：对提示词（prompts）、工具选择和输出格式进行动态修改。
增强鲁棒性：添加重试机制、模型降级策略，以及提前终止逻辑。
安全与合规：实施调用频率限制、防护规则（guardrails）和个人身份信息（PII）检测。

只需将中间件实例传入 create_agent 函数即可启用：

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware, HumanInTheLoopMiddleware

agent = create_agent(
    model="gpt-4.1",
    tools=[...],
    middleware=[
        SummarizationMiddleware(...),
        HumanInTheLoopMiddleware(...)
    ],
)

Agent 的核心执行循环

Agent 的基本工作流程如下：

调用大语言模型 → 模型决定是否使用工具 → 执行工具 → 若无更多工具调用，则结束流程。

该过程可由下图直观表示：

图示说明：

用户输入进入后，Agent 首次调用模型；模型若返回工具调用请求，则执行对应工具并将结果反馈回上下文；随后再次调用模型，如此循环，直到模型不再请求工具调用，最终生成回答并结束。

中间件的介入时机

Middleware 通过钩子（hooks）在上述每个关键步骤的前后插入自定义逻辑，从而实现对整个流程的精细控制。

其介入点如下图所示：

图示说明：

整个 Agent 循环被划分为四个主要阶段：

Before Agent：在 Agent 启动前执行（如初始化状态、校验输入）
Before Model：在每次调用模型前执行（如修改提示、注入上下文）
After Model：在收到模型响应后、执行工具前执行（如解析响应、拦截危险操作）
After Agent：在整个 Agent 执行结束后执行（如清理资源、记录日志）

此外，还支持对模型调用和工具调用进行包装（wrap），实现更细粒度的拦截与修改。

内置中间件

为常见 Agent 使用场景提供开箱即用的中间件

LangChain 与 Deep Agents 提供了一系列针对常见使用场景的预构建中间件。每个中间件都经过生产环境验证，并支持根据您的具体需求进行配置。

跨模型提供商的通用中间件

以下中间件适用于任何 LLM 模型提供商：

中间件	描述
[Summarization（摘要）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。
[Human-in-the-loop（人在回路）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	在执行工具调用前暂停，等待人工审批。
[Model call limit（模型调用限制）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	限制模型调用次数，防止产生过高成本。
[Tool call limit（工具调用限制）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	通过限制调用次数来控制工具的执行。
[Model fallback（模型降级）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	当主模型调用失败时，自动切换到备用模型。
[PII detection（个人身份信息检测）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	检测并处理对话中的个人身份信息（PII）。
[To-do list（待办事项列表）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	为 Agent 赋予任务规划与跟踪能力。
[LLM tool selector（LLM 工具选择器）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。
[Tool retry（工具重试）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	对失败的工具调用自动进行指数退避式重试。
[Model retry（模型重试）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	对失败的模型调用自动进行指数退避式重试。
[LLM tool emulator（LLM 工具模拟器）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	使用 LLM 模拟工具执行结果，用于测试目的。
[Context editing（上下文编辑）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	通过修剪或清除旧的工具调用记录来管理对话上下文。
[Shell tool（Shell 工具）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	为 Agent 提供一个持久化的 Shell 会话以执行命令。
[File search（文件搜索）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。
[Filesystem（文件系统 - Deep Agents）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	为 Agent 提供一个文件系统，用于存储上下文和长期记忆。
[Subagent（子 Agent - Deep Agents）](#中间件描述 Summarization（摘要）当对话历史接近模型上下文长度限制时，自动对其进行摘要压缩。 Human-in-the-loop（人在回路）在执行工具调用前暂停，等待人工审批。 Model call limit（模型调用限制）限制模型调用次数，防止产生过高成本。 Tool call limit（工具调用限制）通过限制调用次数来控制工具的执行。 Model fallback（模型降级）当主模型调用失败时，自动切换到备用模型。 PII detection（个人身份信息检测）检测并处理对话中的个人身份信息（PII）。 To-do list（待办事项列表）为 Agent 赋予任务规划与跟踪能力。 LLM tool selector（LLM 工具选择器）使用一个 LLM 在调用主模型前，智能筛选出最相关的工具。 Tool retry（工具重试）对失败的工具调用自动进行指数退避式重试。 Model retry（模型重试）对失败的模型调用自动进行指数退避式重试。 LLM tool emulator（LLM 工具模拟器）使用 LLM 模拟工具执行结果，用于测试目的。 Context editing（上下文编辑）通过修剪或清除旧的工具调用记录来管理对话上下文。 Shell tool（Shell 工具）为 Agent 提供一个持久化的 Shell 会话以执行命令。 File search（文件搜索）为 Agent 提供基于 Glob 和 Grep 的文件系统搜索工具。 Filesystem（文件系统 - Deep Agents）为 Agent 提供一个文件系统，用于存储上下文和长期记忆。 Subagent（子 Agent - Deep Agents）赋予 Agent 启动子 Agent 的能力。)	赋予 Agent 启动子 Agent 的能力。

Summarization（摘要）

当对话历史接近模型的 Token 限制时，自动对其进行摘要压缩，在保留最新消息的同时压缩旧的上下文。

适用场景：

超长对话，其历史记录已超出模型的上下文窗口。
具有大量轮次的多轮对话。
需要完整保留对话上下文的应用。

API 参考： SummarizationMiddleware

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="gpt-4.1",
    tools=[your_weather_tool, your_calculator_tool],
    middleware=[
        SummarizationMiddleware(
            model="gpt-4.1-mini",
            trigger=("tokens", 4000),
            keep=("messages", 20),
        ),
    ],
)

Human-in-the-loop（人在回路）

在工具执行前暂停 Agent 的运行，等待人工对工具调用进行审批、编辑或拒绝。

适用场景：

高风险操作（如数据库写入、金融交易）需要人工审批。
合规性工作流，强制要求人工监督。
长期对话中，需要人工反馈来引导 Agent。

API 参考： HumanInTheLoopMiddleware

警告：人在回路中间件需要一个 checkpointer（检查点器）来在中断期间维持状态。

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware
from langgraph.checkpoint.memory import InMemorySaver

def read_email_tool(email_id: str) -> str:
    """模拟根据 ID 读取邮件的函数。"""
    return f"ID 为 {email_id} 的邮件内容"

def send_email_tool(recipient: str, subject: str, body: str) -> str:
    """模拟发送邮件的函数。"""
    return f"邮件已发送至 {recipient}，主题为 '{subject}'"

agent = create_agent(
    model="gpt-4.1",
    tools=[your_read_email_tool, your_send_email_tool],
    checkpointer=InMemorySaver(),
    middleware=[
        HumanInTheLoopMiddleware(
            interrupt_on={
                "your_send_email_tool": {
                    "allowed_decisions": ["approve", "edit", "reject"],
                },
                "your_read_email_tool": False,
            }
        ),
    ],
)

Model call limit（模型调用限制）

限制模型调用次数，以防止无限循环或产生过高成本。

适用场景：

防止失控的 Agent 进行过多 API 调用。
在生产环境中实施成本控制。
在特定调用预算内测试 Agent 行为。

API 参考： ModelCallLimitMiddleware

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import ModelCallLimitMiddleware
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="gpt-4.1",
    checkpointer=InMemorySaver(), # 线程限制必需
    tools=[],
    middleware=[
        ModelCallLimitMiddleware(
            thread_limit=10,
            run_limit=5,
            exit_behavior="end",
        ),
    ],
)

Tool call limit（工具调用限制）

通过限制工具调用次数来控制 Agent 的执行，既可以全局限制，也可以针对特定工具。

适用场景：

防止对昂贵的外部 API 进行过多调用。
限制网页搜索或数据库查询次数。
对特定工具的使用实施速率限制。
防范失控的 Agent 循环。

API 参考： ToolCallLimitMiddleware

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import ToolCallLimitMiddleware

agent = create_agent(
    model="gpt-4.1",
    tools=[search_tool, database_tool],
    middleware=[
        # 全局限制
        ToolCallLimitMiddleware(thread_limit=20, run_limit=10),
        # 特定工具限制
        ToolCallLimitMiddleware(
            tool_name="search",
            thread_limit=5,
            run_limit=3,
        ),
    ],
)

... 其他的内置中间件，可以点击对应的官网查看详情。

自定义中间件

通过实现特定的钩子（hooks），您可以在 Agent 执行流程的关键节点运行自定义逻辑，从而构建专属的中间件。

钩子（Hooks）

中间件提供了两种风格的钩子，用于拦截 Agent 的执行过程：

节点式钩子 (Node-style hooks)

在 Agent 执行流程的特定节点按顺序触发。适用于日志记录、输入验证和状态更新等场景。

可用的钩子：

before_agent - Agent 启动前触发（每次调用仅一次）
before_model - 每次模型调用前触发
after_model - 每次收到模型响应后触发
after_agent - Agent 完成后触发（每次调用仅一次）

python 复制代码

from langchain.agents.middleware import before_model, after_model, AgentState
from langchain.messages import AIMessage
from langgraph.runtime import Runtime
from typing import Any


@before_model(can_jump_to=["end"])
def check_message_limit(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
    # 检查消息数量是否达到上限
    if len(state["messages"]) >= 50:
        return {
            "messages": [AIMessage("对话长度已达上限。")],
            "jump_to": "end"  # 跳转到结束节点
        }
    return None

@after_model
def log_response(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
    # 记录模型的响应
    print(f"模型返回: {state['messages'][-1].content}")
    return None

python 复制代码

from langchain.agents.middleware import AgentMiddleware, AgentState, hook_config
from langchain.messages import AIMessage
from langgraph.runtime import Runtime
from typing import Any

class MessageLimitMiddleware(AgentMiddleware):
    def __init__(self, max_messages: int = 50):
        super().__init__()
        self.max_messages = max_messages

    @hook_config(can_jump_to=["end"])
    def before_model(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
        if len(state["messages"]) == self.max_messages:
            return {
                "messages": [AIMessage("对话长度已达上限。")],
                "jump_to": "end"
            }
        return None

    def after_model(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
        print(f"模型返回: {state['messages'][-1].content}")
        return None

包装式钩子 (Wrap-style hooks)

完全控制被包装函数（handler）的调用时机和次数。适用于重试、缓存和请求/响应转换等需要精细控制流的场景。

您可以决定：

不调用 handler（短路执行）
调用一次（正常流程）
多次调用（实现重试逻辑）

可用的钩子：

wrap_model_call - 包裹每次模型调用
wrap_tool_call - 包裹每次工具调用

示例：

python 复制代码

from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from typing import Callable


@wrap_model_call
def retry_model(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    # 尝试最多3次
    for attempt in range(3):
        try:
            return handler(request)
        except Exception as e:
            if attempt == 2:  # 最后一次尝试失败则抛出异常
                raise
            print(f"第 {attempt + 1}/3 次重试，错误: {e}")

python 复制代码

from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse
from typing import Callable

class RetryMiddleware(AgentMiddleware):
    def __init__(self, max_retries: int = 3):
        super().__init__()
        self.max_retries = max_retries

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        for attempt in range(self.max_retries):
            try:
                return handler(request)
            except Exception as e:
                if attempt == self.max_retries - 1:
                    raise
                print(f"第 {attempt + 1}/{self.max_retries} 次重试，错误: {e}")

创建中间件

您可以通过以下两种方式创建中间件：

基于装饰器的中间件

为只需要单个钩子的简单中间件提供快速实现方案。通过装饰器直接包装函数即可。

可用的装饰器：

节点式 (Node-style):

@before_agent - Agent 启动前运行（每次调用仅一次）
@before_model - 每次模型调用前运行
@after_model - 每次模型响应后运行
@after_agent - Agent 完成后运行（每次调用仅一次）
包装式 (Wrap-style):
@wrap_model_call - 用自定义逻辑包裹每次模型调用
@wrap_tool_call - 用自定义逻辑包裹每次工具调用
便捷工具:
@dynamic_prompt - 生成动态的系统提示词

示例：

python 复制代码

from langchain.agents.middleware import (
    before_model,
    wrap_model_call,
    AgentState,
    ModelRequest,
    ModelResponse,
)
from langchain.agents import create_agent
from langgraph.runtime import Runtime
from typing import Any, Callable


@before_model
def log_before_model(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
    print(f"即将调用模型，当前消息数: {len(state['messages'])}")
    return None

@wrap_model_call
def retry_model(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    for attempt in range(3):
        try:
            return handler(request)
        except Exception as e:
            if attempt == 2:
                raise
            print(f"第 {attempt + 1}/3 次重试，错误: {e}")

agent = create_agent(
    model="gpt-4.1",
    middleware=[log_before_model, retry_model],
    tools=[...],
)

何时使用装饰器：

只需要一个钩子
无需复杂配置
快速原型验证

基于类的中间件

当您需要在一个中间件中组合多个钩子、进行复杂配置，或者为同一个钩子同时定义同步和异步实现时，基于类的方式更为强大。

示例：

python 复制代码

from langchain.agents.middleware import (
    AgentMiddleware,
    AgentState,
    ModelRequest,
    ModelResponse,
)
from langgraph.runtime import Runtime
from typing import Any, Callable

class LoggingMiddleware(AgentMiddleware):
    def before_model(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
        print(f"即将调用模型，当前消息数: {len(state['messages'])}")
        return None

    def after_model(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
        print(f"模型返回: {state['messages'][-1].content}")
        return None

agent = create_agent(
    model="gpt-4.1",
    middleware=[LoggingMiddleware()],
    tools=[...],
)

何时使用类：

需要为同一个钩子同时定义同步和异步实现
单个中间件需要多个钩子
需要复杂的初始化配置（例如可配置的阈值、自定义模型等）
希望在不同项目间复用，并通过初始化参数进行配置

自定义状态模式（Custom state schema）

中间件可以通过扩展 Agent 的状态模式（state schema）来添加自定义属性。这使得中间件能够：

跨执行周期追踪状态：在整个 Agent 生命周期内维护计数器、标志位或其他值。
在钩子间共享数据：例如，将 before_model 中的信息传递给 after_model，或在不同的中间件实例间传递数据。
实现横切关注点：在不修改核心 Agent 逻辑的情况下，添加速率限制、用量追踪、用户上下文或审计日志等功能。
做出条件性决策：利用累积的状态信息，动态决定是继续执行、跳转到不同节点，还是修改行为。

python 复制代码

from langchain.agents import create_agent
from langchain.messages import HumanMessage
from langchain.agents.middleware import AgentState, before_model, after_model
from typing_extensions import NotRequired
from typing import Any
from langgraph.runtime import Runtime


# 定义扩展的状态模式
class CustomState(AgentState):
    model_call_count: NotRequired[int]  # 模型调用计数
    user_id: NotRequired[str]           # 用户ID


@before_model(state_schema=CustomState, can_jump_to=["end"])
def check_call_limit(state: CustomState, runtime: Runtime) -> dict[str, Any] | None:
    count = state.get("model_call_count", 0)
    if count > 10:  # 超过10次则终止
        return {"jump_to": "end"}
    return None


@after_model(state_schema=CustomState)
def increment_counter(state: CustomState, runtime: Runtime) -> dict[str, Any] | None:
    # 每次调用后计数器加一
    return {"model_call_count": state.get("model_call_count", 0) + 1}


agent = create_agent(
    model="gpt-4.1",
    middleware=[check_call_limit, increment_counter],
    tools=[],
)

# 调用时传入自定义状态
result = agent.invoke({
    "messages": [HumanMessage("你好")],
    "model_call_count": 0,
    "user_id": "user-123",
})

python 复制代码

from langchain.agents import create_agent
from langchain.messages import HumanMessage
from langchain.agents.middleware import AgentState, AgentMiddleware
from typing_extensions import NotRequired
from typing import Any


class CustomState(AgentState):
    model_call_count: NotRequired[int]
    user_id: NotRequired[str]


class CallCounterMiddleware(AgentMiddleware[CustomState]):
    state_schema = CustomState  # 指定使用的状态模式

    def before_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        count = state.get("model_call_count", 0)
        if count > 10:
            return {"jump_to": "end"}
        return None

    def after_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        return {"model_call_count": state.get("model_call_count", 0) + 1}


agent = create_agent(
    model="gpt-4.1",
    middleware=[CallCounterMiddleware()],
    tools=[],
)

# 调用时传入自定义状态
result = agent.invoke({
    "messages": [HumanMessage("你好")],
    "model_call_count": 0,
    "user_id": "user-123",
})

执行顺序

当使用多个中间件时，理解它们的执行顺序至关重要：

python 复制代码

agent = create_agent(
    model="gpt-4.1",
    middleware=[middleware1, middleware2, middleware3],
    tools=[...],
)

before_* 钩子按顺序执行：

middleware1.before_agent()
middleware2.before_agent()
middleware3.before_agent()

Agent 循环开始

middleware1.before_model()
middleware2.before_model()
middleware3.before_model()

wrap_* 钩子像函数调用一样嵌套：

middleware1.wrap_model_call() → middleware2.wrap_model_call() → middleware3.wrap_model_call() → 模型调用

after_* 钩子按逆序执行：

middleware3.after_model()
middleware2.after_model()
middleware1.after_model()

Agent 循环结束

middleware3.after_agent()
middleware2.after_agent()
middleware1.after_agent()

关键规则：

before_* 钩子：从前往后执行（First to last）
after_* 钩子：从后往前执行（Last to first，逆序）
wrap_* 钩子：嵌套式执行（第一个中间件包裹了所有后续中间件和模型）

Agent 跳转（Agent jumps）

若想从中间件中提前退出，可返回一个包含 jump_to 键的字典。

可用的跳转目标：

'end': 跳转到 Agent 执行的末尾（或第一个 after_agent 钩子）。
'tools': 跳转到工具执行节点。
'model': 跳转到模型调用节点（或第一个 before_model 钩子）。

python 复制代码

from langchain.agents.middleware import after_model, hook_config, AgentState
from langchain.messages import AIMessage
from langgraph.runtime import Runtime
from typing import Any


@after_model
@hook_config(can_jump_to=["end"])
def check_for_blocked(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
    last_message = state["messages"][-1]
    if "BLOCKED" in last_message.content:
        return {
            "messages": [AIMessage("我无法回应此请求。")],
            "jump_to": "end"
        }
    return None

python 复制代码

from langchain.agents.middleware import AgentMiddleware, hook_config, AgentState
from langchain.messages import AIMessage
from langgraph.runtime import Runtime
from typing import Any

class BlockedContentMiddleware(AgentMiddleware):
    @hook_config(can_jump_to=["end"])
    def after_model(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
        last_message = state["messages"][-1]
        if "BLOCKED" in last_message.content:
            return {
                "messages": [AIMessage("我无法回应此请求。")],
                "jump_to": "end"
            }
        return None

最佳实践

保持专注：每个中间件应只做好一件事。
优雅处理错误：不要让中间件的错误导致整个 Agent 崩溃。
选用合适的钩子类型：

节点式钩子（Node-style）用于顺序逻辑（如日志、验证）。
包装式钩子（Wrap-style）用于控制流（如重试、降级、缓存）。

清晰地文档化：对任何自定义的状态属性进行明确说明。
独立单元测试：在集成到 Agent 之前，先对中间件进行独立的单元测试。
考虑执行顺序：将关键的中间件放在列表的前面。
优先使用内置中间件：LangChain 提供了许多开箱即用的中间件，能不用自己造轮子就别造。

示例

动态模型选择

根据上下文动态切换使用不同的模型。

python 复制代码

from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from langchain.chat_models import init_chat_model
from typing import Callable


complex_model = init_chat_model("gpt-4.1")
simple_model = init_chat_model("gpt-4.1-mini")

@wrap_model_call
def dynamic_model(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    # 根据对话长度选择模型
    if len(request.messages) > 10:
        model = complex_model
    else:
        model = simple_model
    return handler(request.override(model=model))

python 复制代码

from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse
from langchain.chat_models import init_chat_model
from typing import Callable

complex_model = init_chat_model("gpt-4.1")
simple_model = init_chat_model("gpt-4.1-mini")

class DynamicModelMiddleware(AgentMiddleware):
    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        if len(request.messages) > 10:
            model = complex_model
        else:
            model = simple_model
        return handler(request.override(model=model))

工具调用监控

监控工具的执行情况，用于调试或审计。

python 复制代码

from langchain.agents.middleware import wrap_tool_call
from langchain.tools.tool_node import ToolCallRequest
from langchain.messages import ToolMessage
from langgraph.types import Command
from typing import Callable


@wrap_tool_call
def monitor_tool(
    request: ToolCallRequest,
    handler: Callable[[ToolCallRequest], ToolMessage | Command],
) -> ToolMessage | Command:
    print(f"正在执行工具: {request.tool_call['name']}")
    print(f"参数: {request.tool_call['args']}")
    try:
        result = handler(request)
        print(f"工具执行成功")
        return result
    except Exception as e:
        print(f"工具执行失败: {e}")
        raise

python 复制代码

from langchain.tools.tool_node import ToolCallRequest
from langchain.agents.middleware import AgentMiddleware
from langchain.messages import ToolMessage
from langgraph.types import Command
from typing import Callable

class ToolMonitoringMiddleware(AgentMiddleware):
    def wrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], ToolMessage | Command],
    ) -> ToolMessage | Command:
        print(f"正在执行工具: {request.tool_call['name']}")
        print(f"参数: {request.tool_call['args']}")
        try:
            result = handler(request)
            print(f"工具执行成功")
            return result
        except Exception as e:
            print(f"工具执行失败: {e}")
            raise

动态工具选择

在运行时动态筛选相关工具，以提升性能和准确性。本节介绍如何过滤已预注册的工具。关于在运行时发现并注册新工具（例如来自 MCP 服务器），请参阅运行时工具注册。

优势：

更短的提示词：只暴露相关工具，降低提示复杂度。
更高的准确性：模型在更少的选项中能做出更正确的选择。
权限控制：可根据用户权限动态过滤工具。

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from typing import Callable


@wrap_model_call
def select_tools(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    """根据状态/上下文选择相关的工具子集。"""
    relevant_tools = select_relevant_tools(request.state, request.runtime)
    return handler(request.override(tools=relevant_tools))

agent = create_agent(
    model="gpt-4.1",
    tools=all_tools,  # 所有可用工具必须预先注册
    middleware=[select_tools],
)

python 复制代码

from langchain.agents import create_agent
from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse
from typing import Callable


class ToolSelectorMiddleware(AgentMiddleware):
    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        """根据状态/上下文选择相关的工具子集。"""
        relevant_tools = select_relevant_tools(request.state, request.runtime)
        return handler(request.override(tools=relevant_tools))

agent = create_agent(
    model="gpt-4.1",
    tools=all_tools,  # 所有可用工具必须预先注册
    middleware=[ToolSelectorMiddleware()],
)

处理系统消息（Working with system messages）

通过 ModelRequest 上的 system_message 字段，在中间件中修改系统消息。即使 Agent 是用字符串 system_prompt 创建的，system_message 字段也始终是一个 SystemMessage 对象。

示例：向系统消息添加上下文

python 复制代码

from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from langchain.messages import SystemMessage
from typing import Callable


@wrap_model_call
def add_context(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    # 始终使用 content_blocks 进行操作
    new_content = list(request.system_message.content_blocks) + [
        {"type": "text", "text": "附加的上下文信息。"}
    ]
    new_system_message = SystemMessage(content=new_content)
    return handler(request.override(system_message=new_system_message))

python 复制代码

from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse
from langchain.messages import SystemMessage
from typing import Callable


class ContextMiddleware(AgentMiddleware):
    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        new_content = list(request.system_message.content_blocks) + [
            {"type": "text", "text": "附加的上下文信息。"}
        ]
        new_system_message = SystemMessage(content=new_content)
        return handler(request.override(system_message=new_system_message))

参考文献

中间件 API 参考
 内置中间件
 Agent 测试指南