memory-eternal 0.10.3 → 0.10.5

package/lib/capture.js

@@ -268,14 +268,18 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
     }
   }
   const out = assembler.blocks().filter((b) => b.type === 'text').map((b) => b.text).join('').trim()
-  const parsed = parseCaptureJson(out)
-  if (!parsed) {
+  const parsed = parseCaptureJsonDetailed(out)
+  if (!parsed.card) {
     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) : '') } }
+    // #24：JSON.parse 的原始报错（如 Bad control character in string literal at position N）
+    // 以前被两个裸 catch{} 完全吞掉，排查只能靠猜；现场摘要也从「只留前 160 字」改成首尾各留一段。
+    const raw = parsed.error ? '（JSON.parse 原始报错：' + parsed.error + '）' : ''
+    return { failure: { code: 'UNPARSEABLE_OUTPUT', message: why + hint + raw + (out ? '：' + describeOutputExcerpt(out) : '') } }
   }
-  return { card: parsed }
+  // repaired=true = 走了「字符串内裸控制字符转义」这条容错路径（#24），排障时能看到它真的生效了。
+  return { card: parsed.card, repaired: parsed.repaired }
 }
 
 /**
@@ -369,24 +373,65 @@ export function looksTruncatedJson(text) {
   return depth > 0 || inStr
 }
 
-export function parseCaptureJson(text) {
-  if (!text) return null
-  // 去掉可能的 ```json 围栏
-  const cleaned = text.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, '').trim()
-  let parsed
-  try {
-    parsed = JSON.parse(cleaned)
-  } catch {
-    // 容错：截取第一个 { 到最后一个 }
-    const start = cleaned.indexOf('{')
-    const end = cleaned.lastIndexOf('}')
-    if (start < 0 || end <= start) return null
-    try {
-      parsed = JSON.parse(cleaned.slice(start, end + 1))
-    } catch {
-      return null
+/**
+ * 把 JSON **字符串值内部**未转义的裸控制字符改成合法转义（issue #24）。
+ *
+ * 模型写 markdown 正文时经常把换行写成真实的 U+000A（而不是 `\n` 两字符），
+ * 这种输出括号是闭合的（looksTruncatedJson 得 false），却因为「字符串内不得出现
+ * 未转义控制字符」被 JSON.parse 必然拒绝 —— 旧实现只做「截 { … }」一层容错，
+ * 于是稳定地误报成 UNPARSEABLE_OUTPUT，真正的知识卡全丢进原文卡兜底。
+ *
+ * 只在字符串内部动手：字符串外的换行/制表符是合法 JSON 空白，改了反而是破坏。
+ * 标准转义（\n \r \t \b \f）用短写，其余控制字符转 \u00XX。
+ *
+ * @returns {{ text: string, repaired: boolean }} repaired=true 表示确实改过字符
+ */
+export function repairJsonControlChars(text) {
+  const s = String(text || '')
+  let out = ''
+  let inStr = false
+  let esc = false
+  let repaired = false
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (!inStr) {
+      if (ch === '"') inStr = true
+      out += ch
+      continue
+    }
+    if (esc) { esc = false; out += ch; continue }
+    if (ch === '\\') { esc = true; out += ch; continue }
+    if (ch === '"') { inStr = false; out += ch; continue }
+    const code = ch.charCodeAt(0)
+    if (code < 0x20) {
+      repaired = true
+      out += code === 0x0a ? '\\n'
+        : code === 0x0d ? '\\r'
+        : code === 0x09 ? '\\t'
+        : code === 0x08 ? '\\b'
+        : code === 0x0c ? '\\f'
+        : '\\u' + code.toString(16).padStart(4, '0')
+      continue
     }
+    out += ch
   }
+  return { text: out, repaired }
+}
+
+/**
+ * 失败现场摘要：首尾各留一段，中间省略多少字写清楚。
+ *
+ * 旧实现 `out.slice(0, 160)` 把正文后半段全砍了，而模型输出恰好经常被切在
+ * `"body": "# ...` 的半截处 —— 看上去更像「输出断了」，把排查引向错误方向（#24）。
+ */
+export function describeOutputExcerpt(text, { head = 120, tail = 120 } = {}) {
+  const s = String(text || '')
+  if (s.length <= head + tail + 20) return s
+  return s.slice(0, head) + '…（中间省略 ' + (s.length - head - tail) + ' 字）…' + s.slice(-tail)
+}
+
+/** 解析出来的对象 → 知识卡（返回 null = 解析成功但内容不合格 / 不值得保存）。 */
+function cardFromParsedJson(parsed) {
   if (!parsed || parsed.save === false) return { save: false }
   // 追加已有卡片：append_to 命中的优先级最高
   if (parsed.append_to) {
@@ -409,6 +454,69 @@ export function parseCaptureJson(text) {
   return finishCard(parsed, title, body)
 }
 
+/**
+ * 解析模型输出：返回「卡片 + 解析诊断」。
+ *
+ * 候选串顺序（#24）：原样 → 截 \`{ … }\` → 各自的「字符串内裸控制字符已转义」版本。
+ * 只要有一个 JSON.parse 成功就停在那一个上（解析成功但语义不合格时不再换候选 ——
+ * 换候选只会把同一份内容再判一遍，与旧实现行为一致）。
+ *
+ * @returns {{ card: object|null, parsed: boolean, error: string, repaired: boolean }}
+ *   parsed=false → 所有候选都没能 JSON.parse（error 里是**原始**报错，不再吞掉）
+ *   parsed=true  → JSON 解析成功；card=null 表示内容不合格 / 不值得保存
+ */
+export function parseCaptureJsonDetailed(text) {
+  if (!text) return { card: null, parsed: false, error: '空输出', repaired: false }
+  // 去掉可能的 ```json 围栏
+  const cleaned = String(text).replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, '').trim()
+  const bases = [cleaned]
+  const start = cleaned.indexOf('{')
+  const end = cleaned.lastIndexOf('}')
+  if (start >= 0 && end > start) bases.push(cleaned.slice(start, end + 1))
+  const candidates = []
+  for (const base of bases) candidates.push({ text: base, repaired: false })
+  for (const base of bases) {
+    const fixed = repairJsonControlChars(base)
+    if (fixed.repaired) candidates.push({ text: fixed.text, repaired: true })
+  }
+  let lastError = ''
+  for (const candidate of candidates) {
+    let parsed
+    try {
+      parsed = JSON.parse(candidate.text)
+    } catch (error) {
+      lastError = String((error && error.message) || error)
+      continue
+    }
+    return { card: cardFromParsedJson(parsed), parsed: true, error: '', repaired: candidate.repaired }
+  }
+  return { card: null, parsed: false, error: lastError || '输出不是合法 JSON', repaired: false }
+}
+
+/** 兼容旧签名：解析成卡片；解析失败 / 内容不合格返回 null。 */
+export function parseCaptureJson(text) {
+  return parseCaptureJsonDetailed(text).card
+}
+
+/**
+ * 撞到输出上限后的重试上限序列（#24）：一路翻倍到 schema 上限，不再只翻一次。
+ *
+ * 旧实现 index.js 里只做一次 倍=2 的重试：1200 → 2400 仍不够就退成原文卡，
+ * 尽管 4000 本来装得下。抽成纯函数，便于单测这条序列。
+ *
+ * @returns {number[]} 例如 start=1200, cap=4000 → [2400, 4000]；start>=cap → []
+ */
+export function maxTokenLadder(start, cap = MAX_CAPTURE_MAX_TOKENS) {
+  const out = []
+  const ceiling = Number(cap) || MAX_CAPTURE_MAX_TOKENS
+  let cur = Number(start) || DEFAULT_CAPTURE_MAX_TOKENS
+  while (cur < ceiling) {
+    cur = Math.min(cur * 2, ceiling)
+    out.push(cur)
+  }
+  return out
+}
+
 /** 标题是否「像标题」：≥4 个字母/数字字符，且不是碎片（错位开头 / 未完结结尾）。 */
 export function isUsableTitle(title) {
   const t = String(title || '').trim()