repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/autopsy/__tests__/history.test.ts
Rawimport { request } from "node:http";
import { setImmediate } from "node:timers/promises";
import { SessionManager } from "@earendil-works/pi-coding-agent";
import { describe, expect, it } from "vitest";
import {
buildInspectorData,
startInspector,
streamInspectorMetrics,
} from "../inspector.ts";
import type { InspectorQuery } from "../src/types.ts";
function fixture() {
const manager = SessionManager.inMemory();
const ctx = { cwd: "/", sessionManager: manager };
const data = (query: InspectorQuery = {}, signal?: AbortSignal) =>
buildInspectorData(ctx, [], [], undefined, query, signal);
return { manager, ctx, data };
}
describe("lazy session history", () => {
it("retains earliest/latest entries beyond both former corpus limits and anchors pages across appends", async () => {
const { manager, data } = fixture();
const ids: string[] = [];
const large = "old body ".repeat(1024);
for (let index = 0; index < 10_050; index++)
ids.push(
manager.appendMessage({
role: "user",
content: large,
timestamp: index,
}),
);
const latest = await data({ limit: 3 });
expect(latest.entries.map((entry) => entry.id)).toEqual(
ids.slice(-3).reverse(),
);
expect(latest.page).toEqual({
total: 10_050,
start: 0,
nextCursor: ids.at(-3),
previousCursor: null,
});
expect(latest.summary.entries).toBe(10_050);
expect(
latest.entries.every(
(entry) =>
Buffer.byteLength(entry.text) <= 2048 &&
Buffer.byteLength(entry.raw) <= 2048 &&
entry.previewTruncated,
),
).toBe(true);
expect(latest.warnings).toEqual([]);
const oldest = await data({ order: "oldest", limit: 2 });
expect(oldest.entries.map((entry) => entry.id)).toEqual(ids.slice(0, 2));
expect(oldest.summary).toEqual(latest.summary);
manager.appendMessage({
role: "user",
content: "appended",
timestamp: 11_000,
});
const next = await data({ limit: 3, after: latest.page.nextCursor! });
expect(next.entries.map((entry) => entry.id)).toEqual(
ids.slice(-6, -3).reverse(),
);
expect(next.page.start).toBe(4);
expect(next.revision).not.toBe(latest.revision);
const previous = await data({ limit: 3, before: next.entries[0]!.id });
expect(previous.entries.map((entry) => entry.id)).toEqual(
latest.entries.map((entry) => entry.id),
);
const around = await data({ around: ids[0]!, limit: 3 });
expect(around.entries.some((entry) => entry.id === ids[0])).toBe(true);
expect(around.page.nextCursor).toBeNull();
});
it("searches full readable content beyond previews, with exact filters and all-session nullable facets", async () => {
const { manager, data } = fixture();
const first = manager.appendMessage({
role: "user",
content: "x".repeat(40_000) + "Late Needle",
timestamp: 0,
});
const offBranch = manager.appendCustomEntry("side", {
value: "not selected",
});
manager.branch(first);
const last = manager.appendUsage("usage", "p", "m", {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
});
const result = await data({
q: "lATE nEEDLE",
role: "user",
provider: "null",
model: "null",
});
expect(result.entries.map((entry) => entry.id)).toEqual([first]);
expect(result.entries[0]?.text).not.toContain("Needle");
expect(result.page.total).toBe(1);
expect(result.facets.types).toContain("custom");
expect(result.facets.providers).toEqual(
expect.arrayContaining([null, "p"]),
);
expect((await data()).entries.some((entry) => entry.id === offBranch)).toBe(
false,
);
expect(
(await data({ branch: "all" })).entries.some(
(entry) => entry.id === offBranch,
),
).toBe(true);
const usage = await data({
provider: JSON.stringify("p"),
model: JSON.stringify("m"),
});
expect(usage.entries.map((entry) => entry.id)).toEqual([last.id]);
expect(usage.summary).toMatchObject({
tokens: 0,
tokensKnown: 1,
storedCost: 0,
storedCostKnown: 1,
});
expect(
(await data({ provider: "null", role: "usage" })).summary.tokens,
).toBeNull();
const stamp = manager.getEntry(first)!.timestamp;
expect(
(await data({ from: stamp, to: stamp })).entries.some(
(entry) => entry.id === first,
),
).toBe(true);
});
it("searches complete provider metadata independently of readable previews", async () => {
const { manager, data } = fixture();
const id = manager.appendMessage({
role: "assistant",
api: "openai",
provider: "p",
model: "m",
timestamp: 1,
content: [
{
type: "text",
text: "ordinary reply",
textSignature: "x".repeat(40_000) + "opaque-needle",
},
],
usage: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
},
stopReason: "stop",
});
const found = await data({ q: "OPAQUE-NEEDLE" });
expect(found.entries.map((entry) => entry.id)).toEqual([id]);
expect(found.entries[0]?.text).toBe("ordinary reply");
expect(found.entries[0]?.raw).not.toContain("opaque-needle");
});
it("shows requested and concrete identities consistently while pricing responders and preserving stored zero", async () => {
const { manager, ctx } = fixture();
const usage = {
input: 1_000_000,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 1_000_000,
cost: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: 0,
totalFromProvider: true,
},
};
for (const responseModel of ["concrete", "unknown", undefined]) {
manager.appendMessage({
role: "assistant",
api: "openai",
provider: "router",
model: "requested",
...(responseModel ? { responseModel } : {}),
content: [],
timestamp: 1,
stopReason: "stop",
usage,
});
}
const prices = (_provider: string, model: string) =>
model === "unknown"
? undefined
: {
input: model === "concrete" ? 2 : 7,
output: 0,
cacheRead: 0,
cacheWrite: 0,
};
const data = await buildInspectorData(ctx, [], [], prices);
expect(data.facets.models).toEqual([
"concrete ← requested",
"unknown ← requested",
"requested",
]);
expect(
data.entries.map((entry) => entry.usage?.catalogCost?.total),
).toEqual([7, 7, 2]);
expect(
data.entries.every(
(entry) =>
entry.usage?.cost === 0 && entry.usage.costSource === "provider",
),
).toBe(true);
const filtered = await buildInspectorData(ctx, [], [], prices, {
model: JSON.stringify("concrete ← requested"),
});
expect(filtered.entries).toHaveLength(1);
expect(filtered.summary).toMatchObject({ storedCost: 0, catalogCost: 2 });
expect(filtered.entries[0]?.raw).toContain('"responseModel"');
const unknown = await buildInspectorData(ctx, [], [], () => undefined);
expect(
unknown.entries.every((entry) => entry.usage?.catalogCost === null),
).toBe(true);
});
it("sums cheap accounting over the entire scope independently of page measurement", async () => {
const { manager, ctx } = fixture();
for (const count of [0, 3]) {
const source = manager.appendUsage("accounting", "p", "m", {
input: count,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: count,
cost: {
input: count,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: count,
},
});
Object.assign(source, { durationMs: count });
}
manager.appendCustomEntry("unknown", {});
let lookups = 0;
const prices = () => {
lookups++;
return { input: 1_000_000, output: 0, cacheRead: 0, cacheWrite: 0 };
};
const first = await buildInspectorData(ctx, [], [], prices, { limit: 1 });
expect(lookups).toBe(1);
const next = await buildInspectorData(ctx, [], [], prices, {
limit: 1,
after: first.page.nextCursor!,
});
expect(first.summary).toMatchObject({
entries: 3,
usageEntries: 2,
tokens: 3,
tokensKnown: 2,
storedCost: 3,
storedCostKnown: 2,
catalogCost: 3,
catalogCostKnown: 2,
durationMs: 3,
durationKnown: 2,
});
expect(next.summary).toEqual(first.summary);
expect(lookups).toBe(2);
});
it("rejects invalid queries, stale/nonmatching anchors and unsupported search, and cancels yielding scans", async () => {
const { manager, data } = fixture();
manager.appendMessage({ role: "user", content: "content", timestamp: 1 });
for (const query of [
{ limit: 0 },
{ limit: 101 },
{ limit: 1.5 },
{ q: "x".repeat(257) },
{ provider: "p" },
{ model: "42" },
{ from: "garbage" },
{ from: "2026-02-30" },
{ from: "2026-01-02", to: "2026-01-01" },
{ after: "x", before: "y" },
])
await expect(data(query)).rejects.toMatchObject({ status: 400 });
await expect(data({ after: "missing" })).rejects.toMatchObject({
status: 409,
});
const entry = manager.getEntries()[0]!;
await expect(
data({ after: entry.id, role: "assistant" }),
).rejects.toMatchObject({ status: 409 });
manager.appendCustomEntry("ephemeral", { unsupported: new Date() });
await expect(data({ q: "unfindable" })).rejects.toMatchObject({
status: 422,
});
const controller = new AbortController();
const pending = data({}, controller.signal);
controller.abort();
await expect(pending).rejects.toMatchObject({ name: "AbortError" });
});
it("matches across detail chunks and cancels an active one-character full-content search", async () => {
const { manager, data } = fixture();
const id = manager.appendMessage({
role: "user",
content: "x".repeat(8191) + "boundary",
timestamp: 1,
});
expect(
(await data({ q: "boundary" })).entries.map((entry) => entry.id),
).toEqual([id]);
const entry = manager.getEntry(id) as { message: { content: string } };
entry.message.content = "x".repeat(32 * 1024 * 1024);
const controller = new AbortController();
const pending = data({ q: "z" }, controller.signal);
await setImmediate();
controller.abort();
await expect(pending).rejects.toMatchObject({ name: "AbortError" });
});
it("propagates slow-reader disconnect cancellation through the metrics pipeline", async () => {
const { manager, data } = fixture();
manager.appendMessage({ role: "user", content: "sample", timestamp: 1 });
const sample = (await data()).entries[0]!;
let produced = 0;
let cleaned = false;
let signal: AbortSignal | undefined;
const inspector = await startInspector(
(query, signal) => data(query, signal),
undefined,
async function* (_query, cancellation) {
signal = cancellation;
try {
for (; produced < 10_000; produced++) {
cancellation.throwIfAborted();
yield {
type: "entry" as const,
entry: { ...sample, toolNames: ["x".repeat(8192)] },
};
}
yield { type: "end" as const };
} finally {
cleaned = true;
}
},
);
try {
await new Promise<void>((resolve, reject) => {
const req = request(`${inspector.url}metrics`, (res) => {
res.once("data", () => {
res.pause();
setTimeout(() => {
req.destroy();
resolve();
}, 50);
});
});
req.on("error", (error) => {
if ((error as NodeJS.ErrnoException).code !== "ECONNRESET")
reject(error);
});
req.end();
});
for (let index = 0; index < 100 && !cleaned; index++)
await new Promise((resolve) => setTimeout(resolve, 5));
expect(signal?.aborted).toBe(true);
expect(cleaned).toBe(true);
expect(produced).toBeLessThan(10_000);
} finally {
await inspector.close();
}
});
it("streams scope metrics independently of pages and never eagerly captures prompts", async () => {
const { manager, ctx, data } = fixture();
for (let index = 0; index < 65; index++)
manager.appendMessage({
role: "user",
content: [
{ type: "text", text: "hello" },
{ type: "image", mimeType: "image/png", data: "invalid" },
],
timestamp: index,
});
const events = [];
for await (const event of streamInspectorMetrics(ctx, undefined, {
limit: 1,
}))
events.push(event);
expect(events).toHaveLength(66);
expect(events.at(-1)).toEqual({ type: "end" });
expect(events[0]).toMatchObject({
type: "entry",
entry: { text: "", raw: "", images: [], metrics: { imageCount: 1 } },
});
let captures = 0;
let cancelled: AbortSignal | undefined;
const inspector = await startInspector(
async (query, signal) => {
if (query.q === "wait") {
cancelled = signal;
while (!signal.aborted) await setImmediate();
signal.throwIfAborted();
}
return data(query, signal);
},
(id) => manager.getEntry(id),
(query, signal) => streamInspectorMetrics(ctx, undefined, query, signal),
() => {
captures++;
return [
{
id: 1,
prompt: "captured",
grouped: "grouped",
timestamp: "now",
entryId: null,
},
];
},
);
try {
expect(
(await (await fetch(`${inspector.url}data?limit=1`)).json()).entries,
).toHaveLength(1);
expect(captures).toBe(0);
expect(
(await (await fetch(`${inspector.url}prompts`)).json())[0].prompt,
).toBe("captured");
expect(captures).toBe(1);
const metrics = await fetch(`${inspector.url}metrics?limit=1`);
expect(metrics.headers.get("content-type")).toContain(
"application/x-ndjson",
);
expect((await metrics.text()).trim().split("\n")).toHaveLength(66);
expect((await fetch(`${inspector.url}data?limit=101`)).status).toBe(400);
expect((await fetch(`${inspector.url}data?after=missing`)).status).toBe(
409,
);
expect(
(await fetch(`${inspector.url}metrics?after=missing`)).status,
).toBe(409);
const req = request(`${inspector.url}data?q=wait`);
req.on("error", () => {});
req.end();
for (let index = 0; index < 100 && !cancelled; index++)
await new Promise((resolve) => setTimeout(resolve, 5));
expect(cancelled).toBeDefined();
req.destroy();
for (let index = 0; index < 100 && !cancelled?.aborted; index++)
await new Promise((resolve) => setTimeout(resolve, 5));
expect(cancelled?.aborted).toBe(true);
} finally {
await inspector.close();
}
});
});