前面两篇讲了 ReAct 和 Plan-Execute,这篇讲第三种循环形态:状态机。它适合"阶段固定、流程很长、随时可能中断"的任务。
适合:写过 if-else 流水线、想搞明白"断点续传"和"策略模式"怎么落地的同学。
一、为什么长流程需要状态机
先说一个场景:用户上传一份资料,要求生成一份 PPT。这个任务要经过:需求澄清 → 选模板 → 生成大纲 → 生成页面结构 → 检索素材 → 渲染 → 完成。
它跟 Plan-Execute 的区别在哪?
- Plan-Execute 的任务清单是模型临时生成的,每次可能不一样;状态机的阶段是产品事先定死的
- Plan-Execute 追求"一批任务尽量并行";状态机追求"每一步可控、可暂停、可恢复"
- 用户可能在"需求澄清"阶段被打断,第二天回来继续;也可能在"渲染"阶段服务重启。状态机必须能从数据库里读回上次的状态接着跑
所以状态机要解决三件事:
- 阶段可枚举:一共几个状态,每个状态做什么
- 状态可持久化:status 存数据库,产出也存数据库
- 流转可恢复:重启后知道下一步该执行谁
二、状态机三件套
最小实现只需要三个东西:
java
enum Status {
REQUIREMENT, TEMPLATE, OUTLINE, SCHEMA, SEARCH, RENDER, SUCCESS, FAILED
}
interface StageStrategy {
Status targetStatus(); // 这一步做完,下一步是谁
void execute(StageContext context); // 这一步具体做什么
}
class StrategyFactory {
private final Map<Status, StageStrategy> strategies = new HashMap<>();
void register(Status status, StageStrategy strategy) {
strategies.put(status, strategy);
}
StageStrategy get(Status status) {
StageStrategy strategy = strategies.get(status);
if (strategy == null) throw new IllegalStateException("未注册状态:" + status);
return strategy;
}
}
- Status:状态枚举,把"流程"变成有限个点
- Strategy:每个状态一个类,只关心"我这一步怎么干、干完去哪"
- Factory :维护
status → strategy的映射,负责"给我这个状态对应的执行者"
为什么不用 if-else?
十个阶段写成 if-else,主流程会有几百行,改一个阶段要动整个方法,测试也没法单独测。用策略模式后:
- 加一个阶段 = 加一个类 + 一行注册
- 每个策略可以单独写单元测试
- 主流程只有"查状态 → 找策略 → 执行"三行
这就是"开闭原则"在 Agent 流程里最实在的用法。
三、流转协议:谁负责推进下一步
状态机最容易写错的不是策略,而是"谁来推进下一步"。常见两种写法:
写法 A:策略自己调用下一个策略
java
void execute(StageContext ctx) {
// 干完活
factory.get(targetStatus()).execute(ctx); // 直接递归
}
简单,但递归一层层套下去,阶段多了会栈溢出,而且异常处理很乱。
写法 B:策略只声明"下一步是谁",由驱动器循环推进
java
while (!current.isTerminal()) {
StageStrategy strategy = factory.get(current);
strategy.execute(context);
current = strategy.targetStatus();
}
推荐这种。每一轮都是独立的,栈不会增长,也方便在每步之间做日志、超时和中断检查。
状态什么时候写库?
这是断点续传的核心。顺序应该是:
- 执行策略,产出结果
- 把产出保存到实例记录
- 把 status 更新为目标状态
- 继续下一步
也就是先把这一步的产出落库,再改状态。这样如果更新状态之后服务崩了,重启后从新状态继续,不会重复执行上一步。
反例:先改状态、再执行下一步。如果改完状态还没来得及跑下一步就崩了,重启后从新状态继续,看起来没问题;但如果策略执行到一半崩了,产出没保存,状态却已经是下一步,重启后会跳过这一步,数据就丢了。
一句话:产出和状态尽量在同一个事务里更新,或者用版本号保证顺序。
信息不足时:写回当前状态,不要标 FAILED
比如"需求澄清"阶段发现用户没说清风格。这不是失败,是"等人"。
正确做法:把 status 写回 REQUIREMENT(或者保持不动),把"还需要什么信息"存到上下文里,然后暂停。用户下次补充时,从 REQUIREMENT 继续。
把"等待输入"标成 FAILED,是状态机最常见的语义错误------FAILED 应该只表示"重试也没用了"。
四、串一条真实流程
以"生成一份 PPT"为例:
REQUIREMENT(需求澄清)
↓ 信息足够
TEMPLATE(选模板)
↓
OUTLINE(生成大纲)
↓
SCHEMA(生成逐页结构)
↓
SEARCH(检索素材/配图)
↓
RENDER(渲染文件)
↓
SUCCESS
每个阶段都写清四件事:输入、输出、失败去哪、能不能暂停。
| 状态 | 输入 | 输出 | 失败去向 |
|---|---|---|---|
| REQUIREMENT | 用户原始需求 | 结构化需求 | 信息不足 → 留在本状态 |
| TEMPLATE | 结构化需求 | 模板 ID | FAILED |
| OUTLINE | 需求 + 模板 | 大纲文本 | 重试一次 → FAILED |
| SCHEMA | 大纲 | 逐页 JSON | 重试一次 → FAILED |
| SEARCH | 逐页 JSON | 素材列表 | 降级为空素材,继续 |
| RENDER | 全部上下文 | 文件地址 | FAILED |
注意 SEARCH 的失败策略是"降级继续":配图失败不应该让整份 PPT 生成失败。每个阶段的失败语义可以不同,这也是策略模式的好处------每个策略自己决定怎么处理异常。
还要留一条"修改旁路":用户说"把第三页改一下",不需要从 REQUIREMENT 重跑整条链,直接进 MODIFY 策略,改完回到 RENDER。状态机不是只能一条直线走。
五、可恢复性怎么落地
实例表至少要有这些字段:
sql
CREATE TABLE task_instance (
id VARCHAR(64) PRIMARY KEY,
conversation_id VARCHAR(64),
status VARCHAR(32), -- 当前状态
context_json TEXT, -- 恢复所需的所有上下文
version INT DEFAULT 0, -- 乐观锁,防重复执行
created_at DATETIME,
updated_at DATETIME
);
context_json 里存什么?判断标准只有一个:"重启后,下一步策略需要什么,就存什么"。比如:
- 结构化需求
- 选中的模板 ID
- 大纲全文
- 逐页 schema
- 素材列表(或者对象存储的 key)
不要存"可以从别处查到的"和"下一步用不到的",否则 JSON 会越来越臃肿。
恢复流程:
java
public void resume(String instanceId) {
Instance inst = store.get(instanceId);
if (inst.getStatus().isTerminal()) return;
StageContext context = new StageContext(inst);
Status current = inst.getStatus();
while (!current.isTerminal()) {
StageStrategy strategy = factory.get(current);
strategy.execute(context);
current = strategy.targetStatus();
store.updateStatus(instanceId, current, context.toJson());
}
}
六、13 个类怎么分层
一个完整实现大概会膨胀到十几个类,别慌,按职责分四层:
| 层 | 类 | 职责 |
|---|---|---|
| 入口层 | Agent / Controller | 接收请求、识别意图(新建/修改/继续)、加载实例 |
| 协议层 | Status、StageStrategy、StageContext | 定义状态枚举、策略接口、上下文载体 |
| 策略层 | 8 个具体策略 | 每个状态一个类,实现 execute |
| 装配层 | StrategyFactory | 注册所有策略,按 status 分发 |
入口层的意图识别容易被忽略:用户说的是"新建一个 PPT"还是"继续上次那个"还是"把第三页改一下",对应三条不同的入口路径。新建 = 创建实例;继续 = 读实例;修改 = 跳到修改策略。三条路径最后都汇到同一个驱动器。
七、完整伪代码
java
// 策略接口
public interface StageStrategy {
Status targetStatus();
void execute(StageContext context);
}
// 一个具体策略
public class OutlineStrategy implements StageStrategy {
@Override
public Status targetStatus() {
return Status.SCHEMA;
}
@Override
public void execute(StageContext context) {
String outline = llm.generateOutline(
context.getRequirement(), context.getTemplateId());
context.getStore().saveOutline(context.getInstanceId(), outline);
// 产出先落库,状态再更新
}
}
// 驱动器
public void run(String instanceId) {
Instance inst = store.get(instanceId);
Status current = inst.getStatus();
StageContext context = new StageContext(inst);
while (!current.isTerminal()) {
StageStrategy strategy = factory.get(current);
try {
strategy.execute(context);
current = strategy.targetStatus();
store.updateStatus(instanceId, current, context.toJson());
} catch (Exception e) {
store.updateStatus(instanceId, Status.FAILED, context.toJson());
throw e;
}
}
}
八、踩坑清单(6 条)
- 状态更新时机错:先改状态后存产出,崩溃后丢数据;正确是产出与状态同事务
- 递归推进状态:一层层递归调用,阶段多了栈溢出,改成循环
- 策略异常没落到 FAILED:实例永久卡在中间状态,用户刷新页面也继续不了
- 策略 Map 漏注册:运行到一半 NPE。启动时校验"每个枚举都有对应策略"
- context JSON 少存字段:恢复后空指针,尤其是"只存了 ID 没存内容"
- 信息不足标 FAILED:应该是"留在当前状态等待输入"
九、适用边界
适合:
- 阶段固定、可以枚举
- 耗时长、可能中途中断
- 需要人工确认/补充信息
- 要支持"继续上次的任务"
不适合:
- 开放式探索,阶段数事先不确定
- 需要大量并行子任务的场景(那更像 Plan-Execute)
一张对比表:
| 维度 | Plan-Execute | 状态机 |
|---|---|---|
| 计划来源 | 模型动态生成 | 产品/业务固定 |
| 并发 | 强(order 波次) | 弱(顺序流转) |
| 断点续传 | 部分 | 原生支持 |
| 适合 | 深度研究、报告 | 长流程、可恢复任务 |
本文为个人学习实践总结,示例代码为通用伪代码,不涉及任何具体项目源码。