LangChain 에이전트 무한루프 차단 실전 가이드

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

const AgentStepSchema = {
  name: "agent_step",
  schema: {
    type: "object",
    additionalProperties: false,
    properties: {
      type: { type: "string", enum: ["tool_call", "final", "abort"] },
      tool: {
        type: "object",
        additionalProperties: false,
        properties: {
          name: { type: "string" },
          arguments: { type: "object" }
        },
        required: ["name", "arguments"]
      },
      final: { type: "string" },
      reason: { type: "string" }
    },
    required: ["type"],
    allOf: [
      {
        if: { properties: { type: { const: "tool_call" } } },
        then: { required: ["tool"] }
      },
      {
        if: { properties: { type: { const: "final" } } },
        then: { required: ["final"] }
      },
      {
        if: { properties: { type: { const: "abort" } } },
        then: { required: ["reason"] }
      }
    ]
  }
} as const;

export async function decideNextStep(input: string) {
  const resp = await client.responses.create({
    model: "gpt-4.1-mini",
    input,
    response_format: {
      type: "json_schema",
      json_schema: AgentStepSchema
    }
  });

  // SDK에 따라 resp.output_text 대신 구조화된 output을 꺼내야 할 수 있음
  const text = resp.output_text;
  return JSON.parse(text) as {
    type: "tool_call" | "final" | "abort";
    tool?: { name: string; arguments: Record<string, unknown> };
    final?: string;
    reason?: string;
  };
}

import { AgentExecutor } from "langchain/agents";
import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "gpt-4.1-mini",
  temperature: 0
});

// tools, agent 구성은 생략

const executor = new AgentExecutor({
  agent,
  tools,
  maxIterations: 6,
  // 일부 런타임에서는 maxExecutionTime 또는 maxExecutionTimeMs 형태
  maxExecutionTime: 20
});

export async function runAgent(input: string) {
  try {
    const result = await executor.invoke({ input });
    return result;
  } catch (e: any) {
    // 하드컷에 걸리면 여기로 떨어지게 만들고,
    // 사용자에게는 "추가 정보 요청" 같은 안전한 응답을 반환
    return {
      output:
        "요청을 처리하는 중 반복이 감지되어 중단했습니다. 필요한 정보(기간/대상/제약)를 조금 더 알려주세요."
    };
  }
}

import crypto from "crypto";

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

function stableStringify(obj: any) {
  return JSON.stringify(obj, Object.keys(obj).sort());
}

function fingerprint(call: ToolCall) {
  const raw = `${call.name}:${stableStringify(call.args)}`;
  return crypto.createHash("sha256").update(raw).digest("hex");
}

export class LoopGuard {
  private seen = new Map<string, number>();

  constructor(
    private readonly maxSameCall = 2,
    private readonly maxTotalCalls = 10
  ) {}

  check(call: ToolCall) {
    const fp = fingerprint(call);
    const count = (this.seen.get(fp) ?? 0) + 1;
    this.seen.set(fp, count);

    const total = Array.from(this.seen.values()).reduce((a, b) => a + b, 0);

    if (total > this.maxTotalCalls) {
      throw new Error("LoopGuard: too many tool calls");
    }
    if (count > this.maxSameCall) {
      throw new Error("LoopGuard: repeated identical tool call");
    }
  }
}

export class ErrorCircuitBreaker {
  private consecutiveErrors = 0;

  constructor(private readonly threshold = 2) {}

  onSuccess() {
    this.consecutiveErrors = 0;
  }

  onError() {
    this.consecutiveErrors += 1;
    if (this.consecutiveErrors >= this.threshold) {
      throw new Error("CircuitBreaker: too many consecutive tool errors");
    }
  }
}

너는 툴을 사용할 수 있는 에이전트다.
다음 규칙을 반드시 따른다.
1) 같은 목적의 툴 호출을 2회 이상 반복하지 않는다.
2) 필요한 정보가 부족하면 type=abort로 종료하고, 사용자에게 필요한 추가 정보를 1~3개 질문한다.
3) 툴 결과가 비어 있으면 쿼리를 무한히 바꾸지 말고, 실패 원인을 한 문장으로 설명한 뒤 abort한다.
4) 최종 답을 낼 수 있으면 type=final로 종료한다.

async function runWithGuards(input: string) {
  const loopGuard = new LoopGuard(2, 8);
  const breaker = new ErrorCircuitBreaker(2);

  for (let i = 0; i < 6; i += 1) {
    const step = await decideNextStep(input);

    if (step.type === "final") return step.final;
    if (step.type === "abort") return `중단: ${step.reason}`;

    const call = { name: step.tool!.name, args: step.tool!.arguments };
    loopGuard.check(call);

    try {
      const obs = await runTool(call.name, call.args);
      breaker.onSuccess();
      input = `${input}\n\n관측 결과: ${JSON.stringify(obs)}`;
    } catch (e) {
      breaker.onError();
      input = `${input}\n\n툴 에러: ${String(e)}`;
    }
  }

  return "반복 한도에 도달해 중단했습니다. 조건을 더 구체화해 주세요.";
}