dsh-plugin-om 0.0.59 → 0.0.60
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 +18 -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 +13 -1
- 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 +1290 -842
- 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 +104 -16
- package/dist/skill/compaction-eval/scripts/view.mjs +317 -104
- 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 = "区间当前条目(等同 getHistory 全区间返回):";
|
|
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 > 300) return `content ${content.length} 字符,超过 300 字符上限,请压成一句话`;
|
|
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,8 +9255,10 @@ 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
|
};
|
|
@@ -9103,6 +9370,48 @@ const COMPRESSION_TOOL_SCHEMAS = [
|
|
|
9103
9370
|
}
|
|
9104
9371
|
}
|
|
9105
9372
|
];
|
|
9373
|
+
/** 归档模式的工具定义:compressHistory 区间限定为一个归档段并要求 keywords。 */
|
|
9374
|
+
const ARCHIVE_TOOL_SCHEMAS = COMPRESSION_TOOL_SCHEMAS.map((schema) => {
|
|
9375
|
+
if (schema.name === "completeCompression") return {
|
|
9376
|
+
...schema,
|
|
9377
|
+
description: "全部归档段都已压缩后调用,成功时立即结束压缩会话。"
|
|
9378
|
+
};
|
|
9379
|
+
if (schema.name !== "compressHistory") return schema;
|
|
9380
|
+
return {
|
|
9381
|
+
name: "compressHistory",
|
|
9382
|
+
description: `把一个归档段(start..end 恰为首条消息列出的某个段)压成一句话摘要。content 不换行、不超过 300 字符,写清结论、决策与涉及的文件;keywords 为供 recall 检索原文的关键词。返回成功即已生效;修改时用同一区间重新提交。`,
|
|
9383
|
+
parameters: {
|
|
9384
|
+
type: "object",
|
|
9385
|
+
properties: {
|
|
9386
|
+
start: {
|
|
9387
|
+
type: "number",
|
|
9388
|
+
description: "归档段起始完整消息 index"
|
|
9389
|
+
},
|
|
9390
|
+
end: {
|
|
9391
|
+
type: "number",
|
|
9392
|
+
description: "归档段结束完整消息 index"
|
|
9393
|
+
},
|
|
9394
|
+
content: {
|
|
9395
|
+
type: "string",
|
|
9396
|
+
description: "一句话摘要(纯文本,不换行,不要包含 CDATA 包裹)。数字、路径、版本号与错误码从原文逐字照抄,不推测补全。"
|
|
9397
|
+
},
|
|
9398
|
+
keywords: {
|
|
9399
|
+
type: "array",
|
|
9400
|
+
minItems: 1,
|
|
9401
|
+
maxItems: 8,
|
|
9402
|
+
items: { type: "string" },
|
|
9403
|
+
description: "1.." + String(8) + " 个关键词:文件名、函数名、命令、主题词等原文中出现的词"
|
|
9404
|
+
}
|
|
9405
|
+
},
|
|
9406
|
+
required: [
|
|
9407
|
+
"start",
|
|
9408
|
+
"end",
|
|
9409
|
+
"content",
|
|
9410
|
+
"keywords"
|
|
9411
|
+
]
|
|
9412
|
+
}
|
|
9413
|
+
};
|
|
9414
|
+
});
|
|
9106
9415
|
//#endregion
|
|
9107
9416
|
//#region src/rate-limit.ts
|
|
9108
9417
|
/**
|
|
@@ -9166,8 +9475,8 @@ async function gateRateLimit(waitMs, signal) {
|
|
|
9166
9475
|
* REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT / COMPLETION_BLOCKED_TEXT。
|
|
9167
9476
|
*
|
|
9168
9477
|
* - 首条 user 消息为压缩指令与 start/end 区间(buildCompressionTaskText),循环附上
|
|
9169
|
-
* 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system
|
|
9170
|
-
*
|
|
9478
|
+
* 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system,归档
|
|
9479
|
+
* 视图追加归档深度压缩约束并改用归档工具定义
|
|
9171
9480
|
* - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
|
|
9172
9481
|
* BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
|
|
9173
9482
|
* - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
|
|
@@ -9221,12 +9530,22 @@ function buildCompressionPrompt(skipReasoning) {
|
|
|
9221
9530
|
/**
|
|
9222
9531
|
* 构建压缩会话首条 user 消息的指令部分(压缩指令 + start/end 区间);区间条目由循环附加。
|
|
9223
9532
|
*/
|
|
9224
|
-
function buildCompressionTaskText(phase, start, end) {
|
|
9225
|
-
if (phase === "reflect")
|
|
9533
|
+
function buildCompressionTaskText(phase, start, end, segments = []) {
|
|
9534
|
+
if (phase === "reflect") {
|
|
9535
|
+
const list = segments.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、");
|
|
9536
|
+
return `归档深度压缩 <history> 块,完整消息区间 [${start}..${end}]:区间条目附在下方。归档段共 ${segments.length} 个:${list}。每个段用一次 compressHistory 压成一句话并给出 keywords,全部完成后调用 completeCompression。`;
|
|
9537
|
+
}
|
|
9226
9538
|
return `压缩完整消息区间 [${start}..${end}]:区间条目附在下方,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。`;
|
|
9227
9539
|
}
|
|
9228
|
-
/**
|
|
9229
|
-
const REFLECT_COMPRESSION_PROMPT = [
|
|
9540
|
+
/** 归档深度压缩的额外约束,只在归档视图注入。 */
|
|
9541
|
+
const REFLECT_COMPRESSION_PROMPT = [
|
|
9542
|
+
"【归档深度压缩】",
|
|
9543
|
+
"- 本次产物是归档块,原文可由主模型通过 recall 按 index 找回;此规则优先于上方的粒度要求。",
|
|
9544
|
+
"- 用户消息与已处理的提问原样保留,无需处理。",
|
|
9545
|
+
"- 相邻两条用户消息之间的全部 assistant 条目构成一个归档段,每段压成一句话:写清结论、决策与涉及的文件,不写过程。",
|
|
9546
|
+
"- 一句话不超过 300 字符、不换行;已被段内后续进展取代的信息直接舍弃。",
|
|
9547
|
+
"- keywords 选原文中出现、便于检索的词:文件名、函数名、命令、错误码、主题词。"
|
|
9548
|
+
].join("\n");
|
|
9230
9549
|
/** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
|
|
9231
9550
|
const ASK_COMPRESSION_PROMPT = [
|
|
9232
9551
|
"【原始提问处理】",
|
|
@@ -9351,10 +9670,11 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9351
9670
|
const logger = makeLogger(ctx, options.debug);
|
|
9352
9671
|
const view = withoutReasoning(options.view, options.skipReasoning);
|
|
9353
9672
|
const state = new CompressionState(view);
|
|
9354
|
-
const
|
|
9673
|
+
const baseTools = view.segments === void 0 ? COMPRESSION_TOOL_SCHEMAS : ARCHIVE_TOOL_SCHEMAS;
|
|
9674
|
+
const tools = state.hasPendingAsks ? [...baseTools, REWRITE_ASK_TOOL_SCHEMA] : baseTools;
|
|
9355
9675
|
const system = [
|
|
9356
9676
|
buildCompressionPrompt(options.skipReasoning),
|
|
9357
|
-
...
|
|
9677
|
+
...view.segments === void 0 ? [] : [REFLECT_COMPRESSION_PROMPT],
|
|
9358
9678
|
...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
|
|
9359
9679
|
].join("\n\n");
|
|
9360
9680
|
const messages = [makePluginUserMessage(withInitialHistory(options.taskText, state))];
|
|
@@ -9476,266 +9796,94 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9476
9796
|
logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
|
|
9477
9797
|
continue;
|
|
9478
9798
|
}
|
|
9479
|
-
if (retryTransient(failureMessage, failureStatus)) continue;
|
|
9480
|
-
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
|
|
9799
|
+
if (retryTransient(failureMessage, failureStatus)) continue;
|
|
9800
|
+
logger.warn(`压缩循环请求失败: ${failureMessage}`);
|
|
9801
|
+
pushPartialAssistant(assembler, messages, options.target);
|
|
9802
|
+
return await failWith(failureMessage, false);
|
|
9803
|
+
}
|
|
9804
|
+
transientRetries = 0;
|
|
9805
|
+
rounds += 1;
|
|
9806
|
+
if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
|
|
9807
|
+
roundStats.push({
|
|
9808
|
+
round: rounds,
|
|
9809
|
+
startedAt: roundStartedAt,
|
|
9810
|
+
durationMs: Date.now() - roundStartedAt,
|
|
9811
|
+
...assembler.usage === void 0 ? {} : { usage: assembler.usage }
|
|
9723
9812
|
});
|
|
9724
|
-
|
|
9725
|
-
|
|
9726
|
-
|
|
9813
|
+
const assistantMessage = assembler.message({
|
|
9814
|
+
provider: options.target.provider,
|
|
9815
|
+
model: options.target.model
|
|
9816
|
+
});
|
|
9817
|
+
messages.push(assistantMessage);
|
|
9818
|
+
const calls = assembler.blocks().filter((block) => block.type === "tool-call");
|
|
9819
|
+
if (calls.length === 0) {
|
|
9820
|
+
if (finish.kind === "max-tokens") {
|
|
9821
|
+
truncations += 1;
|
|
9822
|
+
if (truncations >= MAX_CONSECUTIVE_FAILURES) {
|
|
9823
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
|
|
9824
|
+
logger.warn(error);
|
|
9825
|
+
return await failWith(error, false);
|
|
9826
|
+
}
|
|
9827
|
+
logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
|
|
9828
|
+
omitted.add(assistantMessage);
|
|
9829
|
+
messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
|
|
9830
|
+
continue;
|
|
9831
|
+
}
|
|
9832
|
+
nudges += 1;
|
|
9833
|
+
if (nudges >= MAX_CONSECUTIVE_FAILURES) {
|
|
9834
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
|
|
9835
|
+
logger.warn(error);
|
|
9836
|
+
return await failWith(error, false);
|
|
9837
|
+
}
|
|
9838
|
+
logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
|
|
9839
|
+
messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
|
|
9840
|
+
continue;
|
|
9841
|
+
}
|
|
9842
|
+
nudges = 0;
|
|
9843
|
+
truncations = 0;
|
|
9844
|
+
/** 本轮失败且未被同轮后续成功提交解决的写入目标。 */
|
|
9845
|
+
const unresolved = /* @__PURE__ */ new Set();
|
|
9846
|
+
for (const call of calls) {
|
|
9847
|
+
const result = call.name === "completeCompression" && unresolved.size > 0 ? {
|
|
9848
|
+
text: COMPLETION_BLOCKED_TEXT,
|
|
9849
|
+
isError: true
|
|
9850
|
+
} : state.executeCall(call.name, call.arguments);
|
|
9851
|
+
const target = writeTargetOf(call.name, call.arguments);
|
|
9852
|
+
if (target !== void 0) {
|
|
9853
|
+
if (result.isError) unresolved.add(target);
|
|
9854
|
+
else unresolved.delete(target);
|
|
9855
|
+
}
|
|
9856
|
+
messages.push(toolResultOf(call, result));
|
|
9857
|
+
if (state.completed) break;
|
|
9858
|
+
}
|
|
9859
|
+
if (state.completed) {
|
|
9860
|
+
if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
|
|
9861
|
+
const text = state.buildFinalBlock();
|
|
9862
|
+
if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
|
|
9863
|
+
logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
|
|
9864
|
+
const stats = buildStats();
|
|
9865
|
+
const id = await recordSessionId(true, stats, text.length);
|
|
9866
|
+
return {
|
|
9867
|
+
ok: true,
|
|
9868
|
+
text,
|
|
9869
|
+
rounds,
|
|
9870
|
+
stats,
|
|
9871
|
+
...usage === void 0 ? {} : { usage },
|
|
9872
|
+
...id === void 0 ? {} : { recordSessionId: id }
|
|
9873
|
+
};
|
|
9874
|
+
}
|
|
9727
9875
|
}
|
|
9728
9876
|
}
|
|
9729
9877
|
//#endregion
|
|
9730
9878
|
//#region src/precompress.ts
|
|
9731
9879
|
/** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
|
|
9732
|
-
const jobs = /* @__PURE__ */ new Map();
|
|
9880
|
+
const jobs$1 = /* @__PURE__ */ new Map();
|
|
9733
9881
|
/**
|
|
9734
9882
|
* 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
|
|
9735
9883
|
* 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
|
|
9736
9884
|
*/
|
|
9737
9885
|
function findPrecompressionJob(session, pendingSeq) {
|
|
9738
|
-
const job = jobs.get(session.id);
|
|
9886
|
+
const job = jobs$1.get(session.id);
|
|
9739
9887
|
if (job === void 0) return void 0;
|
|
9740
9888
|
if (job.session === session && job.pendingSeq === pendingSeq) return job;
|
|
9741
9889
|
disposePrecompression(session.id);
|
|
@@ -9747,7 +9895,7 @@ function findPrecompressionJob(session, pendingSeq) {
|
|
|
9747
9895
|
function startPrecompression(options) {
|
|
9748
9896
|
const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
|
|
9749
9897
|
const logger = makeLogger(ctx, config.debug);
|
|
9750
|
-
const existing = jobs.get(session.id);
|
|
9898
|
+
const existing = jobs$1.get(session.id);
|
|
9751
9899
|
if (existing !== void 0) {
|
|
9752
9900
|
if (existing.session === session && existing.pendingSeq === pendingSeq) return {
|
|
9753
9901
|
ok: true,
|
|
@@ -9783,7 +9931,7 @@ function startPrecompression(options) {
|
|
|
9783
9931
|
promise,
|
|
9784
9932
|
state: "running"
|
|
9785
9933
|
};
|
|
9786
|
-
jobs.set(session.id, job);
|
|
9934
|
+
jobs$1.set(session.id, job);
|
|
9787
9935
|
runJobBody(ctx, job, options, logger).then(settle, settle);
|
|
9788
9936
|
logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
|
|
9789
9937
|
return {
|
|
@@ -9885,30 +10033,159 @@ function adoptPersistedSummary(data) {
|
|
|
9885
10033
|
}
|
|
9886
10034
|
/** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
|
|
9887
10035
|
function disposePrecompression(sessionId) {
|
|
9888
|
-
const job = jobs.get(sessionId);
|
|
10036
|
+
const job = jobs$1.get(sessionId);
|
|
9889
10037
|
if (job === void 0) return;
|
|
9890
|
-
jobs.delete(sessionId);
|
|
10038
|
+
jobs$1.delete(sessionId);
|
|
9891
10039
|
job.controller.abort();
|
|
9892
10040
|
}
|
|
9893
10041
|
/** 中止并移除全部后台任务(插件卸载)。 */
|
|
9894
10042
|
function disposeAllPrecompressions() {
|
|
9895
|
-
for (const sessionId of [...jobs.keys()]) disposePrecompression(sessionId);
|
|
10043
|
+
for (const sessionId of [...jobs$1.keys()]) disposePrecompression(sessionId);
|
|
10044
|
+
}
|
|
10045
|
+
//#endregion
|
|
10046
|
+
//#region src/reflect.ts
|
|
10047
|
+
/** session.id → 任务。 */
|
|
10048
|
+
const jobs = /* @__PURE__ */ new Map();
|
|
10049
|
+
/** session.id → 最近一次非中止失败时的 history 块集合键。 */
|
|
10050
|
+
const failedKeys = /* @__PURE__ */ new Map();
|
|
10051
|
+
/** history 块集合键:按 seq 拼接。 */
|
|
10052
|
+
function historyBlocksKey(blocks) {
|
|
10053
|
+
return blocks.map((block) => block.seq).join(",");
|
|
10054
|
+
}
|
|
10055
|
+
/**
|
|
10056
|
+
* 选择归档块:从最后一个块往前累加 token,合计不超过 keepBudget 的尾部块保留,
|
|
10057
|
+
* 至少保留 1 个;其余全部归档。tokensOf 返回单块 token。
|
|
10058
|
+
*/
|
|
10059
|
+
function selectArchiveBlocks(blocks, tokensOf, keepBudget) {
|
|
10060
|
+
let keepFrom = blocks.length;
|
|
10061
|
+
let total = 0;
|
|
10062
|
+
for (let i = blocks.length - 1; i >= 0; i -= 1) {
|
|
10063
|
+
const block = blocks[i];
|
|
10064
|
+
const next = total + tokensOf(block);
|
|
10065
|
+
if (keepFrom < blocks.length && next > keepBudget) break;
|
|
10066
|
+
total = next;
|
|
10067
|
+
keepFrom = i;
|
|
10068
|
+
}
|
|
10069
|
+
return {
|
|
10070
|
+
archived: blocks.slice(0, keepFrom),
|
|
10071
|
+
kept: blocks.slice(keepFrom)
|
|
10072
|
+
};
|
|
10073
|
+
}
|
|
10074
|
+
/** 查询会话当前任务。 */
|
|
10075
|
+
function peekReflectJob(sessionId) {
|
|
10076
|
+
return jobs.get(sessionId);
|
|
10077
|
+
}
|
|
10078
|
+
/** 取出会话当前任务并从注册表移除(提交或丢弃前调用)。 */
|
|
10079
|
+
function takeReflectJob(sessionId) {
|
|
10080
|
+
const job = jobs.get(sessionId);
|
|
10081
|
+
jobs.delete(sessionId);
|
|
10082
|
+
return job;
|
|
10083
|
+
}
|
|
10084
|
+
/** 最近一次非中止失败时的 history 块集合键。 */
|
|
10085
|
+
function reflectFailedKey(sessionId) {
|
|
10086
|
+
return failedKeys.get(sessionId);
|
|
10087
|
+
}
|
|
10088
|
+
/** 启动后台反思;调用方保证同会话无运行中任务。 */
|
|
10089
|
+
function startReflection(options) {
|
|
10090
|
+
const { ctx, session, config, target, reasoningEffort } = options;
|
|
10091
|
+
const logger = makeLogger(ctx, config.debug);
|
|
10092
|
+
const controller = new AbortController();
|
|
10093
|
+
let settle;
|
|
10094
|
+
const promise = new Promise((resolve) => {
|
|
10095
|
+
settle = resolve;
|
|
10096
|
+
});
|
|
10097
|
+
const job = {
|
|
10098
|
+
session,
|
|
10099
|
+
key: options.key,
|
|
10100
|
+
archived: options.archived,
|
|
10101
|
+
view: options.view,
|
|
10102
|
+
skills: options.skills,
|
|
10103
|
+
estimatedTokens: options.estimatedTokens,
|
|
10104
|
+
shadowedCharCount: options.shadowedCharCount,
|
|
10105
|
+
target,
|
|
10106
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort },
|
|
10107
|
+
controller,
|
|
10108
|
+
promise,
|
|
10109
|
+
state: "running"
|
|
10110
|
+
};
|
|
10111
|
+
jobs.set(session.id, job);
|
|
10112
|
+
failedKeys.delete(session.id);
|
|
10113
|
+
runJobBody(ctx, job, config).then(settle, settle);
|
|
10114
|
+
return job;
|
|
10115
|
+
async function runJobBody(context, current, cfg) {
|
|
10116
|
+
const { view } = current;
|
|
10117
|
+
try {
|
|
10118
|
+
const outcome = await runCompressionLoop(context, current.session, {
|
|
10119
|
+
view,
|
|
10120
|
+
originalChars: current.shadowedCharCount,
|
|
10121
|
+
phase: "reflect",
|
|
10122
|
+
taskText: buildCompressionTaskText("reflect", view.minIndex ?? 0, view.maxIndex ?? 0, view.segments),
|
|
10123
|
+
target: current.target,
|
|
10124
|
+
maxTokens: cfg.compressMaxTokens,
|
|
10125
|
+
rateLimitWaitMs: cfg.rateLimitWaitMs,
|
|
10126
|
+
skipReasoning: cfg.compressSkipReasoning,
|
|
10127
|
+
debug: cfg.debug,
|
|
10128
|
+
...current.reasoningEffort === void 0 ? {} : { reasoningEffort: current.reasoningEffort },
|
|
10129
|
+
signal: current.controller.signal
|
|
10130
|
+
});
|
|
10131
|
+
if (outcome.ok) {
|
|
10132
|
+
current.state = "done";
|
|
10133
|
+
current.result = outcome;
|
|
10134
|
+
logger.info(`反思完成(${outcome.stats.durationMs}ms),等待下一个 pre-step 提交`);
|
|
10135
|
+
return;
|
|
10136
|
+
}
|
|
10137
|
+
fail(current, {
|
|
10138
|
+
error: outcome.error,
|
|
10139
|
+
aborted: outcome.aborted,
|
|
10140
|
+
...outcome.recordSessionId === void 0 ? {} : { diagnosticSessionId: outcome.recordSessionId }
|
|
10141
|
+
});
|
|
10142
|
+
logger.info(`反思失败: ${outcome.error}`);
|
|
10143
|
+
} catch (error) {
|
|
10144
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10145
|
+
fail(current, {
|
|
10146
|
+
error: message,
|
|
10147
|
+
aborted: current.controller.signal.aborted
|
|
10148
|
+
});
|
|
10149
|
+
logger.warn(`反思任务异常: ${message}`);
|
|
10150
|
+
}
|
|
10151
|
+
}
|
|
10152
|
+
}
|
|
10153
|
+
/** 登记失败;非中止失败记录集合键,阻止同一块集合重试。 */
|
|
10154
|
+
function fail(job, failure) {
|
|
10155
|
+
job.state = "failed";
|
|
10156
|
+
job.failure = failure;
|
|
10157
|
+
if (!failure.aborted && jobs.get(job.session.id) === job) failedKeys.set(job.session.id, job.key);
|
|
10158
|
+
}
|
|
10159
|
+
/** 中止并移除会话的反思任务,清除失败记录。 */
|
|
10160
|
+
function disposeReflection(sessionId) {
|
|
10161
|
+
failedKeys.delete(sessionId);
|
|
10162
|
+
const job = jobs.get(sessionId);
|
|
10163
|
+
if (job === void 0) return;
|
|
10164
|
+
jobs.delete(sessionId);
|
|
10165
|
+
job.controller.abort();
|
|
10166
|
+
}
|
|
10167
|
+
/** 中止并移除全部反思任务(插件卸载)。 */
|
|
10168
|
+
function disposeAllReflections() {
|
|
10169
|
+
for (const sessionId of [...jobs.keys()]) disposeReflection(sessionId);
|
|
10170
|
+
failedKeys.clear();
|
|
9896
10171
|
}
|
|
9897
10172
|
//#endregion
|
|
9898
10173
|
//#region src/compress.ts
|
|
9899
10174
|
/**
|
|
9900
10175
|
* 两级自动压缩(观察/反思)与 compaction 生命周期提交。
|
|
9901
10176
|
* 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
|
|
9902
|
-
* historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
|
|
9903
|
-
* reflectPass / observePass / maybeCompress。
|
|
10177
|
+
* historyTextOf / archivedHistoryTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
|
|
10178
|
+
* reflectPass / commitReflection / observePass / maybeCompress。
|
|
9904
10179
|
*
|
|
9905
10180
|
* - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
|
|
9906
10181
|
* 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
|
|
9907
10182
|
* completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
|
|
9908
10183
|
* 全程无需整块校验
|
|
9909
|
-
* -
|
|
9910
|
-
*
|
|
9911
|
-
*
|
|
10184
|
+
* - 反思(异步归档):<history> 块 token 合计(估算 × 换算系数,不计 archived-history)
|
|
10185
|
+
* ≥ reflectThresholdTokens 时,保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余块在
|
|
10186
|
+
* 后台归档为一个 <archived-history> 块(reflect.ts);完成后的首个有输入的 pre-step 提交
|
|
10187
|
+
* 替换,并把被归档块中的 skill 以 skill-invocation 消息注入本 step;失败只记
|
|
10188
|
+
* compaction/end(error),块集合变化后重试
|
|
9912
10189
|
* - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
|
|
9913
10190
|
* 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
|
|
9914
10191
|
* (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
|
|
@@ -9920,24 +10197,24 @@ function disposeAllPrecompressions() {
|
|
|
9920
10197
|
* tailMessageCount=0 时触发当轮即到期,阻塞等待注入
|
|
9921
10198
|
* - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
|
|
9922
10199
|
* (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
|
|
9923
|
-
* - 待定标记与压缩结果以
|
|
10200
|
+
* - 待定标记与压缩结果以 ignorable 的 plugin record(kind 为
|
|
9924
10201
|
* om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
|
|
9925
10202
|
* 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
|
|
9926
|
-
* -
|
|
9927
|
-
*
|
|
10203
|
+
* - pre-step 先做反思检查(只启动或跳过,不阻塞),再执行观察(压缩主体在后台运行,
|
|
10204
|
+
* pre-step 仅在到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
|
|
9928
10205
|
* - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
|
|
9929
10206
|
* (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
|
|
9930
10207
|
* ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
|
|
9931
10208
|
* 未命中 / 无元数据 / 查询失败降级为模型默认并报告 reasoning-effort-unavailable 降级
|
|
9932
|
-
* - 压缩边界:最后一个合法 <history> 块之后的消息视为未压缩,其前不重复压缩
|
|
9933
|
-
* -
|
|
10209
|
+
* - 压缩边界:最后一个合法 <history> 或 <archived-history> 块之后的消息视为未压缩,其前不重复压缩
|
|
10210
|
+
* - 观察压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
|
|
9934
10211
|
* 错误),压缩流程向上传播,pre-step 据此拒绝本 step 中断当前 turn;signal 中止标记
|
|
9935
10212
|
* aborted(不中断);成功与失败均落盘压缩会话记录子会话(失败时其 id 随结果传播为
|
|
9936
10213
|
* 诊断子会话 id)
|
|
9937
10214
|
* - 提交走宿主 compaction/* 生命周期事件(start 带 phase → summary → 替换消息 → end),
|
|
9938
10215
|
* 失败补 end(error,实际报错 + 诊断子会话 sessionId);替换消息 source 标记插件标识供 UI 认领
|
|
9939
10216
|
* - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
|
|
9940
|
-
*
|
|
10217
|
+
* ignorable 的 om 警告 plugin record(客户端渲染功能降级警告行,每会话同一
|
|
9941
10218
|
* 问题至多一次);
|
|
9942
10219
|
* 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
|
|
9943
10220
|
* 本轮跳过观察,反思换算系数按 1 计)
|
|
@@ -9990,31 +10267,33 @@ async function resolveCompressionEffort(ctx, session, config, target, logger) {
|
|
|
9990
10267
|
compressionEffortCache.set(cacheKey, resolved);
|
|
9991
10268
|
return resolved;
|
|
9992
10269
|
}
|
|
10270
|
+
/** 插件自产 user/message 的文本;其余事件返回 undefined。 */
|
|
10271
|
+
function pluginOwnedText(event) {
|
|
10272
|
+
if (event?.type !== "user/message") return void 0;
|
|
10273
|
+
if (!isPluginOwnedSource(event.data.source)) return void 0;
|
|
10274
|
+
return blocksToText(event.data.content);
|
|
10275
|
+
}
|
|
9993
10276
|
/**
|
|
9994
|
-
*
|
|
9995
|
-
*
|
|
10277
|
+
* 判定消息是否为本插件的归档块消息并返回整段文本:插件自产且文本以
|
|
10278
|
+
* <archived-history> 开标签起始;其余返回 undefined。
|
|
9996
10279
|
*/
|
|
9997
|
-
|
|
9998
|
-
const
|
|
9999
|
-
if (
|
|
10000
|
-
|
|
10001
|
-
|
|
10002
|
-
|
|
10003
|
-
|
|
10004
|
-
|
|
10005
|
-
}
|
|
10006
|
-
if (outcome.recordSessionId !== void 0) logger.step(`压缩会话记录子会话 ${outcome.recordSessionId}`);
|
|
10007
|
-
return outcome;
|
|
10280
|
+
function archivedHistoryTextOf(event) {
|
|
10281
|
+
const text = pluginOwnedText(event);
|
|
10282
|
+
if (text === void 0) return void 0;
|
|
10283
|
+
const head = text.trimStart();
|
|
10284
|
+
const open = `<${ARCHIVED_HISTORY_TAG}`;
|
|
10285
|
+
if (!head.startsWith(open)) return void 0;
|
|
10286
|
+
const next = head.charAt(open.length);
|
|
10287
|
+
return next === ">" || next === " " ? text : void 0;
|
|
10008
10288
|
}
|
|
10009
10289
|
/**
|
|
10010
10290
|
* 判定消息是否为本插件的压缩日志消息并提取日志文本(按 source 标记判断,兼容旧宿主
|
|
10011
|
-
* checkpoint 标记 'compact')。仅当消息文本含 <history>
|
|
10012
|
-
*
|
|
10291
|
+
* checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签且不是归档块时视为压缩
|
|
10292
|
+
* 日志,返回整段文本;其余返回 undefined。
|
|
10013
10293
|
*/
|
|
10014
10294
|
function historyTextOf(event) {
|
|
10015
|
-
|
|
10016
|
-
if (
|
|
10017
|
-
const text = blocksToText(event.data.content);
|
|
10295
|
+
const text = pluginOwnedText(event);
|
|
10296
|
+
if (text === void 0 || archivedHistoryTextOf(event) !== void 0) return void 0;
|
|
10018
10297
|
const idx = text.indexOf(`<${HISTORY_TAG}`);
|
|
10019
10298
|
if (idx === -1) return void 0;
|
|
10020
10299
|
const rest = text.slice(idx + 7 + 1);
|
|
@@ -10087,16 +10366,28 @@ function computeCompressRange(session, endMessageIndex) {
|
|
|
10087
10366
|
};
|
|
10088
10367
|
}
|
|
10089
10368
|
/**
|
|
10090
|
-
* 压缩边界(historySection
|
|
10091
|
-
*
|
|
10092
|
-
*
|
|
10093
|
-
* undefined。
|
|
10369
|
+
* 压缩边界(historySection):扫描表层全部节点,分别收集合法 <history> 块与
|
|
10370
|
+
* <archived-history> 归档块(内文 + seq,按表层顺序),并以两类块中表层位置最后的
|
|
10371
|
+
* 一个作为压缩边界——边界之后的消息视为未压缩,其前(含边界自身)视为已压缩。
|
|
10372
|
+
* 无压缩块时 blocks / archived 为空、boundarySeq 为 undefined。
|
|
10094
10373
|
*/
|
|
10095
10374
|
function historySection(session) {
|
|
10096
10375
|
const blocks = [];
|
|
10376
|
+
const archived = [];
|
|
10097
10377
|
let boundarySeq;
|
|
10378
|
+
const events = session.snapshotEvents();
|
|
10098
10379
|
for (const seq of session.surface.nodes) {
|
|
10099
|
-
const
|
|
10380
|
+
const event = events[seq];
|
|
10381
|
+
const archivedText = archivedHistoryTextOf(event);
|
|
10382
|
+
if (archivedText !== void 0) {
|
|
10383
|
+
archived.push({
|
|
10384
|
+
text: archivedText,
|
|
10385
|
+
seq
|
|
10386
|
+
});
|
|
10387
|
+
boundarySeq = seq;
|
|
10388
|
+
continue;
|
|
10389
|
+
}
|
|
10390
|
+
const text = historyTextOf(event);
|
|
10100
10391
|
if (text === void 0) continue;
|
|
10101
10392
|
blocks.push({
|
|
10102
10393
|
text,
|
|
@@ -10106,6 +10397,7 @@ function historySection(session) {
|
|
|
10106
10397
|
}
|
|
10107
10398
|
return {
|
|
10108
10399
|
blocks,
|
|
10400
|
+
archived,
|
|
10109
10401
|
boundarySeq
|
|
10110
10402
|
};
|
|
10111
10403
|
}
|
|
@@ -10224,113 +10516,221 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
|
|
|
10224
10516
|
});
|
|
10225
10517
|
}
|
|
10226
10518
|
/**
|
|
10227
|
-
*
|
|
10228
|
-
*
|
|
10229
|
-
*
|
|
10230
|
-
*
|
|
10519
|
+
* 反思(异步归档)检查:每个 pre-step 在观察前调用,不阻塞、不失败。
|
|
10520
|
+
* - 有运行中或待提交任务:跳过(待提交任务由 commitReflection 提交)
|
|
10521
|
+
* - 有失败任务:写 compaction/start + end(error) 后移除
|
|
10522
|
+
* - 无任务:history 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
|
|
10523
|
+
* 保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余归档,启动后台反思;
|
|
10524
|
+
* 同一块集合上次失败则不重试
|
|
10231
10525
|
*/
|
|
10232
|
-
|
|
10526
|
+
function reflectPass(ctx, agent, config, target, reasoningEffort) {
|
|
10233
10527
|
const session = agent.session;
|
|
10234
10528
|
const logger = makeLogger(ctx, config.debug);
|
|
10235
|
-
|
|
10236
|
-
|
|
10237
|
-
if (
|
|
10238
|
-
|
|
10239
|
-
|
|
10529
|
+
const job = peekReflectJob(session.id);
|
|
10530
|
+
if (job !== void 0 && job.session !== session) disposeReflection(session.id);
|
|
10531
|
+
else if (job?.state === "failed") {
|
|
10532
|
+
takeReflectJob(session.id);
|
|
10533
|
+
recordReflectFailure(session, job, logger);
|
|
10534
|
+
return;
|
|
10535
|
+
} else if (job !== void 0) {
|
|
10536
|
+
logger.step(job.state === "running" ? "反思:后台任务运行中,跳过" : "反思:结果待提交,跳过");
|
|
10537
|
+
return;
|
|
10240
10538
|
}
|
|
10539
|
+
startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger);
|
|
10540
|
+
}
|
|
10541
|
+
/**
|
|
10542
|
+
* 提交已完成的反思(pre-step 在 next() 之后、本 step 有待输入消息时调用):
|
|
10543
|
+
* 校验被归档块仍在表层且相邻后写 compaction/start → summary → 替换为 archived-history → end,
|
|
10544
|
+
* 返回需追加到本 step 的 skill 注入消息。无待提交任务、校验或提交失败返回空数组。
|
|
10545
|
+
*/
|
|
10546
|
+
function commitReflection(ctx, agent, config) {
|
|
10547
|
+
const session = agent.session;
|
|
10548
|
+
const job = peekReflectJob(session.id);
|
|
10549
|
+
if (job === void 0 || job.state !== "done") return [];
|
|
10550
|
+
takeReflectJob(session.id);
|
|
10551
|
+
if (job.session !== session) return [];
|
|
10552
|
+
return commitReflectJob(session, job, config, makeLogger(ctx, config.debug));
|
|
10553
|
+
}
|
|
10554
|
+
/** 触发检查:达到阈值且有可归档块时启动后台反思。 */
|
|
10555
|
+
function startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger) {
|
|
10241
10556
|
const threshold = config.reflectThresholdTokens;
|
|
10242
|
-
|
|
10557
|
+
logger.step(`反思检查(反思阈值 ${threshold} tokens)`);
|
|
10558
|
+
const { blocks } = historySection(session);
|
|
10559
|
+
if (blocks.length < 2) {
|
|
10560
|
+
logger.step(`反思:<history> 块 ${blocks.length} 个,无可归档块,跳过`);
|
|
10561
|
+
return;
|
|
10562
|
+
}
|
|
10563
|
+
const key = historyBlocksKey(blocks);
|
|
10564
|
+
if (reflectFailedKey(session.id) === key) {
|
|
10565
|
+
logger.step("反思:上次失败后 <history> 块未变化,跳过");
|
|
10566
|
+
return;
|
|
10567
|
+
}
|
|
10568
|
+
const estimatedTotal = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10243
10569
|
const measurement = measurePressure(ctx, session, logger);
|
|
10244
10570
|
const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10245
|
-
const tokens = Math.round(ratio *
|
|
10246
|
-
const
|
|
10571
|
+
const tokens = Math.round(ratio * estimatedTotal);
|
|
10572
|
+
const detail = `${tokens} tokens(估算 ${estimatedTotal} × 换算系数 ${ratio.toFixed(2)})`;
|
|
10247
10573
|
if (tokens < threshold) {
|
|
10248
|
-
logger.step(
|
|
10249
|
-
return
|
|
10574
|
+
logger.step(`反思:<history> 块 ${detail} < 阈值 ${threshold},跳过`);
|
|
10575
|
+
return;
|
|
10250
10576
|
}
|
|
10251
|
-
|
|
10252
|
-
|
|
10253
|
-
|
|
10254
|
-
|
|
10255
|
-
logger.step("反思:块区段缺失,跳过");
|
|
10256
|
-
return { failed: false };
|
|
10577
|
+
const { archived, kept } = selectArchiveBlocks(blocks, (block) => ratio * estimateTextTokens(block.text), threshold / 3);
|
|
10578
|
+
if (archived.length === 0) {
|
|
10579
|
+
logger.step("反思:尾部保留预算覆盖全部块,无可归档块,跳过");
|
|
10580
|
+
return;
|
|
10257
10581
|
}
|
|
10258
|
-
const view
|
|
10582
|
+
const { view, skills } = buildArchiveView(archived);
|
|
10259
10583
|
if (view.minIndex === void 0 || view.maxIndex === void 0) {
|
|
10260
|
-
logger.step("
|
|
10261
|
-
return
|
|
10584
|
+
logger.step("反思:被归档块内无可定位条目(历史遗留块),跳过");
|
|
10585
|
+
return;
|
|
10262
10586
|
}
|
|
10263
|
-
|
|
10587
|
+
startReflection({
|
|
10588
|
+
ctx,
|
|
10589
|
+
session,
|
|
10590
|
+
config,
|
|
10591
|
+
target,
|
|
10592
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort },
|
|
10593
|
+
key,
|
|
10594
|
+
archived,
|
|
10595
|
+
view,
|
|
10596
|
+
skills,
|
|
10597
|
+
estimatedTokens: archived.reduce((total, block) => total + estimateTextTokens(block.text), 0),
|
|
10598
|
+
shadowedCharCount: archived.reduce((total, block) => total + historyInnerText(block.text).length, 0)
|
|
10599
|
+
});
|
|
10600
|
+
logger.info(`反思:<history> 块 ${detail} ≥ 阈值 ${threshold},后台归档 ${archived.length} 个块,保留 ${kept.length} 个`);
|
|
10601
|
+
}
|
|
10602
|
+
/** 失败任务:在当前开放 turn 内写 compaction/start + end(error);中止的任务不记录。 */
|
|
10603
|
+
function recordReflectFailure(session, job, logger) {
|
|
10604
|
+
const failure = job.failure;
|
|
10605
|
+
if (failure === void 0 || failure.aborted) return;
|
|
10264
10606
|
const lifecycle = {
|
|
10265
10607
|
compactionId: newCompactionId(),
|
|
10266
10608
|
turn: openTurnOf(session)
|
|
10267
10609
|
};
|
|
10268
10610
|
try {
|
|
10269
|
-
logger.step("反思:追加 compaction/start(压缩循环前开启压缩中提示)");
|
|
10270
10611
|
appendCompactionStart(session, lifecycle, "reflect");
|
|
10612
|
+
appendCompactionEnd(session, lifecycle, failure.error, failure.diagnosticSessionId);
|
|
10271
10613
|
} catch (error) {
|
|
10272
10614
|
const message = error instanceof Error ? error.message : String(error);
|
|
10273
|
-
logger.warn(
|
|
10274
|
-
return { failed: false };
|
|
10615
|
+
logger.warn(`反思失败记录追加失败: ${message}`);
|
|
10275
10616
|
}
|
|
10276
|
-
|
|
10277
|
-
|
|
10278
|
-
|
|
10279
|
-
|
|
10280
|
-
|
|
10281
|
-
|
|
10282
|
-
|
|
10283
|
-
|
|
10284
|
-
|
|
10285
|
-
|
|
10286
|
-
|
|
10287
|
-
|
|
10288
|
-
|
|
10289
|
-
|
|
10290
|
-
|
|
10291
|
-
|
|
10292
|
-
|
|
10293
|
-
|
|
10617
|
+
}
|
|
10618
|
+
/** 被归档块仍在表层且在表层顺序中相邻。 */
|
|
10619
|
+
function archivedBlocksIntact(session, job) {
|
|
10620
|
+
const nodes = session.surface.nodes;
|
|
10621
|
+
const first = job.archived[0];
|
|
10622
|
+
if (first === void 0) return false;
|
|
10623
|
+
const start = nodes.indexOf(SessionSeq(first.seq));
|
|
10624
|
+
if (start < 0) return false;
|
|
10625
|
+
return job.archived.every((block, i) => nodes[start + i] === block.seq);
|
|
10626
|
+
}
|
|
10627
|
+
/** 提交成功任务;返回需注入的 skill 消息(表层已有同名 skill 的不注入)。 */
|
|
10628
|
+
function commitReflectJob(session, job, config, logger) {
|
|
10629
|
+
const result = job.result;
|
|
10630
|
+
const first = job.archived[0];
|
|
10631
|
+
const last = job.archived[job.archived.length - 1];
|
|
10632
|
+
if (result === void 0 || first === void 0 || last === void 0) return [];
|
|
10633
|
+
if (!archivedBlocksIntact(session, job)) {
|
|
10634
|
+
logger.info("反思:被归档块已不在表层或不再相邻,丢弃本次结果");
|
|
10635
|
+
return [];
|
|
10636
|
+
}
|
|
10637
|
+
const blockSeqs = job.archived.map((block) => block.seq);
|
|
10638
|
+
const lifecycle = {
|
|
10639
|
+
compactionId: newCompactionId(),
|
|
10640
|
+
turn: openTurnOf(session)
|
|
10294
10641
|
};
|
|
10295
|
-
const report = summaryResult.text;
|
|
10296
10642
|
try {
|
|
10297
|
-
|
|
10643
|
+
appendCompactionStart(session, lifecycle, "reflect");
|
|
10644
|
+
} catch (error) {
|
|
10645
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10646
|
+
logger.warn(`反思提交启动失败: ${message}`);
|
|
10647
|
+
return [];
|
|
10648
|
+
}
|
|
10649
|
+
try {
|
|
10298
10650
|
const summarySeq = appendCompactionSummary(session, {
|
|
10299
10651
|
lifecycle,
|
|
10300
|
-
summary:
|
|
10652
|
+
summary: result.text,
|
|
10301
10653
|
shadowedRange: {
|
|
10302
10654
|
start: first.seq,
|
|
10303
10655
|
end: last.seq
|
|
10304
10656
|
},
|
|
10305
10657
|
shadowedSeqs: blockSeqs,
|
|
10306
|
-
shadowedTokenCount: estimatedTokens,
|
|
10307
|
-
shadowedCharCount,
|
|
10308
|
-
provider: target.provider,
|
|
10309
|
-
model: target.model,
|
|
10658
|
+
shadowedTokenCount: job.estimatedTokens,
|
|
10659
|
+
shadowedCharCount: job.shadowedCharCount,
|
|
10660
|
+
provider: job.target.provider,
|
|
10661
|
+
model: job.target.model,
|
|
10310
10662
|
maxTokens: config.compressMaxTokens,
|
|
10311
|
-
stats:
|
|
10312
|
-
...
|
|
10313
|
-
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
10663
|
+
stats: result.stats,
|
|
10664
|
+
...result.usage === void 0 ? {} : { usage: result.usage },
|
|
10665
|
+
...job.reasoningEffort === void 0 ? {} : { reasoningEffort: job.reasoningEffort }
|
|
10314
10666
|
});
|
|
10315
|
-
|
|
10316
|
-
appendHistoryMessage(session, report, [summarySeq, ...blockSeqs], {
|
|
10667
|
+
appendHistoryMessage(session, result.text, [summarySeq, ...blockSeqs], {
|
|
10317
10668
|
op: "replace",
|
|
10318
10669
|
startSeq: first.seq,
|
|
10319
10670
|
endSeq: last.seq
|
|
10320
10671
|
}, lifecycle.compactionId);
|
|
10321
|
-
|
|
10322
|
-
appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
|
|
10323
|
-
logger.info(`反思完成(摘要 ${tokens} tokens ≥ 阈值 ${threshold},合并 ${blocks.length} 个块为一条)`);
|
|
10324
|
-
return { failed: false };
|
|
10672
|
+
appendCompactionEnd(session, lifecycle, void 0, result.recordSessionId);
|
|
10325
10673
|
} catch (error) {
|
|
10326
10674
|
const message = error instanceof Error ? error.message : String(error);
|
|
10327
10675
|
logger.warn(`反思提交失败: ${message}`);
|
|
10328
10676
|
try {
|
|
10329
|
-
appendCompactionEnd(session, lifecycle, message, void 0,
|
|
10677
|
+
appendCompactionEnd(session, lifecycle, message, void 0, result.stats.durationMs);
|
|
10330
10678
|
} catch {}
|
|
10331
|
-
return
|
|
10679
|
+
return [];
|
|
10680
|
+
}
|
|
10681
|
+
const live = liveSkillNames(session);
|
|
10682
|
+
const messages = job.skills.filter((skill) => !live.has(skill.name)).map((skill) => createUserMessage({
|
|
10683
|
+
content: [{
|
|
10684
|
+
type: "text",
|
|
10685
|
+
text: skill.content
|
|
10686
|
+
}],
|
|
10687
|
+
source: {
|
|
10688
|
+
kind: SKILL_INVOCATION_KIND,
|
|
10689
|
+
name: skill.name,
|
|
10690
|
+
form: "instructions"
|
|
10691
|
+
}
|
|
10692
|
+
}));
|
|
10693
|
+
logger.info(`反思提交:${job.archived.length} 个 <history> 块归档为 archived-history,注入 ${messages.length} 个 skill`);
|
|
10694
|
+
return messages;
|
|
10695
|
+
}
|
|
10696
|
+
/** 表层中仍以 skill 形态存在的名称:history 块内 skill_content、手动加载消息、skill 工具调用。 */
|
|
10697
|
+
function liveSkillNames(session) {
|
|
10698
|
+
const names = /* @__PURE__ */ new Set();
|
|
10699
|
+
const events = session.snapshotEvents();
|
|
10700
|
+
for (const seq of session.surface.nodes) {
|
|
10701
|
+
const event = events[seq];
|
|
10702
|
+
if (event === void 0) continue;
|
|
10703
|
+
const history = historyTextOf(event);
|
|
10704
|
+
if (history !== void 0) {
|
|
10705
|
+
for (const match of history.matchAll(/<skill_content name="([^"]*)"/g)) names.add(unescapeAttr(match[1] ?? ""));
|
|
10706
|
+
continue;
|
|
10707
|
+
}
|
|
10708
|
+
if (event.type === "user/message") {
|
|
10709
|
+
const source = event.data.source;
|
|
10710
|
+
if (source.kind === "skill-invocation" && typeof source.name === "string") names.add(source.name);
|
|
10711
|
+
continue;
|
|
10712
|
+
}
|
|
10713
|
+
if (event.type === "assistant/message") for (const block of event.data.message.content) {
|
|
10714
|
+
if (block.type !== "tool-call" || block.name !== "skill") continue;
|
|
10715
|
+
const name = skillArgName(block.arguments);
|
|
10716
|
+
if (name !== void 0) names.add(name);
|
|
10717
|
+
}
|
|
10718
|
+
}
|
|
10719
|
+
return names;
|
|
10720
|
+
}
|
|
10721
|
+
/** skill 工具调用参数中的 name;参数非法时 undefined。 */
|
|
10722
|
+
function skillArgName(args) {
|
|
10723
|
+
try {
|
|
10724
|
+
const parsed = JSON.parse(args);
|
|
10725
|
+
return typeof parsed?.name === "string" ? parsed.name : void 0;
|
|
10726
|
+
} catch {
|
|
10727
|
+
return;
|
|
10332
10728
|
}
|
|
10333
10729
|
}
|
|
10730
|
+
/** XML 属性值反转义。 */
|
|
10731
|
+
function unescapeAttr(value) {
|
|
10732
|
+
return value.replaceAll(""", "\"").replaceAll("<", "<").replaceAll(">", ">").replaceAll("'", "'").replaceAll("&", "&");
|
|
10733
|
+
}
|
|
10334
10734
|
/**
|
|
10335
10735
|
* 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
|
|
10336
10736
|
* systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
|
|
@@ -10546,8 +10946,8 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
|
|
|
10546
10946
|
const threshold = config.observeThresholdTokens;
|
|
10547
10947
|
const measurement = measurePressure(ctx, session, logger);
|
|
10548
10948
|
if (measurement === void 0) return { failed: false };
|
|
10549
|
-
const { blocks } = historySection(session);
|
|
10550
|
-
const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10949
|
+
const { blocks, archived } = historySection(session);
|
|
10950
|
+
const historyTokens = [...blocks, ...archived].reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10551
10951
|
const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
|
|
10552
10952
|
const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10553
10953
|
const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
|
|
@@ -10688,9 +11088,9 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
|
|
|
10688
11088
|
});
|
|
10689
11089
|
}
|
|
10690
11090
|
/**
|
|
10691
|
-
* 压力检查 +
|
|
10692
|
-
*
|
|
10693
|
-
*
|
|
11091
|
+
* 压力检查 + 两级压缩入口(pre-step 调用,仅主会话生效):
|
|
11092
|
+
* 先反思(异步:只启动或提交后台任务,不阻塞、不失败),后观察(阻塞注入)。
|
|
11093
|
+
* 观察失败传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
|
|
10694
11094
|
*/
|
|
10695
11095
|
async function maybeCompress(ctx, agent, config, signal) {
|
|
10696
11096
|
const session = agent.session;
|
|
@@ -10708,11 +11108,7 @@ async function maybeCompress(ctx, agent, config, signal) {
|
|
|
10708
11108
|
const reasoningEffort = await resolveCompressionEffort(ctx, session, config, target, logger);
|
|
10709
11109
|
const waitCount = config.tailMessageCount;
|
|
10710
11110
|
logger.step("反思 pass 开始");
|
|
10711
|
-
|
|
10712
|
-
if (reflect.failed) {
|
|
10713
|
-
logger.step("反思 pass 失败(本轮将被拒绝),跳过观察 pass");
|
|
10714
|
-
return reflect;
|
|
10715
|
-
}
|
|
11111
|
+
reflectPass(ctx, agent, config, target, reasoningEffort);
|
|
10716
11112
|
logger.step("反思 pass 结束,观察 pass 开始");
|
|
10717
11113
|
const observe = await observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort);
|
|
10718
11114
|
logger.step("观察 pass 结束,压缩流程完成");
|
|
@@ -10934,7 +11330,7 @@ function cosineSimilarity(a, b) {
|
|
|
10934
11330
|
/** 默认配置(冻结对象,resolveConfig 合并的基底;debug 缺省值在解析时按 NODE_ENV 判定)。 */
|
|
10935
11331
|
const DEFAULT_CONFIG = Object.freeze({
|
|
10936
11332
|
observeThresholdTokens: 35e3,
|
|
10937
|
-
reflectThresholdTokens:
|
|
11333
|
+
reflectThresholdTokens: 8e4,
|
|
10938
11334
|
compressMaxTokens: void 0,
|
|
10939
11335
|
rateLimitWaitMs: 6e4,
|
|
10940
11336
|
recompressConcurrency: 2,
|
|
@@ -10946,7 +11342,6 @@ const DEFAULT_CONFIG = Object.freeze({
|
|
|
10946
11342
|
progressReminderIdleSteps: 4,
|
|
10947
11343
|
progressReminderIdleToolCalls: 10,
|
|
10948
11344
|
debug: false,
|
|
10949
|
-
recallEnabled: true,
|
|
10950
11345
|
semanticRecallEnabled: true,
|
|
10951
11346
|
modelDir: sharedModelDir(),
|
|
10952
11347
|
compressProvider: void 0,
|
|
@@ -10968,7 +11363,6 @@ const Config = Schema.object({
|
|
|
10968
11363
|
progressReminderIdleSteps: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.progressReminderIdleSteps).volatile(),
|
|
10969
11364
|
progressReminderIdleToolCalls: Schema.number().step(1).min(0).default(DEFAULT_CONFIG.progressReminderIdleToolCalls).volatile(),
|
|
10970
11365
|
debug: Schema.boolean().default(process.env.NODE_ENV !== "production").volatile(),
|
|
10971
|
-
recallEnabled: Schema.boolean().default(DEFAULT_CONFIG.recallEnabled).volatile(),
|
|
10972
11366
|
semanticRecallEnabled: Schema.boolean().default(DEFAULT_CONFIG.semanticRecallEnabled).volatile(),
|
|
10973
11367
|
modelDir: Schema.string().default(DEFAULT_CONFIG.modelDir).volatile(),
|
|
10974
11368
|
compressProvider: Schema.string().volatile(),
|
|
@@ -11044,8 +11438,7 @@ function resolveConfig(raw) {
|
|
|
11044
11438
|
config.progressReminderEnabled = resolveBoolean(input.progressReminderEnabled, true);
|
|
11045
11439
|
config.progressReminderIdleEnabled = resolveBoolean(input.progressReminderIdleEnabled, DEFAULT_CONFIG.progressReminderIdleEnabled);
|
|
11046
11440
|
config.debug = resolveBoolean(input.debug, process.env.NODE_ENV !== "production");
|
|
11047
|
-
config.
|
|
11048
|
-
config.semanticRecallEnabled = config.recallEnabled && resolveBoolean(input.semanticRecallEnabled, true);
|
|
11441
|
+
config.semanticRecallEnabled = resolveBoolean(input.semanticRecallEnabled, true);
|
|
11049
11442
|
const modelDir = input.modelDir;
|
|
11050
11443
|
if (typeof modelDir === "string" && modelDir.trim() !== "") config.modelDir = modelDir;
|
|
11051
11444
|
config.compressProvider = resolveOptionalString(input.compressProvider);
|
|
@@ -11256,11 +11649,14 @@ function renderCompleteMessageXml(session, cm, options = {}) {
|
|
|
11256
11649
|
//#endregion
|
|
11257
11650
|
//#region src/semantic-recall.ts
|
|
11258
11651
|
/**
|
|
11259
|
-
* recall
|
|
11260
|
-
*
|
|
11652
|
+
* recall 的 query 检索实现:对会话全部完整消息(含被压缩/遮蔽的)检索,返回最匹配的
|
|
11653
|
+
* 完整消息与匹配说明。
|
|
11261
11654
|
* 导出 SemanticOptions / RangeArgs / resolveSemanticRange / tokenize / matchExplanation /
|
|
11262
|
-
* SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch。
|
|
11263
|
-
*
|
|
11655
|
+
* keywordTerms / SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch / keywordSearch。
|
|
11656
|
+
* - 语义检索:本地 ONNX 嵌入(cosine 相似度)
|
|
11657
|
+
* - 字符串匹配(语义增强关闭时):query 按空白拆词,不区分大小写计命中词数,同分时
|
|
11658
|
+
* index 大的优先,零命中不返回
|
|
11659
|
+
* 只匹配文本,纯图片消息不进候选池;
|
|
11264
11660
|
* 区间缺省检索全部、区间不合法回退全量并在输出中告知;输出契约同 recall
|
|
11265
11661
|
* ({ text, images },条目为 XML 形态见 recall-xml.ts,超大结果由 tool-result-pruner
|
|
11266
11662
|
* 裁剪);候选池排除本次调用自身的 toolcall 完整消息(其渲染文本含 query 原文,
|
|
@@ -11332,13 +11728,11 @@ function matchExplanation(query, text, score) {
|
|
|
11332
11728
|
}
|
|
11333
11729
|
/** 模型未就绪时返回给模型的文案(下载完成后直接再次调用即可)。 */
|
|
11334
11730
|
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);
|
|
11731
|
+
/** 收集区间内可检索的候选;会话为空或区间内无候选时返回提示文案。 */
|
|
11732
|
+
function collectCandidates(input) {
|
|
11733
|
+
const { session, start, end, offset, selfCallId } = input;
|
|
11340
11734
|
const cms = indexCompleteMessages(session);
|
|
11341
|
-
if (cms.length === 0) return
|
|
11735
|
+
if (cms.length === 0) return "会话中没有可检索的消息";
|
|
11342
11736
|
const range = resolveSemanticRange(cms.length, {
|
|
11343
11737
|
start,
|
|
11344
11738
|
end,
|
|
@@ -11358,7 +11752,20 @@ async function semanticSearch(input) {
|
|
|
11358
11752
|
text
|
|
11359
11753
|
});
|
|
11360
11754
|
}
|
|
11361
|
-
if (candidates.length === 0) return
|
|
11755
|
+
if (candidates.length === 0) return "指定范围内没有可检索的消息";
|
|
11756
|
+
return {
|
|
11757
|
+
candidates,
|
|
11758
|
+
range
|
|
11759
|
+
};
|
|
11760
|
+
}
|
|
11761
|
+
/** 在会话完整消息中做语义检索,返回 TOP-K 命中条目。 */
|
|
11762
|
+
async function semanticSearch(input) {
|
|
11763
|
+
const { query, topK, options } = input;
|
|
11764
|
+
const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
|
|
11765
|
+
if ((await options?.modelStatus?.() ?? "ready") !== "ready") return textOnly(SEMANTIC_MODEL_NOT_READY_MESSAGE);
|
|
11766
|
+
const collected = collectCandidates(input);
|
|
11767
|
+
if (typeof collected === "string") return textOnly(collected);
|
|
11768
|
+
const { candidates, range } = collected;
|
|
11362
11769
|
const [queryVec] = await embed([query]);
|
|
11363
11770
|
if (!queryVec) return textOnly("语义检索失败:无法生成查询向量");
|
|
11364
11771
|
const vectors = await embed(candidates.map((c) => c.text));
|
|
@@ -11368,18 +11775,53 @@ async function semanticSearch(input) {
|
|
|
11368
11775
|
score: cosineSimilarity(queryVec, vectors[i] ?? /* @__PURE__ */ new Float32Array(0))
|
|
11369
11776
|
}));
|
|
11370
11777
|
scored.sort((a, b) => b.score - a.score);
|
|
11371
|
-
const
|
|
11372
|
-
|
|
11778
|
+
const hits = scored.slice(0, topK ?? 3).map((hit) => ({
|
|
11779
|
+
...hit,
|
|
11780
|
+
explanation: matchExplanation(query, hit.text, hit.score)
|
|
11781
|
+
}));
|
|
11782
|
+
return renderHits(input, range, `${candidates.length} 条可嵌入`, scored.length, hits);
|
|
11783
|
+
}
|
|
11784
|
+
/** 字符串匹配的检索词:query 按空白拆分、转小写、去重。 */
|
|
11785
|
+
function keywordTerms(query) {
|
|
11786
|
+
return [...new Set(query.toLowerCase().split(/\s+/u).filter((term) => term.length > 0))];
|
|
11787
|
+
}
|
|
11788
|
+
/** 在会话完整消息中按字符串匹配检索(语义增强关闭时),返回 TOP-K 命中条目。 */
|
|
11789
|
+
function keywordSearch(input) {
|
|
11790
|
+
const terms = keywordTerms(input.query);
|
|
11791
|
+
if (terms.length === 0) return textOnly("query 不能为空");
|
|
11792
|
+
const collected = collectCandidates(input);
|
|
11793
|
+
if (typeof collected === "string") return textOnly(collected);
|
|
11794
|
+
const { candidates, range } = collected;
|
|
11795
|
+
const scored = candidates.map((c) => {
|
|
11796
|
+
const lower = c.text.toLowerCase();
|
|
11797
|
+
const matched = terms.filter((term) => lower.includes(term));
|
|
11798
|
+
return {
|
|
11799
|
+
...c,
|
|
11800
|
+
score: matched.length,
|
|
11801
|
+
matched
|
|
11802
|
+
};
|
|
11803
|
+
}).filter((c) => c.score > 0);
|
|
11804
|
+
if (scored.length === 0) return textOnly(`未找到包含 ${terms.join(" ")} 中任一词的消息(字符串匹配,不区分大小写)`);
|
|
11805
|
+
scored.sort((a, b) => b.score - a.score || b.cm.index - a.cm.index);
|
|
11806
|
+
const hits = scored.slice(0, input.topK ?? 3).map((hit) => ({
|
|
11807
|
+
...hit,
|
|
11808
|
+
explanation: `命中 ${hit.score}/${terms.length} 个词: ${hit.matched.join(" ")}`
|
|
11809
|
+
}));
|
|
11810
|
+
return renderHits(input, range, `${candidates.length} 条,字符串匹配`, scored.length, hits);
|
|
11811
|
+
}
|
|
11812
|
+
/** 渲染命中条目:查询与检索说明以 XML 注释置于条目之前,每条命中前附匹配说明。 */
|
|
11813
|
+
function renderHits(input, range, poolNote, total, hits) {
|
|
11814
|
+
const { session, query, start, getPruner } = input;
|
|
11373
11815
|
const parts = [];
|
|
11374
11816
|
const images = [];
|
|
11375
|
-
const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${
|
|
11817
|
+
const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${poolNote})` : `检索区间 [${range.lo}..${range.hi}](${poolNote})`;
|
|
11376
11818
|
parts.push(`<!-- ${xmlCommentText(`查询: ${query}`)} -->`);
|
|
11377
11819
|
parts.push(`<!-- ${xmlCommentText(rangeNote)} -->`);
|
|
11378
|
-
parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${
|
|
11820
|
+
parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${total} 条候选)`)} -->`);
|
|
11379
11821
|
for (let i = 0; i < hits.length; i += 1) {
|
|
11380
11822
|
const hit = hits[i];
|
|
11381
11823
|
if (!hit) continue;
|
|
11382
|
-
const note = `<!-- ${xmlCommentText(`${i + 1}. ${
|
|
11824
|
+
const note = `<!-- ${xmlCommentText(`${i + 1}. ${hit.explanation}`)} -->`;
|
|
11383
11825
|
let xml;
|
|
11384
11826
|
let hitImages = [];
|
|
11385
11827
|
try {
|
|
@@ -11405,28 +11847,20 @@ async function semanticSearch(input) {
|
|
|
11405
11847
|
//#endregion
|
|
11406
11848
|
//#region src/recall.ts
|
|
11407
11849
|
/**
|
|
11408
|
-
* recall
|
|
11409
|
-
* 导出 recallArgsSchema /
|
|
11850
|
+
* recall 工具:回看原始会话(含被压缩内容)。
|
|
11851
|
+
* 导出 recallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
|
|
11410
11852
|
* - 区间模式:按完整消息 index 的 start/end/offset 精确返回区间内全部完整消息。
|
|
11411
|
-
* -
|
|
11853
|
+
* - 检索模式(带 query):语义增强启用时按含义检索,否则按字符串匹配,见 semantic-recall.ts。
|
|
11412
11854
|
* 输出值为 { text, images }(契约见 recall-output.ts),text 为 XML 条目序列
|
|
11413
11855
|
* (形态见 recall-xml.ts);recall 自身不设输出上限,超大工具结果由 tool-result-pruner 裁剪。
|
|
11414
11856
|
*/
|
|
11415
11857
|
/**
|
|
11416
|
-
*
|
|
11858
|
+
* recall 参数 schema:带 query 走检索模式(区间可选,用于限定检索范围);
|
|
11859
|
+
* 不带 query 时 start 必填,end 与 offset 至少提供一个(同时给出时 end 优先)。
|
|
11417
11860
|
* 各字段描述经 .describe() 透传到 wire JSON Schema。
|
|
11418
11861
|
*/
|
|
11419
11862
|
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 仅用于限定搜索区间,缺省检索全部。"),
|
|
11863
|
+
query: z.string().optional().describe("检索 query(中英文与代码术语皆可);提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
|
|
11430
11864
|
top_k: z.number().int().min(1).max(10).optional().describe("仅 query 模式:返回最匹配条数(1-10,默认 3)。"),
|
|
11431
11865
|
start: z.number().optional().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;未提供 query 时必填,且 end 与 offset 至少提供一个(同时给出时 end 优先)。"),
|
|
11432
11866
|
end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
|
|
@@ -11451,47 +11885,50 @@ const enhancedRecallArgsSchema = z.object({
|
|
|
11451
11885
|
message: "end 与 offset 至少提供一个"
|
|
11452
11886
|
});
|
|
11453
11887
|
});
|
|
11454
|
-
/** 解析并校验 recall
|
|
11455
|
-
function parseRecallArgs(raw
|
|
11456
|
-
const result =
|
|
11888
|
+
/** 解析并校验 recall 调用参数:失败时抛出首个校验问题的可读消息。 */
|
|
11889
|
+
function parseRecallArgs(raw) {
|
|
11890
|
+
const result = recallArgsSchema.safeParse(raw);
|
|
11457
11891
|
if (!result.success) throw new Error(result.error.issues.map((issue) => `${issue.path.join(".") || "args"}: ${issue.message}`).join("; "));
|
|
11458
11892
|
return result.data;
|
|
11459
11893
|
}
|
|
11460
|
-
/**
|
|
11461
|
-
|
|
11462
|
-
|
|
11463
|
-
|
|
11894
|
+
/** 工具描述:两种用法;query 的匹配方式随语义增强开关变化。 */
|
|
11895
|
+
function recallDescription(semantic) {
|
|
11896
|
+
return `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}两种用法:1) 给出 start 与 end 或 offset,按 index 区间精确返回区间内全部完整消息的内容;2) 给出 query,${semantic ? "按自然语言含义检索最符合的完整消息" : "按字符串匹配检索完整消息(query 按空白拆词、不区分大小写,按命中词数排序,宜用原文中出现的文件名、函数名、错误码或 key-word 关键词)"},默认全量搜索,可用 start/end/offset 限定区间。注意:query 只匹配文本。`;
|
|
11897
|
+
}
|
|
11464
11898
|
/**
|
|
11465
|
-
* 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index
|
|
11466
|
-
*
|
|
11899
|
+
* 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index),
|
|
11900
|
+
* 或按 query 检索(传入 semantic 选项时语义检索,否则字符串匹配)。
|
|
11467
11901
|
*/
|
|
11468
11902
|
function buildRecallTool(options) {
|
|
11469
11903
|
const getPruner = options?.getPruner;
|
|
11470
11904
|
const semantic = options?.semantic;
|
|
11471
11905
|
return {
|
|
11472
11906
|
name: "recall",
|
|
11473
|
-
description: semantic
|
|
11474
|
-
parameters: parametersFromZod(
|
|
11907
|
+
description: recallDescription(semantic !== void 0),
|
|
11908
|
+
parameters: parametersFromZod(recallArgsSchema),
|
|
11475
11909
|
output: {
|
|
11476
11910
|
schema: RECALL_OUTPUT_SCHEMA,
|
|
11477
11911
|
render: (_args, value) => renderRecallOutput(value)
|
|
11478
11912
|
},
|
|
11479
11913
|
async execute(args, exec) {
|
|
11480
|
-
const { query, top_k, start, end, offset } = parseRecallArgs(args
|
|
11914
|
+
const { query, top_k, start, end, offset } = parseRecallArgs(args);
|
|
11481
11915
|
const session = exec.agent?.session;
|
|
11482
11916
|
if (!session) return textOnly("会话异常");
|
|
11483
11917
|
if (!isMainSession(session)) return textOnly("recall 仅主会话可用");
|
|
11484
|
-
if (query !== void 0)
|
|
11485
|
-
|
|
11486
|
-
|
|
11487
|
-
|
|
11488
|
-
|
|
11489
|
-
|
|
11490
|
-
|
|
11491
|
-
|
|
11492
|
-
|
|
11493
|
-
|
|
11494
|
-
|
|
11918
|
+
if (query !== void 0) {
|
|
11919
|
+
const input = {
|
|
11920
|
+
session,
|
|
11921
|
+
query,
|
|
11922
|
+
topK: top_k,
|
|
11923
|
+
start,
|
|
11924
|
+
end,
|
|
11925
|
+
offset,
|
|
11926
|
+
selfCallId: String(exec.callId ?? ""),
|
|
11927
|
+
getPruner: () => getPruner?.(),
|
|
11928
|
+
options: semantic
|
|
11929
|
+
};
|
|
11930
|
+
return semantic ? semanticSearch(input) : keywordSearch(input);
|
|
11931
|
+
}
|
|
11495
11932
|
if (start === void 0) return textOnly("start 必填");
|
|
11496
11933
|
const cms = indexCompleteMessages(session);
|
|
11497
11934
|
const startIndex = Number.isFinite(start) ? Math.floor(start) : 0;
|
|
@@ -11615,15 +12052,15 @@ function findLifecycle(session, compactionId) {
|
|
|
11615
12052
|
}
|
|
11616
12053
|
return lifecycle;
|
|
11617
12054
|
}
|
|
11618
|
-
/**
|
|
12055
|
+
/** 重建被压缩内容的视图:反思用被归档块的归档视图,观察用原消息;不可重建时返回错误。 */
|
|
11619
12056
|
function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
|
|
11620
|
-
if (phase === "reflect") return
|
|
12057
|
+
if (phase === "reflect") return buildArchiveView(shadowedSeqs.flatMap((seq) => {
|
|
11621
12058
|
const text = historyTextOf(session.snapshotEvents()[seq]);
|
|
11622
12059
|
return text === void 0 ? [] : [{
|
|
11623
12060
|
text,
|
|
11624
12061
|
seq
|
|
11625
12062
|
}];
|
|
11626
|
-
})
|
|
12063
|
+
})).view;
|
|
11627
12064
|
return buildObserveView(session, shadowedSeqs, { skipReasoning });
|
|
11628
12065
|
}
|
|
11629
12066
|
/** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
|
|
@@ -11680,7 +12117,7 @@ async function recompress(ctx, agent, config, request, signal) {
|
|
|
11680
12117
|
view,
|
|
11681
12118
|
originalChars,
|
|
11682
12119
|
phase,
|
|
11683
|
-
taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex),
|
|
12120
|
+
taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex, view.segments),
|
|
11684
12121
|
target,
|
|
11685
12122
|
maxTokens: config.compressMaxTokens,
|
|
11686
12123
|
rateLimitWaitMs: config.rateLimitWaitMs,
|
|
@@ -12002,7 +12439,7 @@ function apply(ctx, config) {
|
|
|
12002
12439
|
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
12440
|
const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
|
|
12004
12441
|
const logModel = (message) => logger.info(message);
|
|
12005
|
-
if (
|
|
12442
|
+
if (ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
|
|
12006
12443
|
if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
|
|
12007
12444
|
ctx.inject(["tools"], (inner) => {
|
|
12008
12445
|
let disposeRecall;
|
|
@@ -12011,13 +12448,13 @@ function apply(ctx, config) {
|
|
|
12011
12448
|
/** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
|
|
12012
12449
|
const syncTools = () => {
|
|
12013
12450
|
const next = currentConfig(config);
|
|
12014
|
-
const semantic = next.
|
|
12015
|
-
if (disposeRecall && (
|
|
12451
|
+
const semantic = next.semanticRecallEnabled;
|
|
12452
|
+
if (disposeRecall && (registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
|
|
12016
12453
|
disposeRecall();
|
|
12017
12454
|
disposeRecall = void 0;
|
|
12018
12455
|
registered = void 0;
|
|
12019
12456
|
}
|
|
12020
|
-
if (
|
|
12457
|
+
if (!disposeRecall) {
|
|
12021
12458
|
const directory = next.modelDir;
|
|
12022
12459
|
disposeRecall = inner.tools.register(buildRecallTool({
|
|
12023
12460
|
getPruner: () => inner.get("toolResultPruner"),
|
|
@@ -12047,6 +12484,8 @@ function apply(ctx, config) {
|
|
|
12047
12484
|
ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
|
|
12048
12485
|
ctx.on("session/disposed", (session) => disposePrecompression(session.id));
|
|
12049
12486
|
ctx.effect(() => () => disposeAllPrecompressions(), "dsh-plugin-om: precompression registry");
|
|
12487
|
+
ctx.on("session/disposed", (session) => disposeReflection(session.id));
|
|
12488
|
+
ctx.effect(() => () => disposeAllReflections(), "dsh-plugin-om: reflection registry");
|
|
12050
12489
|
ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
|
|
12051
12490
|
let outcome = { failed: false };
|
|
12052
12491
|
try {
|
|
@@ -12064,7 +12503,16 @@ function apply(ctx, config) {
|
|
|
12064
12503
|
logger.warn(`上下文压缩失败,拒绝本 step 中断当前 turn:${outcome.error}${diagnostic}`);
|
|
12065
12504
|
return { kind: "reject" };
|
|
12066
12505
|
}
|
|
12067
|
-
|
|
12506
|
+
let decision = await next();
|
|
12507
|
+
if (decision.kind === "enter" && decision.messages.length > 0 && !signal.aborted && isMainSession(agent.session)) try {
|
|
12508
|
+
const skills = commitReflection(ctx, agent, currentConfig(config));
|
|
12509
|
+
if (skills.length > 0) decision = {
|
|
12510
|
+
...decision,
|
|
12511
|
+
messages: [...decision.messages, ...skills]
|
|
12512
|
+
};
|
|
12513
|
+
} catch (error) {
|
|
12514
|
+
logger.warn(`反思提交失败: ${error instanceof Error ? error.message : String(error)}`);
|
|
12515
|
+
}
|
|
12068
12516
|
const latest = currentConfig(config);
|
|
12069
12517
|
const reminders = activeSystemReminders(latest);
|
|
12070
12518
|
if (decision.kind === "enter" && !signal.aborted && reminders.length > 0 && isMainSession(agent.session)) return {
|