Chain-of-Thought 없이 추론 - ReAct·RAP 실전

// tools.ts
export type ToolName = "web_search" | "get_doc";

export type ToolCall =
  | { name: "web_search"; args: { query: string } }
  | { name: "get_doc"; args: { id: string } };

export async function runTool(call: ToolCall) {
  switch (call.name) {
    case "web_search": {
      // 실제로는 사내 검색, OpenSearch, Serp API 등으로 대체
      const { query } = call.args;
      return {
        results: [
          { title: "Result A", snippet: `About: ${query}`, url: "https://example.com/a" },
          { title: "Result B", snippet: `More: ${query}`, url: "https://example.com/b" }
        ]
      };
    }
    case "get_doc": {
      const { id } = call.args;
      return { id, content: `Document content for ${id}` };
    }
  }
}

// protocol.ts
export type AgentStep =
  | { type: "tool"; call: { name: string; args: any } }
  | { type: "final"; answer: string };

export function safeJsonParse(input: string) {
  try {
    return { ok: true as const, value: JSON.parse(input) };
  } catch (e) {
    return { ok: false as const, error: e };
  }
}

// agent.ts
import { runTool, ToolCall } from "./tools";
import { AgentStep, safeJsonParse } from "./protocol";

type Message = { role: "system" | "user" | "assistant"; content: string };

async function callLLM(messages: Message[]): Promise<string> {
  // 벤더 SDK 호출로 교체
  // 여기서는 모델이 JSON만 반환한다고 가정
  return "";
}

export async function runReAct(question: string) {
  const system: Message = {
    role: "system",
    content: [
      "You are an agent.",
      "Do not output reasoning.",
      "Return ONLY JSON.",
      "Output must be either:",
      "{\"type\":\"tool\",\"call\":{\"name\":string,\"args\":object}}",
      "or {\"type\":\"final\",\"answer\":string}"
    ].join("\n")
  };

  const messages: Message[] = [
    system,
    { role: "user", content: question }
  ];

  const observations: any[] = [];
  const maxSteps = 6;

  for (let step = 0; step < maxSteps; step++) {
    // 관찰값을 모델에게 주되, 원본 로그를 과다 노출하지 않도록 요약 가능
    if (observations.length > 0) {
      messages.push({
        role: "assistant",
        content: JSON.stringify({
          type: "observation",
          items: observations
        })
      });
    }

    const raw = await callLLM(messages);
    const parsed = safeJsonParse(raw);
    if (!parsed.ok) {
      // 모델이 포맷을 어기면 재시도 프롬프트로 교정
      messages.push({
        role: "assistant",
        content: "Invalid JSON. Return ONLY valid JSON for the protocol."
      });
      continue;
    }

    const out = parsed.value as AgentStep;

    if (out.type === "final") {
      return { answer: out.answer, observations };
    }

    if (out.type === "tool") {
      const call = out.call as ToolCall;
      const toolResult = await runTool(call);
      observations.push({ call, result: toolResult });
      continue;
    }

    // 방어적 처리
    messages.push({
      role: "assistant",
      content: "Protocol violation. Output must be tool or final."
    });
  }

  return {
    answer: "I could not finish within the step limit.",
    observations
  };
}

// rap.ts
type Proposal = { id: string; plan: string; requiredTools: string[] };

export function validateAnswer(answer: string) {
  // 실무에서는 규칙 기반 + LLM 기반 평가를 섞기도 함
  const tooVague = answer.length < 80;
  const hasSteps = answer.includes("1)") || answer.includes("- ");

  return {
    ok: !tooVague && hasSteps,
    reasons: [
      ...(tooVague ? ["too_short"] : []),
      ...(!hasSteps ? ["no_actionable_steps"] : [])
    ]
  };
}

export async function runRAP(question: string) {
  // 1) proposal 생성(모델)
  const proposals: Proposal[] = [
    { id: "p1", plan: "Search docs and summarize", requiredTools: ["web_search"] },
    { id: "p2", plan: "Fetch internal doc by id", requiredTools: ["get_doc"] }
  ];

  // 2) 가장 적합한 proposal을 고르거나, 둘 다 실행해 비교
  // 3) 실행 결과로 답 생성
  const draft = `1) Check logs\n2) Verify config\n3) Apply fix\n...`;

  // 4) 검증 실패 시 수정 루프
  const v = validateAnswer(draft);
  if (!v.ok) {
    const revised = draft + "\n\n(Added more concrete steps.)";
    return { answer: revised, validator: v };
  }

  return { answer: draft, validator: v };
}