LangChain Tool Calling 무한루프 끊는 6패턴

// TypeScript 예시: 출력 스키마를 강제하는 방식(개념 예시)
// 실제 구현은 사용하는 LLM wrapper/structured output에 맞게 조정하세요.

type AgentDecision =
  | { type: "tool"; toolName: string; args: Record<string, unknown>; reason: string }
  | { type: "final"; finalAnswer: string; citations?: string[] };

const STOP_CONTRACT = `
너는 툴을 사용할 수 있다.
규칙:
1) 툴 호출이 정말 필요할 때만 tool 결정을 내려라.
2) 같은 툴을 같은 인자로 2번 이상 호출하지 마라.
3) 툴 결과가 부족하면 사용자에게 확인 질문을 1개만 하고 final로 종료하라.
4) 최종 답을 낼 수 있으면 반드시 final로 종료하라.
`;

import crypto from "crypto";

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

function signature(toolName: string, args: any) {
  const raw = `${toolName}:${stableStringify(args)}`;
  return crypto.createHash("sha256").update(raw).digest("hex");
}

type CallRecord = { sig: string; toolName: string; args: any; observationHash?: string };

class LoopGuard {
  private calls: CallRecord[] = [];

  constructor(private maxSameCall = 2, private maxTotalCalls = 12) {}

  addCall(toolName: string, args: any, observation?: string) {
    const sig = signature(toolName, args);
    const observationHash = observation
      ? crypto.createHash("sha256").update(observation).digest("hex")
      : undefined;

    this.calls.push({ sig, toolName, args, observationHash });

    if (this.calls.length > this.maxTotalCalls) {
      throw new Error("LoopGuard: maxTotalCalls exceeded");
    }

    const sameSigCount = this.calls.filter(c => c.sig === sig).length;
    if (sameSigCount > this.maxSameCall) {
      throw new Error("LoopGuard: repeated identical tool call");
    }

    if (observationHash) {
      const sameObsCount = this.calls.filter(c => c.observationHash === observationHash).length;
      if (sameObsCount >= 3) {
        throw new Error("LoopGuard: repeated identical observation");
      }
    }
  }
}

type State =
  | { step: "normalize"; query: string }
  | { step: "gather"; query: string; attempts: number }
  | { step: "verify"; query: string; context: string }
  | { step: "final"; answer: string };

async function runAgent(initialQuery: string) {
  let state: State = { step: "normalize", query: initialQuery };

  while (state.step !== "final") {
    if (state.step === "normalize") {
      state = { step: "gather", query: state.query.trim(), attempts: 0 };
      continue;
    }

    if (state.step === "gather") {
      if (state.attempts >= 2) {
        // 정보 수집은 2회까지만 허용
        state = {
          step: "final",
          answer: "추가 조회 없이 확답이 어렵습니다. 어떤 시스템/데이터를 기준으로 답해야 하나요?"
        };
        continue;
      }

      const context = await searchTool({ q: state.query });
      state = { step: "verify", query: state.query, context };
      continue;
    }

    if (state.step === "verify") {
      const ok = contextLooksSufficient(state.context);
      if (!ok) {
        // verify에서 gather로 되돌아가더라도 attempts를 증가
        state = { step: "gather", query: state.query, attempts: 1 };
        continue;
      }

      const answer = await synthesizeAnswer(state.query, state.context);
      state = { step: "final", answer };
      continue;
    }
  }

  return state.answer;
}

type ToolArgs = { q: string; idempotencyKey: string };

const memoryCache = new Map<string, { ok: boolean; value: string; ts: number }>();

async function cachedSearchTool(args: ToolArgs) {
  const key = `search:${args.idempotencyKey}`;
  const cached = memoryCache.get(key);

  if (cached && Date.now() - cached.ts < 60_000) {
    if (!cached.ok) throw new Error("cached failure");
    return cached.value;
  }

  try {
    const value = await searchTool({ q: args.q });
    memoryCache.set(key, { ok: true, value, ts: Date.now() });
    return value;
  } catch (e: any) {
    memoryCache.set(key, { ok: false, value: String(e?.message ?? e), ts: Date.now() });
    throw e;
  }
}

import { z } from "zod";

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

type SearchResult = z.infer<typeof SearchResultSchema>;

async function searchToolValidated(args: { q: string }): Promise<SearchResult> {
  const raw = await searchToolRaw(args); // 외부 API 호출

  let parsed: any;
  try {
    parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
  } catch {
    throw new Error("tool output is not valid JSON");
  }

  const result = SearchResultSchema.safeParse(parsed);
  if (!result.success) {
    throw new Error("tool output schema mismatch");
  }

  return result.data;
}

type CircuitState = { openUntil: number; failures: number };

class ToolCircuitBreaker {
  private state = new Map<string, CircuitState>();

  constructor(
    private failureThreshold = 3,
    private openMs = 30_000
  ) {}

  canCall(toolName: string) {
    const s = this.state.get(toolName);
    if (!s) return true;
    return Date.now() > s.openUntil;
  }

  recordSuccess(toolName: string) {
    this.state.delete(toolName);
  }

  recordFailure(toolName: string) {
    const s = this.state.get(toolName) ?? { openUntil: 0, failures: 0 };
    s.failures += 1;
    if (s.failures >= this.failureThreshold) {
      s.openUntil = Date.now() + this.openMs;
    }
    this.state.set(toolName, s);
  }
}

async function callToolWithBreaker<T>(
  breaker: ToolCircuitBreaker,
  toolName: string,
  fn: () => Promise<T>
): Promise<T> {
  if (!breaker.canCall(toolName)) {
    throw new Error("circuit open: tool temporarily disabled");
  }

  try {
    const v = await fn();
    breaker.recordSuccess(toolName);
    return v;
  } catch (e) {
    breaker.recordFailure(toolName);
    throw e;
  }
}