Agent开发 06|状态与恢复:任务中断后如何继续?

Agent开发 06|状态与恢复:任务中断后如何继续?

《Agent开发》系列 · 第 06 篇

用户希望处理订单 1001 的金币未到账问题。AI 助手已经查询订单,创建了补发 500 金币的申请,正在等待运营人员审批。这时后端重启了。

重启之后,它还记得等待的是哪份申请吗?如果审批事件又来了一次,会不会再创建一份任务?更麻烦的是:假如金币已经补发成功,程序却在记录"任务完成"之前崩溃,恢复后会不会再发一次?

这些问题不能靠提示词解决,也不能只靠模型记住聊天内容。后端需要保存任务进度,按照明确规则恢复,并核对已经发生的业务操作。

本篇用一个不需要 API Key 的 SQLite 示例,实际复现"业务成功后、任务状态保存前崩溃"。先理解发生了什么,再看 State、Checkpoint、持久化和幂等分别解决哪一部分问题。

一、为什么重新问一遍模型,不能代替恢复?

一个 Agent 系统通常由三类参与者配合:大模型理解信息、提出工具请求或生成回答;AI 助手后端组织调用并执行校验;订单与账务系统提供数据、执行业务操作。

假设后端恢复后只问模型:"我们刚才做到哪了?"模型也许能从提供的历史中总结出"审批已经通过"。但这句话不能证明审批记录确实存在,更不能证明金币是否已经入账。

恢复必须回答几个可以核验的问题:

问题 应该依据什么
这是哪一个任务? 稳定的任务标识
上次执行到了哪里? 持久化的任务状态与执行记录
当前操作获得批准了吗? 可信审批记录及批准范围
操作是否已经发生? 业务系统的操作结果或账务记录
接下来允许执行什么? 当前状态、业务条件与执行规则

模型可以帮助解释结果,但这些依据需要由后端读取和验证。恢复不是重新生成一段看起来连贯的对话,而是让程序从可核验的进度继续执行。

二、State:后端记录"任务现在是什么情况"

2.1 State 不只是一个状态字符串

State(状态)是程序维护的任务执行数据。WAITING_APPROVAL 是其中的阶段字段,完整状态还需要说明正在等待谁、处理哪个订单,以及下一步操作所需的信息。

例如:

json 复制代码
{
  "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 是某个执行位置的保存记录

假设后端依次经历:

text 复制代码
创建申请
    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 审批等待是一种可恢复的业务状态

审批可能需要几小时。后端可以先保存待审批任务并结束当前处理,等审批事件到来时,再启动新的处理过程:

text 复制代码
后端收到处理请求
    ↓
创建待审批任务并提交状态
    ↓
返回"等待审批",当前处理结束

稍后,审批事件到来
    ↓
后端验证审批人、申请标识和批准范围
    ↓
保存批准记录,将任务转为 READY
    ↓
读取当前业务状态,执行允许的后续工作

等待不要求原来的函数、连接或机器一直存活。恢复发生在另一个进程也可以,只要它能读取必要状态,并遵守相同的规则。

4.2 恢复不一定从崩溃前那一行继续

本例重启后重新进入 resume(),先核对业务操作,而不是恢复 Python 的调用栈。

框架也有各自的恢复语义。例如,LangGraph 的中断恢复可能重新执行包含中断的节点,因此中断前的代码可能再次运行。带有业务写入的步骤需要考虑重放,不应假定"之前执行过的代码绝不会再跑"。LangGraph Interrupts 文档

4.3 事件可能重复,状态推进也要有规则

消息重投、用户重复点击、网络重试,都可能使同一审批被处理多次。

本例把每个任务的批准记录设为唯一:同一范围的重复批准返回 ALREADY_APPROVED,不重复新增检查点。当前请求如果已经偏离批准范围,则拒绝执行。

完整系统还要处理拒绝、撤销、过期、修改后重新申请等状态。不能只用一个 approved=True 覆盖整个审批生命周期,也不能允许晚到的旧批准覆盖更新后的拒绝或新申请。

五、最危险的间隙:业务成功了,Checkpoint 还没保存

5.1 为什么恢复时只读任务状态会出错?

考虑这段过程:

text 复制代码
任务为 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,在文件所在目录依次运行。建议使用一个新的数据库文件名,避免之前练习的状态影响结果:

bash 复制代码
python3 state_recovery.py init --db lesson06.sqlite3
python3 state_recovery.py status --db lesson06.sqlite3

此时任务为 WAITING_APPROVAL,余额为 0,检查点数量为 1。两次命令是不同进程,仍然读到同一份记录。

init 不会重置已有任务或余额。需要重做实验时换一个新的 --db 文件名,不要误以为重复初始化能撤销已经发生的业务操作。

6.3 批准后,在业务提交之后退出

bash 复制代码
python3 state_recovery.py approve --db lesson06.sqlite3
python3 state_recovery.py resume --db lesson06.sqlite3 --crash-after-grant

第二条命令输出:

text 复制代码
业务结果: GRANTED
模拟崩溃:业务已提交,成功检查点尚未保存

命令会以退出码 75 结束,这是故意注入的故障。这里模拟的是进程在确定位置退出,不是整机断电或磁盘损坏。

接着查看状态:

bash 复制代码
python3 state_recovery.py status --db lesson06.sqlite3

可以看到:

json 复制代码
{"balance": 500, "checkpoints": 2, "grants": 1, "phase": "READY", "revision": 2}

这正是需要理解的情况:任务记录没完成,业务却已经成功。

6.4 重启恢复,再重复恢复一次

bash 复制代码
python3 state_recovery.py resume --db lesson06.sqlite3
python3 state_recovery.py resume --db lesson06.sqlite3

恢复时业务层返回 ALREADY_GRANTED,后端核对已有记录并保存成功状态。再次运行也不会重复入账,最终为:

json 复制代码
{"balance": 500, "checkpoints": 3, "grants": 1, "phase": "SUCCEEDED", "revision": 3}

可以看到,代码可能执行多次,但业务只入账一次。这个示例没有证明任意分布式场景的"恰好执行一次",验证的是本地数据库约束下同一笔发放不重复生效。

七、关键代码为什么这样安排?

7.1 先核验批准范围,再处理重复请求

grant_once() 先读取任务与审批记录,比较操作、订单、用户、金币数量和操作标识。参数合法,不等于参数已经获批。

随后查询已有发放记录。如果发现同一订单已有不同用户、数量或操作标识的记录,程序报错要求核对,而不是悄悄当作成功。

这条顺序也意味着,重复调用不能绕过批准范围检查。本例的终态查询返回历史已完成结果,并不承诺当前账户余额还等于当初的发放数量;真实账户后来可能消费或发生其他变动。

7.2 业务结果先提交,任务完成后记录

恢复的核心结构是:

python 复制代码
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 使用临时数据库,包含跨进程崩溃恢复、重复批准、未审批拒绝、批准范围变化、支付状态变化、缺失账户回滚、未知版本拒绝、成功证据核验和两个进程并发恢复等检查。

在配套目录运行:

bash 复制代码
python3 -m unittest -v test_state_recovery.py

最重要的验证不是"恢复函数返回了成功",而是同时检查任务与业务结果:余额是否只增加一次,发放记录是否唯一,检查点是否对应已提交状态。

测试覆盖的是列出的本地场景,不代表真实支付系统、分布式网络或多机灾备已通过验证。

十、面试与自查

Q:State 和 Checkpoint 是什么关系?

State 是任务的执行数据;Checkpoint 是某个执行边界保存的状态与恢复进度。后端或框架负责保存和恢复。检查点需要能指向下一步处理,但不保证外部业务操作与它同步提交。

Q:保存了 Checkpoint,为什么还需要幂等?

因为业务可能先成功,而检查点尚未更新。恢复会再次进入相关步骤,必须用稳定的业务操作标识核对已有结果,避免重复产生效果。

Q:如何处理审批等待期间重启?

先持久化任务与申请关联,结束当前处理;审批事件到来后验证身份、范围和当前状态,再恢复任务。执行前重新核对业务条件,不直接信任旧摘要。

请尝试回答三个问题:

  1. 余额已经增加,但任务仍为 READY,应该重新发放还是先核对?
  2. 每次重试都生成新的幂等键,会有什么后果?
  3. 把任务恢复到昨天的 Checkpoint,会不会自动撤销今天已经发生的金币写入?

参考思路:先核对已有业务操作;新键可能让业务服务把重试当成新请求;恢复任务历史不会自动撤销外部写入,撤销或补偿需要独立业务流程。

十一、总结

可靠恢复需要三类信息配合:任务状态说明正在处理什么,检查点记录已保存的执行进度,业务系统说明操作实际发生了什么。

后端恢复后不能只看一句"审批通过",也不能只看阶段仍是 READY。它需要核对批准范围与业务结果,使用稳定操作标识控制重复执行,再把确认后的进度保存下来。

参考资料

附录:完整可运行代码

文件名:state_recovery.py。与配套示例一致;测试文件单独放在配套目录。

python 复制代码
"""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:如何找到并用好企业知识? 我们将讨论如何找到适用的文档片段,并让回答有可追溯的依据。

相关推荐
J船长16 分钟前
Agent开发 09|Model Gateway:怎么选模型、做降级、算成本?
agent
J船长18 分钟前
Agent开发·阶段总结(二)|从上下文到评测,串起 Agent 的信息与质量管理
agent
J船长1 小时前
Agent开发 05|Context Engineering:如何构建高质量的模型上下文?
agent
J船长1 小时前
Agent开发·阶段总结(一)|从工具调用到协作审批,串起 Agent 的执行过程
agent
J船长2 小时前
Agent开发 04|协作与审批:怎样分工、何时让人确认?
agent
江屿风3 小时前
AI Agent架构全解析:从规划到记忆的智能跃迁
人工智能·笔记·架构·agent·c/s·mcp工作流
J船长5 小时前
Agent开发 03|架构选型:不同模式怎么选?
agent
J船长6 小时前
Agent开发 02|Agent Loop:任务如何持续执行?
agent
J船长7 小时前
Agent开发 01|Function Calling:AI 如何调用工具?
agent