@modusensus/dsh-mneme 0.7.28 → 0.7.29

package/src/service.js

@@ -416,6 +416,171 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  /**
+   * Recall fusion (plan #1). Turns the three ranked signal lists (keyword,
+   * vector, BM25) into a single merged list. Three recipes, selected by
+   * config.recallFusion:
+   *  - blend (default): legacy behavior — weighted sum for vector/hybrid, union
+   *    backfill for auto. Byte-identical to pre-fusion code, so enabling the
+   *    config never regresses anybody.
+   *  - rrf: Reciprocal Rank Fusion — Σ 1/(k + rank + 1) over each list a row
+   *    appears in. Rank-based, so the unit mismatch (raw cosine vs keyword
+   *    score vs normalized IDF) is irrelevant.
+   *  - minmax: min-max normalize each source list's scores to [0,1] then take
+   *    the weighted sum — a scale-aware version of `blend`.
+   * Returns { merged, signals }, where signals is Map<id, {keyword, vector,
+   * bm25}> so searchMemories can decorate rows when signalTransparency is on.
+   */
+  function fuseRecall({ keyword, vector, bm25, lim, mode, wv, wk, wb }) {
+    const recipe = config?.recallFusion ?? "blend";
+
+    // Per-source scores are recorded for every recipe so signalTransparency
+    // works regardless of how the ranking was produced.
+    const signals = new Map();
+    const addSig = (id, field, sc) => {
+      const cur = signals.get(id) ?? {};
+      cur[field] = sc;
+      signals.set(id, cur);
+    };
+    for (const m of keyword) addSig(m.id, "keyword", m.score ?? 0);
+    for (const m of vector) addSig(m.id, "vector", m.score ?? 0);
+    for (const m of bm25) addSig(m.id, "bm25", m.score ?? 0);
+
+    const vectorIds = new Set(vector.map((m) => m.id));
+    const keywordIds = new Set(keyword.map((m) => m.id));
+
+    // Mode contract (aligns rrf/minmax with blend): keyword-only searches must
+    // stay keyword-only regardless of recipe, so enabling an opt-in recipe can
+    // never pull vector/BM25 rows into a mode="keyword" request. This mirrors
+    // the blend branch's `mode === "keyword"` short-circuit (byte-for-byte).
+    if (mode === "keyword") {
+      return { merged: keyword.slice(0, lim), signals };
+    }
+
+    let merged;
+    if (recipe === "rrf") {
+      // Rank-based: only the position of a row inside each surviving source
+      // list matters, so no cross-signal scale calibration is needed.
+      const k = 60; // standard RRF constant (plan #1 documents k=60)
+      const rows = new Map();
+      const addList = (list) => list.forEach((m, idx) => {
+        const s = 1 / (k + idx + 1);
+        const cur = rows.get(m.id);
+        if (cur) cur.score += s;
+        else rows.set(m.id, { ...m, score: s });
+      });
+      addList(keyword);
+      addList(vector);
+      addList(bm25);
+      merged = [...rows.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, lim);
+    } else if (recipe === "minmax") {
+      // Scale-aware weighted sum: each source list is min-max normalized to
+      // [0,1] before blending, so raw cosine and keyword score live on the
+      // same footing.
+      const norm = (list) => {
+        if (!list.length) return new Map();
+        let min = Infinity, max = -Infinity;
+        for (const m of list) { const s = m.score ?? 0; if (s < min) min = s; if (s > max) max = s; }
+        const range = max - min;
+        const out = new Map();
+        for (const m of list) out.set(m.id, range > 0 ? ((m.score ?? 0) - min) / range : 0.5);
+        return out;
+      };
+      const kw = norm(keyword), ve = norm(vector), bm = norm(bm25);
+      const rows = new Map();
+      const seed = (m) => { if (!rows.has(m.id)) rows.set(m.id, { ...m, score: 0 }); };
+      for (const m of keyword) seed(m);
+      for (const m of vector) seed(m);
+      for (const m of bm25) seed(m);
+      for (const [id, row] of rows) {
+        const k = kw.get(id) ?? 0;
+        const v = ve.get(id) ?? 0;
+        const b = bm.get(id) ?? 0;
+        row.score = v * wv + k * wk + b * wb;
+      }
+      merged = [...rows.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, lim);
+    } else {
+      // blend — the pre-existing per-mode behavior, extracted verbatim.
+      if (mode === "keyword") {
+        merged = keyword;
+      } else if (mode === "vector" || mode === "hybrid") {
+        const byId = new Map();
+        for (const m of vector) {
+          const rec = byId.get(m.id);
+          byId.set(m.id, rec ? { ...rec, score: Math.max(rec.score ?? 0, m.score ?? 0) } : m);
+        }
+        for (const m of keyword) {
+          const rec = byId.get(m.id);
+          if (rec) {
+            byId.set(m.id, { ...rec, score: (rec.score ?? 0) * wv + (m.score ?? 0) * wk });
+          } else {
+            byId.set(m.id, m);
+          }
+        }
+        for (const m of bm25) {
+          const rec = byId.get(m.id);
+          if (rec) {
+            if (keywordIds.has(m.id)) continue;
+            byId.set(m.id, { ...rec, score: (rec.score ?? 0) + wb * (m.score ?? 0) });
+          } else {
+            byId.set(m.id, { ...m, score: wb * (m.score ?? 0) });
+          }
+        }
+        const ranked = [...byId.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+        merged = ranked.slice(0, lim);
+        if (merged.length < lim && !merged.length) {
+          merged = keyword.slice(0, lim);
+        }
+      } else {
+        // auto: keyword leads, vector + BM25 fill remaining slots.
+        merged = keyword.slice(0, lim);
+        const seen = new Set(merged.map((m) => m.id));
+        for (const m of vector) {
+          if (merged.length >= lim) break;
+          if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
+        }
+        for (const m of bm25) {
+          if (merged.length >= lim) break;
+          if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
+        }
+      }
+    }
+
+    // Mode contract, auto (aligns rrf/minmax with blend): keyword leads, the
+    // recipe fills the remaining slots. blend.auto already front-loads keyword;
+    // rrf/minmax rank across sources, so re-apply the same "keyword first"
+    // ordering here to preserve the pre-fusion auto contract — the keyword
+    // hit list keeps its power, and only slots it couldn't fill go to the
+    // recipe's ranking.
+    if (recipe !== "blend" && mode === "auto" && keyword.length) {
+      const head = keyword.slice(0, lim);
+      const seen = new Set(head.map((m) => m.id));
+      const tail = merged.filter((m) => !seen.has(m.id)).slice(0, Math.max(0, lim - head.length));
+      merged = head.concat(tail);
+    }
+
+    return { merged, signals };
+  }
+
+  /**
+   * Search memories for a query. Merges up to three recall sources (keyword,
+   * vector, BM25) according to config.recallFusion (blend/rrf/minmax — see
+   * fuseRecall), then optionally decorates rows with per-source signals
+   * (config.signalTransparency), applies semantic dedup (non-keyword modes),
+   * reranking, and epistemic trust re-weighting, and finally hands the merged
+   * list to the recall-layer recorder.
+   *
+   * options:
+   *   mode          — 'auto' (default) | 'keyword' | 'vector' | 'hybrid'
+   *   topK          — max rows (default 20)
+   *   threshold     — explicit vector score floor (overrides adaptive)
+   *   useRerank     — apply the reranker if available (default true)
+   *   recordRecall  — write a recall_runs audit row (default from config)
+   *
+   * Returns an array of memory rows { id, title, content, score, source, ... },
+   * with `signals` added when config.signalTransparency is on. Never throws:
+   * a vector/rerank failure degrades to keyword results.
+   */
   async function searchMemories(query, options = {}) {
     const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = options.recordRecall ?? (config?.recallRecordDefault ?? true) } = options;
     const q = String(query ?? "").trim();
@@ -477,69 +642,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // Loose blend weight: BM25 confirms and backfills, never dominates the
     // semantic signal. Same-memory overlap boosts, unseen ids backfill.
     const wb = 0.3;
-    // Path bookkeeping for the boost rule below: which ids each semantic
-    // recall path surfaced.
-    const vectorIds = new Set(vector.map((m) => m.id));
-    const keywordIds = new Set(keyword.map((m) => m.id));
 
     // Hybrid blending weights from config when provided.
     const wv = config?.hybridSearchVectorWeight ?? DEFAULT_HYBRID_WEIGHTS.vector;
     const wk = config?.hybridSearchKeywordWeight ?? DEFAULT_HYBRID_WEIGHTS.keyword;
 
-    let merged;
-    if (mode === "keyword") {
-      merged = keyword;
-    } else if (mode === "vector" || mode === "hybrid") {
-      // semantic-first: vector recalls lead, keyword + BM25 fill remaining
-      // slots. Weighted blend when sides scored the same memory; otherwise
-      // vector order leads (it is the semantic signal), lexical paths
-      // backfill.
-      const byId = new Map();
-      for (const m of vector) {
-        const rec = byId.get(m.id);
-        byId.set(m.id, rec ? { ...rec, score: Math.max(rec.score ?? 0, m.score ?? 0) } : m);
-      }
-      for (const m of keyword) {
-        const rec = byId.get(m.id);
-        if (rec) {
-          // Same memory from both sides: blend the scores.
-          byId.set(m.id, { ...rec, score: (rec.score ?? 0) * wv + (m.score ?? 0) * wk });
-        } else {
-          byId.set(m.id, m);
-        }
-      }
-      for (const m of bm25) {
-        const rec = byId.get(m.id);
-        if (rec) {
-          // Boost rule: a row the LIKE keyword path already hit carries the
-          // query as a substring, so BM25 tokens are trivially present —
-          // boosting it double-counts lexical evidence. Only vector-recalled
-          // rows (lexical hit is genuinely new information) get the boost.
-          if (keywordIds.has(m.id)) continue;
-          byId.set(m.id, { ...rec, score: (rec.score ?? 0) + wb * (m.score ?? 0) });
-        } else {
-          byId.set(m.id, { ...m, score: wb * (m.score ?? 0) });
-        }
-      }
-      const ranked = [...byId.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-      merged = ranked.slice(0, lim);
-      if (merged.length < lim && !merged.length) {
-        // Vector unavailable entirely: fall back to plain keyword.
-        merged = keyword.slice(0, lim);
-      }
-    } else {
-      // auto: keyword leads, vector + BM25 fill remaining slots (legacy
-      // behavior, extended with the third path)
-      merged = keyword.slice(0, lim);
-      const seen = new Set(merged.map((m) => m.id));
-      for (const m of vector) {
-        if (merged.length >= lim) break;
-        if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
-      }
-      for (const m of bm25) {
-        if (merged.length >= lim) break;
-        if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
-      }
+    const { merged: fusedMerged, signals } = fuseRecall({ keyword, vector, bm25, lim, mode, wv, wk, wb });
+    let merged = fusedMerged;
+    // Signal transparency (#2): decorate each returned row with its per-source
+    // scores and the final fused score. Purely additive — never changes rank.
+    if (config?.signalTransparency === true) {
+      merged = merged.map((m) => ({ ...m, signals: { ...(signals.get(m.id) ?? {}), final: m.score ?? 0 } }));
     }
 
     // Search-time semantic dedup (v0.5.0 2.3): near-duplicate rows are

package/src/settings.js

@@ -58,6 +58,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "bm25SearchEnabled",
   "conflictFreezeEnabled",
   "trustEpistemicWeighting",
+  // Plan #2: attach per-source {keyword, vector, bm25, final} signals to each
+  // search result for transparency/debugging. Default off, purely decorative.
+  "signalTransparency",
   // Issue #89：宽容校验回归（默认开）+ 跨类型合并显式放宽（默认关）。
   "dreamSkipInvalid",
   "allowCrossTypeMerge",
@@ -86,6 +89,10 @@ const FEATURE_FLAG_STRINGS = [
   // /llm-providers 端点一起提供，留空 = 用巩固模型或当前模型。
   "sleepProvider",
   "sleepModel",
+  // 实体抽取侧专用路由（issue #109）：provider/model 显式指定，
+  // 留空 = 用当前默认模型。
+  "entityExtractionProvider",
+  "entityExtractionModel",
   "localEmbedModel",
   "ollamaModel"
 ];
@@ -94,7 +101,12 @@ const FEATURE_FLAG_STRINGS = [
 const FEATURE_FLAG_URLS = ["ollamaBaseUrl"];
 // 枚举开关（与 config.js 的 z.union(z.const(...)) 对齐）：仅允许列出的值。
 const FEATURE_FLAG_ENUMS = {
-  embedProvider: ["openai", "local", "ollama"]
+  embedProvider: ["openai", "local", "ollama"],
+  // Plan #1: recall fusion recipe. blend = legacy (default); rrf / minmax are
+  // rank/scale-aware alternatives selected by the panel.
+  recallFusion: ["blend", "rrf", "minmax"],
+  // 实体抽取思考强度（issue #109）：与 dreamReasoningEffort 枚举对齐。
+  entityExtractionReasoning: ["low", "medium", "high", "none"]
 };
 const FEATURE_FLAG_STRING_MAX = 200;
 

package/test/api.test.js

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createApi } from "../src/api.js";
@@ -517,6 +518,20 @@ test("Bug10: vector-reindex with an embed-only OpenAI-compatible embedder return
   assert.equal(vectorIndex.getEmbedding(service.all()[0].id).length, 3, "embedding persisted");
 });
 
+// --- /info（反馈预填的插件版本）-----------------------------------------------
+
+test("GET /api/dsh-mneme/info returns the package version for feedback prefills", async () => {
+  const { routes } = setup(undefined);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/info");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/info"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  // 与插件根 package.json 的版本一致（反馈 issue/邮件的预填环境信息依赖它）。
+  const expected = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  assert.equal(data.version, expected);
+});
+
 // --- feature flags（/features：overrides + effective）------------------------
 
 test("GET /api/dsh-mneme/features returns empty overrides and effective config defaults", async () => {
@@ -527,12 +542,15 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
   assert.deepEqual(data.overrides, {});
-  // effective 覆盖全部 37 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
+  // effective 覆盖全部 42 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
   // dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes、面板可调的
-  // dreamMaxTokens 与本轮睡眠路由 sleepProvider/sleepModel），未覆盖时取
-  // bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema 默认值
-  // （Config({}) 解析为 undefined），不编造给前端 → 37 - 2 = 35
-  assert.equal(Object.keys(data.effective).length, 35);
+  // dreamMaxTokens、睡眠路由 sleepProvider/sleepModel、PR1 新增的
+  // recallFusion/signalTransparency，以及 issue #109 新增的实体抽取路由
+  // entityExtractionProvider/entityExtractionModel/entityExtractionReasoning），
+  // 未覆盖时取 bundle 配置的解析默认值；
+  // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
+  // 不编造给前端 → 42 - 2 = 40
+  assert.equal(Object.keys(data.effective).length, 40);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
@@ -555,6 +573,13 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(data.effective.ollamaBaseUrl, "http://localhost:11434");
   assert.equal(data.effective.ollamaModel, "nomic-embed-text");
   assert.equal(data.effective.embedProvider, "openai");
+  // PR1：融合配方枚举 + 信号透明布尔（均有默认值，故计入 effective 计数）
+  assert.equal(data.effective.recallFusion, "blend");
+  assert.equal(data.effective.signalTransparency, false);
+  // issue #109：实体抽取路由三键（均有默认值，故计入 effective 计数）
+  assert.equal(data.effective.entityExtractionProvider, "");
+  assert.equal(data.effective.entityExtractionModel, "");
+  assert.equal(data.effective.entityExtractionReasoning, "none");
 });
 
 test("PUT /api/dsh-mneme/features round-trips, overrides effective and persists", async () => {

package/test/benchmark.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runBenchmark, TEST_CASES } from "../scripts/benchmark-recall.js";
+import { runBenchmark, runFusionBenchmark, seedService, TEST_CASES } from "../scripts/benchmark-recall.js";
 
 // The benchmark harness must stay a working evaluation: it runs the real
 // searchMemories pipeline over the seeded store and the fused configuration
@@ -33,3 +33,62 @@ test("test cases cover the scattered-term BM25 territory", () => {
     assert.ok(tc.query && tc.expected.length > 0);
   }
 });
+
+// --- PR1: recall fusion recipes + signal transparency ---------------------
+
+test("fusion-recipe A/B runs blend/rrf/minmax with valid recall on the seed corpus", async () => {
+  const report = await runFusionBenchmark({ topK: 5 });
+  assert.deepEqual(report.runs.map((r) => r.config), ["blend", "rrf", "minmax"]);
+  for (const run of report.runs) {
+    assert.equal(run.rows.length, TEST_CASES.length, `${run.config} covers every query`);
+    assert.ok(run.recallAtK >= 0 && run.recallAtK <= 1, `${run.config} recallAtK in [0,1]`);
+    assert.ok(run.avgMrr >= 0 && run.avgMrr <= 1, `${run.config} avgMrr in [0,1]`);
+  }
+});
+
+test("signalTransparency decorates rows with per-source signals", async () => {
+  const svc = seedService({ recallFusion: "blend", signalTransparency: true });
+  const rows = await svc.searchMemories("rust 异步", { mode: "auto", topK: 5, useRerank: false });
+  assert.ok(rows.length > 0, "the seed corpus returns hits for a scattered-term query");
+  for (const r of rows) {
+    assert.equal(typeof r.signals, "object", "each row carries a signals object");
+    assert.equal(typeof r.signals.final, "number", "signals carries the fused final score");
+    assert.ok([
+      "keyword" in r.signals,
+      "vector" in r.signals,
+      "bm25" in r.signals
+    ].some(Boolean), "at least one source signal is present");
+  }
+});
+
+test("recallFusion recipes produce distinct fused scores for the same memory", async () => {
+  const scores = {};
+  for (const recipe of ["blend", "rrf", "minmax"]) {
+    const svc = seedService({ recallFusion: recipe });
+    const rows = await svc.searchMemories("rust 异步", { mode: "auto", topK: 5, useRerank: false });
+    const hit = rows.find((r) => r.id === "mem_async_pattern") ?? rows[0];
+    assert.ok(hit, `${recipe} surfaces a hit`);
+    scores[recipe] = hit.score ?? 0;
+  }
+  // RRF is rank-based (Σ 1/(k+rank+1)) and minmax normalizes before blending,
+  // so they must not all collapse onto the same numeric score.
+  assert.ok(new Set(Object.values(scores)).size > 1, `recipes score differently: ${JSON.stringify(scores)}`);
+});
+
+// PR1 + CodeRabbit: an opt-in recipe must never change keyword-only behavior.
+// mode="keyword" is the documented text-only path; regardless of recipe, the
+// result must contain only keyword-sourced rows — no vector/BM25 bleed-in.
+// (Note: on a scattered-CJK query the keyword source can itself be empty, in
+// which case auto correctly falls back to BM25 — that is the pre-fusion blend
+// behavior and is NOT a regression. Only mode="keyword" is a hard text path.)
+test("opt-in recipes keep mode=keyword keyword-only (no vector/BM25 bleed)", async () => {
+  for (const recipe of ["blend", "rrf", "minmax"]) {
+    const svc = seedService({ recallFusion: recipe });
+    const rows = await svc.searchMemories("rust 异步", { mode: "keyword", topK: 5, useRerank: false });
+    const keywordOnly = rows.every((r) => r.source === "keyword");
+    assert.ok(
+      keywordOnly,
+      `${recipe} under mode=keyword must keep only keyword rows; got sources: ${[...new Set(rows.map((r) => r.source))].join(",")}`
+    );
+  }
+});

package/test/client.test.js

@@ -554,3 +554,42 @@ test("consolidation/sleep model routing: provider dropdowns from /llm-providers,
     "the route selects must share the string-input width budget"
   );
 });
+
+// 帮助与反馈入口（v0.8）：设置页底部三个反馈链接——GitHub 新建 issue 预填
+// （环境信息）、邮件反馈、浏览已知问题。纯前端链接零后端成本；插件版本从
+// /info 拉取（version 只读，不铺任何 token/凭据）。公开链接不得带个人邮箱。
+test("settings feedback card: prefilled issue + mailto + browse, version from /info", () => {
+  // 1. 版本预填端点
+  assert.ok(
+    clientSource.includes('apiFetch("/api/dsh-mneme/info")'),
+    "the feedback card must fetch the plugin version from /info"
+  );
+  assert.ok(
+    clientSource.includes("setPkgVersion"),
+    "the fetched version must land in component state"
+  );
+  // 2. GitHub 新建 issue：issues/new?title=&body= 预填环境信息（当前仓库无模板）
+  assert.ok(
+    clientSource.includes("https://github.com/modusensus/dsh-mneme/issues/new?title="),
+    "the issue link must prefill title+body on issues/new"
+  );
+  assert.ok(
+    clientSource.includes("**插件版本**") && clientSource.includes("**平台**"),
+    "the prefill body must carry plugin version and platform"
+  );
+  // 3. 邮件反馈：官方邮箱（对外不写个人邮箱），mailto 预填 subject+body
+  assert.ok(
+    clientSource.includes("mailto:work@modusensus.space?subject="),
+    "the mailto link must point at the public support address"
+  );
+  // 4. 浏览已知问题：跳仓库 issues 列表页（去重前置步骤）
+  assert.ok(
+    clientSource.includes('href: "https://github.com/modusensus/dsh-mneme/issues"'),
+    "the browse link must open the repo issues list"
+  );
+  // 5. 双语 i18n
+  for (const key of ["feedback.title", "feedback.newIssue", "feedback.email", "feedback.browse", "feedback.hint"]) {
+    const occurrences = clientSource.split(`"memory.settings.${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key memory.settings.${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});

package/test/entities.test.js

@@ -520,3 +520,28 @@ test("extractor fails safe when callLLM rejects → {ok:false}", async () => {
   assert.ok(result.error);
   store.close();
 });
+
+// --- issue #109: provider/model override + reasoning effort pass-through -----
+
+test("extractor passes provider/model/reasoningEffort through to callLLM options", async () => {
+  const store = openStore();
+  let captured = null;
+  const callLLM = async (_messages, options) => {
+    captured = options;
+    return JSON.stringify({ entities: [{ name: "Vite", type: "technology", attrs: [] }], relations: [] });
+  };
+  const config = { entityExtractionProvider: "openai", entityExtractionModel: "gpt-x", entityExtractionReasoning: "high" };
+  const result = await extractEntities({ id: "m1", content: "Vite 是前端构建工具" }, { store, config, callLLM });
+  assert.equal(result.ok, true);
+  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high" });
+  store.close();
+});
+
+test("extractor omits empty provider/model and 'none' reasoning from options", async () => {
+  const store = openStore();
+  let captured = "unset";
+  const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
+  await extractEntities({ id: "m2", content: "空文本" }, { store, config: {}, callLLM });
+  assert.deepEqual(captured, {}, "no provider/model/reasoning keys when unset");
+  store.close();
+});

package/test/reasoning-effort.test.js

@@ -13,6 +13,7 @@ import { runSleep } from "../src/dream/sleep.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createVectorIndex } from "../src/vector-index.js";
+import { createEntityStreamAdapter } from "../src/index.js";
 
 const embedder = {
   embedSingle: async () => [1, 0, 0],
@@ -576,3 +577,79 @@ test("defaultEffort trap: sleep conflict pass remaps a poison effort too", async
   }
   store.close();
 });
+
+// ------------------------------------------------- entity extraction adapter (issue #108/#109)
+// The streamEntityText adapter lives in index.js; it maps the extractor's
+// options onto a dsh-llm stream route and retries once without the effort
+// when the first attempt is rejected. These tests drive the real exported
+// factory, not a mock of it.
+
+test("issue#109: entity extraction effort rejection retries once without the effort", async () => {
+  const calls = [];
+  const warnings = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        // First attempt carries the effort: the provider rejects it via an
+        // error finish chunk (the realistic stream-level rejection).
+        if (options.reasoningEffort) {
+          yield { type: "finish", reason: { kind: "error", message: "UNSUPPORTED_REASONING_EFFORT" } };
+          return;
+        }
+        yield { type: "text-delta", index: 0, text: "{\"entities\":[{\"name\":\"张三\",\"type\":\"person\",\"attrs\":[{\"key\":\"职业\",\"value\":\"工程师\",\"confidence\":0.9}]}],\"relations\":[]}" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: (m) => warnings.push(String(m)) }
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    { reasoningEffort: "low" }
+  );
+  assert.equal(calls.length, 2, "attempt (rejected) + retry without effort");
+  assert.equal(calls[0].reasoningEffort, "low", "first attempt forwards the effort");
+  assert.equal("reasoningEffort" in calls[1], false, "retry omits the rejected effort field");
+  assert.equal(calls[0].provider, "mock", "route resolved from agentDefaultModel");
+  assert.equal(calls[0].model, "mock-model", "route model from agentDefaultModel");
+  assert.equal(calls[0].maxTokens, 4096, "extraction caps its output");
+  assert.ok(text.includes("张三"), "retry stream text is returned");
+  assert.ok(warnings.some((w) => w.includes("rejected, retrying without it")), "rejection is logged");
+});
+
+test("issue#109: entity extraction never retries blindly without an effort configured", async () => {
+  const calls = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        yield { type: "finish", reason: { kind: "error", message: "overloaded" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} }
+  });
+  const text = await streamEntityText([{ role: "user", content: [] }], {});
+  assert.equal(text, undefined, "failure yields no text");
+  assert.equal(calls.length, 1, "no blind retry when no effort was requested");
+});
+
+test("issue#109: entity extraction explicit provider/model win over the default route", async () => {
+  const calls = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        yield { type: "text-delta", index: 0, text: "{}" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "default", model: "default-model" }) },
+    logger: { warn: () => {} }
+  });
+  await streamEntityText([{ role: "user", content: [] }], { provider: "volcano", model: "deepseek-v3" });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].provider, "volcano", "explicit provider beats the default");
+  assert.equal(calls[0].model, "deepseek-v3", "explicit model beats the default");
+});