@reactive-agents/replay 0.11.0

package/dist/index.d.ts

@@ -0,0 +1,139 @@
+import { Trace, TraceEvent } from '@reactive-agents/trace';
+import { Layer } from 'effect';
+import { ToolService } from '@reactive-agents/tools';
+
+interface RecordedToolResult {
+    readonly toolName: string;
+    readonly argsHash: string;
+    readonly args: unknown;
+    readonly result: unknown;
+    readonly ok: boolean;
+    readonly error?: string;
+    readonly durationMs: number;
+    readonly iter: number;
+    readonly seq: number;
+    readonly truncated?: boolean;
+}
+interface RecordedRun {
+    readonly runId: string;
+    readonly task: string;
+    readonly model: string;
+    readonly provider: string;
+    readonly config: Readonly<Record<string, unknown>>;
+    readonly trace: Trace;
+    readonly toolTable: ReadonlyMap<string, readonly RecordedToolResult[]>;
+}
+interface ReplayOverrides {
+    readonly systemPrompt?: string;
+    readonly model?: string;
+    readonly temperature?: number;
+    /** strict (default): error on unrecorded tool call. lenient: return no-recording marker. */
+    readonly onMissingToolResult?: "strict" | "lenient";
+}
+type BuilderFn = (() => Promise<unknown>) | ((ctx: BuildContext) => Promise<unknown>);
+interface BuildContext {
+    readonly overrides: ReplayOverrides;
+    readonly recordedRun: RecordedRun;
+}
+interface TraceSnapshot {
+    readonly runId: string;
+    readonly task: string;
+    readonly model: string;
+    readonly iterations: number;
+    readonly toolCalls: readonly {
+        readonly toolName: string;
+        readonly argsHash: string;
+        readonly ok: boolean;
+    }[];
+    readonly output: string | undefined;
+    readonly totalTokens: number;
+    readonly totalCostUsd: number;
+    readonly durationMs: number;
+}
+type ToolSeqEdit = {
+    readonly kind: "added";
+    readonly toolName: string;
+    readonly argsHash: string;
+    readonly atIndex: number;
+} | {
+    readonly kind: "removed";
+    readonly toolName: string;
+    readonly argsHash: string;
+    readonly atIndex: number;
+} | {
+    readonly kind: "reordered";
+    readonly toolName: string;
+    readonly argsHash: string;
+    readonly from: number;
+    readonly to: number;
+};
+interface ReplayDiff {
+    readonly identical: boolean;
+    readonly iterationsDelta: number;
+    readonly toolSequenceDiff: readonly ToolSeqEdit[];
+    readonly outputDiff: {
+        readonly original: string | undefined;
+        readonly replay: string | undefined;
+        readonly equal: boolean;
+    };
+    readonly tokensDelta: number;
+    readonly costDelta: number;
+    readonly durationDeltaMs: number;
+}
+interface ReplayResult {
+    readonly original: TraceSnapshot;
+    readonly replay: TraceSnapshot;
+    readonly diff: ReplayDiff;
+}
+
+declare function loadRecordedRun(idOrPath: string): Promise<RecordedRun>;
+
+declare function computeArgsHash(args: unknown): string;
+declare function buildToolTable(events: readonly TraceEvent[]): Map<string, RecordedToolResult[]>;
+
+type ReplayHit = {
+    readonly hit: true;
+    readonly result: unknown;
+    readonly ok: boolean;
+    readonly error?: string;
+    readonly truncated?: boolean;
+} | {
+    readonly hit: false;
+};
+interface ReplayResultProvider {
+    readonly next: (toolName: string, args: unknown) => ReplayHit;
+}
+declare function makeReplayController(table: ReadonlyMap<string, readonly RecordedToolResult[]>): ReplayResultProvider;
+
+declare function makeReplayToolLayer(provider: ReplayResultProvider, mode?: "strict" | "lenient"): Layer.Layer<ToolService, never, never>;
+
+declare function diffTraces(a: TraceSnapshot, b: TraceSnapshot): ReplayDiff;
+
+declare function snapshotFromRecordedRun(run: RecordedRun): TraceSnapshot;
+interface AgentRunOutcome {
+    readonly output?: string;
+    readonly totalTokens?: number;
+    readonly totalCostUsd?: number;
+    readonly durationMs?: number;
+    readonly toolCalls?: readonly {
+        readonly toolName: string;
+        readonly argsHash: string;
+        readonly ok: boolean;
+    }[];
+    readonly iterations?: number;
+}
+declare function snapshotFromAgentResult(result: AgentRunOutcome, recordedRun: RecordedRun): TraceSnapshot;
+
+/**
+ * Re-run a recorded agent run with optional prompt/model overrides.
+ *
+ * The builder function is responsible for constructing an agent that uses the
+ * replay tool layer ({@link makeReplayToolLayer}) so tool results are dispensed
+ * from the recording rather than executed live. Builder must return an object
+ * exposing `run(task: string): Promise<AgentRunOutcome>` and an optional
+ * `dispose()`. The orchestrator invokes `run(recordedRun.task)`, captures the
+ * outcome, and produces a structural diff against the original.
+ */
+declare function replay(recordedRun: RecordedRun, builderFn: BuilderFn, overrides?: ReplayOverrides): Promise<ReplayResult>;
+
+export { type AgentRunOutcome, type BuildContext, type BuilderFn, type RecordedRun, type RecordedToolResult, type ReplayDiff, type ReplayHit, type ReplayOverrides, type ReplayResult, type ReplayResultProvider, type ToolSeqEdit, type TraceSnapshot, buildToolTable, computeArgsHash, diffTraces, loadRecordedRun, makeReplayController, makeReplayToolLayer, replay, snapshotFromAgentResult, snapshotFromRecordedRun };

package/dist/index.js

@@ -0,0 +1,262 @@
+// src/load.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, isAbsolute } from "path";
+import { loadTrace } from "@reactive-agents/trace";
+
+// src/tool-table.ts
+import { createHash } from "crypto";
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
+  if (Array.isArray(v)) return "[" + v.map(stableStringify).join(",") + "]";
+  const obj = v;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function computeArgsHash(args) {
+  return createHash("sha256").update(stableStringify(args)).digest("hex").slice(0, 16);
+}
+function buildToolTable(events) {
+  const table = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind !== "tool-call-end") continue;
+    const e = ev;
+    const argsHash = computeArgsHash(e.args);
+    const key = `${e.toolName}::${argsHash}`;
+    const entry = {
+      toolName: e.toolName,
+      argsHash,
+      args: e.args,
+      result: e.result,
+      ok: e.ok ?? true,
+      error: e.error,
+      durationMs: e.durationMs ?? 0,
+      iter: e.iter,
+      seq: e.seq,
+      truncated: e.resultTruncated
+    };
+    const list = table.get(key) ?? [];
+    list.push(entry);
+    table.set(key, list);
+  }
+  return table;
+}
+
+// src/load.ts
+var SEARCH_DIRS = [
+  join(homedir(), ".reactive-agents", "traces"),
+  join(process.cwd(), ".reactive-agents", "traces")
+];
+async function loadRecordedRun(idOrPath) {
+  const path = resolvePath(idOrPath);
+  const trace = await loadTrace(path);
+  const runStarted = trace.events.find(
+    (e) => e.kind === "run-started"
+  );
+  if (!runStarted) {
+    throw new Error(`replay: no run-started event in ${path}`);
+  }
+  const toolTable = buildToolTable(trace.events);
+  return {
+    runId: trace.runId,
+    task: runStarted.task,
+    model: runStarted.model,
+    provider: runStarted.provider,
+    config: runStarted.config,
+    trace,
+    toolTable
+  };
+}
+function resolvePath(idOrPath) {
+  if (isAbsolute(idOrPath) && existsSync(idOrPath)) return idOrPath;
+  if (existsSync(idOrPath)) return idOrPath;
+  for (const dir of SEARCH_DIRS) {
+    const candidate = join(dir, `${idOrPath}.jsonl`);
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`replay: cannot resolve ${idOrPath}; searched ${SEARCH_DIRS.join(", ")}`);
+}
+
+// src/replay-controller.ts
+function makeReplayController(table) {
+  const cursors = /* @__PURE__ */ new Map();
+  return {
+    next(toolName, args) {
+      const key = `${toolName}::${computeArgsHash(args)}`;
+      const list = table.get(key);
+      if (!list) return { hit: false };
+      const idx = cursors.get(key) ?? 0;
+      if (idx >= list.length) return { hit: false };
+      cursors.set(key, idx + 1);
+      const rec = list[idx];
+      return {
+        hit: true,
+        result: rec.result,
+        ok: rec.ok,
+        error: rec.error,
+        truncated: rec.truncated
+      };
+    }
+  };
+}
+
+// src/replay-tool-layer.ts
+import { Effect, Layer } from "effect";
+import { ToolService } from "@reactive-agents/tools";
+var die = (m) => Effect.die(new Error(`replay: ToolService.${m} not supported during replay`));
+function makeReplayToolLayer(provider, mode = "strict") {
+  return Layer.succeed(
+    ToolService,
+    ToolService.of({
+      execute: ((input) => Effect.gen(function* () {
+        const hit = provider.next(input.toolName, input.arguments);
+        const started = Date.now();
+        if (!hit.hit) {
+          if (mode === "strict") {
+            return yield* Effect.die(
+              new Error(
+                `replay: unrecorded tool call ${input.toolName} (strict mode); switch to onMissingToolResult:"lenient" or extend the recording`
+              )
+            );
+          }
+          return {
+            toolName: input.toolName,
+            success: false,
+            error: "replay: no recording for this call (lenient mode)",
+            executionTimeMs: Date.now() - started
+          };
+        }
+        if (!hit.ok) {
+          return {
+            toolName: input.toolName,
+            success: false,
+            error: hit.error ?? "replay: recorded error",
+            executionTimeMs: Date.now() - started
+          };
+        }
+        if (hit.truncated && mode === "strict") {
+          return yield* Effect.die(
+            new Error(
+              `replay: recorded tool result for ${input.toolName} was truncated; live re-execution may diverge. Switch to lenient mode to proceed.`
+            )
+          );
+        }
+        return {
+          toolName: input.toolName,
+          success: true,
+          result: hit.result,
+          executionTimeMs: Date.now() - started
+        };
+      })),
+      register: (() => die("register")),
+      unregisterTool: (() => Effect.succeed(void 0)),
+      connectMCPServer: (() => die("connectMCPServer")),
+      disconnectMCPServer: (() => die("disconnectMCPServer")),
+      listTools: (() => Effect.succeed([])),
+      getTool: (() => die("getTool")),
+      toFunctionCallingFormat: (() => Effect.succeed([])),
+      listMCPServers: (() => Effect.succeed([]))
+    })
+  );
+}
+
+// src/diff.ts
+function diffTraces(a, b) {
+  const outputEqual = a.output === b.output;
+  const toolSequenceDiff = diffToolSequence(a.toolCalls, b.toolCalls);
+  const identical = outputEqual && a.iterations === b.iterations && toolSequenceDiff.length === 0 && a.totalTokens === b.totalTokens;
+  return {
+    identical,
+    iterationsDelta: b.iterations - a.iterations,
+    toolSequenceDiff,
+    outputDiff: { original: a.output, replay: b.output, equal: outputEqual },
+    tokensDelta: b.totalTokens - a.totalTokens,
+    costDelta: b.totalCostUsd - a.totalCostUsd,
+    durationDeltaMs: b.durationMs - a.durationMs
+  };
+}
+function diffToolSequence(a, b) {
+  const edits = [];
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x && !y) {
+      edits.push({ kind: "removed", toolName: x.toolName, argsHash: x.argsHash, atIndex: i });
+    } else if (!x && y) {
+      edits.push({ kind: "added", toolName: y.toolName, argsHash: y.argsHash, atIndex: i });
+    } else if (x && y && (x.toolName !== y.toolName || x.argsHash !== y.argsHash)) {
+      edits.push({ kind: "removed", toolName: x.toolName, argsHash: x.argsHash, atIndex: i });
+      edits.push({ kind: "added", toolName: y.toolName, argsHash: y.argsHash, atIndex: i });
+    }
+  }
+  return edits;
+}
+
+// src/snapshot.ts
+import { traceStats } from "@reactive-agents/trace";
+function snapshotFromRecordedRun(run) {
+  const stats = traceStats(run.trace);
+  const completed = run.trace.events.find(
+    (e) => e.kind === "run-completed"
+  );
+  const toolCalls = [];
+  for (const [, list] of run.toolTable) {
+    for (const r of list) {
+      toolCalls.push({ toolName: r.toolName, argsHash: r.argsHash, ok: r.ok });
+    }
+  }
+  return {
+    runId: run.runId,
+    task: run.task,
+    model: run.model,
+    iterations: stats.iterations,
+    toolCalls,
+    output: completed?.output,
+    totalTokens: stats.totalTokens,
+    totalCostUsd: completed?.totalCostUsd ?? 0,
+    durationMs: stats.durationMs
+  };
+}
+function snapshotFromAgentResult(result, recordedRun) {
+  return {
+    runId: `${recordedRun.runId}-replay`,
+    task: recordedRun.task,
+    model: recordedRun.model,
+    iterations: result.iterations ?? 0,
+    toolCalls: result.toolCalls ?? [],
+    output: result.output,
+    totalTokens: result.totalTokens ?? 0,
+    totalCostUsd: result.totalCostUsd ?? 0,
+    durationMs: result.durationMs ?? 0
+  };
+}
+
+// src/replay.ts
+async function replay(recordedRun, builderFn, overrides = {}) {
+  const ctx = { overrides, recordedRun };
+  const agent = await (builderFn.length > 0 ? builderFn(ctx) : builderFn());
+  try {
+    const result = await agent.run(recordedRun.task);
+    const original = snapshotFromRecordedRun(recordedRun);
+    const replaySnapshot = snapshotFromAgentResult(result, recordedRun);
+    const diff = diffTraces(original, replaySnapshot);
+    return { original, replay: replaySnapshot, diff };
+  } finally {
+    if (typeof agent.dispose === "function") {
+      await agent.dispose();
+    }
+  }
+}
+export {
+  buildToolTable,
+  computeArgsHash,
+  diffTraces,
+  loadRecordedRun,
+  makeReplayController,
+  makeReplayToolLayer,
+  replay,
+  snapshotFromAgentResult,
+  snapshotFromRecordedRun
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/load.ts","../src/tool-table.ts","../src/replay-controller.ts","../src/replay-tool-layer.ts","../src/diff.ts","../src/snapshot.ts","../src/replay.ts"],"sourcesContent":["import { existsSync } from \"node:fs\"\nimport { homedir } from \"node:os\"\nimport { join, isAbsolute } from \"node:path\"\nimport { loadTrace } from \"@reactive-agents/trace\"\nimport type { TraceEvent } from \"@reactive-agents/trace\"\nimport { buildToolTable } from \"./tool-table.js\"\nimport type { RecordedRun } from \"./types.js\"\n\nconst SEARCH_DIRS = [\n    join(homedir(), \".reactive-agents\", \"traces\"),\n    join(process.cwd(), \".reactive-agents\", \"traces\"),\n]\n\ninterface RunStartedShape {\n    readonly kind: \"run-started\"\n    readonly task: string\n    readonly model: string\n    readonly provider: string\n    readonly config: Record<string, unknown>\n}\n\nexport async function loadRecordedRun(idOrPath: string): Promise<RecordedRun> {\n    const path = resolvePath(idOrPath)\n    const trace = await loadTrace(path)\n    const runStarted = trace.events.find(\n        (e): e is TraceEvent & RunStartedShape => e.kind === \"run-started\",\n    )\n    if (!runStarted) {\n        throw new Error(`replay: no run-started event in ${path}`)\n    }\n    const toolTable = buildToolTable(trace.events)\n    return {\n        runId: trace.runId,\n        task: runStarted.task,\n        model: runStarted.model,\n        provider: runStarted.provider,\n        config: runStarted.config,\n        trace,\n        toolTable,\n    }\n}\n\nfunction resolvePath(idOrPath: string): string {\n    if (isAbsolute(idOrPath) && existsSync(idOrPath)) return idOrPath\n    if (existsSync(idOrPath)) return idOrPath\n    for (const dir of SEARCH_DIRS) {\n        const candidate = join(dir, `${idOrPath}.jsonl`)\n        if (existsSync(candidate)) return candidate\n    }\n    throw new Error(`replay: cannot resolve ${idOrPath}; searched ${SEARCH_DIRS.join(\", \")}`)\n}\n","import { createHash } from \"node:crypto\"\nimport type { TraceEvent } from \"@reactive-agents/trace\"\nimport type { RecordedToolResult } from \"./types.js\"\n\nfunction stableStringify(v: unknown): string {\n    if (v === null || typeof v !== \"object\") return JSON.stringify(v) ?? \"null\"\n    if (Array.isArray(v)) return \"[\" + v.map(stableStringify).join(\",\") + \"]\"\n    const obj = v as Record<string, unknown>\n    const keys = Object.keys(obj).sort()\n    return \"{\" + keys.map((k) => JSON.stringify(k) + \":\" + stableStringify(obj[k])).join(\",\") + \"}\"\n}\n\nexport function computeArgsHash(args: unknown): string {\n    return createHash(\"sha256\").update(stableStringify(args)).digest(\"hex\").slice(0, 16)\n}\n\ninterface ToolCallEndShape {\n    readonly kind: \"tool-call-end\"\n    readonly toolName: string\n    readonly args?: unknown\n    readonly result?: unknown\n    readonly resultTruncated?: boolean\n    readonly ok?: boolean\n    readonly error?: string\n    readonly durationMs?: number\n    readonly iter: number\n    readonly seq: number\n}\n\nexport function buildToolTable(events: readonly TraceEvent[]): Map<string, RecordedToolResult[]> {\n    const table = new Map<string, RecordedToolResult[]>()\n    for (const ev of events) {\n        if (ev.kind !== \"tool-call-end\") continue\n        const e = ev as unknown as ToolCallEndShape\n        const argsHash = computeArgsHash(e.args)\n        const key = `${e.toolName}::${argsHash}`\n        const entry: RecordedToolResult = {\n            toolName: e.toolName,\n            argsHash,\n            args: e.args,\n            result: e.result,\n            ok: e.ok ?? true,\n            error: e.error,\n            durationMs: e.durationMs ?? 0,\n            iter: e.iter,\n            seq: e.seq,\n            truncated: e.resultTruncated,\n        }\n        const list = table.get(key) ?? []\n        list.push(entry)\n        table.set(key, list)\n    }\n    return table\n}\n","import { computeArgsHash } from \"./tool-table.js\"\nimport type { RecordedToolResult } from \"./types.js\"\n\nexport type ReplayHit =\n    | { readonly hit: true; readonly result: unknown; readonly ok: boolean; readonly error?: string; readonly truncated?: boolean }\n    | { readonly hit: false }\n\nexport interface ReplayResultProvider {\n    readonly next: (toolName: string, args: unknown) => ReplayHit\n}\n\nexport function makeReplayController(\n    table: ReadonlyMap<string, readonly RecordedToolResult[]>,\n): ReplayResultProvider {\n    const cursors = new Map<string, number>()\n    return {\n        next(toolName, args) {\n            const key = `${toolName}::${computeArgsHash(args)}`\n            const list = table.get(key)\n            if (!list) return { hit: false }\n            const idx = cursors.get(key) ?? 0\n            if (idx >= list.length) return { hit: false }\n            cursors.set(key, idx + 1)\n            const rec = list[idx]\n            return {\n                hit: true,\n                result: rec.result,\n                ok: rec.ok,\n                error: rec.error,\n                truncated: rec.truncated,\n            }\n        },\n    }\n}\n","import { Effect, Layer } from \"effect\"\nimport { ToolService } from \"@reactive-agents/tools\"\nimport type { ReplayResultProvider } from \"./replay-controller.js\"\n\nconst die = (m: string): Effect.Effect<never, never, never> =>\n    Effect.die(new Error(`replay: ToolService.${m} not supported during replay`))\n\nexport function makeReplayToolLayer(\n    provider: ReplayResultProvider,\n    mode: \"strict\" | \"lenient\" = \"strict\",\n): Layer.Layer<ToolService, never, never> {\n    return Layer.succeed(\n        ToolService,\n        ToolService.of({\n            execute: ((input: { toolName: string; arguments?: unknown }) =>\n                Effect.gen(function* () {\n                    const hit = provider.next(input.toolName, input.arguments)\n                    const started = Date.now()\n                    if (!hit.hit) {\n                        if (mode === \"strict\") {\n                            return yield* Effect.die(\n                                new Error(\n                                    `replay: unrecorded tool call ${input.toolName} (strict mode); switch to onMissingToolResult:\"lenient\" or extend the recording`,\n                                ),\n                            )\n                        }\n                        return {\n                            toolName: input.toolName,\n                            success: false,\n                            error: \"replay: no recording for this call (lenient mode)\",\n                            executionTimeMs: Date.now() - started,\n                        }\n                    }\n                    if (!hit.ok) {\n                        return {\n                            toolName: input.toolName,\n                            success: false,\n                            error: hit.error ?? \"replay: recorded error\",\n                            executionTimeMs: Date.now() - started,\n                        }\n                    }\n                    if (hit.truncated && mode === \"strict\") {\n                        return yield* Effect.die(\n                            new Error(\n                                `replay: recorded tool result for ${input.toolName} was truncated; live re-execution may diverge. Switch to lenient mode to proceed.`,\n                            ),\n                        )\n                    }\n                    return {\n                        toolName: input.toolName,\n                        success: true,\n                        result: hit.result,\n                        executionTimeMs: Date.now() - started,\n                    }\n                })) as never,\n            register: (() => die(\"register\")) as never,\n            unregisterTool: (() => Effect.succeed(undefined)) as never,\n            connectMCPServer: (() => die(\"connectMCPServer\")) as never,\n            disconnectMCPServer: (() => die(\"disconnectMCPServer\")) as never,\n            listTools: (() => Effect.succeed([] as never)) as never,\n            getTool: (() => die(\"getTool\")) as never,\n            toFunctionCallingFormat: (() => Effect.succeed([] as never)) as never,\n            listMCPServers: (() => Effect.succeed([] as never)) as never,\n        }),\n    )\n}\n","import type { ReplayDiff, TraceSnapshot, ToolSeqEdit } from \"./types.js\"\n\nexport function diffTraces(a: TraceSnapshot, b: TraceSnapshot): ReplayDiff {\n    const outputEqual = a.output === b.output\n    const toolSequenceDiff = diffToolSequence(a.toolCalls, b.toolCalls)\n    const identical =\n        outputEqual &&\n        a.iterations === b.iterations &&\n        toolSequenceDiff.length === 0 &&\n        a.totalTokens === b.totalTokens\n    return {\n        identical,\n        iterationsDelta: b.iterations - a.iterations,\n        toolSequenceDiff,\n        outputDiff: { original: a.output, replay: b.output, equal: outputEqual },\n        tokensDelta: b.totalTokens - a.totalTokens,\n        costDelta: b.totalCostUsd - a.totalCostUsd,\n        durationDeltaMs: b.durationMs - a.durationMs,\n    }\n}\n\nfunction diffToolSequence(\n    a: readonly { readonly toolName: string; readonly argsHash: string }[],\n    b: readonly { readonly toolName: string; readonly argsHash: string }[],\n): ToolSeqEdit[] {\n    const edits: ToolSeqEdit[] = []\n    const len = Math.max(a.length, b.length)\n    for (let i = 0; i < len; i++) {\n        const x = a[i]\n        const y = b[i]\n        if (x && !y) {\n            edits.push({ kind: \"removed\", toolName: x.toolName, argsHash: x.argsHash, atIndex: i })\n        } else if (!x && y) {\n            edits.push({ kind: \"added\", toolName: y.toolName, argsHash: y.argsHash, atIndex: i })\n        } else if (x && y && (x.toolName !== y.toolName || x.argsHash !== y.argsHash)) {\n            edits.push({ kind: \"removed\", toolName: x.toolName, argsHash: x.argsHash, atIndex: i })\n            edits.push({ kind: \"added\", toolName: y.toolName, argsHash: y.argsHash, atIndex: i })\n        }\n    }\n    return edits\n}\n","import { traceStats } from \"@reactive-agents/trace\"\nimport type { RecordedRun, TraceSnapshot } from \"./types.js\"\n\ninterface RunCompletedShape {\n    readonly kind: \"run-completed\"\n    readonly output?: string\n    readonly totalCostUsd?: number\n}\n\nexport function snapshotFromRecordedRun(run: RecordedRun): TraceSnapshot {\n    const stats = traceStats(run.trace)\n    const completed = run.trace.events.find(\n        (e): e is typeof e & RunCompletedShape => e.kind === \"run-completed\",\n    )\n    const toolCalls: { toolName: string; argsHash: string; ok: boolean }[] = []\n    for (const [, list] of run.toolTable) {\n        for (const r of list) {\n            toolCalls.push({ toolName: r.toolName, argsHash: r.argsHash, ok: r.ok })\n        }\n    }\n    return {\n        runId: run.runId,\n        task: run.task,\n        model: run.model,\n        iterations: stats.iterations,\n        toolCalls,\n        output: completed?.output,\n        totalTokens: stats.totalTokens,\n        totalCostUsd: completed?.totalCostUsd ?? 0,\n        durationMs: stats.durationMs,\n    }\n}\n\nexport interface AgentRunOutcome {\n    readonly output?: string\n    readonly totalTokens?: number\n    readonly totalCostUsd?: number\n    readonly durationMs?: number\n    readonly toolCalls?: readonly { readonly toolName: string; readonly argsHash: string; readonly ok: boolean }[]\n    readonly iterations?: number\n}\n\nexport function snapshotFromAgentResult(\n    result: AgentRunOutcome,\n    recordedRun: RecordedRun,\n): TraceSnapshot {\n    return {\n        runId: `${recordedRun.runId}-replay`,\n        task: recordedRun.task,\n        model: recordedRun.model,\n        iterations: result.iterations ?? 0,\n        toolCalls: result.toolCalls ?? [],\n        output: result.output,\n        totalTokens: result.totalTokens ?? 0,\n        totalCostUsd: result.totalCostUsd ?? 0,\n        durationMs: result.durationMs ?? 0,\n    }\n}\n","import { diffTraces } from \"./diff.js\"\nimport { snapshotFromAgentResult, snapshotFromRecordedRun, type AgentRunOutcome } from \"./snapshot.js\"\nimport type { BuildContext, BuilderFn, RecordedRun, ReplayOverrides, ReplayResult } from \"./types.js\"\n\n/**\n * Re-run a recorded agent run with optional prompt/model overrides.\n *\n * The builder function is responsible for constructing an agent that uses the\n * replay tool layer ({@link makeReplayToolLayer}) so tool results are dispensed\n * from the recording rather than executed live. Builder must return an object\n * exposing `run(task: string): Promise<AgentRunOutcome>` and an optional\n * `dispose()`. The orchestrator invokes `run(recordedRun.task)`, captures the\n * outcome, and produces a structural diff against the original.\n */\nexport async function replay(\n    recordedRun: RecordedRun,\n    builderFn: BuilderFn,\n    overrides: ReplayOverrides = {},\n): Promise<ReplayResult> {\n    const ctx: BuildContext = { overrides, recordedRun }\n    const agent = (await (builderFn.length > 0\n        ? (builderFn as (c: BuildContext) => Promise<unknown>)(ctx)\n        : (builderFn as () => Promise<unknown>)())) as {\n            run: (task: string) => Promise<AgentRunOutcome>\n            dispose?: () => Promise<void>\n        }\n    try {\n        const result = await agent.run(recordedRun.task)\n        const original = snapshotFromRecordedRun(recordedRun)\n        const replaySnapshot = snapshotFromAgentResult(result, recordedRun)\n        const diff = diffTraces(original, replaySnapshot)\n        return { original, replay: replaySnapshot, diff }\n    } finally {\n        if (typeof agent.dispose === \"function\") {\n            await agent.dispose()\n        }\n    }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@reactive-agents/replay",
+  "version": "0.11.0",
+  "description": "Deterministic re-run of recorded reactive-agent traces with prompt/model overrides",
+  "type": "module",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.base.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --reporter=dots",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {
+    "@reactive-agents/core": "0.11.0",
+    "@reactive-agents/trace": "0.11.0",
+    "@reactive-agents/tools": "0.11.0",
+    "effect": "^3.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/replay"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "homepage": "https://docs.reactiveagents.dev/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}