dsh-memory-tiers 0.5.0 → 0.8.1

package/compaction.mjs

@@ -54,6 +54,10 @@ function eventRole(ev) {
 export async function compactSurface(session, mem, opts = {}) {
   const keepTurns = Math.max(0, Number(opts.keepTurns ?? 1))
   const archiveChars = Math.max(100, Number(opts.archiveChars ?? 1200))
+  // ★ 归档开关：autoCapture 已经把这一轮（问+答+工具）写进 L1 了，
+  //   这里再归档一次会把同一轮存两遍。所以调用方在"rows 已写成功"时传 archive:false，
+  //   只做"把历史换成占位"，不再抄一份进记忆。
+  const doArchive = opts.archive !== false
   const log = opts.log || console
 
   const nodes = session?.surface?.nodes
@@ -107,52 +111,55 @@ export async function compactSurface(session, mem, opts = {}) {
   const endSeq = sliceSeqs[sliceSeqs.length - 1]
 
   // ── 先把要丢的内容归档进记忆，写成功才动手丢 ──
-  const lines = []
-  let totalChars = 0
-  let dropped = 0
-  // ★ 只归档「真人在说」「模型在答」「工具结果」三类。
-  //   surface 里还混着 runtime-context（工作目录/沙箱策略）、skill-catalog（技能清单）、
-  //   time-context（时间快照）——这些是框架注入的，归档进去不仅没用，
-  //   还会把注入块（含记忆块自身）原样抄进记忆，形成自我污染。
-  const ARCHIVABLE = new Set(['user', 'model', 'tool'])
-  for (const seq of sliceSeqs) {
-    const ev = session.eventAt(seq)
-    if (!ev) continue
-    const src = (ev.data?.message ?? ev.data)?.source
-    if (!ARCHIVABLE.has(src?.kind)) { dropped++; continue }
-    const t = eventText(ev)
-    if (!t) { dropped++; continue }
-    const line = `${eventRole(ev)}: ${t}`
-    if (totalChars + line.length > archiveChars) {
-      // ★ 不能整段丢掉：至少保留能塞下的部分，否则归档变成一句「（还有 N 条略）」，
-      //   这个 bug 在第一次上线时真实发生过（3 条空归档躺在 L1 里）。
-      const room = archiveChars - totalChars
-      if (room > 60) {
-        lines.push(line.slice(0, room - 1) + '…')
-        totalChars += room
+  //   archive:false 时整段跳过（这一轮已经由 autoCapture 的 rows 写进 L1 了）。
+  let archived = 0
+  if (doArchive) {
+    const lines = []
+    let totalChars = 0
+    let dropped = 0
+    // ★ 只归档「真人在说」「模型在答」「工具结果」三类。
+    //   surface 里还混着 runtime-context（工作目录/沙箱策略）、skill-catalog（技能清单）、
+    //   time-context（时间快照）——这些是框架注入的，归档进去不仅没用，
+    //   还会把注入块（含记忆块自身）原样抄进记忆，形成自我污染。
+    const ARCHIVABLE = new Set(['user', 'model', 'tool'])
+    for (const seq of sliceSeqs) {
+      const ev = session.eventAt(seq)
+      if (!ev) continue
+      const src = (ev.data?.message ?? ev.data)?.source
+      if (!ARCHIVABLE.has(src?.kind)) { dropped++; continue }
+      const t = eventText(ev)
+      if (!t) { dropped++; continue }
+      const line = `${eventRole(ev)}: ${t}`
+      if (totalChars + line.length > archiveChars) {
+        // ★ 不能整段丢掉：至少保留能塞下的部分，否则归档变成一句「（还有 N 条略）」，
+        //   这个 bug 在第一次上线时真实发生过（3 条空归档躺在 L1 里）。
+        const room = archiveChars - totalChars
+        if (room > 60) {
+          lines.push(line.slice(0, room - 1) + '…')
+          totalChars += room
+        }
+        dropped += sliceSeqs.length - lines.length
+        break
       }
-      dropped += sliceSeqs.length - lines.length
-      break
+      lines.push(line)
+      totalChars += line.length
     }
-    lines.push(line)
-    totalChars += line.length
-  }
-  if (dropped > 0 && lines.length) lines.push(`…（另有 ${dropped} 条系统注入或过长内容未收录）`)
+    if (dropped > 0 && lines.length) lines.push(`…（另有 ${dropped} 条系统注入或过长内容未收录）`)
 
-  let archived = 0
-  if (lines.length && mem?.writeMany) {
-    try {
-      const rounds = userIdx.filter((i) => i < keepStart).length
-      const res = await mem.writeMany([{
-        text: `[归档] 前 ${rounds} 轮对话（已被压缩出上下文）：\n${lines.join('\n')}`,
-        speaker: 'archive',
-        channel: 'dialog',
-      }])
-      archived = Array.isArray(res) ? res.length : 1
-    } catch (err) {
-      // ★ 归档失败就绝不压缩：宁可上下文大，也不能丢内容
-      log.warn?.('[memory-tiers] 压缩前归档失败，放弃本次压缩：%s', err?.message ?? err)
-      return { compacted: false, removed: 0, archived: 0, reason: 'archive-failed' }
+    if (lines.length && mem?.writeMany) {
+      try {
+        const rounds = userIdx.filter((i) => i < keepStart).length
+        const res = await mem.writeMany([{
+          text: `[归档] 前 ${rounds} 轮对话（已被压缩出上下文）：\n${lines.join('\n')}`,
+          speaker: 'archive',
+          channel: 'dialog',
+        }])
+        archived = Array.isArray(res) ? res.length : 1
+      } catch (err) {
+        // ★ 归档失败就绝不压缩：宁可上下文大，也不能丢内容
+        log.warn?.('[memory-tiers] 压缩前归档失败，放弃本次压缩：%s', err?.message ?? err)
+        return { compacted: false, removed: 0, archived: 0, reason: 'archive-failed' }
+      }
     }
   }
 

package/dshllm.mjs

@@ -0,0 +1,141 @@
+/**
+ * 走 dsh 自己的会话模型（不需要额外的 key）
+ *
+ * 背景：融合判关系、摘要这类"小活"，用户希望直接跟着当前对话用的模型走——
+ *   对话用 flash 它就 flash，用 pro 它就 pro，不用再单独配一家 provider。
+ *
+ * dsh 有两个服务能给到这件事：
+ *   ctx.get('llm')                 → prepareCall({provider, model}, signal, configure)
+ *                                    官方插件 dsh-session-title-llm 就是这么打辅助请求的
+ *   ctx.get('agentDefaultModel')   → currentSelection() 返回 {provider, model, reasoningEffort}
+ *
+ * 流式返回，chunk 形状（照 dsh-llm 的 BlockAssembler）：
+ *   {type:'block-start'} {type:'text-delta', text} {type:'reasoning-delta', text}
+ *   {type:'block-end'} {type:'usage', usage} {type:'finish', reason}
+ * 我们只收 text-delta，reasoning-delta 一律丢掉（那就是思考过程）。
+ *
+ * 关思考：没有统一的 enable_thinking 开关。做法是从 modelInfo.reasoning.efforts
+ * 里取**最低档**（efforts 是从小到大排的），等价于这个模型能选的"最少思考"。
+ */
+
+const DEFAULT_TIMEOUT_MS = 30000
+
+export function createSessionCaller(getCtx, opts = {}) {
+  const log = opts.log
+  let cached
+  let cacheTried = false
+
+  /** 拿到 llm / agentDefaultModel 两个服务；拿不到就记下来不再反复试 */
+  function services() {
+    if (cached || cacheTried) return cached || null
+    cacheTried = true
+    try {
+      const ctx = typeof getCtx === 'function' ? getCtx() : getCtx
+      if (!ctx) return null
+      const llm = (typeof ctx.get === 'function' ? ctx.get('llm') : null) ?? ctx.llm
+      const dm = (typeof ctx.get === 'function' ? ctx.get('agentDefaultModel') : null) ?? ctx.agentDefaultModel
+      if (!llm || typeof llm.prepareCall !== 'function') return null
+      cached = { llm, dm }
+    } catch (err) {
+      log?.warn?.('[memory-tiers] 取 dsh llm 服务失败：%s', err?.message ?? err)
+    }
+    return cached || null
+  }
+
+  /** 当前会话模型：{provider, model, reasoningEffort} 或 null */
+  function selection() {
+    const s = services()
+    if (!s?.dm || typeof s.dm.currentSelection !== 'function') return null
+    try {
+      const sel = s.dm.currentSelection()
+      if (!sel?.provider || !sel?.model) return null
+      return sel
+    } catch { return null }
+  }
+
+  function available() {
+    return !!selection()
+  }
+
+  /** 关思考用：取模型支持的最低 reasoningEffort */
+  function lowestEffort(modelInfo) {
+    const efforts = modelInfo?.reasoning?.efforts
+    if (Array.isArray(efforts) && efforts.length && efforts[0]?.id) return efforts[0].id
+    return undefined
+  }
+
+  /**
+   * 打一次请求
+   * @returns {string} 模型输出的纯文本（已 trim）；失败抛错，由调用方回落
+   */
+  async function call({
+    system = '',
+    user = '',
+    maxTokens = 400,
+    temperature = 0,
+    disableThinking = true,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  }) {
+    const s = services()
+    if (!s) throw new Error('拿不到 dsh 的 llm 服务')
+    const sel = selection()
+    if (!sel) throw new Error('取不到当前会话模型（agentDefaultModel 未就绪）')
+
+    const signal = AbortSignal.timeout(timeoutMs)
+
+    // prepareCall 的第三个参数是 configure(controls, modelInfo)：
+    //   只能改 controls（推理强度/温度/上限），不能改路由（provider/model）
+    const call = await s.llm.prepareCall(
+      { provider: sel.provider, model: sel.model, maxTokens },
+      signal,
+      (controls, modelInfo) => {
+        const next = { ...controls }
+        if (temperature !== undefined) next.temperature = temperature
+        if (disableThinking) {
+          const effort = lowestEffort(modelInfo)
+          if (effort !== undefined) next.reasoningEffort = effort
+        }
+        return next
+      },
+    )
+
+    // ★ 不能再改 maxTokens / temperature：prepareCall 已经把配置冻住了，
+    //   事后改会触发 "prepared LLM call config changed before adapter dispatch"。
+    const options = {
+      ...call.config,
+      messages: [{ role: 'user', content: [{ type: 'text', text: String(user) }] }],
+      system: String(system || ''),
+      purpose: 'memory-tiers',
+      signal,
+    }
+
+    let text = ''
+    let finish = null
+    for await (const chunk of call.stream(options)) {
+      const t = chunk?.type
+      if (t === 'text-delta') text += chunk.text ?? ''
+      else if (t === 'finish') { finish = chunk.reason; break }
+      else if (t === 'error') finish = { kind: 'error', failure: { message: chunk?.message ?? '流式返回错误' } }
+      else if (t === 'usage') { /* 不记账：会话模型的用量算在对话账上 */ }
+    }
+
+    if (finish?.kind === 'error' || finish?.kind === 'aborted') {
+      throw new Error(String(finish?.failure?.message ?? finish?.kind ?? '会话模型调用失败'))
+    }
+    return { text: text.trim(), provider: sel.provider, model: sel.model }
+  }
+
+  /** 给设置页看的：能不能用、当前是哪个模型、支持的最低思考档 */
+  function info() {
+    const sel = selection()
+    if (!sel) return { available: false, reason: services() ? 'agentDefaultModel 未就绪' : '未取到 llm 服务' }
+    return {
+      available: true,
+      provider: sel.provider,
+      model: sel.model,
+      reasoningEffort: sel.reasoningEffort ?? null,
+    }
+  }
+
+  return { available, selection, call, info }
+}