Skip to content
TypeScript
5.3 KB
Raw Blame
/**
 * 멀티모델 에이전트 러너 (opencode / openclaw / hermes).
 * 이 도구들은 provider/model 형식으로 모델을 받는 모델-불문 에이전트다.
 * 각 도구의 실제 호출 규약(웹 문서 기준):
 *   - opencode: `opencode run --format json --model <provider>/<model> --dir <work> "<prompt>"`
 *   - openclaw: `openclaw agent --message "<prompt>" --model <provider>/<model> --json`
 *   - hermes:   `hermes -z "<prompt>" --model <provider>/<model>`  (stdout = 평문 결과)
 * fail-soft: 절대 throw 금지, 항상 output.txt + transcript.jsonl.
 */
import { mkdirSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { instructionFor, isLocalBench, setupTask, taskIds, verify } from "../benches/index";
import { parseComboId } from "../combos";
import { modelFamily, providerFor, resolveModelAlias } from "../config";
import { applyHarnessToWorkdir } from "../harness";
import type { RawRunArtifact, RunInvocation } from "../models";
import { type RunnerAdapter, RunnerUnavailable } from "./base";
import { commandExists, execCapture } from "./util";

export interface MultiModelSpec {
  name: string;
  bin: string;
  /** 인자 빌더. modelArg 는 'provider/model' 또는 null('default' → 생략). */
  buildArgs(instruction: string, modelArg: string | null, work: string): string[];
  /** stdout 에서 사람이 읽을 결과 텍스트 추출. */
  extractResult(stdout: string): string;
}

export class MultiModelRunner implements RunnerAdapter {
  constructor(private spec: MultiModelSpec) {}

  get name(): string {
    return this.spec.name;
  }

  isAvailable(): boolean {
    return commandExists(this.spec.bin);
  }

  loadTaskCatalog(bench: string): string[] {
    if (isLocalBench(bench)) return taskIds(bench);
    throw new RunnerUnavailable(
      `${this.spec.name}: external bench '${bench}' not supported directly`,
    );
  }

  async run(inv: RunInvocation): Promise<RawRunArtifact> {
    const { model, harness } = parseComboId(inv.combo.comboId);
    const work = inv.workDir;
    mkdirSync(work, { recursive: true });
    const resultPath = join(work, "output.txt");
    const transcriptPath = join(work, "transcript.jsonl");

    if (isLocalBench(inv.bench)) setupTask(inv.taskId, work);
    // 하네스 per-run 적용 (룰/스킬을 work_dir 로 materialize; 전역 오염 없음)
    applyHarnessToWorkdir(harness, work);

    const instruction =
      inv.instruction ?? instructionFor(inv.taskId) ?? `Complete task ${inv.taskId}`;
    const resolved = resolveModelAlias(model);
    // 'default'(계정 기본)은 명시 모델 생략, 그 외엔 provider/model
    const modelArg =
      resolved === "default" ? null : `${providerFor(modelFamily(model))}/${resolved}`;

    const args = this.spec.buildArgs(instruction, modelArg, work);
    const res = await execCapture(this.spec.bin, args, { cwd: work, timeoutS: inv.timeoutS });

    writeFileSync(transcriptPath, res.stdout || "");
    writeFileSync(
      resultPath,
      res.stdout ? this.spec.extractResult(res.stdout) : res.stderr || "(no output)",
    );

    const ok = res.error === null && !res.timedOut && res.code === 0;
    const rawResolved = isLocalBench(inv.bench) ? verify(inv.taskId, work) : null;

    return {
      invocation: inv,
      success: ok,
      resultPath,
      transcriptPath,
      wallTimeMs: res.wallTimeMs,
      rawResolved,
      totalCostUsd: null, // 비용은 단가맵 추정으로 위임
      numTurns: null,
      error: res.error ?? (res.timedOut ? "timeout" : res.code !== 0 ? `exit ${res.code}` : null),
    };
  }
}

// ── 도구별 spec ──────────────────────────────────────────
function jsonTextFields(stdout: string): string {
  const texts: string[] = [];
  const collect = (n: unknown): void => {
    if (!n || typeof n !== "object") return;
    if (Array.isArray(n)) {
      for (const v of n) collect(v);
      return;
    }
    const o = n as Record<string, unknown>;
    if (typeof o.text === "string") texts.push(o.text);
    for (const v of Object.values(o)) collect(v);
  };
  for (const line of stdout.split("\n")) {
    const s = line.trim();
    if (!s) continue;
    try {
      collect(JSON.parse(s));
    } catch {
      // ignore
    }
  }
  return texts.join("\n") || stdout.trim();
}

export const OPENCODE_SPEC: MultiModelSpec = {
  name: "opencode",
  bin: "opencode",
  buildArgs: (instruction, modelArg, work) => [
    "run",
    "--format",
    "json",
    "--dir",
    work,
    ...(modelArg ? ["--model", modelArg] : []),
    instruction,
  ],
  extractResult: (stdout) => jsonTextFields(stdout),
};

export const OPENCLAW_SPEC: MultiModelSpec = {
  name: "openclaw",
  bin: "openclaw",
  buildArgs: (instruction, modelArg) => [
    "agent",
    "--message",
    instruction,
    "--json",
    ...(modelArg ? ["--model", modelArg] : []),
  ],
  extractResult: (stdout) => jsonTextFields(stdout),
};

export const HERMES_SPEC: MultiModelSpec = {
  name: "hermes",
  bin: "hermes",
  buildArgs: (instruction, modelArg) => [
    "-z",
    instruction,
    ...(modelArg ? ["--model", modelArg] : []),
  ],
  extractResult: (stdout) => stdout.trim(), // 평문
};

export const MULTIMODEL_SPECS: Record<string, MultiModelSpec> = {
  opencode: OPENCODE_SPEC,
  openclaw: OPENCLAW_SPEC,
  hermes: HERMES_SPEC,
};