再現できないエージェント障害をなくす設計 — 決定論的リプレイとイベントソーシング

// boundary.ts
import { AgentEvent, BoundaryKind, EventStore } from "./events";
 
export type Mode = "record" | "replay";
 
export class RunContext {
  private seq = 0;
  private cursor = 0;
  private recorded: AgentEvent[] = [];
 
  constructor(
    public readonly runId: string,
    public readonly mode: Mode,
    private readonly store: EventStore,
    private replayLog: AgentEvent[] = [],
  ) {}
 
  static async forReplay(runId: string, store: EventStore) {
    const log = await store.load(runId);
    return new RunContext(runId, "replay", store, log);
  }
 
  // すべての非決定境界はこの1点を通す
  async boundary<T>(
    kind: BoundaryKind,
    key: string,
    input: unknown,
    real: () => Promise<{ value: T; tokensIn?: number; tokensOut?: number; costUsd?: number }>,
  ): Promise<T> {
    const seq = this.seq++;
 
    if (this.mode === "replay") {
      const e = this.replayLog[this.cursor++];
      if (!e || e.kind !== kind || e.key !== key || e.seq !== seq) {
        // 録音時と分岐がずれた = リプレイ前提が壊れている
        throw new ReplayDivergenceError(this.runId, seq, kind, key, e);
      }
      return e.output as T;
    }
 
    const r = await real();
    const event: AgentEvent = {
      runId: this.runId, seq, kind, key,
      input, output: r.value,
      tokensIn: r.tokensIn, tokensOut: r.tokensOut, costUsd: r.costUsd,
      ts: new Date().toISOString(),
    };
    await this.store.append(event);
    this.recorded.push(event);
    return r.value;
  }
}
 
export class ReplayDivergenceError extends Error {
  constructor(runId: string, seq: number, kind: string, key: string, got: AgentEvent | undefined) {
    super(`Replay diverged at run=${runId} seq=${seq} expected ${kind}:${key} got ${got?.kind}:${got?.key}`);
    this.name = "ReplayDivergenceError";
  }
}

// model.ts
import Anthropic from "@anthropic-ai/sdk";
import { RunContext } from "./boundary";
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }); // 例: "YOUR_API_KEY"
 
// 概算コスト（Sonnet 4.6 の例。実値は料金ページの単価で更新してください）
const PRICE_IN = 3.0 / 1_000_000;   // USD / input token
const PRICE_OUT = 15.0 / 1_000_000; // USD / output token
 
export async function callClaude(ctx: RunContext, messages: Anthropic.MessageParam[]) {
  return ctx.boundary("model", "claude:messages", { messages }, async () => {
    const res = await client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 2048,
      temperature: 0,
      messages,
    });
    const tin = res.usage.input_tokens;
    const tout = res.usage.output_tokens;
    return {
      value: res,
      tokensIn: tin,
      tokensOut: tout,
      costUsd: tin * PRICE_IN + tout * PRICE_OUT,
    };
  });
}

// tools.ts
import { RunContext } from "./boundary";
 
export const now = (ctx: RunContext) =>
  ctx.boundary("clock", "now", null, async () => ({ value: Date.now() }));
 
export const rand = (ctx: RunContext) =>
  ctx.boundary("random", "rand", null, async () => ({ value: Math.random() }));
 
export async function fetchOrders(ctx: RunContext, customerId: string) {
  return ctx.boundary("tool", "tool:fetch_orders", { customerId }, async () => {
    const res = await fetch(`https://api.example.com/orders?c=${customerId}`);
    return { value: await res.json() };
  });
}

// replay.ts
import { RunContext } from "./boundary";
import { jsonlStore } from "./store";
import { runAgent } from "./agent"; // 本番と同一のループ本体
 
async function replay(runId: string) {
  const ctx = await RunContext.forReplay(runId, jsonlStore);
  try {
    const result = await runAgent(ctx); // ネットワークもLLMも一切叩かない
    console.log("再生完了:", result);
  } catch (e) {
    if (e instanceof Error && e.name === "ReplayDivergenceError") {
      console.error("分岐ずれを検出。コード変更か記録欠落の可能性:", e.message);
    } else {
      console.error("録音時と同じ地点で失敗を再現:", e);
    }
  }
}
 
replay(process.argv[2]);

// cost.ts
import { EventStore } from "./events";
 
export async function runCost(store: EventStore, runId: string) {
  const events = await store.load(runId);
  const model = events.filter((e) => e.kind === "model");
  const tokensIn = model.reduce((s, e) => s + (e.tokensIn ?? 0), 0);
  const tokensOut = model.reduce((s, e) => s + (e.tokensOut ?? 0), 0);
  const costUsd = model.reduce((s, e) => s + (e.costUsd ?? 0), 0);
  return { runId, calls: model.length, tokensIn, tokensOut, costUsd };
}