@restregular/dsh-memory 0.7.3 → 0.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +12 -3
- package/lib/client.js +29 -10
- package/lib/inject/apply.js +11 -2
- package/lib/inject/rules-delta.js +70 -0
- package/lib/inject/rules.js +118 -10
- package/lib/panel.js +9 -0
- package/lib/provider/apply.js +10 -0
- package/lib/provider/index.js +23 -0
- package/lib/provider/inject-settings.js +8 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -28,7 +28,7 @@ English: Local, durable memory for DeepSeek Harness — one npm package, one loa
|
|
|
28
28
|
| **印象形态** | 每轮只给每条记忆的短摘要;模型判断相关但需要细节时再 `memory_search` 取全文(可在面板关掉,退回长文召回) |
|
|
29
29
|
| **会话摘要** | 会话第一步注入一次「已有记忆」概览:项目 + global 按**重要度 × 新鲜度**挑几条,省得模型从头摸索 |
|
|
30
30
|
| **记忆使用策略** | 系统提示常驻段:什么时候该查记忆、查到怎么复用、查不到时低风险推断 / 高风险先问用户 |
|
|
31
|
-
| **硬性规则** | `kind: rule` 的记忆进系统提示常驻段(限量、可关)。能机械校验的规则应该做成钩子,提示词只做解释 |
|
|
31
|
+
| **硬性规则** | `kind: rule` 的记忆进系统提示常驻段(限量、可关);**新增/改过的规则会在旧会话的下一轮补一条提醒**(同一条只提醒一次)。能机械校验的规则应该做成钩子,提示词只做解释 |
|
|
32
32
|
| **五个工具** | `memory_save` / `memory_search` / `memory_list` / `memory_get` / `memory_forget`(摘要带 8 位 id,`memory_get` 直接取全文) |
|
|
33
33
|
| **管理面板** | 设置页「记忆」:记录(浏览 / 搜索 / 新建 / 编辑 / 删除)+ 设置(召回、摘要、印象、策略、规则、轮末提醒逐项开关、导入导出)、向量服务启停、模型与硬件、维护(卸载 / 清空) |
|
|
34
34
|
| **向量后端一键装** | 面板里选模型 → 下 llama.cpp 运行时 + 模型 → 托管 `llama-server` 进程;内置 8 个模型 + 硬件推荐 + 自定义 GGUF |
|
|
@@ -106,7 +106,7 @@ memory_save({
|
|
|
106
106
|
|
|
107
107
|
- **服务**:「向量服务」:状态、地址、启停开关、**模型与硬件**(见下)、维护(卸载向量服务 / 清空记忆数据,两步确认)
|
|
108
108
|
- **记录**(默认打开):顶部统计(记忆数 / 作用域数 / 待嵌入向量数)、搜索、按作用域筛选、**新建**(任意作用域 + 类型,类型里含 `rule`)、展开编辑 / 删除;列表放在独立的滚动容器里(记忆再多也不把面板撑长),滚动条是自定义的细圆头样式,从侧栏入口打开时容器还会跟着窗口长高;作用域下拉**动态枚举实际存在的作用域**(`global` 显示「全局」、project 显示 cwd、会话 scope 显示会话标题、自定义 scope 显示原名)
|
|
109
|
-
- **设置**:注入链路逐项开关 —— 每轮召回(topK / 预算)、印象形态(每条字数)、会话摘要(条数 / 预算)、记忆使用策略段、硬性规则段(条数 /
|
|
109
|
+
- **设置**:注入链路逐项开关 —— 每轮召回(topK / 预算)、印象形态(每条字数)、会话摘要(条数 / 预算)、记忆使用策略段、硬性规则段(条数 / 预算 / 变更提醒,并显示当前规则条数)、轮末提醒、侧栏入口;底部「数据」:导出全部 / 导入文件。改完**即保存**,不需要点按钮
|
|
110
110
|
|
|
111
111
|
> **导入 / 导出**:导出的是纯文本 —— 作用域、类型、内容、标签、重要度、时间戳,**没有向量**。导入时逐条走保存路径,按**当前模型重新嵌入**,并按「作用域 + 内容」去重(重复的计入「跳过」)。一次最多 5000 条。
|
|
112
112
|
|
|
@@ -177,7 +177,7 @@ provider 的配置在顶层,工具 / 注入 / 面板各占一个小节(合并前
|
|
|
177
177
|
impression: { enabled: true, chars: 120 } # 每条只给摘要,细节再 memory_search
|
|
178
178
|
digest: { enabled: true, topK: 8, tokenBudget: 400 } # 会话第一步的概览
|
|
179
179
|
policy: { enabled: true } # 系统提示:记忆使用策略
|
|
180
|
-
rules: { enabled: true, maxItems: 10, tokenBudget: 300 } # 系统提示:kind=rule
|
|
180
|
+
rules: { enabled: true, maxItems: 10, tokenBudget: 300, delta: true } # 系统提示:kind=rule(δ=旧会话补新规则)
|
|
181
181
|
turnEnd: { enabled: false } # 轮末提醒(下一轮开头提示落盘)
|
|
182
182
|
panel: { route: '/memory/api' }
|
|
183
183
|
```
|
|
@@ -189,6 +189,7 @@ provider 的配置在顶层,工具 / 注入 / 面板各占一个小节(合并前
|
|
|
189
189
|
|
|
190
190
|
- **注入分四层**:`recall`(每轮按问题检索)、`digest`(会话第一步给概览)、`policy`(系统提示常驻的使用策略)、`rules`(系统提示常驻的 `kind=rule` 规则),外加 `turnEnd`(轮末提醒,默认关)。每层独立开关,`inject.enabled: false` 全关。面板改过的值写在 `<storeDir>/settings.json`,**优先级高于这里的配置**。
|
|
191
191
|
- **写规则**:`memory_save({ kind: 'rule', content: '改 lib 必须同时改 source' })`。规则会进系统提示常驻段;能机械校验的规则更适合做成钩子,提示词只负责解释。
|
|
192
|
+
- **规则变更怎么进旧会话**:系统提示段本身每步都会按 store 快照重渲染,但那只改提示词文本、不产生任何对话消息,旧会话里的模型不会主动重读;而且常驻段有 token 预算,新规则可能被更重要的旧规则挤掉。所以 `rules.delta`(默认开)在一轮的第一步比一次「这个会话已经见过的规则行」与当前规则,把新增/改过的补成一条 `source.kind='memory'` 消息(旧会话重开、宿主重启都不会重复提醒);关掉它只影响这条提醒,常驻段照旧。
|
|
192
193
|
|
|
193
194
|
向量检索是**按配置启用**的:写了 `endpoint`、配了 `spawn`、或面板里装了本地后端才会碰网络,否则一个请求都不发,检索自动降级为纯词法(IDF + CJK bigram)。不需要自动召回就 `inject.enabled: false`。
|
|
194
195
|
|
|
@@ -320,6 +321,14 @@ tools/build-single-package.mjs 构建(产物契约检查 + 可选加载验证)
|
|
|
320
321
|
|
|
321
322
|
## 版本
|
|
322
323
|
|
|
324
|
+
- **0.9.0** —— **规则变更会跟进旧会话**:
|
|
325
|
+
- 以前在别的会话里新加一条 `kind=rule`,旧会话继续聊时只有系统提示段的文本会刷新 —— 不产生对话消息,模型未必会重读;而且规则段有 300 token 预算,新规则可能被更重要的旧规则挤出常驻段。
|
|
326
|
+
- 现在每轮第一步比一次「该系统提示里的规则行 ∪ 历史里注入过的增量行」与当前规则,把新增/改过的补成一条 `source.kind='memory'` 消息(与召回/摘要同一条卡片来源),只提醒没出现过的;新会话第一步不补(系统提示本来就全有)。
|
|
327
|
+
- 面板「设置 → 硬性规则」新增**变更提醒**开关(`rules.delta`,默认开);关掉只停这条提醒,常驻段与检索不受影响。
|
|
328
|
+
- **0.8.0** —— 「服务 → 维护」新增**重建全部向量**:
|
|
329
|
+
- 一键把所有记录的向量(内存 + 磁盘)作废、重新排队并按当前模型重嵌,用于换过模型或怀疑向量与内容对不上时修复;只显示在两个条件都满足时(配置了后端且启用),两步确认,后台执行、不阻塞请求。
|
|
330
|
+
- 进度看「待嵌入向量」:面板在有待嵌入时每 **1.5s** 自动刷新列表徽标与计数(上限 300 次);从其它标签切回「记录」也会立即刷新一次。
|
|
331
|
+
- 重建期间向量检索暂时只用词法,完成一条恢复一条。
|
|
323
332
|
- **0.7.3** —— 修复「编辑一条记忆后一直显示待嵌入」:
|
|
324
333
|
- 面板 `/update` 改内容时只删了内存里的向量、**没有把 `.vec` 标脏**,重启后旧向量仍在磁盘上,会被当成“已嵌入”继续用(而且内容已经变了)。现在旧向量在内存与磁盘上一并作废。
|
|
325
334
|
- 编辑后**立即重建这一条**的向量(不再等 60s 的定时回填);重建失败才留在队列里由重试兜底。
|
package/lib/client.js
CHANGED
|
@@ -678,12 +678,13 @@ window.__ModuleLoader__.load({
|
|
|
678
678
|
},
|
|
679
679
|
{
|
|
680
680
|
key: 'rules', title: '硬性规则',
|
|
681
|
-
desc: '把 kind=rule
|
|
681
|
+
desc: '把 kind=rule 的记忆放进系统提示常驻段;旧会话下一轮补一条新增/变更的规则。',
|
|
682
682
|
hint: '关闭只影响系统提示常驻段,记忆本身仍可被检索',
|
|
683
683
|
fields: [
|
|
684
684
|
{ k: 'enabled', label: '启用', type: 'bool' },
|
|
685
685
|
{ k: 'maxItems', label: '最多条数', type: 'num', min: 1, max: 40, step: 1 },
|
|
686
686
|
{ k: 'tokenBudget', label: 'token 预算', type: 'num', min: 50, max: 4000, step: 50 },
|
|
687
|
+
{ k: 'delta', label: '变更提醒', type: 'bool', hint: '旧会话在下一轮第一步补一条「新增/变更的规则」,同一条只提醒一次' },
|
|
687
688
|
],
|
|
688
689
|
},
|
|
689
690
|
{
|
|
@@ -789,7 +790,7 @@ window.__ModuleLoader__.load({
|
|
|
789
790
|
? h(Switch, {
|
|
790
791
|
key: field.k,
|
|
791
792
|
checked: Boolean(value[field.k]),
|
|
792
|
-
title: group.hint || field.label,
|
|
793
|
+
title: field.hint || group.hint || field.label,
|
|
793
794
|
onChange: (next) => patch(group.key, field.k, next),
|
|
794
795
|
})
|
|
795
796
|
: h('label', { className: 'set-field', key: field.k }, field.label, ' ',
|
|
@@ -898,8 +899,8 @@ window.__ModuleLoader__.load({
|
|
|
898
899
|
)
|
|
899
900
|
}
|
|
900
901
|
|
|
901
|
-
/** 待嵌入自动刷新:最多
|
|
902
|
-
const PENDING_POLL_LIMIT =
|
|
902
|
+
/** 待嵌入自动刷新:最多 300 次 × 1.5s(后端挂着时不无限轮询)。 */
|
|
903
|
+
const PENDING_POLL_LIMIT = 300
|
|
903
904
|
|
|
904
905
|
function MemoryPanel() {
|
|
905
906
|
const [records, setRecords] = React.useState([])
|
|
@@ -974,8 +975,8 @@ window.__ModuleLoader__.load({
|
|
|
974
975
|
}
|
|
975
976
|
|
|
976
977
|
/**
|
|
977
|
-
* 维护动作:卸载向量服务 /
|
|
978
|
-
*
|
|
978
|
+
* 维护动作:卸载向量服务 / 清空记忆数据 / 重建全部向量。前两者不可撤销,重建代价高,
|
|
979
|
+
* 都走两步确认(dangerAsk 记住当前等确认的那一项,第二次点击才真的发请求)。
|
|
979
980
|
*/
|
|
980
981
|
const maintenanceAction = async (which) => {
|
|
981
982
|
if (dangerAsk !== which) { setDangerAsk(which); setEmbedNotice(''); return }
|
|
@@ -984,8 +985,10 @@ window.__ModuleLoader__.load({
|
|
|
984
985
|
try {
|
|
985
986
|
const value = which === 'uninstall'
|
|
986
987
|
? await api('embed/uninstall', {})
|
|
987
|
-
|
|
988
|
-
|
|
988
|
+
: which === 'reindex'
|
|
989
|
+
? await api('embed/reindex', {})
|
|
990
|
+
// 服务端要求显式 confirm:"delete",避免任何一次误触就清库
|
|
991
|
+
: await api('data/wipe', { confirm: 'delete' })
|
|
989
992
|
setEmbedServer(value.embedServer ? { ...value.embedServer } : value)
|
|
990
993
|
if (which === 'uninstall') {
|
|
991
994
|
setEmbedNotice(value.removed
|
|
@@ -993,6 +996,9 @@ window.__ModuleLoader__.load({
|
|
|
993
996
|
: value.reason === 'EXTERNAL_BACKEND'
|
|
994
997
|
? '当前后端不在本插件管理的目录里(是你自己装的),没有删除任何东西。'
|
|
995
998
|
: '没有找到本插件安装的向量服务文件。')
|
|
999
|
+
} else if (which === 'reindex') {
|
|
1000
|
+
setPendingTick(0)
|
|
1001
|
+
setEmbedNotice(`已开始重建 ${value.records ?? 0} 条的向量;「待嵌入向量」会逐步下降,期间检索暂时只用词法。`)
|
|
996
1002
|
} else {
|
|
997
1003
|
setEmbedNotice(`已清空 ${value.removed ?? 0} 条记忆(${(value.scopes ?? []).length} 个作用域)。`)
|
|
998
1004
|
}
|
|
@@ -1033,7 +1039,7 @@ window.__ModuleLoader__.load({
|
|
|
1033
1039
|
const timer = setTimeout(() => {
|
|
1034
1040
|
setPendingTick((n) => n + 1)
|
|
1035
1041
|
load()
|
|
1036
|
-
},
|
|
1042
|
+
}, 1500)
|
|
1037
1043
|
return () => clearTimeout(timer)
|
|
1038
1044
|
}, [pendingTick, pending])
|
|
1039
1045
|
// 服务端 /status 给的 scope → label 映射(会话标题、project 的 cwd 只有服务端知道)
|
|
@@ -1151,6 +1157,8 @@ window.__ModuleLoader__.load({
|
|
|
1151
1157
|
onInstall: (override) => embedAction('install', override),
|
|
1152
1158
|
}),
|
|
1153
1159
|
)
|
|
1160
|
+
// 重建向量只在"配置了后端且启用"时有意义(maintenanceCard 在 configured 声明之前构建)。
|
|
1161
|
+
const canReindex = Boolean(embedServer && embedServer.enabled && (embedServer.configured === undefined ? Boolean(embedServer.baseUrl) : embedServer.configured))
|
|
1154
1162
|
// 维护区:DSH 卸载插件时不会给插件任何提问机会(就是 pnpm remove + 去掉
|
|
1155
1163
|
// bundles),所以"要不要留向量服务 / 要不要留记忆数据"只能在这里、卸载之前问。
|
|
1156
1164
|
const maintenanceCard = maintenance
|
|
@@ -1168,6 +1176,17 @@ window.__ModuleLoader__.load({
|
|
|
1168
1176
|
: h('button', { key: 'ask', disabled: embedBusy, onClick: () => maintenanceAction('uninstall') }, '卸载向量服务'))
|
|
1169
1177
|
: h('span', { className: 'muted' }, '未安装'),
|
|
1170
1178
|
),
|
|
1179
|
+
h('div', { className: 'maint-row' },
|
|
1180
|
+
h('span', { className: 'grow' }, `向量索引:${maintenance.records} 条`),
|
|
1181
|
+
canReindex
|
|
1182
|
+
? (maintenance.records > 0
|
|
1183
|
+
? (dangerAsk === 'reindex'
|
|
1184
|
+
? [h('button', { key: 'ok', className: 'danger', disabled: embedBusy, onClick: () => maintenanceAction('reindex') }, `确认重建 ${maintenance.records} 条的向量`),
|
|
1185
|
+
h('button', { key: 'no', disabled: embedBusy, onClick: () => setDangerAsk('') }, '取消')]
|
|
1186
|
+
: h('button', { key: 'ask', disabled: embedBusy, onClick: () => maintenanceAction('reindex') }, '重建全部向量'))
|
|
1187
|
+
: h('span', { className: 'muted' }, '无'))
|
|
1188
|
+
: h('span', { className: 'muted' }, '向量未启用'),
|
|
1189
|
+
),
|
|
1171
1190
|
h('div', { className: 'maint-row' },
|
|
1172
1191
|
h('span', { className: 'grow' }, `记忆数据:${maintenance.records} 条`),
|
|
1173
1192
|
maintenance.storeDir ? h('span', { className: 'muted path', title: maintenance.storeDir }, maintenance.storeDir) : null,
|
|
@@ -1233,7 +1252,7 @@ window.__ModuleLoader__.load({
|
|
|
1233
1252
|
return h('div', { className: 'memp' },
|
|
1234
1253
|
h('div', { className: 'tabs' },
|
|
1235
1254
|
h('button', { className: 'tab' + (tab === 'records' ? ' on' : ''), onClick: () => setTab('records') }, '服务'),
|
|
1236
|
-
h('button', { className: 'tab' + (tab === 'data' ? ' on' : ''), onClick: () => setTab('data') }, '记录'),
|
|
1255
|
+
h('button', { className: 'tab' + (tab === 'data' ? ' on' : ''), onClick: () => { if (tab !== 'data') load(); setTab('data') } }, '记录'),
|
|
1237
1256
|
h('button', { className: 'tab' + (tab === 'settings' ? ' on' : ''), onClick: () => setTab('settings') }, '设置'),
|
|
1238
1257
|
),
|
|
1239
1258
|
tab === 'settings' ? h(SettingsTab, {}) : tab === 'data' ? dataBody : overviewBody,
|
package/lib/inject/apply.js
CHANGED
|
@@ -6,6 +6,7 @@
|
|
|
6
6
|
* 2. digest —— 会话第一步给一次"已有记忆"的摘要
|
|
7
7
|
* 3. policy —— 系统提示里的「记忆使用策略」常驻段
|
|
8
8
|
* 4. rules —— 系统提示里的「硬性规则」段(kind='rule' 的记忆)
|
|
9
|
+
* 另有 rulesDelta —— 旧会话在下一轮补一条新增/变更的规则(0.9.0;随 rules 开关)
|
|
9
10
|
* 另有 turnEnd —— 轮末提醒(下一轮开头提示"上一轮若有结论就记一条"),默认关。
|
|
10
11
|
*
|
|
11
12
|
* Message construction MUST go through createUserMessage: the loop reads
|
|
@@ -33,6 +34,7 @@ import {
|
|
|
33
34
|
} from './inject.js'
|
|
34
35
|
import { renderDigestBlock } from './digest.js'
|
|
35
36
|
import { renderRulesBlock } from './rules.js'
|
|
37
|
+
import { ruleDeltaText } from './rules-delta.js'
|
|
36
38
|
import { POLICY_TEXT } from './policy.js'
|
|
37
39
|
import { normalizeInjectSettings, } from '../provider/inject-settings.js'
|
|
38
40
|
|
|
@@ -174,13 +176,20 @@ export function apply(ctx , config = {}) {
|
|
|
174
176
|
|
|
175
177
|
// 摘要(每个会话一次)、召回(每轮有新内容时)、轮末提醒(下一轮首步)合成
|
|
176
178
|
// 同一条消息:内容没变就什么都不加,避免一步两张卡片。
|
|
179
|
+
const settings = enabled ? settingsOf() : undefined
|
|
177
180
|
const parts = []
|
|
181
|
+
// 规则增量:别的会话新加/改过的规则,在本轮第一步给旧会话补一次。
|
|
182
|
+
// `delta !== false` 而不是 `=== true`:老 provider 的 settings 快照没有这个
|
|
183
|
+
// 字段时要按"开"处理,否则升级当天等于静默关掉。
|
|
184
|
+
if (settings && step === 1 && settings.rules.enabled && settings.rules.delta !== false) {
|
|
185
|
+
const delta = ruleDeltaText(agent, memory, settings.rules)
|
|
186
|
+
if (delta) parts.push(delta)
|
|
187
|
+
}
|
|
178
188
|
if (pendingNudge && step === 1) {
|
|
179
189
|
pendingNudge = false
|
|
180
190
|
parts.push(NUDGE_TEXT)
|
|
181
191
|
}
|
|
182
|
-
if (
|
|
183
|
-
const settings = settingsOf()
|
|
192
|
+
if (settings) {
|
|
184
193
|
if (settings.digest.enabled) {
|
|
185
194
|
const digest = await digester.maybeDigest(sessionIdOf(agent), scopes, (records) =>
|
|
186
195
|
renderDigestBlock(records, settings.digest)?.text ?? null)
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 规则增量(0.9.0):旧会话继续聊之前,把「这个会话还没见过的硬性规则」补一条消息。
|
|
3
|
+
*
|
|
4
|
+
* 为什么光刷新系统提示不够:规则段每步都会按 store 快照重渲染,但那条更新只改
|
|
5
|
+
* 系统提示文本、不产生任何对话消息 —— 模型在旧会话里接着聊时不会主动重读;
|
|
6
|
+
* 而且规则段有 token 预算,新规则还可能被更重要的旧规则挤出常驻段。
|
|
7
|
+
*
|
|
8
|
+
* 这里只做"读会话派生历史 + 算差集 + 渲染",宿主差异(拿不到 session / 拿不到
|
|
9
|
+
* listSync)一律降级为不提醒 —— 注入路径抛错会打断整个 agent 循环。
|
|
10
|
+
*/
|
|
11
|
+
|
|
12
|
+
import {
|
|
13
|
+
latestSystemText,
|
|
14
|
+
renderRulesDeltaBlock,
|
|
15
|
+
seenRuleLines,
|
|
16
|
+
unseenRules,
|
|
17
|
+
|
|
18
|
+
} from './rules.js'
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
/** 宿主 Session 上我们用到的那一小部分(派生历史是 surface 节点的缓存投影)。 */
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
/** provider 在增量侧需要的能力(缺一个就走"不提醒")。 */
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
/** 会话的模型可见历史;老宿主 / 半个加载失败时返回 undefined。 */
|
|
33
|
+
export function derivedHistoryOf(agent ) {
|
|
34
|
+
try {
|
|
35
|
+
const session = (agent )?.session
|
|
36
|
+
const derive = session?.deriveMessages
|
|
37
|
+
if (typeof derive !== 'function') return undefined
|
|
38
|
+
const history = derive.call(session)
|
|
39
|
+
return Array.isArray(history) ? (history ) : undefined
|
|
40
|
+
} catch {
|
|
41
|
+
return undefined
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* 增量块的正文;没有新增/变更(或这是会话的第一步)时返回 undefined。
|
|
47
|
+
*
|
|
48
|
+
* 规则范围与系统提示「硬性规则」段一致(`resolveReadScopes`,拿不到就 global),
|
|
49
|
+
* 免得提醒了本来就不该进常驻段的规则。只在一轮的第一步调用:增量消息会持久化,
|
|
50
|
+
* 每一步都算会重复;新会话(还没有系统提示)直接跳过 —— 系统提示这次就带全。
|
|
51
|
+
*/
|
|
52
|
+
export function ruleDeltaText(agent , memory , cfg ) {
|
|
53
|
+
const history = derivedHistoryOf(agent)
|
|
54
|
+
if (history === undefined || latestSystemText(history) === undefined) return undefined
|
|
55
|
+
let scopes = ['global']
|
|
56
|
+
try {
|
|
57
|
+
const resolved = memory.resolveReadScopes?.(agent)
|
|
58
|
+
if (Array.isArray(resolved) && resolved.length > 0) scopes = resolved
|
|
59
|
+
} catch { scopes = ['global'] }
|
|
60
|
+
let records
|
|
61
|
+
try {
|
|
62
|
+
records = memory.listSync?.({ scopes, kind: 'rule', limit: 100 }) ?? []
|
|
63
|
+
} catch {
|
|
64
|
+
return undefined
|
|
65
|
+
}
|
|
66
|
+
return renderRulesDeltaBlock(unseenRules(records, seenRuleLines(history)), cfg) ?? undefined
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
//# sourceURL=source/memory-inject/src/rules-delta.ts
|
package/lib/inject/rules.js
CHANGED
|
@@ -4,28 +4,136 @@
|
|
|
4
4
|
* 为什么放系统提示而不是每轮消息:规则要"一直在场",但每轮复制会膨胀并稀释
|
|
5
5
|
* 注意力;系统提示是每步都会看见的位置,且文本稳定时可以跟着前缀缓存。
|
|
6
6
|
* 只放"不可机械校验"的规则 —— 能写成检查的规则应该进钩子(代码强制)。
|
|
7
|
+
*
|
|
8
|
+
* 增量提醒(0.9.0):系统提示段每步都会按内存快照重渲染,但"规则是别的会话里
|
|
9
|
+
* 新加的"这件事只改文本、不产生任何对话消息;模型在旧会话里继续聊时未必会
|
|
10
|
+
* 重新读一遍系统提示,而且规则段有 token 预算,新规则可能被旧规则挤出常驻段。
|
|
11
|
+
* 所以 apply.ts 在每轮第一步把「这个会话还没见过的规则行」补成一条消息。
|
|
12
|
+
* 这里只放纯函数:渲染、从系统提示/历史消息里抽取规则行、算差集。
|
|
7
13
|
*/
|
|
8
14
|
|
|
9
15
|
import { estimateTokens } from '../provider/rerank.js'
|
|
10
16
|
|
|
11
17
|
|
|
12
|
-
const
|
|
18
|
+
export const RULES_HEADER =
|
|
19
|
+
'以下是必须遵守的硬性规则(来自 kind=rule 的长期记忆;除非用户明确要求破例,否则按它做):'
|
|
13
20
|
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
21
|
+
export const RULES_DELTA_HEADER =
|
|
22
|
+
'以下是新增或变更的硬性规则(来自 kind=rule 的长期记忆;从现在起按它做):'
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* 一条规则的渲染行。常驻段与增量块共用同一个格式 —— 增量靠"逐行比对"判断
|
|
26
|
+
* 会话是否已经见过某条规则,两边只要有一个字符不同就会重复提醒。
|
|
27
|
+
*/
|
|
28
|
+
export function ruleLine(record ) {
|
|
29
|
+
return `- ${record.content.replace(/\s+/g, ' ').slice(0, 240)}`
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
/** 规则排序:重要度优先,其次新的在前,最后按内容稳定排序(两个实例结果一致)。 */
|
|
33
|
+
export function orderRules(records ) {
|
|
34
|
+
return [...records].sort(
|
|
35
|
+
(a, b) =>
|
|
36
|
+
b.importance - a.importance ||
|
|
37
|
+
b.updatedAt - a.updatedAt ||
|
|
38
|
+
a.content.localeCompare(b.content),
|
|
39
|
+
)
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
function renderLines(records , header , cfg , budget ) {
|
|
43
|
+
let tokens = estimateTokens(header) + 4
|
|
19
44
|
const lines = []
|
|
20
|
-
for (const record of
|
|
21
|
-
const line =
|
|
45
|
+
for (const record of orderRules(records).slice(0, cfg.maxItems)) {
|
|
46
|
+
const line = ruleLine(record)
|
|
22
47
|
const cost = estimateTokens(line) + 1
|
|
23
|
-
if (tokens + cost >
|
|
48
|
+
if (tokens + cost > budget) break
|
|
24
49
|
lines.push(line)
|
|
25
50
|
tokens += cost
|
|
26
51
|
}
|
|
27
52
|
if (lines.length === 0) return null
|
|
28
|
-
return `${
|
|
53
|
+
return `${header}\n${lines.join('\n')}`
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
/** 渲染规则段(系统提示常驻)。重要性优先,新的在前;每条截 240 字,超出预算截断。 */
|
|
57
|
+
export function renderRulesBlock(records , cfg ) {
|
|
58
|
+
return renderLines(records, RULES_HEADER, cfg, cfg.tokenBudget)
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
/**
|
|
62
|
+
* 渲染"新增/变更的规则"块。预算比常驻段留宽一点:增量块本来就是常驻段装不下
|
|
63
|
+
* 时才需要的补充,用同一个 300 token 的上限容易把最该提醒的一条又截掉。
|
|
64
|
+
*/
|
|
65
|
+
export function renderRulesDeltaBlock(records , cfg ) {
|
|
66
|
+
return renderLines(records, RULES_DELTA_HEADER, cfg, Math.max(cfg.tokenBudget, 600))
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
/** 模型可见历史里的一小部分形状(只读;不依赖宿主的 Message 类型)。 */
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
|
|
76
|
+
/** 一条消息的纯文本(多个 text 块用换行连接)。 */
|
|
77
|
+
export function messageText(message ) {
|
|
78
|
+
return (message.content ?? [])
|
|
79
|
+
.filter((block) => block.type === 'text' && typeof block.text === 'string')
|
|
80
|
+
.map((block) => block.text )
|
|
81
|
+
.join('\n')
|
|
29
82
|
}
|
|
30
83
|
|
|
84
|
+
/**
|
|
85
|
+
* 从一段提示文本里抽出以 `header` 开头的段。段与段之间用一个空行分隔,
|
|
86
|
+
* 段内的行都是单行(渲染时已把空白折叠成空格)。
|
|
87
|
+
*/
|
|
88
|
+
export function extractSection(text , header ) {
|
|
89
|
+
const at = text.indexOf(header)
|
|
90
|
+
if (at < 0) return undefined
|
|
91
|
+
const rest = text.slice(at + header.length)
|
|
92
|
+
const end = rest.indexOf('\n\n')
|
|
93
|
+
return end < 0 ? rest : rest.slice(0, end)
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
/** 段里的条目行(以 `- ` 开头、已 trim 的行)。 */
|
|
97
|
+
export function sectionLines(section ) {
|
|
98
|
+
if (!section) return []
|
|
99
|
+
return section
|
|
100
|
+
.split('\n')
|
|
101
|
+
.map((line) => line.trim())
|
|
102
|
+
.filter((line) => line.startsWith('- '))
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
/** 模型可见历史里最新的那条非空系统提示(宿主可能在历史里追加多个系统节点)。 */
|
|
106
|
+
export function latestSystemText(history ) {
|
|
107
|
+
for (let i = history.length - 1; i >= 0; i--) {
|
|
108
|
+
const message = history[i]
|
|
109
|
+
if (message?.role !== 'system') continue
|
|
110
|
+
const text = messageText(message)
|
|
111
|
+
if (text.length > 0) return text
|
|
112
|
+
}
|
|
113
|
+
return undefined
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* 这个会话"已经看见过"的规则行 = 最新系统提示里的规则段
|
|
118
|
+
* ∪ 历史上注入过的增量块(同一条规则只会提醒一次,重启宿主也不会重复)。
|
|
119
|
+
*/
|
|
120
|
+
export function seenRuleLines(history ) {
|
|
121
|
+
const seen = new Set ()
|
|
122
|
+
const systemText = latestSystemText(history)
|
|
123
|
+
if (systemText !== undefined) {
|
|
124
|
+
for (const line of sectionLines(extractSection(systemText, RULES_HEADER))) seen.add(line)
|
|
125
|
+
}
|
|
126
|
+
for (const message of history) {
|
|
127
|
+
if (message.role !== 'user' || message.source?.kind !== 'memory') continue
|
|
128
|
+
for (const line of sectionLines(extractSection(messageText(message), RULES_DELTA_HEADER))) seen.add(line)
|
|
129
|
+
}
|
|
130
|
+
return seen
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/** 还没在这个会话里出现过的规则(按常驻段同一套行格式比对)。 */
|
|
134
|
+
export function unseenRules(records , seen ) {
|
|
135
|
+
return records.filter((record) => !seen.has(ruleLine(record)))
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
|
|
31
139
|
//# sourceURL=source/memory-inject/src/rules.ts
|
package/lib/panel.js
CHANGED
|
@@ -363,6 +363,15 @@ async function handle(ctx, routePath, req, res) {
|
|
|
363
363
|
writeJson(res, { ok: true, value: { ...out, ...(await memory.embedServerStatus()) } })
|
|
364
364
|
return
|
|
365
365
|
}
|
|
366
|
+
if (method === 'POST' && path === '/embed/reindex') {
|
|
367
|
+
if (typeof memory.reindexAll !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供向量重建接口(请升级 @restregular/dsh-memory)')
|
|
368
|
+
// 同步部分只作废旧向量 + 排队,真正的重嵌在后台跑,不阻塞请求;进度看 /status 的待嵌入计数。
|
|
369
|
+
const result = memory.reindexAll() ?? {}
|
|
370
|
+
const total = typeof result.total === 'number' ? result.total : 0
|
|
371
|
+
console.log(`[dsh-memory-panel] 开始重建全部向量:${total} 条`)
|
|
372
|
+
writeJson(res, { ok: true, value: { scheduled: true, records: total } })
|
|
373
|
+
return
|
|
374
|
+
}
|
|
366
375
|
if (method === 'POST' && path === '/data/wipe') {
|
|
367
376
|
if (typeof memory.wipeAllRecords !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供数据清理接口(请升级 @restregular/dsh-memory)')
|
|
368
377
|
const body = await readJsonBody(req)
|
package/lib/provider/apply.js
CHANGED
|
@@ -155,6 +155,16 @@ export class CordisMemoryService extends Service {
|
|
|
155
155
|
return this.impl.reindexRecord(scope, id)
|
|
156
156
|
}
|
|
157
157
|
|
|
158
|
+
/** 维护:重建全部向量(作废旧向量并重新嵌入)。 */
|
|
159
|
+
reindexAll() {
|
|
160
|
+
return this.impl.reindexAll()
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/** 维护:作废全部向量并按当前模型后台重嵌。 */
|
|
164
|
+
reindexAll() {
|
|
165
|
+
return this.impl.reindexAll()
|
|
166
|
+
}
|
|
167
|
+
|
|
158
168
|
/** 作用域别名(没有则 undefined)。 */
|
|
159
169
|
scopeName(scope ) {
|
|
160
170
|
return this.impl.scopeName(scope)
|
package/lib/provider/index.js
CHANGED
|
@@ -1296,6 +1296,29 @@ export class LocalMemoryService {
|
|
|
1296
1296
|
return true
|
|
1297
1297
|
}
|
|
1298
1298
|
|
|
1299
|
+
/**
|
|
1300
|
+
* 作废全部向量并按当前模型重新嵌入。给"换模型残留了旧向量 / 怀疑向量有问题"用:
|
|
1301
|
+
* 同步部分只清空 + 排队,真正的重嵌在后台跑(别让 HTTP 等几分钟)。
|
|
1302
|
+
* 返回排队条数;进度由面板的「待嵌入」计数与自动刷新体现。
|
|
1303
|
+
*/
|
|
1304
|
+
reindexAll() {
|
|
1305
|
+
if (!this.cfg.vector.enabled || !this.cfg.vector.configured) return { total: 0, queued: this.pendingEmbedCount }
|
|
1306
|
+
this.discoverScopes()
|
|
1307
|
+
let total = 0
|
|
1308
|
+
for (const s of this.store.allScopes()) {
|
|
1309
|
+
for (const id of s.records.keys()) {
|
|
1310
|
+
s.vectors.delete(id)
|
|
1311
|
+
s.embedPending.add(id)
|
|
1312
|
+
total += 1
|
|
1313
|
+
}
|
|
1314
|
+
s.vectorsDirty = true
|
|
1315
|
+
s.dirty = true
|
|
1316
|
+
}
|
|
1317
|
+
this.store.scheduleFlush()
|
|
1318
|
+
void this.backfillAll({ throttleMs: 50 }).catch(() => { /* 失败留给 60s 重试 */ })
|
|
1319
|
+
return { total, queued: this.pendingEmbedCount }
|
|
1320
|
+
}
|
|
1321
|
+
|
|
1299
1322
|
/**
|
|
1300
1323
|
* First-fill: embed the ENTIRE backlog (unlike backfillEmbeddings' single
|
|
1301
1324
|
* batch per scope), in throttled batches so a big import does not hammer
|
|
@@ -34,6 +34,12 @@
|
|
|
34
34
|
|
|
35
35
|
|
|
36
36
|
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
|
|
37
43
|
|
|
38
44
|
|
|
39
45
|
|
|
@@ -61,7 +67,7 @@ export const defaultInjectSettings = {
|
|
|
61
67
|
digest: { enabled: true, topK: 8, tokenBudget: 400 },
|
|
62
68
|
impression: { enabled: true, chars: 120 },
|
|
63
69
|
policy: { enabled: true },
|
|
64
|
-
rules: { enabled: true, maxItems: 10, tokenBudget: 300 },
|
|
70
|
+
rules: { enabled: true, maxItems: 10, tokenBudget: 300, delta: true },
|
|
65
71
|
turnEnd: { enabled: false },
|
|
66
72
|
sidebar: { enabled: false },
|
|
67
73
|
}
|
|
@@ -122,6 +128,7 @@ export function normalizeInjectSettings(raw , base = def
|
|
|
122
128
|
enabled: bool(rules.enabled, base.rules.enabled),
|
|
123
129
|
maxItems: clampInt(rules.maxItems, 1, 40, base.rules.maxItems),
|
|
124
130
|
tokenBudget: clampInt(rules.tokenBudget, 50, 4000, base.rules.tokenBudget),
|
|
131
|
+
delta: bool(rules.delta, base.rules.delta),
|
|
125
132
|
},
|
|
126
133
|
turnEnd: { enabled: bool(turnEnd.enabled, base.turnEnd.enabled) },
|
|
127
134
|
sidebar: { enabled: bool(sidebar.enabled, base.sidebar.enabled) },
|