AutoGPT 비용 폭주 막기 - 토큰·툴 호출 한도 설계

// TypeScript 예시

type Budget = {
  maxInputTokens: number;
  maxOutputTokens: number;
  maxTotalTokens: number; // input + output 누적
};

type Usage = {
  inputTokens: number;
  outputTokens: number;
  totalTokens: number;
};

class BudgetExceededError extends Error {}

class BudgetManager {
  private usedTotal = 0;

  constructor(private budget: Budget) {}

  reserve(estimatedTotalTokens: number) {
    if (this.usedTotal + estimatedTotalTokens > this.budget.maxTotalTokens) {
      throw new BudgetExceededError(
        `Budget exceeded: used=${this.usedTotal}, reserve=${estimatedTotalTokens}, max=${this.budget.maxTotalTokens}`
      );
    }
    // 예약 시점에 미리 차감해서 동시성에서도 안전하게
    this.usedTotal += estimatedTotalTokens;
  }

  settle(actual: Usage, reserved: number) {
    const diff = reserved - actual.totalTokens;
    // diff가 양수면 덜 썼으니 되돌려줌
    this.usedTotal -= Math.max(0, diff);
  }

  remaining() {
    return Math.max(0, this.budget.maxTotalTokens - this.usedTotal);
  }
}

type ToolName = "web_search" | "crawl" | "db_query" | "code_exec";

const TOOL_COST: Record<ToolName, number> = {
  web_search: 5,
  crawl: 10,
  db_query: 2,
  code_exec: 8,
};

class ToolBudgetManager {
  private used = 0;

  constructor(private maxUnits: number) {}

  checkAndConsume(tool: ToolName) {
    const cost = TOOL_COST[tool];
    if (this.used + cost > this.maxUnits) {
      throw new Error(
        `Tool budget exceeded: tool=${tool}, used=${this.used}, cost=${cost}, max=${this.maxUnits}`
      );
    }
    this.used += cost;
  }

  remaining() {
    return Math.max(0, this.maxUnits - this.used);
  }
}

type ToolCallKey = string;

type CallResult = { ok: boolean; status?: number };

class CircuitBreaker {
  private failures: Map<ToolCallKey, number> = new Map();

  constructor(private maxConsecutiveFailures: number) {}

  beforeCall(key: ToolCallKey) {
    const f = this.failures.get(key) ?? 0;
    if (f >= this.maxConsecutiveFailures) {
      throw new Error(`Circuit open for key=${key}, failures=${f}`);
    }
  }

  afterCall(key: ToolCallKey, result: CallResult) {
    const f = this.failures.get(key) ?? 0;
    if (result.ok) this.failures.set(key, 0);
    else this.failures.set(key, f + 1);
  }
}

type Phase = "plan" | "gather" | "execute" | "verify";

type AgentState = {
  phase: Phase;
  step: number;
  memorySummary: string;
};

async function runAgent(task: string) {
  const tokenBudget = new BudgetManager({
    maxInputTokens: 20000,
    maxOutputTokens: 6000,
    maxTotalTokens: 25000,
  });

  const toolBudget = new ToolBudgetManager(40);
  const breaker = new CircuitBreaker(3);

  let state: AgentState = { phase: "plan", step: 0, memorySummary: "" };

  while (state.step < 20) {
    state.step += 1;

    // 단계별 예산 정책 예시
    if (state.phase === "gather" && toolBudget.remaining() < 10) {
      state.phase = "execute"; // 강등: 더 이상 수집하지 않음
    }

    // LLM 호출 전 토큰 예약(대략치)
    const reserved = 1200;
    tokenBudget.reserve(reserved);

    const llmResp = await callLLM({
      task,
      phase: state.phase,
      remainingTokens: tokenBudget.remaining(),
      remainingToolUnits: toolBudget.remaining(),
      memory: state.memorySummary,
    });

    tokenBudget.settle(
      {
        inputTokens: llmResp.usage.input,
        outputTokens: llmResp.usage.output,
        totalTokens: llmResp.usage.input + llmResp.usage.output,
      },
      reserved
    );

    if (llmResp.type === "final") return llmResp.text;

    if (llmResp.type === "tool") {
      const tool = llmResp.toolName as any;
      toolBudget.checkAndConsume(tool);

      const key = `${tool}:${stableStringify(llmResp.args)}`;
      breaker.beforeCall(key);

      const result = await callTool(tool, llmResp.args)
        .then((data) => ({ ok: true, data }))
        .catch((e) => ({ ok: false, error: String(e) }));

      breaker.afterCall(key, { ok: result.ok });

      // 툴 결과는 요약해서 메모리에 누적
      state.memorySummary = await summarizeToolResult(state.memorySummary, result);

      // 다음 phase 전이(간단 예시)
      state.phase = state.phase === "plan" ? "gather" : state.phase;
      continue;
    }

    // 그 외 액션은 phase를 진행
    state.phase = nextPhase(state.phase);
  }

  return "Budget-safe fallback: partial answer with current evidence.";
}