Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

7.8 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import { DEFAULT_TURN_RECORD_LIMITS, TurnRecords, turnAnchorFor } from "./turn-records";
import type { ResponsesItem } from "./types";

const KiB = 1024;
const MiB = 1024 * KiB;

// Deliberately opaque structural store values. These are not invented Responses events,
// upstream request bodies or protocol captures: TurnRecords promises JSON byte storage.
function payload(text: string): ResponsesItem[] {
  return [{ type: "T3-opaque-store-value", text }];
}
const bytes = (items: ResponsesItem[]) => Buffer.byteLength(JSON.stringify(items), "utf8");

describe("T3 turn record storage", () => {
  test("REQ-25 counts exact UTF-8 JSON bytes and returns the stored record", () => {
    const records = new TurnRecords();
    const items = payload("é🙂");

    expect(records.put("session", "anchor", items)).toBe(true);
    expect(records.get("session", "anchor")).toEqual({
      sessionKey: "session",
      anchor: "anchor",
      items,
      bytes: bytes(items),
    });
    expect(records.bytes).toBe(bytes(items));
    expect(records.size).toBe(1);
    expect(records.get("other-session", "anchor")).toBeUndefined();
    records.clear();
    expect(records.bytes).toBe(0);
    expect(records.size).toBe(0);
  });

  test("REQ-25 accepts exactly the per-record byte ceiling and refuses one extra byte", () => {
    const exact = payload("x".repeat(128));
    const limit = bytes(exact);
    const records = new TurnRecords({ limits: { maxRecordBytes: limit, maxBytes: 4 * limit } });

    expect(records.put("session", "exact", exact)).toBe(true);
    expect(records.put("session", "oversize", payload("x".repeat(129)))).toBe(false);
    expect(records.get("session", "oversize")).toBeUndefined();
    expect(records.get("session", "exact")?.items).toEqual(exact);
    expect(records.bytes).toBe(limit);
    expect(records.size).toBe(1);
  });

  test("REQ-25 evicts the least recently rendered record under the byte cap", () => {
    const items = payload("x".repeat(100));
    const records = new TurnRecords({
      limits: { maxBytes: 2 * bytes(items), maxRecordBytes: 1000 },
    });
    records.put("session", "first", items);
    records.put("session", "second", items);
    expect(records.get("session", "first")).toBeDefined();

    records.put("session", "third", items);

    expect(records.get("session", "first")).toBeDefined();
    expect(records.get("session", "second")).toBeUndefined();
    expect(records.get("session", "third")).toBeDefined();
    expect(records.isEvicted("session", "second")).toBe(true);
    expect(records.isEvicted("other-session", "second")).toBe(false);
    expect(records.bytes).toBe(2 * bytes(items));
  });

  test("REQ-25 separately enforces record count and FIFO eviction-id retention", () => {
    const records = new TurnRecords({ limits: { maxRecords: 1, maxEvictedIds: 2 } });
    for (let i = 0; i < 5; i++) expect(records.put("session", `anchor-${i}`, [])).toBe(true);

    expect(records.size).toBe(1);
    expect(records.get("session", "anchor-4")).toBeDefined();
    expect(records.isEvicted("session", "anchor-0")).toBe(false);
    expect(records.isEvicted("session", "anchor-2")).toBe(true);
    expect(records.isEvicted("session", "anchor-3")).toBe(true);
  });

  test("REQ-25 replacement updates byte totals rather than charging both versions", () => {
    const records = new TurnRecords();
    records.put("session", "same", payload("old"));
    const replacement = payload("new and longer é");

    expect(records.put("session", "same", replacement)).toBe(true);

    expect(records.size).toBe(1);
    expect(records.bytes).toBe(bytes(replacement));
    expect(records.get("session", "same")?.items).toEqual(replacement);
  });

  test("REQ-25 keeps bytes bounded for 2000 records with six scaled interstitial outputs each", () => {
    const items = Array.from({ length: 6 }, () => ({
      type: "T3-opaque-store-value",
      text: "x".repeat(KiB),
    }));
    const records = new TurnRecords({ limits: { maxBytes: 32 * KiB, maxRecordBytes: 8 * KiB } });
    for (let i = 0; i < 2000; i++) {
      expect(records.put("session", `anchor-${i}`, items)).toBe(true);
      expect(records.bytes).toBeLessThanOrEqual(32 * KiB);
    }

    expect(records.get("session", "anchor-1999")).toBeDefined();
    expect(records.isEvicted("session", "anchor-0")).toBe(true);
    expect(records.size).toBeLessThan(6);
  }, 20_000);

  test("REQ-25 enforces the real 32 MiB byte cap on six-MiB output records", () => {
    const items = Array.from({ length: 6 }, () => ({
      type: "T3-opaque-store-value",
      text: "x".repeat(MiB),
    }));
    const records = new TurnRecords();
    for (let i = 0; i < 8; i++) {
      expect(records.put("session", `anchor-${i}`, items)).toBe(true);
      expect(records.bytes).toBeLessThanOrEqual(32 * MiB);
    }

    expect(records.isEvicted("session", "anchor-0")).toBe(true);
    expect(records.get("session", "anchor-7")).toBeDefined();
    expect(records.size).toBe(5);
  }, 20_000);

  test("REQ-25 refuses a default over-eight-MiB record without retaining its data", () => {
    const records = new TurnRecords();

    expect(records.put("session", "oversize", payload("x".repeat(8 * MiB)))).toBe(false);

    expect(records.get("session", "oversize")).toBeUndefined();
    expect(records.size).toBe(0);
    expect(records.bytes).toBe(0);
  }, 20_000);

  test("REQ-28 exposes the documented turn-record limits", () => {
    expect(DEFAULT_TURN_RECORD_LIMITS).toEqual({
      maxRecords: 2000,
      maxBytes: 32 * MiB,
      maxRecordBytes: 8 * MiB,
      maxEvictedIds: 20_000,
    });
  });
});

describe("T3 turn anchors", () => {
  // Structural Claude Code message arrays, as specified in architecture.md §5.8.
  const assistant = {
    role: "assistant" as const,
    content: [{ type: "text" as const, text: "same answer" }],
  };
  const previous = {
    role: "user" as const,
    content: [{ type: "text" as const, text: "question" }],
  };

  test("REQ-26 cache_control on the previous message does not change the anchor", () => {
    const marked = {
      ...previous,
      cache_control: { type: "ephemeral" },
      content: previous.content.map((block) => ({
        ...block,
        cache_control: { type: "ephemeral" },
      })),
    };

    expect(turnAnchorFor("session", assistant, marked)).toBe(
      turnAnchorFor("session", assistant, previous)
    );
  });

  test("REQ-26 different previous prompts and different sessions do not share text anchors", () => {
    const anchor = turnAnchorFor("session", assistant, previous);
    expect(
      turnAnchorFor("session", assistant, {
        role: "user",
        content: [{ type: "text", text: "another question" }],
      })
    ).not.toBe(anchor);
    expect(turnAnchorFor("another-session", assistant, previous)).not.toBe(anchor);
    expect(turnAnchorFor("session", assistant, undefined)).not.toBe(anchor);
  });

  test("REQ-26 uses the first tool_use id rather than text or the previous message", () => {
    const message = {
      role: "assistant" as const,
      content: [
        { type: "text" as const, text: "explanation" },
        { type: "tool_use" as const, id: "T3-first-tool", name: "X", input: {} },
        { type: "tool_use" as const, id: "T3-second-tool", name: "Y", input: {} },
      ],
    };

    expect(turnAnchorFor("session", message, previous)).toBe("T3-first-tool");
  });

  test("REQ-26 canonicalizes trimmed text blocks joined by newlines", () => {
    const split = {
      role: "assistant" as const,
      content: [
        { type: "text" as const, text: "  first  " },
        { type: "text" as const, text: " second " },
      ],
    };
    const joined = {
      role: "assistant" as const,
      content: [{ type: "text" as const, text: "first\nsecond" }],
    };

    expect(turnAnchorFor("session", split, previous)).toBe(
      turnAnchorFor("session", joined, previous)
    );
  });
});