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);
}

// 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;
}