AI Agent 工具调用死循环怎么停：重复检测、错误分类与熔断

export function canonical(x) {
  if (Array.isArray(x)) return x.map(canonical);
  if (x && typeof x === 'object') {
    return Object.fromEntries(Object.keys(x).sort().map(k => [k, canonical(x[k])]));
  }
  return x;
}

export class Guard {
  constructor({ now, wait, limits, revision = 0 }) {
    this.now = now;
    this.wait = wait;
    this.limits = limits;
    this.deadline = now() + limits.ms;
    this.revision = revision;
    this.models = 0;
    this.requests = 0;
    this.executions = 0;
    this.stagnant = 0;
    this.history = [];
    this.operations = new Map();
    this.terminal = null;
  }
  stop(state, reason) {
    this.terminal ??= {
      state, reason, models: this.models,
      requests: this.requests, executions: this.executions,
      revision: this.revision,
      operations: [...this.operations.entries()].map(([key, v]) => ({ key, ...v }))
    };
    return this.terminal;
  }
  run(plan, execute, inspect) {
    let observation = null;
    while (!this.terminal) {
      if (this.now() >= this.deadline) return this.stop('PARTIAL', 'deadline');
      if (this.models >= this.limits.models) return this.stop('PARTIAL', 'model_budget');
      this.models++;
      let call;
      try { call = plan(observation); }
      catch { return this.stop('FAILED', 'planner_error'); }
      if (call?.type === 'finish') {
        let done = false;
        try { done = inspect(null, call).done === true; } catch {}
        return this.stop(done ? 'COMPLETED' : 'PARTIAL', done ? 'goal_met' : 'goal_unverified');
      }
      if (!call || typeof call.tool !== 'string' || !call.args ||
          !['read', 'write'].includes(call.effect)) return this.stop('FAILED', 'bad_call');
      if (this.now() >= this.deadline) return this.stop('PARTIAL', 'deadline');
      if (this.requests >= this.limits.requests) return this.stop('PARTIAL', 'request_budget');
      this.requests++;
      let fp;
      try { fp = call.tool + ':' + JSON.stringify(canonical(call.args)); }
      catch { return this.stop('FAILED', 'bad_args'); }
      const key = call.operationKey;
      if (call.effect === 'write' && (typeof key !== 'string' || !key)) {
        return this.stop('NEEDS_HUMAN', 'missing_operation_key');
      }
      const old = call.effect === 'write' ? this.operations.get(key) : null;
      if (old && old.fp !== fp) return this.stop('NEEDS_HUMAN', 'operation_conflict');
      if (old && old.state !== 'COMMITTED') return this.stop('NEEDS_HUMAN', 'unknown_commit');
      if (this.history.filter(x => x === fp).length >= this.limits.same) {
        return this.stop('PARTIAL', 'same_call');
      }
      const h = this.history.slice(-3);
      if (h.length === 3 && h[0] !== h[1] && h[0] === h[2] && h[1] === fp) {
        return this.stop('PARTIAL', 'short_cycle');
      }
      let result;
      if (old) result = old.result;
      else {
        if (this.executions >= this.limits.executions) return this.stop('PARTIAL', 'execution_budget');
        if (call.effect === 'write') this.operations.set(key, { state: 'UNKNOWN', fp });
        this.executions++;
        try { result = execute(call); }
        catch { return this.stop(call.effect === 'write' ? 'NEEDS_HUMAN' : 'FAILED', 'executor_error'); }
      }
      if (!result || !['SUCCESS', 'RETRYABLE', 'PENDING', 'PRECONDITION', 'FATAL'].includes(result.kind)) {
        return this.stop(call.effect === 'write' ? 'NEEDS_HUMAN' : 'FAILED', 'bad_result');
      }
      let verified;
      try { verified = inspect(result, call); }
      catch { return this.stop(call.effect === 'write' ? 'NEEDS_HUMAN' : 'FAILED', 'invalid_evidence'); }
      if (!verified || !Number.isSafeInteger(verified.revision) ||
          verified.revision < this.revision || typeof verified.done !== 'boolean') {
        return this.stop(call.effect === 'write' ? 'NEEDS_HUMAN' : 'FAILED', 'invalid_evidence');
      }
      if (call.effect === 'write') {
        if (result.kind !== 'SUCCESS' || verified.committed !== true) {
          return this.stop('NEEDS_HUMAN', 'unknown_commit');
        }
        this.operations.set(key, { state: 'COMMITTED', fp, result });
      }
      if (result.kind === 'FATAL') return this.stop('FAILED', 'fatal');
      if (result.kind === 'PRECONDITION') return this.stop('NEEDS_HUMAN', 'precondition');
      if (verified.revision > this.revision) {
        this.revision = verified.revision;
        this.stagnant = 0;
        this.history = [];
      } else this.stagnant++;
      this.history.push(fp);
      if (verified.done) return this.stop('COMPLETED', 'goal_met');
      if (this.stagnant >= this.limits.stagnant) return this.stop('PARTIAL', 'no_progress');
      if (['RETRYABLE', 'PENDING'].includes(result.kind)) {
        if (!Number.isFinite(result.waitMs) || result.waitMs <= 0) return this.stop('FAILED', 'invalid_wait');
        if (this.now() + result.waitMs >= this.deadline) return this.stop('PARTIAL', 'deadline');
        this.wait(result.waitMs);
      }
      observation = result;
    }
    return this.terminal;
  }
}

let time = 0;
const accepted = new Set();
const guard = new Guard({
  now: () => time, wait: ms => { time += ms; },
  limits: { ms: 1000, models: 8, requests: 8, executions: 6, same: 2, stagnant: 3 }
});
const report = guard.run(
  () => ({ tool: 'read_page', args: { page: accepted.size + 1 }, effect: 'read' }),
  call => ({ kind: 'SUCCESS', page: call.args.page, ids: [`item-${call.args.page}`] }),
  (result, call) => {
    if (result) {
      if (call.tool !== 'read_page' || result.page !== call.args.page ||
          result.page !== accepted.size + 1 || result.page > 3 ||
          JSON.stringify(result.ids) !== JSON.stringify([`item-${result.page}`])) {
        throw new Error('invalid page');
      }
      accepted.add(result.page);
    }
    return { revision: accepted.size, done: accepted.size === 3 };
  }
);
console.log(report.state, report.executions, report.revision);

{
  "state": "NEEDS_HUMAN",
  "reason": "unknown_commit",
  "completed": ["incident_loaded", "recipient_validated"],
  "operation_key": "incident-42-first-notice",
  "operation_state": "UNKNOWN",
  "remaining_budget": { "model_calls": 4, "tool_executions": 2 },
  "resume_condition": "核对该业务操作是否已提交，再处理未完成步骤"
}