memory-eternal 0.10.0 → 0.10.2

package/lib/capture-log.js

@@ -1,59 +1,65 @@
-// 记忆核心 · 自动沉淀日志的持久层（JSONL 追加）。
-//
-// 为什么要有它：
-// 1) 独立 Web 页（lib/web.js 起的进程）拿不到宿主内存里的日志，面板只能显示
-//    「日志仅在 DSH 宿主内可用」——用户看到的就是"记录里没内容"；
-// 2) 宿主重启后内存环形缓冲清空，历史诊断信息全丢。
-// 落一个 JSONL 到 DSH_HOME 里，两边都能读：宿主写、两边读，最多保留最近 500 条。
-
-import { promises as fs } from 'node:fs'
-import path from 'node:path'
-import os from 'node:os'
-
-const FILE = 'memory-eternal-capture.jsonl'
-export const CAPTURE_LOG_MAX_LINES = 500
-
-/** 日志文件路径（与 vault 同级的 DSH_HOME 下）。 */
-export function captureLogPath(env = process.env) {
-  const home = env.DSH_HOME || path.join(os.homedir(), '.dsh')
-  return path.join(home, FILE)
-}
-
-/** 追加一条（失败静默：日志不能反过来搞坏沉淀管线）。 */
-export async function appendCaptureLog(entry, env = process.env) {
-  try { await fs.appendFile(captureLogPath(env), JSON.stringify(entry) + '\n', 'utf8') } catch { /* 忽略 */ }
-}
-
-/** 读最近 limit 条，**最新在前**（与 /capture-log 接口语义一致）。 */
-export async function readCaptureLog(limit = 100, env = process.env) {
-  try {
-    const txt = await fs.readFile(captureLogPath(env), 'utf8')
-    const lines = txt.split('\n').filter(Boolean)
-    const out = []
-    for (const line of lines.slice(-limit)) {
-      try { out.push(JSON.parse(line)) } catch { /* 跳过坏行 */ }
-    }
-    return out.reverse()
-  } catch { return [] }
-}
-
-/** 从日志推健康状态（独立 Web 页没有宿主内存状态，只能看最近一条结论）。 */
-export function deriveHealth(entries) {
-  for (const e of entries || []) {
-    if (e.action === 'fail') return { ok: false, reason: e.reason || '', since: e.time || 0, lastOkAt: 0, lastFailAt: e.time || 0 }
-    if (e.action === 'created' || e.action === 'appended') return { ok: true, reason: '', since: 0, lastOkAt: e.time || 0, lastFailAt: 0 }
-  }
-  return null
-}
-
-/** 行数超上限时重写为最近 CAPTURE_LOG_MAX_LINES 行（由宿主定期调用）。 */
-export async function rotateCaptureLog(env = process.env) {
-  try {
-    const p = captureLogPath(env)
-    const txt = await fs.readFile(p, 'utf8')
-    const lines = txt.split('\n').filter(Boolean)
-    if (lines.length <= CAPTURE_LOG_MAX_LINES) return false
-    await fs.writeFile(p, lines.slice(-CAPTURE_LOG_MAX_LINES).join('\n') + '\n', 'utf8')
-    return true
-  } catch { return false }
-}
+// 记忆核心 · 自动沉淀日志的持久层（JSONL 追加）。
+//
+// 为什么要有它：
+// 1) 独立 Web 页（lib/web.js 起的进程）拿不到宿主内存里的日志，面板只能显示
+//    「日志仅在 DSH 宿主内可用」——用户看到的就是"记录里没内容"；
+// 2) 宿主重启后内存环形缓冲清空，历史诊断信息全丢。
+// 落一个 JSONL 到 DSH_HOME 里，两边都能读：宿主写、两边读，最多保留最近 500 条。
+
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+const FILE = 'memory-eternal-capture.jsonl'
+export const CAPTURE_LOG_MAX_LINES = 500
+
+/** 日志文件路径（与 vault 同级的 DSH_HOME 下）。 */
+export function captureLogPath(env = process.env) {
+  const home = env.DSH_HOME || path.join(os.homedir(), '.dsh')
+  return path.join(home, FILE)
+}
+
+/** 追加一条（失败静默：日志不能反过来搞坏沉淀管线）。 */
+export async function appendCaptureLog(entry, env = process.env) {
+  try {
+    const file = captureLogPath(env)
+    // DSH_HOME 还不存在时先建出来：否则 appendFile 直接 ENOENT，而这里又是静默失败 ——
+    // 诊断信息（如「插件安装不完整」）会连一条都留不下。
+    await fs.mkdir(path.dirname(file), { recursive: true })
+    await fs.appendFile(file, JSON.stringify(entry) + '\n', 'utf8')
+  } catch { /* 忽略 */ }
+}
+
+/** 读最近 limit 条，**最新在前**（与 /capture-log 接口语义一致）。 */
+export async function readCaptureLog(limit = 100, env = process.env) {
+  try {
+    const txt = await fs.readFile(captureLogPath(env), 'utf8')
+    const lines = txt.split('\n').filter(Boolean)
+    const out = []
+    for (const line of lines.slice(-limit)) {
+      try { out.push(JSON.parse(line)) } catch { /* 跳过坏行 */ }
+    }
+    return out.reverse()
+  } catch { return [] }
+}
+
+/** 从日志推健康状态（独立 Web 页没有宿主内存状态，只能看最近一条结论）。 */
+export function deriveHealth(entries) {
+  for (const e of entries || []) {
+    if (e.action === 'fail') return { ok: false, reason: e.reason || '', since: e.time || 0, lastOkAt: 0, lastFailAt: e.time || 0 }
+    if (e.action === 'created' || e.action === 'appended') return { ok: true, reason: '', since: 0, lastOkAt: e.time || 0, lastFailAt: 0 }
+  }
+  return null
+}
+
+/** 行数超上限时重写为最近 CAPTURE_LOG_MAX_LINES 行（由宿主定期调用）。 */
+export async function rotateCaptureLog(env = process.env) {
+  try {
+    const p = captureLogPath(env)
+    const txt = await fs.readFile(p, 'utf8')
+    const lines = txt.split('\n').filter(Boolean)
+    if (lines.length <= CAPTURE_LOG_MAX_LINES) return false
+    await fs.writeFile(p, lines.slice(-CAPTURE_LOG_MAX_LINES).join('\n') + '\n', 'utf8')
+    return true
+  } catch { return false }
+}

package/lib/capture.js

@@ -19,6 +19,18 @@ export const DEDUP_THRESHOLD = 0.62
 /** 参与语义去重的近邻卡片数上限（控制 token）。 */
 export const DEDUP_NEIGHBORS = 8
 
+/**
+ * 蒸馏输出 token 上限的默认值（issue #18）。
+ *
+ * 旧默认 900 与 system prompt 要求的「300-800 字正文」不匹配：中文 800 字本身就逼近 900 token，
+ * 再叠加 JSON 结构开销与超长会话输入，轻易撞上限 → 输出被截断 → 旧代码把它误报成
+ * UNPARSEABLE_OUTPUT，最终落一张 raw 噪声卡。2000 给正文留出余量（仍是单次调用的量级）。
+ */
+export const DEFAULT_CAPTURE_MAX_TOKENS = 2000
+
+/** 蒸馏输出上限的硬顶（与 api.js 的 NUM_RANGE.captureMaxTokens 一致）。 */
+export const MAX_CAPTURE_MAX_TOKENS = 4000
+
 // 沉淀预筛：仅当对话含「可复用」信号时才调用 LLM，避免对纯闲聊/寒暄发起昂贵的 LLM 判定。
 const DURABLE_SIGNALS = /(#{1,3}\s|```|\[\[|\]|\(https?:|\.(md|ts|js|py|json|yml|yaml|sh|sql)\b|`|\b\d{2,}\b|选择|决定|采用|方案|结论|原因|根因|问题|解决|修复|报错|错误|教训|架构|设计|配置|部署|流程|步骤|算法|原理|函数|接口|参数|命令|依赖|版本|坑|踩|优化|性能|数据库|索引|模型|token|推荐|偏好|约定|规范)/
 
@@ -218,13 +230,17 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
     source: { kind: 'plugin', plugin: 'memory-eternal' },
   })]
 
+  const maxTokens = opts.maxTokens ?? DEFAULT_CAPTURE_MAX_TOKENS
+  // #15：route.reasoningEffort === null 表示该 provider 明确声明不支持 reasoning effort，
+  // 此时**不传**这个字段（传了会被 LLM 层硬校验拒绝，等于每次沉淀先白烧一次调用）。
+  const effort = route.reasoningEffort === undefined ? 'off' : route.reasoningEffort
   const options = {
     provider: route.provider,
     model: route.model,
     messages,
     system,
-    maxTokens: opts.maxTokens ?? 900,
-    reasoningEffort: 'off',
+    maxTokens,
+    ...(effort ? { reasoningEffort: effort } : {}),
     purpose: 'memory-capture',
     signal: opts.signal ?? AbortSignal.timeout(45000),
   }
@@ -240,10 +256,24 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
       },
     }
   }
+  // #18 根因 1：撞到输出上限时 finish.kind === 'max-tokens'（dsh-llm 的 FinishReasonMap）。
+  // 旧实现只认 error/aborted，于是截断的 JSON 一路落到 parseCaptureJson 上被误报成
+  // UNPARSEABLE_OUTPUT —— 真实原因（输出被截断）被完全掩盖。这里给独立错误码。
+  if (finish.kind === 'max-tokens') {
+    return {
+      failure: {
+        code: 'MAX_TOKENS',
+        message: `输出撞到 maxTokens=${maxTokens} 上限被截断（不是解析失败）：调大「蒸馏输出上限」captureMaxTokens，或缩短会话输入`,
+      },
+    }
+  }
   const out = assembler.blocks().filter((b) => b.type === 'text').map((b) => b.text).join('').trim()
   const parsed = parseCaptureJson(out)
   if (!parsed) {
-    return { failure: { code: 'UNPARSEABLE_OUTPUT', message: out ? '模型输出无法解析为 JSON：' + out.slice(0, 160) : '模型返回空文本' } }
+    const why = out ? '模型输出无法解析为 JSON' : '模型返回空文本'
+    // 括号没闭合 = 截断的强特征：即便宿主没给 max-tokens finish，也把方向指对（#18 建议 1）
+    const hint = out && looksTruncatedJson(out) ? '（JSON 括号未闭合，疑似输出被截断）' : ''
+    return { failure: { code: 'UNPARSEABLE_OUTPUT', message: why + hint + (out ? '：' + out.slice(0, 160) : '') } }
   }
   return { card: parsed }
 }
@@ -315,6 +345,30 @@ async function importLlmHelpers() {
   }
 }
 
+/**
+ * 判断一段文本的 JSON 结构是否**没闭合**（截断的强特征，issue #18 建议 1）。
+ * 只做括号/引号配对扫描，不解析；用于把「疑似被截断」和「模型乱输出」区分开。
+ */
+export function looksTruncatedJson(text) {
+  const s = String(text || '').trim()
+  if (!s) return false
+  let depth = 0
+  let inStr = false
+  let esc = false
+  for (const ch of s) {
+    if (inStr) {
+      if (esc) esc = false
+      else if (ch === '\\') esc = true
+      else if (ch === '"') inStr = false
+      continue
+    }
+    if (ch === '"') inStr = true
+    else if (ch === '{' || ch === '[') depth++
+    else if (ch === '}' || ch === ']') depth--
+  }
+  return depth > 0 || inStr
+}
+
 export function parseCaptureJson(text) {
   if (!text) return null
   // 去掉可能的 ```json 围栏
@@ -530,25 +584,76 @@ export async function routeCandidates(llm, opts = {}) {
   try {
     const providers = llm.listProviders() || []
     if (!providers.length) return out
+    // 候选按「能力」排序：明确不支持 reasoning effort 的往后放（#15 问题 2）。
+    // 注意**不删除**它们 —— 不传 reasoningEffort 之后它们完全可能正常出卡，
+    // 而删掉它们会让「候选全不支持」的机器直接没有兜底（见 #15 的实测：四个网关全不支持）。
+    const push = (provider, model, modelInfo) => {
+      if (!provider || !provider.id || !model) return
+      if (out.some((r) => r.provider === provider.id)) return
+      const entry = { provider: provider.id, model }
+      if (!supportsReasoningEffort(provider, modelInfo)) entry.reasoningEffort = null
+      out.push(entry)
+    }
+    const modelsOf = async (id) => {
+      const list = await llm.listModels(id)
+      return Array.isArray(list) ? list : []
+    }
     if (want) {
       const hit = providers.find((p) => p && p.id === want)
       if (hit) {
-        const models = (await llm.listModels(hit.id)) || []
+        const models = await modelsOf(hit.id)
         const model = wantModel || (models[0] && models[0].id)
-        if (model) out.push({ provider: hit.id, model })
+        push(hit, model, models.find((m) => m && m.id === model) || null)
       }
     }
+    const rest = []
     for (const p of providers) {
       if (!p || !p.id || out.some((r) => r.provider === p.id)) continue
-      const models = (await llm.listModels(p.id)) || []
+      const models = await modelsOf(p.id)
       const model = (p.id === want && wantModel) || (models[0] && models[0].id)
-      if (model) out.push({ provider: p.id, model })
+      if (!model) continue
+      rest.push({ p, model, info: models.find((m) => m && m.id === model) || null })
+    }
+    // Array.prototype.sort 是稳定的：能力相同的候选保持原有的「注册顺序」语义
+    rest.sort((a, b) => Number(!supportsReasoningEffort(a.p, a.info)) - Number(!supportsReasoningEffort(b.p, b.info)))
+    for (const r of rest) {
       if (out.length >= limit) break
+      push(r.p, r.model, r.info)
     }
   } catch { /* 路由解析失败按空列表返回，由调用方兜底 */ }
   return out
 }
 
+/**
+ * 该 provider/model 是否**明确声明**不支持 reasoning effort（#15 问题 2）。
+ *
+ * DSH 的 LLM 层会按 provider 声明的能力硬校验：声明不支持时，请求里带上
+ * reasoningEffort 会在发出前/发出时以 UNSUPPORTED_REASONING_EFFORT 失败。
+ * 声明位置随版本而异（provider.compat / provider.capabilities / 模型条目的 reasoning），
+ * 这里全部读一遍；**未知一律按「支持」处理**，避免把能力推断错成功能退化。
+ *
+ * @param {object|null} providerInfo llm.listProviders() 的条目
+ * @param {object|null} [modelInfo]  llm.listModels() 的对应条目
+ * @returns {boolean}
+ */
+export function supportsReasoningEffort(providerInfo, modelInfo = null) {
+  const flag = (o) => {
+    if (!o || typeof o !== 'object') return undefined
+    if (typeof o.supportsReasoningEffort === 'boolean') return o.supportsReasoningEffort
+    if (o.compat && typeof o.compat.supportsReasoningEffort === 'boolean') return o.compat.supportsReasoningEffort
+    if (o.capabilities && typeof o.capabilities.supportsReasoningEffort === 'boolean') return o.capabilities.supportsReasoningEffort
+    return undefined
+  }
+  const fromProvider = flag(providerInfo)
+  if (fromProvider === false) return false
+  const fromModel = flag(modelInfo)
+  if (fromModel === false) return false
+  // 模型条目自带 reasoning 能力表且**为空** → 该模型没有可选 effort，等于不支持
+  const reasoning = modelInfo && modelInfo.reasoning
+  if (reasoning && Array.isArray(reasoning.efforts) && reasoning.efforts.length === 0) return false
+  return true
+}
+
 /** 解析当前模型路由：显式配置优先，其次第一个 provider 的首个模型（保持旧行为作兜底）。 */
 export async function resolveRoute(llm, opts = {}) {
   const list = await routeCandidates(llm, opts)