#2790 · Claude resume transcript integrity

import { randomUUID } from "node:crypto";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { createServer } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { query, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
import { afterEach, expect, it } from "vitest";

const temporaryPaths: string[] = [];

afterEach(async () => {
  await Promise.all(
    temporaryPaths.splice(0).map((path) => rm(path, { force: true, recursive: true })),
  );
});

function projectDirectoryName(path: string): string {
  return path.replace(/[^a-zA-Z0-9]/g, "-");
}

it("keeps a trailing tool result when a Claude session resumes", async () => {
  const root = await mkdtemp(join(tmpdir(), "bb-claude-resume-repro-"));
  temporaryPaths.push(root);
  const workspace = join(root, "workspace");
  const config = join(root, "config");
  const sessionId = randomUUID();
  const promptId = randomUUID();
  const toolUseMessageId = randomUUID();
  const toolResultMessageId = randomUUID();
  const toolUseId = "toolu_repro";
  const timestamp = "2026-09-01T00:00:00.000Z";
  const projectDirectory = join(
    config,
    "projects",
    projectDirectoryName(workspace),
  );
  await mkdir(projectDirectory, { recursive: true });
  await mkdir(workspace, { recursive: true });
  const transcript = [
    {
      type: "user",
      uuid: promptId,
      parentUuid: null,
      sessionId,
      timestamp,
      cwd: workspace,
      message: { role: "user", content: "run the tool" },
    },
    {
      type: "assistant",
      uuid: toolUseMessageId,
      parentUuid: promptId,
      sessionId,
      timestamp,
      cwd: workspace,
      message: {
        role: "assistant",
        content: [
          {
            type: "tool_use",
            id: toolUseId,
            name: "Bash",
            input: { command: "true" },
          },
        ],
      },
    },
    {
      type: "user",
      uuid: toolResultMessageId,
      parentUuid: toolUseMessageId,
      sessionId,
      timestamp,
      cwd: workspace,
      message: {
        role: "user",
        content: [
          {
            type: "tool_result",
            tool_use_id: toolUseId,
            content: "tool output that must survive",
            is_error: false,
          },
        ],
      },
      toolUseResult: {
        stdout: "tool output that must survive",
        stderr: "",
        interrupted: false,
      },
    },
  ];
  await writeFile(
    join(projectDirectory, `${sessionId}.jsonl`),
    `${transcript.map((entry) => JSON.stringify(entry)).join("\n")}\n`,
  );

  let requestBody: string | undefined;
  const requestUrls: string[] = [];
  const server = createServer((request, response) => {
    requestUrls.push(request.url ?? "");
    const chunks: Buffer[] = [];
    request.on("data", (chunk: Buffer) => chunks.push(chunk));
    request.on("end", () => {
      const body = Buffer.concat(chunks).toString("utf8");
      if (request.url?.includes("count_tokens")) {
        response.writeHead(200, { "content-type": "application/json" });
        response.end(JSON.stringify({ input_tokens: 1 }));
        return;
      }
      if (request.url?.includes("/v1/messages")) {
        requestBody = body;
        response.writeHead(200, { "content-type": "application/json" });
        response.end(
          JSON.stringify({
            id: "msg_repro",
            type: "message",
            role: "assistant",
            model: "claude-sonnet-4-20250514",
            content: [{ type: "text", text: "ok" }],
            stop_reason: "end_turn",
            stop_sequence: null,
            usage: {
              input_tokens: 1,
              output_tokens: 1,
              cache_creation_input_tokens: 0,
              cache_read_input_tokens: 0,
            },
          }),
        );
        return;
      }
      response.writeHead(404).end();
    });
  });
  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
  const address = server.address();
  if (address === null || typeof address === "string") {
    throw new Error("Expected a local API port");
  }

  const abortController = new AbortController();
  let stderr = "";
  const prompt = {
    async *[Symbol.asyncIterator]() {
      yield {
        type: "user" as const,
        message: { role: "user" as const, content: "continue" },
        parent_tool_use_id: null,
        session_id: sessionId,
        uuid: randomUUID(),
      };
    },
  };
  const sdkQuery = query({
    prompt,
    options: {
      abortController,
      cwd: workspace,
      systemPrompt: "",
      env: {
        ...process.env,
        ANTHROPIC_API_KEY: "test-key",
        ANTHROPIC_BASE_URL: `http://127.0.0.1:${address.port}`,
        CLAUDE_CONFIG_DIR: config,
        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
      },
      includePartialMessages: true,
      model: "claude-sonnet-4-20250514",
      persistSession: true,
      resume: sessionId,
      settingSources: [],
      stderr: (data) => {
        stderr += data;
      },
    },
  });
  const receivedMessages: SDKMessage[] = [];
  const run = async (): Promise<void> => {
    for await (const message of sdkQuery) {
      receivedMessages.push(message);
      if (message.type === "result") {
        return;
      }
    }
    throw new Error("Claude query ended without a result");
  };

  try {
    await Promise.race([
      run(),
      new Promise<void>((_, reject) =>
        setTimeout(
          () =>
            reject(
              new Error(
                `Claude resume timed out; requests=${JSON.stringify(requestUrls)}; stderr=${stderr.slice(0, 2_000)}`,
              ),
            ),
          30_000,
        ),
      ),
    ]);
  } finally {
    abortController.abort();
    sdkQuery.close();
    server.closeAllConnections();
    await new Promise<void>((resolve) => server.close(() => resolve()));
  }

  expect(requestBody).toContain("tool output that must survive");
  expect(receivedMessages.some((message) => message.type === "result")).toBe(
    true,
  );
}, 60_000);