@restregular/dsh-memory 0.35.1 → 0.35.3
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/CHANGELOG.md +13 -0
- package/lib/panel.js +4 -3
- package/lib/provider/apply.js +5 -0
- package/lib/provider/hooks.js +17 -5
- package/lib/provider/index.js +40 -2
- package/lib/tools/apply.js +17 -1
- package/lib/tools/index.js +21 -9
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,19 @@
|
|
|
2
2
|
|
|
3
3
|
本项目的版本记录。安装 id 与 npm 版本一一对应。
|
|
4
4
|
|
|
5
|
+
## 0.35.3 — 钩子否决保存时自动带上关联规则 ID
|
|
6
|
+
|
|
7
|
+
- **问题**:钩子拒绝一条记忆写入时,报错只说「钩子『记忆内容规范(概括句:正文)』判定不符合要求」,模型看不到这条校验代码挂在**哪条规则记忆**上 —— 脚本的 `message` 往往只讲"缺什么",模型想按规则全文改对却无从取起。
|
|
8
|
+
- **修法**:`HookOutcome.hook` 带上 `ruleId`(钩子创建时由 `memory_save.hookCode` 关联的规则记忆 id);`before-save` 否决时报错自动追加一行「关联规则记忆:<完整 id>(用 memory_get("<8位短 id>") 取全文,按规则改好后重试)」。`memory_hooks run` 的判定说明、试跑 outcome 也带上同一个 ruleId。没有关联规则的手动钩子不会凭空造出这一行。
|
|
9
|
+
- 回归守卫:`hooks.test.ts` 加两条(报错带 ruleId + memory_get 提示 / 裸钩子不伪造 ruleId,试跑 outcome 带 ruleId),`bundled-skills.test.ts` 加一条静态守卫。全套 641 tests / 640 pass / 1 skipped。
|
|
10
|
+
|
|
11
|
+
## 0.35.2 — 修复「未批准的新脚本无法试跑」:试跑改按 id 精确执行
|
|
12
|
+
|
|
13
|
+
- **问题(再次实机验证发现)**:技能 `memory-hook-scripts` 的上手流程第一步就是「先 `memory_hooks run` 试跑样例,再上线」。但 0.35.0/0.35.1 的 `run` 走的是 `runHooks(phase, ...)`,而 `runHooks` 会在 `HookStore.forRun()` 里过滤掉**未批准**的钩子(审批门禁放在存储层是对的),于是刚保存、还没批准的新脚本试跑时永远报「脚本没有命中这次输入(作用域/类型过滤把它排除了)」—— 实际上是审批门禁挡的,报错还说错了原因。流程直接走不通。
|
|
14
|
+
- **修法**:新增 `runHookTrial(id, input)` —— 按 id 精确跑**指定的那一条**,绕过审批门禁,且不记统计(试跑不是真实运行)。它不写记忆、不改数据,只是把脚本跑一遍拿返回值,所以绕过门禁是安全的;真实运行(保存前 / 保存后 / 注入前)仍走原来的审批门禁。`memory_hooks run` 与面板「试跑」都改用它,不再用 phase+scope/kind 二次过滤。
|
|
15
|
+
- **附带修复**:`memory_save` 的结果渲染此前忽略了 `hook` 字段,带 `hookCode` 保存后只说「已保存记忆」,Agent 不知道脚本挂没挂上、是不是还在等批准。现在回传「随附规则代码 <id>(<时机>):已获批准 / 用户拒绝·不会运行 / 等待批准超时·不会运行 / 当前环境无法审批·不会运行」。
|
|
16
|
+
- 回归守卫:`bundled-skills.test.ts` 加两条(run 走 runHookTrial、memory_save 渲染回传 hook),`hooks.test.ts` 加两条(未批准也能按 id 精确试跑且不记统计、不存在的 id 返回空)。全套 638 tests / 637 pass / 1 skipped。
|
|
17
|
+
|
|
5
18
|
## 0.35.1 — 修复 0.35.0 实机验证发现的两个问题
|
|
6
19
|
|
|
7
20
|
- **问题 1:随包技能 `memory-hook-scripts` 加载不到**。两个工具的描述都引导 Agent 用 `skill` 工具加载它,但实机 `skill("memory-hook-scripts")` 报 unknown。根因是冷启动丢注册:`mountBundledSkills` 在 apply 里用 `ctx.get('skills')` 一次性取样,而 `skills` 服务由宿主核心提供、常晚于本插件 apply 就绪 —— 取到 undefined 且不会重试,技能永久消失(与 0.8.x 那次插件冷启动丢注册同一个坑)。改为在 apply 里用 `ctx.inject(['skills'], scope => mountBundledSkills(scope))` 等服务就绪后再挂,且放在独立 inject 回调里,不把整条 entry 拖成 PENDING。
|
package/lib/panel.js
CHANGED
|
@@ -1297,13 +1297,14 @@ async function handle(ctx, routePath, req, res) {
|
|
|
1297
1297
|
}
|
|
1298
1298
|
|
|
1299
1299
|
if (action === 'run') {
|
|
1300
|
-
if (typeof memory.
|
|
1300
|
+
if (typeof memory.runHookTrial !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供记忆钩子试跑接口(请升级 @restregular/dsh-memory)')
|
|
1301
1301
|
const id = typeof body.id === 'string' ? body.id : ''
|
|
1302
1302
|
const content = typeof body.content === 'string' ? body.content : ''
|
|
1303
1303
|
if (content.trim() === '') throw new ApiError(400, 'HOOK_CONTENT_REQUIRED', 'content 不能为空(试跑要一段样例正文)')
|
|
1304
1304
|
const hook = typeof memory.getHook === 'function' ? memory.getHook(id) : undefined
|
|
1305
1305
|
if (hook === undefined) throw new ApiError(404, 'HOOK_NOT_FOUND', '没有找到这个钩子')
|
|
1306
|
-
|
|
1306
|
+
// 0.35.2:按 id 精确试跑、绕过审批门禁 —— 新脚本未批准时也要能先看判断结果。
|
|
1307
|
+
const outcomes = memory.runHookTrial(id, {
|
|
1307
1308
|
memory: {
|
|
1308
1309
|
scope: hook.scopes[0] ?? 'global',
|
|
1309
1310
|
kind: hook.kinds[0] ?? 'rule',
|
|
@@ -1313,7 +1314,7 @@ async function handle(ctx, routePath, req, res) {
|
|
|
1313
1314
|
},
|
|
1314
1315
|
tool: 'panel',
|
|
1315
1316
|
})
|
|
1316
|
-
writeJson(res, { ok: true, value: { outcomes
|
|
1317
|
+
writeJson(res, { ok: true, value: { outcomes } })
|
|
1317
1318
|
return
|
|
1318
1319
|
}
|
|
1319
1320
|
|
package/lib/provider/apply.js
CHANGED
|
@@ -430,6 +430,11 @@ export class CordisMemoryService extends Service {
|
|
|
430
430
|
return this.impl.runHooks(phase, input)
|
|
431
431
|
}
|
|
432
432
|
|
|
433
|
+
/** 试跑指定钩子(绕过审批门禁,不写记忆、不记统计)。 */
|
|
434
|
+
runHookTrial(id , input ) {
|
|
435
|
+
return this.impl.runHookTrial(id, input)
|
|
436
|
+
}
|
|
437
|
+
|
|
433
438
|
parseForInject(records , sessionId ) {
|
|
434
439
|
return this.impl.parseForInject(records, sessionId)
|
|
435
440
|
}
|
package/lib/provider/hooks.js
CHANGED
|
@@ -118,7 +118,8 @@ const PHASE_ENTRY = {
|
|
|
118
118
|
|
|
119
119
|
/** 单个钩子的运行结果。 */
|
|
120
120
|
|
|
121
|
-
|
|
121
|
+
|
|
122
|
+
|
|
122
123
|
|
|
123
124
|
|
|
124
125
|
|
|
@@ -416,13 +417,13 @@ export class HookStore {
|
|
|
416
417
|
* 但**永远不会被执行**。把闸门放在存储层而不是各个调用点,是因为调用点有四个
|
|
417
418
|
* (保存前 / 保存后 / 注入前 / 试跑),漏一个就是一条绕过审批的路径。
|
|
418
419
|
*/
|
|
419
|
-
forRun(phase , target , settings ) {
|
|
420
|
+
forRun(phase , target , settings , ignoreApproval = false) {
|
|
420
421
|
this.load()
|
|
421
422
|
return this.hooks.filter((hook) =>
|
|
422
423
|
hook.enabled
|
|
423
424
|
&& hook.phase === phase
|
|
424
425
|
&& hookApplies(hook, target)
|
|
425
|
-
&& !hookNeedsApproval(hook, settings))
|
|
426
|
+
&& (ignoreApproval || !hookNeedsApproval(hook, settings)))
|
|
426
427
|
}
|
|
427
428
|
|
|
428
429
|
save(input , settings ) {
|
|
@@ -547,15 +548,26 @@ export function runHooks(
|
|
|
547
548
|
phase ,
|
|
548
549
|
input ,
|
|
549
550
|
settings ,
|
|
551
|
+
options = {},
|
|
550
552
|
) {
|
|
551
553
|
if (!settings.enabled) return []
|
|
552
554
|
const out = []
|
|
553
|
-
for (const hook of store.forRun(
|
|
555
|
+
for (const hook of store.forRun(
|
|
556
|
+
phase,
|
|
557
|
+
{ scope: input.memory.scope, kind: input.memory.kind },
|
|
558
|
+
settings,
|
|
559
|
+
options.ignoreApproval === true,
|
|
560
|
+
)) {
|
|
554
561
|
const started = Date.now()
|
|
555
562
|
const result = runHookCode(hook.code, phase, input, settings)
|
|
556
563
|
const crashed = result.error !== undefined
|
|
557
564
|
const outcome = {
|
|
558
|
-
hook: {
|
|
565
|
+
hook: {
|
|
566
|
+
id: hook.id,
|
|
567
|
+
name: hook.name,
|
|
568
|
+
phase,
|
|
569
|
+
...(hook.ruleId !== undefined ? { ruleId: hook.ruleId } : {}),
|
|
570
|
+
},
|
|
559
571
|
// 崩溃时 ok 恒 true —— 调用方据此"不阻断"。
|
|
560
572
|
ok: crashed ? true : result.ok,
|
|
561
573
|
durationMs: Date.now() - started,
|
package/lib/provider/index.js
CHANGED
|
@@ -53,6 +53,7 @@ import {
|
|
|
53
53
|
describeOutcomes,
|
|
54
54
|
hashHookCode,
|
|
55
55
|
hookNeedsApproval,
|
|
56
|
+
runHookCode,
|
|
56
57
|
runHooks,
|
|
57
58
|
|
|
58
59
|
|
|
@@ -1051,11 +1052,41 @@ export class LocalMemoryService {
|
|
|
1051
1052
|
return answer.outcome === 'timeout' ? 'timeout' : answer.outcome === 'unavailable' ? 'unavailable' : 'rejected'
|
|
1052
1053
|
}
|
|
1053
1054
|
|
|
1054
|
-
/** 真正跑一批钩子(工具 /
|
|
1055
|
+
/** 真正跑一批钩子(工具 / 注入共用)。未批准的钩子不会执行。 */
|
|
1055
1056
|
runHooks(phase , input ) {
|
|
1056
1057
|
return runHooks(this.hooks, phase, input, this.hookSettings())
|
|
1057
1058
|
}
|
|
1058
1059
|
|
|
1060
|
+
/**
|
|
1061
|
+
* 试跑指定的一条钩子(memory_hooks run / 面板试跑)。
|
|
1062
|
+
*
|
|
1063
|
+
* 与 runHooks 唯一的区别是**绕过审批门禁**:新写的脚本还没批准时必须能先看判断
|
|
1064
|
+
* 结果,否则技能里"先 run 试跑再上线"的流程根本走不通。试跑不产生副作用 ——
|
|
1065
|
+
* 不写记忆、不改数据,只是把脚本跑一遍拿返回值;统计也不记(试跑不是真实运行)。
|
|
1066
|
+
*/
|
|
1067
|
+
runHookTrial(id , input ) {
|
|
1068
|
+
const hook = this.hooks.get(id)
|
|
1069
|
+
if (hook === undefined) return []
|
|
1070
|
+
const started = Date.now()
|
|
1071
|
+
const result = runHookCode(hook.code, hook.phase, input, this.hookSettings())
|
|
1072
|
+
const crashed = result.error !== undefined
|
|
1073
|
+
return [{
|
|
1074
|
+
hook: {
|
|
1075
|
+
id: hook.id,
|
|
1076
|
+
name: hook.name,
|
|
1077
|
+
phase: hook.phase,
|
|
1078
|
+
...(hook.ruleId !== undefined ? { ruleId: hook.ruleId } : {}),
|
|
1079
|
+
},
|
|
1080
|
+
ok: crashed ? true : result.ok,
|
|
1081
|
+
durationMs: Date.now() - started,
|
|
1082
|
+
...(result.message !== undefined ? { message: result.message } : {}),
|
|
1083
|
+
...(result.content !== undefined ? { content: result.content } : {}),
|
|
1084
|
+
...(result.drop === true ? { drop: true } : {}),
|
|
1085
|
+
...(crashed ? { error: result.error } : {}),
|
|
1086
|
+
...(result.logs.length > 0 ? { logs: result.logs.slice(0, 20) } : {}),
|
|
1087
|
+
}]
|
|
1088
|
+
}
|
|
1089
|
+
|
|
1059
1090
|
/**
|
|
1060
1091
|
* 注入前解析:把一批记录按 before-inject 钩子处理一遍。
|
|
1061
1092
|
*
|
|
@@ -3353,9 +3384,16 @@ export class LocalMemoryService {
|
|
|
3353
3384
|
const veto = outcomes.find((outcome) => outcome.error === undefined && !outcome.ok)
|
|
3354
3385
|
if (veto !== undefined) {
|
|
3355
3386
|
const why = veto.message !== undefined && veto.message !== '' ? veto.message : '内容不符合规则记忆的要求'
|
|
3387
|
+
// 0.35.3:把关联的规则记忆 id 自动带进报错。钩子只是规则的执行体,
|
|
3388
|
+
// 模型看到"哪个校验器拒了"还不够 —— 它要能立刻取规则全文才能改对,
|
|
3389
|
+
// 否则只能靠脚本 message 里那几句话猜。
|
|
3390
|
+
const ruleId = veto.hook.ruleId
|
|
3391
|
+
const ruleLine = ruleId !== undefined && ruleId !== ''
|
|
3392
|
+
? `\n关联规则记忆:${ruleId}(用 memory_get("${ruleId.slice(0, 8)}") 取全文,按规则改好后重试)。`
|
|
3393
|
+
: ''
|
|
3356
3394
|
throw memoryError(
|
|
3357
3395
|
'HOOK_REJECTED',
|
|
3358
|
-
`记忆未保存:钩子「${veto.hook.name}」判定不符合要求 —— ${why}\n`
|
|
3396
|
+
`记忆未保存:钩子「${veto.hook.name}」判定不符合要求 —— ${why}${ruleLine}\n`
|
|
3359
3397
|
+ '按提示改好 content 后重新调用 memory_save(这不是权限问题,不需要审批)。',
|
|
3360
3398
|
)
|
|
3361
3399
|
}
|
package/lib/tools/apply.js
CHANGED
|
@@ -138,9 +138,25 @@ export function apply(ctx , config = {}) {
|
|
|
138
138
|
|
|
139
139
|
register(tools.memory_save, (value, _args, exec) => {
|
|
140
140
|
const agent = (exec )?.agent
|
|
141
|
-
|
|
141
|
+
const head = value.deduped
|
|
142
142
|
? `已更新既有记忆(内容相同,去重):${value.id} @ ${renderScope(value.scope, agent)}`
|
|
143
143
|
: `已保存记忆 ${value.id} @ ${renderScope(value.scope, agent)}`
|
|
144
|
+
// 0.35.2:带 hookCode 时把钩子的登记 / 审批结局回给模型 —— 否则它不知道
|
|
145
|
+
// 脚本到底挂没挂上、是不是还在等批准(未批准 = 不会运行)。
|
|
146
|
+
const hook = value.hook
|
|
147
|
+
if (hook === undefined) return head
|
|
148
|
+
const approvalText = {
|
|
149
|
+
approved: '已获批准,会按设定时机运行',
|
|
150
|
+
rejected: '用户拒绝批准,**不会运行**(改脚本或让用户批准后才生效)',
|
|
151
|
+
timeout: '等待批准超时,**不会运行**',
|
|
152
|
+
unavailable: '当前环境无法审批,**不会运行**',
|
|
153
|
+
unsupported: '当前 provider 不支持钩子,脚本未登记',
|
|
154
|
+
'not-needed': '无需批准',
|
|
155
|
+
}
|
|
156
|
+
const state = hook.approval.startsWith('save-failed')
|
|
157
|
+
? `登记失败:${hook.approval.slice('save-failed: '.length)}`
|
|
158
|
+
: approvalText[hook.approval] ?? hook.approval
|
|
159
|
+
return `${head}\n随附规则代码 ${hook.id !== '' ? `${hook.id} ` : ''}(${hook.phase}):${state}`
|
|
144
160
|
})
|
|
145
161
|
|
|
146
162
|
register(tools.memory_search, (value, _args, exec) => {
|
package/lib/tools/index.js
CHANGED
|
@@ -329,8 +329,13 @@ import { canonicalWorkspacePath, defaultScopeDescription, normalizeScopeInput, r
|
|
|
329
329
|
|
|
330
330
|
|
|
331
331
|
|
|
332
|
-
|
|
332
|
+
|
|
333
333
|
|
|
334
|
+
|
|
335
|
+
|
|
336
|
+
|
|
337
|
+
|
|
338
|
+
|
|
334
339
|
|
|
335
340
|
|
|
336
341
|
|
|
@@ -365,7 +370,8 @@ import { canonicalWorkspacePath, defaultScopeDescription, normalizeScopeInput, r
|
|
|
365
370
|
|
|
366
371
|
/** 一次钩子运行的结果(试跑与真实运行同形)。 */
|
|
367
372
|
|
|
368
|
-
|
|
373
|
+
|
|
374
|
+
|
|
369
375
|
|
|
370
376
|
|
|
371
377
|
|
|
@@ -2510,13 +2516,16 @@ export function memoryHooksTool(opts )
|
|
|
2510
2516
|
|
|
2511
2517
|
// run:拿一段正文试跑,不写记忆。这是唯一能"先看效果再上线"的入口。
|
|
2512
2518
|
const hook = findHook(service, args.id ?? '')
|
|
2513
|
-
if (typeof service.
|
|
2514
|
-
throw new MemoryToolError('HOOKS_UNSUPPORTED', '当前 memory provider
|
|
2519
|
+
if (typeof service.runHookTrial !== 'function') {
|
|
2520
|
+
throw new MemoryToolError('HOOKS_UNSUPPORTED', '当前 memory provider 不支持记忆钩子试跑(请升级 @restregular/dsh-memory)')
|
|
2515
2521
|
}
|
|
2516
2522
|
const content = typeof args.content === 'string' && args.content.trim() !== ''
|
|
2517
2523
|
? args.content
|
|
2518
2524
|
: throwErr(new MemoryToolError('HOOK_CONTENT_REQUIRED', 'run 需要 content:拿一段正文让脚本跑一次'))
|
|
2519
|
-
|
|
2525
|
+
// 0.35.2:按 id 精确试跑这一条,绕过审批门禁。老写法用 phase+scope/kind
|
|
2526
|
+
// 再过滤一遍,未批准的钩子会被门禁挡掉、表现为"脚本没有命中",与
|
|
2527
|
+
// 技能里"先 run 试跑再上线"的流程直接矛盾。
|
|
2528
|
+
const input = {
|
|
2520
2529
|
memory: {
|
|
2521
2530
|
scope: (args.scopes ?? hook.scopes)[0] ?? 'global',
|
|
2522
2531
|
kind: (args.kinds ?? hook.kinds)[0] ?? 'rule',
|
|
@@ -2525,16 +2534,19 @@ export function memoryHooksTool(opts )
|
|
|
2525
2534
|
importance: 0.8,
|
|
2526
2535
|
},
|
|
2527
2536
|
tool: 'memory_hooks',
|
|
2528
|
-
}
|
|
2529
|
-
const mine =
|
|
2537
|
+
}
|
|
2538
|
+
const mine = service.runHookTrial(hook.id, input)
|
|
2530
2539
|
const verdict = mine[0]
|
|
2540
|
+
const ruleRef = verdict?.hook.ruleId !== undefined && verdict.hook.ruleId !== ''
|
|
2541
|
+
? `(关联规则记忆 ${verdict.hook.ruleId},可用 memory_get 取全文)`
|
|
2542
|
+
: ''
|
|
2531
2543
|
const note = verdict === undefined
|
|
2532
2544
|
? '脚本没有命中这次输入(作用域/类型过滤把它排除了)。'
|
|
2533
2545
|
: verdict.error !== undefined
|
|
2534
2546
|
? `脚本运行失败:${verdict.error}`
|
|
2535
2547
|
: verdict.ok
|
|
2536
|
-
?
|
|
2537
|
-
: `脚本判定:不通过 —— ${verdict.message ?? '(脚本没给 message)'}`
|
|
2548
|
+
? `脚本判定:通过。${ruleRef}`
|
|
2549
|
+
: `脚本判定:不通过 —— ${verdict.message ?? '(脚本没给 message)'}${ruleRef}`
|
|
2538
2550
|
return { action, hooks: [withApproval(hook)], outcomes: mine, note }
|
|
2539
2551
|
},
|
|
2540
2552
|
}
|