dsh-plugin-om 0.0.59 → 0.0.61
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 +34 -19
- package/dist/client/OmConfigCard.d.ts.map +1 -1
- package/dist/client/OmWarningCard.d.ts +1 -2
- package/dist/client/OmWarningCard.d.ts.map +1 -1
- package/dist/client/definition.d.ts +3 -3
- package/dist/client/locales.d.ts +3 -5
- package/dist/client/locales.d.ts.map +1 -1
- package/dist/client/om-config-controller.d.ts +1 -4
- package/dist/client/om-config-controller.d.ts.map +1 -1
- package/dist/client.js +26 -35
- package/dist/client.js.map +1 -1
- package/dist/compress-loop.d.ts +5 -5
- package/dist/compress-loop.d.ts.map +1 -1
- package/dist/compress-tools.d.ts +21 -2
- package/dist/compress-tools.d.ts.map +1 -1
- package/dist/compress-view.d.ts +37 -4
- package/dist/compress-view.d.ts.map +1 -1
- package/dist/compress.d.ts +46 -27
- package/dist/compress.d.ts.map +1 -1
- package/dist/config.d.ts +2 -6
- package/dist/config.d.ts.map +1 -1
- package/dist/constants.d.ts +14 -2
- package/dist/constants.d.ts.map +1 -1
- package/dist/degrade.d.ts.map +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +1300 -848
- package/dist/om-event-append.d.ts +5 -0
- package/dist/om-event-append.d.ts.map +1 -0
- package/dist/om-event.d.ts +16 -17
- package/dist/om-event.d.ts.map +1 -1
- package/dist/precompress.d.ts +1 -1
- package/dist/precompress.d.ts.map +1 -1
- package/dist/recall.d.ts +12 -20
- package/dist/recall.d.ts.map +1 -1
- package/dist/recompress.d.ts +1 -1
- package/dist/reflect.d.ts +89 -0
- package/dist/reflect.d.ts.map +1 -0
- package/dist/semantic-recall.d.ts +11 -4
- package/dist/semantic-recall.d.ts.map +1 -1
- package/dist/skill/compaction-eval/scripts/compress.mjs +107 -17
- package/dist/skill/compaction-eval/scripts/prepare.mjs +3 -5
- package/dist/skill/compaction-eval/scripts/view.mjs +319 -104
- package/dist/thinking-binding.d.ts +3 -2
- package/dist/thinking-binding.d.ts.map +1 -1
- package/dist/types.d.ts +13 -12
- package/dist/types.d.ts.map +1 -1
- package/package.json +1 -1
package/dist/index.mjs
CHANGED
|
@@ -4,10 +4,10 @@ import { brandString } from "@deepseek-ai/dsh-brand";
|
|
|
4
4
|
import { CompactionId } from "@deepseek-ai/dsh-compaction";
|
|
5
5
|
import { BlockAssembler, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, freezeMessage, isAgentLoopRequest, markAgentLoopRequest } from "@deepseek-ai/dsh-llm";
|
|
6
6
|
import { scopeOf } from "@deepseek-ai/dsh-scope";
|
|
7
|
-
import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
|
|
7
|
+
import { SessionId, SessionSeq, appendPluginRecord } from "@deepseek-ai/dsh-session";
|
|
8
8
|
import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
|
|
9
|
-
import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
|
|
10
9
|
import { z } from "zod";
|
|
10
|
+
import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
|
|
11
11
|
import Schema from "@deepseek-ai/schemastery";
|
|
12
12
|
import { homedir } from "node:os";
|
|
13
13
|
import path from "node:path";
|
|
@@ -291,390 +291,29 @@ function buildCompactionEvalCommand(ctx) {
|
|
|
291
291
|
};
|
|
292
292
|
}
|
|
293
293
|
//#endregion
|
|
294
|
-
//#region
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
*
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
}
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
/**
|
|
318
|
-
* 插件自产消息的 producer-owned source kind(format v4 要求消息 source 为生产者自有
|
|
319
|
-
* kind,与宿主 v3→v4 迁移对本插件旧日志的产出一致;types.ts 把它声明进宿主
|
|
320
|
-
* MessageSourceMap,使 UserMessage.source 原生接受该形态)。
|
|
321
|
-
*/
|
|
322
|
-
const PLUGIN_SOURCE_KIND = "plugin:dsh-plugin-om";
|
|
323
|
-
/** 构造插件自产消息的 source(compactionId 仅替换检查点消息传入)。 */
|
|
324
|
-
function omSource(compactionId) {
|
|
325
|
-
return {
|
|
326
|
-
kind: PLUGIN_SOURCE_KIND,
|
|
327
|
-
...compactionId === void 0 ? {} : { compactionId }
|
|
328
|
-
};
|
|
329
|
-
}
|
|
330
|
-
/** 压缩日志标签名:<history>...</history> 包裹观察/反思日志块。 */
|
|
331
|
-
const HISTORY_TAG = "history";
|
|
332
|
-
/** 压缩日志块开标签的 tip 属性(对 AI 的提醒:本块是历史压缩产物,不要复述)。 */
|
|
333
|
-
const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
|
|
334
|
-
/**
|
|
335
|
-
* 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
|
|
336
|
-
* 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
|
|
337
|
-
*/
|
|
338
|
-
/** 压缩会话首条消息中预注入区间条目的标题行,评估脚本据此提取原文视图。 */
|
|
339
|
-
const INITIAL_HISTORY_HEADER = "区间当前条目(等同 getHistory 全区间返回):";
|
|
340
|
-
const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
|
|
341
|
-
/**
|
|
342
|
-
* 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
|
|
343
|
-
* CDATA 约定 + toolcall 结构)始终保留;<user_message> /
|
|
344
|
-
* <skill_content> / <ask-user-question> 的条目说明仅在块内存在对应条目时追加。
|
|
345
|
-
*/
|
|
346
|
-
function historyFormatNote(sections = {}) {
|
|
347
|
-
const parts = [
|
|
348
|
-
COMPLETE_MESSAGE_DEFINITION,
|
|
349
|
-
"<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
|
|
350
|
-
"<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
|
|
351
|
-
];
|
|
352
|
-
if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
|
|
353
|
-
if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
|
|
354
|
-
if (sections.askUserQuestion) parts.push("<ask-user-question index=\"N\"> 表示向用户提问,CDATA 内为逐题成对的 q:(提问)与 a:(用户回答)行,未作答的题记为 a:(未回答)");
|
|
355
|
-
return `<!-- ${parts.join(";")} -->`;
|
|
356
|
-
}
|
|
357
|
-
/** skill 工具名:toolcall 条目的工具名为该值时视为 skill 加载,<history> 块中以 <skill_content> 元素呈现。 */
|
|
358
|
-
const SKILL_TOOL_NAME = "skill";
|
|
359
|
-
/**
|
|
360
|
-
* 提问工具名:成功且问题与答案完整配对时视为合法 ask,失败调用按普通 toolcall 处理。
|
|
361
|
-
* 合法 ask 直接压缩需二次确认;未直接压缩的原始 ask 重写后以 q/a 形式保留。
|
|
362
|
-
*/
|
|
363
|
-
const ASK_USER_QUESTION_TOOL_NAME = "ask_user_question";
|
|
364
|
-
/**
|
|
365
|
-
* 压缩因 signal 中止而放弃时 compaction/end 的 error 标识(服务端写入、客户端过滤):
|
|
366
|
-
* 中止不是失败,客户端据此隐藏失败行(宿主不变量要求无 summary 的 end 必须带 error)。
|
|
367
|
-
*/
|
|
368
|
-
const COMPACTION_ABORTED_ERROR = "压缩已中止(signal aborted)";
|
|
369
|
-
/**
|
|
370
|
-
* 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
|
|
371
|
-
* 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
|
|
372
|
-
* (kind 'plugin' + plugin 字段)仅作读取防御保留。
|
|
373
|
-
*/
|
|
374
|
-
function isPluginOwnedSource(source) {
|
|
375
|
-
if (source?.kind === "compact-checkpoint") return true;
|
|
376
|
-
if (source?.kind === "plugin:dsh-plugin-om") return true;
|
|
377
|
-
if (source?.kind !== "plugin") return false;
|
|
378
|
-
return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
|
|
379
|
-
}
|
|
380
|
-
//#endregion
|
|
381
|
-
//#region src/logger.ts
|
|
382
|
-
/**
|
|
383
|
-
* 插件日志门面:step 为步骤级(debug)日志,按配置开关过滤;info/warn 始终输出。
|
|
384
|
-
* 导出 PluginLogger / makeLogger。
|
|
385
|
-
*/
|
|
386
|
-
/** 构建插件日志门面:统一加 PLUGIN_LABEL 前缀,step 按 debug 开关过滤。 */
|
|
387
|
-
function makeLogger(ctx, debug) {
|
|
388
|
-
return {
|
|
389
|
-
step(message) {
|
|
390
|
-
if (typeof debug === "function" ? debug() : debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
|
|
391
|
-
},
|
|
392
|
-
info(message) {
|
|
393
|
-
ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
|
|
394
|
-
},
|
|
395
|
-
warn(message) {
|
|
396
|
-
ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
|
|
397
|
-
}
|
|
398
|
-
};
|
|
399
|
-
}
|
|
400
|
-
//#endregion
|
|
401
|
-
//#region src/compaction-log.ts
|
|
402
|
-
/** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
|
|
403
|
-
const COMPACTION_LOG_PROVIDER = "om-compaction-log";
|
|
404
|
-
/** 压缩 pass 的中文标签(会话记录 label 用;未知阶段回落「压缩」)。 */
|
|
405
|
-
function phaseLabel(phase) {
|
|
406
|
-
if (phase === "observe") return "观察";
|
|
407
|
-
if (phase === "reflect") return "反思";
|
|
408
|
-
return "压缩";
|
|
409
|
-
}
|
|
410
|
-
/**
|
|
411
|
-
* 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
|
|
412
|
-
* 重压缩追加 `-重压缩`,失败追加 `-失败`。
|
|
413
|
-
*/
|
|
414
|
-
function compressionRecordLabel(phase, range, success, retry) {
|
|
415
|
-
return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
|
|
416
|
-
}
|
|
417
|
-
/** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
|
|
418
|
-
function failureText(failure) {
|
|
419
|
-
if (failure === void 0) return "无(压缩失败)";
|
|
420
|
-
const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
|
|
421
|
-
return `无(压缩失败:${failure.reason}${last})`;
|
|
422
|
-
}
|
|
423
|
-
/** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
|
|
424
|
-
function compressionInfo(info) {
|
|
425
|
-
const effort = info.reasoningEffort ?? "默认思考等级";
|
|
426
|
-
const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
|
|
427
|
-
return {
|
|
428
|
-
text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
|
|
429
|
-
provider: info.target.provider,
|
|
430
|
-
model: info.target.model
|
|
431
|
-
};
|
|
432
|
-
}
|
|
433
|
-
/**
|
|
434
|
-
* 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
|
|
435
|
-
* 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
|
|
436
|
-
* time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
|
|
437
|
-
* 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
|
|
438
|
-
*/
|
|
439
|
-
function seedEvent(type, seq, time, data, surfaceOp) {
|
|
440
|
-
return {
|
|
441
|
-
type,
|
|
442
|
-
seq,
|
|
443
|
-
time,
|
|
444
|
-
data,
|
|
445
|
-
...surfaceOp === void 0 ? {} : { surfaceOp }
|
|
446
|
-
};
|
|
447
|
-
}
|
|
448
|
-
/**
|
|
449
|
-
* 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
|
|
450
|
-
* 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
|
|
451
|
-
* 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
|
|
452
|
-
* 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
|
|
453
|
-
* 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
|
|
454
|
-
* 轮结束时刻与循环结束时刻。
|
|
455
|
-
*/
|
|
456
|
-
function buildCompressionSeed(messages, stats, label, info, system) {
|
|
457
|
-
const seed = [];
|
|
458
|
-
const push = (type, time, data, surfaceOp) => {
|
|
459
|
-
seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
|
|
460
|
-
};
|
|
461
|
-
let cursor = stats.startedAt;
|
|
462
|
-
const at = (time) => {
|
|
463
|
-
cursor = Math.max(cursor, time);
|
|
464
|
-
return cursor;
|
|
465
|
-
};
|
|
466
|
-
const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
|
|
467
|
-
push("subagent/descriptor", at(stats.startedAt), {
|
|
468
|
-
version: SUBAGENT_DESCRIPTOR_VERSION,
|
|
469
|
-
mode: "one-shot",
|
|
470
|
-
provider: COMPACTION_LOG_PROVIDER,
|
|
471
|
-
label
|
|
472
|
-
});
|
|
473
|
-
push("turn/start", at(stats.startedAt), { turn: 1 });
|
|
474
|
-
let step = 1;
|
|
475
|
-
let assistantIndex = 0;
|
|
476
|
-
let stepTime = stats.startedAt;
|
|
477
|
-
let stepOpen = false;
|
|
478
|
-
let pending = [];
|
|
479
|
-
const closeStep = () => {
|
|
480
|
-
if (!stepOpen) return;
|
|
481
|
-
for (const call of pending) {
|
|
482
|
-
if (executed.has(call.id)) continue;
|
|
483
|
-
const repair = createToolResultMessage({
|
|
484
|
-
callId: call.id,
|
|
485
|
-
content: [{
|
|
486
|
-
type: "text",
|
|
487
|
-
text: "压缩循环未执行此工具调用"
|
|
488
|
-
}],
|
|
489
|
-
isError: true
|
|
490
|
-
});
|
|
491
|
-
push("tool/result", at(stepTime), {
|
|
492
|
-
turn: 1,
|
|
493
|
-
step,
|
|
494
|
-
message: {
|
|
495
|
-
...repair,
|
|
496
|
-
id: `forked-tool-result-${call.id}-${uuid()}`
|
|
497
|
-
},
|
|
498
|
-
error: {
|
|
499
|
-
name: "ToolNotStartedError",
|
|
500
|
-
code: "TOOL_NOT_STARTED"
|
|
501
|
-
}
|
|
502
|
-
}, "append");
|
|
503
|
-
}
|
|
504
|
-
push("step/end", at(stepTime), {
|
|
505
|
-
turn: 1,
|
|
506
|
-
step
|
|
507
|
-
});
|
|
508
|
-
pending = [];
|
|
509
|
-
stepOpen = false;
|
|
510
|
-
};
|
|
511
|
-
for (const message of messages) if (message.role === "assistant") {
|
|
512
|
-
closeStep();
|
|
513
|
-
step += 1;
|
|
514
|
-
const round = stats.rounds[assistantIndex];
|
|
515
|
-
assistantIndex += 1;
|
|
516
|
-
const startAt = round?.startedAt ?? stepTime;
|
|
517
|
-
const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
|
|
518
|
-
push("step/start", at(startAt), {
|
|
519
|
-
turn: 1,
|
|
520
|
-
step
|
|
521
|
-
});
|
|
522
|
-
stepOpen = true;
|
|
523
|
-
const assistant = message;
|
|
524
|
-
const assistantTime = at(completedAt);
|
|
525
|
-
push("assistant/message", assistantTime, {
|
|
526
|
-
turn: 1,
|
|
527
|
-
step,
|
|
528
|
-
message: assistant,
|
|
529
|
-
stream: [],
|
|
530
|
-
...round?.usage === void 0 ? {} : { usage: round.usage }
|
|
531
|
-
}, "append");
|
|
532
|
-
stepTime = assistantTime;
|
|
533
|
-
pending = assistant.content.filter((block) => block.type === "tool-call");
|
|
534
|
-
for (const call of pending) {
|
|
535
|
-
if (!executed.has(call.id)) continue;
|
|
536
|
-
push("tool/call", at(stepTime), {
|
|
537
|
-
turn: 1,
|
|
538
|
-
step,
|
|
539
|
-
callId: call.id,
|
|
540
|
-
name: call.name,
|
|
541
|
-
arguments: call.arguments
|
|
542
|
-
});
|
|
543
|
-
}
|
|
544
|
-
} else if (message.role === "tool") push("tool/result", at(stepTime), {
|
|
545
|
-
turn: 1,
|
|
546
|
-
step,
|
|
547
|
-
message
|
|
548
|
-
}, "append");
|
|
549
|
-
else if (!stepOpen) {
|
|
550
|
-
const user = message;
|
|
551
|
-
push("step/start", at(stats.startedAt), {
|
|
552
|
-
turn: 1,
|
|
553
|
-
step
|
|
554
|
-
});
|
|
555
|
-
stepOpen = true;
|
|
556
|
-
if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
|
|
557
|
-
turn: 1,
|
|
558
|
-
step,
|
|
559
|
-
message: createSystemMessage(system)
|
|
560
|
-
}, "append");
|
|
561
|
-
push("user/message", at(stats.startedAt), {
|
|
562
|
-
...user,
|
|
563
|
-
source: { kind: "user" }
|
|
564
|
-
}, "append");
|
|
565
|
-
} else {
|
|
566
|
-
const user = message;
|
|
567
|
-
push("user/message", at(stepTime), user, "append");
|
|
568
|
-
}
|
|
569
|
-
closeStep();
|
|
570
|
-
if (info !== void 0) {
|
|
571
|
-
step += 1;
|
|
572
|
-
push("step/start", at(stats.completedAt), {
|
|
573
|
-
turn: 1,
|
|
574
|
-
step
|
|
575
|
-
});
|
|
576
|
-
push("assistant/message", at(stats.completedAt), {
|
|
577
|
-
turn: 1,
|
|
578
|
-
step,
|
|
579
|
-
message: createAssistantMessage({
|
|
580
|
-
content: [{
|
|
581
|
-
type: "text",
|
|
582
|
-
text: info.text
|
|
583
|
-
}],
|
|
584
|
-
source: {
|
|
585
|
-
provider: info.provider,
|
|
586
|
-
model: info.model
|
|
587
|
-
}
|
|
588
|
-
}),
|
|
589
|
-
stream: []
|
|
590
|
-
}, "append");
|
|
591
|
-
push("step/end", at(stats.completedAt), {
|
|
592
|
-
turn: 1,
|
|
593
|
-
step
|
|
594
|
-
});
|
|
595
|
-
}
|
|
596
|
-
push("turn/end", at(stats.completedAt), {
|
|
597
|
-
turn: 1,
|
|
598
|
-
reason: { kind: "completed" }
|
|
599
|
-
});
|
|
600
|
-
return seed;
|
|
601
|
-
}
|
|
602
|
-
/**
|
|
603
|
-
* 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
|
|
604
|
-
* ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
|
|
605
|
-
* delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
|
|
606
|
-
* om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
|
|
607
|
-
* subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
|
|
608
|
-
* logger.warn 并返回 undefined。
|
|
609
|
-
*/
|
|
610
|
-
async function recordCompressionSession(ctx, parentSession, options) {
|
|
611
|
-
const logger = makeLogger(ctx, options.debug);
|
|
612
|
-
try {
|
|
613
|
-
const header = parentSession.header;
|
|
614
|
-
const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
|
|
615
|
-
const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
|
|
616
|
-
const sessions = ctx.get("sessions");
|
|
617
|
-
if (sessions === void 0) {
|
|
618
|
-
logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
|
|
619
|
-
return;
|
|
620
|
-
}
|
|
621
|
-
const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
|
|
622
|
-
seed,
|
|
623
|
-
meta: {
|
|
624
|
-
...header.cwd === void 0 ? {} : { cwd: header.cwd },
|
|
625
|
-
parentSession: parentSession.id,
|
|
626
|
-
origin: "subagent",
|
|
627
|
-
delegationDepth: (header.delegationDepth ?? 0) + 1
|
|
628
|
-
}
|
|
629
|
-
});
|
|
630
|
-
const persistence = ctx.get("sessionPersistence");
|
|
631
|
-
if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
|
|
632
|
-
const write = await persistence.create(child.header);
|
|
633
|
-
try {
|
|
634
|
-
await write.append(child.snapshotEvents());
|
|
635
|
-
await write.flush();
|
|
636
|
-
} finally {
|
|
637
|
-
await write.close();
|
|
638
|
-
}
|
|
639
|
-
parentSession.append("subagent/catalog", {
|
|
640
|
-
version: 0,
|
|
641
|
-
childId: child.id,
|
|
642
|
-
childCreatedAt: child.header.createdAt,
|
|
643
|
-
mode: "one-shot",
|
|
644
|
-
label
|
|
645
|
-
});
|
|
646
|
-
await sessions.flush(parentSession);
|
|
647
|
-
return child.id;
|
|
648
|
-
} catch (error) {
|
|
649
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
650
|
-
logger.warn(`压缩会话记录子会话落盘失败: ${message}`);
|
|
651
|
-
return;
|
|
652
|
-
}
|
|
653
|
-
}
|
|
654
|
-
//#endregion
|
|
655
|
-
//#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
|
|
656
|
-
var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
657
|
-
/**
|
|
658
|
-
* Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
|
|
659
|
-
*
|
|
660
|
-
* Works with anything that has a `length` property and index access properties,
|
|
661
|
-
* including NodeList.
|
|
662
|
-
*
|
|
663
|
-
* @param {T[] | { length: number; [number]: T }} list
|
|
664
|
-
* @param {function (item: T, index: number, list:T[]):boolean} predicate
|
|
665
|
-
* @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac
|
|
666
|
-
* Allows injecting a custom implementation in tests (`Array.prototype` by default).
|
|
667
|
-
* @returns {T | undefined}
|
|
668
|
-
* @template {unknown} T
|
|
669
|
-
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
|
|
670
|
-
* @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
|
|
671
|
-
*/
|
|
672
|
-
function find(list, predicate, ac) {
|
|
673
|
-
if (ac === void 0) ac = Array.prototype;
|
|
674
|
-
if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
|
|
675
|
-
for (var i = 0; i < list.length; i++) if (hasOwn(list, i)) {
|
|
676
|
-
var item = list[i];
|
|
677
|
-
if (predicate.call(void 0, item, i, list)) return item;
|
|
294
|
+
//#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
|
|
295
|
+
var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
296
|
+
/**
|
|
297
|
+
* Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
|
|
298
|
+
*
|
|
299
|
+
* Works with anything that has a `length` property and index access properties,
|
|
300
|
+
* including NodeList.
|
|
301
|
+
*
|
|
302
|
+
* @param {T[] | { length: number; [number]: T }} list
|
|
303
|
+
* @param {function (item: T, index: number, list:T[]):boolean} predicate
|
|
304
|
+
* @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac
|
|
305
|
+
* Allows injecting a custom implementation in tests (`Array.prototype` by default).
|
|
306
|
+
* @returns {T | undefined}
|
|
307
|
+
* @template {unknown} T
|
|
308
|
+
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
|
|
309
|
+
* @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
|
|
310
|
+
*/
|
|
311
|
+
function find(list, predicate, ac) {
|
|
312
|
+
if (ac === void 0) ac = Array.prototype;
|
|
313
|
+
if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
|
|
314
|
+
for (var i = 0; i < list.length; i++) if (hasOwn(list, i)) {
|
|
315
|
+
var item = list[i];
|
|
316
|
+
if (predicate.call(void 0, item, i, list)) return item;
|
|
678
317
|
}
|
|
679
318
|
}
|
|
680
319
|
/**
|
|
@@ -7742,7 +7381,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
7742
7381
|
exports.onWarningStopParsing = onWarningStopParsing;
|
|
7743
7382
|
}));
|
|
7744
7383
|
//#endregion
|
|
7745
|
-
//#region src/
|
|
7384
|
+
//#region src/constants.ts
|
|
7746
7385
|
var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
|
|
7747
7386
|
var conventions = require_conventions();
|
|
7748
7387
|
exports.assign = conventions.assign;
|
|
@@ -7782,6 +7421,80 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
7782
7421
|
exports.onErrorStopParsing = domParser.onErrorStopParsing;
|
|
7783
7422
|
exports.onWarningStopParsing = domParser.onWarningStopParsing;
|
|
7784
7423
|
})))();
|
|
7424
|
+
/** 插件标识:日志前缀与历史日志的 source.plugin 取值。 */
|
|
7425
|
+
const PLUGIN_LABEL = "dsh-plugin-om";
|
|
7426
|
+
/**
|
|
7427
|
+
* 插件自产消息的 producer-owned source kind(format v4 要求消息 source 为生产者自有
|
|
7428
|
+
* kind,与宿主 v3→v4 迁移对本插件旧日志的产出一致;types.ts 把它声明进宿主
|
|
7429
|
+
* MessageSourceMap,使 UserMessage.source 原生接受该形态)。
|
|
7430
|
+
*/
|
|
7431
|
+
const PLUGIN_SOURCE_KIND = "plugin:dsh-plugin-om";
|
|
7432
|
+
/** 构造插件自产消息的 source(compactionId 仅替换检查点消息传入)。 */
|
|
7433
|
+
function omSource(compactionId) {
|
|
7434
|
+
return {
|
|
7435
|
+
kind: PLUGIN_SOURCE_KIND,
|
|
7436
|
+
...compactionId === void 0 ? {} : { compactionId }
|
|
7437
|
+
};
|
|
7438
|
+
}
|
|
7439
|
+
/** 压缩日志标签名:<history>...</history> 包裹观察/反思日志块。 */
|
|
7440
|
+
const HISTORY_TAG = "history";
|
|
7441
|
+
/** 压缩日志块开标签的 tip 属性(对 AI 的提醒:本块是历史压缩产物,不要复述)。 */
|
|
7442
|
+
const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
|
|
7443
|
+
/** 归档块标签名:反思把较早的 <history> 块深度压缩为 <archived-history>。 */
|
|
7444
|
+
const ARCHIVED_HISTORY_TAG = "archived-history";
|
|
7445
|
+
/** 归档块开标签的 tip 属性。 */
|
|
7446
|
+
const ARCHIVED_HISTORY_TIP = "此块已被深度压缩,如需原文细节请用 recall 查看";
|
|
7447
|
+
/**
|
|
7448
|
+
* 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
|
|
7449
|
+
* 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
|
|
7450
|
+
*/
|
|
7451
|
+
/** 压缩会话首条消息中预注入区间条目的标题行,评估脚本据此提取原文视图。 */
|
|
7452
|
+
const INITIAL_HISTORY_HEADER = "区间当前条目:";
|
|
7453
|
+
const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
|
|
7454
|
+
/**
|
|
7455
|
+
* 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
|
|
7456
|
+
* CDATA 约定 + toolcall 结构)始终保留;<user_message> /
|
|
7457
|
+
* <skill_content> / <ask-user-question> 的条目说明仅在块内存在对应条目时追加。
|
|
7458
|
+
*/
|
|
7459
|
+
function historyFormatNote(sections = {}) {
|
|
7460
|
+
const parts = [
|
|
7461
|
+
COMPLETE_MESSAGE_DEFINITION,
|
|
7462
|
+
"<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
|
|
7463
|
+
"<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
|
|
7464
|
+
];
|
|
7465
|
+
if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
|
|
7466
|
+
if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
|
|
7467
|
+
if (sections.askUserQuestion) parts.push("<ask-user-question index=\"N\"> 表示向用户提问,CDATA 内为逐题成对的 q:(提问)与 a:(用户回答)行,未作答的题记为 a:(未回答)");
|
|
7468
|
+
if (sections.keyWord) parts.push("<assistant start=\"A\" end=\"B\" key-word=\"K\"> 的正文是该区间的一句话摘要,K 为供 recall 检索原文的关键词");
|
|
7469
|
+
return `<!-- ${parts.join(";")} -->`;
|
|
7470
|
+
}
|
|
7471
|
+
/** skill 工具名:toolcall 条目的工具名为该值时视为 skill 加载,<history> 块中以 <skill_content> 元素呈现。 */
|
|
7472
|
+
const SKILL_TOOL_NAME = "skill";
|
|
7473
|
+
/** 手动加载 skill 的系统消息 source kind。 */
|
|
7474
|
+
const SKILL_INVOCATION_KIND = "skill-invocation";
|
|
7475
|
+
/**
|
|
7476
|
+
* 提问工具名:成功且问题与答案完整配对时视为合法 ask,失败调用按普通 toolcall 处理。
|
|
7477
|
+
* 合法 ask 直接压缩需二次确认;未直接压缩的原始 ask 重写后以 q/a 形式保留。
|
|
7478
|
+
*/
|
|
7479
|
+
const ASK_USER_QUESTION_TOOL_NAME = "ask_user_question";
|
|
7480
|
+
/**
|
|
7481
|
+
* 压缩因 signal 中止而放弃时 compaction/end 的 error 标识(服务端写入、客户端过滤):
|
|
7482
|
+
* 中止不是失败,客户端据此隐藏失败行(宿主不变量要求无 summary 的 end 必须带 error)。
|
|
7483
|
+
*/
|
|
7484
|
+
const COMPACTION_ABORTED_ERROR = "压缩已中止(signal aborted)";
|
|
7485
|
+
/**
|
|
7486
|
+
* 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
|
|
7487
|
+
* 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
|
|
7488
|
+
* (kind 'plugin' + plugin 字段)仅作读取防御保留。
|
|
7489
|
+
*/
|
|
7490
|
+
function isPluginOwnedSource(source) {
|
|
7491
|
+
if (source?.kind === "compact-checkpoint") return true;
|
|
7492
|
+
if (source?.kind === "plugin:dsh-plugin-om") return true;
|
|
7493
|
+
if (source?.kind !== "plugin") return false;
|
|
7494
|
+
return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
|
|
7495
|
+
}
|
|
7496
|
+
//#endregion
|
|
7497
|
+
//#region src/log-index.ts
|
|
7785
7498
|
/**
|
|
7786
7499
|
* 会话日志索引:完整消息索引与渲染。
|
|
7787
7500
|
* 导出 indexCompleteMessages(完整消息三类折叠索引,recall 与摘要共用同一套编号)、
|
|
@@ -8377,13 +8090,17 @@ function parseBlockEntries(blockText, blockSeq) {
|
|
|
8377
8090
|
}
|
|
8378
8091
|
const start = intAttr(el, "start");
|
|
8379
8092
|
const end = intAttr(el, "end");
|
|
8380
|
-
if (start !== void 0 && end !== void 0)
|
|
8381
|
-
|
|
8382
|
-
|
|
8383
|
-
|
|
8384
|
-
|
|
8385
|
-
|
|
8386
|
-
|
|
8093
|
+
if (start !== void 0 && end !== void 0) {
|
|
8094
|
+
const keyWord = el.getAttribute("key-word");
|
|
8095
|
+
entries.push({
|
|
8096
|
+
kind: "assistant",
|
|
8097
|
+
lo: start,
|
|
8098
|
+
hi: end,
|
|
8099
|
+
text,
|
|
8100
|
+
blockSeq,
|
|
8101
|
+
...keyWord === null || keyWord === "" ? {} : { keyWord }
|
|
8102
|
+
});
|
|
8103
|
+
}
|
|
8387
8104
|
} else if (el.nodeName === "skill_content") {
|
|
8388
8105
|
const index = intAttr(el, "index");
|
|
8389
8106
|
if (index !== void 0) {
|
|
@@ -8435,18 +8152,67 @@ function parseBlockEntries(blockText, blockSeq) {
|
|
|
8435
8152
|
if (entries.length === 0) return opaque();
|
|
8436
8153
|
return entries;
|
|
8437
8154
|
}
|
|
8155
|
+
/** 已处理的 ask 条目(q/a 形态,非失败 toolcall)。 */
|
|
8156
|
+
function isHandledAsk(entry) {
|
|
8157
|
+
return entry.kind === "assistant" && entry.toolName === "ask_user_question" && entry.toolArgs === void 0;
|
|
8158
|
+
}
|
|
8159
|
+
/** 转义 XML 属性值。 */
|
|
8160
|
+
function escapeAttr(value) {
|
|
8161
|
+
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """);
|
|
8162
|
+
}
|
|
8163
|
+
/** 把 skill 条目渲染为宿主 skill 引用的注入正文:两段结构按宿主格式重建,已有包裹原样使用。 */
|
|
8164
|
+
function skillInjectionText(name, text) {
|
|
8165
|
+
const sections = skillContentSections(text);
|
|
8166
|
+
const head = `<skill_content name="${escapeAttr(name)}">`;
|
|
8167
|
+
if (sections) return `${head}<skill_resources>${sections.resources}</skill_resources>\n\n<skill_instructions>${sections.instructions}</skill_instructions></skill_content>`;
|
|
8168
|
+
if (/^\s*<skill_content\b[^>]*>[\s\S]*<\/skill_content>\s*$/.test(text)) return text.trim();
|
|
8169
|
+
return `${head}${text}</skill_content>`;
|
|
8170
|
+
}
|
|
8438
8171
|
/**
|
|
8439
|
-
*
|
|
8440
|
-
*
|
|
8441
|
-
*
|
|
8172
|
+
* 归档视图:被归档 <history> 块的条目去掉 reasoning 与具名 skill。用户条目与已处理
|
|
8173
|
+
* ask 原样保留并作为分隔,其间连续的可定位 assistant 条目构成一个归档段;不可定位的
|
|
8174
|
+
* 遗留条目同样作为分隔原样保留。具名 skill 按名称去重保留最新一份,随结果返回。
|
|
8442
8175
|
*/
|
|
8443
|
-
function
|
|
8176
|
+
function buildArchiveView(blocks) {
|
|
8177
|
+
const skills = /* @__PURE__ */ new Map();
|
|
8444
8178
|
const entries = [];
|
|
8445
|
-
|
|
8446
|
-
|
|
8179
|
+
const segments = [];
|
|
8180
|
+
let open;
|
|
8181
|
+
const close = () => {
|
|
8182
|
+
if (open !== void 0) segments.push(open);
|
|
8183
|
+
open = void 0;
|
|
8184
|
+
};
|
|
8185
|
+
for (const block of blocks) for (const entry of parseBlockEntries(block.text, block.seq)) {
|
|
8186
|
+
if (entry.kind === "reasoning") continue;
|
|
8187
|
+
if (entry.toolName === "skill" && entry.skillName !== void 0 && entry.skillName !== "" && entry.lo !== void 0) {
|
|
8188
|
+
const name = entry.skillName;
|
|
8189
|
+
skills.delete(name);
|
|
8190
|
+
skills.set(name, {
|
|
8191
|
+
name,
|
|
8192
|
+
index: entry.lo,
|
|
8193
|
+
content: skillInjectionText(name, entry.text)
|
|
8194
|
+
});
|
|
8195
|
+
continue;
|
|
8196
|
+
}
|
|
8197
|
+
entries.push(entry);
|
|
8198
|
+
if (entry.kind === "user" || isHandledAsk(entry) || entry.lo === void 0 || entry.hi === void 0) {
|
|
8199
|
+
close();
|
|
8200
|
+
continue;
|
|
8201
|
+
}
|
|
8202
|
+
if (open === void 0) open = {
|
|
8203
|
+
lo: entry.lo,
|
|
8204
|
+
hi: entry.hi
|
|
8205
|
+
};
|
|
8206
|
+
else open.hi = Math.max(open.hi, entry.hi);
|
|
8207
|
+
}
|
|
8208
|
+
close();
|
|
8447
8209
|
return {
|
|
8448
|
-
|
|
8449
|
-
|
|
8210
|
+
view: {
|
|
8211
|
+
entries,
|
|
8212
|
+
...viewBounds(entries),
|
|
8213
|
+
segments
|
|
8214
|
+
},
|
|
8215
|
+
skills: [...skills.values()].sort((a, b) => a.index - b.index)
|
|
8450
8216
|
};
|
|
8451
8217
|
}
|
|
8452
8218
|
/**
|
|
@@ -8539,6 +8305,7 @@ function entryToElement(doc, entry) {
|
|
|
8539
8305
|
el.setAttribute("start", String(entry.lo));
|
|
8540
8306
|
el.setAttribute("end", String(entry.hi));
|
|
8541
8307
|
}
|
|
8308
|
+
if (entry.keyWord !== void 0) el.setAttribute("key-word", entry.keyWord);
|
|
8542
8309
|
appendCdataText(doc, el, entry.text);
|
|
8543
8310
|
return el;
|
|
8544
8311
|
}
|
|
@@ -8552,6 +8319,474 @@ function renderEntriesXml(entries) {
|
|
|
8552
8319
|
return entries.map((entry) => serializer.serializeToString(entryToElement(doc, entry))).join("\n");
|
|
8553
8320
|
}
|
|
8554
8321
|
//#endregion
|
|
8322
|
+
//#region src/om-event.ts
|
|
8323
|
+
/** 各类别对应的 plugin record 类型名(grammar:`plugin:` 后以 `/` 分段)。 */
|
|
8324
|
+
const OM_RECORD_TYPES = {
|
|
8325
|
+
"om/warning": "plugin:dsh-plugin-om/warning",
|
|
8326
|
+
"om/observe-pending": "plugin:dsh-plugin-om/observe-pending",
|
|
8327
|
+
"om/observe-invalidate": "plugin:dsh-plugin-om/observe-invalidate",
|
|
8328
|
+
"om/observe-summary": "plugin:dsh-plugin-om/observe-summary"
|
|
8329
|
+
};
|
|
8330
|
+
/** plugin record 类型名到 om 类别的反查表。 */
|
|
8331
|
+
const KIND_BY_RECORD_TYPE = new Map(Object.entries(OM_RECORD_TYPES).map(([kind, type]) => [type, kind]));
|
|
8332
|
+
/**
|
|
8333
|
+
* 解码一条会话事件为 om 私有事件:仅识别带 ignorable 标记且类型名属于本插件的
|
|
8334
|
+
* plugin record;类型不符、载荷非对象或字段缺失时返回 undefined。
|
|
8335
|
+
*/
|
|
8336
|
+
function readOmEvent(event) {
|
|
8337
|
+
if (event === void 0 || event === null || event.ignorable !== true) return void 0;
|
|
8338
|
+
const kind = KIND_BY_RECORD_TYPE.get(event.type);
|
|
8339
|
+
if (kind === void 0) return void 0;
|
|
8340
|
+
const payload = event.data;
|
|
8341
|
+
if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
|
|
8342
|
+
const rest = payload;
|
|
8343
|
+
switch (kind) {
|
|
8344
|
+
case "om/warning": {
|
|
8345
|
+
const { problem, message } = rest;
|
|
8346
|
+
if (typeof problem !== "string" || typeof message !== "string") return void 0;
|
|
8347
|
+
return {
|
|
8348
|
+
kind,
|
|
8349
|
+
data: {
|
|
8350
|
+
problem,
|
|
8351
|
+
message
|
|
8352
|
+
},
|
|
8353
|
+
seq: event.seq
|
|
8354
|
+
};
|
|
8355
|
+
}
|
|
8356
|
+
case "om/observe-pending": {
|
|
8357
|
+
const { triggerMessageIndex } = rest;
|
|
8358
|
+
if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
|
|
8359
|
+
return {
|
|
8360
|
+
kind,
|
|
8361
|
+
data: { triggerMessageIndex },
|
|
8362
|
+
seq: event.seq
|
|
8363
|
+
};
|
|
8364
|
+
}
|
|
8365
|
+
case "om/observe-invalidate": {
|
|
8366
|
+
const { pendingSeq } = rest;
|
|
8367
|
+
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
8368
|
+
return {
|
|
8369
|
+
kind,
|
|
8370
|
+
data: { pendingSeq },
|
|
8371
|
+
seq: event.seq
|
|
8372
|
+
};
|
|
8373
|
+
}
|
|
8374
|
+
case "om/observe-summary": {
|
|
8375
|
+
const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
|
|
8376
|
+
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
8377
|
+
if (typeof report !== "string") return void 0;
|
|
8378
|
+
if (typeof provider !== "string" || typeof model !== "string") return void 0;
|
|
8379
|
+
if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
|
|
8380
|
+
if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
|
|
8381
|
+
if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
|
|
8382
|
+
const parsedUsage = readTokenUsage(usage);
|
|
8383
|
+
if (parsedUsage === null) return void 0;
|
|
8384
|
+
return {
|
|
8385
|
+
kind,
|
|
8386
|
+
data: {
|
|
8387
|
+
pendingSeq,
|
|
8388
|
+
report,
|
|
8389
|
+
provider,
|
|
8390
|
+
model,
|
|
8391
|
+
startedAt,
|
|
8392
|
+
completedAt,
|
|
8393
|
+
durationMs,
|
|
8394
|
+
...recordSessionId === void 0 ? {} : { recordSessionId },
|
|
8395
|
+
...parsedUsage === void 0 ? {} : { usage: parsedUsage },
|
|
8396
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
8397
|
+
},
|
|
8398
|
+
seq: event.seq
|
|
8399
|
+
};
|
|
8400
|
+
}
|
|
8401
|
+
default: return;
|
|
8402
|
+
}
|
|
8403
|
+
}
|
|
8404
|
+
/** 校验有限数值字段(时间戳/耗时)。 */
|
|
8405
|
+
function isFiniteNumber(value) {
|
|
8406
|
+
return typeof value === "number" && Number.isFinite(value);
|
|
8407
|
+
}
|
|
8408
|
+
/** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
|
|
8409
|
+
function readTokenUsage(value) {
|
|
8410
|
+
if (value === void 0) return void 0;
|
|
8411
|
+
if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
|
|
8412
|
+
const usage = value;
|
|
8413
|
+
const { inputTokens, outputTokens } = usage;
|
|
8414
|
+
if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
|
|
8415
|
+
const result = {
|
|
8416
|
+
inputTokens,
|
|
8417
|
+
outputTokens
|
|
8418
|
+
};
|
|
8419
|
+
for (const key of [
|
|
8420
|
+
"totalTokens",
|
|
8421
|
+
"cacheReadTokens",
|
|
8422
|
+
"cacheWriteTokens",
|
|
8423
|
+
"reasoningTokens"
|
|
8424
|
+
]) {
|
|
8425
|
+
const field = usage[key];
|
|
8426
|
+
if (field === void 0) continue;
|
|
8427
|
+
if (!isFiniteNumber(field)) return null;
|
|
8428
|
+
result[key] = field;
|
|
8429
|
+
}
|
|
8430
|
+
return result;
|
|
8431
|
+
}
|
|
8432
|
+
function findOmEvents(session, kind) {
|
|
8433
|
+
const result = [];
|
|
8434
|
+
for (const event of session.snapshotEvents()) {
|
|
8435
|
+
const om = readOmEvent(event);
|
|
8436
|
+
if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
|
|
8437
|
+
}
|
|
8438
|
+
return result;
|
|
8439
|
+
}
|
|
8440
|
+
//#endregion
|
|
8441
|
+
//#region src/om-event-append.ts
|
|
8442
|
+
/**
|
|
8443
|
+
* om 私有事件写入:经宿主 appendPluginRecord 追加 plugin record。
|
|
8444
|
+
* 导出 appendOmEvent。仅服务端使用,读取侧见 om-event.ts。
|
|
8445
|
+
*/
|
|
8446
|
+
/** 追加一条 om 私有事件(ignorable,不进 surface),返回事件 seq。 */
|
|
8447
|
+
function appendOmEvent(session, kind, data) {
|
|
8448
|
+
const type = OM_RECORD_TYPES[kind];
|
|
8449
|
+
return appendPluginRecord(session, type, data);
|
|
8450
|
+
}
|
|
8451
|
+
//#endregion
|
|
8452
|
+
//#region src/degrade.ts
|
|
8453
|
+
/**
|
|
8454
|
+
* 降级报告:压缩流程中的挂载失败统一出口。
|
|
8455
|
+
* 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
|
|
8456
|
+
*
|
|
8457
|
+
* - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
|
|
8458
|
+
* 并向会话日志追加 ignorable 的 om 警告 plugin record(
|
|
8459
|
+
* 见 om-event.ts;客户端渲染为「功能降级」警告行);
|
|
8460
|
+
* 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
|
|
8461
|
+
* - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
|
|
8462
|
+
* - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
|
|
8463
|
+
*/
|
|
8464
|
+
/** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
|
|
8465
|
+
const DEGRADE_PROBLEMS = {
|
|
8466
|
+
"systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
|
|
8467
|
+
"tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
|
|
8468
|
+
"reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
|
|
8469
|
+
};
|
|
8470
|
+
/**
|
|
8471
|
+
* 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
|
|
8472
|
+
* 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
|
|
8473
|
+
* 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
|
|
8474
|
+
* 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
|
|
8475
|
+
*/
|
|
8476
|
+
function reportDegrade(session, logger, problem) {
|
|
8477
|
+
const message = DEGRADE_PROBLEMS[problem];
|
|
8478
|
+
let first = true;
|
|
8479
|
+
try {
|
|
8480
|
+
first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
|
|
8481
|
+
} catch {}
|
|
8482
|
+
if (!first) return;
|
|
8483
|
+
console.warn(`${PLUGIN_LABEL}: ${message}`);
|
|
8484
|
+
logger.warn(message);
|
|
8485
|
+
try {
|
|
8486
|
+
appendOmEvent(session, "om/warning", {
|
|
8487
|
+
problem,
|
|
8488
|
+
message
|
|
8489
|
+
});
|
|
8490
|
+
} catch (error) {
|
|
8491
|
+
const text = error instanceof Error ? error.message : String(error);
|
|
8492
|
+
logger.warn(`om 警告事件追加失败: ${text}`);
|
|
8493
|
+
}
|
|
8494
|
+
}
|
|
8495
|
+
//#endregion
|
|
8496
|
+
//#region src/logger.ts
|
|
8497
|
+
/**
|
|
8498
|
+
* 插件日志门面:step 为步骤级(debug)日志,按配置开关过滤;info/warn 始终输出。
|
|
8499
|
+
* 导出 PluginLogger / makeLogger。
|
|
8500
|
+
*/
|
|
8501
|
+
/** 构建插件日志门面:统一加 PLUGIN_LABEL 前缀,step 按 debug 开关过滤。 */
|
|
8502
|
+
function makeLogger(ctx, debug) {
|
|
8503
|
+
return {
|
|
8504
|
+
step(message) {
|
|
8505
|
+
if (typeof debug === "function" ? debug() : debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
|
|
8506
|
+
},
|
|
8507
|
+
info(message) {
|
|
8508
|
+
ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
|
|
8509
|
+
},
|
|
8510
|
+
warn(message) {
|
|
8511
|
+
ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
|
|
8512
|
+
}
|
|
8513
|
+
};
|
|
8514
|
+
}
|
|
8515
|
+
//#endregion
|
|
8516
|
+
//#region src/format.ts
|
|
8517
|
+
/**
|
|
8518
|
+
* 紧凑数字格式化(压缩卡片、重压缩记录与压缩日志共用)。零依赖,服务端与浏览器均可引用。导出 formatCompactCount / formatSeconds。
|
|
8519
|
+
* <1k 原样;≥1k 用 k;≥1w(万)用 w;≥1M 用 M;保留 1 位小数并去掉末尾 .0。
|
|
8520
|
+
*/
|
|
8521
|
+
function formatCompactCount(value) {
|
|
8522
|
+
const trim = (n) => {
|
|
8523
|
+
const text = String(Math.round(n * 10) / 10);
|
|
8524
|
+
return text.endsWith(".0") ? text.slice(0, -2) : text;
|
|
8525
|
+
};
|
|
8526
|
+
if (value >= 1e6) return `${trim(value / 1e6)}M`;
|
|
8527
|
+
if (value >= 1e4) return `${trim(value / 1e4)}w`;
|
|
8528
|
+
if (value >= 1e3) return `${trim(value / 1e3)}k`;
|
|
8529
|
+
return String(value);
|
|
8530
|
+
}
|
|
8531
|
+
/** 毫秒耗时格式化为一位小数的秒数,如 63.1s。 */
|
|
8532
|
+
function formatSeconds(durationMs) {
|
|
8533
|
+
return `${(durationMs / 1e3).toFixed(1)}s`;
|
|
8534
|
+
}
|
|
8535
|
+
//#endregion
|
|
8536
|
+
//#region src/compaction-log.ts
|
|
8537
|
+
/** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
|
|
8538
|
+
const COMPACTION_LOG_PROVIDER = "om-compaction-log";
|
|
8539
|
+
/** 压缩 pass 的中文标签(会话记录 label 用;未知阶段回落「压缩」)。 */
|
|
8540
|
+
function phaseLabel(phase) {
|
|
8541
|
+
if (phase === "observe") return "观察";
|
|
8542
|
+
if (phase === "reflect") return "反思";
|
|
8543
|
+
return "压缩";
|
|
8544
|
+
}
|
|
8545
|
+
/**
|
|
8546
|
+
* 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
|
|
8547
|
+
* 重压缩追加 `-重压缩`,失败追加 `-失败`。
|
|
8548
|
+
*/
|
|
8549
|
+
function compressionRecordLabel(phase, range, success, retry) {
|
|
8550
|
+
return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
|
|
8551
|
+
}
|
|
8552
|
+
/** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
|
|
8553
|
+
function failureText(failure) {
|
|
8554
|
+
if (failure === void 0) return "无(压缩失败)";
|
|
8555
|
+
const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
|
|
8556
|
+
return `无(压缩失败:${failure.reason}${last})`;
|
|
8557
|
+
}
|
|
8558
|
+
/** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
|
|
8559
|
+
function compressionInfo(info) {
|
|
8560
|
+
const effort = info.reasoningEffort ?? "默认思考等级";
|
|
8561
|
+
const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
|
|
8562
|
+
return {
|
|
8563
|
+
text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
|
|
8564
|
+
provider: info.target.provider,
|
|
8565
|
+
model: info.target.model
|
|
8566
|
+
};
|
|
8567
|
+
}
|
|
8568
|
+
/**
|
|
8569
|
+
* 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
|
|
8570
|
+
* 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
|
|
8571
|
+
* time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
|
|
8572
|
+
* 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
|
|
8573
|
+
*/
|
|
8574
|
+
function seedEvent(type, seq, time, data, surfaceOp) {
|
|
8575
|
+
return {
|
|
8576
|
+
type,
|
|
8577
|
+
seq,
|
|
8578
|
+
time,
|
|
8579
|
+
data,
|
|
8580
|
+
...surfaceOp === void 0 ? {} : { surfaceOp }
|
|
8581
|
+
};
|
|
8582
|
+
}
|
|
8583
|
+
/**
|
|
8584
|
+
* 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
|
|
8585
|
+
* 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
|
|
8586
|
+
* 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
|
|
8587
|
+
* 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
|
|
8588
|
+
* 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
|
|
8589
|
+
* 轮结束时刻与循环结束时刻。
|
|
8590
|
+
*/
|
|
8591
|
+
function buildCompressionSeed(messages, stats, label, info, system) {
|
|
8592
|
+
const seed = [];
|
|
8593
|
+
const push = (type, time, data, surfaceOp) => {
|
|
8594
|
+
seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
|
|
8595
|
+
};
|
|
8596
|
+
let cursor = stats.startedAt;
|
|
8597
|
+
const at = (time) => {
|
|
8598
|
+
cursor = Math.max(cursor, time);
|
|
8599
|
+
return cursor;
|
|
8600
|
+
};
|
|
8601
|
+
const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
|
|
8602
|
+
push("subagent/descriptor", at(stats.startedAt), {
|
|
8603
|
+
version: SUBAGENT_DESCRIPTOR_VERSION,
|
|
8604
|
+
mode: "one-shot",
|
|
8605
|
+
provider: COMPACTION_LOG_PROVIDER,
|
|
8606
|
+
label
|
|
8607
|
+
});
|
|
8608
|
+
push("turn/start", at(stats.startedAt), { turn: 1 });
|
|
8609
|
+
let step = 1;
|
|
8610
|
+
let assistantIndex = 0;
|
|
8611
|
+
let stepTime = stats.startedAt;
|
|
8612
|
+
let stepOpen = false;
|
|
8613
|
+
let pending = [];
|
|
8614
|
+
const closeStep = () => {
|
|
8615
|
+
if (!stepOpen) return;
|
|
8616
|
+
for (const call of pending) {
|
|
8617
|
+
if (executed.has(call.id)) continue;
|
|
8618
|
+
const repair = createToolResultMessage({
|
|
8619
|
+
callId: call.id,
|
|
8620
|
+
content: [{
|
|
8621
|
+
type: "text",
|
|
8622
|
+
text: "压缩循环未执行此工具调用"
|
|
8623
|
+
}],
|
|
8624
|
+
isError: true
|
|
8625
|
+
});
|
|
8626
|
+
push("tool/result", at(stepTime), {
|
|
8627
|
+
turn: 1,
|
|
8628
|
+
step,
|
|
8629
|
+
message: {
|
|
8630
|
+
...repair,
|
|
8631
|
+
id: `forked-tool-result-${call.id}-${uuid()}`
|
|
8632
|
+
},
|
|
8633
|
+
error: {
|
|
8634
|
+
name: "ToolNotStartedError",
|
|
8635
|
+
code: "TOOL_NOT_STARTED"
|
|
8636
|
+
}
|
|
8637
|
+
}, "append");
|
|
8638
|
+
}
|
|
8639
|
+
push("step/end", at(stepTime), {
|
|
8640
|
+
turn: 1,
|
|
8641
|
+
step
|
|
8642
|
+
});
|
|
8643
|
+
pending = [];
|
|
8644
|
+
stepOpen = false;
|
|
8645
|
+
};
|
|
8646
|
+
for (const message of messages) if (message.role === "assistant") {
|
|
8647
|
+
closeStep();
|
|
8648
|
+
step += 1;
|
|
8649
|
+
const round = stats.rounds[assistantIndex];
|
|
8650
|
+
assistantIndex += 1;
|
|
8651
|
+
const startAt = round?.startedAt ?? stepTime;
|
|
8652
|
+
const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
|
|
8653
|
+
push("step/start", at(startAt), {
|
|
8654
|
+
turn: 1,
|
|
8655
|
+
step
|
|
8656
|
+
});
|
|
8657
|
+
stepOpen = true;
|
|
8658
|
+
const assistant = message;
|
|
8659
|
+
const assistantTime = at(completedAt);
|
|
8660
|
+
push("assistant/message", assistantTime, {
|
|
8661
|
+
turn: 1,
|
|
8662
|
+
step,
|
|
8663
|
+
message: assistant,
|
|
8664
|
+
stream: [],
|
|
8665
|
+
...round?.usage === void 0 ? {} : { usage: round.usage }
|
|
8666
|
+
}, "append");
|
|
8667
|
+
stepTime = assistantTime;
|
|
8668
|
+
pending = assistant.content.filter((block) => block.type === "tool-call");
|
|
8669
|
+
for (const call of pending) {
|
|
8670
|
+
if (!executed.has(call.id)) continue;
|
|
8671
|
+
push("tool/call", at(stepTime), {
|
|
8672
|
+
turn: 1,
|
|
8673
|
+
step,
|
|
8674
|
+
callId: call.id,
|
|
8675
|
+
name: call.name,
|
|
8676
|
+
arguments: call.arguments
|
|
8677
|
+
});
|
|
8678
|
+
}
|
|
8679
|
+
} else if (message.role === "tool") push("tool/result", at(stepTime), {
|
|
8680
|
+
turn: 1,
|
|
8681
|
+
step,
|
|
8682
|
+
message
|
|
8683
|
+
}, "append");
|
|
8684
|
+
else if (!stepOpen) {
|
|
8685
|
+
const user = message;
|
|
8686
|
+
push("step/start", at(stats.startedAt), {
|
|
8687
|
+
turn: 1,
|
|
8688
|
+
step
|
|
8689
|
+
});
|
|
8690
|
+
stepOpen = true;
|
|
8691
|
+
if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
|
|
8692
|
+
turn: 1,
|
|
8693
|
+
step,
|
|
8694
|
+
message: createSystemMessage(system)
|
|
8695
|
+
}, "append");
|
|
8696
|
+
push("user/message", at(stats.startedAt), {
|
|
8697
|
+
...user,
|
|
8698
|
+
source: { kind: "user" }
|
|
8699
|
+
}, "append");
|
|
8700
|
+
} else {
|
|
8701
|
+
const user = message;
|
|
8702
|
+
push("user/message", at(stepTime), user, "append");
|
|
8703
|
+
}
|
|
8704
|
+
closeStep();
|
|
8705
|
+
if (info !== void 0) {
|
|
8706
|
+
step += 1;
|
|
8707
|
+
push("step/start", at(stats.completedAt), {
|
|
8708
|
+
turn: 1,
|
|
8709
|
+
step
|
|
8710
|
+
});
|
|
8711
|
+
push("assistant/message", at(stats.completedAt), {
|
|
8712
|
+
turn: 1,
|
|
8713
|
+
step,
|
|
8714
|
+
message: createAssistantMessage({
|
|
8715
|
+
content: [{
|
|
8716
|
+
type: "text",
|
|
8717
|
+
text: info.text
|
|
8718
|
+
}],
|
|
8719
|
+
source: {
|
|
8720
|
+
provider: info.provider,
|
|
8721
|
+
model: info.model
|
|
8722
|
+
}
|
|
8723
|
+
}),
|
|
8724
|
+
stream: []
|
|
8725
|
+
}, "append");
|
|
8726
|
+
push("step/end", at(stats.completedAt), {
|
|
8727
|
+
turn: 1,
|
|
8728
|
+
step
|
|
8729
|
+
});
|
|
8730
|
+
}
|
|
8731
|
+
push("turn/end", at(stats.completedAt), {
|
|
8732
|
+
turn: 1,
|
|
8733
|
+
reason: { kind: "completed" }
|
|
8734
|
+
});
|
|
8735
|
+
return seed;
|
|
8736
|
+
}
|
|
8737
|
+
/**
|
|
8738
|
+
* 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
|
|
8739
|
+
* ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
|
|
8740
|
+
* delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
|
|
8741
|
+
* om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
|
|
8742
|
+
* subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
|
|
8743
|
+
* logger.warn 并返回 undefined。
|
|
8744
|
+
*/
|
|
8745
|
+
async function recordCompressionSession(ctx, parentSession, options) {
|
|
8746
|
+
const logger = makeLogger(ctx, options.debug);
|
|
8747
|
+
try {
|
|
8748
|
+
const header = parentSession.header;
|
|
8749
|
+
const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
|
|
8750
|
+
const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
|
|
8751
|
+
const sessions = ctx.get("sessions");
|
|
8752
|
+
if (sessions === void 0) {
|
|
8753
|
+
logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
|
|
8754
|
+
return;
|
|
8755
|
+
}
|
|
8756
|
+
const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
|
|
8757
|
+
seed,
|
|
8758
|
+
meta: {
|
|
8759
|
+
...header.cwd === void 0 ? {} : { cwd: header.cwd },
|
|
8760
|
+
parentSession: parentSession.id,
|
|
8761
|
+
origin: "subagent",
|
|
8762
|
+
delegationDepth: (header.delegationDepth ?? 0) + 1
|
|
8763
|
+
}
|
|
8764
|
+
});
|
|
8765
|
+
const persistence = ctx.get("sessionPersistence");
|
|
8766
|
+
if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
|
|
8767
|
+
const write = await persistence.create(child.header);
|
|
8768
|
+
try {
|
|
8769
|
+
await write.append(child.snapshotEvents());
|
|
8770
|
+
await write.flush();
|
|
8771
|
+
} finally {
|
|
8772
|
+
await write.close();
|
|
8773
|
+
}
|
|
8774
|
+
parentSession.append("subagent/catalog", {
|
|
8775
|
+
version: 0,
|
|
8776
|
+
childId: child.id,
|
|
8777
|
+
childCreatedAt: child.header.createdAt,
|
|
8778
|
+
mode: "one-shot",
|
|
8779
|
+
label
|
|
8780
|
+
});
|
|
8781
|
+
await sessions.flush(parentSession);
|
|
8782
|
+
return child.id;
|
|
8783
|
+
} catch (error) {
|
|
8784
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
8785
|
+
logger.warn(`压缩会话记录子会话落盘失败: ${message}`);
|
|
8786
|
+
return;
|
|
8787
|
+
}
|
|
8788
|
+
}
|
|
8789
|
+
//#endregion
|
|
8555
8790
|
//#region src/compress-tools.ts
|
|
8556
8791
|
/** 判定 JSON 对象,不接受数组或 null。 */
|
|
8557
8792
|
function isJsonRecord(value) {
|
|
@@ -8763,6 +8998,11 @@ var CompressionState = class CompressionState {
|
|
|
8763
8998
|
text: `${CompressionState.spanLabel(lo, hi)} 超出要求的压缩区间 [${minIndex}..${maxIndex}]`,
|
|
8764
8999
|
isError: true
|
|
8765
9000
|
};
|
|
9001
|
+
const archive = this.archiveCheck(lo, hi, content, args.keywords);
|
|
9002
|
+
if (typeof archive === "string") return {
|
|
9003
|
+
text: archive,
|
|
9004
|
+
isError: true
|
|
9005
|
+
};
|
|
8766
9006
|
let insideCount = 0;
|
|
8767
9007
|
for (const entry of this.view.entries) {
|
|
8768
9008
|
if (entry.lo === void 0 || entry.hi === void 0) continue;
|
|
@@ -8818,13 +9058,32 @@ var CompressionState = class CompressionState {
|
|
|
8818
9058
|
this.replacements.push({
|
|
8819
9059
|
lo,
|
|
8820
9060
|
hi,
|
|
8821
|
-
content
|
|
9061
|
+
content,
|
|
9062
|
+
...archive === void 0 ? {} : { keywords: archive }
|
|
8822
9063
|
});
|
|
8823
9064
|
return {
|
|
8824
9065
|
text: `已压缩${CompressionState.spanLabel(lo, hi)}(${insideCount} 条 assistant 条目)`,
|
|
8825
9066
|
isError: false
|
|
8826
9067
|
};
|
|
8827
9068
|
}
|
|
9069
|
+
/**
|
|
9070
|
+
* 归档模式校验:区间须恰为一个归档段,content 为不超过 ARCHIVE_SUMMARY_MAX_CHARS 的单行,
|
|
9071
|
+
* keywords 为 1..ARCHIVE_MAX_KEYWORDS 个非空单行词。非归档模式返回 undefined;
|
|
9072
|
+
* 校验失败返回错误文本,通过返回规整后的关键词。
|
|
9073
|
+
*/
|
|
9074
|
+
archiveCheck(lo, hi, content, keywords) {
|
|
9075
|
+
const segments = this.view.segments;
|
|
9076
|
+
if (segments === void 0) return void 0;
|
|
9077
|
+
if (!segments.some((seg) => seg.lo === lo && seg.hi === hi)) return `${CompressionState.spanLabel(lo, hi)} 不是归档段;区间必须恰为一个段:${segments.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、")}`;
|
|
9078
|
+
if (/[\r\n]/.test(content)) return "content 必须是一句话,不能换行";
|
|
9079
|
+
if (content.length > 1e3) return `content ${content.length} 字符,超过 ${ARCHIVE_SUMMARY_MAX_CHARS} 字符上限,请压成一句话`;
|
|
9080
|
+
if (!Array.isArray(keywords) || keywords.length === 0 || keywords.length > 8 || keywords.some((k) => typeof k !== "string" || k.trim() === "" || /[\r\n]/.test(k))) return `keywords 必须是 1..8 个非空单行关键词`;
|
|
9081
|
+
return keywords.map((k) => String(k).trim());
|
|
9082
|
+
}
|
|
9083
|
+
/** 归档模式下尚未被摘要覆盖的段。 */
|
|
9084
|
+
uncoveredSegments() {
|
|
9085
|
+
return (this.view.segments ?? []).filter((seg) => !this.replacements.some((rep) => rep.lo === seg.lo && rep.hi === seg.hi));
|
|
9086
|
+
}
|
|
8828
9087
|
/** 完全包含该条目的替换记录;替换区间两两不相交,至多一条。 */
|
|
8829
9088
|
replacementFor(entry) {
|
|
8830
9089
|
const { lo, hi } = entry;
|
|
@@ -8868,7 +9127,8 @@ var CompressionState = class CompressionState {
|
|
|
8868
9127
|
kind: "assistant",
|
|
8869
9128
|
lo: rep.lo,
|
|
8870
9129
|
hi: rep.hi,
|
|
8871
|
-
text: rep.content
|
|
9130
|
+
text: rep.content,
|
|
9131
|
+
...rep.keywords === void 0 ? {} : { keyWord: rep.keywords.join(", ") }
|
|
8872
9132
|
},
|
|
8873
9133
|
blocks: [],
|
|
8874
9134
|
replacement: rep
|
|
@@ -8961,6 +9221,11 @@ var CompressionState = class CompressionState {
|
|
|
8961
9221
|
text: `尚未处理原始 ask(index ${pending.join("、")}):请直接压缩,或先查看再调用 rewriteAskUserQuestion 重写后保留`,
|
|
8962
9222
|
isError: true
|
|
8963
9223
|
};
|
|
9224
|
+
const uncovered = this.uncoveredSegments();
|
|
9225
|
+
if (uncovered.length > 0) return {
|
|
9226
|
+
text: `尚有归档段未压缩:${uncovered.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、")}。每个段都要用 compressHistory 压成一句话后再完成`,
|
|
9227
|
+
isError: true
|
|
9228
|
+
};
|
|
8964
9229
|
this._completed = true;
|
|
8965
9230
|
return {
|
|
8966
9231
|
text: this.buildFinalBlock(),
|
|
@@ -8990,11 +9255,15 @@ var CompressionState = class CompressionState {
|
|
|
8990
9255
|
const note = historyFormatNote({
|
|
8991
9256
|
user: entries.some((e) => e.kind === "user"),
|
|
8992
9257
|
skill: entries.some((e) => e.kind === "assistant" && e.toolName === "skill"),
|
|
8993
|
-
askUserQuestion: entries.some(isAskEntry)
|
|
9258
|
+
askUserQuestion: entries.some(isAskEntry),
|
|
9259
|
+
keyWord: entries.some((e) => e.keyWord !== void 0)
|
|
8994
9260
|
});
|
|
9261
|
+
if (this.view.segments !== void 0) return `<${ARCHIVED_HISTORY_TAG} tip="${ARCHIVED_HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${ARCHIVED_HISTORY_TAG}>`;
|
|
8995
9262
|
return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${HISTORY_TAG}>`;
|
|
8996
9263
|
}
|
|
8997
9264
|
};
|
|
9265
|
+
/** 归档摘要单句的硬性字符上限(超出即拒绝)。 */
|
|
9266
|
+
const ARCHIVE_SUMMARY_MAX_CHARS = 1e3;
|
|
8998
9267
|
/** 仅含原始合法 ask 的压缩会话使用的重写工具。 */
|
|
8999
9268
|
const REWRITE_ASK_TOOL_SCHEMA = {
|
|
9000
9269
|
name: "rewriteAskUserQuestion",
|
|
@@ -9103,6 +9372,48 @@ const COMPRESSION_TOOL_SCHEMAS = [
|
|
|
9103
9372
|
}
|
|
9104
9373
|
}
|
|
9105
9374
|
];
|
|
9375
|
+
/** 归档模式的工具定义:compressHistory 区间限定为一个归档段并要求 keywords。 */
|
|
9376
|
+
const ARCHIVE_TOOL_SCHEMAS = COMPRESSION_TOOL_SCHEMAS.map((schema) => {
|
|
9377
|
+
if (schema.name === "completeCompression") return {
|
|
9378
|
+
...schema,
|
|
9379
|
+
description: "全部归档段都已压缩后调用,成功时立即结束压缩会话。"
|
|
9380
|
+
};
|
|
9381
|
+
if (schema.name !== "compressHistory") return schema;
|
|
9382
|
+
return {
|
|
9383
|
+
name: "compressHistory",
|
|
9384
|
+
description: `把一个归档段(start..end 恰为首条消息列出的某个段)压成一句话摘要。content 不换行,建议不超过 300 字符,写清结论、决策与涉及的文件;硬性上限 ${ARCHIVE_SUMMARY_MAX_CHARS} 字符,超出会被拒绝。keywords 为供 recall 检索原文的关键词。返回成功即已生效;修改时用同一区间重新提交。`,
|
|
9385
|
+
parameters: {
|
|
9386
|
+
type: "object",
|
|
9387
|
+
properties: {
|
|
9388
|
+
start: {
|
|
9389
|
+
type: "number",
|
|
9390
|
+
description: "归档段起始完整消息 index"
|
|
9391
|
+
},
|
|
9392
|
+
end: {
|
|
9393
|
+
type: "number",
|
|
9394
|
+
description: "归档段结束完整消息 index"
|
|
9395
|
+
},
|
|
9396
|
+
content: {
|
|
9397
|
+
type: "string",
|
|
9398
|
+
description: "一句话摘要(纯文本,不换行,不要包含 CDATA 包裹)。数字、路径、版本号与错误码从原文逐字照抄,不推测补全。"
|
|
9399
|
+
},
|
|
9400
|
+
keywords: {
|
|
9401
|
+
type: "array",
|
|
9402
|
+
minItems: 1,
|
|
9403
|
+
maxItems: 8,
|
|
9404
|
+
items: { type: "string" },
|
|
9405
|
+
description: "1.." + String(8) + " 个关键词:文件名、函数名、命令、主题词等原文中出现的词"
|
|
9406
|
+
}
|
|
9407
|
+
},
|
|
9408
|
+
required: [
|
|
9409
|
+
"start",
|
|
9410
|
+
"end",
|
|
9411
|
+
"content",
|
|
9412
|
+
"keywords"
|
|
9413
|
+
]
|
|
9414
|
+
}
|
|
9415
|
+
};
|
|
9416
|
+
});
|
|
9106
9417
|
//#endregion
|
|
9107
9418
|
//#region src/rate-limit.ts
|
|
9108
9419
|
/**
|
|
@@ -9166,8 +9477,8 @@ async function gateRateLimit(waitMs, signal) {
|
|
|
9166
9477
|
* REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT / COMPLETION_BLOCKED_TEXT。
|
|
9167
9478
|
*
|
|
9168
9479
|
* - 首条 user 消息为压缩指令与 start/end 区间(buildCompressionTaskText),循环附上
|
|
9169
|
-
* 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system
|
|
9170
|
-
*
|
|
9480
|
+
* 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system,归档
|
|
9481
|
+
* 视图追加归档深度压缩约束并改用归档工具定义
|
|
9171
9482
|
* - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
|
|
9172
9483
|
* BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
|
|
9173
9484
|
* - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
|
|
@@ -9221,12 +9532,22 @@ function buildCompressionPrompt(skipReasoning) {
|
|
|
9221
9532
|
/**
|
|
9222
9533
|
* 构建压缩会话首条 user 消息的指令部分(压缩指令 + start/end 区间);区间条目由循环附加。
|
|
9223
9534
|
*/
|
|
9224
|
-
function buildCompressionTaskText(phase, start, end) {
|
|
9225
|
-
if (phase === "reflect")
|
|
9535
|
+
function buildCompressionTaskText(phase, start, end, segments = []) {
|
|
9536
|
+
if (phase === "reflect") {
|
|
9537
|
+
const list = segments.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、");
|
|
9538
|
+
return `归档深度压缩 <history> 块,完整消息区间 [${start}..${end}]:区间条目附在下方。归档段共 ${segments.length} 个:${list}。每个段用一次 compressHistory 压成一句话并给出 keywords,全部完成后调用 completeCompression。`;
|
|
9539
|
+
}
|
|
9226
9540
|
return `压缩完整消息区间 [${start}..${end}]:区间条目附在下方,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。`;
|
|
9227
9541
|
}
|
|
9228
|
-
/**
|
|
9229
|
-
const REFLECT_COMPRESSION_PROMPT = [
|
|
9542
|
+
/** 归档深度压缩的额外约束,只在归档视图注入。 */
|
|
9543
|
+
const REFLECT_COMPRESSION_PROMPT = [
|
|
9544
|
+
"【归档深度压缩】",
|
|
9545
|
+
"- 本次产物是归档块,原文可由主模型通过 recall 按 index 找回;此规则优先于上方的粒度要求。",
|
|
9546
|
+
"- 用户消息与已处理的提问原样保留,无需处理。",
|
|
9547
|
+
"- 相邻两条用户消息之间的全部 assistant 条目构成一个归档段,每段压成一句话:写清结论、决策与涉及的文件,不写过程。",
|
|
9548
|
+
`- 一句话建议不超过 300 字符、不换行;已被段内后续进展取代的信息直接舍弃。`,
|
|
9549
|
+
"- keywords 选原文中出现、便于检索的词:文件名、函数名、命令、错误码、主题词。"
|
|
9550
|
+
].join("\n");
|
|
9230
9551
|
/** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
|
|
9231
9552
|
const ASK_COMPRESSION_PROMPT = [
|
|
9232
9553
|
"【原始提问处理】",
|
|
@@ -9351,10 +9672,11 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9351
9672
|
const logger = makeLogger(ctx, options.debug);
|
|
9352
9673
|
const view = withoutReasoning(options.view, options.skipReasoning);
|
|
9353
9674
|
const state = new CompressionState(view);
|
|
9354
|
-
const
|
|
9675
|
+
const baseTools = view.segments === void 0 ? COMPRESSION_TOOL_SCHEMAS : ARCHIVE_TOOL_SCHEMAS;
|
|
9676
|
+
const tools = state.hasPendingAsks ? [...baseTools, REWRITE_ASK_TOOL_SCHEMA] : baseTools;
|
|
9355
9677
|
const system = [
|
|
9356
9678
|
buildCompressionPrompt(options.skipReasoning),
|
|
9357
|
-
...
|
|
9679
|
+
...view.segments === void 0 ? [] : [REFLECT_COMPRESSION_PROMPT],
|
|
9358
9680
|
...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
|
|
9359
9681
|
].join("\n\n");
|
|
9360
9682
|
const messages = [makePluginUserMessage(withInitialHistory(options.taskText, state))];
|
|
@@ -9478,264 +9800,92 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9478
9800
|
}
|
|
9479
9801
|
if (retryTransient(failureMessage, failureStatus)) continue;
|
|
9480
9802
|
logger.warn(`压缩循环请求失败: ${failureMessage}`);
|
|
9481
|
-
pushPartialAssistant(assembler, messages, options.target);
|
|
9482
|
-
return await failWith(failureMessage, false);
|
|
9483
|
-
}
|
|
9484
|
-
transientRetries = 0;
|
|
9485
|
-
rounds += 1;
|
|
9486
|
-
if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
|
|
9487
|
-
roundStats.push({
|
|
9488
|
-
round: rounds,
|
|
9489
|
-
startedAt: roundStartedAt,
|
|
9490
|
-
durationMs: Date.now() - roundStartedAt,
|
|
9491
|
-
...assembler.usage === void 0 ? {} : { usage: assembler.usage }
|
|
9492
|
-
});
|
|
9493
|
-
const assistantMessage = assembler.message({
|
|
9494
|
-
provider: options.target.provider,
|
|
9495
|
-
model: options.target.model
|
|
9496
|
-
});
|
|
9497
|
-
messages.push(assistantMessage);
|
|
9498
|
-
const calls = assembler.blocks().filter((block) => block.type === "tool-call");
|
|
9499
|
-
if (calls.length === 0) {
|
|
9500
|
-
if (finish.kind === "max-tokens") {
|
|
9501
|
-
truncations += 1;
|
|
9502
|
-
if (truncations >= MAX_CONSECUTIVE_FAILURES) {
|
|
9503
|
-
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
|
|
9504
|
-
logger.warn(error);
|
|
9505
|
-
return await failWith(error, false);
|
|
9506
|
-
}
|
|
9507
|
-
logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
|
|
9508
|
-
omitted.add(assistantMessage);
|
|
9509
|
-
messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
|
|
9510
|
-
continue;
|
|
9511
|
-
}
|
|
9512
|
-
nudges += 1;
|
|
9513
|
-
if (nudges >= MAX_CONSECUTIVE_FAILURES) {
|
|
9514
|
-
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
|
|
9515
|
-
logger.warn(error);
|
|
9516
|
-
return await failWith(error, false);
|
|
9517
|
-
}
|
|
9518
|
-
logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
|
|
9519
|
-
messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
|
|
9520
|
-
continue;
|
|
9521
|
-
}
|
|
9522
|
-
nudges = 0;
|
|
9523
|
-
truncations = 0;
|
|
9524
|
-
/** 本轮失败且未被同轮后续成功提交解决的写入目标。 */
|
|
9525
|
-
const unresolved = /* @__PURE__ */ new Set();
|
|
9526
|
-
for (const call of calls) {
|
|
9527
|
-
const result = call.name === "completeCompression" && unresolved.size > 0 ? {
|
|
9528
|
-
text: COMPLETION_BLOCKED_TEXT,
|
|
9529
|
-
isError: true
|
|
9530
|
-
} : state.executeCall(call.name, call.arguments);
|
|
9531
|
-
const target = writeTargetOf(call.name, call.arguments);
|
|
9532
|
-
if (target !== void 0) {
|
|
9533
|
-
if (result.isError) unresolved.add(target);
|
|
9534
|
-
else unresolved.delete(target);
|
|
9535
|
-
}
|
|
9536
|
-
messages.push(toolResultOf(call, result));
|
|
9537
|
-
if (state.completed) break;
|
|
9538
|
-
}
|
|
9539
|
-
if (state.completed) {
|
|
9540
|
-
if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
|
|
9541
|
-
const text = state.buildFinalBlock();
|
|
9542
|
-
if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
|
|
9543
|
-
logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
|
|
9544
|
-
const stats = buildStats();
|
|
9545
|
-
const id = await recordSessionId(true, stats, text.length);
|
|
9546
|
-
return {
|
|
9547
|
-
ok: true,
|
|
9548
|
-
text,
|
|
9549
|
-
rounds,
|
|
9550
|
-
stats,
|
|
9551
|
-
...usage === void 0 ? {} : { usage },
|
|
9552
|
-
...id === void 0 ? {} : { recordSessionId: id }
|
|
9553
|
-
};
|
|
9554
|
-
}
|
|
9555
|
-
}
|
|
9556
|
-
}
|
|
9557
|
-
//#endregion
|
|
9558
|
-
//#region src/om-event.ts
|
|
9559
|
-
/** om 信封 text 前缀:标识该 feedback/record 记录由本插件写入。 */
|
|
9560
|
-
const OM_EVENT_PREFIX = "om:1:";
|
|
9561
|
-
/**
|
|
9562
|
-
* 解码一条会话事件为 om 私有事件:仅识别 feedback/record 中带 om 信封前缀的
|
|
9563
|
-
* text;前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
|
|
9564
|
-
*/
|
|
9565
|
-
function readOmEvent(event) {
|
|
9566
|
-
if (event === void 0 || event === null || event.type !== "feedback/record") return void 0;
|
|
9567
|
-
const text = event.data.text;
|
|
9568
|
-
if (typeof text !== "string" || !text.startsWith("om:1:")) return void 0;
|
|
9569
|
-
let envelope;
|
|
9570
|
-
try {
|
|
9571
|
-
envelope = JSON.parse(text.slice(5));
|
|
9572
|
-
} catch {
|
|
9573
|
-
return;
|
|
9574
|
-
}
|
|
9575
|
-
if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) return void 0;
|
|
9576
|
-
const { kind, ...rest } = envelope;
|
|
9577
|
-
switch (kind) {
|
|
9578
|
-
case "om/warning": {
|
|
9579
|
-
const { problem, message } = rest;
|
|
9580
|
-
if (typeof problem !== "string" || typeof message !== "string") return void 0;
|
|
9581
|
-
return {
|
|
9582
|
-
kind,
|
|
9583
|
-
data: {
|
|
9584
|
-
problem,
|
|
9585
|
-
message
|
|
9586
|
-
},
|
|
9587
|
-
seq: event.seq
|
|
9588
|
-
};
|
|
9589
|
-
}
|
|
9590
|
-
case "om/observe-pending": {
|
|
9591
|
-
const { triggerMessageIndex } = rest;
|
|
9592
|
-
if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
|
|
9593
|
-
return {
|
|
9594
|
-
kind,
|
|
9595
|
-
data: { triggerMessageIndex },
|
|
9596
|
-
seq: event.seq
|
|
9597
|
-
};
|
|
9598
|
-
}
|
|
9599
|
-
case "om/observe-invalidate": {
|
|
9600
|
-
const { pendingSeq } = rest;
|
|
9601
|
-
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
9602
|
-
return {
|
|
9603
|
-
kind,
|
|
9604
|
-
data: { pendingSeq },
|
|
9605
|
-
seq: event.seq
|
|
9606
|
-
};
|
|
9607
|
-
}
|
|
9608
|
-
case "om/observe-summary": {
|
|
9609
|
-
const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
|
|
9610
|
-
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
9611
|
-
if (typeof report !== "string") return void 0;
|
|
9612
|
-
if (typeof provider !== "string" || typeof model !== "string") return void 0;
|
|
9613
|
-
if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
|
|
9614
|
-
if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
|
|
9615
|
-
if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
|
|
9616
|
-
const parsedUsage = readTokenUsage(usage);
|
|
9617
|
-
if (parsedUsage === null) return void 0;
|
|
9618
|
-
return {
|
|
9619
|
-
kind,
|
|
9620
|
-
data: {
|
|
9621
|
-
pendingSeq,
|
|
9622
|
-
report,
|
|
9623
|
-
provider,
|
|
9624
|
-
model,
|
|
9625
|
-
startedAt,
|
|
9626
|
-
completedAt,
|
|
9627
|
-
durationMs,
|
|
9628
|
-
...recordSessionId === void 0 ? {} : { recordSessionId },
|
|
9629
|
-
...parsedUsage === void 0 ? {} : { usage: parsedUsage },
|
|
9630
|
-
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
9631
|
-
},
|
|
9632
|
-
seq: event.seq
|
|
9633
|
-
};
|
|
9634
|
-
}
|
|
9635
|
-
default: return;
|
|
9636
|
-
}
|
|
9637
|
-
}
|
|
9638
|
-
/** 校验有限数值字段(时间戳/耗时)。 */
|
|
9639
|
-
function isFiniteNumber(value) {
|
|
9640
|
-
return typeof value === "number" && Number.isFinite(value);
|
|
9641
|
-
}
|
|
9642
|
-
/** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
|
|
9643
|
-
function readTokenUsage(value) {
|
|
9644
|
-
if (value === void 0) return void 0;
|
|
9645
|
-
if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
|
|
9646
|
-
const usage = value;
|
|
9647
|
-
const { inputTokens, outputTokens } = usage;
|
|
9648
|
-
if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
|
|
9649
|
-
const result = {
|
|
9650
|
-
inputTokens,
|
|
9651
|
-
outputTokens
|
|
9652
|
-
};
|
|
9653
|
-
for (const key of [
|
|
9654
|
-
"totalTokens",
|
|
9655
|
-
"cacheReadTokens",
|
|
9656
|
-
"cacheWriteTokens",
|
|
9657
|
-
"reasoningTokens"
|
|
9658
|
-
]) {
|
|
9659
|
-
const field = usage[key];
|
|
9660
|
-
if (field === void 0) continue;
|
|
9661
|
-
if (!isFiniteNumber(field)) return null;
|
|
9662
|
-
result[key] = field;
|
|
9663
|
-
}
|
|
9664
|
-
return result;
|
|
9665
|
-
}
|
|
9666
|
-
/** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
|
|
9667
|
-
function encodeOmEvent(kind, data) {
|
|
9668
|
-
return `${OM_EVENT_PREFIX}${JSON.stringify({
|
|
9669
|
-
kind,
|
|
9670
|
-
...data
|
|
9671
|
-
})}`;
|
|
9672
|
-
}
|
|
9673
|
-
/** 追加一条 om 私有事件(借用 feedback/record,log-only,不进 surface),返回事件 seq。 */
|
|
9674
|
-
function appendOmEvent(session, kind, data) {
|
|
9675
|
-
return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
|
|
9676
|
-
}
|
|
9677
|
-
function findOmEvents(session, kind) {
|
|
9678
|
-
const result = [];
|
|
9679
|
-
for (const event of session.snapshotEvents()) {
|
|
9680
|
-
const om = readOmEvent(event);
|
|
9681
|
-
if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
|
|
9682
|
-
}
|
|
9683
|
-
return result;
|
|
9684
|
-
}
|
|
9685
|
-
//#endregion
|
|
9686
|
-
//#region src/degrade.ts
|
|
9687
|
-
/**
|
|
9688
|
-
* 降级报告:压缩流程中的挂载失败统一出口。
|
|
9689
|
-
* 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
|
|
9690
|
-
*
|
|
9691
|
-
* - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
|
|
9692
|
-
* 并向会话日志追加 log-only 的 om 警告事件(借用 feedback/record 的 om 信封,
|
|
9693
|
-
* 见 om-event.ts;客户端渲染为「功能降级」警告行);
|
|
9694
|
-
* 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
|
|
9695
|
-
* - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
|
|
9696
|
-
* - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
|
|
9697
|
-
*/
|
|
9698
|
-
/** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
|
|
9699
|
-
const DEGRADE_PROBLEMS = {
|
|
9700
|
-
"systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
|
|
9701
|
-
"tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
|
|
9702
|
-
"reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
|
|
9703
|
-
};
|
|
9704
|
-
/**
|
|
9705
|
-
* 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
|
|
9706
|
-
* 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
|
|
9707
|
-
* 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
|
|
9708
|
-
* 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
|
|
9709
|
-
*/
|
|
9710
|
-
function reportDegrade(session, logger, problem) {
|
|
9711
|
-
const message = DEGRADE_PROBLEMS[problem];
|
|
9712
|
-
let first = true;
|
|
9713
|
-
try {
|
|
9714
|
-
first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
|
|
9715
|
-
} catch {}
|
|
9716
|
-
if (!first) return;
|
|
9717
|
-
console.warn(`${PLUGIN_LABEL}: ${message}`);
|
|
9718
|
-
logger.warn(message);
|
|
9719
|
-
try {
|
|
9720
|
-
appendOmEvent(session, "om/warning", {
|
|
9721
|
-
problem,
|
|
9722
|
-
message
|
|
9803
|
+
pushPartialAssistant(assembler, messages, options.target);
|
|
9804
|
+
return await failWith(failureMessage, false);
|
|
9805
|
+
}
|
|
9806
|
+
transientRetries = 0;
|
|
9807
|
+
rounds += 1;
|
|
9808
|
+
if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
|
|
9809
|
+
roundStats.push({
|
|
9810
|
+
round: rounds,
|
|
9811
|
+
startedAt: roundStartedAt,
|
|
9812
|
+
durationMs: Date.now() - roundStartedAt,
|
|
9813
|
+
...assembler.usage === void 0 ? {} : { usage: assembler.usage }
|
|
9723
9814
|
});
|
|
9724
|
-
|
|
9725
|
-
|
|
9726
|
-
|
|
9815
|
+
const assistantMessage = assembler.message({
|
|
9816
|
+
provider: options.target.provider,
|
|
9817
|
+
model: options.target.model
|
|
9818
|
+
});
|
|
9819
|
+
messages.push(assistantMessage);
|
|
9820
|
+
const calls = assembler.blocks().filter((block) => block.type === "tool-call");
|
|
9821
|
+
if (calls.length === 0) {
|
|
9822
|
+
if (finish.kind === "max-tokens") {
|
|
9823
|
+
truncations += 1;
|
|
9824
|
+
if (truncations >= MAX_CONSECUTIVE_FAILURES) {
|
|
9825
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
|
|
9826
|
+
logger.warn(error);
|
|
9827
|
+
return await failWith(error, false);
|
|
9828
|
+
}
|
|
9829
|
+
logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
|
|
9830
|
+
omitted.add(assistantMessage);
|
|
9831
|
+
messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
|
|
9832
|
+
continue;
|
|
9833
|
+
}
|
|
9834
|
+
nudges += 1;
|
|
9835
|
+
if (nudges >= MAX_CONSECUTIVE_FAILURES) {
|
|
9836
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
|
|
9837
|
+
logger.warn(error);
|
|
9838
|
+
return await failWith(error, false);
|
|
9839
|
+
}
|
|
9840
|
+
logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
|
|
9841
|
+
messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
|
|
9842
|
+
continue;
|
|
9843
|
+
}
|
|
9844
|
+
nudges = 0;
|
|
9845
|
+
truncations = 0;
|
|
9846
|
+
/** 本轮失败且未被同轮后续成功提交解决的写入目标。 */
|
|
9847
|
+
const unresolved = /* @__PURE__ */ new Set();
|
|
9848
|
+
for (const call of calls) {
|
|
9849
|
+
const result = call.name === "completeCompression" && unresolved.size > 0 ? {
|
|
9850
|
+
text: COMPLETION_BLOCKED_TEXT,
|
|
9851
|
+
isError: true
|
|
9852
|
+
} : state.executeCall(call.name, call.arguments);
|
|
9853
|
+
const target = writeTargetOf(call.name, call.arguments);
|
|
9854
|
+
if (target !== void 0) {
|
|
9855
|
+
if (result.isError) unresolved.add(target);
|
|
9856
|
+
else unresolved.delete(target);
|
|
9857
|
+
}
|
|
9858
|
+
messages.push(toolResultOf(call, result));
|
|
9859
|
+
if (state.completed) break;
|
|
9860
|
+
}
|
|
9861
|
+
if (state.completed) {
|
|
9862
|
+
if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
|
|
9863
|
+
const text = state.buildFinalBlock();
|
|
9864
|
+
if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
|
|
9865
|
+
logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
|
|
9866
|
+
const stats = buildStats();
|
|
9867
|
+
const id = await recordSessionId(true, stats, text.length);
|
|
9868
|
+
return {
|
|
9869
|
+
ok: true,
|
|
9870
|
+
text,
|
|
9871
|
+
rounds,
|
|
9872
|
+
stats,
|
|
9873
|
+
...usage === void 0 ? {} : { usage },
|
|
9874
|
+
...id === void 0 ? {} : { recordSessionId: id }
|
|
9875
|
+
};
|
|
9876
|
+
}
|
|
9727
9877
|
}
|
|
9728
9878
|
}
|
|
9729
9879
|
//#endregion
|
|
9730
9880
|
//#region src/precompress.ts
|
|
9731
9881
|
/** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
|
|
9732
|
-
const jobs = /* @__PURE__ */ new Map();
|
|
9882
|
+
const jobs$1 = /* @__PURE__ */ new Map();
|
|
9733
9883
|
/**
|
|
9734
9884
|
* 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
|
|
9735
9885
|
* 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
|
|
9736
9886
|
*/
|
|
9737
9887
|
function findPrecompressionJob(session, pendingSeq) {
|
|
9738
|
-
const job = jobs.get(session.id);
|
|
9888
|
+
const job = jobs$1.get(session.id);
|
|
9739
9889
|
if (job === void 0) return void 0;
|
|
9740
9890
|
if (job.session === session && job.pendingSeq === pendingSeq) return job;
|
|
9741
9891
|
disposePrecompression(session.id);
|
|
@@ -9747,7 +9897,7 @@ function findPrecompressionJob(session, pendingSeq) {
|
|
|
9747
9897
|
function startPrecompression(options) {
|
|
9748
9898
|
const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
|
|
9749
9899
|
const logger = makeLogger(ctx, config.debug);
|
|
9750
|
-
const existing = jobs.get(session.id);
|
|
9900
|
+
const existing = jobs$1.get(session.id);
|
|
9751
9901
|
if (existing !== void 0) {
|
|
9752
9902
|
if (existing.session === session && existing.pendingSeq === pendingSeq) return {
|
|
9753
9903
|
ok: true,
|
|
@@ -9783,7 +9933,7 @@ function startPrecompression(options) {
|
|
|
9783
9933
|
promise,
|
|
9784
9934
|
state: "running"
|
|
9785
9935
|
};
|
|
9786
|
-
jobs.set(session.id, job);
|
|
9936
|
+
jobs$1.set(session.id, job);
|
|
9787
9937
|
runJobBody(ctx, job, options, logger).then(settle, settle);
|
|
9788
9938
|
logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
|
|
9789
9939
|
return {
|
|
@@ -9885,30 +10035,159 @@ function adoptPersistedSummary(data) {
|
|
|
9885
10035
|
}
|
|
9886
10036
|
/** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
|
|
9887
10037
|
function disposePrecompression(sessionId) {
|
|
9888
|
-
const job = jobs.get(sessionId);
|
|
10038
|
+
const job = jobs$1.get(sessionId);
|
|
9889
10039
|
if (job === void 0) return;
|
|
9890
|
-
jobs.delete(sessionId);
|
|
10040
|
+
jobs$1.delete(sessionId);
|
|
9891
10041
|
job.controller.abort();
|
|
9892
10042
|
}
|
|
9893
10043
|
/** 中止并移除全部后台任务(插件卸载)。 */
|
|
9894
10044
|
function disposeAllPrecompressions() {
|
|
9895
|
-
for (const sessionId of [...jobs.keys()]) disposePrecompression(sessionId);
|
|
10045
|
+
for (const sessionId of [...jobs$1.keys()]) disposePrecompression(sessionId);
|
|
10046
|
+
}
|
|
10047
|
+
//#endregion
|
|
10048
|
+
//#region src/reflect.ts
|
|
10049
|
+
/** session.id → 任务。 */
|
|
10050
|
+
const jobs = /* @__PURE__ */ new Map();
|
|
10051
|
+
/** session.id → 最近一次非中止失败时的 history 块集合键。 */
|
|
10052
|
+
const failedKeys = /* @__PURE__ */ new Map();
|
|
10053
|
+
/** history 块集合键:按 seq 拼接。 */
|
|
10054
|
+
function historyBlocksKey(blocks) {
|
|
10055
|
+
return blocks.map((block) => block.seq).join(",");
|
|
10056
|
+
}
|
|
10057
|
+
/**
|
|
10058
|
+
* 选择归档块:从最后一个块往前累加 token,合计不超过 keepBudget 的尾部块保留,
|
|
10059
|
+
* 至少保留 1 个;其余全部归档。tokensOf 返回单块 token。
|
|
10060
|
+
*/
|
|
10061
|
+
function selectArchiveBlocks(blocks, tokensOf, keepBudget) {
|
|
10062
|
+
let keepFrom = blocks.length;
|
|
10063
|
+
let total = 0;
|
|
10064
|
+
for (let i = blocks.length - 1; i >= 0; i -= 1) {
|
|
10065
|
+
const block = blocks[i];
|
|
10066
|
+
const next = total + tokensOf(block);
|
|
10067
|
+
if (keepFrom < blocks.length && next > keepBudget) break;
|
|
10068
|
+
total = next;
|
|
10069
|
+
keepFrom = i;
|
|
10070
|
+
}
|
|
10071
|
+
return {
|
|
10072
|
+
archived: blocks.slice(0, keepFrom),
|
|
10073
|
+
kept: blocks.slice(keepFrom)
|
|
10074
|
+
};
|
|
10075
|
+
}
|
|
10076
|
+
/** 查询会话当前任务。 */
|
|
10077
|
+
function peekReflectJob(sessionId) {
|
|
10078
|
+
return jobs.get(sessionId);
|
|
10079
|
+
}
|
|
10080
|
+
/** 取出会话当前任务并从注册表移除(提交或丢弃前调用)。 */
|
|
10081
|
+
function takeReflectJob(sessionId) {
|
|
10082
|
+
const job = jobs.get(sessionId);
|
|
10083
|
+
jobs.delete(sessionId);
|
|
10084
|
+
return job;
|
|
10085
|
+
}
|
|
10086
|
+
/** 最近一次非中止失败时的 history 块集合键。 */
|
|
10087
|
+
function reflectFailedKey(sessionId) {
|
|
10088
|
+
return failedKeys.get(sessionId);
|
|
10089
|
+
}
|
|
10090
|
+
/** 启动后台反思;调用方保证同会话无运行中任务。 */
|
|
10091
|
+
function startReflection(options) {
|
|
10092
|
+
const { ctx, session, config, target, reasoningEffort } = options;
|
|
10093
|
+
const logger = makeLogger(ctx, config.debug);
|
|
10094
|
+
const controller = new AbortController();
|
|
10095
|
+
let settle;
|
|
10096
|
+
const promise = new Promise((resolve) => {
|
|
10097
|
+
settle = resolve;
|
|
10098
|
+
});
|
|
10099
|
+
const job = {
|
|
10100
|
+
session,
|
|
10101
|
+
key: options.key,
|
|
10102
|
+
archived: options.archived,
|
|
10103
|
+
view: options.view,
|
|
10104
|
+
skills: options.skills,
|
|
10105
|
+
estimatedTokens: options.estimatedTokens,
|
|
10106
|
+
shadowedCharCount: options.shadowedCharCount,
|
|
10107
|
+
target,
|
|
10108
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort },
|
|
10109
|
+
controller,
|
|
10110
|
+
promise,
|
|
10111
|
+
state: "running"
|
|
10112
|
+
};
|
|
10113
|
+
jobs.set(session.id, job);
|
|
10114
|
+
failedKeys.delete(session.id);
|
|
10115
|
+
runJobBody(ctx, job, config).then(settle, settle);
|
|
10116
|
+
return job;
|
|
10117
|
+
async function runJobBody(context, current, cfg) {
|
|
10118
|
+
const { view } = current;
|
|
10119
|
+
try {
|
|
10120
|
+
const outcome = await runCompressionLoop(context, current.session, {
|
|
10121
|
+
view,
|
|
10122
|
+
originalChars: current.shadowedCharCount,
|
|
10123
|
+
phase: "reflect",
|
|
10124
|
+
taskText: buildCompressionTaskText("reflect", view.minIndex ?? 0, view.maxIndex ?? 0, view.segments),
|
|
10125
|
+
target: current.target,
|
|
10126
|
+
maxTokens: cfg.compressMaxTokens,
|
|
10127
|
+
rateLimitWaitMs: cfg.rateLimitWaitMs,
|
|
10128
|
+
skipReasoning: cfg.compressSkipReasoning,
|
|
10129
|
+
debug: cfg.debug,
|
|
10130
|
+
...current.reasoningEffort === void 0 ? {} : { reasoningEffort: current.reasoningEffort },
|
|
10131
|
+
signal: current.controller.signal
|
|
10132
|
+
});
|
|
10133
|
+
if (outcome.ok) {
|
|
10134
|
+
current.state = "done";
|
|
10135
|
+
current.result = outcome;
|
|
10136
|
+
logger.info(`反思完成(${outcome.stats.durationMs}ms),等待下一个 pre-step 提交`);
|
|
10137
|
+
return;
|
|
10138
|
+
}
|
|
10139
|
+
fail(current, {
|
|
10140
|
+
error: outcome.error,
|
|
10141
|
+
aborted: outcome.aborted,
|
|
10142
|
+
...outcome.recordSessionId === void 0 ? {} : { diagnosticSessionId: outcome.recordSessionId }
|
|
10143
|
+
});
|
|
10144
|
+
logger.info(`反思失败: ${outcome.error}`);
|
|
10145
|
+
} catch (error) {
|
|
10146
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10147
|
+
fail(current, {
|
|
10148
|
+
error: message,
|
|
10149
|
+
aborted: current.controller.signal.aborted
|
|
10150
|
+
});
|
|
10151
|
+
logger.warn(`反思任务异常: ${message}`);
|
|
10152
|
+
}
|
|
10153
|
+
}
|
|
10154
|
+
}
|
|
10155
|
+
/** 登记失败;非中止失败记录集合键,阻止同一块集合重试。 */
|
|
10156
|
+
function fail(job, failure) {
|
|
10157
|
+
job.state = "failed";
|
|
10158
|
+
job.failure = failure;
|
|
10159
|
+
if (!failure.aborted && jobs.get(job.session.id) === job) failedKeys.set(job.session.id, job.key);
|
|
10160
|
+
}
|
|
10161
|
+
/** 中止并移除会话的反思任务,清除失败记录。 */
|
|
10162
|
+
function disposeReflection(sessionId) {
|
|
10163
|
+
failedKeys.delete(sessionId);
|
|
10164
|
+
const job = jobs.get(sessionId);
|
|
10165
|
+
if (job === void 0) return;
|
|
10166
|
+
jobs.delete(sessionId);
|
|
10167
|
+
job.controller.abort();
|
|
10168
|
+
}
|
|
10169
|
+
/** 中止并移除全部反思任务(插件卸载)。 */
|
|
10170
|
+
function disposeAllReflections() {
|
|
10171
|
+
for (const sessionId of [...jobs.keys()]) disposeReflection(sessionId);
|
|
10172
|
+
failedKeys.clear();
|
|
9896
10173
|
}
|
|
9897
10174
|
//#endregion
|
|
9898
10175
|
//#region src/compress.ts
|
|
9899
10176
|
/**
|
|
9900
10177
|
* 两级自动压缩(观察/反思)与 compaction 生命周期提交。
|
|
9901
10178
|
* 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
|
|
9902
|
-
* historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
|
|
9903
|
-
* reflectPass / observePass / maybeCompress。
|
|
10179
|
+
* historyTextOf / archivedHistoryTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
|
|
10180
|
+
* reflectPass / commitReflection / observePass / maybeCompress。
|
|
9904
10181
|
*
|
|
9905
10182
|
* - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
|
|
9906
10183
|
* 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
|
|
9907
10184
|
* completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
|
|
9908
10185
|
* 全程无需整块校验
|
|
9909
|
-
* -
|
|
9910
|
-
*
|
|
9911
|
-
*
|
|
10186
|
+
* - 反思(异步归档):<history> 块 token 合计(估算 × 换算系数,不计 archived-history)
|
|
10187
|
+
* ≥ reflectThresholdTokens 时,保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余块在
|
|
10188
|
+
* 后台归档为一个 <archived-history> 块(reflect.ts);完成后的首个有输入的 pre-step 提交
|
|
10189
|
+
* 替换,并把被归档块中的 skill 以 skill-invocation 消息注入本 step;失败只记
|
|
10190
|
+
* compaction/end(error),块集合变化后重试
|
|
9912
10191
|
* - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
|
|
9913
10192
|
* 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
|
|
9914
10193
|
* (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
|
|
@@ -9920,24 +10199,24 @@ function disposeAllPrecompressions() {
|
|
|
9920
10199
|
* tailMessageCount=0 时触发当轮即到期,阻塞等待注入
|
|
9921
10200
|
* - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
|
|
9922
10201
|
* (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
|
|
9923
|
-
* - 待定标记与压缩结果以
|
|
10202
|
+
* - 待定标记与压缩结果以 ignorable 的 plugin record(kind 为
|
|
9924
10203
|
* om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
|
|
9925
10204
|
* 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
|
|
9926
|
-
* -
|
|
9927
|
-
*
|
|
10205
|
+
* - pre-step 先做反思检查(只启动或跳过,不阻塞),再执行观察(压缩主体在后台运行,
|
|
10206
|
+
* pre-step 仅在到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
|
|
9928
10207
|
* - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
|
|
9929
10208
|
* (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
|
|
9930
10209
|
* ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
|
|
9931
10210
|
* 未命中 / 无元数据 / 查询失败降级为模型默认并报告 reasoning-effort-unavailable 降级
|
|
9932
|
-
* - 压缩边界:最后一个合法 <history> 块之后的消息视为未压缩,其前不重复压缩
|
|
9933
|
-
* -
|
|
10211
|
+
* - 压缩边界:最后一个合法 <history> 或 <archived-history> 块之后的消息视为未压缩,其前不重复压缩
|
|
10212
|
+
* - 观察压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
|
|
9934
10213
|
* 错误),压缩流程向上传播,pre-step 据此拒绝本 step 中断当前 turn;signal 中止标记
|
|
9935
10214
|
* aborted(不中断);成功与失败均落盘压缩会话记录子会话(失败时其 id 随结果传播为
|
|
9936
10215
|
* 诊断子会话 id)
|
|
9937
10216
|
* - 提交走宿主 compaction/* 生命周期事件(start 带 phase → summary → 替换消息 → end),
|
|
9938
10217
|
* 失败补 end(error,实际报错 + 诊断子会话 sessionId);替换消息 source 标记插件标识供 UI 认领
|
|
9939
10218
|
* - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
|
|
9940
|
-
*
|
|
10219
|
+
* ignorable 的 om 警告 plugin record(客户端渲染功能降级警告行,每会话同一
|
|
9941
10220
|
* 问题至多一次);
|
|
9942
10221
|
* 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
|
|
9943
10222
|
* 本轮跳过观察,反思换算系数按 1 计)
|
|
@@ -9990,31 +10269,33 @@ async function resolveCompressionEffort(ctx, session, config, target, logger) {
|
|
|
9990
10269
|
compressionEffortCache.set(cacheKey, resolved);
|
|
9991
10270
|
return resolved;
|
|
9992
10271
|
}
|
|
10272
|
+
/** 插件自产 user/message 的文本;其余事件返回 undefined。 */
|
|
10273
|
+
function pluginOwnedText(event) {
|
|
10274
|
+
if (event?.type !== "user/message") return void 0;
|
|
10275
|
+
if (!isPluginOwnedSource(event.data.source)) return void 0;
|
|
10276
|
+
return blocksToText(event.data.content);
|
|
10277
|
+
}
|
|
9993
10278
|
/**
|
|
9994
|
-
*
|
|
9995
|
-
*
|
|
10279
|
+
* 判定消息是否为本插件的归档块消息并返回整段文本:插件自产且文本以
|
|
10280
|
+
* <archived-history> 开标签起始;其余返回 undefined。
|
|
9996
10281
|
*/
|
|
9997
|
-
|
|
9998
|
-
const
|
|
9999
|
-
if (
|
|
10000
|
-
|
|
10001
|
-
|
|
10002
|
-
|
|
10003
|
-
|
|
10004
|
-
|
|
10005
|
-
}
|
|
10006
|
-
if (outcome.recordSessionId !== void 0) logger.step(`压缩会话记录子会话 ${outcome.recordSessionId}`);
|
|
10007
|
-
return outcome;
|
|
10282
|
+
function archivedHistoryTextOf(event) {
|
|
10283
|
+
const text = pluginOwnedText(event);
|
|
10284
|
+
if (text === void 0) return void 0;
|
|
10285
|
+
const head = text.trimStart();
|
|
10286
|
+
const open = `<${ARCHIVED_HISTORY_TAG}`;
|
|
10287
|
+
if (!head.startsWith(open)) return void 0;
|
|
10288
|
+
const next = head.charAt(open.length);
|
|
10289
|
+
return next === ">" || next === " " ? text : void 0;
|
|
10008
10290
|
}
|
|
10009
10291
|
/**
|
|
10010
10292
|
* 判定消息是否为本插件的压缩日志消息并提取日志文本(按 source 标记判断,兼容旧宿主
|
|
10011
|
-
* checkpoint 标记 'compact')。仅当消息文本含 <history>
|
|
10012
|
-
*
|
|
10293
|
+
* checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签且不是归档块时视为压缩
|
|
10294
|
+
* 日志,返回整段文本;其余返回 undefined。
|
|
10013
10295
|
*/
|
|
10014
10296
|
function historyTextOf(event) {
|
|
10015
|
-
|
|
10016
|
-
if (
|
|
10017
|
-
const text = blocksToText(event.data.content);
|
|
10297
|
+
const text = pluginOwnedText(event);
|
|
10298
|
+
if (text === void 0 || archivedHistoryTextOf(event) !== void 0) return void 0;
|
|
10018
10299
|
const idx = text.indexOf(`<${HISTORY_TAG}`);
|
|
10019
10300
|
if (idx === -1) return void 0;
|
|
10020
10301
|
const rest = text.slice(idx + 7 + 1);
|
|
@@ -10087,16 +10368,28 @@ function computeCompressRange(session, endMessageIndex) {
|
|
|
10087
10368
|
};
|
|
10088
10369
|
}
|
|
10089
10370
|
/**
|
|
10090
|
-
* 压缩边界(historySection
|
|
10091
|
-
*
|
|
10092
|
-
*
|
|
10093
|
-
* undefined。
|
|
10371
|
+
* 压缩边界(historySection):扫描表层全部节点,分别收集合法 <history> 块与
|
|
10372
|
+
* <archived-history> 归档块(内文 + seq,按表层顺序),并以两类块中表层位置最后的
|
|
10373
|
+
* 一个作为压缩边界——边界之后的消息视为未压缩,其前(含边界自身)视为已压缩。
|
|
10374
|
+
* 无压缩块时 blocks / archived 为空、boundarySeq 为 undefined。
|
|
10094
10375
|
*/
|
|
10095
10376
|
function historySection(session) {
|
|
10096
10377
|
const blocks = [];
|
|
10378
|
+
const archived = [];
|
|
10097
10379
|
let boundarySeq;
|
|
10380
|
+
const events = session.snapshotEvents();
|
|
10098
10381
|
for (const seq of session.surface.nodes) {
|
|
10099
|
-
const
|
|
10382
|
+
const event = events[seq];
|
|
10383
|
+
const archivedText = archivedHistoryTextOf(event);
|
|
10384
|
+
if (archivedText !== void 0) {
|
|
10385
|
+
archived.push({
|
|
10386
|
+
text: archivedText,
|
|
10387
|
+
seq
|
|
10388
|
+
});
|
|
10389
|
+
boundarySeq = seq;
|
|
10390
|
+
continue;
|
|
10391
|
+
}
|
|
10392
|
+
const text = historyTextOf(event);
|
|
10100
10393
|
if (text === void 0) continue;
|
|
10101
10394
|
blocks.push({
|
|
10102
10395
|
text,
|
|
@@ -10106,6 +10399,7 @@ function historySection(session) {
|
|
|
10106
10399
|
}
|
|
10107
10400
|
return {
|
|
10108
10401
|
blocks,
|
|
10402
|
+
archived,
|
|
10109
10403
|
boundarySeq
|
|
10110
10404
|
};
|
|
10111
10405
|
}
|
|
@@ -10224,113 +10518,221 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
|
|
|
10224
10518
|
});
|
|
10225
10519
|
}
|
|
10226
10520
|
/**
|
|
10227
|
-
*
|
|
10228
|
-
*
|
|
10229
|
-
*
|
|
10230
|
-
*
|
|
10521
|
+
* 反思(异步归档)检查:每个 pre-step 在观察前调用,不阻塞、不失败。
|
|
10522
|
+
* - 有运行中或待提交任务:跳过(待提交任务由 commitReflection 提交)
|
|
10523
|
+
* - 有失败任务:写 compaction/start + end(error) 后移除
|
|
10524
|
+
* - 无任务:history 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
|
|
10525
|
+
* 保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余归档,启动后台反思;
|
|
10526
|
+
* 同一块集合上次失败则不重试
|
|
10231
10527
|
*/
|
|
10232
|
-
|
|
10528
|
+
function reflectPass(ctx, agent, config, target, reasoningEffort) {
|
|
10233
10529
|
const session = agent.session;
|
|
10234
10530
|
const logger = makeLogger(ctx, config.debug);
|
|
10235
|
-
|
|
10236
|
-
|
|
10237
|
-
if (
|
|
10238
|
-
|
|
10239
|
-
|
|
10531
|
+
const job = peekReflectJob(session.id);
|
|
10532
|
+
if (job !== void 0 && job.session !== session) disposeReflection(session.id);
|
|
10533
|
+
else if (job?.state === "failed") {
|
|
10534
|
+
takeReflectJob(session.id);
|
|
10535
|
+
recordReflectFailure(session, job, logger);
|
|
10536
|
+
return;
|
|
10537
|
+
} else if (job !== void 0) {
|
|
10538
|
+
logger.step(job.state === "running" ? "反思:后台任务运行中,跳过" : "反思:结果待提交,跳过");
|
|
10539
|
+
return;
|
|
10240
10540
|
}
|
|
10541
|
+
startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger);
|
|
10542
|
+
}
|
|
10543
|
+
/**
|
|
10544
|
+
* 提交已完成的反思(pre-step 在 next() 之后、本 step 有待输入消息时调用):
|
|
10545
|
+
* 校验被归档块仍在表层且相邻后写 compaction/start → summary → 替换为 archived-history → end,
|
|
10546
|
+
* 返回需追加到本 step 的 skill 注入消息。无待提交任务、校验或提交失败返回空数组。
|
|
10547
|
+
*/
|
|
10548
|
+
function commitReflection(ctx, agent, config) {
|
|
10549
|
+
const session = agent.session;
|
|
10550
|
+
const job = peekReflectJob(session.id);
|
|
10551
|
+
if (job === void 0 || job.state !== "done") return [];
|
|
10552
|
+
takeReflectJob(session.id);
|
|
10553
|
+
if (job.session !== session) return [];
|
|
10554
|
+
return commitReflectJob(session, job, config, makeLogger(ctx, config.debug));
|
|
10555
|
+
}
|
|
10556
|
+
/** 触发检查:达到阈值且有可归档块时启动后台反思。 */
|
|
10557
|
+
function startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger) {
|
|
10241
10558
|
const threshold = config.reflectThresholdTokens;
|
|
10242
|
-
|
|
10559
|
+
logger.step(`反思检查(反思阈值 ${threshold} tokens)`);
|
|
10560
|
+
const { blocks } = historySection(session);
|
|
10561
|
+
if (blocks.length < 2) {
|
|
10562
|
+
logger.step(`反思:<history> 块 ${blocks.length} 个,无可归档块,跳过`);
|
|
10563
|
+
return;
|
|
10564
|
+
}
|
|
10565
|
+
const key = historyBlocksKey(blocks);
|
|
10566
|
+
if (reflectFailedKey(session.id) === key) {
|
|
10567
|
+
logger.step("反思:上次失败后 <history> 块未变化,跳过");
|
|
10568
|
+
return;
|
|
10569
|
+
}
|
|
10570
|
+
const estimatedTotal = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10243
10571
|
const measurement = measurePressure(ctx, session, logger);
|
|
10244
10572
|
const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10245
|
-
const tokens = Math.round(ratio *
|
|
10246
|
-
const
|
|
10573
|
+
const tokens = Math.round(ratio * estimatedTotal);
|
|
10574
|
+
const detail = `${tokens} tokens(估算 ${estimatedTotal} × 换算系数 ${ratio.toFixed(2)})`;
|
|
10247
10575
|
if (tokens < threshold) {
|
|
10248
|
-
logger.step(
|
|
10249
|
-
return
|
|
10576
|
+
logger.step(`反思:<history> 块 ${detail} < 阈值 ${threshold},跳过`);
|
|
10577
|
+
return;
|
|
10250
10578
|
}
|
|
10251
|
-
|
|
10252
|
-
|
|
10253
|
-
|
|
10254
|
-
|
|
10255
|
-
logger.step("反思:块区段缺失,跳过");
|
|
10256
|
-
return { failed: false };
|
|
10579
|
+
const { archived, kept } = selectArchiveBlocks(blocks, (block) => ratio * estimateTextTokens(block.text), threshold / 3);
|
|
10580
|
+
if (archived.length === 0) {
|
|
10581
|
+
logger.step("反思:尾部保留预算覆盖全部块,无可归档块,跳过");
|
|
10582
|
+
return;
|
|
10257
10583
|
}
|
|
10258
|
-
const view
|
|
10584
|
+
const { view, skills } = buildArchiveView(archived);
|
|
10259
10585
|
if (view.minIndex === void 0 || view.maxIndex === void 0) {
|
|
10260
|
-
logger.step("
|
|
10261
|
-
return
|
|
10586
|
+
logger.step("反思:被归档块内无可定位条目(历史遗留块),跳过");
|
|
10587
|
+
return;
|
|
10262
10588
|
}
|
|
10263
|
-
|
|
10589
|
+
startReflection({
|
|
10590
|
+
ctx,
|
|
10591
|
+
session,
|
|
10592
|
+
config,
|
|
10593
|
+
target,
|
|
10594
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort },
|
|
10595
|
+
key,
|
|
10596
|
+
archived,
|
|
10597
|
+
view,
|
|
10598
|
+
skills,
|
|
10599
|
+
estimatedTokens: archived.reduce((total, block) => total + estimateTextTokens(block.text), 0),
|
|
10600
|
+
shadowedCharCount: archived.reduce((total, block) => total + historyInnerText(block.text).length, 0)
|
|
10601
|
+
});
|
|
10602
|
+
logger.info(`反思:<history> 块 ${detail} ≥ 阈值 ${threshold},后台归档 ${archived.length} 个块,保留 ${kept.length} 个`);
|
|
10603
|
+
}
|
|
10604
|
+
/** 失败任务:在当前开放 turn 内写 compaction/start + end(error);中止的任务不记录。 */
|
|
10605
|
+
function recordReflectFailure(session, job, logger) {
|
|
10606
|
+
const failure = job.failure;
|
|
10607
|
+
if (failure === void 0 || failure.aborted) return;
|
|
10264
10608
|
const lifecycle = {
|
|
10265
10609
|
compactionId: newCompactionId(),
|
|
10266
10610
|
turn: openTurnOf(session)
|
|
10267
10611
|
};
|
|
10268
10612
|
try {
|
|
10269
|
-
logger.step("反思:追加 compaction/start(压缩循环前开启压缩中提示)");
|
|
10270
10613
|
appendCompactionStart(session, lifecycle, "reflect");
|
|
10614
|
+
appendCompactionEnd(session, lifecycle, failure.error, failure.diagnosticSessionId);
|
|
10271
10615
|
} catch (error) {
|
|
10272
10616
|
const message = error instanceof Error ? error.message : String(error);
|
|
10273
|
-
logger.warn(
|
|
10274
|
-
return { failed: false };
|
|
10617
|
+
logger.warn(`反思失败记录追加失败: ${message}`);
|
|
10275
10618
|
}
|
|
10276
|
-
|
|
10277
|
-
|
|
10278
|
-
|
|
10279
|
-
|
|
10280
|
-
|
|
10281
|
-
|
|
10282
|
-
|
|
10283
|
-
|
|
10284
|
-
|
|
10285
|
-
|
|
10286
|
-
|
|
10287
|
-
|
|
10288
|
-
|
|
10289
|
-
|
|
10290
|
-
|
|
10291
|
-
|
|
10292
|
-
|
|
10293
|
-
|
|
10619
|
+
}
|
|
10620
|
+
/** 被归档块仍在表层且在表层顺序中相邻。 */
|
|
10621
|
+
function archivedBlocksIntact(session, job) {
|
|
10622
|
+
const nodes = session.surface.nodes;
|
|
10623
|
+
const first = job.archived[0];
|
|
10624
|
+
if (first === void 0) return false;
|
|
10625
|
+
const start = nodes.indexOf(SessionSeq(first.seq));
|
|
10626
|
+
if (start < 0) return false;
|
|
10627
|
+
return job.archived.every((block, i) => nodes[start + i] === block.seq);
|
|
10628
|
+
}
|
|
10629
|
+
/** 提交成功任务;返回需注入的 skill 消息(表层已有同名 skill 的不注入)。 */
|
|
10630
|
+
function commitReflectJob(session, job, config, logger) {
|
|
10631
|
+
const result = job.result;
|
|
10632
|
+
const first = job.archived[0];
|
|
10633
|
+
const last = job.archived[job.archived.length - 1];
|
|
10634
|
+
if (result === void 0 || first === void 0 || last === void 0) return [];
|
|
10635
|
+
if (!archivedBlocksIntact(session, job)) {
|
|
10636
|
+
logger.info("反思:被归档块已不在表层或不再相邻,丢弃本次结果");
|
|
10637
|
+
return [];
|
|
10638
|
+
}
|
|
10639
|
+
const blockSeqs = job.archived.map((block) => block.seq);
|
|
10640
|
+
const lifecycle = {
|
|
10641
|
+
compactionId: newCompactionId(),
|
|
10642
|
+
turn: openTurnOf(session)
|
|
10294
10643
|
};
|
|
10295
|
-
const report = summaryResult.text;
|
|
10296
10644
|
try {
|
|
10297
|
-
|
|
10645
|
+
appendCompactionStart(session, lifecycle, "reflect");
|
|
10646
|
+
} catch (error) {
|
|
10647
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10648
|
+
logger.warn(`反思提交启动失败: ${message}`);
|
|
10649
|
+
return [];
|
|
10650
|
+
}
|
|
10651
|
+
try {
|
|
10298
10652
|
const summarySeq = appendCompactionSummary(session, {
|
|
10299
10653
|
lifecycle,
|
|
10300
|
-
summary:
|
|
10654
|
+
summary: result.text,
|
|
10301
10655
|
shadowedRange: {
|
|
10302
10656
|
start: first.seq,
|
|
10303
10657
|
end: last.seq
|
|
10304
10658
|
},
|
|
10305
10659
|
shadowedSeqs: blockSeqs,
|
|
10306
|
-
shadowedTokenCount: estimatedTokens,
|
|
10307
|
-
shadowedCharCount,
|
|
10308
|
-
provider: target.provider,
|
|
10309
|
-
model: target.model,
|
|
10660
|
+
shadowedTokenCount: job.estimatedTokens,
|
|
10661
|
+
shadowedCharCount: job.shadowedCharCount,
|
|
10662
|
+
provider: job.target.provider,
|
|
10663
|
+
model: job.target.model,
|
|
10310
10664
|
maxTokens: config.compressMaxTokens,
|
|
10311
|
-
stats:
|
|
10312
|
-
...
|
|
10313
|
-
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
10665
|
+
stats: result.stats,
|
|
10666
|
+
...result.usage === void 0 ? {} : { usage: result.usage },
|
|
10667
|
+
...job.reasoningEffort === void 0 ? {} : { reasoningEffort: job.reasoningEffort }
|
|
10314
10668
|
});
|
|
10315
|
-
|
|
10316
|
-
appendHistoryMessage(session, report, [summarySeq, ...blockSeqs], {
|
|
10669
|
+
appendHistoryMessage(session, result.text, [summarySeq, ...blockSeqs], {
|
|
10317
10670
|
op: "replace",
|
|
10318
10671
|
startSeq: first.seq,
|
|
10319
10672
|
endSeq: last.seq
|
|
10320
10673
|
}, lifecycle.compactionId);
|
|
10321
|
-
|
|
10322
|
-
appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
|
|
10323
|
-
logger.info(`反思完成(摘要 ${tokens} tokens ≥ 阈值 ${threshold},合并 ${blocks.length} 个块为一条)`);
|
|
10324
|
-
return { failed: false };
|
|
10674
|
+
appendCompactionEnd(session, lifecycle, void 0, result.recordSessionId);
|
|
10325
10675
|
} catch (error) {
|
|
10326
10676
|
const message = error instanceof Error ? error.message : String(error);
|
|
10327
10677
|
logger.warn(`反思提交失败: ${message}`);
|
|
10328
10678
|
try {
|
|
10329
|
-
appendCompactionEnd(session, lifecycle, message, void 0,
|
|
10679
|
+
appendCompactionEnd(session, lifecycle, message, void 0, result.stats.durationMs);
|
|
10330
10680
|
} catch {}
|
|
10331
|
-
return
|
|
10681
|
+
return [];
|
|
10682
|
+
}
|
|
10683
|
+
const live = liveSkillNames(session);
|
|
10684
|
+
const messages = job.skills.filter((skill) => !live.has(skill.name)).map((skill) => createUserMessage({
|
|
10685
|
+
content: [{
|
|
10686
|
+
type: "text",
|
|
10687
|
+
text: skill.content
|
|
10688
|
+
}],
|
|
10689
|
+
source: {
|
|
10690
|
+
kind: SKILL_INVOCATION_KIND,
|
|
10691
|
+
name: skill.name,
|
|
10692
|
+
form: "instructions"
|
|
10693
|
+
}
|
|
10694
|
+
}));
|
|
10695
|
+
logger.info(`反思提交:${job.archived.length} 个 <history> 块归档为 archived-history,注入 ${messages.length} 个 skill`);
|
|
10696
|
+
return messages;
|
|
10697
|
+
}
|
|
10698
|
+
/** 表层中仍以 skill 形态存在的名称:history 块内 skill_content、手动加载消息、skill 工具调用。 */
|
|
10699
|
+
function liveSkillNames(session) {
|
|
10700
|
+
const names = /* @__PURE__ */ new Set();
|
|
10701
|
+
const events = session.snapshotEvents();
|
|
10702
|
+
for (const seq of session.surface.nodes) {
|
|
10703
|
+
const event = events[seq];
|
|
10704
|
+
if (event === void 0) continue;
|
|
10705
|
+
const history = historyTextOf(event);
|
|
10706
|
+
if (history !== void 0) {
|
|
10707
|
+
for (const match of history.matchAll(/<skill_content name="([^"]*)"/g)) names.add(unescapeAttr(match[1] ?? ""));
|
|
10708
|
+
continue;
|
|
10709
|
+
}
|
|
10710
|
+
if (event.type === "user/message") {
|
|
10711
|
+
const source = event.data.source;
|
|
10712
|
+
if (source.kind === "skill-invocation" && typeof source.name === "string") names.add(source.name);
|
|
10713
|
+
continue;
|
|
10714
|
+
}
|
|
10715
|
+
if (event.type === "assistant/message") for (const block of event.data.message.content) {
|
|
10716
|
+
if (block.type !== "tool-call" || block.name !== "skill") continue;
|
|
10717
|
+
const name = skillArgName(block.arguments);
|
|
10718
|
+
if (name !== void 0) names.add(name);
|
|
10719
|
+
}
|
|
10720
|
+
}
|
|
10721
|
+
return names;
|
|
10722
|
+
}
|
|
10723
|
+
/** skill 工具调用参数中的 name;参数非法时 undefined。 */
|
|
10724
|
+
function skillArgName(args) {
|
|
10725
|
+
try {
|
|
10726
|
+
const parsed = JSON.parse(args);
|
|
10727
|
+
return typeof parsed?.name === "string" ? parsed.name : void 0;
|
|
10728
|
+
} catch {
|
|
10729
|
+
return;
|
|
10332
10730
|
}
|
|
10333
10731
|
}
|
|
10732
|
+
/** XML 属性值反转义。 */
|
|
10733
|
+
function unescapeAttr(value) {
|
|
10734
|
+
return value.replaceAll(""", "\"").replaceAll("<", "<").replaceAll(">", ">").replaceAll("'", "'").replaceAll("&", "&");
|
|
10735
|
+
}
|
|
10334
10736
|
/**
|
|
10335
10737
|
* 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
|
|
10336
10738
|
* systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
|
|
@@ -10546,8 +10948,8 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
|
|
|
10546
10948
|
const threshold = config.observeThresholdTokens;
|
|
10547
10949
|
const measurement = measurePressure(ctx, session, logger);
|
|
10548
10950
|
if (measurement === void 0) return { failed: false };
|
|
10549
|
-
const { blocks } = historySection(session);
|
|
10550
|
-
const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10951
|
+
const { blocks, archived } = historySection(session);
|
|
10952
|
+
const historyTokens = [...blocks, ...archived].reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10551
10953
|
const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
|
|
10552
10954
|
const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10553
10955
|
const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
|
|
@@ -10688,9 +11090,9 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
|
|
|
10688
11090
|
});
|
|
10689
11091
|
}
|
|
10690
11092
|
/**
|
|
10691
|
-
* 压力检查 +
|
|
10692
|
-
*
|
|
10693
|
-
*
|
|
11093
|
+
* 压力检查 + 两级压缩入口(pre-step 调用,仅主会话生效):
|
|
11094
|
+
* 先反思(异步:只启动或提交后台任务,不阻塞、不失败),后观察(阻塞注入)。
|
|
11095
|
+
* 观察失败传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
|
|
10694
11096
|
*/
|
|
10695
11097
|
async function maybeCompress(ctx, agent, config, signal) {
|
|
10696
11098
|
const session = agent.session;
|
|
@@ -10708,11 +11110,7 @@ async function maybeCompress(ctx, agent, config, signal) {
|
|
|
10708
11110
|
const reasoningEffort = await resolveCompressionEffort(ctx, session, config, target, logger);
|
|
10709
11111
|
const waitCount = config.tailMessageCount;
|
|
10710
11112
|
logger.step("反思 pass 开始");
|
|
10711
|
-
|
|
10712
|
-
if (reflect.failed) {
|
|
10713
|
-
logger.step("反思 pass 失败(本轮将被拒绝),跳过观察 pass");
|
|
10714
|
-
return reflect;
|
|
10715
|
-
}
|
|
11113
|
+
reflectPass(ctx, agent, config, target, reasoningEffort);
|
|
10716
11114
|
logger.step("反思 pass 结束,观察 pass 开始");
|
|
10717
11115
|
const observe = await observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort);
|
|
10718
11116
|
logger.step("观察 pass 结束,压缩流程完成");
|
|
@@ -10934,7 +11332,7 @@ function cosineSimilarity(a, b) {
|
|
|
10934
11332
|
/** 默认配置(冻结对象,resolveConfig 合并的基底;debug 缺省值在解析时按 NODE_ENV 判定)。 */
|
|
10935
11333
|
const DEFAULT_CONFIG = Object.freeze({
|
|
10936
11334
|
observeThresholdTokens: 35e3,
|
|
10937
|
-
reflectThresholdTokens:
|
|
11335
|
+
reflectThresholdTokens: 8e4,
|
|
10938
11336
|
compressMaxTokens: void 0,
|
|
10939
11337
|
rateLimitWaitMs: 6e4,
|
|
10940
11338
|
recompressConcurrency: 2,
|
|
@@ -10946,7 +11344,6 @@ const DEFAULT_CONFIG = Object.freeze({
|
|
|
10946
11344
|
progressReminderIdleSteps: 4,
|
|
10947
11345
|
progressReminderIdleToolCalls: 10,
|
|
10948
11346
|
debug: false,
|
|
10949
|
-
recallEnabled: true,
|
|
10950
11347
|
semanticRecallEnabled: true,
|
|
10951
11348
|
modelDir: sharedModelDir(),
|
|
10952
11349
|
compressProvider: void 0,
|
|
@@ -10968,7 +11365,6 @@ const Config = Schema.object({
|
|
|
10968
11365
|
progressReminderIdleSteps: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.progressReminderIdleSteps).volatile(),
|
|
10969
11366
|
progressReminderIdleToolCalls: Schema.number().step(1).min(0).default(DEFAULT_CONFIG.progressReminderIdleToolCalls).volatile(),
|
|
10970
11367
|
debug: Schema.boolean().default(process.env.NODE_ENV !== "production").volatile(),
|
|
10971
|
-
recallEnabled: Schema.boolean().default(DEFAULT_CONFIG.recallEnabled).volatile(),
|
|
10972
11368
|
semanticRecallEnabled: Schema.boolean().default(DEFAULT_CONFIG.semanticRecallEnabled).volatile(),
|
|
10973
11369
|
modelDir: Schema.string().default(DEFAULT_CONFIG.modelDir).volatile(),
|
|
10974
11370
|
compressProvider: Schema.string().volatile(),
|
|
@@ -11044,8 +11440,7 @@ function resolveConfig(raw) {
|
|
|
11044
11440
|
config.progressReminderEnabled = resolveBoolean(input.progressReminderEnabled, true);
|
|
11045
11441
|
config.progressReminderIdleEnabled = resolveBoolean(input.progressReminderIdleEnabled, DEFAULT_CONFIG.progressReminderIdleEnabled);
|
|
11046
11442
|
config.debug = resolveBoolean(input.debug, process.env.NODE_ENV !== "production");
|
|
11047
|
-
config.
|
|
11048
|
-
config.semanticRecallEnabled = config.recallEnabled && resolveBoolean(input.semanticRecallEnabled, true);
|
|
11443
|
+
config.semanticRecallEnabled = resolveBoolean(input.semanticRecallEnabled, true);
|
|
11049
11444
|
const modelDir = input.modelDir;
|
|
11050
11445
|
if (typeof modelDir === "string" && modelDir.trim() !== "") config.modelDir = modelDir;
|
|
11051
11446
|
config.compressProvider = resolveOptionalString(input.compressProvider);
|
|
@@ -11256,11 +11651,14 @@ function renderCompleteMessageXml(session, cm, options = {}) {
|
|
|
11256
11651
|
//#endregion
|
|
11257
11652
|
//#region src/semantic-recall.ts
|
|
11258
11653
|
/**
|
|
11259
|
-
* recall
|
|
11260
|
-
*
|
|
11654
|
+
* recall 的 query 检索实现:对会话全部完整消息(含被压缩/遮蔽的)检索,返回最匹配的
|
|
11655
|
+
* 完整消息与匹配说明。
|
|
11261
11656
|
* 导出 SemanticOptions / RangeArgs / resolveSemanticRange / tokenize / matchExplanation /
|
|
11262
|
-
* SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch。
|
|
11263
|
-
*
|
|
11657
|
+
* keywordTerms / SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch / keywordSearch。
|
|
11658
|
+
* - 语义检索:本地 ONNX 嵌入(cosine 相似度)
|
|
11659
|
+
* - 字符串匹配(语义增强关闭时):query 按空白拆词,不区分大小写计命中词数,同分时
|
|
11660
|
+
* index 大的优先,零命中不返回
|
|
11661
|
+
* 只匹配文本,纯图片消息不进候选池;
|
|
11264
11662
|
* 区间缺省检索全部、区间不合法回退全量并在输出中告知;输出契约同 recall
|
|
11265
11663
|
* ({ text, images },条目为 XML 形态见 recall-xml.ts,超大结果由 tool-result-pruner
|
|
11266
11664
|
* 裁剪);候选池排除本次调用自身的 toolcall 完整消息(其渲染文本含 query 原文,
|
|
@@ -11332,13 +11730,11 @@ function matchExplanation(query, text, score) {
|
|
|
11332
11730
|
}
|
|
11333
11731
|
/** 模型未就绪时返回给模型的文案(下载完成后直接再次调用即可)。 */
|
|
11334
11732
|
const SEMANTIC_MODEL_NOT_READY_MESSAGE = "语义检索暂不可用,本地向量模型尚未就绪。";
|
|
11335
|
-
/**
|
|
11336
|
-
|
|
11337
|
-
const { session,
|
|
11338
|
-
const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
|
|
11339
|
-
if ((await options?.modelStatus?.() ?? "ready") !== "ready") return textOnly(SEMANTIC_MODEL_NOT_READY_MESSAGE);
|
|
11733
|
+
/** 收集区间内可检索的候选;会话为空或区间内无候选时返回提示文案。 */
|
|
11734
|
+
function collectCandidates(input) {
|
|
11735
|
+
const { session, start, end, offset, selfCallId } = input;
|
|
11340
11736
|
const cms = indexCompleteMessages(session);
|
|
11341
|
-
if (cms.length === 0) return
|
|
11737
|
+
if (cms.length === 0) return "会话中没有可检索的消息";
|
|
11342
11738
|
const range = resolveSemanticRange(cms.length, {
|
|
11343
11739
|
start,
|
|
11344
11740
|
end,
|
|
@@ -11358,7 +11754,20 @@ async function semanticSearch(input) {
|
|
|
11358
11754
|
text
|
|
11359
11755
|
});
|
|
11360
11756
|
}
|
|
11361
|
-
if (candidates.length === 0) return
|
|
11757
|
+
if (candidates.length === 0) return "指定范围内没有可检索的消息";
|
|
11758
|
+
return {
|
|
11759
|
+
candidates,
|
|
11760
|
+
range
|
|
11761
|
+
};
|
|
11762
|
+
}
|
|
11763
|
+
/** 在会话完整消息中做语义检索,返回 TOP-K 命中条目。 */
|
|
11764
|
+
async function semanticSearch(input) {
|
|
11765
|
+
const { query, topK, options } = input;
|
|
11766
|
+
const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
|
|
11767
|
+
if ((await options?.modelStatus?.() ?? "ready") !== "ready") return textOnly(SEMANTIC_MODEL_NOT_READY_MESSAGE);
|
|
11768
|
+
const collected = collectCandidates(input);
|
|
11769
|
+
if (typeof collected === "string") return textOnly(collected);
|
|
11770
|
+
const { candidates, range } = collected;
|
|
11362
11771
|
const [queryVec] = await embed([query]);
|
|
11363
11772
|
if (!queryVec) return textOnly("语义检索失败:无法生成查询向量");
|
|
11364
11773
|
const vectors = await embed(candidates.map((c) => c.text));
|
|
@@ -11368,18 +11777,53 @@ async function semanticSearch(input) {
|
|
|
11368
11777
|
score: cosineSimilarity(queryVec, vectors[i] ?? /* @__PURE__ */ new Float32Array(0))
|
|
11369
11778
|
}));
|
|
11370
11779
|
scored.sort((a, b) => b.score - a.score);
|
|
11371
|
-
const
|
|
11372
|
-
|
|
11780
|
+
const hits = scored.slice(0, topK ?? 3).map((hit) => ({
|
|
11781
|
+
...hit,
|
|
11782
|
+
explanation: matchExplanation(query, hit.text, hit.score)
|
|
11783
|
+
}));
|
|
11784
|
+
return renderHits(input, range, `${candidates.length} 条可嵌入`, scored.length, hits);
|
|
11785
|
+
}
|
|
11786
|
+
/** 字符串匹配的检索词:query 按空白拆分、转小写、去重。 */
|
|
11787
|
+
function keywordTerms(query) {
|
|
11788
|
+
return [...new Set(query.toLowerCase().split(/\s+/u).filter((term) => term.length > 0))];
|
|
11789
|
+
}
|
|
11790
|
+
/** 在会话完整消息中按字符串匹配检索(语义增强关闭时),返回 TOP-K 命中条目。 */
|
|
11791
|
+
function keywordSearch(input) {
|
|
11792
|
+
const terms = keywordTerms(input.query);
|
|
11793
|
+
if (terms.length === 0) return textOnly("query 不能为空");
|
|
11794
|
+
const collected = collectCandidates(input);
|
|
11795
|
+
if (typeof collected === "string") return textOnly(collected);
|
|
11796
|
+
const { candidates, range } = collected;
|
|
11797
|
+
const scored = candidates.map((c) => {
|
|
11798
|
+
const lower = c.text.toLowerCase();
|
|
11799
|
+
const matched = terms.filter((term) => lower.includes(term));
|
|
11800
|
+
return {
|
|
11801
|
+
...c,
|
|
11802
|
+
score: matched.length,
|
|
11803
|
+
matched
|
|
11804
|
+
};
|
|
11805
|
+
}).filter((c) => c.score > 0);
|
|
11806
|
+
if (scored.length === 0) return textOnly(`未找到包含 ${terms.join(" ")} 中任一词的消息(字符串匹配,不区分大小写)`);
|
|
11807
|
+
scored.sort((a, b) => b.score - a.score || b.cm.index - a.cm.index);
|
|
11808
|
+
const hits = scored.slice(0, input.topK ?? 3).map((hit) => ({
|
|
11809
|
+
...hit,
|
|
11810
|
+
explanation: `命中 ${hit.score}/${terms.length} 个词: ${hit.matched.join(" ")}`
|
|
11811
|
+
}));
|
|
11812
|
+
return renderHits(input, range, `${candidates.length} 条,字符串匹配`, scored.length, hits);
|
|
11813
|
+
}
|
|
11814
|
+
/** 渲染命中条目:查询与检索说明以 XML 注释置于条目之前,每条命中前附匹配说明。 */
|
|
11815
|
+
function renderHits(input, range, poolNote, total, hits) {
|
|
11816
|
+
const { session, query, start, getPruner } = input;
|
|
11373
11817
|
const parts = [];
|
|
11374
11818
|
const images = [];
|
|
11375
|
-
const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${
|
|
11819
|
+
const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${poolNote})` : `检索区间 [${range.lo}..${range.hi}](${poolNote})`;
|
|
11376
11820
|
parts.push(`<!-- ${xmlCommentText(`查询: ${query}`)} -->`);
|
|
11377
11821
|
parts.push(`<!-- ${xmlCommentText(rangeNote)} -->`);
|
|
11378
|
-
parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${
|
|
11822
|
+
parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${total} 条候选)`)} -->`);
|
|
11379
11823
|
for (let i = 0; i < hits.length; i += 1) {
|
|
11380
11824
|
const hit = hits[i];
|
|
11381
11825
|
if (!hit) continue;
|
|
11382
|
-
const note = `<!-- ${xmlCommentText(`${i + 1}. ${
|
|
11826
|
+
const note = `<!-- ${xmlCommentText(`${i + 1}. ${hit.explanation}`)} -->`;
|
|
11383
11827
|
let xml;
|
|
11384
11828
|
let hitImages = [];
|
|
11385
11829
|
try {
|
|
@@ -11405,28 +11849,20 @@ async function semanticSearch(input) {
|
|
|
11405
11849
|
//#endregion
|
|
11406
11850
|
//#region src/recall.ts
|
|
11407
11851
|
/**
|
|
11408
|
-
* recall
|
|
11409
|
-
* 导出 recallArgsSchema /
|
|
11852
|
+
* recall 工具:回看原始会话(含被压缩内容)。
|
|
11853
|
+
* 导出 recallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
|
|
11410
11854
|
* - 区间模式:按完整消息 index 的 start/end/offset 精确返回区间内全部完整消息。
|
|
11411
|
-
* -
|
|
11855
|
+
* - 检索模式(带 query):语义增强启用时按含义检索,否则按字符串匹配,见 semantic-recall.ts。
|
|
11412
11856
|
* 输出值为 { text, images }(契约见 recall-output.ts),text 为 XML 条目序列
|
|
11413
11857
|
* (形态见 recall-xml.ts);recall 自身不设输出上限,超大工具结果由 tool-result-pruner 裁剪。
|
|
11414
11858
|
*/
|
|
11415
11859
|
/**
|
|
11416
|
-
*
|
|
11860
|
+
* recall 参数 schema:带 query 走检索模式(区间可选,用于限定检索范围);
|
|
11861
|
+
* 不带 query 时 start 必填,end 与 offset 至少提供一个(同时给出时 end 优先)。
|
|
11417
11862
|
* 各字段描述经 .describe() 透传到 wire JSON Schema。
|
|
11418
11863
|
*/
|
|
11419
11864
|
const recallArgsSchema = z.object({
|
|
11420
|
-
|
|
11421
|
-
end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
|
|
11422
|
-
offset: z.number().optional().describe("与 end 互斥,相对 start 的步数(正向后、负向前)。")
|
|
11423
|
-
}).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
|
|
11424
|
-
/**
|
|
11425
|
-
* 语义增强 recall 参数 schema:带 query 走语义模式(区间可选,用于限定检索范围),
|
|
11426
|
-
* 不带 query 时与基础 schema 的校验一致。
|
|
11427
|
-
*/
|
|
11428
|
-
const enhancedRecallArgsSchema = z.object({
|
|
11429
|
-
query: z.string().optional().describe("按含义检索的自然语言 query(中英文与代码术语皆可,如 \"修复 retry backoff 的逻辑\");提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
|
|
11865
|
+
query: z.string().optional().describe("检索 query(中英文与代码术语皆可);提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
|
|
11430
11866
|
top_k: z.number().int().min(1).max(10).optional().describe("仅 query 模式:返回最匹配条数(1-10,默认 3)。"),
|
|
11431
11867
|
start: z.number().optional().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;未提供 query 时必填,且 end 与 offset 至少提供一个(同时给出时 end 优先)。"),
|
|
11432
11868
|
end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
|
|
@@ -11451,47 +11887,50 @@ const enhancedRecallArgsSchema = z.object({
|
|
|
11451
11887
|
message: "end 与 offset 至少提供一个"
|
|
11452
11888
|
});
|
|
11453
11889
|
});
|
|
11454
|
-
/** 解析并校验 recall
|
|
11455
|
-
function parseRecallArgs(raw
|
|
11456
|
-
const result =
|
|
11890
|
+
/** 解析并校验 recall 调用参数:失败时抛出首个校验问题的可读消息。 */
|
|
11891
|
+
function parseRecallArgs(raw) {
|
|
11892
|
+
const result = recallArgsSchema.safeParse(raw);
|
|
11457
11893
|
if (!result.success) throw new Error(result.error.issues.map((issue) => `${issue.path.join(".") || "args"}: ${issue.message}`).join("; "));
|
|
11458
11894
|
return result.data;
|
|
11459
11895
|
}
|
|
11460
|
-
/**
|
|
11461
|
-
|
|
11462
|
-
|
|
11463
|
-
|
|
11896
|
+
/** 工具描述:两种用法;query 的匹配方式随语义增强开关变化。 */
|
|
11897
|
+
function recallDescription(semantic) {
|
|
11898
|
+
return `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}两种用法:1) 给出 start 与 end 或 offset,按 index 区间精确返回区间内全部完整消息的内容;2) 给出 query,${semantic ? "按自然语言含义检索最符合的完整消息" : "按字符串匹配检索完整消息(query 按空白拆词、不区分大小写,按命中词数排序,宜用原文中出现的文件名、函数名、错误码或 key-word 关键词)"},默认全量搜索,可用 start/end/offset 限定区间。注意:query 只匹配文本。`;
|
|
11899
|
+
}
|
|
11464
11900
|
/**
|
|
11465
|
-
* 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index
|
|
11466
|
-
*
|
|
11901
|
+
* 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index),
|
|
11902
|
+
* 或按 query 检索(传入 semantic 选项时语义检索,否则字符串匹配)。
|
|
11467
11903
|
*/
|
|
11468
11904
|
function buildRecallTool(options) {
|
|
11469
11905
|
const getPruner = options?.getPruner;
|
|
11470
11906
|
const semantic = options?.semantic;
|
|
11471
11907
|
return {
|
|
11472
11908
|
name: "recall",
|
|
11473
|
-
description: semantic
|
|
11474
|
-
parameters: parametersFromZod(
|
|
11909
|
+
description: recallDescription(semantic !== void 0),
|
|
11910
|
+
parameters: parametersFromZod(recallArgsSchema),
|
|
11475
11911
|
output: {
|
|
11476
11912
|
schema: RECALL_OUTPUT_SCHEMA,
|
|
11477
11913
|
render: (_args, value) => renderRecallOutput(value)
|
|
11478
11914
|
},
|
|
11479
11915
|
async execute(args, exec) {
|
|
11480
|
-
const { query, top_k, start, end, offset } = parseRecallArgs(args
|
|
11916
|
+
const { query, top_k, start, end, offset } = parseRecallArgs(args);
|
|
11481
11917
|
const session = exec.agent?.session;
|
|
11482
11918
|
if (!session) return textOnly("会话异常");
|
|
11483
11919
|
if (!isMainSession(session)) return textOnly("recall 仅主会话可用");
|
|
11484
|
-
if (query !== void 0)
|
|
11485
|
-
|
|
11486
|
-
|
|
11487
|
-
|
|
11488
|
-
|
|
11489
|
-
|
|
11490
|
-
|
|
11491
|
-
|
|
11492
|
-
|
|
11493
|
-
|
|
11494
|
-
|
|
11920
|
+
if (query !== void 0) {
|
|
11921
|
+
const input = {
|
|
11922
|
+
session,
|
|
11923
|
+
query,
|
|
11924
|
+
topK: top_k,
|
|
11925
|
+
start,
|
|
11926
|
+
end,
|
|
11927
|
+
offset,
|
|
11928
|
+
selfCallId: String(exec.callId ?? ""),
|
|
11929
|
+
getPruner: () => getPruner?.(),
|
|
11930
|
+
options: semantic
|
|
11931
|
+
};
|
|
11932
|
+
return semantic ? semanticSearch(input) : keywordSearch(input);
|
|
11933
|
+
}
|
|
11495
11934
|
if (start === void 0) return textOnly("start 必填");
|
|
11496
11935
|
const cms = indexCompleteMessages(session);
|
|
11497
11936
|
const startIndex = Number.isFinite(start) ? Math.floor(start) : 0;
|
|
@@ -11615,15 +12054,15 @@ function findLifecycle(session, compactionId) {
|
|
|
11615
12054
|
}
|
|
11616
12055
|
return lifecycle;
|
|
11617
12056
|
}
|
|
11618
|
-
/**
|
|
12057
|
+
/** 重建被压缩内容的视图:反思用被归档块的归档视图,观察用原消息;不可重建时返回错误。 */
|
|
11619
12058
|
function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
|
|
11620
|
-
if (phase === "reflect") return
|
|
12059
|
+
if (phase === "reflect") return buildArchiveView(shadowedSeqs.flatMap((seq) => {
|
|
11621
12060
|
const text = historyTextOf(session.snapshotEvents()[seq]);
|
|
11622
12061
|
return text === void 0 ? [] : [{
|
|
11623
12062
|
text,
|
|
11624
12063
|
seq
|
|
11625
12064
|
}];
|
|
11626
|
-
})
|
|
12065
|
+
})).view;
|
|
11627
12066
|
return buildObserveView(session, shadowedSeqs, { skipReasoning });
|
|
11628
12067
|
}
|
|
11629
12068
|
/** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
|
|
@@ -11680,7 +12119,7 @@ async function recompress(ctx, agent, config, request, signal) {
|
|
|
11680
12119
|
view,
|
|
11681
12120
|
originalChars,
|
|
11682
12121
|
phase,
|
|
11683
|
-
taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex),
|
|
12122
|
+
taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex, view.segments),
|
|
11684
12123
|
target,
|
|
11685
12124
|
maxTokens: config.compressMaxTokens,
|
|
11686
12125
|
rateLimitWaitMs: config.rateLimitWaitMs,
|
|
@@ -11880,7 +12319,8 @@ function ensureSystemReminders(session, messages, reminders, idle = DEFAULT_PROG
|
|
|
11880
12319
|
* 导出 staleAssistantIds / isAnthropicSigned / stripReasoning / sanitizeMessages /
|
|
11881
12320
|
* registerThinkingBinding。
|
|
11882
12321
|
*
|
|
11883
|
-
* -
|
|
12322
|
+
* - 分界:seq 最大的 OM 消息(最新一次替换检查点)。观察压缩时其位于表层最后;
|
|
12323
|
+
* 反思提交的归档块追加在日志尾部但表层位于保留的旧 H 块之前,故按 seq 选取
|
|
11884
12324
|
* - 过期:分界之后 seq 小于分界的 assistant/message,即生成于该次替换之前
|
|
11885
12325
|
* - 仅剥离 Anthropic 签名:replayState api 为 Anthropic 协议、模型名含 claude-、
|
|
11886
12326
|
* 且带签名或 redacted 的 reasoning;其余模型的签名校验不绑定前缀,保持原样
|
|
@@ -11893,22 +12333,23 @@ const CLAUDE_MODEL = /\bclaude-/i;
|
|
|
11893
12333
|
function isRecord(value) {
|
|
11894
12334
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
11895
12335
|
}
|
|
11896
|
-
/**
|
|
12336
|
+
/** 返回前缀已被最新 OM 消息改写的 assistant 消息 id;无 OM 消息时为空。 */
|
|
11897
12337
|
function staleAssistantIds(session) {
|
|
11898
12338
|
const stale = /* @__PURE__ */ new Set();
|
|
11899
12339
|
const events = session.snapshotEvents();
|
|
11900
12340
|
const nodes = session.surface.nodes;
|
|
11901
12341
|
let boundary = -1;
|
|
11902
|
-
|
|
12342
|
+
let boundarySeq = -1;
|
|
12343
|
+
for (let i = 0; i < nodes.length; i += 1) {
|
|
11903
12344
|
const seq = nodes[i];
|
|
11904
|
-
|
|
11905
|
-
|
|
12345
|
+
if (seq === void 0) continue;
|
|
12346
|
+
const event = events[seq];
|
|
12347
|
+
if (event?.type === "user/message" && event.data.source?.kind === "plugin:dsh-plugin-om" && seq > boundarySeq) {
|
|
11906
12348
|
boundary = i;
|
|
11907
|
-
|
|
12349
|
+
boundarySeq = seq;
|
|
11908
12350
|
}
|
|
11909
12351
|
}
|
|
11910
|
-
|
|
11911
|
-
if (boundarySeq === void 0) return stale;
|
|
12352
|
+
if (boundarySeq < 0) return stale;
|
|
11912
12353
|
for (const seq of nodes.slice(boundary + 1)) {
|
|
11913
12354
|
const event = events[seq];
|
|
11914
12355
|
if (event?.type === "assistant/message" && seq < boundarySeq) stale.add(event.data.message.id);
|
|
@@ -12002,7 +12443,7 @@ function apply(ctx, config) {
|
|
|
12002
12443
|
logger.step(`apply 启动:observeThresholdTokens=${String(resolved.observeThresholdTokens)} reflectThresholdTokens=${String(resolved.reflectThresholdTokens)} compressMaxTokens=${resolved.compressMaxTokens === void 0 ? "未设置" : String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} omEnabled=${String(resolved.omEnabled)} debug=${String(resolved.debug)} compressProvider=${resolved.compressProvider ?? "跟随会话路由"} compressModel=${resolved.compressModel ?? "跟随会话路由"} compressReasoningEffort=${resolved.compressReasoningEffort ?? "模型默认"}`);
|
|
12003
12444
|
const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
|
|
12004
12445
|
const logModel = (message) => logger.info(message);
|
|
12005
|
-
if (
|
|
12446
|
+
if (ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
|
|
12006
12447
|
if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
|
|
12007
12448
|
ctx.inject(["tools"], (inner) => {
|
|
12008
12449
|
let disposeRecall;
|
|
@@ -12011,13 +12452,13 @@ function apply(ctx, config) {
|
|
|
12011
12452
|
/** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
|
|
12012
12453
|
const syncTools = () => {
|
|
12013
12454
|
const next = currentConfig(config);
|
|
12014
|
-
const semantic = next.
|
|
12015
|
-
if (disposeRecall && (
|
|
12455
|
+
const semantic = next.semanticRecallEnabled;
|
|
12456
|
+
if (disposeRecall && (registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
|
|
12016
12457
|
disposeRecall();
|
|
12017
12458
|
disposeRecall = void 0;
|
|
12018
12459
|
registered = void 0;
|
|
12019
12460
|
}
|
|
12020
|
-
if (
|
|
12461
|
+
if (!disposeRecall) {
|
|
12021
12462
|
const directory = next.modelDir;
|
|
12022
12463
|
disposeRecall = inner.tools.register(buildRecallTool({
|
|
12023
12464
|
getPruner: () => inner.get("toolResultPruner"),
|
|
@@ -12047,6 +12488,8 @@ function apply(ctx, config) {
|
|
|
12047
12488
|
ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
|
|
12048
12489
|
ctx.on("session/disposed", (session) => disposePrecompression(session.id));
|
|
12049
12490
|
ctx.effect(() => () => disposeAllPrecompressions(), "dsh-plugin-om: precompression registry");
|
|
12491
|
+
ctx.on("session/disposed", (session) => disposeReflection(session.id));
|
|
12492
|
+
ctx.effect(() => () => disposeAllReflections(), "dsh-plugin-om: reflection registry");
|
|
12050
12493
|
ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
|
|
12051
12494
|
let outcome = { failed: false };
|
|
12052
12495
|
try {
|
|
@@ -12064,7 +12507,16 @@ function apply(ctx, config) {
|
|
|
12064
12507
|
logger.warn(`上下文压缩失败,拒绝本 step 中断当前 turn:${outcome.error}${diagnostic}`);
|
|
12065
12508
|
return { kind: "reject" };
|
|
12066
12509
|
}
|
|
12067
|
-
|
|
12510
|
+
let decision = await next();
|
|
12511
|
+
if (decision.kind === "enter" && decision.messages.length > 0 && !signal.aborted && isMainSession(agent.session)) try {
|
|
12512
|
+
const skills = commitReflection(ctx, agent, currentConfig(config));
|
|
12513
|
+
if (skills.length > 0) decision = {
|
|
12514
|
+
...decision,
|
|
12515
|
+
messages: [...decision.messages, ...skills]
|
|
12516
|
+
};
|
|
12517
|
+
} catch (error) {
|
|
12518
|
+
logger.warn(`反思提交失败: ${error instanceof Error ? error.message : String(error)}`);
|
|
12519
|
+
}
|
|
12068
12520
|
const latest = currentConfig(config);
|
|
12069
12521
|
const reminders = activeSystemReminders(latest);
|
|
12070
12522
|
if (decision.kind === "enter" && !signal.aborted && reminders.length > 0 && isMainSession(agent.session)) return {
|