Python 不给每个工具的 execute 加取消令牌参数——这是深思熟虑的简化， 跟照抄 Go 的结构无关。原因见本章开头：Python 的取消能力到不了单个 工具内部（urllib、subprocess.run() 都没有“被另一个线程喊停“的 内建机制），把一个用不上的参数硬塞进八个工具的签名里，只会增加复杂度、 不会增加能力。取消改用一个 threading.Event，只在轮次的两个检查点 （发下一个请求之前、工具批量执行完之后）被读。

第一步，收拾被打断的历史——跟 Go 版是同一个函数，同一个道理：

# heal_turn 把一轮没正常收尾的历史补回合法状态。
#
# 半途而废不是免费的：它会把 history 停在一个协议不允许的位置。一条带
# tool_calls 的 assistant 消息，后面必须跟着每个 id 对应的 tool 消息，
# 打断正好落在这两者之间，下一句话发出去就是 400——不是模型不高兴，是
# 请求本身不合法。补上"没有执行"的结果，再留一条模型看得见的说明：它得
# 知道刚才那件事是断在半路的，不是自己干完了。
def heal_turn(history, note):
    if not history:
        return history
    last = history[-1]
    if last.get("role") == "assistant" and not last.get("tool_calls"):
        return history  # 模型把话说完了才出的事，历史本来就是合法的
    if last.get("role") == "assistant" and last.get("tool_calls"):
        for tc in last["tool_calls"]:
            history.append({
                "role": "tool",
                "tool_call_id": tc["id"],
                "content": "错误: 这一轮中断了，这个工具没有执行。",
            })
    history.append({"role": "assistant", "content": note})
    return history


def heal(sess, note):
    sess.history = heal_turn(sess.history, note)
    try:
        sess.save()
    except OSError as e:
        print(f"警告: 会话保存失败: {e}", file=sys.stderr)

第二步，把 agent loop 搬出来，变成能反复调用的函数——多接受一个 cancel_event，在两个检查点读它：

MAX_ROUNDS = 10


# run_turn 把一句话跑到底：发请求、有 tool_calls 就分发、没有就收工。
# cancel_event 只在轮次边界（下一个请求之前、工具批量执行完之后）生效
# ——urllib 的请求和 subprocess 的 bash 调用一旦已经发出/已经在跑，这
# 一版不打断它，只保证"这一轮接下来还没做的事不会再做"。
def run_turn(base, api_key, model, reg, sess, window, input_text, cancel_event):
    sess.history.append({"role": "user", "content": input_text})
    for round_no in range(1, MAX_ROUNDS + 1):
        if cancel_event.is_set():
            raise InterruptedError("cancelled")
        r = send(base, api_key, model, sess.history, reg.definitions())
        choice = r["choices"][0]
        msg = choice["message"]
        sess.history.append(msg)
        # …… 压缩、打印，和练习 23 一字不差 ……

        if choice.get("finish_reason") != "tool_calls":
            print(msg.get("content") or "", flush=True)
            print(f"\n[本轮 {round_no} 次请求 · ……]", file=sys.stderr)
            sess.save()
            return

        tool_calls = msg.get("tool_calls") or []
        sess.history.extend(dispatch_tool_calls(reg, round_no, tool_calls))
        sess.save()
        if cancel_event.is_set():
            raise InterruptedError("cancelled")
    raise RuntimeError(f"这一句话跑满 {MAX_ROUNDS} 次请求还没收敛，停在这里")

第三步，喊停。Python 的信号处理函数只在主线程运行：SIGINT 到达时， 即使主线程正阻塞在 join() 里，也会先跳出去执行 handler（这里只是 set() 一下事件），再回到 join() 继续等——这跟 Go 版“select 守着 done 和 sig 两个 channel“是同一个效果，只是换了 Python 的机制：

# run_interruptible 跑一轮，同时盯着 Ctrl+C。信号只在轮次跑着的时候
# 接管，跑完立刻还给操作系统。
def run_interruptible(base, api_key, model, reg, sess, window, input_text):
    cancel_event = threading.Event()
    outcome = {}

    def worker():
        try:
            run_turn(base, api_key, model, reg, sess, window, input_text, cancel_event)
        except InterruptedError:
            outcome["interrupted"] = True
        except Exception as e:
            outcome["error"] = e

    def handler(signum, frame):
        cancel_event.set()

    old_handler = signal.signal(signal.SIGINT, handler)
    t = threading.Thread(target=worker)
    t.start()
    t.join()
    signal.signal(signal.SIGINT, old_handler)

    if outcome.get("interrupted"):
        heal(sess, "[这一轮被用户打断]")
        print("\n[已打断这一轮。对话还在，接着说]", file=sys.stderr)
    elif "error" in outcome:
        print("错误:", outcome["error"], file=sys.stderr)
        heal(sess, f"[这一轮没跑完：{outcome['error']}]")

第四步，常驻循环本身。Python 的 sys.stdin.readline() 本来就是 全程序共用的同一个对象，不需要像 Go 那样专门把两个读者收编成一个—— 这个坑从一开始就不存在：

def repl(base, api_key, model, reg, sess, window, first_task):
    print("[常驻模式：一行一句话。空行忽略，/exit 或 Ctrl+D 退出；轮次跑起来之后 Ctrl+C 打断这一轮，不退出进程]",
          file=sys.stderr)
    while True:
        line = first_task
        first_task = ""
        if not line:
            print("\n> ", file=sys.stderr, end="", flush=True)
            text = sys.stdin.readline()
            if not text:  # EOF（Ctrl+D）
                print(file=sys.stderr)
                break
            line = text.strip()
        if not line:
            continue
        if line in ("/exit", "/quit"):
            break
        run_interruptible(base, api_key, model, reg, sess, window, line)
    try:
        sess.save()
    except OSError as e:
        print(f"警告: 会话保存失败: {e}", file=sys.stderr)
    print(f"[会话 ID: {sess.id}，用 -c {sess.id} 继续]", file=sys.stderr)
    return 0

最后，main() 的尾巴。命令行上的任务从必填变成选填：

    # 任务从必填变成选填：不给就直接进提示符，给了就当第一句话，说完
    # 照样留在提示符上。这是这一章唯一改变的用法。
    first_task = args[0] if args else ""
    # ……
    sys.exit(repl(base, api_key, model, reg, sess, window, first_task))

JavaScript 跟 Python 一样，不给每个工具的 execute 加取消参数—— 但取消能力的边界跟 Python 恰好相反：fetch() 原生支持 AbortController，网络请求能被真正中断；execFileSync 是同步阻塞 调用，独占 Node 唯一的线程，bash 子进程反而完全打不断。

第一步，收拾被打断的历史：

// healTurn 把一轮没正常收尾的历史补回合法状态。
function healTurn(history, note) {
  if (history.length === 0) return history;
  const last = history[history.length - 1];
  if (last.role === "assistant" && !(last.tool_calls?.length)) {
    return history; // 模型把话说完了才出的事，历史本来就是合法的
  }
  if (last.role === "assistant" && last.tool_calls?.length) {
    for (const tc of last.tool_calls) {
      history.push({ role: "tool", tool_call_id: tc.id, content: "错误: 这一轮中断了，这个工具没有执行。" });
    }
  }
  history.push({ role: "assistant", content: note });
  return history;
}

function heal(sess, note) {
  sess.history = healTurn(sess.history, note);
  try {
    sess.save();
  } catch (err) {
    console.error(`警告: 会话保存失败: ${err.message}`);
  }
}

第二步，send 多接受一个可选的 AbortSignal——只有最外层 runTurn 发起的这一轮请求会传它，sub_agent/workflow 内部各自的请求不传：

async function send(base, apiKey, model, history, tools, signal) {
  // ……
  try {
    resp = await fetch(base + "/chat/completions", {
      method: "POST",
      headers: { /* …… */ },
      body,
      signal,
    });
  } catch (err) {
    if (err.name === "AbortError") throw err; // 原样往上抛，按取消处理
    throw new Error(`请求失败: ${err.cause ?? err}`);
  }
  // ……
}

第三步，把 agent loop 搬出来：

const MAX_ROUNDS = 10;

// runTurn 把一句话跑到底：发请求、有 tool_calls 就分发、没有就收工。
async function runTurn(base, apiKey, model, reg, sess, window, input, signal) {
  sess.history.push({ role: "user", content: input });
  for (let round = 1; round <= MAX_ROUNDS; round++) {
    const r = await send(base, apiKey, model, sess.history, reg.definitions(), signal);
    // …… 压缩、打印，和练习 23 一字不差 ……
    if (choice.finish_reason !== "tool_calls") {
      console.log(msg.content ?? "");
      console.error(`\n[本轮 ${round} 次请求 · ……]`);
      sess.save();
      return;
    }
    sess.history.push(...(await dispatchToolCalls(reg, round, toolCalls)));
    sess.save();
  }
  throw new Error(`这一句话跑满 ${MAX_ROUNDS} 次请求还没收敛，停在这里`);
}

第四步，喊停。AbortController 是这里真正做事的角色：SIGINT 一来 就 abort()，如果这一刻正好卡在 send() 的 fetch() 里，请求立刻 中断、抛出 AbortError：

async function runInterruptible(base, apiKey, model, reg, sess, window, input) {
  const controller = new AbortController();
  const onSigint = () => controller.abort();
  process.on("SIGINT", onSigint);
  try {
    await runTurn(base, apiKey, model, reg, sess, window, input, controller.signal);
  } catch (err) {
    if (err.name === "AbortError") {
      heal(sess, "[这一轮被用户打断]");
      console.error("\n[已打断这一轮。对话还在，接着说]");
    } else {
      console.error("错误:", err.message ?? err);
      heal(sess, `[这一轮没跑完：${err.message ?? err}]`);
    }
  } finally {
    process.off("SIGINT", onSigint);
  }
}

第五步，常驻循环。读输入复用 confirm() 那个 readLineSync()， 不用 node:readline 另起一套——两套机制同时抢一个标准输入会互相偷 字节，这一版从一开始就只有一个读者，不用像 Go 版那样后来去统一。但 readLineSync() 原本没有区分“真正的流结束“和“用户敲了个空行“，这一 章第一次需要这个区分，顺手把它修对：

// n===0 是真正的流结束（Ctrl+D、管道关闭），跟"空行回车"长得一样。
// 区分靠时机：如果 n===0 发生在一个字符都还没攒到的时候，就是纯粹的
// EOF，返回 null；如果是攒了几个字符之后才碰到流结束，先把这几个
// 字符交回去，下一次调用再返回 null。
function readLineSync() {
  const buf = Buffer.alloc(1);
  const chunks = [];
  for (;;) {
    let n;
    try {
      n = readSync(0, buf, 0, 1);
    } catch (err) {
      if (err.code === "EAGAIN") continue;
      return null;
    }
    if (n === 0) return chunks.length === 0 ? null : Buffer.from(chunks).toString("utf-8");
    if (buf[0] === 0x0a) break;
    chunks.push(buf[0]);
  }
  return Buffer.from(chunks).toString("utf-8");
}

async function repl(base, apiKey, model, reg, sess, window, firstTask) {
  console.error("[常驻模式：一行一句话。空行忽略，/exit 或 Ctrl+D 退出；轮次跑起来之后 Ctrl+C 打断这一轮，不退出进程]");
  for (;;) {
    let line = firstTask;
    firstTask = "";
    if (!line) {
      process.stderr.write("\n> ");
      const text = readLineSync();
      if (text === null) {
        console.error("");
        break;
      }
      line = text.trim();
    }
    if (!line) continue;
    if (line === "/exit" || line === "/quit") break;
    await runInterruptible(base, apiKey, model, reg, sess, window, line);
  }
  try {
    sess.save();
  } catch (err) {
    console.error(`警告: 会话保存失败: ${err.message}`);
  }
  console.error(`[会话 ID: ${sess.id}，用 -c ${sess.id} 继续]`);
  return 0;
}

最后，顶层脚本的任务从必填变成选填：

const firstTask = args[0] ?? "";
// ……
process.exit(await repl(base, apiKey, model, reg, sess, window, firstTask));

cd exercises/ex24/python
export OPENAI_API_KEY=sk-xxxx
export MODEL=deepseek-v4-flash
export OPENAI_BASE_URL=https://api.deepseek.com/v1
python3 main.py

cd exercises/ex24/node
export OPENAI_API_KEY=sk-xxxx
export MODEL=deepseek-v4-flash
export OPENAI_BASE_URL=https://api.deepseek.com/v1
node main.mjs