@modusensus/dsh-mneme 0.8.4 → 0.8.6

package/test/llm-audit.test.js

@@ -7,6 +7,7 @@ import { createDreamScheduler } from "../src/dream.js";
 import { createSummarizer } from "../src/summarize.js";
 import { createApi } from "../src/api.js";
 import { createSettings } from "../src/settings.js";
+import { createEntityStreamAdapter } from "../src/index.js";
 import { mockCtx } from "./helpers/dream-mock.js";
 
 // Bug8: LLM audit trail. Every background LLM call (autoDream consolidation +
@@ -195,6 +196,159 @@ test("autoSummarize writes an llm_audit_logs row (trigger_source autoSummarize)"
   store.close();
 });
 
+// --- token 记账：用量嵌在 chunk.usage 下 -------------------------------------
+// 真实 dsh-llm 协议的用量形状是 { type:"usage", usage: TokenUsage }（TokenUsage
+// = { inputTokens, outputTokens, … }），chunk 顶层没有 token 字段。把整个 chunk
+// 当用量对象读取会让 input/output 恒为 undefined，审计行落 0：本机实测 7 天 49
+// 次 success 调用 total_tokens 全 0，面板「LLM 消耗」永远显示 0。下面三例锁住
+// 真实形状，并保留用量平铺在顶层的兼容分支。
+
+/** 在 base ctx 的流末尾（finish 之前）插入一个 usage chunk。 */
+function withUsageChunk(base, usageChunk) {
+  return {
+    ...base,
+    llm: {
+      async *stream(options) {
+        for await (const chunk of base.llm.stream(options)) {
+          if (chunk.type === "finish") yield usageChunk;
+          yield chunk;
+        }
+      }
+    }
+  };
+}
+
+/** consolidation 决策：全部 keep，保证 run 成功且无需解析语义。 */
+const keepAllDecisions = (listText) => {
+  const ids = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=\w+\s*\|\s*importance=\d+/g)].map((m) => m[1]);
+  return JSON.stringify(ids.map((id) => ({ action: "keep", ids: [id] })));
+};
+
+test("autoDream records tokens from the nested usage chunk (chunk.usage)", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  const ctx = withUsageChunk(
+    mockCtx({ onConsolidation: keepAllDecisions }),
+    { type: "usage", usage: { inputTokens: 1200, outputTokens: 300, totalTokens: 1500 } }
+  );
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, true);
+
+  const rows = service.listLlmAudits();
+  const consolidate = rows.find((r) => r.operation_type === "dream_consolidate");
+  assert.equal(consolidate.input_tokens, 1200, "input tokens come from chunk.usage");
+  assert.equal(consolidate.output_tokens, 300, "output tokens come from chunk.usage");
+  assert.equal(consolidate.total_tokens, 1500);
+  const summary = rows.find((r) => r.operation_type === "dream_summarize");
+  assert.equal(summary.total_tokens, 1500, "the dream summary call is accounted too");
+  store.close();
+});
+
+test("autoSummarize records tokens from the nested usage chunk (chunk.usage)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const ctx = withUsageChunk({
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    logger: { warn: () => {} },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: JSON.stringify([
+          { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 }
+        ]) };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  }, { type: "usage", usage: { inputTokens: 800, outputTokens: 200, totalTokens: 1000 } });
+  const config = {
+    autoSummarize: true,
+    summarizeProvider: "deepseek",
+    summarizeModel: "deepseek-chat",
+    llmAudit: { enabled: true }
+  };
+  createSummarizer(ctx, service, config);
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: {} }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "帮我选型" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  const rows = service.listLlmAudits();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].input_tokens, 800, "input tokens come from chunk.usage");
+  assert.equal(rows[0].output_tokens, 200, "output tokens come from chunk.usage");
+  assert.equal(rows[0].total_tokens, 1000);
+  store.close();
+});
+
+test("flat top-level usage shape still records tokens", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  const ctx = withUsageChunk(
+    mockCtx({ onConsolidation: keepAllDecisions }),
+    { type: "usage", inputTokens: 40, outputTokens: 10 }
+  );
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  await dream.runDream(ctx, service, config);
+  const consolidate = service.listLlmAudits().find((r) => r.operation_type === "dream_consolidate");
+  assert.equal(consolidate.total_tokens, 50, "flat shape is still readable");
+  store.close();
+});
+
+// --- token 记账的边界语义 ----------------------------------------------------
+// 上面三例锁的是「有 usage chunk 且形状正确」。契约的另一半是「没有用量时的
+// 行为」：未知不等于错误，记 0（不崩，也不凭空编数），同时保留协议演进时
+// 用量平铺在 chunk 根的读法。
+
+test("no usage chunk at all still writes 0 tokens and never crashes", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  // 桩的原始形状就是不发 usage chunk：适配器未上报用量的情形走这条路径。
+  const ctx = mockCtx({ onConsolidation: keepAllDecisions });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, true, "缺少用量不该让巩固本身失败");
+  const rows = service.listLlmAudits();
+  assert.ok(rows.length >= 1, "巩固那行仍然要写下");
+  for (const row of rows) {
+    assert.equal(row.input_tokens, 0, "未知用量记 0，不编数");
+    assert.equal(row.output_tokens, 0);
+    assert.equal(row.total_tokens, 0);
+  }
+  store.close();
+});
+
+test("root-level flattened usage fields still record tokens (protocol fallback)", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  // 用量数字直接挂在 chunk 根、没有嵌套 usage 对象，命中的是 `chunk.usage ?? chunk`
+  // 的兜底分支；这里用 snake_case，锁住读取端的别名链。
+  const ctx = withUsageChunk(
+    mockCtx({ onConsolidation: keepAllDecisions }),
+    { type: "usage", input_tokens: 9, output_tokens: 3 }
+  );
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, true);
+  const rows = service.listLlmAudits();
+  assert.ok(rows.length >= 1);
+  for (const row of rows) {
+    assert.equal(row.input_tokens, 9, "根级平铺字段仍可读");
+    assert.equal(row.output_tokens, 3);
+    assert.equal(row.total_tokens, 12);
+  }
+  store.close();
+});
+
 // --- API surface ------------------------------------------------------------
 
 class FakeRes extends EventEmitter {
@@ -307,3 +461,96 @@ test("GET /api/dsh-mneme/semantic/llm-audit/stats aggregates by source and statu
   assert.equal(errStatus.c, 1);
   store.close();
 });
+
+// ------------------------------------------- entity extraction (issue #250)
+// 实体抽取是「每次写入记忆都会跑」的后台 LLM 链路，但 createEntityStreamAdapter
+// 只拿到 llm 句柄、没有 service，所以从来没有写审计的能力——面板因此回答不了
+// 「关掉实体抽取能省多少」。下面两条用例锁定 usage chunk 汇总落库，以及审计写失败
+// 只 warn 不反噬（CONTRIBUTING 的 fail-safe 硬约定）。
+
+test("entity extraction writes an llm_audit row with the streamed usage tokens", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 700, outputTokens: 180, totalTokens: 880 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "the extracted text still reaches the extractor");
+
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.ok(row, "entity_extract audit row present");
+  assert.equal(row.trigger_source, "entityExtract");
+  assert.equal(row.operation_type, "entity_extract");
+  assert.equal(row.status, "success");
+  assert.equal(row.model_id, "mock:mock-model", "the resolved route is recorded");
+  assert.equal(row.input_tokens, 700, "input tokens come from chunk.usage");
+  assert.equal(row.output_tokens, 180, "output tokens come from chunk.usage");
+  assert.equal(row.total_tokens, 880);
+  store.close();
+});
+
+test("entity extraction audit write failure only warns and never sinks the extraction", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  // 审计表写不进去（只读库 / 磁盘满）绝不能把抽取本身拖失败—— fail-safe 是硬约定。
+  service.saveLlmAudit = () => { throw new Error("attempt to write a readonly database"); };
+  const warnings = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: (m) => warnings.push(String(m)) },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "extraction text survives an audit write failure");
+  assert.ok(warnings.some((w) => w.includes("llm audit write failed")),
+    "the audit failure is logged rather than swallowed silently");
+  store.close();
+});
+
+test("entity extraction writes no audit row when llmAudit.enabled === false", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service,
+    // 单闸门：与 dream / sleep / summarize 同一个 llmAudit.enabled，不新增第二道。
+    config: { llmAudit: { enabled: false } }
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "turning the audit off must not break extraction");
+  assert.equal(service.listLlmAudits().length, 0, "no audit rows when disabled");
+  store.close();
+});

package/test/local-embedder.test.js

@@ -79,7 +79,7 @@ test("LocalEmbedder init threads resilientModelDownload and logger to engineFact
   assert.equal(seen.resilientModelDownload, false, "直连构造不显式给 true = 保持现状");
 });
 
-test("LocalEmbedder embed returns [n, dim] with mean pooling and chunking", async () => {
+test("LocalEmbedder embed returns [n, dim] with the model's pooling and chunking", async () => {
   const calls = [];
   const e = new LocalEmbedder({
     model: "Xenova/bge-small-zh-v1.5",
@@ -95,6 +95,18 @@ test("LocalEmbedder embed returns [n, dim] with mean pooling and chunking", asyn
   }
   // 3 texts at batchSize 2 -> two extractor calls.
   assert.deepEqual(calls.map((c) => c.count), [2, 1]);
+  // BGE 系按 CLS 训练（模型自带 1_Pooling/config.json: pooling_mode_cls_token=true）
+  assert.deepEqual(calls[0].opts, { pooling: "cls", normalize: true });
+});
+
+test("LocalEmbedder keeps mean pooling for models outside the CLS families", async () => {
+  const calls = [];
+  const e = new LocalEmbedder({
+    model: "sentence-transformers/all-MiniLM-L6-v2",
+    engineFactory: async () => makeFakeExtractor(384, calls)
+  });
+  await e.init();
+  await e.embed(["x"]);
   assert.deepEqual(calls[0].opts, { pooling: "mean", normalize: true });
 });
 
@@ -105,14 +117,45 @@ test("LocalEmbedder embedSingle returns a single vector", async () => {
   assert.equal(v.length, 384);
 });
 
+test("LocalEmbedder resolves pooling by model family, explicit value wins", async () => {
+  const cases = [
+    [{ model: "Xenova/bge-small-zh-v1.5" }, "cls", "BGE 默认 cls"],
+    [{ model: "BAAI/bge-m3" }, "cls", "BGE 大小写无关"],
+    [{ model: "sentence-transformers/all-MiniLM-L6-v2" }, "mean", "非 BGE 族保持 mean"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }, "mean", "显式覆盖 auto"],
+    [{ model: "sentence-transformers/all-MiniLM-L6-v2", pooling: "cls" }, "cls", "显式覆盖非 BGE"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: "AUTO" }, "cls", "大小写/空白容错"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: " bogus " }, "cls", "未知值退回 auto"]
+  ];
+  for (const [opts, expected, why] of cases) {
+    const calls = [];
+    const e = new LocalEmbedder({ ...opts, engineFactory: async () => makeFakeExtractor(512, calls) });
+    assert.equal(e.pooling, expected, why);
+    await e.init();
+    await e.embed(["x"]);
+    assert.equal(calls[0].opts.pooling, expected, `${why}: 必须真的传进 extractor`);
+  }
+});
+
 test("LocalEmbedder dimension and modelHash are stable", () => {
   const a = new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5" });
   const b = new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5" });
   assert.equal(a.dimension, 512);
   assert.equal(a.modelHash, b.modelHash);
-  assert.match(a.modelHash, /^Xenova\/bge-small-zh-v1\.5#[0-9a-f]+$/);
+  // BGE 解析为 cls，且池化进指纹（否则旧索引不会被判失配、不会重建）
+  assert.match(a.modelHash, /^Xenova\/bge-small-zh-v1\.5@cls#[0-9a-f]+$/);
   // Different model -> different hash.
   assert.notEqual(a.modelHash, new LocalEmbedder({ model: "other/model" }).modelHash);
+  // 显式 mean 保持历史指纹形状，不给未受影响的索引制造无谓重建
+  assert.match(
+    new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }).modelHash,
+    /^Xenova\/bge-small-zh-v1\.5#[0-9a-f]+$/
+  );
+  // 两种池化是不同向量空间，绝不能共用一个指纹
+  assert.notEqual(
+    a.modelHash,
+    new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }).modelHash
+  );
 });
 
 test("LocalEmbedder throws before init and after dispose", async () => {