From 0ee14fa8a7187d3a7210540d0be52c584017c89c Mon Sep 17 00:00:00 2001 From: zack-dev-cm <112114097+zack-dev-cm@users.noreply.github.com> Date: Fri, 13 Nov 2026 06:28:41 +0400 Subject: [PATCH] perf(api): count consolidation summaries without loading records Signed-off-by: zack-dev-cm <112114097+zack-dev-cm@users.noreply.github.com> --- src/triggers/api.ts | 13 +++- test/consolidation-summary-counts.test.ts | 91 +++++++++++++++++++++++ 2 files changed, 102 insertions(+), 2 deletions(-) create mode 100644 test/consolidation-summary-counts.test.ts diff --git a/src/triggers/api.ts b/src/triggers/api.ts index 46e318b89d..701d9d49f8 100644 --- a/src/triggers/api.ts +++ b/src/triggers/api.ts @@ -480,17 +480,26 @@ export function createStatusReporter(sdk: IIIClient, kv: StateKV, deps: StatusRe }; } +async function countConsolidationSummaries(kv: StateKV): Promise { + if (typeof kv.listKeys === "function") { + try { + return (await kv.listKeys(KV.summaries)).length; + } catch {} + } + return (await kv.list(KV.summaries).catch(() => [])).length; +} + export function createConsolidationStatusReader(kv: StateKV) { const counts = singleFlight(async () => { const [summaries, memories, semantic, procedural, relations] = await Promise.all([ - kv.list(KV.summaries).catch(() => []), + countConsolidationSummaries(kv), collectAll(kv, KV.memories).catch(() => []), collectAll(kv, KV.semantic).catch(() => []), collectAll(kv, KV.procedural).catch(() => []), collectAll(kv, KV.relations).catch(() => []), ]); return { - summaries: summaries.length, + summaries, recurringPatterns: memories.filter( (m) => m.isLatest && diff --git a/test/consolidation-summary-counts.test.ts b/test/consolidation-summary-counts.test.ts new file mode 100644 index 0000000000..e745acefcd --- /dev/null +++ b/test/consolidation-summary-counts.test.ts @@ -0,0 +1,91 @@ +import { describe, expect, it, vi } from "vitest"; +import { createConsolidationStatusReader } from "../src/triggers/api.js"; +import { StateKV, type StateBackend } from "../src/state/kv.js"; +import { KV } from "../src/state/schema.js"; + +type Call = { function_id: string; payload: { scope: string; key?: string } }; +type Row = Record | null; + +function fixture(backend: StateBackend, options: { rejectSummaryKeys?: boolean; rejectSummaryValues?: boolean } = {}) { + const data = new Map>([ + [KV.summaries, new Map([["summary-a", { sessionId: "a", content: "a".repeat(32768) }], ["summary-b", { sessionId: "b", content: "b".repeat(32768) }], ["summary-null", null]])], + [KV.semantic, new Map([["semantic-a", { id: "a" }], ["semantic-b", { id: "b" }], ["semantic-null", null]])], + [KV.procedural, new Map([["procedure-a", { id: "a" }], ["procedure-null", null]])], + [KV.relations, new Map([["relation-a", { id: "a" }], ["relation-b", { id: "b" }], ["relation-c", { id: "c" }], ["relation-null", null]])], + [KV.memories, new Map([ + ["recurring-a", { id: "recurring-a", isLatest: true, type: "pattern", recurrence: 2 }], + ["recurring-b", { id: "recurring-b", isLatest: true, type: "pattern", sessionIds: ["s1", "s2"] }], + ["repeated-session", { id: "repeated-session", isLatest: true, type: "pattern", sessionIds: ["s1", "s1"] }], + ["stale", { id: "stale", isLatest: false, type: "pattern", recurrence: 5 }], + ["not-pattern", { id: "not-pattern", isLatest: true, type: "fact", recurrence: 5 }], + ["not-latest", { id: "not-latest", type: "pattern", recurrence: 5 }], + ["null", null], + ])], + ]); + const calls: Call[] = []; + const sdk = { + trigger: vi.fn(async (call: Call) => { + calls.push(structuredClone(call)); + const rows = data.get(call.payload.scope) ?? new Map(); + if (call.function_id === "state::list_keys") { + if (call.payload.scope === KV.summaries && options.rejectSummaryKeys) throw new Error("state::list_keys unavailable"); + const keys = [...rows.keys()]; + return backend === "redis" ? { keys } : keys; + } + if (call.function_id === "state::list") { + if (call.payload.scope === KV.summaries && options.rejectSummaryValues) throw new Error("summary values unavailable"); + return structuredClone([...rows.values()]); + } + if (call.function_id === "state::get") return structuredClone(rows.get(call.payload.key ?? "") ?? null); + throw new Error(`Unexpected fixture invocation: ${call.function_id}`); + }), + }; + return { kv: new StateKV(sdk as never, { backend }), data, calls }; +} + +function expectCounts(status: Awaited>>, summaries: number) { + expect(status.summaries).toBe(summaries); + expect(status.recurringPatterns).toBe(2); + expect(status.tiers.find((tier) => tier.id === "semantic")?.count).toBe(2); + expect(status.tiers.find((tier) => tier.id === "procedural")?.count).toBe(1); + expect(status.tiers.find((tier) => tier.id === "relations")?.count).toBe(3); +} + +describe("consolidation summary counts", () => { + it.each(["file", "redis"] as const)("counts summaries without transferring their record values on %s", async (backend) => { + const { kv, calls } = fixture(backend); + const status = await createConsolidationStatusReader(kv)({ lastRun: null }); + expectCounts(status, 3); + expect(calls.filter((call) => call.payload.scope === KV.summaries && ["state::list", "state::get"].includes(call.function_id))).toEqual([]); + }); + + it.each(["file", "redis"] as const)("preserves nullable rows, real pattern filtering and count reuse on %s", async (backend) => { + const { kv, data, calls } = fixture(backend); + const read = createConsolidationStatusReader(kv); + expectCounts(await read({ lastRun: null }), 3); + const before = calls.length; + data.get(KV.summaries)!.set("later", { sessionId: "later" }); + expectCounts(await read({ lastRun: null }), 3); + expect(calls).toHaveLength(before); + expect(calls.some((call) => call.payload.scope === KV.memories && call.function_id === "state::get")).toBe(true); + }); + + it.each(["file", "redis"] as const)("keeps the working value-list fallback when summary key listing rejects on %s", async (backend) => { + const { kv, calls } = fixture(backend, { rejectSummaryKeys: true }); + expectCounts(await createConsolidationStatusReader(kv)({ lastRun: null }), 3); + expect(calls.filter((call) => call.payload.scope === KV.summaries && call.function_id === "state::list")).toHaveLength(1); + }); + + it("supports list-only adapters without a key-list method", async () => { + const { data } = fixture("file"); + const kv = { + list: async (scope: string) => [...(data.get(scope)?.values() ?? [])].filter((row) => row !== null), + }; + expectCounts(await createConsolidationStatusReader(kv as never)({ lastRun: null }), 2); + }); + + it("retains the empty best-effort summary count when both read paths fail", async () => { + const { kv } = fixture("file", { rejectSummaryKeys: true, rejectSummaryValues: true }); + expectCounts(await createConsolidationStatusReader(kv)({ lastRun: null }), 0); + }); +});