@modusensus/dsh-mneme 0.7.24 → 0.7.26

package/test/reasoning-effort.test.js

@@ -413,3 +413,166 @@ test("sleep passes the stream failure accessor so a stream-level effort rejectio
   assert.equal("reasoningEffort" in captured[1], false, "conflict retry omits the rejected effort field");
   store.close();
 });
+
+// ------------------------------------------------------------------ defaultEffort trap
+// DSH Desktop's volcano-engine adapter declares reasoning.defaultEffort="low"
+// for a model that rejects "low", so omitting the field is NOT a safe retry —
+// the harness substitutes the poison default and fails again. resolveDreamEffort
+// queries resolveModelInfo up front and forwards a value that is actually in
+// the model's declared efforts, so the first attempt already carries a
+// supported effort and never trips UNSUPPORTED_REASONING_EFFORT.
+
+test("defaultEffort trap: configured 'low' remapped to the first supported effort when default is poison", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const infoCalls = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
+    ])
+  });
+  // The adapter's capability report: defaultEffort "low" is NOT in efforts
+  // (the model rejects it) — exactly the volcano-engine/deepseek-v4-flash trap.
+  ctx.llm.resolveModelInfo = async (provider, model) => {
+    infoCalls.push([provider, model]);
+    return {
+      provider,
+      model,
+      reasoning: {
+        efforts: [{ id: "medium" }, { id: "high" }],
+        defaultEffort: "low"
+      }
+    };
+  };
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "low" });
+  assert.equal(result.ok, true, "run succeeds without ever tripping the poison default");
+  assert.ok(result.applied > 0, "consolidation lands changes");
+  assert.deepEqual(infoCalls[0], ["mock", "mock-model"], "capability queried for the exact dream route");
+  assert.equal(captured[0].reasoningEffort, "medium", "poison 'low' remapped to the first supported effort");
+  assert.equal(captured[1].reasoningEffort, "medium", "summary pass uses the same resolved effort");
+  store.close();
+});
+
+test("defaultEffort trap: model with no reasoning capability omits the field entirely", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
+    ])
+  });
+  // Non-thinking model (e.g. deepseek-v4-flash): adapter reports no reasoning
+  // capability, so ANY explicit effort would be rejected — the helper must
+  // drop it, which is the harness's safe "no reasoning" path.
+  ctx.llm.resolveModelInfo = async () => ({ provider: "mock", model: "mock-model", reasoning: undefined });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "high" });
+  assert.equal(result.ok, true);
+  for (const options of captured) {
+    assert.equal("reasoningEffort" in options, false, "no reasoning capability -> effort omitted, never rejected");
+  }
+  store.close();
+});
+
+test("defaultEffort trap: configured effort supported is forwarded verbatim", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
+    ])
+  });
+  ctx.llm.resolveModelInfo = async () => ({
+    provider: "mock",
+    model: "mock-model",
+    reasoning: { efforts: [{ id: "high" }, { id: "low" }], defaultEffort: "low" }
+  });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "high" });
+  assert.equal(result.ok, true);
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "high", "supported configured value untouched");
+  }
+  store.close();
+});
+
+test("defaultEffort trap: capability query failure falls back to configured effort (retry still guards)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const calls = [];
+  const warnings = [];
+  const ctx = {
+    logger: { warn: (m) => warnings.push(String(m)) },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        if (options.reasoningEffort) {
+          throw new Error("UNSUPPORTED_REASONING_EFFORT: mock does not support reasoning effort \"high\"");
+        }
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
+          ]) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：用户偏好中文。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      },
+      // Adapter knows nothing about the model — helper must not crash, and the
+      // configured effort flows through so withEffortFallback still retries.
+      resolveModelInfo: async () => { throw new Error("adapter not reachable"); }
+    }
+  };
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "high" });
+  assert.equal(result.ok, true, "run succeeds via the no-effort retry");
+  assert.equal(calls[0].reasoningEffort, "high", "configured effort forwarded when capability query fails");
+  assert.equal("reasoningEffort" in calls[1], false, "rejected effort retried without the field");
+  assert.ok(warnings.some((w) => w.includes("resolveModelInfo failed")), "capability-query failure is logged");
+  store.close();
+});
+
+test("defaultEffort trap: sleep conflict pass remaps a poison effort too", async () => {
+  const { store, service, vectorIndex } = sleepSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "主题X", content: "内容A 关于主题X", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "主题X副本", content: "内容B 关于主题X", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+  const captured = [];
+  const ctx = sleepCtx(
+    (userText) => userText.startsWith("候选冲突")
+      ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
+      : "[]",
+    { provider: "mock", model: "sleep-model" },
+    captured
+  );
+  ctx.llm.resolveModelInfo = async (provider, model) => ({
+    provider,
+    model,
+    reasoning: { efforts: [{ id: "medium" }, { id: "high" }], defaultEffort: "low" }
+  });
+  const result = await runSleep(ctx, service, baseConfig({ sleepReasoningEffort: "low" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+  assert.ok(captured.length >= 2, "conflict + pattern passes both hit the LLM");
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "medium", "poison 'low' remapped on sleep passes too");
+  }
+  store.close();
+});

package/test/tools.test.js

@@ -44,15 +44,15 @@ function walkSchema(node, path, problems) {
   }
 }
 
-test("registers seven tools with correct names", () => {
+test("registers eight tools with correct names", () => {
   const { registered } = setup();
   const names = registered.map((t) => t.name).sort();
-  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_list", "memory_save", "memory_search", "memory_update"]);
+  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_get", "memory_list", "memory_save", "memory_search", "memory_update"]);
 });
 
 test("compiled schemas pass the enforced DSH subset (defineTool projection)", () => {
   const { registered } = setup();
-  assert.equal(registered.length, 7);
+  assert.equal(registered.length, 8);
   for (const tool of registered) {
     assertSupportedJsonSchema(tool.parameters);
     assertSupportedJsonSchema(tool.output.schema);
@@ -91,6 +91,57 @@ test("memory_search finds by CJK substring", async () => {
   assert.equal(result.items[0].title, "记忆插件");
 });
 
+// Regression: memory_get.execute must live on the defineTool options (top
+// level), NOT nested inside output — a misplaced execute silently becomes
+// options.execute === undefined and every call throws "userExecute is not a
+// function" while tests that only count tool names still pass.
+test("memory_get returns the full body via execute and render", async () => {
+  const { registered, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "完整正文内容" });
+  const get = registered.find((t) => t.name === "memory_get");
+  const res = await get.execute({ id: memory.id });
+  assert.equal(res.memory.id, memory.id);
+  assert.equal(res.memory.content, "完整正文内容");
+  assert.deepEqual(validateJsonSchemaValue(get.output.schema, res), []);
+  const text = get.output.render({}, res)[0].text;
+  assert.ok(text.includes("完整正文内容"), "full body in render");
+  assert.ok(text.includes(memory.id) && text.includes("t"), "id + title in render");
+});
+
+test("memory_get on missing id rejects", async () => {
+  const { registered } = setup();
+  const get = registered.find((t) => t.name === "memory_get");
+  await assert.rejects(() => get.execute({ id: "missing" }), /memory not found/);
+});
+
+// Render output is what hosts surface to the model (not the structured JSON),
+// so it must embed titles + body previews, not just a hit count.
+test("memory_search render embeds titles and body previews, not just a count", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "history", title: "旅行计划", content: "用户当前最苦恼时间安排与伦敦行程" });
+  service.saveWithDedupe({ type: "project", title: "插件定位", content: "dsh-mneme 插件做记忆沉淀" });
+  const search = registered.find((t) => t.name === "memory_search");
+  const res = await search.execute({ query: "时间" });
+  assert.ok(res.items.length >= 1, "search hit exists");
+  const text = search.output.render({}, res)[0].text;
+  assert.match(text, /Found \d+ memory entr/);
+  assert.ok(text.includes("旅行计划"), "title embedded in render");
+  assert.ok(text.includes("伦敦行程"), "body preview embedded in render");
+  assert.ok(text.includes("ID: "), "id embedded");
+});
+
+test("memory_list render embeds titles and ids, not just counts", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "昵称", content: "桉桉" });
+  service.saveWithDedupe({ type: "project", title: "博客", content: "modusensus" });
+  const list = registered.find((t) => t.name === "memory_list");
+  const res = await list.execute({});
+  const text = list.output.render({}, res)[0].text;
+  assert.match(text, /\d+ memory entries \(of \d+\):/);
+  assert.ok(text.includes("昵称") && text.includes("博客"), "titles embedded");
+  assert.ok(text.includes("ID: "), "ids embedded");
+});
+
 test("memory_list filters by type", async () => {
   const { registered, service } = setup();
   service.saveWithDedupe({ type: "preference", title: "a", content: "x" });