AutoGPT 도구 호출 무한루프 차단 - FSM·가드레일

type State =
  | "IDLE"
  | "PLANNING"
  | "TOOL_RUNNING"
  | "EVALUATING"
  | "DONE"
  | "FAILED"
  | "ESCALATED";

type ToolCall = {
  name: string;
  args: Record<string, unknown>;
};

type Observation = {
  ok: boolean;
  data?: unknown;
  error?: { code: string; message: string };
};

type Ctx = {
  state: State;
  step: number;
  maxSteps: number;
  lastToolCall?: ToolCall;
  toolCallHistory: Array<{ fingerprint: string; atStep: number }>;
  observation?: Observation;
};

function fingerprintToolCall(call: ToolCall): string {
  // JSON stringify는 키 순서 이슈가 있어 안정화가 필요할 수 있음
  return `${call.name}:${JSON.stringify(call.args)}`;
}

function assertTransition(from: State, to: State) {
  const allowed: Record<State, State[]> = {
    IDLE: ["PLANNING"],
    PLANNING: ["TOOL_RUNNING", "DONE", "ESCALATED", "FAILED"],
    TOOL_RUNNING: ["EVALUATING", "FAILED"],
    EVALUATING: ["PLANNING", "DONE", "ESCALATED", "FAILED"],
    DONE: [],
    FAILED: [],
    ESCALATED: [],
  };
  if (!allowed[from].includes(to)) {
    throw new Error(`Invalid transition: ${from} -> ${to}`);
  }
}

function transition(ctx: Ctx, to: State): Ctx {
  assertTransition(ctx.state, to);
  return { ...ctx, state: to };
}

function guardStepBudget(ctx: Ctx): Ctx {
  if (ctx.step >= ctx.maxSteps) {
    return transition(ctx, "ESCALATED");
  }
  return ctx;
}

function guardDuplicateToolCall(
  ctx: Ctx,
  call: ToolCall,
  limit: number
): { ok: true } | { ok: false; reason: string } {
  const fp = fingerprintToolCall(call);
  const count = ctx.toolCallHistory.filter(h => h.fingerprint === fp).length;
  if (count >= limit) {
    return { ok: false, reason: `Duplicate tool call blocked: ${fp}` };
  }
  return { ok: true };
}

function recordToolCall(ctx: Ctx, call: ToolCall): Ctx {
  const fp = fingerprintToolCall(call);
  return {
    ...ctx,
    lastToolCall: call,
    toolCallHistory: [...ctx.toolCallHistory, { fingerprint: fp, atStep: ctx.step }],
  };
}

type RetryPolicy = {
  maxRetries: number;
  baseDelayMs: number;
};

async function withRetry<T>(
  fn: () => Promise<T>,
  classify: (e: unknown) => { retryable: boolean; code: string },
  policy: RetryPolicy
): Promise<T> {
  let attempt = 0;
  while (true) {
    try {
      return await fn();
    } catch (e) {
      const c = classify(e);
      if (!c.retryable || attempt >= policy.maxRetries) throw e;
      const delay = policy.baseDelayMs * Math.pow(2, attempt);
      const jitter = Math.floor(Math.random() * 200);
      await new Promise(r => setTimeout(r, delay + jitter));
      attempt++;
    }
  }
}

import { z } from "zod";

const SearchResultSchema = z.object({
  items: z.array(
    z.object({
      title: z.string(),
      url: z.string().url(),
      snippet: z.string().optional(),
    })
  ),
});

type SearchResult = z.infer<typeof SearchResultSchema>;

function validateSearchObservation(obs: Observation):
  | { ok: true; value: SearchResult }
  | { ok: false; reason: string } {
  if (!obs.ok) return { ok: false, reason: obs.error?.message ?? "unknown error" };
  const parsed = SearchResultSchema.safeParse(obs.data);
  if (!parsed.success) return { ok: false, reason: parsed.error.message };
  return { ok: true, value: parsed.data };
}

async function runAgent(initialCtx: Ctx) {
  let ctx = transition(initialCtx, "PLANNING");

  while (true) {
    ctx = guardStepBudget(ctx);
    if (["DONE", "FAILED", "ESCALATED"].includes(ctx.state)) return ctx;

    if (ctx.state === "PLANNING") {
      // LLM에게 다음 행동을 요청: tool call 또는 done
      // (여기서는 의사 코드)
      const decision = await decideNextAction(ctx);

      if (decision.type === "done") {
        ctx = transition(ctx, "DONE");
        continue;
      }

      if (decision.type === "tool") {
        const dup = guardDuplicateToolCall(ctx, decision.call, 2);
        if (!dup.ok) {
          // 동일 호출 반복이면 에스컬레이션 또는 다른 전략 유도
          ctx = transition(ctx, "ESCALATED");
          continue;
        }

        ctx = recordToolCall(ctx, decision.call);
        ctx = transition(ctx, "TOOL_RUNNING");
        continue;
      }

      ctx = transition(ctx, "FAILED");
      continue;
    }

    if (ctx.state === "TOOL_RUNNING") {
      const call = ctx.lastToolCall!;

      const obs = await executeTool(call);
      ctx = { ...ctx, observation: obs };
      ctx = transition(ctx, "EVALUATING");
      continue;
    }

    if (ctx.state === "EVALUATING") {
      const obs = ctx.observation!;

      // 도구별 검증/평가
      const evalResult = await evaluateObservation(ctx, obs);

      if (evalResult.type === "done") ctx = transition(ctx, "DONE");
      else if (evalResult.type === "replan") ctx = transition(ctx, "PLANNING");
      else if (evalResult.type === "escalate") ctx = transition(ctx, "ESCALATED");
      else ctx = transition(ctx, "FAILED");

      ctx = { ...ctx, step: ctx.step + 1 };
      continue;
    }
  }
}