Replay

Every model request a thread makes is recorded: the exact bytes that were sent, and the events they were built from. replay() rebuilds each of those requests from the log with the code you are running now and checks that the bytes match. It calls no model and no tool, starts no sandbox and writes nothing, so it is free and safe to run on production data.

Use it as the first step of your evals: before you stub-run saved cases or pay for a judge, prove the new build still sees your threads the way the old one did.

Replay one thread

import { openThread, sqlite } from "@threads/core";

const store = sqlite("./threads-data");
const opened = await openThread(store, threadId);
if (!opened.ok) throw new Error(opened.error.message);

const replayed = await opened.value.replay();
if (!replayed.ok) {
  console.error(replayed.error.code, "at seq", replayed.error.seq);
}

A thread that made no model request replays trivially. A fork replays its parent's history too.

Run it in CI

Keep a corpus of real threads (export them with threads export, or point at a copy of a production store) and replay every one on each pull request. A failure names the thread, the check that failed and the seq of the request, so you can open that request in the timeline.

import { expect, test } from "bun:test";
import { openThread, sqlite } from "@threads/core";
import { corpus } from "./corpus"; // your list of thread ids

const store = sqlite("./fixtures/threads");

for (const id of corpus) {
  test(`thread ${id} still reproduces`, async () => {
    const opened = await openThread(store, id);
    if (!opened.ok) throw new Error(opened.error.message);
    const replayed = await opened.value.replay();
    expect(replayed).toEqual({ ok: true, value: undefined });
  });
}

The TypeScript and Python packages write the same bytes, so a corpus recorded by one replays in the other.

What a failure means

The first failure wins: replay() stops at the earliest request that doesn't reproduce and reports its seq.