让人来审批工具调用：HITL 怎么做

agent := &agents.Agent{
    Name: "运维助手",
    Tools: []agents.Tool{
        agents.NewFunctionTool("delete_user", "删除用户", deleteUser),
        agents.NewFunctionTool("send_email", "发邮件", sendEmail),
        agents.NewFunctionTool("refund", "退款", refund),
    },
}

agents.Run(ctx, agent, "把昨天下单的那几个用户处理一下", opts)
// Agent 可能理解成"删除这几个用户"，直接删了！

模型这轮要调 3 个工具：[delete_user, send_email, refund]
  → delete_user 需要审批，暂停
  → send_email 不需要审批，先执行了
  → refund 不需要审批，先执行了
  → 人审批 delete_user：同意
  → resume：重跑这一轮？那 send_email 和 refund 要再跑一次！

// agents/tool.go:68
type FunctionTool struct {
    // ...
    NeedsApproval bool  // 这个工具永远需要审批
    NeedsApprovalFunc func(ctx, rc, argsJSON) (bool, error)  // 按调用动态决定
}

deleteTool := agents.NewFunctionTool("delete_user", "删用户", deleteUser)
deleteTool.NeedsApproval = true  // 永远需要审批

emailTool := agents.NewFunctionTool("send_email", "发邮件", sendEmail)
emailTool.NeedsApprovalFunc = func(ctx, rc, argsJSON string) (bool, error) {
    var args struct{ To, Subject, Body string }
    json.Unmarshal([]byte(argsJSON), &args)
    // 发给外部域名要审批，内部不用
    if !strings.Contains(args.To, "@company.com") {
        return true, nil  // 外部邮件，审批
    }
    return false, nil  // 内部邮件，直接发
}

// agents/tool.go:89
func (t *FunctionTool) requiresApproval(ctx, rc, argsJSON) (bool, error) {
    if t.NeedsApprovalFunc != nil {
        return t.NeedsApprovalFunc(ctx, rc, argsJSON)
    }
    return t.NeedsApproval, nil
}

// agents/run_step.go:179（简化）
toRun, interruptions, rejected := partitionByApproval(processed.Functions, ...)

if len(interruptions) > 0 {
    // 有待审批的 → 构造 RunState，返回 interruption
    return &singleStepResult{
        NextStep: stepInterruption,
        Interruptions: interruptions,
    }
}

// agents/run.go:456（简化）
case stepInterruption:
    state := &RunState{
        CurrentAgent:        agent,
        OriginalInput:       r.originalInput,
        GeneratedItems:      r.generatedItems,
        InterruptedResponse: resp,  // 被中断的那次模型响应
        Interruptions:       step.Interruptions,
        Approvals:           r.rc.Approvals,
        Usage:               r.rc.Usage,
        CurrentTurn:         turn,  // 记住中断在第几轮
    }
    return &RunResult{State: state}

// agents/run_state.go:45
func (s *RunState) Approve(item *ToolApprovalItem, always bool) {
    s.Approvals.Approve(item, always)
}

func (s *RunState) Reject(item *ToolApprovalItem, always bool, message string) {
    s.Approvals.Reject(item, always, message)
}

// 用户审批 delete_user 调用
state.Approve(interruption, false)  // 只这一次
// 或
state.Approve(interruption, true)   // 以后 delete_user 都自动同意

// 按 callID（单次决策）
approvals.byCallID["call_abc"] = approved

// 按 toolName（always 决策）
approvals.byTool["delete_user"] = approved

// agents/run_state.go:65（简化）
func ResumeRun(ctx context.Context, state *RunState, opts RunOptions) (*RunResult, error) {
    rc := NewRunContext(opts.Context)
    rc.Approvals = state.Approvals  // 把审批决策还原
    rc.Usage = state.Usage          // 把 token 用量还原（不重新计）

    r := &runner{
        opts: opts, rc: rc,
        resume: state,                // 关键：把 state 塞进 runner
        maxTurns: maxTurns,
    }
    return r.loop(ctx, state.CurrentAgent, state.OriginalInput)
}

// agents/run.go:211（简化）
if r.resume != nil {
    // 从 state 恢复所有累积状态
    r.generatedItems = r.resume.GeneratedItems
    r.sessionItems = r.resume.SessionItems
    r.previousResponseID = ...
    startTurn = r.resume.CurrentTurn  // 从中断的轮次继续，不重新计数
}

// agents/run.go:315
if resumedTurn {  // resume 的第一轮
    resp = r.resume.InterruptedResponse  // 复用上次响应，不调模型
}

中断前：模型要调 [delete_user]
人审批：Approve(delete_user)
resume：delete_user 现在 approved → 执行它 → 结果加入历史 → 继续循环

Agent 后端进程                审批前端
    │                          │
    ├─ Run 到危险工具，暂停      │
    ├─ 把 RunState 序列化成 JSON │
    ├─ 发给前端 ─────────────►  │
    │                          ├─ 用户看到"要删用户，同意？"
    │                          ├─ 点"同意"
    │   ◄─────────────── 发回审批决策
    ├─ RunStateFromJSON 重建    │
    ├─ ResumeRun 继续执行       │

// mini-claude-code/approval.go
var dangerousPatterns = []string{
    "rm ", "rmdir", "git push", "git reset", "mv ",
    ">", ">>", "curl", "wget", "kill", "sudo", ...
}

func confirmDangerous(command string) bool {
    for _, p := range dangerousPatterns {
        if strings.Contains(strings.ToLower(command), p) {
            // 危险，问用户
            fmt.Printf("⚠️ 检测到潜在危险命令: %s\n允许执行? [y/N]: ", command)
            resp := readLine()
            return resp == "y"
        }
    }
    return true // 不危险,放行
}

if t.Approve != nil && !t.Approve(args.Command) {
    return "⚠️ 用户拒绝了此命令的执行。请换一个方案。", nil  // 回喂,不中断
}

Run 调到危险工具
  → partitionByApproval 分出待审批的
  → 有待审批 → 构造 RunState，返回 interruption（所有工具都不执行）
  → 调用方处理 RunState：Approve/Reject（可带 always）
  → ResumeRun(state)
    → 从 state 恢复（轮次、usage、items）
    → 复用 InterruptedResponse（不重新调模型）
    → 查 ApprovalStore，执行 approved 的工具
    → 继续循环