import { 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((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(); } }); });