Antigravity Agent の Record & Replay — 失敗を3分で再現する本番運用パターン

// recorder.ts
import { createHash } from "node:crypto";
 
type Mode = "record" | "replay" | "off";
 
export interface Trace {
  runId: string;
  events: TraceEvent[];
}
 
export type TraceEvent =
  | { kind: "model_call"; t: number; hash: string; req: unknown; res: unknown }
  | { kind: "tool_call"; t: number; name: string; args: unknown; res: unknown }
  | { kind: "clock"; t: number; value: number }
  | { kind: "random"; t: number; value: number };
 
const MODE: Mode = (process.env.AGY_RECORDER_MODE as Mode) ?? "off";
let currentTrace: Trace | null = null;
let replayCursor = 0;
let replayTrace: Trace | null = null;
 
export function startRun(runId: string) {
  if (MODE === "record") currentTrace = { runId, events: [] };
}
 
export function endRun(): Trace | null {
  const t = currentTrace;
  currentTrace = null;
  return t;
}
 
export function loadReplay(trace: Trace) {
  replayTrace = trace;
  replayCursor = 0;
}
 
// 任意のオブジェクトから決定的ハッシュを作る
function hashOf(obj: unknown): string {
  return createHash("sha256").update(JSON.stringify(obj)).digest("hex").slice(0, 12);
}
 
// モデル呼び出しを包む
export async function recordedModelCall<T>(
  req: unknown,
  exec: () => Promise<T>,
): Promise<T> {
  const t = Date.now();
  const hash = hashOf(req);
  if (MODE === "replay" && replayTrace) {
    const ev = replayTrace.events[replayCursor++];
    if (!ev || ev.kind !== "model_call" || ev.hash !== hash) {
      throw new Error(`Replay divergence at cursor ${replayCursor - 1}`);
    }
    return ev.res as T;
  }
  const res = await exec();
  currentTrace?.events.push({ kind: "model_call", t, hash, req, res });
  return res;
}
 
// ツール呼び出しを包む
export async function recordedTool<T>(
  name: string,
  args: unknown,
  exec: () => Promise<T>,
): Promise<T> {
  const t = Date.now();
  if (MODE === "replay" && replayTrace) {
    const ev = replayTrace.events[replayCursor++];
    if (!ev || ev.kind !== "tool_call" || ev.name !== name) {
      throw new Error(`Replay divergence: expected ${name}`);
    }
    return ev.res as T;
  }
  const res = await exec();
  currentTrace?.events.push({ kind: "tool_call", t, name, args, res });
  return res;
}
 
// 時計の境界
export function now(): number {
  if (MODE === "replay" && replayTrace) {
    const ev = replayTrace.events[replayCursor++];
    if (!ev || ev.kind !== "clock") throw new Error("Replay clock divergence");
    return ev.value;
  }
  const t = Date.now();
  currentTrace?.events.push({ kind: "clock", t, value: t });
  return t;
}

// replay-harness.ts
import { loadReplay, type Trace } from "./recorder";
import { runAgent } from "./agent";
import { readFileSync } from "node:fs";
 
async function main() {
  const path = process.argv[2];
  if (!path) throw new Error("usage: replay <trace.json>");
  process.env.AGY_RECORDER_MODE = "replay";
  const trace: Trace = JSON.parse(readFileSync(path, "utf-8"));
  loadReplay(trace);
  // 入力プロンプトは trace の最初の model_call から復元
  const firstReq = (trace.events.find((e) => e.kind === "model_call") as any).req;
  await runAgent(firstReq.messages);
}
main().catch((e) => {
  console.error("[replay]", e);
  process.exit(1);
});

// trace-store.ts (Cloudflare Workers 想定)
export interface Env {
  TRACES_R2: R2Bucket;
  TRACES_KV: KVNamespace;
}
 
export async function putTrace(env: Env, trace: Trace, failed: boolean) {
  const key = `traces/${trace.runId}.json`;
  await env.TRACES_R2.put(key, JSON.stringify(trace), {
    httpMetadata: { contentType: "application/json" },
  });
  await env.TRACES_KV.put(
    `idx:${trace.runId}`,
    JSON.stringify({ key, failed, t: Date.now() }),
    { expirationTtl: failed ? 90 * 86400 : 7 * 86400 },
  );
}
 
export async function getTrace(env: Env, runId: string): Promise<Trace | null> {
  const idx = await env.TRACES_KV.get(`idx:${runId}`, "json") as any;
  if (!idx) return null;
  const obj = await env.TRACES_R2.get(idx.key);
  return obj ? (await obj.json()) as Trace : null;
}

// mask.ts
const SECRET_PATTERNS: RegExp[] = [
  /sk-[A-Za-z0-9_-]{20,}/g,             // モデルプロバイダ秘密鍵
  /ghp_[A-Za-z0-9]{36}/g,                // GitHub PAT
  /pk_live_[A-Za-z0-9]{20,}/g,           // Stripe publishable
  /price_[A-Za-z0-9]{14,}/g,             // Stripe price id
  /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, // email
];
 
export function mask<T>(value: T): T {
  const s = JSON.stringify(value);
  let masked = s;
  for (const p of SECRET_PATTERNS) masked = masked.replace(p, "<REDACTED>");
  // Authorization ヘッダ・Cookie はキー単位で消す
  masked = masked.replace(/"authorization"\s*:\s*"[^"]*"/gi, '"authorization":"<REDACTED>"');
  masked = masked.replace(/"cookie"\s*:\s*"[^"]*"/gi, '"cookie":"<REDACTED>"');
  return JSON.parse(masked);
}

// match-mode.ts
import { createHash } from "node:crypto";
 
export type MatchMode = "strict" | "loose";
 
const MATCH: MatchMode = (process.env.AGY_REPLAY_MATCH as MatchMode) ?? "strict";
 
export function requestKey(req: any, mode: MatchMode = MATCH): string {
  if (mode === "strict") {
    return createHash("sha256").update(JSON.stringify(req)).digest("hex").slice(0, 12);
  }
  // loose: 使える道具の集合と、最後のユーザー発話だけを見る
  const toolNames = (req.tools ?? []).map((t: any) => t.name).sort().join(",");
  const lastUser = [...(req.messages ?? [])].reverse().find((m: any) => m.role === "user");
  const lastText =
    typeof lastUser?.content === "string"
      ? lastUser.content
      : (lastUser?.content ?? []).map((c: any) => c.text ?? "").join("");
  return createHash("sha256")
    .update(`${toolNames}\n${lastText.trim()}`)
    .digest("hex")
    .slice(0, 12);
}
 
// divergence を「どのフィールドがずれたか」まで見せる
export function explainDivergence(recorded: any, current: any): string {
  const keys = new Set([
    ...Object.keys(recorded ?? {}),
    ...Object.keys(current ?? {}),
  ]);
  const lines: string[] = [];
  for (const k of keys) {
    const a = JSON.stringify(recorded?.[k]);
    const b = JSON.stringify(current?.[k]);
    if (a === b) continue;
    lines.push(`  ${k}: recorded=${trunc(a)} / now=${trunc(b)}`);
  }
  return lines.length ? lines.join("\n") : "  (フィールド単位の差分なし)";
}
 
function trunc(s = "undefined", n = 120) {
  return s.length > n ? `${s.slice(0, n)}…` : s;
}

if (MODE === "replay" && replayTrace) {
  const ev = replayTrace.events[replayCursor++];
  if (!ev || ev.kind !== "model_call") {
    throw new Error(`Replay divergence: expected model_call at ${replayCursor - 1}`);
  }
  const want = requestKey((ev as any).req);
  const got = requestKey(req);
  if (want !== got) {
    throw new Error(
      `Replay divergence at ${replayCursor - 1} (mode=${MATCH})\n` +
        explainDivergence((ev as any).req, req),
    );
  }
  return ev.res as T;
}

// bisect.ts (簡略版)
export async function bisect(trace: Trace, predicate: (subTrace: Trace) => Promise<boolean>) {
  let lo = 0;
  let hi = trace.events.length;
  while (hi - lo > 1) {
    const mid = Math.floor((lo + hi) / 2);
    const sub: Trace = { ...trace, events: trace.events.slice(0, mid) };
    if (await predicate(sub)) hi = mid;
    else lo = mid;
  }
  return lo;
}