Agent开发 06|状态与恢复:任务中断后如何继续?
《Agent开发》系列 · 第 06 篇
用户希望处理订单 1001 的金币未到账问题。AI 助手已经查询订单,创建了补发 500 金币的申请,正在等待运营人员审批。这时后端重启了。
重启之后,它还记得等待的是哪份申请吗?如果审批事件又来了一次,会不会再创建一份任务?更麻烦的是:假如金币已经补发成功,程序却在记录“任务完成”之前崩溃,恢复后会不会再发一次?
这些问题不能靠提示词解决,也不能只靠模型记住聊天内容。后端需要保存任务进度,按照明确规则恢复,并核对已经发生的业务操作。
本篇用一个不需要 API Key 的 SQLite 示例,实际复现“业务成功后、任务状态保存前崩溃”。先理解发生了什么,再看 State、Checkpoint、持久化和幂等分别解决哪一部分问题。
一、为什么重新问一遍模型,不能代替恢复?
一个 Agent 系统通常由三类参与者配合:大模型理解信息、提出工具请求或生成回答;AI 助手后端组织调用并执行校验;订单与账务系统提供数据、执行业务操作。
假设后端恢复后只问模型:“我们刚才做到哪了?”模型也许能从提供的历史中总结出“审批已经通过”。但这句话不能证明审批记录确实存在,更不能证明金币是否已经入账。
恢复必须回答几个可以核验的问题:
| 问题 | 应该依据什么 |
|---|---|
| 这是哪一个任务? | 稳定的任务标识 |
| 上次执行到了哪里? | 持久化的任务状态与执行记录 |
| 当前操作获得批准了吗? | 可信审批记录及批准范围 |
| 操作是否已经发生? | 业务系统的操作结果或账务记录 |
| 接下来允许执行什么? | 当前状态、业务条件与执行规则 |
模型可以帮助解释结果,但这些依据需要由后端读取和验证。恢复不是重新生成一段看起来连贯的对话,而是让程序从可核验的进度继续执行。
二、State:后端记录“任务现在是什么情况”
2.1 State 不只是一个状态字符串
State(状态)是程序维护的任务执行数据。WAITING_APPROVAL 是其中的阶段字段,完整状态还需要说明正在等待谁、处理哪个订单,以及下一步操作所需的信息。
例如:
{
"task_id": "task-1001",
"order_id": "1001",
"user_id": "user-a",
"coin_amount": 500,
"operation_key": "grant:1001",
"phase": "WAITING_APPROVAL",
"revision": 1,
"schema_version": 1
}
这里的 task_id 标识任务;operation_key 标识准备执行的那笔业务操作,后面会解释它怎样帮助防重;revision 标识任务状态更新到了第几版;schema_version 说明这份状态采用哪一版数据结构。
它们用途不同。两个不同任务可能指向同一笔业务操作,所以不能简单把每次新建的任务号都当成防重依据。
2.2 State、Context 与 Memory 怎样联系?
Context 是模型当前请求能够使用的输入。后端可以从 State 中选取任务进度和必要事实,组织进 Context;没有带进去的信息,不能假定模型自动知道。
Memory 是保存下来供后续交互使用的信息。会话内容常归入短期记忆,用户长期偏好归入长期记忆,任务的中间事实和待办事项也常被称为工作记忆。这些概念的划分会有重叠,工作记忆可以由 State 承载,不一定需要额外建一套系统。
但一条“用户偏好简洁回答”的长期记忆,与一份“批准补发 500 金币”的审批记录,不能采用相同的信任方式。前者辅助表达,后者需要可验证的身份、范围和有效性。
2.3 Session 和任务也不是同一个东西
Session(会话)通常关联一段用户交互。同一会话中可以创建多个任务,一个等待审批的任务也可能在用户关闭页面后继续存在。
本例使用固定任务号,简化了会话管理。真实系统需要把用户、租户、会话、任务和业务操作关联起来,同时在读取时检查访问权限。知道某个任务号,不等于获得了查看或恢复它的权限。
三、Checkpoint:保存“可以从这里恢复的进度”
3.1 State 是内容,Checkpoint 是某个执行位置的保存记录
假设后端依次经历:
创建申请
State:WAITING_APPROVAL,revision=1
保存 Checkpoint 1
↓
收到并核验审批
State:READY,revision=2
保存 Checkpoint 2
↓
核对并完成业务操作
State:SUCCEEDED,revision=3
保存 Checkpoint 3
Checkpoint(检查点)保存某个执行边界的状态,以及恢复所需的进度信息。根据 Runtime 的设计,它还可能包括下一步节点、已完成步骤、等待的事件和中断信息。
可以这样区分:State 回答“任务目前有哪些数据”,Checkpoint 回答“执行到这个位置时,保存了什么,之后怎样接着走”。
保存动作由后端程序或运行框架完成,不是由模型“记在脑子里”。某些框架提供 Checkpointer,帮你按框架的执行边界保存状态,但业务授权和外部操作核对仍需应用自己设计。LangGraph 持久化文档
3.2 本例怎样保存?
本例有一个 tasks 表,保存当前任务状态;还有一个 checkpoints 表,按版本保存阶段快照。更新任务行与写入检查点在同一个数据库事务中完成,避免一边更新成功、另一边失败。
恢复时读取 tasks 中最新的已提交状态,由 phase 决定后续操作。检查点表帮助查看阶段记录;本例没有实现任意历史版本回放,也没有实现通用工作流引擎。
仅把任意 Python 对象序列化成 JSON,并不自动得到可恢复系统。 程序还得知道怎样解释它、允许进入哪些步骤,以及哪些外部操作需要重新核对。
3.3 持久化不等于一定写数据库
持久化是让数据在进程退出后仍然存在。数据库、对象存储或其他可靠存储都可以承载不同类型的数据。选择需要考虑并发更新、查询、事务、容量和运维。
本文选择 SQLite,是为了用标准库在单机上演示事务与重启恢复。内存中的字典会随进程消失;SQLite 文件可以跨进程保留,但本例没有因此获得多机高可用、容灾和完整备份能力。
四、暂停与恢复:不要把等待理解成一直占着线程
4.1 审批等待是一种可恢复的业务状态
审批可能需要几小时。后端可以先保存待审批任务并结束当前处理,等审批事件到来时,再启动新的处理过程:
后端收到处理请求
↓
创建待审批任务并提交状态
↓
返回“等待审批”,当前处理结束
稍后,审批事件到来
↓
后端验证审批人、申请标识和批准范围
↓
保存批准记录,将任务转为 READY
↓
读取当前业务状态,执行允许的后续工作
等待不要求原来的函数、连接或机器一直存活。恢复发生在另一个进程也可以,只要它能读取必要状态,并遵守相同的规则。
4.2 恢复不一定从崩溃前那一行继续
本例重启后重新进入 resume(),先核对业务操作,而不是恢复 Python 的调用栈。
框架也有各自的恢复语义。例如,LangGraph 的中断恢复可能重新执行包含中断的节点,因此中断前的代码可能再次运行。带有业务写入的步骤需要考虑重放,不应假定“之前执行过的代码绝不会再跑”。LangGraph Interrupts 文档
4.3 事件可能重复,状态推进也要有规则
消息重投、用户重复点击、网络重试,都可能使同一审批被处理多次。
本例把每个任务的批准记录设为唯一:同一范围的重复批准返回 ALREADY_APPROVED,不重复新增检查点。当前请求如果已经偏离批准范围,则拒绝执行。
完整系统还要处理拒绝、撤销、过期、修改后重新申请等状态。不能只用一个 approved=True 覆盖整个审批生命周期,也不能允许晚到的旧批准覆盖更新后的拒绝或新申请。
五、最危险的间隙:业务成功了,Checkpoint 还没保存
5.1 为什么恢复时只读任务状态会出错?
考虑这段过程:
任务为 READY
↓
调用账务服务,金币增加 500,业务提交成功
↓
进程崩溃
× 尚未把任务改成 SUCCEEDED
重启后,任务记录仍然是 READY。如果程序把它解释为“业务尚未执行”,就可能再增加 500 金币。
Checkpoint 保存的是 Runtime 已确认的进度,不必然与外部系统的最新事实完全同步。旧检查点说明“尚未记录完成”,不能单独证明“操作没有发生”。
5.2 幂等:同一笔业务操作重复提交,也不重复产生效果
为订单 1001 的这笔发放使用稳定操作标识 grant:1001。恢复后继续使用它,而不是每次重试都生成新编号。
业务服务接到请求后,检查这笔操作是否已经完成:已经完成则返回已保存的结果;没有完成才执行写入。这个“重复提交不重复产生业务效果”的性质,就是这里需要的幂等性。
防重规则还要符合业务含义。本例假设每张订单只允许一次完整发放,因此账务表同时要求 order_id 唯一。真实业务如果允许分批、退款后重新发放等情况,需要更精确的业务标识与规则,不能照搬“一张订单永远只有一行”。
5.3 去重记录和余额更新必须保持一致
如果先保存“已处理”,再更新余额,第二步失败可能导致以后永远无法补发。如果先更新余额,再单独保存“已处理”,中间失败又可能重复增加余额。
本例把发放记录和余额更新放入同一个 SQLite 写事务,并用唯一约束限制重复记录。发生异常时,两项更新一起回滚。SQLite 的 BEGIN IMMEDIATE 会先取得写事务,本例的并发恢复通过数据库串行化写入。SQLite 事务文档
需要注意:事务本身不定义什么叫重复。唯一业务标识、去重规则与事务一致性必须一起设计。 两次普通的“余额加 500”各自放进事务,仍然可能都成功。
如果账务服务是远程系统,不能用后端数据库事务包住一次 HTTP 请求就宣称原子完成。应该由业务服务提供幂等与结果查询能力;结果暂时不明确时,保留待核对状态并继续对账。
六、代码实践:真的让进程退出,再恢复
6.1 示例范围
配套文件在 demo/06-state-recovery/state_recovery.py,完整代码见附录。需要 Python 3.10+,无需第三方包和模型密钥。
本例直接从“已创建待审批申请”开始,使用固定订单和模拟可信审批事件。它没有真实模型、用户认证、租户隔离、审批页面或支付渠道接口。
账务表与任务表放在同一个 SQLite 文件中,但业务提交与任务完成分为两个事务,刻意保留刚才解释的故障间隙,以观察恢复行为。
6.2 先保存待审批任务
复制附录保存为 state_recovery.py,在文件所在目录依次运行。建议使用一个新的数据库文件名,避免之前练习的状态影响结果:
python3 state_recovery.py init --db lesson06.sqlite3
python3 state_recovery.py status --db lesson06.sqlite3
此时任务为 WAITING_APPROVAL,余额为 0,检查点数量为 1。两次命令是不同进程,仍然读到同一份记录。
init 不会重置已有任务或余额。需要重做实验时换一个新的 --db 文件名,不要误以为重复初始化能撤销已经发生的业务操作。
6.3 批准后,在业务提交之后退出
python3 state_recovery.py approve --db lesson06.sqlite3
python3 state_recovery.py resume --db lesson06.sqlite3 --crash-after-grant
第二条命令输出:
业务结果: GRANTED
模拟崩溃:业务已提交,成功检查点尚未保存
命令会以退出码 75 结束,这是故意注入的故障。这里模拟的是进程在确定位置退出,不是整机断电或磁盘损坏。
接着查看状态:
python3 state_recovery.py status --db lesson06.sqlite3
可以看到:
{"balance": 500, "checkpoints": 2, "grants": 1, "phase": "READY", "revision": 2}
这正是需要理解的情况:任务记录没完成,业务却已经成功。
6.4 重启恢复,再重复恢复一次
python3 state_recovery.py resume --db lesson06.sqlite3
python3 state_recovery.py resume --db lesson06.sqlite3
恢复时业务层返回 ALREADY_GRANTED,后端核对已有记录并保存成功状态。再次运行也不会重复入账,最终为:
{"balance": 500, "checkpoints": 3, "grants": 1, "phase": "SUCCEEDED", "revision": 3}
可以看到,代码可能执行多次,但业务只入账一次。这个示例没有证明任意分布式场景的“恰好执行一次”,验证的是本地数据库约束下同一笔发放不重复生效。
七、关键代码为什么这样安排?
7.1 先核验批准范围,再处理重复请求
grant_once() 先读取任务与审批记录,比较操作、订单、用户、金币数量和操作标识。参数合法,不等于参数已经获批。
随后查询已有发放记录。如果发现同一订单已有不同用户、数量或操作标识的记录,程序报错要求核对,而不是悄悄当作成功。
这条顺序也意味着,重复调用不能绕过批准范围检查。本例的终态查询返回历史已完成结果,并不承诺当前账户余额还等于当初的发放数量;真实账户后来可能消费或发生其他变动。
7.2 业务结果先提交,任务完成后记录
恢复的核心结构是:
result = grant_once(path)
print("业务结果:", result, flush=True)
if crash_after_grant:
print("模拟崩溃:业务已提交,成功检查点尚未保存", flush=True)
os._exit(75)
finish(path)
grant_once() 的事务已经结束,finish() 才去更新任务。故障开关就在两者之间。
finish() 也不会只凭调用者说成功就更新状态:它再次确认批准范围与账务记录匹配,然后才把阶段改成 SUCCEEDED 并保存检查点。
7.3 为什么保存版本号?
revision 让我们看见任务经历了哪些更新。本例用数据库写事务控制并发,没有把 revision 实现成乐观锁。
如果改用乐观并发控制,需要像“只在数据库版本仍为 2 时更新到 3”这样做条件更新,并检查受影响行数;发现冲突后重新读取或拒绝,不能只是把数字加一。
schema_version 处理另一类问题:新代码是否还能理解旧状态。本例遇到未知版本会拒绝恢复,没有自动迁移功能。生产升级需要设计迁移、兼容处理或旧版本任务的继续执行策略。
八、从这个 Demo 到可靠恢复,还要补什么?
| 问题 | 本例做到了什么 | 真实系统还需要考虑什么 |
|---|---|---|
| 进程重启 | SQLite 保存状态,重新启动可读取 | 存储故障、备份与恢复演练 |
| 重复执行 | 唯一约束与事务限制重复入账 | 远程幂等期限、业务规则和对账 |
| 并发恢复 | 单机 SQLite 写事务串行化 | 多实例任务领取、租约与过期工作者隔离 |
| 人工审批 | 固定可信事件与范围快照 | 认证、审批人权限、过期、撤销与审计 |
| 状态变化 | 阶段校验及检查点记录 | 拒绝、取消、补偿和人工接管路径 |
| 代码升级 | 拒绝未知状态版本 | 迁移与兼容性验证 |
租约是给某个工作者一段时间的任务处理权;它过期后可能由别人接手。原工作者如果还在运行,就可能产生并发。因此,复杂系统还需要版本或隔离标识让过期工作者的写入失效,不能只依靠“我已经拿到任务”这段内存判断。
取消也不等于回滚。用户取消时,业务可能已经执行,需要查询结果并按业务规则决定是否补偿。不能把状态改成 CANCELLED 就当作金币从未发过。
九、如何验证恢复机制?
配套 test_state_recovery.py 使用临时数据库,包含跨进程崩溃恢复、重复批准、未审批拒绝、批准范围变化、支付状态变化、缺失账户回滚、未知版本拒绝、成功证据核验和两个进程并发恢复等检查。
在配套目录运行:
python3 -m unittest -v test_state_recovery.py
最重要的验证不是“恢复函数返回了成功”,而是同时检查任务与业务结果:余额是否只增加一次,发放记录是否唯一,检查点是否对应已提交状态。
测试覆盖的是列出的本地场景,不代表真实支付系统、分布式网络或多机灾备已通过验证。
十、面试与自查
Q:State 和 Checkpoint 是什么关系?
State 是任务的执行数据;Checkpoint 是某个执行边界保存的状态与恢复进度。后端或框架负责保存和恢复。检查点需要能指向下一步处理,但不保证外部业务操作与它同步提交。
Q:保存了 Checkpoint,为什么还需要幂等?
因为业务可能先成功,而检查点尚未更新。恢复会再次进入相关步骤,必须用稳定的业务操作标识核对已有结果,避免重复产生效果。
Q:如何处理审批等待期间重启?
先持久化任务与申请关联,结束当前处理;审批事件到来后验证身份、范围和当前状态,再恢复任务。执行前重新核对业务条件,不直接信任旧摘要。
请尝试回答三个问题:
- 余额已经增加,但任务仍为
READY,应该重新发放还是先核对? - 每次重试都生成新的幂等键,会有什么后果?
- 把任务恢复到昨天的 Checkpoint,会不会自动撤销今天已经发生的金币写入?
参考思路:先核对已有业务操作;新键可能让业务服务把重试当成新请求;恢复任务历史不会自动撤销外部写入,撤销或补偿需要独立业务流程。
十一、总结
可靠恢复需要三类信息配合:任务状态说明正在处理什么,检查点记录已保存的执行进度,业务系统说明操作实际发生了什么。
后端恢复后不能只看一句“审批通过”,也不能只看阶段仍是 READY。它需要核对批准范围与业务结果,使用稳定操作标识控制重复执行,再把确认后的进度保存下来。
参考资料
附录:完整可运行代码
文件名:state_recovery.py。与配套示例一致;测试文件单独放在配套目录。
"""SQLite 状态恢复教学示例。Python 3.10+,无第三方依赖。
CLI 模拟可信后台操作,不提供用户认证接口,也不调用模型。
"""
import argparse
import json
import os
import sqlite3
from contextlib import contextmanager
TASK_ID = "task-1001"
def encode(value):
return json.dumps(value, ensure_ascii=False, sort_keys=True)
@contextmanager
def connect(path):
db = sqlite3.connect(path, timeout=10, isolation_level=None)
db.row_factory = sqlite3.Row
db.execute("PRAGMA foreign_keys = ON")
try:
yield db
finally:
db.close()
@contextmanager
def transaction(db):
db.execute("BEGIN IMMEDIATE")
try:
yield
db.commit()
except BaseException:
db.rollback()
raise
def load_task(db):
row = db.execute("SELECT * FROM tasks WHERE task_id=?", (TASK_ID,)).fetchone()
if row is None:
raise ValueError("请先运行 init")
if row["schema_version"] != 1:
raise ValueError("不支持的状态版本,需要迁移后再恢复")
return dict(row)
def save_checkpoint(db, task):
# 调用者在同一事务中保存任务行与检查点。
db.execute(
"INSERT INTO checkpoints VALUES (?, ?, ?)",
(task["task_id"], task["revision"], encode(task)),
)
def scope(task):
return {
"operation": "grant_coins",
"order_id": task["order_id"],
"user_id": task["user_id"],
"coin_amount": task["coin_amount"],
"operation_key": task["operation_key"],
}
def init(path):
with connect(path) as db:
db.executescript("""
CREATE TABLE IF NOT EXISTS orders (
order_id TEXT PRIMARY KEY, user_id TEXT NOT NULL,
coin_amount INTEGER NOT NULL CHECK(coin_amount > 0), paid INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS accounts (
user_id TEXT PRIMARY KEY, balance INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS tasks (
task_id TEXT PRIMARY KEY, order_id TEXT NOT NULL,
user_id TEXT NOT NULL, coin_amount INTEGER NOT NULL CHECK(coin_amount > 0),
operation_key TEXT NOT NULL, phase TEXT NOT NULL,
revision INTEGER NOT NULL, schema_version INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS approvals (
task_id TEXT PRIMARY KEY, approved_scope TEXT NOT NULL,
reviewer_id TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS checkpoints (
task_id TEXT NOT NULL, revision INTEGER NOT NULL, snapshot TEXT NOT NULL,
PRIMARY KEY(task_id, revision)
);
CREATE TABLE IF NOT EXISTS grants (
operation_key TEXT PRIMARY KEY, order_id TEXT NOT NULL UNIQUE,
user_id TEXT NOT NULL, coin_amount INTEGER NOT NULL
);
""")
with transaction(db):
db.execute("INSERT OR IGNORE INTO orders VALUES ('1001','user-a',500,1)")
db.execute("INSERT OR IGNORE INTO accounts VALUES ('user-a',0)")
cursor = db.execute(
"INSERT OR IGNORE INTO tasks VALUES (?,?,?,?,?,?,?,?)",
(TASK_ID, "1001", "user-a", 500, "grant:1001", "WAITING_APPROVAL", 1, 1),
)
if cursor.rowcount:
save_checkpoint(db, load_task(db))
def approve(path):
with connect(path) as db, transaction(db):
task = load_task(db)
existing = db.execute("SELECT * FROM approvals WHERE task_id=?", (TASK_ID,)).fetchone()
if existing:
if existing["approved_scope"] != encode(scope(task)):
raise PermissionError("当前请求与批准范围不一致")
return "ALREADY_APPROVED"
if task["phase"] != "WAITING_APPROVAL":
raise ValueError("当前状态不允许审批")
# 演示固定的可信审批事件,生产中必须先验证审批人和事件。
db.execute("INSERT INTO approvals VALUES (?,?,?)",
(TASK_ID, encode(scope(task)), "operator-demo"))
db.execute("UPDATE tasks SET phase='READY',revision=revision+1 WHERE task_id=?", (TASK_ID,))
save_checkpoint(db, load_task(db))
return "APPROVED"
def grant_once(path):
"""模拟业务服务:审批核验、去重记录和余额变更在同一写事务中。"""
with connect(path) as db, transaction(db):
task = load_task(db)
approval = db.execute("SELECT * FROM approvals WHERE task_id=?", (TASK_ID,)).fetchone()
if task["phase"] not in {"READY", "SUCCEEDED"} or approval is None:
raise PermissionError("任务尚未获得执行许可")
if approval["approved_scope"] != encode(scope(task)):
raise PermissionError("执行请求超出批准范围")
previous = db.execute("SELECT * FROM grants WHERE order_id=?", (task["order_id"],)).fetchone()
if previous:
if (previous["user_id"], previous["coin_amount"], previous["operation_key"]) != (
task["user_id"], task["coin_amount"], task["operation_key"]
):
raise ValueError("已有发放与当前请求冲突,需要核对")
return "ALREADY_GRANTED"
order = db.execute("SELECT * FROM orders WHERE order_id=?", (task["order_id"],)).fetchone()
if order is None or order["paid"] != 1:
raise ValueError("订单不存在或支付无效")
if (order["user_id"], order["coin_amount"]) != (task["user_id"], task["coin_amount"]):
raise ValueError("当前订单与批准请求不匹配")
db.execute("INSERT INTO grants VALUES (?,?,?,?)", (
task["operation_key"], task["order_id"], task["user_id"], task["coin_amount"]))
cursor = db.execute("UPDATE accounts SET balance=balance+? WHERE user_id=?",
(task["coin_amount"], task["user_id"]))
if cursor.rowcount != 1:
raise ValueError("目标账户不存在")
return "GRANTED"
def finish(path):
with connect(path) as db, transaction(db):
task = load_task(db)
approval = db.execute("SELECT * FROM approvals WHERE task_id=?", (TASK_ID,)).fetchone()
grant = db.execute("SELECT * FROM grants WHERE operation_key=?", (task["operation_key"],)).fetchone()
if approval is None or approval["approved_scope"] != encode(scope(task)):
raise PermissionError("批准范围已发生变化")
if grant is None or (grant["order_id"], grant["user_id"], grant["coin_amount"]) != (
task["order_id"], task["user_id"], task["coin_amount"]
):
raise ValueError("没有匹配的业务成功记录")
if task["phase"] == "SUCCEEDED":
return
if task["phase"] != "READY":
raise ValueError("当前状态不能标记成功")
db.execute("UPDATE tasks SET phase='SUCCEEDED',revision=revision+1 WHERE task_id=?", (TASK_ID,))
save_checkpoint(db, load_task(db))
def resume(path, crash_after_grant=False):
result = grant_once(path)
print("业务结果:", result, flush=True)
if crash_after_grant:
print("模拟崩溃:业务已提交,成功检查点尚未保存", flush=True)
os._exit(75)
finish(path)
return "SUCCEEDED"
def status(path):
with connect(path) as db:
task = load_task(db)
row = db.execute("SELECT balance FROM accounts WHERE user_id=?", (task["user_id"],)).fetchone()
return {
"phase": task["phase"], "revision": task["revision"],
"balance": row["balance"] if row else None,
"grants": db.execute("SELECT count(*) FROM grants").fetchone()[0],
"checkpoints": db.execute("SELECT count(*) FROM checkpoints").fetchone()[0],
}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("command", choices=["init", "approve", "resume", "status"])
parser.add_argument("--db", default="state_demo.sqlite3")
parser.add_argument("--crash-after-grant", action="store_true")
args = parser.parse_args()
if args.crash_after_grant and args.command != "resume":
parser.error("--crash-after-grant 只能用于 resume")
if args.command == "init":
init(args.db)
elif args.command == "approve":
print(approve(args.db))
elif args.command == "resume":
print(resume(args.db, args.crash_after_grant))
print(encode(status(args.db)))
if __name__ == "__main__":
main()
可以亲手运行一次故障路径:看见余额已经变化,而任务仍停在 READY,再观察恢复如何核对结果。只有把这两个状态分开看,才容易理解为什么“存档”和“防重”缺一不可。
任务现在能够跨重启继续,但调查还需要可靠的业务知识。下一篇:Agent开发 07|RAG:如何找到并用好企业知识? 我们将讨论如何找到适用的文档片段,并让回答有可追溯的依据。