AbortController 与 terminate 设计原理#

用户点击”停止”按钮时，发生了什么？

如果 LLM 正在响应 → AbortController.abort() 立即中断 HTTP 流如果工具正在执行 → 工具返回 terminate: true 不继续下一轮

两种场景，两种机制，两种设计模式。

AbortController：预先注册模式#

AbortController 不是”中途注入”，而是”预先注册”。

设计思想#

想象一个快递系统：

1
你下单时告诉快递员："如果我不想要了，打这个电话取消"
2
│
3
│  电话号码 = AbortSignal（预先注册的"取消通道")
4
│
5
│  快递员在送货过程中不断检查："电话有没有被打？"
6
│
7
│  如果被打 → 停止送货 → 通知你"已取消"

三个阶段#

创建阶段（预先注册）

1
const abortCtrl = new AbortController();
2
agent.run(input, { signal: abortCtrl.signal });

Agent 内部：

持有 signal 引用（不是一次性传递，而是持续持有）
每次调用 LLM、每次读取数据，都带上这个 signal

运行阶段（持续检查）

1
// HTTP 请求层
2
fetch(url, { signal });
3

4
// 底层内部
5
while (读取数据) {
6
  if (signal.aborted) {  // 每次循环都检查
7
    throw AbortError;
8
  }
9
  // 继续读取...
10
}

取消阶段（触发信号）

1
// 用户点击"停止"
2
abortCtrl.abort();
3

4
// 发生什么
5
signal.aborted = true         // 状态改变
6
所有检查 signal.aborted 的地方 → "看到"变化 → 触发错误
7
Agent 捕获错误 → 发出 error 事件 → Agent 结束

关键：状态共享，而非消息传递#

传统消息传递：用户发送”停止”消息 → Agent 收到消息 → 处理

AbortController 设计：用户改变 signal.aborted = true → Agent 持有的 signal 引用看到变化 → 自动触发错误

区别：

消息传递：需要 Agent 有接收逻辑
AbortController：Agent 只需持有引用，底层自动检查

terminate：返回值携带模式#

terminate 不是”注入”，而是”返回值自带标记”。

设计思想#

想象餐厅用餐：

1
你吃完饭后，服务员问："还需要点别的吗？"
2
│
3
│  如果你只是吃完一道菜：
4
│  → 服务员："好的，下一道菜"（继续）
5
│
6
│  如果你吃完了整个套餐：
7
│  → 你说："不用了，我吃完了"（terminate）
8
│  → 服务员不继续推荐，直接结账
9
│
10
│  "我吃完了"就是 terminate: true
11
│  它是你的"回答"，不是服务员的"指令"

三个阶段#

工具执行阶段

1
async execute(id, args, signal, onUpdate) {
2
  // 执行工具逻辑...
3

4
  return {
5
    content: [...],
6
    terminate: true  // 工具自己决定
7
  };
8
}

Agent 收集阶段

1
const results = [
2
  { content: [...], terminate: true },   // 工具A
3
  { content: [...], terminate: false },  // 工具B
4
];
5

6
// Agent 问：所有工具都说"我吃完了"吗？
7
const allTerminate = results.every(r => r.terminate === true);
8

9
// 不全是 → 继续调用 LLM
10
// 全是 → 结束本轮

决策阶段

1
if (allTerminate) {
2
  // 所有工具都说"不需要继续了"
3
  // Agent 结束，不调用 LLM
4
} else {
5
  // 还有工具需要继续
6
  // Agent 用工具结果调用 LLM → 继续生成
7
}

关键：返回值携带决策信息#

传统设计：Agent → 工具执行 → Agent 决定是否继续

terminate 设计：Agent → 工具执行 → 工具返回结果 + terminate 建议 → Agent 检查建议 → 决定是否继续

优势：

工具可以表达”我已完成最终输出”
Agent 不需要猜测工具意图
批量工具时，所有工具都同意才停止（安全设计）

两种模式对比#

特性对比#

特性	AbortController	terminate
设计模式	预先注册 + 状态共享	返回值携带
注入时机	创建时注册，运行时检查	执行后返回，Agent收集检查
触发方式	外部改变状态	内部返回值携带
传播方式	引用共享（多处同时看到）	值传递（逐层返回）
生效时机	立即（下次检查时）	执行完成后
作用对象	HTTP请求、数据读取	Agent轮次逻辑
事件表现	error (reason: aborted)	正常 tool_execution_end

图示对比#

AbortController（预先注册）：

1
创建时 ──────────────────────────────────────→ 运行时
2
  │                                              │
3
  │  注册 signal                                 │  检查 signal.aborted
4
  │  ↓                                           │  ↓
5
  │  Agent 持有引用                              │  每个操作都检查
6
  │  HTTP 持有引用                               │  if (aborted) throw Error
7
  │                                              │
8
  ↓                                              ↓
9
用户调用 abort()                              Agent 收到错误
10
  │                                              │
11
  │  signal.aborted = true                       │  发出 error 事件
12
  │                                              │  Agent 结束
13
  ↓                                              ↓

terminate（返回值携带）：

1
执行时 ──────────────────────────────────────→ 完成时
2
  │                                              │
3
  │  tool.execute()                              │  tool 返回结果
4
  │                                              │  { terminate: true }
5
  │                                              │
6
  ↓                                              ↓
7
Agent 等待                                    Agent 收集所有结果
8
  │                                              │
9
  │                                              │  检查 every(terminate)
10
  │                                              │  ↓
11
  │                                              │  决定是否继续
12
  ↓                                              ↓

Web Chat 停止功能实现#

用户点击”停止”按钮时，同时触发两个机制：

两层停止机制#

1
// 优雅停止（推荐）
2
function handleGracefulCancel() {
3
  cancelRequested = true;  // 标记取消意图
4
}
5

6
// 强制停止（紧急情况）
7
function handleForceCancel() {
8
  abortCtrl.abort();  // 立即中断 HTTP
9
}

AgentRunner 实现#

1
class AgentRunner {
2
  private abortCtrl: AbortController | null = null;
3
  private cancelRequested = false;  // 优雅取消标志
4

5
  // 优雅取消：工具继续执行，完成后 Agent 终止
6
  gracefulCancel() {
7
    this.cancelRequested = true;
8
  }
9

10
  // 强制取消：立即中断
11
  forceCancel() {
12
    this.abortCtrl?.abort();
13
  }
14

15
  async run(input: string) {
16
    this.abortCtrl = new AbortController();
17
    this.cancelRequested = false;
18

19
    const agent = new Agent({
20
      model: { ... },
21
      tools: [...],
22

23
      // 关键：afterToolCall 检查取消状态
24
      afterToolCall: async (context, signal) => {
25
        if (this.cancelRequested) {
26
          console.log("[优雅取消] 工具已完成，Agent 将终止");
27
          return {
28
            content: context.result.content,  // 保留工具结果
29
            terminate: true,                  // 强制终止
30
          };
31
        }
32
        return undefined;  // 不修改
33
      },
34
    });
35

36
    const stream = agent.run(input, { signal: this.abortCtrl.signal });
37
    // ...
38
  }
39
}

流程对比#

优雅关闭：

1
gracefulCancel() → cancelRequested=true
2
    ↓
3
工具正常执行完成
4
    ↓
5
afterToolCall 检查 → 修改 terminate: true
6
    ↓
7
tool_execution_end (terminate: true)
8
    ↓
9
every(terminate) → Agent 终止

强制关闭：

1
forceCancel() → abort()
2
    ↓
3
工具检查 signal.aborted → 立即中断
4
    ↓
5
message_update: error (reason: aborted)
6
    ↓
7
Agent 直接结束

适用场景#

Agent 状态	优雅停止	强制停止
LLM 正在响应	✗（无法优雅）	✓ 立即中断
工具正在执行	✓ 完成工具后终止	✓ 立即中断
空闲等待	✓ 无需处理	✓ 无需处理

总结#

AbortController = 预先注册的”取消通道”

创建时注册，运行时检查状态
用户改变状态 → 所有检查点同时看到 → 自动触发错误

terminate = 返回值携带的”完成建议”

工具执行后返回 terminate: true
Agent 收集所有返回值 → 检查 every(terminate) → 决定是否继续

核心区别：

AbortController 是”外部中断”（用户主动触发）
terminate 是”内部建议”（工具表达意图）

音乐

音乐

AbortController 与 terminate 设计原理#

AbortController：预先注册模式#

设计思想#

三个阶段#

关键：状态共享，而非消息传递#

terminate：返回值携带模式#

设计思想#

三个阶段#

关键：返回值携带决策信息#

两种模式对比#

特性对比#

图示对比#

Web Chat 停止功能实现#

两层停止机制#

AgentRunner 实现#

流程对比#

适用场景#

总结#

支持与分享

音乐

文章目录