LangChain Tool 무한루프 끊는 7가지 수문장

import { AgentExecutor } from "langchain/agents";

const executor = new AgentExecutor({
  agent,
  tools,
  maxIterations: 6,
  // LangChain 버전에 따라 옵션명이 다를 수 있습니다.
  // 없다면 아래 수문장 6의 AbortSignal 패턴으로 타임박스를 구현하세요.
});

import { z } from "zod";
import { tool } from "langchain/tools";

const LookupResult = z.object({
  ok: z.boolean(),
  done: z.boolean(),
  retryable: z.boolean(),
  reason: z.string().optional(),
  data: z.any().optional(),
});

type LookupResult = z.infer<typeof LookupResult>;

export const userLookupTool = tool(
  async (input: { userId: string }): Promise<LookupResult> => {
    try {
      const data = await fetch(`https://api.example.com/users/${input.userId}`).then(r => r.json());
      return { ok: true, done: true, retryable: false, data };
    } catch (e: any) {
      // 재시도 가능한 실패와 아닌 실패를 분리
      const retryable = Boolean(e?.code === "ETIMEDOUT" || e?.status === 429);
      return { ok: false, done: !retryable, retryable, reason: String(e?.message ?? e) };
    }
  },
  {
    name: "user_lookup",
    description: "Fetch user profile by userId and return structured result.",
    schema: z.object({ userId: z.string() }),
  }
);

import type {
  BaseCallbackHandler,
  CallbackManagerForToolRun,
} from "langchain/callbacks";

class ToolLoopBreaker extends (Object as { new (): BaseCallbackHandler }) {
  name = "tool_loop_breaker";
  private window: string[] = [];

  constructor(private readonly limit: number = 3) {
    super();
  }

  async handleToolStart(
    tool: { name: string },
    input: string,
    runId: string,
    parentRunId?: string,
    tags?: string[],
    metadata?: Record<string, unknown>,
    runManager?: CallbackManagerForToolRun
  ) {
    const key = `${tool.name}:${input}`;
    this.window.push(key);
    if (this.window.length > 10) this.window.shift();

    const recent = this.window.slice(-this.limit);
    const allSame = recent.length === this.limit && recent.every(v => v === recent[0]);

    if (allSame) {
      throw new Error(
        `Tool loop detected: repeated ${tool.name} with same input ${this.limit} times`
      );
    }
  }
}

// executor 생성 시 callbacks에 주입
const callbacks = [new ToolLoopBreaker(3)];

async function retry<T>(fn: () => Promise<T>, opts: { retries: number; baseMs: number }) {
  let lastErr: any;
  for (let i = 0; i <= opts.retries; i++) {
    try {
      return await fn();
    } catch (e) {
      lastErr = e;
      const wait = opts.baseMs * Math.pow(2, i);
      await new Promise(r => setTimeout(r, wait));
    }
  }
  throw lastErr;
}

export const searchTool = tool(
  async (input: { q: string }) => {
    try {
      const data = await retry(
        () => fetch(`https://search.example.com?q=${encodeURIComponent(input.q)}`).then(r => r.json()),
        { retries: 2, baseMs: 200 }
      );
      return { ok: true, done: true, retryable: false, data };
    } catch (e: any) {
      return { ok: false, done: true, retryable: false, reason: "Search failed after retries" };
    }
  },
  {
    name: "search",
    description: "Search the web and return results. Retries are handled internally.",
    schema: z.object({ q: z.string().min(1) }),
  }
);

- If a tool call fails with retryable=false, do not call the same tool again.
- Do not repeat a tool call with the same arguments.
- When you have enough information to answer, stop using tools and provide the final answer.

function withTimeout(ms: number) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(new Error("timeout")), ms);
  return {
    signal: controller.signal,
    clear: () => clearTimeout(timer),
  };
}

export const httpGetTool = tool(
  async (input: { url: string }) => {
    const { signal, clear } = withTimeout(4000);
    try {
      const res = await fetch(input.url, { signal });
      const text = await res.text();
      return { ok: true, done: true, retryable: false, data: text.slice(0, 2000) };
    } catch (e: any) {
      const isAbort = String(e?.name).includes("Abort") || String(e?.message).includes("timeout");
      return { ok: false, done: !isAbort, retryable: isAbort, reason: "HTTP request failed" };
    } finally {
      clear();
    }
  },
  {
    name: "http_get",
    description: "GET a URL with timeout and return truncated body.",
    schema: z.object({ url: z.string().url() }),
  }
);

try {
  const result = await executor.invoke({ input: userInput }, { callbacks });
  return result;
} catch (e: any) {
  const msg = String(e?.message ?? e);
  if (msg.includes("Tool loop detected")) {
    return {
      output:
        "도구 호출이 반복되어 안전장치가 실행되었습니다. " +
        "현재 정보만으로는 확답이 어렵습니다. " +
        "다음 중 하나를 알려주시면 도구 호출 없이 정리해 드릴게요: (1) 정확한 에러 로그 (2) 기대 결과 (3) 마지막으로 성공했던 입력",
    };
  }
  throw e;
}