dsh-plugin-om 0.0.56 → 0.0.58
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 +73 -17
- package/dist/client/OmCompactionCard.d.ts.map +1 -1
- package/dist/client/OmEvalModelPanel.d.ts +22 -0
- package/dist/client/OmEvalModelPanel.d.ts.map +1 -0
- package/dist/client/OmRecompressMenu.d.ts +3 -3
- package/dist/client/OmRecompressMenu.d.ts.map +1 -1
- package/dist/client/compaction-eval-jump.d.ts +20 -0
- package/dist/client/compaction-eval-jump.d.ts.map +1 -0
- package/dist/client/definition.d.ts +2 -2
- package/dist/client/definition.d.ts.map +1 -1
- package/dist/client/eval-model-panel.d.ts +57 -0
- package/dist/client/eval-model-panel.d.ts.map +1 -0
- package/dist/client/eval-model-register.d.ts +10 -0
- package/dist/client/eval-model-register.d.ts.map +1 -0
- package/dist/client/index.d.ts +2 -1
- package/dist/client/index.d.ts.map +1 -1
- package/dist/client/locales.d.ts +13 -2
- package/dist/client/locales.d.ts.map +1 -1
- package/dist/client/om-config-controller.d.ts +4 -1
- package/dist/client/om-config-controller.d.ts.map +1 -1
- package/dist/client/recompress-run.d.ts +23 -2
- package/dist/client/recompress-run.d.ts.map +1 -1
- package/dist/client.js +675 -116
- package/dist/client.js.map +1 -1
- package/dist/compaction-eval-command.d.ts +54 -0
- package/dist/compaction-eval-command.d.ts.map +1 -0
- package/dist/compaction-log.d.ts +31 -9
- package/dist/compaction-log.d.ts.map +1 -1
- package/dist/compress-loop.d.ts +21 -10
- package/dist/compress-loop.d.ts.map +1 -1
- package/dist/compress-tools.d.ts +16 -8
- package/dist/compress-tools.d.ts.map +1 -1
- package/dist/compress-view.d.ts +1 -3
- package/dist/compress-view.d.ts.map +1 -1
- package/dist/compress.d.ts +117 -8
- package/dist/compress.d.ts.map +1 -1
- package/dist/config.d.ts +4 -0
- package/dist/config.d.ts.map +1 -1
- package/dist/constants.d.ts +3 -1
- package/dist/constants.d.ts.map +1 -1
- package/dist/eval-session-text.d.ts +28 -0
- package/dist/eval-session-text.d.ts.map +1 -0
- package/dist/index.d.ts +4 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +1390 -478
- package/dist/log-index.d.ts +2 -2
- package/dist/log-index.d.ts.map +1 -1
- package/dist/om-event.d.ts +26 -2
- package/dist/om-event.d.ts.map +1 -1
- package/dist/precompress.d.ts +100 -0
- package/dist/precompress.d.ts.map +1 -0
- package/dist/recall-xml.d.ts +2 -1
- package/dist/recall-xml.d.ts.map +1 -1
- package/dist/recompress-gate.d.ts +11 -0
- package/dist/recompress-gate.d.ts.map +1 -0
- package/dist/recompress.d.ts +20 -4
- package/dist/recompress.d.ts.map +1 -1
- package/dist/skill/compaction-eval/SKILL.md +72 -0
- package/dist/skill/compaction-eval/references/facts-prompt.md +42 -0
- package/dist/skill/compaction-eval/references/judge-prompt.md +48 -0
- package/dist/skill/compaction-eval/references/rules.md +56 -0
- package/dist/skill/compaction-eval/scripts/aggregate.mjs +372 -0
- package/dist/skill/compaction-eval/scripts/compress.mjs +15675 -0
- package/dist/skill/compaction-eval/scripts/merge.mjs +287 -0
- package/dist/skill/compaction-eval/scripts/prepare.mjs +1620 -0
- package/dist/skill/compaction-eval/scripts/view.mjs +15983 -0
- package/dist/thinking-binding.d.ts +28 -0
- package/dist/thinking-binding.d.ts.map +1 -0
- package/dist/types.d.ts +9 -6
- package/dist/types.d.ts.map +1 -1
- package/package.json +47 -40
package/dist/index.mjs
CHANGED
|
@@ -1,20 +1,296 @@
|
|
|
1
|
+
import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
|
|
2
|
+
import { fileURLToPath } from "node:url";
|
|
3
|
+
import { brandString } from "@deepseek-ai/dsh-brand";
|
|
1
4
|
import { CompactionId } from "@deepseek-ai/dsh-compaction";
|
|
2
|
-
import { BlockAssembler, createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
|
|
5
|
+
import { BlockAssembler, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, freezeMessage, isAgentLoopRequest, markAgentLoopRequest } from "@deepseek-ai/dsh-llm";
|
|
3
6
|
import { scopeOf } from "@deepseek-ai/dsh-scope";
|
|
4
7
|
import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
|
|
5
8
|
import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
|
|
6
9
|
import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
|
|
7
10
|
import { z } from "zod";
|
|
8
11
|
import Schema from "@deepseek-ai/schemastery";
|
|
9
|
-
import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
|
|
10
12
|
import { homedir } from "node:os";
|
|
11
13
|
import path from "node:path";
|
|
12
|
-
import { fileURLToPath } from "node:url";
|
|
13
14
|
import { toJSONSchema } from "zod/v4/core";
|
|
14
15
|
import { AttachmentId } from "@deepseek-ai/dsh-attachment";
|
|
15
16
|
//#region \0rolldown/runtime.js
|
|
16
17
|
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
|
|
17
18
|
//#endregion
|
|
19
|
+
//#region src/eval-session-text.ts
|
|
20
|
+
/**
|
|
21
|
+
* /om-compaction-eval 的文本契约:命令名与描述、新会话首条消息、成功文本及其反解。
|
|
22
|
+
* 宿主命令与客户端跳转共用本模块,因此不得引入 Node 专有依赖(客户端 bundle 会内联它)。
|
|
23
|
+
* 导出 EVAL_COMMAND_NAME / EVAL_COMMAND_DESCRIPTION / EvalPromptInput / buildEvalPrompt /
|
|
24
|
+
* evalStartedText / parseEvalSessionId。
|
|
25
|
+
*/
|
|
26
|
+
/** 命令名(无参数,裸调用即执行)。 */
|
|
27
|
+
const EVAL_COMMAND_NAME = "om-compaction-eval";
|
|
28
|
+
/** 命令描述(斜杠菜单与命令目录展示)。 */
|
|
29
|
+
const EVAL_COMMAND_DESCRIPTION = "ai分析OM结果";
|
|
30
|
+
/** 新会话首条消息:只给文档路径与会话标识,评估步骤全部由文档决定。 */
|
|
31
|
+
function buildEvalPrompt(input) {
|
|
32
|
+
const workspaceId = input.workspaceId === void 0 ? "" : ` workspace_id ${input.workspaceId}`;
|
|
33
|
+
return `按照 ${input.docPath} 分析会话。workspace ${input.cwd}${workspaceId} session_id ${input.sessionId}`;
|
|
34
|
+
}
|
|
35
|
+
/** 成功文本前缀;客户端按同一格式反解新会话 id 用于跳转。 */
|
|
36
|
+
const STARTED_PREFIX = "已启动 OM 结果分析会话 ";
|
|
37
|
+
/** 命令成功文本。 */
|
|
38
|
+
function evalStartedText(sessionId) {
|
|
39
|
+
return `${STARTED_PREFIX}${sessionId}`;
|
|
40
|
+
}
|
|
41
|
+
//#endregion
|
|
42
|
+
//#region src/utils.ts
|
|
43
|
+
/** 判断值是否为普通对象(非 null、非数组)。 */
|
|
44
|
+
function isRecord$1(value) {
|
|
45
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
46
|
+
}
|
|
47
|
+
/** 生成 uuid:优先 crypto.randomUUID,回退为时间戳+随机串拼接。 */
|
|
48
|
+
function uuid() {
|
|
49
|
+
const cryptoObj = globalThis.crypto;
|
|
50
|
+
if (cryptoObj && typeof cryptoObj.randomUUID === "function") return cryptoObj.randomUUID();
|
|
51
|
+
return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
|
|
52
|
+
}
|
|
53
|
+
/** 提取 content 数组中的纯文本块(type === 'text' 的 block.text 拼接)。 */
|
|
54
|
+
function blocksToText(blocks) {
|
|
55
|
+
if (!Array.isArray(blocks)) return "";
|
|
56
|
+
const out = [];
|
|
57
|
+
for (const block of blocks) if (isRecord$1(block) && block.type === "text" && typeof block.text === "string") out.push(block.text);
|
|
58
|
+
return out.join("");
|
|
59
|
+
}
|
|
60
|
+
/** 消息内容的字符数:递归计入 text 块与 tool-result 内嵌文本。 */
|
|
61
|
+
function textCharCount(message) {
|
|
62
|
+
if (!message || !Array.isArray(message.content)) return 0;
|
|
63
|
+
let total = 0;
|
|
64
|
+
for (const block of message.content) if (block.type === "text") total += block.text.length;
|
|
65
|
+
else if (block.type === "tool-result") total += blocksToText(block.content).length;
|
|
66
|
+
return total;
|
|
67
|
+
}
|
|
68
|
+
/** 一组表层事件 seq 派生消息的字符数之和(OM 卡片「原始字符」口径)。 */
|
|
69
|
+
function seqsCharCount(session, seqs) {
|
|
70
|
+
const events = session.snapshotEvents();
|
|
71
|
+
return seqs.reduce((total, seq) => {
|
|
72
|
+
const event = events[seq];
|
|
73
|
+
return total + textCharCount(event ? session.deriveEventMessage(event) : null);
|
|
74
|
+
}, 0);
|
|
75
|
+
}
|
|
76
|
+
/** 面向 recall 的完整消息呈现:text 原样;tool-call 展开(参数=代码);tool-result 取文本。 */
|
|
77
|
+
function renderMessageText(message) {
|
|
78
|
+
if (!message || !Array.isArray(message.content)) return "";
|
|
79
|
+
const parts = [];
|
|
80
|
+
for (const block of message.content) if (block.type === "text") parts.push(block.text);
|
|
81
|
+
else if (block.type === "tool-call") parts.push(`[tool-call ${block.name} id=${String(block.id)}]
|
|
82
|
+
${toolArgsJson(block.arguments)}`);
|
|
83
|
+
else if (block.type === "tool-result") parts.push(blocksToText(block.content));
|
|
84
|
+
return parts.join("\n");
|
|
85
|
+
}
|
|
86
|
+
/** 安全 JSON 序列化:序列化失败时退回 String 呈现。 */
|
|
87
|
+
function safeJson(value) {
|
|
88
|
+
try {
|
|
89
|
+
return JSON.stringify(value, null, 2);
|
|
90
|
+
} catch {
|
|
91
|
+
return String(value);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* 工具调用参数的 JSON 文本(CDATA 内保持只有一层 JSON 转义):
|
|
96
|
+
* 字符串参数是模型产出的原始 JSON 串,原样返回(本身即合法 JSON,不再二次序列化);
|
|
97
|
+
* 其余结构 JSON.stringify 序列化一次。
|
|
98
|
+
*/
|
|
99
|
+
function toolArgsJson(args) {
|
|
100
|
+
if (typeof args === "string") return args;
|
|
101
|
+
return safeJson(args);
|
|
102
|
+
}
|
|
103
|
+
/**
|
|
104
|
+
* 向元素追加 CDATA 正文:正文统一以 CDATA 包裹(逐字原样,不做实体转义)。
|
|
105
|
+
* 正文含 ]]> 时拆为相邻多个 CDATA 段,拼接后逐字还原原文,对读取方透明。
|
|
106
|
+
*/
|
|
107
|
+
function appendCdataText(doc, el, text) {
|
|
108
|
+
const parts = text.split("]]>");
|
|
109
|
+
for (let i = 0; i < parts.length; i += 1) if (i === 0) el.appendChild(doc.createCDATASection(parts[0] ?? ""));
|
|
110
|
+
else {
|
|
111
|
+
el.appendChild(doc.createCDATASection("]]"));
|
|
112
|
+
el.appendChild(doc.createCDATASection(`>${parts[i] ?? ""}`));
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
/** 主会话判定:subagent 会话 header.origin === 'subagent'。 */
|
|
116
|
+
function isMainSession(session) {
|
|
117
|
+
return session.header?.origin !== "subagent";
|
|
118
|
+
}
|
|
119
|
+
/** 解析会话路由目标(provider/model),未路由时返回 undefined。 */
|
|
120
|
+
function routedTarget(session) {
|
|
121
|
+
try {
|
|
122
|
+
const config = session.requestHeader()?.config;
|
|
123
|
+
if (config?.provider && config.model) return {
|
|
124
|
+
provider: config.provider,
|
|
125
|
+
model: config.model
|
|
126
|
+
};
|
|
127
|
+
} catch {}
|
|
128
|
+
}
|
|
129
|
+
//#endregion
|
|
130
|
+
//#region src/compaction-eval-command.ts
|
|
131
|
+
/**
|
|
132
|
+
* /om-compaction-eval 命令:在被分析会话所属工作区新建一个会话,由它按随包发布的
|
|
133
|
+
* compaction-eval 文档分析当前会话的 OM 压缩结果,本会话上下文不受影响。
|
|
134
|
+
* 文档路径由本模块自身位置推出:发布产物优先,仓库源码兜底。
|
|
135
|
+
* 新会话的模型与思考等级默认沿用当前会话,可由命令参数 `provider/model [思考等级]` 指定。
|
|
136
|
+
* 导出 skillDocCandidates / skillDocPath / EvalModel / parseEvalModelInput /
|
|
137
|
+
* StartEvalResult / startEvalSession / buildCompactionEvalCommand。
|
|
138
|
+
*/
|
|
139
|
+
const MODEL_USAGE = "用法:/om-compaction-eval [provider/model [思考等级]]";
|
|
140
|
+
/**
|
|
141
|
+
* 解析命令参数 `provider/model [思考等级]`:以第一个 `/` 切分 provider 与 model,空白分隔等级。
|
|
142
|
+
* @returns 无参数时 model 为 undefined(沿用当前会话);格式错误返回用法说明。
|
|
143
|
+
*/
|
|
144
|
+
function parseEvalModelInput(rawInput) {
|
|
145
|
+
const parts = rawInput.split(/\s+/).filter((part) => part !== "");
|
|
146
|
+
if (parts.length === 0) return {
|
|
147
|
+
ok: true,
|
|
148
|
+
model: void 0
|
|
149
|
+
};
|
|
150
|
+
const [route, reasoningEffort] = parts;
|
|
151
|
+
const slash = route?.indexOf("/") ?? -1;
|
|
152
|
+
if (route === void 0 || slash <= 0 || slash === route.length - 1 || parts.length > 2) return {
|
|
153
|
+
ok: false,
|
|
154
|
+
error: MODEL_USAGE
|
|
155
|
+
};
|
|
156
|
+
return {
|
|
157
|
+
ok: true,
|
|
158
|
+
model: {
|
|
159
|
+
provider: route.slice(0, slash),
|
|
160
|
+
model: route.slice(slash + 1),
|
|
161
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
162
|
+
}
|
|
163
|
+
};
|
|
164
|
+
}
|
|
165
|
+
/** 当前会话最近一次请求使用的模型与思考等级;尚未请求过时 undefined。 */
|
|
166
|
+
function currentModel(session) {
|
|
167
|
+
try {
|
|
168
|
+
const config = session.requestHeader()?.config;
|
|
169
|
+
if (!config?.provider || !config.model) return void 0;
|
|
170
|
+
return {
|
|
171
|
+
provider: config.provider,
|
|
172
|
+
model: config.model,
|
|
173
|
+
...config.reasoningEffort === void 0 ? {} : { reasoningEffort: config.reasoningEffort }
|
|
174
|
+
};
|
|
175
|
+
} catch {
|
|
176
|
+
return;
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
/**
|
|
180
|
+
* skill 文档候选绝对路径,按优先级排列:
|
|
181
|
+
* 1. 发布产物 dist/skill/compaction-eval/SKILL.md(脚本为自包含 .mjs);
|
|
182
|
+
* 2. 仓库源码 .agents/skills/compaction-eval/SKILL.md(开发时 dist 未构建)。
|
|
183
|
+
* @param fromUrl - 入口模块 URL,缺省为本模块(打包后即 dist/index.mjs)。
|
|
184
|
+
*/
|
|
185
|
+
function skillDocCandidates(fromUrl = import.meta.url) {
|
|
186
|
+
return [fileURLToPath(new URL("./skill/compaction-eval/SKILL.md", fromUrl)), fileURLToPath(new URL("../.agents/skills/compaction-eval/SKILL.md", fromUrl))];
|
|
187
|
+
}
|
|
188
|
+
/**
|
|
189
|
+
* 第一个存在的 skill 文档路径。
|
|
190
|
+
* @param fromUrl - 入口模块 URL,缺省为本模块。
|
|
191
|
+
* @returns 文档绝对路径;都不存在时 undefined。
|
|
192
|
+
*/
|
|
193
|
+
function skillDocPath(fromUrl = import.meta.url) {
|
|
194
|
+
return skillDocCandidates(fromUrl).find((candidate) => existsSync(candidate));
|
|
195
|
+
}
|
|
196
|
+
/** 当前会话所属工作区 id;宿主无 workspaceRegistry 或会话未归属时 undefined。 */
|
|
197
|
+
function workspaceOf(ctx, sessionId) {
|
|
198
|
+
const registry = ctx.get("workspaceRegistry");
|
|
199
|
+
if (registry === void 0) return void 0;
|
|
200
|
+
return registry.list().find((workspace) => workspace.sessionIds.includes(sessionId))?.id;
|
|
201
|
+
}
|
|
202
|
+
/**
|
|
203
|
+
* 新建同工作区会话并投递首条消息。
|
|
204
|
+
* 非主会话、会话无 cwd、文档缺失或宿主缺 sessionController 时返回失败且不建会话;
|
|
205
|
+
* 建会话与投递的异常归一为失败原因。
|
|
206
|
+
* @param ctx - 宿主上下文(经 ctx.get 容错读取 sessionController 与 workspaceRegistry)。
|
|
207
|
+
* @param agent - 命令所针对的会话,其 id 与 cwd 决定分析目标与新会话位置。
|
|
208
|
+
* @param signal - 命令取消信号,透传给投递。
|
|
209
|
+
* @param model - 新会话模型;缺省沿用当前会话,当前会话尚未请求过时用宿主默认。
|
|
210
|
+
*/
|
|
211
|
+
async function startEvalSession(ctx, agent, signal, model) {
|
|
212
|
+
const session = agent.session;
|
|
213
|
+
if (!isMainSession(session)) return {
|
|
214
|
+
ok: false,
|
|
215
|
+
error: "OM 结果分析仅支持主会话"
|
|
216
|
+
};
|
|
217
|
+
const cwd = session.header?.cwd;
|
|
218
|
+
if (cwd === void 0 || cwd === "") return {
|
|
219
|
+
ok: false,
|
|
220
|
+
error: "当前会话没有工作区信息"
|
|
221
|
+
};
|
|
222
|
+
const docPath = skillDocPath();
|
|
223
|
+
if (docPath === void 0) return {
|
|
224
|
+
ok: false,
|
|
225
|
+
error: "找不到 compaction-eval 文档"
|
|
226
|
+
};
|
|
227
|
+
const controller = ctx.get("sessionController");
|
|
228
|
+
if (controller === void 0) return {
|
|
229
|
+
ok: false,
|
|
230
|
+
error: "宿主未提供 sessionController 服务"
|
|
231
|
+
};
|
|
232
|
+
const workspaceId = workspaceOf(ctx, session.id);
|
|
233
|
+
const preset = session.header?.agentPreset;
|
|
234
|
+
try {
|
|
235
|
+
const created = await controller.create({
|
|
236
|
+
...workspaceId === void 0 ? { cwd } : { workspaceId },
|
|
237
|
+
...preset === void 0 ? {} : { agentPreset: preset }
|
|
238
|
+
});
|
|
239
|
+
const selected = model ?? currentModel(session);
|
|
240
|
+
if (selected !== void 0) await controller.selectModel({
|
|
241
|
+
sessionId: created.sessionId,
|
|
242
|
+
...selected
|
|
243
|
+
});
|
|
244
|
+
await controller.prompt({
|
|
245
|
+
requestId: brandString(uuid()),
|
|
246
|
+
sessionId: created.sessionId,
|
|
247
|
+
mode: "queue",
|
|
248
|
+
content: [{
|
|
249
|
+
type: "text",
|
|
250
|
+
text: buildEvalPrompt({
|
|
251
|
+
docPath,
|
|
252
|
+
cwd,
|
|
253
|
+
...workspaceId === void 0 ? {} : { workspaceId },
|
|
254
|
+
sessionId: session.id
|
|
255
|
+
})
|
|
256
|
+
}]
|
|
257
|
+
}, signal);
|
|
258
|
+
return {
|
|
259
|
+
ok: true,
|
|
260
|
+
sessionId: created.sessionId,
|
|
261
|
+
text: evalStartedText(created.sessionId)
|
|
262
|
+
};
|
|
263
|
+
} catch (error) {
|
|
264
|
+
return {
|
|
265
|
+
ok: false,
|
|
266
|
+
error: error instanceof Error ? error.message : String(error)
|
|
267
|
+
};
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
/** 构造 /om-compaction-eval 命令定义:可选参数指定新会话的模型与思考等级。 */
|
|
271
|
+
function buildCompactionEvalCommand(ctx) {
|
|
272
|
+
return {
|
|
273
|
+
name: EVAL_COMMAND_NAME,
|
|
274
|
+
description: EVAL_COMMAND_DESCRIPTION,
|
|
275
|
+
input: { hint: "[provider/model [思考等级]]" },
|
|
276
|
+
handler: async ({ agent, rawInput, signal }) => {
|
|
277
|
+
const parsed = parseEvalModelInput(rawInput);
|
|
278
|
+
if (!parsed.ok) return {
|
|
279
|
+
kind: "error",
|
|
280
|
+
text: parsed.error
|
|
281
|
+
};
|
|
282
|
+
const result = await startEvalSession(ctx, agent, signal, parsed.model);
|
|
283
|
+
return result.ok ? {
|
|
284
|
+
kind: "success",
|
|
285
|
+
text: result.text
|
|
286
|
+
} : {
|
|
287
|
+
kind: "error",
|
|
288
|
+
text: result.error
|
|
289
|
+
};
|
|
290
|
+
}
|
|
291
|
+
};
|
|
292
|
+
}
|
|
293
|
+
//#endregion
|
|
18
294
|
//#region src/format.ts
|
|
19
295
|
/**
|
|
20
296
|
* 紧凑数字格式化(压缩卡片、重压缩记录与压缩日志共用)。零依赖,服务端与浏览器均可引用。导出 formatCompactCount / formatSeconds。
|
|
@@ -59,7 +335,7 @@ const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
|
|
|
59
335
|
* 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
|
|
60
336
|
* 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
|
|
61
337
|
*/
|
|
62
|
-
const COMPLETE_MESSAGE_DEFINITION = "
|
|
338
|
+
const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
|
|
63
339
|
/**
|
|
64
340
|
* 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
|
|
65
341
|
* CDATA 约定 + toolcall 结构)始终保留;<user_message> /
|
|
@@ -69,7 +345,7 @@ function historyFormatNote(sections = {}) {
|
|
|
69
345
|
const parts = [
|
|
70
346
|
COMPLETE_MESSAGE_DEFINITION,
|
|
71
347
|
"<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
|
|
72
|
-
"<assistant type=\"toolcall\" tool-name=\"T\"
|
|
348
|
+
"<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
|
|
73
349
|
];
|
|
74
350
|
if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
|
|
75
351
|
if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
|
|
@@ -120,94 +396,6 @@ function makeLogger(ctx, debug) {
|
|
|
120
396
|
};
|
|
121
397
|
}
|
|
122
398
|
//#endregion
|
|
123
|
-
//#region src/utils.ts
|
|
124
|
-
/** 判断值是否为普通对象(非 null、非数组)。 */
|
|
125
|
-
function isRecord(value) {
|
|
126
|
-
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
127
|
-
}
|
|
128
|
-
/** 生成 uuid:优先 crypto.randomUUID,回退为时间戳+随机串拼接。 */
|
|
129
|
-
function uuid() {
|
|
130
|
-
const cryptoObj = globalThis.crypto;
|
|
131
|
-
if (cryptoObj && typeof cryptoObj.randomUUID === "function") return cryptoObj.randomUUID();
|
|
132
|
-
return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
|
|
133
|
-
}
|
|
134
|
-
/** 提取 content 数组中的纯文本块(type === 'text' 的 block.text 拼接)。 */
|
|
135
|
-
function blocksToText(blocks) {
|
|
136
|
-
if (!Array.isArray(blocks)) return "";
|
|
137
|
-
const out = [];
|
|
138
|
-
for (const block of blocks) if (isRecord(block) && block.type === "text" && typeof block.text === "string") out.push(block.text);
|
|
139
|
-
return out.join("");
|
|
140
|
-
}
|
|
141
|
-
/** 消息内容的字符数:递归计入 text 块与 tool-result 内嵌文本。 */
|
|
142
|
-
function textCharCount(message) {
|
|
143
|
-
if (!message || !Array.isArray(message.content)) return 0;
|
|
144
|
-
let total = 0;
|
|
145
|
-
for (const block of message.content) if (block.type === "text") total += block.text.length;
|
|
146
|
-
else if (block.type === "tool-result") total += blocksToText(block.content).length;
|
|
147
|
-
return total;
|
|
148
|
-
}
|
|
149
|
-
/** 一组表层事件 seq 派生消息的字符数之和(OM 卡片「原始字符」口径)。 */
|
|
150
|
-
function seqsCharCount(session, seqs) {
|
|
151
|
-
const events = session.snapshotEvents();
|
|
152
|
-
return seqs.reduce((total, seq) => {
|
|
153
|
-
const event = events[seq];
|
|
154
|
-
return total + textCharCount(event ? session.deriveEventMessage(event) : null);
|
|
155
|
-
}, 0);
|
|
156
|
-
}
|
|
157
|
-
/** 面向 recall 的完整消息呈现:text 原样;tool-call 展开(参数=代码);tool-result 取文本。 */
|
|
158
|
-
function renderMessageText(message) {
|
|
159
|
-
if (!message || !Array.isArray(message.content)) return "";
|
|
160
|
-
const parts = [];
|
|
161
|
-
for (const block of message.content) if (block.type === "text") parts.push(block.text);
|
|
162
|
-
else if (block.type === "tool-call") parts.push(`[tool-call ${block.name} id=${String(block.id)}]
|
|
163
|
-
${toolArgsJson(block.arguments)}`);
|
|
164
|
-
else if (block.type === "tool-result") parts.push(blocksToText(block.content));
|
|
165
|
-
return parts.join("\n");
|
|
166
|
-
}
|
|
167
|
-
/** 安全 JSON 序列化:序列化失败时退回 String 呈现。 */
|
|
168
|
-
function safeJson(value) {
|
|
169
|
-
try {
|
|
170
|
-
return JSON.stringify(value, null, 2);
|
|
171
|
-
} catch {
|
|
172
|
-
return String(value);
|
|
173
|
-
}
|
|
174
|
-
}
|
|
175
|
-
/**
|
|
176
|
-
* 工具调用参数的 JSON 文本(CDATA 内保持只有一层 JSON 转义):
|
|
177
|
-
* 字符串参数是模型产出的原始 JSON 串,原样返回(本身即合法 JSON,不再二次序列化);
|
|
178
|
-
* 其余结构 JSON.stringify 序列化一次。
|
|
179
|
-
*/
|
|
180
|
-
function toolArgsJson(args) {
|
|
181
|
-
if (typeof args === "string") return args;
|
|
182
|
-
return safeJson(args);
|
|
183
|
-
}
|
|
184
|
-
/**
|
|
185
|
-
* 向元素追加 CDATA 正文:正文统一以 CDATA 包裹(逐字原样,不做实体转义)。
|
|
186
|
-
* 正文含 ]]> 时拆为相邻多个 CDATA 段,拼接后逐字还原原文,对读取方透明。
|
|
187
|
-
*/
|
|
188
|
-
function appendCdataText(doc, el, text) {
|
|
189
|
-
const parts = text.split("]]>");
|
|
190
|
-
for (let i = 0; i < parts.length; i += 1) if (i === 0) el.appendChild(doc.createCDATASection(parts[0] ?? ""));
|
|
191
|
-
else {
|
|
192
|
-
el.appendChild(doc.createCDATASection("]]"));
|
|
193
|
-
el.appendChild(doc.createCDATASection(`>${parts[i] ?? ""}`));
|
|
194
|
-
}
|
|
195
|
-
}
|
|
196
|
-
/** 主会话判定:subagent 会话 header.origin === 'subagent'。 */
|
|
197
|
-
function isMainSession(session) {
|
|
198
|
-
return session.header?.origin !== "subagent";
|
|
199
|
-
}
|
|
200
|
-
/** 解析会话路由目标(provider/model),未路由时返回 undefined。 */
|
|
201
|
-
function routedTarget(session) {
|
|
202
|
-
try {
|
|
203
|
-
const config = session.requestHeader()?.config;
|
|
204
|
-
if (config?.provider && config.model) return {
|
|
205
|
-
provider: config.provider,
|
|
206
|
-
model: config.model
|
|
207
|
-
};
|
|
208
|
-
} catch {}
|
|
209
|
-
}
|
|
210
|
-
//#endregion
|
|
211
399
|
//#region src/compaction-log.ts
|
|
212
400
|
/** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
|
|
213
401
|
const COMPACTION_LOG_PROVIDER = "om-compaction-log";
|
|
@@ -218,17 +406,22 @@ function phaseLabel(phase) {
|
|
|
218
406
|
return "压缩";
|
|
219
407
|
}
|
|
220
408
|
/**
|
|
221
|
-
* 压缩会话记录 label
|
|
222
|
-
*
|
|
409
|
+
* 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
|
|
410
|
+
* 重压缩追加 `-重压缩`,失败追加 `-失败`。
|
|
223
411
|
*/
|
|
224
|
-
function compressionRecordLabel(phase,
|
|
225
|
-
|
|
226
|
-
|
|
412
|
+
function compressionRecordLabel(phase, range, success, retry) {
|
|
413
|
+
return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
|
|
414
|
+
}
|
|
415
|
+
/** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
|
|
416
|
+
function failureText(failure) {
|
|
417
|
+
if (failure === void 0) return "无(压缩失败)";
|
|
418
|
+
const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
|
|
419
|
+
return `无(压缩失败:${failure.reason}${last})`;
|
|
227
420
|
}
|
|
228
421
|
/** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
|
|
229
422
|
function compressionInfo(info) {
|
|
230
423
|
const effort = info.reasoningEffort ?? "默认思考等级";
|
|
231
|
-
const result = info.resultChars === void 0 ?
|
|
424
|
+
const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
|
|
232
425
|
return {
|
|
233
426
|
text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
|
|
234
427
|
provider: info.target.provider,
|
|
@@ -258,7 +451,7 @@ function seedEvent(type, seq, time, data, surfaceOp) {
|
|
|
258
451
|
* 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
|
|
259
452
|
* 轮结束时刻与循环结束时刻。
|
|
260
453
|
*/
|
|
261
|
-
function buildCompressionSeed(messages, stats, label, info) {
|
|
454
|
+
function buildCompressionSeed(messages, stats, label, info, system) {
|
|
262
455
|
const seed = [];
|
|
263
456
|
const push = (type, time, data, surfaceOp) => {
|
|
264
457
|
seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
|
|
@@ -276,12 +469,13 @@ function buildCompressionSeed(messages, stats, label, info) {
|
|
|
276
469
|
label
|
|
277
470
|
});
|
|
278
471
|
push("turn/start", at(stats.startedAt), { turn: 1 });
|
|
279
|
-
let step =
|
|
472
|
+
let step = 1;
|
|
280
473
|
let assistantIndex = 0;
|
|
281
474
|
let stepTime = stats.startedAt;
|
|
475
|
+
let stepOpen = false;
|
|
282
476
|
let pending = [];
|
|
283
477
|
const closeStep = () => {
|
|
284
|
-
if (
|
|
478
|
+
if (!stepOpen) return;
|
|
285
479
|
for (const call of pending) {
|
|
286
480
|
if (executed.has(call.id)) continue;
|
|
287
481
|
const repair = createToolResultMessage({
|
|
@@ -310,6 +504,7 @@ function buildCompressionSeed(messages, stats, label, info) {
|
|
|
310
504
|
step
|
|
311
505
|
});
|
|
312
506
|
pending = [];
|
|
507
|
+
stepOpen = false;
|
|
313
508
|
};
|
|
314
509
|
for (const message of messages) if (message.role === "assistant") {
|
|
315
510
|
closeStep();
|
|
@@ -322,6 +517,7 @@ function buildCompressionSeed(messages, stats, label, info) {
|
|
|
322
517
|
turn: 1,
|
|
323
518
|
step
|
|
324
519
|
});
|
|
520
|
+
stepOpen = true;
|
|
325
521
|
const assistant = message;
|
|
326
522
|
const assistantTime = at(completedAt);
|
|
327
523
|
push("assistant/message", assistantTime, {
|
|
@@ -348,7 +544,26 @@ function buildCompressionSeed(messages, stats, label, info) {
|
|
|
348
544
|
step,
|
|
349
545
|
message
|
|
350
546
|
}, "append");
|
|
351
|
-
else
|
|
547
|
+
else if (!stepOpen) {
|
|
548
|
+
const user = message;
|
|
549
|
+
push("step/start", at(stats.startedAt), {
|
|
550
|
+
turn: 1,
|
|
551
|
+
step
|
|
552
|
+
});
|
|
553
|
+
stepOpen = true;
|
|
554
|
+
if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
|
|
555
|
+
turn: 1,
|
|
556
|
+
step,
|
|
557
|
+
message: createSystemMessage(system)
|
|
558
|
+
}, "append");
|
|
559
|
+
push("user/message", at(stats.startedAt), {
|
|
560
|
+
...user,
|
|
561
|
+
source: { kind: "user" }
|
|
562
|
+
}, "append");
|
|
563
|
+
} else {
|
|
564
|
+
const user = message;
|
|
565
|
+
push("user/message", at(stepTime), user, "append");
|
|
566
|
+
}
|
|
352
567
|
closeStep();
|
|
353
568
|
if (info !== void 0) {
|
|
354
569
|
step += 1;
|
|
@@ -386,7 +601,7 @@ function buildCompressionSeed(messages, stats, label, info) {
|
|
|
386
601
|
* 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
|
|
387
602
|
* ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
|
|
388
603
|
* delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
|
|
389
|
-
* om-compaction-log,label
|
|
604
|
+
* om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
|
|
390
605
|
* subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
|
|
391
606
|
* logger.warn 并返回 undefined。
|
|
392
607
|
*/
|
|
@@ -394,9 +609,14 @@ async function recordCompressionSession(ctx, parentSession, options) {
|
|
|
394
609
|
const logger = makeLogger(ctx, options.debug);
|
|
395
610
|
try {
|
|
396
611
|
const header = parentSession.header;
|
|
397
|
-
const label = compressionRecordLabel(options.phase, options.
|
|
398
|
-
const seed = buildCompressionSeed(options.messages, options.stats, label, options.info);
|
|
399
|
-
const
|
|
612
|
+
const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
|
|
613
|
+
const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
|
|
614
|
+
const sessions = ctx.get("sessions");
|
|
615
|
+
if (sessions === void 0) {
|
|
616
|
+
logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
|
|
617
|
+
return;
|
|
618
|
+
}
|
|
619
|
+
const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
|
|
400
620
|
seed,
|
|
401
621
|
meta: {
|
|
402
622
|
...header.cwd === void 0 ? {} : { cwd: header.cwd },
|
|
@@ -421,7 +641,7 @@ async function recordCompressionSession(ctx, parentSession, options) {
|
|
|
421
641
|
mode: "one-shot",
|
|
422
642
|
label
|
|
423
643
|
});
|
|
424
|
-
await
|
|
644
|
+
await sessions.flush(parentSession);
|
|
425
645
|
return child.id;
|
|
426
646
|
} catch (error) {
|
|
427
647
|
const message = error instanceof Error ? error.message : String(error);
|
|
@@ -7569,8 +7789,9 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
7569
7789
|
* renderCompleteMessage(完整消息渲染与图片附件收集)。事件日志仅追加(被遮蔽的事件仍可读,
|
|
7570
7790
|
* recall 依赖此性质)。
|
|
7571
7791
|
*
|
|
7572
|
-
*
|
|
7573
|
-
* toolcall(单个工具调用及其结果,result 按 callId
|
|
7792
|
+
* 完整消息分四类:user(用户消息)、assistant(模型输出文本)、
|
|
7793
|
+
* toolcall(单个工具调用及其结果,result 按 callId 匹配并入)、
|
|
7794
|
+
* skill(手动加载的 skill,source.kind 为 skill-invocation 的系统消息)。其余系统消息不占位。
|
|
7574
7795
|
* index 从 0 起、按日志顺序递增、只追加不重排(压缩后旧摘要条目引用的 index 仍然有效)。
|
|
7575
7796
|
*/
|
|
7576
7797
|
/** 查找 seq 在表层节点序列中的下标(不在则返回 -1)。 */
|
|
@@ -7579,7 +7800,16 @@ function surfaceIndexOf(nodes, seq) {
|
|
|
7579
7800
|
return -1;
|
|
7580
7801
|
}
|
|
7581
7802
|
/**
|
|
7582
|
-
*
|
|
7803
|
+
* 手动加载 skill 的名称:source.kind 为 skill-invocation 且 name 为非空字符串时返回,否则 undefined。
|
|
7804
|
+
* 当前宿主类型未声明该 kind,故以宽松结构读取。
|
|
7805
|
+
*/
|
|
7806
|
+
function skillInvocationName(source) {
|
|
7807
|
+
if (source?.kind !== "skill-invocation") return void 0;
|
|
7808
|
+
const name = source.name;
|
|
7809
|
+
return typeof name === "string" && name !== "" ? name : void 0;
|
|
7810
|
+
}
|
|
7811
|
+
/**
|
|
7812
|
+
* 完整消息索引:按日志顺序把消息事件折叠为完整消息序列(四类,见文件头)。
|
|
7583
7813
|
* 工具调用结果按 source.callId 匹配其 tool-call 并入该条;未匹配的 result 独立成条(防御)。
|
|
7584
7814
|
* 本插件自产消息不占位;压缩在 agent/pre-step 触发(call-result 完备),不存在未闭合调用。
|
|
7585
7815
|
*/
|
|
@@ -7593,11 +7823,18 @@ function indexCompleteMessages(session) {
|
|
|
7593
7823
|
if (event.type === "user/message") {
|
|
7594
7824
|
const source = event.data.source;
|
|
7595
7825
|
if (isPluginOwnedSource(source)) continue;
|
|
7826
|
+
const skillName = skillInvocationName(source);
|
|
7596
7827
|
if (source?.kind === "user") cms.push({
|
|
7597
7828
|
index: cms.length,
|
|
7598
7829
|
type: "user",
|
|
7599
7830
|
seqs: [seq]
|
|
7600
7831
|
});
|
|
7832
|
+
else if (skillName !== void 0) cms.push({
|
|
7833
|
+
index: cms.length,
|
|
7834
|
+
type: "skill",
|
|
7835
|
+
seqs: [seq],
|
|
7836
|
+
skillName
|
|
7837
|
+
});
|
|
7601
7838
|
} else if (event.type === "assistant/message") {
|
|
7602
7839
|
const message = event.data.message;
|
|
7603
7840
|
if (!message || !Array.isArray(message.content)) continue;
|
|
@@ -7647,10 +7884,10 @@ function indexCompleteMessages(session) {
|
|
|
7647
7884
|
function collectImageRefs(content, out) {
|
|
7648
7885
|
if (!Array.isArray(content)) return;
|
|
7649
7886
|
for (const block of content) {
|
|
7650
|
-
if (!isRecord(block)) continue;
|
|
7887
|
+
if (!isRecord$1(block)) continue;
|
|
7651
7888
|
if (block.type === "image") {
|
|
7652
7889
|
const a = block.attachment;
|
|
7653
|
-
if (isRecord(a) && typeof a.attachmentId === "string" && a.attachmentId !== "" && typeof a.mediaType === "string" && typeof a.bytes === "number" && Number.isFinite(a.bytes) && typeof a.width === "number" && Number.isFinite(a.width) && typeof a.height === "number" && Number.isFinite(a.height)) out.push({
|
|
7890
|
+
if (isRecord$1(a) && typeof a.attachmentId === "string" && a.attachmentId !== "" && typeof a.mediaType === "string" && typeof a.bytes === "number" && Number.isFinite(a.bytes) && typeof a.width === "number" && Number.isFinite(a.width) && typeof a.height === "number" && Number.isFinite(a.height)) out.push({
|
|
7654
7891
|
attachmentId: a.attachmentId,
|
|
7655
7892
|
mediaType: a.mediaType,
|
|
7656
7893
|
bytes: a.bytes,
|
|
@@ -7697,13 +7934,13 @@ function renderToolResultText(session, cm, pruner) {
|
|
|
7697
7934
|
return message ? renderMessageText(message) : "";
|
|
7698
7935
|
}
|
|
7699
7936
|
/** 渲染一条完整消息为「文本 + 图片」(recall 输出用):
|
|
7700
|
-
* user 取消息原文,assistant 取文本块,toolcall 为调用块 + 结果文本
|
|
7937
|
+
* user / skill 取消息原文,assistant 取文本块,toolcall 为调用块 + 结果文本
|
|
7701
7938
|
* (pruner 裁剪超大结果);同时收集该条完整消息携带的图片附件(含 tool-result 嵌套,
|
|
7702
7939
|
* pruner 裁剪掉的图片不收集)。
|
|
7703
7940
|
*/
|
|
7704
7941
|
function renderCompleteMessageParts(session, cm, pruner) {
|
|
7705
7942
|
const images = [];
|
|
7706
|
-
if (cm.type === "user") {
|
|
7943
|
+
if (cm.type === "user" || cm.type === "skill") {
|
|
7707
7944
|
const seq = cm.seqs[0];
|
|
7708
7945
|
const event = seq === void 0 ? void 0 : session.snapshotEvents()[seq];
|
|
7709
7946
|
const message = event ? session.deriveEventMessage(event) : null;
|
|
@@ -7808,7 +8045,7 @@ function skillNameOf(session, cm) {
|
|
|
7808
8045
|
for (const block of message.content) if (block.type === "tool-call" && String(block.id ?? "") === (cm.callId ?? "")) {
|
|
7809
8046
|
try {
|
|
7810
8047
|
const args = JSON.parse(String(block.arguments ?? ""));
|
|
7811
|
-
if (isRecord(args) && typeof args.name === "string") return args.name;
|
|
8048
|
+
if (isRecord$1(args) && typeof args.name === "string") return args.name;
|
|
7812
8049
|
} catch {}
|
|
7813
8050
|
return "";
|
|
7814
8051
|
}
|
|
@@ -7918,6 +8155,19 @@ function buildObserveView(session, seqs, options = {}) {
|
|
|
7918
8155
|
});
|
|
7919
8156
|
continue;
|
|
7920
8157
|
}
|
|
8158
|
+
if (cm.type === "skill") {
|
|
8159
|
+
const text = renderCompleteMessage(session, cm);
|
|
8160
|
+
if (text.trim() === "") continue;
|
|
8161
|
+
entries.push({
|
|
8162
|
+
kind: "assistant",
|
|
8163
|
+
lo: cm.index,
|
|
8164
|
+
hi: cm.index,
|
|
8165
|
+
text,
|
|
8166
|
+
toolName: SKILL_TOOL_NAME,
|
|
8167
|
+
...cm.skillName === void 0 ? {} : { skillName: cm.skillName }
|
|
8168
|
+
});
|
|
8169
|
+
continue;
|
|
8170
|
+
}
|
|
7921
8171
|
if (options.skipReasoning !== true) {
|
|
7922
8172
|
const callSeq = cm.seqs[0];
|
|
7923
8173
|
const reasonings = callSeq === void 0 ? void 0 : reasoningBySeq.get(callSeq);
|
|
@@ -7953,7 +8203,6 @@ function buildObserveView(session, seqs, options = {}) {
|
|
|
7953
8203
|
text,
|
|
7954
8204
|
...toolName === void 0 ? {} : { toolName },
|
|
7955
8205
|
...skillName === void 0 ? {} : { skillName },
|
|
7956
|
-
...cm.callId === void 0 || toolArgs === void 0 ? {} : { callId: cm.callId },
|
|
7957
8206
|
...toolArgs === void 0 ? {} : { toolArgs },
|
|
7958
8207
|
...toolResult === void 0 ? {} : { toolResult },
|
|
7959
8208
|
...ask === null ? {} : { ask }
|
|
@@ -8103,14 +8352,12 @@ function parseBlockEntries(blockText, blockSeq) {
|
|
|
8103
8352
|
if (toolArgs !== void 0) {
|
|
8104
8353
|
const toolResult = childText(el, "tool-result");
|
|
8105
8354
|
const toolName = el.getAttribute("tool-name");
|
|
8106
|
-
const callId = el.getAttribute("callId");
|
|
8107
8355
|
entries.push({
|
|
8108
8356
|
kind: "assistant",
|
|
8109
8357
|
lo: index,
|
|
8110
8358
|
hi: index,
|
|
8111
8359
|
text,
|
|
8112
8360
|
...toolName === null || toolName === "" ? {} : { toolName },
|
|
8113
|
-
...callId === null || callId === "" ? {} : { callId },
|
|
8114
8361
|
toolArgs,
|
|
8115
8362
|
...toolResult === void 0 ? {} : { toolResult },
|
|
8116
8363
|
blockSeq
|
|
@@ -8223,7 +8470,6 @@ function entryToElement(doc, entry) {
|
|
|
8223
8470
|
el.setAttribute("index", String(entry.lo));
|
|
8224
8471
|
el.setAttribute("type", "toolcall");
|
|
8225
8472
|
if (entry.toolName !== void 0 && entry.toolName !== "") el.setAttribute("tool-name", entry.toolName);
|
|
8226
|
-
if (entry.callId !== void 0 && entry.callId !== "") el.setAttribute("callId", entry.callId);
|
|
8227
8473
|
const args = doc.createElement("tool-args");
|
|
8228
8474
|
appendCdataText(doc, args, entry.toolArgs);
|
|
8229
8475
|
el.appendChild(args);
|
|
@@ -8315,13 +8561,13 @@ function isAskEntry(entry) {
|
|
|
8315
8561
|
}
|
|
8316
8562
|
/** 压缩会话的工具状态:视图 + 替换记录 + 二次确认标记(skill / ask_user_question)+ 完成标记。 */
|
|
8317
8563
|
var CompressionState = class CompressionState {
|
|
8318
|
-
view;
|
|
8319
8564
|
replacements = [];
|
|
8320
8565
|
challengedSkills = /* @__PURE__ */ new Set();
|
|
8321
8566
|
viewedAsks = /* @__PURE__ */ new Set();
|
|
8322
8567
|
undeliveredAsks = /* @__PURE__ */ new Set();
|
|
8323
8568
|
rewrittenAsks = /* @__PURE__ */ new Map();
|
|
8324
8569
|
_completed = false;
|
|
8570
|
+
view;
|
|
8325
8571
|
/**
|
|
8326
8572
|
* @param view 压缩视图(观察或反思),工具校验与最终块构建的数据源。
|
|
8327
8573
|
*/
|
|
@@ -8387,9 +8633,10 @@ var CompressionState = class CompressionState {
|
|
|
8387
8633
|
return Math.floor(value);
|
|
8388
8634
|
}
|
|
8389
8635
|
/**
|
|
8390
|
-
* getHistory:返回 [start..end]
|
|
8391
|
-
* start/end 缺省为要求区间首尾;越界或 start > end
|
|
8392
|
-
*
|
|
8636
|
+
* getHistory:返回 [start..end] 区间内的当前条目(无 <history> 包裹)。
|
|
8637
|
+
* start/end 缺省为要求区间首尾;越界或 start > end 返回错误。本次替换的区间显示为
|
|
8638
|
+
* 摘要条目,与查询区间相交即整条返回;区间切入已有压缩块(反思视图)时返回该块当前
|
|
8639
|
+
* 全部条目,跨块摘要连带展开其覆盖的块。
|
|
8393
8640
|
*/
|
|
8394
8641
|
getHistory(args) {
|
|
8395
8642
|
const { minIndex, maxIndex } = this.view;
|
|
@@ -8422,15 +8669,26 @@ var CompressionState = class CompressionState {
|
|
|
8422
8669
|
isError: true
|
|
8423
8670
|
};
|
|
8424
8671
|
const intersects = (entry) => entry.lo !== void 0 && entry.hi !== void 0 && entry.lo <= end && entry.hi >= start;
|
|
8425
|
-
const
|
|
8426
|
-
|
|
8427
|
-
|
|
8672
|
+
const projected = this.project();
|
|
8673
|
+
const expanded = /* @__PURE__ */ new Set();
|
|
8674
|
+
for (let grown = true; grown;) {
|
|
8675
|
+
grown = false;
|
|
8676
|
+
for (const item of projected) {
|
|
8677
|
+
if (!intersects(item.entry) && !item.blocks.some((seq) => expanded.has(seq))) continue;
|
|
8678
|
+
for (const seq of item.blocks) {
|
|
8679
|
+
if (expanded.has(seq)) continue;
|
|
8680
|
+
expanded.add(seq);
|
|
8681
|
+
grown = true;
|
|
8682
|
+
}
|
|
8683
|
+
}
|
|
8684
|
+
}
|
|
8685
|
+
const selected = projected.filter((item) => item.blocks.length > 0 ? item.blocks.some((seq) => expanded.has(seq)) : intersects(item.entry));
|
|
8428
8686
|
if (selected.length === 0) return {
|
|
8429
8687
|
text: `区间 [${start}..${end}] 没有条目`,
|
|
8430
8688
|
isError: false
|
|
8431
8689
|
};
|
|
8432
|
-
const text =
|
|
8433
|
-
for (const entry of selected) if (entry.ask !== void 0 && entry.lo !== void 0) this.undeliveredAsks.add(entry.lo);
|
|
8690
|
+
const text = renderEntriesXml(selected.map((item) => item.entry));
|
|
8691
|
+
for (const { entry } of selected) if (entry.ask !== void 0 && entry.lo !== void 0) this.undeliveredAsks.add(entry.lo);
|
|
8434
8692
|
return {
|
|
8435
8693
|
text,
|
|
8436
8694
|
isError: false
|
|
@@ -8522,7 +8780,7 @@ var CompressionState = class CompressionState {
|
|
|
8522
8780
|
isError: true
|
|
8523
8781
|
};
|
|
8524
8782
|
for (const rep of this.replacements) if (rep.lo <= hi && rep.hi >= lo && !(rep.lo >= lo && rep.hi <= hi)) return {
|
|
8525
|
-
text: `${CompressionState.spanLabel(lo, hi)} 与已有替换区间 [${rep.lo}..${rep.hi}]
|
|
8783
|
+
text: `${CompressionState.spanLabel(lo, hi)} 与已有替换区间 [${rep.lo}..${rep.hi}] 部分重叠,只能完全包含或不相交。[${rep.lo}..${rep.hi}] 已生效,修改其摘要时用相同或更大的区间重新提交`,
|
|
8526
8784
|
isError: true
|
|
8527
8785
|
};
|
|
8528
8786
|
const unchallenged = [];
|
|
@@ -8565,9 +8823,60 @@ var CompressionState = class CompressionState {
|
|
|
8565
8823
|
isError: false
|
|
8566
8824
|
};
|
|
8567
8825
|
}
|
|
8826
|
+
/** 完全包含该条目的替换记录;替换区间两两不相交,至多一条。 */
|
|
8827
|
+
replacementFor(entry) {
|
|
8828
|
+
const { lo, hi } = entry;
|
|
8829
|
+
if (lo === void 0 || hi === void 0) return void 0;
|
|
8830
|
+
return this.replacements.find((rep) => lo >= rep.lo && hi <= rep.hi);
|
|
8831
|
+
}
|
|
8568
8832
|
/** 条目是否已被成功直接压缩完全覆盖。 */
|
|
8569
8833
|
coveredBy(entry) {
|
|
8570
|
-
return
|
|
8834
|
+
return this.replacementFor(entry) !== void 0;
|
|
8835
|
+
}
|
|
8836
|
+
/**
|
|
8837
|
+
* 当前状态投影:按视图顺序,被替换条目由一条摘要条目代替,摘要位于首个被替换条目处。
|
|
8838
|
+
* reasoning 带 index 时按自身区间取舍,无 index 时跟随其后第一条非 reasoning 条目。
|
|
8839
|
+
*/
|
|
8840
|
+
project() {
|
|
8841
|
+
const entries = this.view.entries;
|
|
8842
|
+
const reps = new Array(entries.length);
|
|
8843
|
+
let next;
|
|
8844
|
+
for (let i = entries.length - 1; i >= 0; i -= 1) {
|
|
8845
|
+
const entry = entries[i];
|
|
8846
|
+
if (entry === void 0) continue;
|
|
8847
|
+
const own = this.replacementFor(entry);
|
|
8848
|
+
if (entry.kind !== "reasoning") next = own;
|
|
8849
|
+
reps[i] = entry.kind === "reasoning" && entry.lo === void 0 ? next : own;
|
|
8850
|
+
}
|
|
8851
|
+
const projected = [];
|
|
8852
|
+
const summaries = /* @__PURE__ */ new Map();
|
|
8853
|
+
entries.forEach((entry, i) => {
|
|
8854
|
+
const rep = reps[i];
|
|
8855
|
+
if (rep === void 0) {
|
|
8856
|
+
projected.push({
|
|
8857
|
+
entry,
|
|
8858
|
+
blocks: entry.blockSeq === void 0 ? [] : [entry.blockSeq]
|
|
8859
|
+
});
|
|
8860
|
+
return;
|
|
8861
|
+
}
|
|
8862
|
+
let summary = summaries.get(rep);
|
|
8863
|
+
if (summary === void 0) {
|
|
8864
|
+
summary = {
|
|
8865
|
+
entry: {
|
|
8866
|
+
kind: "assistant",
|
|
8867
|
+
lo: rep.lo,
|
|
8868
|
+
hi: rep.hi,
|
|
8869
|
+
text: rep.content
|
|
8870
|
+
},
|
|
8871
|
+
blocks: [],
|
|
8872
|
+
replacement: rep
|
|
8873
|
+
};
|
|
8874
|
+
summaries.set(rep, summary);
|
|
8875
|
+
projected.push(summary);
|
|
8876
|
+
}
|
|
8877
|
+
if (entry.blockSeq !== void 0 && !summary.blocks.includes(entry.blockSeq)) summary.blocks.push(entry.blockSeq);
|
|
8878
|
+
});
|
|
8879
|
+
return projected;
|
|
8571
8880
|
}
|
|
8572
8881
|
/** 重写已查看、尚未压缩覆盖的原始 ask,一次提交全部题。 */
|
|
8573
8882
|
rewriteAskUserQuestion(args) {
|
|
@@ -8657,62 +8966,31 @@ var CompressionState = class CompressionState {
|
|
|
8657
8966
|
};
|
|
8658
8967
|
}
|
|
8659
8968
|
/**
|
|
8660
|
-
* 构建最终 <history>
|
|
8661
|
-
*
|
|
8662
|
-
*
|
|
8663
|
-
* 块首按最终条目动态生成格式说明注释,开标签携带 tip 属性。
|
|
8969
|
+
* 构建最终 <history> 块:取当前状态投影并去掉 reasoning——user 条目原样、被替换区间为
|
|
8970
|
+
* <assistant index|start end> 摘要条目、未替换普通与历史条目原样保留,原始 ask 使用
|
|
8971
|
+
* 重写后的 q/a。块首按最终条目动态生成格式说明注释,开标签携带 tip 属性。
|
|
8664
8972
|
*/
|
|
8665
8973
|
buildFinalBlock() {
|
|
8666
8974
|
const pending = this.unprocessedAskIndices();
|
|
8667
8975
|
if (pending.length > 0) throw new Error(`原始 ask 尚未处理:index ${pending.join("、")}`);
|
|
8668
|
-
const
|
|
8669
|
-
|
|
8670
|
-
if (!root) return "";
|
|
8671
|
-
const coveredBy = (entry) => this.coveredBy(entry);
|
|
8672
|
-
const reps = [...this.replacements].sort((a, b) => a.lo - b.lo);
|
|
8673
|
-
let nextRep = 0;
|
|
8674
|
-
const emitReplacement = (rep) => {
|
|
8675
|
-
const el = doc.createElement("assistant");
|
|
8676
|
-
if (rep.lo === rep.hi) el.setAttribute("index", String(rep.lo));
|
|
8677
|
-
else {
|
|
8678
|
-
el.setAttribute("start", String(rep.lo));
|
|
8679
|
-
el.setAttribute("end", String(rep.hi));
|
|
8680
|
-
}
|
|
8681
|
-
appendCdataText(doc, el, rep.content);
|
|
8682
|
-
root.appendChild(el);
|
|
8683
|
-
};
|
|
8684
|
-
const flushReplacementsBefore = (lo) => {
|
|
8685
|
-
while (nextRep < reps.length) {
|
|
8686
|
-
const rep = reps[nextRep];
|
|
8687
|
-
if (rep === void 0) break;
|
|
8688
|
-
if (lo !== void 0 && rep.lo >= lo) break;
|
|
8689
|
-
emitReplacement(rep);
|
|
8690
|
-
nextRep += 1;
|
|
8691
|
-
}
|
|
8692
|
-
};
|
|
8693
|
-
for (const entry of this.view.entries) {
|
|
8694
|
-
if (entry.kind === "reasoning") continue;
|
|
8695
|
-
if (coveredBy(entry)) continue;
|
|
8696
|
-
flushReplacementsBefore(entry.lo);
|
|
8976
|
+
const entries = this.project().flatMap(({ entry }) => {
|
|
8977
|
+
if (entry.kind === "reasoning") return [];
|
|
8697
8978
|
const qa = entry.lo === void 0 ? void 0 : this.rewrittenAsks.get(entry.lo);
|
|
8698
|
-
|
|
8979
|
+
if (entry.ask === void 0 || qa === void 0 || entry.lo === void 0) return [entry];
|
|
8980
|
+
return [{
|
|
8699
8981
|
kind: "assistant",
|
|
8700
8982
|
lo: entry.lo,
|
|
8701
8983
|
hi: entry.lo,
|
|
8702
8984
|
toolName: ASK_USER_QUESTION_TOOL_NAME,
|
|
8703
8985
|
text: `<ask-user-question>${qa.map((item) => `q:${item.q}\na:${item.a}`).join("\n")}</ask-user-question>`
|
|
8704
|
-
}
|
|
8705
|
-
|
|
8706
|
-
}
|
|
8707
|
-
flushReplacementsBefore(void 0);
|
|
8986
|
+
}];
|
|
8987
|
+
});
|
|
8708
8988
|
const note = historyFormatNote({
|
|
8709
|
-
user:
|
|
8710
|
-
skill:
|
|
8711
|
-
askUserQuestion:
|
|
8989
|
+
user: entries.some((e) => e.kind === "user"),
|
|
8990
|
+
skill: entries.some((e) => e.kind === "assistant" && e.toolName === "skill"),
|
|
8991
|
+
askUserQuestion: entries.some(isAskEntry)
|
|
8712
8992
|
});
|
|
8713
|
-
|
|
8714
|
-
const inner = Array.from(root.childNodes).map((node) => serializer.serializeToString(node)).join("\n");
|
|
8715
|
-
return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${inner}\n</${HISTORY_TAG}>`;
|
|
8993
|
+
return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${HISTORY_TAG}>`;
|
|
8716
8994
|
}
|
|
8717
8995
|
};
|
|
8718
8996
|
/** 仅含原始合法 ask 的压缩会话使用的重写工具。 */
|
|
@@ -8767,7 +9045,7 @@ const REWRITE_ASK_TOOL_SCHEMA = {
|
|
|
8767
9045
|
const COMPRESSION_TOOL_SCHEMAS = [
|
|
8768
9046
|
{
|
|
8769
9047
|
name: "getHistory",
|
|
8770
|
-
description: "
|
|
9048
|
+
description: "查看压缩区间内的历史条目,返回当前状态:本次已压缩的区间显示为摘要条目;区间切入已有 <history> 块时返回该块全部条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。",
|
|
8771
9049
|
parameters: {
|
|
8772
9050
|
type: "object",
|
|
8773
9051
|
properties: {
|
|
@@ -8784,7 +9062,7 @@ const COMPRESSION_TOOL_SCHEMAS = [
|
|
|
8784
9062
|
},
|
|
8785
9063
|
{
|
|
8786
9064
|
name: "compressHistory",
|
|
8787
|
-
description: "把 index 单条或 start..end 连续区间的 assistant 类条目(模型输出文本、工具调用)替换为 content 摘要。index 与 start/end 二选一,start 与 end 成对提供且 start==end 等同 index
|
|
9065
|
+
description: "把 index 单条或 start..end 连续区间的 assistant 类条目(模型输出文本、工具调用)替换为 content 摘要。index 与 start/end 二选一,start 与 end 成对提供且 start==end 等同 index。区间不得覆盖用户消息,不得与已有替换区间部分重叠(完全包含则覆盖)。返回成功即已生效,无需查看验证,不要用单条 index 试探;修改已提交的摘要时用相同或更大的区间重新提交。用户消息保持原样,无需处理。",
|
|
8788
9066
|
parameters: {
|
|
8789
9067
|
type: "object",
|
|
8790
9068
|
properties: {
|
|
@@ -8877,21 +9155,24 @@ async function gateRateLimit(waitMs, signal) {
|
|
|
8877
9155
|
* 工具驱动的压缩循环:以新会话方式直连 ctx.llm.stream(),模型通过 getHistory /
|
|
8878
9156
|
* compressHistory / completeCompression 完成压缩,存在原始合法提问时加入重写工具。
|
|
8879
9157
|
* 导出 runCompressionLoop / buildCompressionPrompt / buildCompressionTaskText /
|
|
8880
|
-
* ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT。
|
|
9158
|
+
* REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT。
|
|
8881
9159
|
*
|
|
8882
9160
|
* - 首条 user 消息仅含压缩指令与 start/end 区间(buildCompressionTaskText),不含
|
|
8883
|
-
* 历史消息内容;共享压缩提示词作为 system
|
|
9161
|
+
* 历史消息内容;共享压缩提示词作为 system,反思 pass 追加反思合并约束
|
|
8884
9162
|
* - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
|
|
8885
9163
|
* BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
|
|
8886
9164
|
* - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
|
|
8887
9165
|
* 块由 CompressionState 构建,全程无需整块校验
|
|
8888
|
-
* - 模型输出纯文本(无工具调用)时追加提醒消息继续,连续
|
|
8889
|
-
* -
|
|
8890
|
-
*
|
|
9166
|
+
* - 模型输出纯文本(无工具调用)时追加提醒消息继续,连续 3 轮仍无工具调用判失败
|
|
9167
|
+
* - 输出被 max-tokens 截断且无工具调用时单独计数:该轮 assistant 消息仅落盘、不进入后续
|
|
9168
|
+
* 请求,追加截断专用提醒,连续 3 轮截断判失败;任一轮有工具调用则两个计数清零
|
|
9169
|
+
* - 429 限流走全局限流等待门(gateRateLimit / noteRateLimit);瞬时错误(5xx、网络类)
|
|
9170
|
+
* 同样经限流门等待后重试,连续最多重试 3 次,任一轮成功响应后清零;重试轮不计入轮数;
|
|
9171
|
+
* 其余请求级错误(含 4xx)直接判失败
|
|
8891
9172
|
* - signal 中止标记 aborted;token usage 汇总全部轮次;统计循环起止时间戳、总耗时
|
|
8892
9173
|
* 与逐轮请求统计(CompressionStats),随结果返回并随会话记录落盘
|
|
8893
|
-
* -
|
|
8894
|
-
*
|
|
9174
|
+
* - 成功与失败均把循环消息组落盘为子会话(recordCompressionSession,system 一并落盘
|
|
9175
|
+
* 为 system/message),成功记录 sessionId 于日志,失败记录作为诊断子会话 id 向上传播
|
|
8895
9176
|
*/
|
|
8896
9177
|
/**
|
|
8897
9178
|
* 共享压缩提示词(观察/反思同一套):完整消息定义、工具语义、压缩要求、skill 与
|
|
@@ -8905,8 +9186,8 @@ function buildCompressionPrompt(skipReasoning) {
|
|
|
8905
9186
|
`【完整消息定义】${COMPLETE_MESSAGE_DEFINITION}`,
|
|
8906
9187
|
"",
|
|
8907
9188
|
"【工具】",
|
|
8908
|
-
"- getHistory(option?: {start?, end?}):查看压缩区间内的历史条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index
|
|
8909
|
-
"- compressHistory(option?: {index?, start?, end?, content}):把 index 单条或 start..end 连续区间的 assistant 类条目替换为 content 摘要(纯文本,不要包含 CDATA 包裹,插件自动包裹)。index 与 start/end 二选一,start==end 等同 index
|
|
9189
|
+
"- getHistory(option?: {start?, end?}):查看压缩区间内的历史条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。返回当前状态,不带 <history> 包裹:本次已压缩的区间显示为摘要条目;区间切入已有 <history> 块时返回整块。",
|
|
9190
|
+
"- compressHistory(option?: {index?, start?, end?, content}):把 index 单条或 start..end 连续区间的 assistant 类条目替换为 content 摘要(纯文本,不要包含 CDATA 包裹,插件自动包裹)。index 与 start/end 二选一,start==end 等同 index。区间不得覆盖用户消息;与已有替换区间部分重叠会被拒绝,完全包含则覆盖。返回成功即已生效,无需查看验证,不要用单条 index 试探;修改已提交的摘要时用相同或更大的区间重新提交。",
|
|
8910
9191
|
"- completeCompression():全部压缩完成后调用,立即结束。",
|
|
8911
9192
|
"",
|
|
8912
9193
|
"【压缩要求】",
|
|
@@ -8915,9 +9196,13 @@ function buildCompressionPrompt(skipReasoning) {
|
|
|
8915
9196
|
"- 将具有关联性的 assistant 消息按内在逻辑连贯性划分为连续模块,聚合为区间压缩(start..end)",
|
|
8916
9197
|
"- 单条重要的完整消息以 index 单独压缩",
|
|
8917
9198
|
"- 压缩后的 assistant 消息内,应当描述**行为逻辑**,强调关键的**结论、产出和任务**;涉及到的具体文件保留完整路径",
|
|
8918
|
-
"-
|
|
9199
|
+
"- 摘要粒度按后续用途分配,与消息位置无关:",
|
|
9200
|
+
" - 未完成的任务、当前状态、待办与未解决的问题保留细节;涉及的文件写明最新状态。",
|
|
9201
|
+
" - 已完成的子任务只保留结果、决策及理由、排除的方案及原因。",
|
|
9202
|
+
" - 不可再生的信息不论早晚都要保留:用户提出的约束与偏好、做出的决策、报错原文、外部返回的关键数据、验证过的结论。",
|
|
9203
|
+
" - 可以低成本重新获取的内容(文件内容、命令输出、搜索结果)只记来源与要点。",
|
|
8919
9204
|
"- <history> 条目正文以 CDATA 包裹,CDATA 内为逐字原样内容。",
|
|
8920
|
-
"- 工具调用条目为 <assistant index=\"N\" type=\"toolcall\" tool-name=\"…\"
|
|
9205
|
+
"- 工具调用条目为 <assistant index=\"N\" type=\"toolcall\" tool-name=\"…\">,内含 <tool-args>(调用参数 JSON)与 <tool-result>(工具返回内容)两个 CDATA 子元素。",
|
|
8921
9206
|
"- 加载的 skill 以 <skill_content name=\"…\" index=\"N\"> 条目呈现,内含 <skill_resources> 与 <skill_instructions> 两段,内文为加载的 skill 内容,属于关键信息。仅在你明确判断该 skill 与后续任务无关时,压缩它;如果该 skill 与后续任务相关,或者你无法判断,不要压缩,**保持原文**。",
|
|
8922
9207
|
"- 已有 <history> 块中的 ask_user_question 以 <ask-user-question index=\"N\"> 呈现,CDATA 内为逐题成对的 q:(问题文本)与 a:(用户回答)行,未作答的题记为 a:(未回答)。这些提问已经处理;仅在明确判断与后续任务无关时压缩,否则保持原样。原始提问按本会话的专用处理规则执行。",
|
|
8923
9208
|
"- 除原始提问外,未压缩的条目将原样保留;宁可保留也不要强行压缩不确定的内容。",
|
|
@@ -8931,6 +9216,8 @@ function buildCompressionTaskText(phase, start, end) {
|
|
|
8931
9216
|
if (phase === "reflect") return `合并压缩全部 <history> 块,完整消息区间 [${start}..${end}]:用 getHistory 查看已有块条目,用 compressHistory 重新压缩合并 assistant 条目,完成后调用 completeCompression。`;
|
|
8932
9217
|
return `压缩完整消息区间 [${start}..${end}]:用 getHistory 查看条目,用 compressHistory 分批压缩 assistant 条目,完成后调用 completeCompression。`;
|
|
8933
9218
|
}
|
|
9219
|
+
/** 反思合并的额外约束,只在反思 pass 注入。 */
|
|
9220
|
+
const REFLECT_COMPRESSION_PROMPT = ["【反思合并】", "- 重新压缩已有摘要条目时,保留其中的不可再生信息,不要逐轮缩减。"].join("\n");
|
|
8934
9221
|
/** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
|
|
8935
9222
|
const ASK_COMPRESSION_PROMPT = [
|
|
8936
9223
|
"【原始提问处理】",
|
|
@@ -8945,6 +9232,12 @@ const ASK_COMPRESSION_PROMPT = [
|
|
|
8945
9232
|
].join("\n");
|
|
8946
9233
|
/** 模型输出纯文本(无工具调用)时追加的提醒消息文本。 */
|
|
8947
9234
|
const COMPRESSION_NUDGE_TEXT = "请通过工具执行压缩:用 getHistory 查看区间条目,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。不要输出与工具调用无关的文本。";
|
|
9235
|
+
/** 输出被 max-tokens 截断且无工具调用时追加的提醒消息文本。 */
|
|
9236
|
+
const TRUNCATION_NUDGE_TEXT = "上一轮输出因长度上限被截断,其中的工具调用未被接收。请缩短思考,直接分批调用 compressHistory(每次覆盖较小区间),最后调用 completeCompression。";
|
|
9237
|
+
/** 连续无工具调用、连续截断各自允许的最大轮数。 */
|
|
9238
|
+
const MAX_CONSECUTIVE_FAILURES = 3;
|
|
9239
|
+
/** 瞬时请求错误的连续最大重试次数。 */
|
|
9240
|
+
const MAX_TRANSIENT_RETRIES = 3;
|
|
8948
9241
|
/** 视图原始消息字符数估算:非 reasoning 条目之和;工具调用条目的 text 已含参数与结果,不重复计入。 */
|
|
8949
9242
|
function viewCharCount(view) {
|
|
8950
9243
|
return view.entries.reduce((total, entry) => entry.kind === "reasoning" ? total : total + entry.text.length, 0);
|
|
@@ -9003,18 +9296,43 @@ function addUsage(total, add) {
|
|
|
9003
9296
|
function isRateLimitFailure(message, status) {
|
|
9004
9297
|
return status === 429 || isRateLimitError(message);
|
|
9005
9298
|
}
|
|
9299
|
+
/** 是否为可重试的瞬时失败:有 status 时按 5xx 判定,否则匹配 5xx 状态码或常见网络类错误文案。 */
|
|
9300
|
+
function isTransientFailure(message, status) {
|
|
9301
|
+
if (status !== void 0) return status >= 500 && status <= 599;
|
|
9302
|
+
return /\b5\d{2}\b|econnreset|etimedout|econnrefused|epipe|socket hang up|fetch failed|network|overloaded|timed? ?out/i.test(message);
|
|
9303
|
+
}
|
|
9304
|
+
/** skipReasoning=true 时去掉视图中的 reasoning 条目(兑现 getHistory 不输出 reasoning 的契约);否则原样返回。 */
|
|
9305
|
+
function withoutReasoning(view, skipReasoning) {
|
|
9306
|
+
if (!skipReasoning) return view;
|
|
9307
|
+
return {
|
|
9308
|
+
...view,
|
|
9309
|
+
entries: view.entries.filter((entry) => entry.kind !== "reasoning")
|
|
9310
|
+
};
|
|
9311
|
+
}
|
|
9006
9312
|
/**
|
|
9007
|
-
* 运行工具驱动的压缩循环:直到模型调用 completeCompression(成功)、连续
|
|
9313
|
+
* 运行工具驱动的压缩循环:直到模型调用 completeCompression(成功)、连续 3 轮无
|
|
9008
9314
|
* 工具调用、请求级错误或 signal 中止(失败)。成功与失败均落盘循环会话记录。
|
|
9009
9315
|
*/
|
|
9010
9316
|
async function runCompressionLoop(ctx, session, options) {
|
|
9011
9317
|
const logger = makeLogger(ctx, options.debug);
|
|
9012
|
-
const
|
|
9318
|
+
const view = withoutReasoning(options.view, options.skipReasoning);
|
|
9319
|
+
const state = new CompressionState(view);
|
|
9013
9320
|
const tools = state.hasPendingAsks ? [...COMPRESSION_TOOL_SCHEMAS, REWRITE_ASK_TOOL_SCHEMA] : COMPRESSION_TOOL_SCHEMAS;
|
|
9014
|
-
const system = [
|
|
9321
|
+
const system = [
|
|
9322
|
+
buildCompressionPrompt(options.skipReasoning),
|
|
9323
|
+
...options.phase === "reflect" ? [REFLECT_COMPRESSION_PROMPT] : [],
|
|
9324
|
+
...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
|
|
9325
|
+
].join("\n\n");
|
|
9015
9326
|
const messages = [makePluginUserMessage(options.taskText)];
|
|
9016
9327
|
let rounds = 0;
|
|
9017
9328
|
let nudges = 0;
|
|
9329
|
+
let truncations = 0;
|
|
9330
|
+
let transientRetries = 0;
|
|
9331
|
+
/** 最后一个收到终态的请求的 finish 类型与输出 token 数(失败日志用)。 */
|
|
9332
|
+
let lastFinish;
|
|
9333
|
+
let lastOutputTokens;
|
|
9334
|
+
/** 仅落盘、不进入后续请求的消息(截断轮的 assistant 消息)。 */
|
|
9335
|
+
const omitted = /* @__PURE__ */ new Set();
|
|
9018
9336
|
let usage;
|
|
9019
9337
|
const startedAt = Date.now();
|
|
9020
9338
|
const roundStats = [];
|
|
@@ -9028,23 +9346,33 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9028
9346
|
rounds: roundStats
|
|
9029
9347
|
};
|
|
9030
9348
|
};
|
|
9031
|
-
const recordSessionId = async (success, stats, resultChars) => recordCompressionSession(ctx, session, {
|
|
9349
|
+
const recordSessionId = async (success, stats, resultChars, failure) => recordCompressionSession(ctx, session, {
|
|
9032
9350
|
phase: options.phase,
|
|
9351
|
+
range: {
|
|
9352
|
+
...view.minIndex === void 0 ? {} : { min: view.minIndex },
|
|
9353
|
+
...view.maxIndex === void 0 ? {} : { max: view.maxIndex }
|
|
9354
|
+
},
|
|
9033
9355
|
messages,
|
|
9034
9356
|
stats,
|
|
9357
|
+
system,
|
|
9035
9358
|
success,
|
|
9036
9359
|
debug: options.debug,
|
|
9037
9360
|
info: compressionInfo({
|
|
9038
9361
|
target: options.target,
|
|
9039
|
-
originalChars: options.originalChars ?? viewCharCount(
|
|
9362
|
+
originalChars: options.originalChars ?? viewCharCount(view),
|
|
9040
9363
|
...options.reasoningEffort === void 0 ? {} : { reasoningEffort: options.reasoningEffort },
|
|
9041
|
-
...resultChars === void 0 ? {} : { resultChars }
|
|
9364
|
+
...resultChars === void 0 ? {} : { resultChars },
|
|
9365
|
+
...failure === void 0 ? {} : { failure }
|
|
9042
9366
|
}),
|
|
9043
|
-
...options.
|
|
9367
|
+
...options.retry === void 0 ? {} : { retry: options.retry }
|
|
9044
9368
|
});
|
|
9045
9369
|
const failWith = async (error, aborted) => {
|
|
9046
9370
|
const stats = buildStats();
|
|
9047
|
-
const id = await recordSessionId(false, stats
|
|
9371
|
+
const id = await recordSessionId(false, stats, void 0, {
|
|
9372
|
+
reason: error,
|
|
9373
|
+
...lastFinish === void 0 ? {} : { finish: lastFinish },
|
|
9374
|
+
...lastOutputTokens === void 0 ? {} : { outputTokens: lastOutputTokens }
|
|
9375
|
+
});
|
|
9048
9376
|
return {
|
|
9049
9377
|
ok: false,
|
|
9050
9378
|
error,
|
|
@@ -9054,6 +9382,14 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9054
9382
|
};
|
|
9055
9383
|
};
|
|
9056
9384
|
logger.step(`压缩循环开始(${options.phase === "reflect" ? "反思" : "观察"},provider ${options.target.provider},model ${options.target.model},maxTokens ${options.maxTokens === void 0 ? "未设置" : String(options.maxTokens)})`);
|
|
9385
|
+
/** 瞬时失败且未超重试额度时记入限流门并返回 true(调用方 continue 重试)。 */
|
|
9386
|
+
const retryTransient = (message, status) => {
|
|
9387
|
+
if (!isTransientFailure(message, status) || transientRetries >= MAX_TRANSIENT_RETRIES) return false;
|
|
9388
|
+
transientRetries += 1;
|
|
9389
|
+
noteRateLimit();
|
|
9390
|
+
logger.warn(`压缩循环请求瞬时失败(${message}),等待 ${options.rateLimitWaitMs}ms 后重试(${transientRetries}/${MAX_TRANSIENT_RETRIES})`);
|
|
9391
|
+
return true;
|
|
9392
|
+
};
|
|
9057
9393
|
for (;;) {
|
|
9058
9394
|
if (options.signal?.aborted) {
|
|
9059
9395
|
logger.warn("压缩循环中止(signal 已中止),放弃本次压缩");
|
|
@@ -9073,7 +9409,7 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9073
9409
|
purpose: "compaction",
|
|
9074
9410
|
...options.signal === void 0 ? {} : { signal: options.signal },
|
|
9075
9411
|
system,
|
|
9076
|
-
messages:
|
|
9412
|
+
messages: messages.filter((message) => !omitted.has(message)),
|
|
9077
9413
|
tools
|
|
9078
9414
|
};
|
|
9079
9415
|
const assembler = new BlockAssembler();
|
|
@@ -9087,25 +9423,31 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9087
9423
|
logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
|
|
9088
9424
|
continue;
|
|
9089
9425
|
}
|
|
9426
|
+
if (retryTransient(message)) continue;
|
|
9090
9427
|
logger.warn(`压缩循环请求失败: ${message}`);
|
|
9091
9428
|
return await failWith(message, false);
|
|
9092
9429
|
}
|
|
9093
9430
|
const finish = assembler.finish;
|
|
9431
|
+
lastFinish = finish.kind;
|
|
9432
|
+
lastOutputTokens = assembler.usage?.outputTokens;
|
|
9094
9433
|
if (finish.kind === "aborted") {
|
|
9095
9434
|
logger.warn("压缩循环中止(流以 aborted 结束),放弃本次压缩");
|
|
9096
9435
|
return await failWith(COMPACTION_ABORTED_ERROR, true);
|
|
9097
9436
|
}
|
|
9098
9437
|
if (finish.kind === "error") {
|
|
9099
9438
|
const failureMessage = typeof finish.failure?.message === "string" && finish.failure.message !== "" ? finish.failure.message : "流以 error 终态结束(无失败详情)";
|
|
9100
|
-
|
|
9439
|
+
const failureStatus = typeof finish.failure?.status === "number" ? finish.failure.status : void 0;
|
|
9440
|
+
if (isRateLimitFailure(failureMessage, failureStatus)) {
|
|
9101
9441
|
noteRateLimit();
|
|
9102
9442
|
logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
|
|
9103
9443
|
continue;
|
|
9104
9444
|
}
|
|
9445
|
+
if (retryTransient(failureMessage, failureStatus)) continue;
|
|
9105
9446
|
logger.warn(`压缩循环请求失败: ${failureMessage}`);
|
|
9106
9447
|
pushPartialAssistant(assembler, messages, options.target);
|
|
9107
9448
|
return await failWith(failureMessage, false);
|
|
9108
9449
|
}
|
|
9450
|
+
transientRetries = 0;
|
|
9109
9451
|
rounds += 1;
|
|
9110
9452
|
if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
|
|
9111
9453
|
roundStats.push({
|
|
@@ -9121,9 +9463,21 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9121
9463
|
messages.push(assistantMessage);
|
|
9122
9464
|
const calls = assembler.blocks().filter((block) => block.type === "tool-call");
|
|
9123
9465
|
if (calls.length === 0) {
|
|
9466
|
+
if (finish.kind === "max-tokens") {
|
|
9467
|
+
truncations += 1;
|
|
9468
|
+
if (truncations >= MAX_CONSECUTIVE_FAILURES) {
|
|
9469
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
|
|
9470
|
+
logger.warn(error);
|
|
9471
|
+
return await failWith(error, false);
|
|
9472
|
+
}
|
|
9473
|
+
logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
|
|
9474
|
+
omitted.add(assistantMessage);
|
|
9475
|
+
messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
|
|
9476
|
+
continue;
|
|
9477
|
+
}
|
|
9124
9478
|
nudges += 1;
|
|
9125
|
-
if (nudges >=
|
|
9126
|
-
const error =
|
|
9479
|
+
if (nudges >= MAX_CONSECUTIVE_FAILURES) {
|
|
9480
|
+
const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
|
|
9127
9481
|
logger.warn(error);
|
|
9128
9482
|
return await failWith(error, false);
|
|
9129
9483
|
}
|
|
@@ -9132,6 +9486,7 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9132
9486
|
continue;
|
|
9133
9487
|
}
|
|
9134
9488
|
nudges = 0;
|
|
9489
|
+
truncations = 0;
|
|
9135
9490
|
for (const call of calls) {
|
|
9136
9491
|
messages.push(toolResultOf(call, state.executeCall(call.name, call.arguments)));
|
|
9137
9492
|
if (state.completed) break;
|
|
@@ -9205,9 +9560,64 @@ function readOmEvent(event) {
|
|
|
9205
9560
|
seq: event.seq
|
|
9206
9561
|
};
|
|
9207
9562
|
}
|
|
9563
|
+
case "om/observe-summary": {
|
|
9564
|
+
const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
|
|
9565
|
+
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
9566
|
+
if (typeof report !== "string") return void 0;
|
|
9567
|
+
if (typeof provider !== "string" || typeof model !== "string") return void 0;
|
|
9568
|
+
if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
|
|
9569
|
+
if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
|
|
9570
|
+
if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
|
|
9571
|
+
const parsedUsage = readTokenUsage(usage);
|
|
9572
|
+
if (parsedUsage === null) return void 0;
|
|
9573
|
+
return {
|
|
9574
|
+
kind,
|
|
9575
|
+
data: {
|
|
9576
|
+
pendingSeq,
|
|
9577
|
+
report,
|
|
9578
|
+
provider,
|
|
9579
|
+
model,
|
|
9580
|
+
startedAt,
|
|
9581
|
+
completedAt,
|
|
9582
|
+
durationMs,
|
|
9583
|
+
...recordSessionId === void 0 ? {} : { recordSessionId },
|
|
9584
|
+
...parsedUsage === void 0 ? {} : { usage: parsedUsage },
|
|
9585
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
9586
|
+
},
|
|
9587
|
+
seq: event.seq
|
|
9588
|
+
};
|
|
9589
|
+
}
|
|
9208
9590
|
default: return;
|
|
9209
9591
|
}
|
|
9210
9592
|
}
|
|
9593
|
+
/** 校验有限数值字段(时间戳/耗时)。 */
|
|
9594
|
+
function isFiniteNumber(value) {
|
|
9595
|
+
return typeof value === "number" && Number.isFinite(value);
|
|
9596
|
+
}
|
|
9597
|
+
/** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
|
|
9598
|
+
function readTokenUsage(value) {
|
|
9599
|
+
if (value === void 0) return void 0;
|
|
9600
|
+
if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
|
|
9601
|
+
const usage = value;
|
|
9602
|
+
const { inputTokens, outputTokens } = usage;
|
|
9603
|
+
if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
|
|
9604
|
+
const result = {
|
|
9605
|
+
inputTokens,
|
|
9606
|
+
outputTokens
|
|
9607
|
+
};
|
|
9608
|
+
for (const key of [
|
|
9609
|
+
"totalTokens",
|
|
9610
|
+
"cacheReadTokens",
|
|
9611
|
+
"cacheWriteTokens",
|
|
9612
|
+
"reasoningTokens"
|
|
9613
|
+
]) {
|
|
9614
|
+
const field = usage[key];
|
|
9615
|
+
if (field === void 0) continue;
|
|
9616
|
+
if (!isFiniteNumber(field)) return null;
|
|
9617
|
+
result[key] = field;
|
|
9618
|
+
}
|
|
9619
|
+
return result;
|
|
9620
|
+
}
|
|
9211
9621
|
/** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
|
|
9212
9622
|
function encodeOmEvent(kind, data) {
|
|
9213
9623
|
return `${OM_EVENT_PREFIX}${JSON.stringify({
|
|
@@ -9272,28 +9682,204 @@ function reportDegrade(session, logger, problem) {
|
|
|
9272
9682
|
}
|
|
9273
9683
|
}
|
|
9274
9684
|
//#endregion
|
|
9685
|
+
//#region src/precompress.ts
|
|
9686
|
+
/** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
|
|
9687
|
+
const jobs = /* @__PURE__ */ new Map();
|
|
9688
|
+
/**
|
|
9689
|
+
* 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
|
|
9690
|
+
* 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
|
|
9691
|
+
*/
|
|
9692
|
+
function findPrecompressionJob(session, pendingSeq) {
|
|
9693
|
+
const job = jobs.get(session.id);
|
|
9694
|
+
if (job === void 0) return void 0;
|
|
9695
|
+
if (job.session === session && job.pendingSeq === pendingSeq) return job;
|
|
9696
|
+
disposePrecompression(session.id);
|
|
9697
|
+
}
|
|
9698
|
+
/**
|
|
9699
|
+
* 启动后台预压缩:同步准备区间/视图;无可行区间时失效待定标记并返回原因。
|
|
9700
|
+
* 同会话已有匹配任务时幂等返回;标记不同则中止旧任务后替换。
|
|
9701
|
+
*/
|
|
9702
|
+
function startPrecompression(options) {
|
|
9703
|
+
const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
|
|
9704
|
+
const logger = makeLogger(ctx, config.debug);
|
|
9705
|
+
const existing = jobs.get(session.id);
|
|
9706
|
+
if (existing !== void 0) {
|
|
9707
|
+
if (existing.session === session && existing.pendingSeq === pendingSeq) return {
|
|
9708
|
+
ok: true,
|
|
9709
|
+
job: existing
|
|
9710
|
+
};
|
|
9711
|
+
disposePrecompression(session.id);
|
|
9712
|
+
}
|
|
9713
|
+
const prepare = prepareObserveCompression(session, triggerMessageIndex, config);
|
|
9714
|
+
if (!prepare.ok) {
|
|
9715
|
+
logger.step(`预压缩:${prepare.reason},失效待定标记视为完成`);
|
|
9716
|
+
try {
|
|
9717
|
+
appendOmEvent(session, "om/observe-invalidate", { pendingSeq });
|
|
9718
|
+
} catch (error) {
|
|
9719
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
9720
|
+
logger.warn(`预压缩:待定失效标记追加失败: ${message}`);
|
|
9721
|
+
}
|
|
9722
|
+
return {
|
|
9723
|
+
ok: false,
|
|
9724
|
+
reason: prepare.reason
|
|
9725
|
+
};
|
|
9726
|
+
}
|
|
9727
|
+
const controller = new AbortController();
|
|
9728
|
+
let settle;
|
|
9729
|
+
const promise = new Promise((resolve) => {
|
|
9730
|
+
settle = resolve;
|
|
9731
|
+
});
|
|
9732
|
+
const job = {
|
|
9733
|
+
pendingSeq,
|
|
9734
|
+
triggerMessageIndex,
|
|
9735
|
+
session,
|
|
9736
|
+
prepared: prepare.prepared,
|
|
9737
|
+
controller,
|
|
9738
|
+
promise,
|
|
9739
|
+
state: "running"
|
|
9740
|
+
};
|
|
9741
|
+
jobs.set(session.id, job);
|
|
9742
|
+
runJobBody(ctx, job, options, logger).then(settle, settle);
|
|
9743
|
+
logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
|
|
9744
|
+
return {
|
|
9745
|
+
ok: true,
|
|
9746
|
+
job
|
|
9747
|
+
};
|
|
9748
|
+
}
|
|
9749
|
+
/** 任务主体:压缩循环 → 成功持久化结果信封 + flush → 状态登记;异常按失败处理。 */
|
|
9750
|
+
async function runJobBody(ctx, job, options, logger) {
|
|
9751
|
+
const { config, target, reasoningEffort } = options;
|
|
9752
|
+
const { prepared } = job;
|
|
9753
|
+
try {
|
|
9754
|
+
const outcome = await runCompressionLoop(ctx, job.session, {
|
|
9755
|
+
view: prepared.view,
|
|
9756
|
+
originalChars: prepared.shadowedCharCount,
|
|
9757
|
+
phase: "observe",
|
|
9758
|
+
taskText: buildCompressionTaskText("observe", prepared.view.minIndex, prepared.view.maxIndex),
|
|
9759
|
+
target,
|
|
9760
|
+
maxTokens: config.compressMaxTokens,
|
|
9761
|
+
rateLimitWaitMs: config.rateLimitWaitMs,
|
|
9762
|
+
skipReasoning: config.compressSkipReasoning,
|
|
9763
|
+
debug: config.debug,
|
|
9764
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort },
|
|
9765
|
+
signal: job.controller.signal
|
|
9766
|
+
});
|
|
9767
|
+
if (!outcome.ok) {
|
|
9768
|
+
job.state = "failed";
|
|
9769
|
+
job.failure = {
|
|
9770
|
+
error: outcome.error,
|
|
9771
|
+
aborted: outcome.aborted,
|
|
9772
|
+
...outcome.recordSessionId === void 0 ? {} : { diagnosticSessionId: outcome.recordSessionId }
|
|
9773
|
+
};
|
|
9774
|
+
logger.info(`预压缩失败(pendingSeq ${job.pendingSeq}): ${outcome.error}`);
|
|
9775
|
+
return;
|
|
9776
|
+
}
|
|
9777
|
+
appendOmEvent(job.session, "om/observe-summary", {
|
|
9778
|
+
pendingSeq: job.pendingSeq,
|
|
9779
|
+
report: outcome.text,
|
|
9780
|
+
provider: target.provider,
|
|
9781
|
+
model: target.model,
|
|
9782
|
+
startedAt: outcome.stats.startedAt,
|
|
9783
|
+
completedAt: outcome.stats.completedAt,
|
|
9784
|
+
durationMs: outcome.stats.durationMs,
|
|
9785
|
+
...outcome.recordSessionId === void 0 ? {} : { recordSessionId: outcome.recordSessionId },
|
|
9786
|
+
...outcome.usage === void 0 ? {} : { usage: outcome.usage },
|
|
9787
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
9788
|
+
});
|
|
9789
|
+
await flushSession(ctx, job.session, logger);
|
|
9790
|
+
job.state = "done";
|
|
9791
|
+
job.result = outcome;
|
|
9792
|
+
logger.info(`预压缩完成(pendingSeq ${job.pendingSeq},${outcome.stats.durationMs}ms),等待到期注入`);
|
|
9793
|
+
} catch (error) {
|
|
9794
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
9795
|
+
job.state = "failed";
|
|
9796
|
+
job.failure = {
|
|
9797
|
+
error: message,
|
|
9798
|
+
aborted: job.controller.signal.aborted
|
|
9799
|
+
};
|
|
9800
|
+
logger.warn(`预压缩任务异常(pendingSeq ${job.pendingSeq}): ${message}`);
|
|
9801
|
+
}
|
|
9802
|
+
}
|
|
9803
|
+
/** 结果信封落盘:sessions.flush 失败仅记日志(内存日志仍在,turn 结束时宿主兜底 flush)。 */
|
|
9804
|
+
async function flushSession(ctx, session, logger) {
|
|
9805
|
+
try {
|
|
9806
|
+
const sessions = ctx.get("sessions");
|
|
9807
|
+
if (sessions === void 0) {
|
|
9808
|
+
logger.warn("预压缩:sessions 服务未挂载,结果信封跳过即时 flush");
|
|
9809
|
+
return;
|
|
9810
|
+
}
|
|
9811
|
+
await sessions.flush(session);
|
|
9812
|
+
} catch (error) {
|
|
9813
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
9814
|
+
logger.warn(`预压缩:结果信封 flush 失败: ${message}`);
|
|
9815
|
+
}
|
|
9816
|
+
}
|
|
9817
|
+
/**
|
|
9818
|
+
* 采纳持久化的 om/observe-summary 信封为压缩成功结果(重启恢复路径)。
|
|
9819
|
+
* 轮数信息未持久化:rounds 按 0 与空数组重建(仅诊断记录使用,注入不依赖)。
|
|
9820
|
+
*/
|
|
9821
|
+
function adoptPersistedSummary(data) {
|
|
9822
|
+
return {
|
|
9823
|
+
result: {
|
|
9824
|
+
ok: true,
|
|
9825
|
+
text: data.report,
|
|
9826
|
+
rounds: 0,
|
|
9827
|
+
stats: {
|
|
9828
|
+
startedAt: data.startedAt,
|
|
9829
|
+
completedAt: data.completedAt,
|
|
9830
|
+
durationMs: data.durationMs,
|
|
9831
|
+
rounds: []
|
|
9832
|
+
},
|
|
9833
|
+
...data.usage === void 0 ? {} : { usage: data.usage },
|
|
9834
|
+
...data.recordSessionId === void 0 ? {} : { recordSessionId: data.recordSessionId }
|
|
9835
|
+
},
|
|
9836
|
+
provider: data.provider,
|
|
9837
|
+
model: data.model,
|
|
9838
|
+
...data.reasoningEffort === void 0 ? {} : { reasoningEffort: data.reasoningEffort }
|
|
9839
|
+
};
|
|
9840
|
+
}
|
|
9841
|
+
/** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
|
|
9842
|
+
function disposePrecompression(sessionId) {
|
|
9843
|
+
const job = jobs.get(sessionId);
|
|
9844
|
+
if (job === void 0) return;
|
|
9845
|
+
jobs.delete(sessionId);
|
|
9846
|
+
job.controller.abort();
|
|
9847
|
+
}
|
|
9848
|
+
/** 中止并移除全部后台任务(插件卸载)。 */
|
|
9849
|
+
function disposeAllPrecompressions() {
|
|
9850
|
+
for (const sessionId of [...jobs.keys()]) disposePrecompression(sessionId);
|
|
9851
|
+
}
|
|
9852
|
+
//#endregion
|
|
9275
9853
|
//#region src/compress.ts
|
|
9276
9854
|
/**
|
|
9277
9855
|
* 两级自动压缩(观察/反思)与 compaction 生命周期提交。
|
|
9278
9856
|
* 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
|
|
9279
|
-
* historyTextOf / findObservePending /
|
|
9857
|
+
* historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
|
|
9858
|
+
* reflectPass / observePass / maybeCompress。
|
|
9280
9859
|
*
|
|
9281
9860
|
* - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
|
|
9282
9861
|
* 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
|
|
9283
9862
|
* completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
|
|
9284
9863
|
* 全程无需整块校验
|
|
9285
|
-
* - 反思:全部 <history> 块 token
|
|
9286
|
-
*
|
|
9287
|
-
*
|
|
9288
|
-
*
|
|
9289
|
-
*
|
|
9290
|
-
*
|
|
9291
|
-
*
|
|
9292
|
-
*
|
|
9293
|
-
*
|
|
9294
|
-
*
|
|
9295
|
-
*
|
|
9296
|
-
*
|
|
9864
|
+
* - 反思:全部 <history> 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
|
|
9865
|
+
* 把全部块条目作为压缩视图重新压缩合并(视图无条目时跳过,如全部为不可解析的历史
|
|
9866
|
+
* 遗留块)
|
|
9867
|
+
* - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
|
|
9868
|
+
* 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
|
|
9869
|
+
* (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
|
|
9870
|
+
* 结果写 om/observe-summary 信封、不做替换);每个 pre-step 对账保证活跃标记对应任务
|
|
9871
|
+
* 或持久化结果(重启恢复直接采纳信封、不重压缩;失败任务丢弃重启);新增完整消息数 ≥
|
|
9872
|
+
* tailMessageCount 时到期,把压缩边界至触发点的全部消息作为压缩视图注入为新 <history>
|
|
9873
|
+
* 块(旧块保留),等待期间的新消息成为下一轮未压缩尾部(延迟窗口内压力允许短暂超
|
|
9874
|
+
* 阈值);到期未完成时阻塞等待后台任务(turn 取消则放行不注入,任务继续后台);
|
|
9875
|
+
* tailMessageCount=0 时触发当轮即到期,阻塞等待注入
|
|
9876
|
+
* - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
|
|
9877
|
+
* (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
|
|
9878
|
+
* - 待定标记与压缩结果以 log-only om 信封事件(借用 feedback/record,kind 为
|
|
9879
|
+
* om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
|
|
9880
|
+
* 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
|
|
9881
|
+
* - 两级在 pre-step 串行执行(先反思后观察;观察的压缩主体在后台运行,pre-step 仅在
|
|
9882
|
+
* 到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
|
|
9297
9883
|
* - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
|
|
9298
9884
|
* (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
|
|
9299
9885
|
* ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
|
|
@@ -9308,8 +9894,8 @@ function reportDegrade(session, logger, problem) {
|
|
|
9308
9894
|
* - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
|
|
9309
9895
|
* log-only om 警告事件(借用 feedback/record,客户端渲染功能降级警告行,每会话同一
|
|
9310
9896
|
* 问题至多一次);
|
|
9311
|
-
* 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter
|
|
9312
|
-
*
|
|
9897
|
+
* 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
|
|
9898
|
+
* 本轮跳过观察,反思换算系数按 1 计)
|
|
9313
9899
|
*/
|
|
9314
9900
|
/** 历史文本 token 估算:4 字符 ≈ 1 token(与宿主 dsh-token-meter 启发式一致)。 */
|
|
9315
9901
|
function estimateTextTokens(text) {
|
|
@@ -9608,13 +10194,16 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
|
|
|
9608
10194
|
return { failed: false };
|
|
9609
10195
|
}
|
|
9610
10196
|
const threshold = config.reflectThresholdTokens;
|
|
9611
|
-
const
|
|
10197
|
+
const estimatedTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
10198
|
+
const measurement = measurePressure(ctx, session, logger);
|
|
10199
|
+
const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10200
|
+
const tokens = Math.round(ratio * estimatedTokens);
|
|
9612
10201
|
const shadowedCharCount = blocks.reduce((total, block) => total + historyInnerText(block.text).length, 0);
|
|
9613
10202
|
if (tokens < threshold) {
|
|
9614
|
-
logger.step(`反思:摘要 ${tokens} tokens
|
|
10203
|
+
logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})< 阈值 ${threshold},跳过`);
|
|
9615
10204
|
return { failed: false };
|
|
9616
10205
|
}
|
|
9617
|
-
logger.step(`反思:摘要 ${tokens} tokens
|
|
10206
|
+
logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})≥ 阈值 ${threshold},触发精简合并(${blocks.length} 个块)`);
|
|
9618
10207
|
const first = blocks[0];
|
|
9619
10208
|
const last = blocks[blocks.length - 1];
|
|
9620
10209
|
if (first === void 0 || last === void 0) {
|
|
@@ -9669,7 +10258,7 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
|
|
|
9669
10258
|
end: last.seq
|
|
9670
10259
|
},
|
|
9671
10260
|
shadowedSeqs: blockSeqs,
|
|
9672
|
-
shadowedTokenCount:
|
|
10261
|
+
shadowedTokenCount: estimatedTokens,
|
|
9673
10262
|
shadowedCharCount,
|
|
9674
10263
|
provider: target.provider,
|
|
9675
10264
|
model: target.model,
|
|
@@ -9690,250 +10279,368 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
|
|
|
9690
10279
|
return { failed: false };
|
|
9691
10280
|
} catch (error) {
|
|
9692
10281
|
const message = error instanceof Error ? error.message : String(error);
|
|
9693
|
-
logger.warn(`反思提交失败: ${message}`);
|
|
10282
|
+
logger.warn(`反思提交失败: ${message}`);
|
|
10283
|
+
try {
|
|
10284
|
+
appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
|
|
10285
|
+
} catch {}
|
|
10286
|
+
return { failed: false };
|
|
10287
|
+
}
|
|
10288
|
+
}
|
|
10289
|
+
/**
|
|
10290
|
+
* 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
|
|
10291
|
+
* systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
|
|
10292
|
+
* 或组装/渲染失败时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
|
|
10293
|
+
* 服务缺失属挂载失败:console 外部 + om 警告事件每会话报告一次;组装失败仅记日志。
|
|
10294
|
+
*/
|
|
10295
|
+
async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
|
|
10296
|
+
const systemPrompt = ctx.get("systemPrompt");
|
|
10297
|
+
if (systemPrompt === void 0 || typeof systemPrompt.assemble !== "function") {
|
|
10298
|
+
reportDegrade(agent.session, logger, "systemPrompt-missing");
|
|
10299
|
+
return 0;
|
|
10300
|
+
}
|
|
10301
|
+
try {
|
|
10302
|
+
const agentCtx = agent.ctx;
|
|
10303
|
+
const scope = agentCtx === void 0 ? void 0 : scopeOf(agentCtx);
|
|
10304
|
+
const assembleContext = { agent };
|
|
10305
|
+
if (scope !== void 0) assembleContext.scope = scope;
|
|
10306
|
+
if (signal !== void 0) assembleContext.signal = signal;
|
|
10307
|
+
const assembly = await systemPrompt.assemble(assembleContext);
|
|
10308
|
+
return estimateTextTokens(renderPrompt(assembly));
|
|
10309
|
+
} catch (error) {
|
|
10310
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10311
|
+
logger.warn(`系统提示词 tokens 估算失败,按 0 计: ${message}`);
|
|
10312
|
+
return 0;
|
|
10313
|
+
}
|
|
10314
|
+
}
|
|
10315
|
+
/**
|
|
10316
|
+
* 估算请求工具定义 tokens:按会话请求头 tools(assembled tool schemas)JSON 序列化
|
|
10317
|
+
* 长度/4 启发式计(与宿主 dsh-token-meter 对工具 schema 的启发式一致)。请求头读取
|
|
10318
|
+
* 失败或缺 tools 时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
|
|
10319
|
+
*/
|
|
10320
|
+
function estimateToolsTokens(session, logger) {
|
|
10321
|
+
try {
|
|
10322
|
+
const header = session.requestHeader();
|
|
10323
|
+
if (header?.tools === void 0 || header.tools.length === 0) return 0;
|
|
10324
|
+
return estimateTextTokens(JSON.stringify(header.tools));
|
|
10325
|
+
} catch (error) {
|
|
10326
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10327
|
+
logger.warn(`工具定义 tokens 估算失败,按 0 计: ${message}`);
|
|
10328
|
+
return 0;
|
|
10329
|
+
}
|
|
10330
|
+
}
|
|
10331
|
+
/**
|
|
10332
|
+
* 读取压力计量(tokenMeter.measure)。调用异常时记日志并报告降级(console 外部 +
|
|
10333
|
+
* om 警告事件每会话一次),返回 undefined——观察本轮跳过(无压力数据不触发),
|
|
10334
|
+
* 反思换算系数按 1 计;都不阻塞 turn。
|
|
10335
|
+
*/
|
|
10336
|
+
function measurePressure(ctx, session, logger) {
|
|
10337
|
+
try {
|
|
10338
|
+
const measurement = ctx.tokenMeter.measure(session);
|
|
10339
|
+
return {
|
|
10340
|
+
surfaceTokens: measurement.surfaceTokens,
|
|
10341
|
+
surfaceDeltaTokens: measurement.surfaceDeltaTokens,
|
|
10342
|
+
baselineUsageTokens: measurement.baseline.kind === "usage" ? measurement.baseline.tokens : void 0
|
|
10343
|
+
};
|
|
10344
|
+
} catch (error) {
|
|
10345
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10346
|
+
logger.warn(`上下文压力读取失败(tokenMeter.measure 抛错): ${message}`);
|
|
10347
|
+
reportDegrade(session, logger, "tokenMeter-unavailable");
|
|
10348
|
+
return;
|
|
10349
|
+
}
|
|
10350
|
+
}
|
|
10351
|
+
/**
|
|
10352
|
+
* 换算系数:上次请求真实用量基线 ÷ 锚点估算量(工具定义估算 + 锚点表层 =
|
|
10353
|
+
* 当前表层 − 表层增量),把字符/4 估算换算为主模型真实 token 单位。无真实用量
|
|
10354
|
+
* 基线或锚点估算量非正时按 1 计;结果恒 ≥ 1(真实用量低于估算时宿主已回退估算基线)。
|
|
10355
|
+
*/
|
|
10356
|
+
function conversionRatio(measurement, toolsTokens) {
|
|
10357
|
+
if (measurement.baselineUsageTokens === void 0) return 1;
|
|
10358
|
+
const anchorTokens = toolsTokens + measurement.surfaceTokens - measurement.surfaceDeltaTokens;
|
|
10359
|
+
if (anchorTokens <= 0) return 1;
|
|
10360
|
+
return Math.max(1, measurement.baselineUsageTokens / anchorTokens);
|
|
10361
|
+
}
|
|
10362
|
+
/**
|
|
10363
|
+
* 准备观察压缩:计算区间 [压缩边界..触发点]、校验可行性并构建压缩视图。
|
|
10364
|
+
* 不写任何事件;供延迟执行与后台预压缩共用。
|
|
10365
|
+
*/
|
|
10366
|
+
function prepareObserveCompression(session, triggerMessageIndex, config) {
|
|
10367
|
+
const range = computeCompressRange(session, triggerMessageIndex);
|
|
10368
|
+
if (!range) return {
|
|
10369
|
+
ok: false,
|
|
10370
|
+
reason: "无可行压缩区间(边界后无消息、触发点已被压缩或配对无法平衡)"
|
|
10371
|
+
};
|
|
10372
|
+
const replaceSeqs = range.shadowedSeqs;
|
|
10373
|
+
const replaceStart = replaceSeqs[0];
|
|
10374
|
+
if (replaceStart === void 0) return {
|
|
10375
|
+
ok: false,
|
|
10376
|
+
reason: "区间内无新消息(全部为压缩日志块)"
|
|
10377
|
+
};
|
|
10378
|
+
const shadowedSet = new Set(replaceSeqs);
|
|
10379
|
+
if (indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq))).length === 0) return {
|
|
10380
|
+
ok: false,
|
|
10381
|
+
reason: "区间内无完整消息"
|
|
10382
|
+
};
|
|
10383
|
+
const shadowedCharCount = seqsCharCount(session, replaceSeqs);
|
|
10384
|
+
const view = buildObserveView(session, replaceSeqs, { skipReasoning: config.compressSkipReasoning });
|
|
10385
|
+
if (view.minIndex === void 0 || view.maxIndex === void 0) return {
|
|
10386
|
+
ok: false,
|
|
10387
|
+
reason: "区间内无可定位条目"
|
|
10388
|
+
};
|
|
10389
|
+
return {
|
|
10390
|
+
ok: true,
|
|
10391
|
+
prepared: {
|
|
10392
|
+
range,
|
|
10393
|
+
replaceSeqs,
|
|
10394
|
+
replaceStart,
|
|
10395
|
+
shadowedCharCount,
|
|
10396
|
+
view: {
|
|
10397
|
+
...view,
|
|
10398
|
+
minIndex: view.minIndex,
|
|
10399
|
+
maxIndex: view.maxIndex
|
|
10400
|
+
}
|
|
10401
|
+
}
|
|
10402
|
+
};
|
|
10403
|
+
}
|
|
10404
|
+
/**
|
|
10405
|
+
* 提交观察压缩结果:compaction/summary(影子价格认领)→ 替换被压缩区间为 <history>
|
|
10406
|
+
* 块(旧块保留)→ compaction/end → 清除待定标记。调用前须已追加 compaction/start
|
|
10407
|
+
* (同一开放 turn 内满足宿主括号不变量)。提交失败为局部异常(压缩已成功):记日志、
|
|
10408
|
+
* 补 end(error) 后返回不失败结果,不中断 turn;待定标记保留,边界后移后由
|
|
10409
|
+
* findObservePending 判定过期。
|
|
10410
|
+
*/
|
|
10411
|
+
function commitObserveCompression(ctx, session, lifecycle, prepared, summaryResult, opts) {
|
|
10412
|
+
const { logger, clearPending, target, triggerNote } = opts;
|
|
10413
|
+
const { range, replaceSeqs, replaceStart, shadowedCharCount } = prepared;
|
|
10414
|
+
const report = summaryResult.text;
|
|
10415
|
+
const usage = summaryResult.usage;
|
|
10416
|
+
const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
|
|
10417
|
+
const event = session.snapshotEvents()[seq];
|
|
10418
|
+
const message = event ? session.deriveEventMessage(event) : null;
|
|
10419
|
+
let tokens = 0;
|
|
10420
|
+
if (message) try {
|
|
10421
|
+
tokens = ctx.tokenMeter.estimateMessage(message);
|
|
10422
|
+
} catch {
|
|
10423
|
+
reportDegrade(session, logger, "tokenMeter-unavailable");
|
|
10424
|
+
}
|
|
10425
|
+
return total + tokens;
|
|
10426
|
+
}, 0);
|
|
10427
|
+
try {
|
|
10428
|
+
logger.step("观察提交:追加 compaction/summary(影子价格认领)");
|
|
10429
|
+
const summarySeq = appendCompactionSummary(session, {
|
|
10430
|
+
lifecycle,
|
|
10431
|
+
summary: report,
|
|
10432
|
+
shadowedRange: {
|
|
10433
|
+
start: replaceStart,
|
|
10434
|
+
end: range.end
|
|
10435
|
+
},
|
|
10436
|
+
shadowedSeqs: replaceSeqs,
|
|
10437
|
+
shadowedTokenCount,
|
|
10438
|
+
shadowedCharCount,
|
|
10439
|
+
provider: target.provider,
|
|
10440
|
+
model: target.model,
|
|
10441
|
+
maxTokens: opts.maxTokens,
|
|
10442
|
+
stats: summaryResult.stats,
|
|
10443
|
+
...usage === void 0 ? {} : { usage },
|
|
10444
|
+
...opts.reasoningEffort === void 0 ? {} : { reasoningEffort: opts.reasoningEffort }
|
|
10445
|
+
});
|
|
10446
|
+
logger.step("观察提交:替换被压缩新消息区间为 <history>(旧块保留)");
|
|
10447
|
+
appendHistoryMessage(session, report, [summarySeq, ...replaceSeqs], {
|
|
10448
|
+
op: "replace",
|
|
10449
|
+
startSeq: replaceStart,
|
|
10450
|
+
endSeq: range.end
|
|
10451
|
+
}, lifecycle.compactionId);
|
|
10452
|
+
logger.step("观察提交:追加 compaction/end");
|
|
10453
|
+
appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
|
|
10454
|
+
clearPending();
|
|
10455
|
+
logger.info(`观察压缩完成(替换 ${replaceSeqs.length} 个表层节点,约 ${shadowedTokenCount} tokens,压缩至${triggerNote})`);
|
|
10456
|
+
return { failed: false };
|
|
10457
|
+
} catch (error) {
|
|
10458
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10459
|
+
logger.warn(`观察压缩提交失败: ${message}`);
|
|
9694
10460
|
try {
|
|
9695
10461
|
appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
|
|
9696
10462
|
} catch {}
|
|
9697
10463
|
return { failed: false };
|
|
9698
10464
|
}
|
|
9699
10465
|
}
|
|
9700
|
-
/**
|
|
9701
|
-
|
|
9702
|
-
|
|
9703
|
-
* 或组装/渲染失败时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
|
|
9704
|
-
* 服务缺失属挂载失败:console 外部 + om 警告事件每会话报告一次;组装失败仅记日志。
|
|
9705
|
-
*/
|
|
9706
|
-
async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
|
|
9707
|
-
const systemPrompt = ctx.get("systemPrompt");
|
|
9708
|
-
if (systemPrompt === void 0 || typeof systemPrompt.assemble !== "function") {
|
|
9709
|
-
reportDegrade(agent.session, logger, "systemPrompt-missing");
|
|
9710
|
-
return 0;
|
|
9711
|
-
}
|
|
9712
|
-
try {
|
|
9713
|
-
const agentCtx = agent.ctx;
|
|
9714
|
-
const scope = agentCtx === void 0 ? void 0 : scopeOf(agentCtx);
|
|
9715
|
-
const assembleContext = { agent };
|
|
9716
|
-
if (scope !== void 0) assembleContext.scope = scope;
|
|
9717
|
-
if (signal !== void 0) assembleContext.signal = signal;
|
|
9718
|
-
const assembly = await systemPrompt.assemble(assembleContext);
|
|
9719
|
-
return estimateTextTokens(renderPrompt(assembly));
|
|
9720
|
-
} catch (error) {
|
|
9721
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
9722
|
-
logger.warn(`系统提示词 tokens 估算失败,按 0 计: ${message}`);
|
|
9723
|
-
return 0;
|
|
9724
|
-
}
|
|
9725
|
-
}
|
|
9726
|
-
/**
|
|
9727
|
-
* 估算请求工具定义 tokens:按会话请求头 tools(assembled tool schemas)JSON 序列化
|
|
9728
|
-
* 长度/4 启发式计(与宿主 dsh-token-meter 对工具 schema 的启发式一致)。请求头读取
|
|
9729
|
-
* 失败或缺 tools 时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
|
|
9730
|
-
*/
|
|
9731
|
-
function estimateToolsTokens(session, logger) {
|
|
9732
|
-
try {
|
|
9733
|
-
const header = session.requestHeader();
|
|
9734
|
-
if (header?.tools === void 0 || header.tools.length === 0) return 0;
|
|
9735
|
-
return estimateTextTokens(JSON.stringify(header.tools));
|
|
9736
|
-
} catch (error) {
|
|
9737
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
9738
|
-
logger.warn(`工具定义 tokens 估算失败,按 0 计: ${message}`);
|
|
9739
|
-
return 0;
|
|
9740
|
-
}
|
|
10466
|
+
/** 匹配 pendingSeq 的最后一条持久化压缩结果信封(重启恢复采纳;正常每标记至多一条)。 */
|
|
10467
|
+
function findPersistedSummary(session, pendingSeq) {
|
|
10468
|
+
return findOmEvents(session, "om/observe-summary").filter((event) => event.data.pendingSeq === pendingSeq).at(-1);
|
|
9741
10469
|
}
|
|
9742
|
-
/**
|
|
9743
|
-
|
|
9744
|
-
|
|
9745
|
-
|
|
9746
|
-
|
|
9747
|
-
|
|
9748
|
-
|
|
9749
|
-
return ctx.tokenMeter.measure(session).totalTokens;
|
|
9750
|
-
} catch (error) {
|
|
9751
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
9752
|
-
logger.warn(`上下文压力读取失败(tokenMeter.measure 抛错),本轮跳过观察压缩: ${message}`);
|
|
9753
|
-
reportDegrade(session, logger, "tokenMeter-unavailable");
|
|
9754
|
-
return;
|
|
9755
|
-
}
|
|
10470
|
+
/** 等待 signal 中止(无 signal 时返回永不 resolve 的 Promise,race 仅由任务完成决定)。 */
|
|
10471
|
+
function signalAbortedRace(signal) {
|
|
10472
|
+
if (signal === void 0) return new Promise(() => {});
|
|
10473
|
+
if (signal.aborted) return Promise.resolve();
|
|
10474
|
+
return new Promise((resolve) => {
|
|
10475
|
+
signal.addEventListener("abort", () => resolve(), { once: true });
|
|
10476
|
+
});
|
|
9756
10477
|
}
|
|
9757
10478
|
/**
|
|
9758
|
-
*
|
|
9759
|
-
*
|
|
9760
|
-
*
|
|
9761
|
-
*
|
|
9762
|
-
*
|
|
9763
|
-
*
|
|
9764
|
-
*
|
|
9765
|
-
*
|
|
10479
|
+
* 观察(打标记 → 对账 → 到期注入):每个 pre-step 串行执行三阶段。
|
|
10480
|
+
* 打标记:无活跃待定标记时测净压力 tokens(换算系数 × 未压缩表层估算,未压缩 =
|
|
10481
|
+
* 表层 − 已压缩 <history> 块估算合计 − 系统提示词估算),首次 ≥ observeThresholdTokens
|
|
10482
|
+
* 写 om/observe-pending(触发点 = 当时的最后一条完整消息 index)。
|
|
10483
|
+
* 对账:活跃标记必须对应后台任务或持久化结果——匹配 pendingSeq 的 om/observe-summary
|
|
10484
|
+
* 信封直接采纳(重启恢复,不重压缩);无结果且无任务(或任务已失败)时启动后台预压缩
|
|
10485
|
+
* (无可行区间则失效标记视为完成);无活跃标记时清理注册表(边界后移使标记过期的运行中
|
|
10486
|
+
* 任务被中止)。
|
|
10487
|
+
* 到期:新增完整消息数 ≥ tailMessageCount 时注入——已完成结果在同一 pre-step / 同一开放
|
|
10488
|
+
* turn 内一次提交(compaction/start → summary → 替换 → end → 失效标记,满足宿主括号
|
|
10489
|
+
* 不变量);运行中任务等待其完成(turn 被取消则放行不注入,任务继续后台);失败返回
|
|
10490
|
+
* 失败结果(error = 最后一次错误,标记保留,下个 pre-step 重启任务重试)。
|
|
9766
10491
|
*/
|
|
9767
10492
|
async function observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort) {
|
|
9768
10493
|
const session = agent.session;
|
|
9769
10494
|
const logger = makeLogger(ctx, config.debug);
|
|
9770
10495
|
logger.step(`观察检查(观察阈值 ${config.observeThresholdTokens} tokens,延迟等待 ${waitCount} 条完整消息)`);
|
|
9771
|
-
const { blocks } = historySection(session);
|
|
9772
10496
|
const pending = findObservePending(session);
|
|
9773
10497
|
let triggerMessageIndex;
|
|
9774
10498
|
let pendingSeq;
|
|
9775
|
-
let triggerNote;
|
|
9776
10499
|
if (pending === void 0) {
|
|
10500
|
+
disposePrecompression(session.id);
|
|
9777
10501
|
const threshold = config.observeThresholdTokens;
|
|
9778
|
-
const
|
|
9779
|
-
if (
|
|
10502
|
+
const measurement = measurePressure(ctx, session, logger);
|
|
10503
|
+
if (measurement === void 0) return { failed: false };
|
|
10504
|
+
const { blocks } = historySection(session);
|
|
9780
10505
|
const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
|
|
9781
10506
|
const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
|
|
9782
|
-
const
|
|
9783
|
-
const
|
|
10507
|
+
const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
|
|
10508
|
+
const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
|
|
10509
|
+
const netTokens = Math.round(ratio * uncompressedTokens);
|
|
10510
|
+
const formula = `换算系数 ${ratio.toFixed(2)} ×(表层 ${measurement.surfaceTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens})`;
|
|
9784
10511
|
if (netTokens < threshold) {
|
|
9785
|
-
logger.step(`观察:净压力 ${netTokens} tokens
|
|
10512
|
+
logger.step(`观察:净压力 ${netTokens} tokens(${formula})< 阈值 ${threshold},跳过`);
|
|
9786
10513
|
return { failed: false };
|
|
9787
10514
|
}
|
|
9788
|
-
logger.step(`观察:净压力 ${netTokens} tokens
|
|
10515
|
+
logger.step(`观察:净压力 ${netTokens} tokens(${formula})≥ 阈值 ${threshold},触发压缩`);
|
|
9789
10516
|
const lastMessageIndex = indexCompleteMessages(session).length - 1;
|
|
9790
10517
|
if (lastMessageIndex < 0) {
|
|
9791
10518
|
logger.step("观察:会话尚无完整消息,跳过");
|
|
9792
10519
|
return { failed: false };
|
|
9793
10520
|
}
|
|
9794
10521
|
triggerMessageIndex = lastMessageIndex;
|
|
9795
|
-
|
|
9796
|
-
|
|
9797
|
-
|
|
9798
|
-
|
|
9799
|
-
|
|
9800
|
-
logger.warn(`观察:待定标记追加失败,本轮跳过(下轮重新评估): ${message}`);
|
|
9801
|
-
return { failed: false };
|
|
9802
|
-
}
|
|
9803
|
-
logger.step(`观察:记录待定标记(触发点完整消息 index ${triggerMessageIndex}),等待 ${waitCount} 条新完整消息后压缩`);
|
|
10522
|
+
try {
|
|
10523
|
+
pendingSeq = appendObservePending(session, triggerMessageIndex);
|
|
10524
|
+
} catch (error) {
|
|
10525
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
10526
|
+
logger.warn(`观察:待定标记追加失败,本轮跳过(下轮重新评估): ${message}`);
|
|
9804
10527
|
return { failed: false };
|
|
9805
10528
|
}
|
|
9806
|
-
|
|
10529
|
+
logger.step(`观察:记录待定标记(触发点完整消息 index ${triggerMessageIndex}),开始后台预压缩,等待 ${waitCount} 条新完整消息后注入`);
|
|
9807
10530
|
} else {
|
|
9808
|
-
const arrived = indexCompleteMessages(session).length - 1 - pending.triggerMessageIndex;
|
|
9809
|
-
if (arrived < waitCount) {
|
|
9810
|
-
logger.step(`观察:待定标记等待中(触发点完整消息 index ${pending.triggerMessageIndex},新增 ${arrived}/${waitCount} 条),跳过`);
|
|
9811
|
-
return { failed: false };
|
|
9812
|
-
}
|
|
9813
|
-
logger.step(`观察:待定标记延迟到期(触发点完整消息 index ${pending.triggerMessageIndex},新增 ${arrived} ≥ ${waitCount} 条),执行压缩`);
|
|
9814
10531
|
triggerMessageIndex = pending.triggerMessageIndex;
|
|
9815
10532
|
pendingSeq = pending.seq;
|
|
9816
|
-
triggerNote = `待定标记触发点完整消息 index ${pending.triggerMessageIndex}`;
|
|
9817
10533
|
}
|
|
10534
|
+
/** 注入成功后失效待定标记并清理注册表(done 任务的 abort 无副作用)。 */
|
|
9818
10535
|
const clearPending = () => {
|
|
9819
|
-
if (pendingSeq === void 0) return;
|
|
9820
10536
|
try {
|
|
9821
10537
|
appendObserveInvalidate(session, pendingSeq);
|
|
9822
10538
|
} catch (error) {
|
|
9823
10539
|
const message = error instanceof Error ? error.message : String(error);
|
|
9824
10540
|
logger.warn(`观察:待定失效标记追加失败: ${message}`);
|
|
9825
10541
|
}
|
|
10542
|
+
disposePrecompression(session.id);
|
|
9826
10543
|
};
|
|
9827
|
-
const
|
|
9828
|
-
|
|
9829
|
-
|
|
9830
|
-
|
|
9831
|
-
|
|
10544
|
+
const persisted = findPersistedSummary(session, pendingSeq);
|
|
10545
|
+
let adopted;
|
|
10546
|
+
let job = findPrecompressionJob(session, pendingSeq);
|
|
10547
|
+
if (persisted !== void 0) {
|
|
10548
|
+
adopted = adoptPersistedSummary(persisted.data);
|
|
10549
|
+
if (job !== void 0 && job.state === "running") disposePrecompression(session.id);
|
|
10550
|
+
job = void 0;
|
|
10551
|
+
logger.step(`观察:采纳持久化压缩结果(om/observe-summary seq ${persisted.seq})`);
|
|
10552
|
+
} else if (job === void 0 || job.state === "failed") {
|
|
10553
|
+
if (job !== void 0) {
|
|
10554
|
+
logger.step(`观察:后台任务失败(${job.failure?.error ?? "未知错误"}),丢弃并重启`);
|
|
10555
|
+
disposePrecompression(session.id);
|
|
10556
|
+
}
|
|
10557
|
+
const started = startPrecompression({
|
|
10558
|
+
ctx,
|
|
10559
|
+
session,
|
|
10560
|
+
config,
|
|
10561
|
+
target,
|
|
10562
|
+
pendingSeq,
|
|
10563
|
+
triggerMessageIndex,
|
|
10564
|
+
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
10565
|
+
});
|
|
10566
|
+
if (!started.ok) return { failed: false };
|
|
10567
|
+
job = started.job;
|
|
9832
10568
|
}
|
|
9833
|
-
|
|
9834
|
-
|
|
9835
|
-
|
|
9836
|
-
if (replaceStart === void 0) {
|
|
9837
|
-
logger.step("观察:区间内无新消息(全部为压缩日志块),清除待定标记视为完成");
|
|
9838
|
-
clearPending();
|
|
10569
|
+
const arrived = indexCompleteMessages(session).length - 1 - triggerMessageIndex;
|
|
10570
|
+
if (arrived < waitCount) {
|
|
10571
|
+
logger.step(`观察:待定标记等待中(触发点完整消息 index ${triggerMessageIndex},新增 ${arrived}/${waitCount}),后台${adopted !== void 0 ? "已有持久化结果待注入" : `任务${job?.state ?? "未知"}`}`);
|
|
9839
10572
|
return { failed: false };
|
|
9840
10573
|
}
|
|
9841
|
-
|
|
9842
|
-
|
|
9843
|
-
|
|
9844
|
-
|
|
9845
|
-
|
|
10574
|
+
logger.step(`观察:待定标记延迟到期(触发点完整消息 index ${triggerMessageIndex},新增 ${arrived} ≥ ${waitCount}),执行注入`);
|
|
10575
|
+
let summaryResult;
|
|
10576
|
+
let prepared;
|
|
10577
|
+
let commitTarget = target;
|
|
10578
|
+
let commitEffort = reasoningEffort;
|
|
10579
|
+
if (adopted !== void 0) {
|
|
10580
|
+
summaryResult = adopted.result;
|
|
10581
|
+
commitTarget = {
|
|
10582
|
+
provider: adopted.provider,
|
|
10583
|
+
model: adopted.model
|
|
10584
|
+
};
|
|
10585
|
+
commitEffort = adopted.reasoningEffort;
|
|
10586
|
+
const prepare = prepareObserveCompression(session, triggerMessageIndex, config);
|
|
10587
|
+
if (!prepare.ok) {
|
|
10588
|
+
logger.step(`观察:${prepare.reason},清除待定标记视为完成`);
|
|
10589
|
+
clearPending();
|
|
10590
|
+
return { failed: false };
|
|
10591
|
+
}
|
|
10592
|
+
prepared = prepare.prepared;
|
|
10593
|
+
} else if (job !== void 0) {
|
|
10594
|
+
if (job.state === "running") {
|
|
10595
|
+
if (signal?.aborted) {
|
|
10596
|
+
logger.step("观察:pre-step 已中止,放行不注入(后台任务继续)");
|
|
10597
|
+
return { failed: false };
|
|
10598
|
+
}
|
|
10599
|
+
logger.step("观察:到期未完成预压缩,阻塞等待后台任务");
|
|
10600
|
+
await Promise.race([job.promise, signalAbortedRace(signal)]);
|
|
10601
|
+
}
|
|
10602
|
+
if (job.state === "failed") {
|
|
10603
|
+
const failure = job.failure;
|
|
10604
|
+
return {
|
|
10605
|
+
failed: true,
|
|
10606
|
+
error: failure?.error ?? "后台预压缩失败",
|
|
10607
|
+
aborted: failure?.aborted ?? false,
|
|
10608
|
+
...failure?.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: failure.diagnosticSessionId }
|
|
10609
|
+
};
|
|
10610
|
+
}
|
|
10611
|
+
if (job.state === "running") {
|
|
10612
|
+
logger.step("观察:等待期间 turn 被取消,放行不注入(后台任务继续)");
|
|
10613
|
+
return { failed: false };
|
|
10614
|
+
}
|
|
10615
|
+
summaryResult = job.result;
|
|
10616
|
+
prepared = job.prepared;
|
|
9846
10617
|
}
|
|
9847
|
-
|
|
9848
|
-
|
|
9849
|
-
if (view.minIndex === void 0 || view.maxIndex === void 0) {
|
|
9850
|
-
logger.step("观察:区间内无可定位条目,清除待定标记视为完成");
|
|
9851
|
-
clearPending();
|
|
10618
|
+
if (summaryResult === void 0 || prepared === void 0) {
|
|
10619
|
+
logger.warn("观察:到期但无可注入的压缩结果,本轮跳过(下轮对账重试)");
|
|
9852
10620
|
return { failed: false };
|
|
9853
10621
|
}
|
|
9854
|
-
|
|
10622
|
+
const triggerNote = `触发点完整消息 index ${triggerMessageIndex}`;
|
|
10623
|
+
logger.step(`观察:压缩区间 [${prepared.range.start}..${prepared.range.end}],遮蔽 ${prepared.replaceSeqs.length} 个表层节点,压缩至${triggerNote}`);
|
|
9855
10624
|
const lifecycle = {
|
|
9856
10625
|
compactionId: newCompactionId(),
|
|
9857
10626
|
turn: openTurnOf(session)
|
|
9858
10627
|
};
|
|
9859
10628
|
try {
|
|
9860
|
-
logger.step("观察:追加 compaction/start
|
|
10629
|
+
logger.step("观察:追加 compaction/start(注入开始)");
|
|
9861
10630
|
appendCompactionStart(session, lifecycle, "observe");
|
|
9862
10631
|
} catch (error) {
|
|
9863
10632
|
const message = error instanceof Error ? error.message : String(error);
|
|
9864
10633
|
logger.warn(`观察压缩启动失败: ${message}`);
|
|
9865
10634
|
return { failed: false };
|
|
9866
10635
|
}
|
|
9867
|
-
|
|
9868
|
-
|
|
9869
|
-
originalChars: shadowedCharCount,
|
|
9870
|
-
phase: "observe",
|
|
9871
|
-
taskText: buildCompressionTaskText("observe", view.minIndex, view.maxIndex),
|
|
9872
|
-
target,
|
|
10636
|
+
return commitObserveCompression(ctx, session, lifecycle, prepared, summaryResult, {
|
|
10637
|
+
target: commitTarget,
|
|
9873
10638
|
maxTokens: config.compressMaxTokens,
|
|
9874
|
-
|
|
9875
|
-
|
|
9876
|
-
|
|
9877
|
-
|
|
9878
|
-
|
|
9879
|
-
}, logger, "observe");
|
|
9880
|
-
if (!summaryResult.ok) return {
|
|
9881
|
-
failed: true,
|
|
9882
|
-
error: summaryResult.error,
|
|
9883
|
-
aborted: summaryResult.aborted,
|
|
9884
|
-
...summaryResult.recordSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.recordSessionId }
|
|
9885
|
-
};
|
|
9886
|
-
const report = summaryResult.text;
|
|
9887
|
-
const usage = summaryResult.usage;
|
|
9888
|
-
const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
|
|
9889
|
-
const event = session.snapshotEvents()[seq];
|
|
9890
|
-
const message = event ? session.deriveEventMessage(event) : null;
|
|
9891
|
-
let tokens = 0;
|
|
9892
|
-
if (message) try {
|
|
9893
|
-
tokens = ctx.tokenMeter.estimateMessage(message);
|
|
9894
|
-
} catch {
|
|
9895
|
-
reportDegrade(session, logger, "tokenMeter-unavailable");
|
|
9896
|
-
}
|
|
9897
|
-
return total + tokens;
|
|
9898
|
-
}, 0);
|
|
9899
|
-
try {
|
|
9900
|
-
logger.step("观察提交:追加 compaction/summary(影子价格认领)");
|
|
9901
|
-
const summarySeq = appendCompactionSummary(session, {
|
|
9902
|
-
lifecycle,
|
|
9903
|
-
summary: report,
|
|
9904
|
-
shadowedRange: {
|
|
9905
|
-
start: replaceStart,
|
|
9906
|
-
end: range.end
|
|
9907
|
-
},
|
|
9908
|
-
shadowedSeqs: replaceSeqs,
|
|
9909
|
-
shadowedTokenCount,
|
|
9910
|
-
shadowedCharCount,
|
|
9911
|
-
provider: target.provider,
|
|
9912
|
-
model: target.model,
|
|
9913
|
-
maxTokens: config.compressMaxTokens,
|
|
9914
|
-
stats: summaryResult.stats,
|
|
9915
|
-
...usage === void 0 ? {} : { usage },
|
|
9916
|
-
...reasoningEffort === void 0 ? {} : { reasoningEffort }
|
|
9917
|
-
});
|
|
9918
|
-
logger.step("观察提交:替换被压缩新消息区间为 <history>(旧块保留)");
|
|
9919
|
-
appendHistoryMessage(session, report, [summarySeq, ...replaceSeqs], {
|
|
9920
|
-
op: "replace",
|
|
9921
|
-
startSeq: replaceStart,
|
|
9922
|
-
endSeq: range.end
|
|
9923
|
-
}, lifecycle.compactionId);
|
|
9924
|
-
logger.step("观察提交:追加 compaction/end");
|
|
9925
|
-
appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
|
|
9926
|
-
clearPending();
|
|
9927
|
-
logger.info(`观察压缩完成(替换 ${replaceSeqs.length} 个表层节点,约 ${shadowedTokenCount} tokens,压缩至${triggerNote})`);
|
|
9928
|
-
return { failed: false };
|
|
9929
|
-
} catch (error) {
|
|
9930
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
9931
|
-
logger.warn(`观察压缩提交失败: ${message}`);
|
|
9932
|
-
try {
|
|
9933
|
-
appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
|
|
9934
|
-
} catch {}
|
|
9935
|
-
return { failed: false };
|
|
9936
|
-
}
|
|
10639
|
+
reasoningEffort: commitEffort,
|
|
10640
|
+
triggerNote,
|
|
10641
|
+
logger,
|
|
10642
|
+
clearPending
|
|
10643
|
+
});
|
|
9937
10644
|
}
|
|
9938
10645
|
/**
|
|
9939
10646
|
* 压力检查 + 两级压缩入口:先反思后观察,pre-step 阻塞串行执行;仅主会话生效。
|
|
@@ -10185,6 +10892,7 @@ const DEFAULT_CONFIG = Object.freeze({
|
|
|
10185
10892
|
reflectThresholdTokens: 4e4,
|
|
10186
10893
|
compressMaxTokens: void 0,
|
|
10187
10894
|
rateLimitWaitMs: 6e4,
|
|
10895
|
+
recompressConcurrency: 2,
|
|
10188
10896
|
tailMessageCount: 20,
|
|
10189
10897
|
compressSkipReasoning: true,
|
|
10190
10898
|
omEnabled: true,
|
|
@@ -10206,6 +10914,7 @@ const Config = Schema.object({
|
|
|
10206
10914
|
reflectThresholdTokens: Schema.number().step(1).default(DEFAULT_CONFIG.reflectThresholdTokens).volatile(),
|
|
10207
10915
|
compressMaxTokens: Schema.number().step(1).volatile(),
|
|
10208
10916
|
rateLimitWaitMs: Schema.number().step(1).default(DEFAULT_CONFIG.rateLimitWaitMs).volatile(),
|
|
10917
|
+
recompressConcurrency: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.recompressConcurrency).volatile(),
|
|
10209
10918
|
tailMessageCount: Schema.number().step(1).default(DEFAULT_CONFIG.tailMessageCount).volatile(),
|
|
10210
10919
|
compressSkipReasoning: Schema.boolean().default(DEFAULT_CONFIG.compressSkipReasoning).volatile(),
|
|
10211
10920
|
omEnabled: Schema.boolean().default(DEFAULT_CONFIG.omEnabled).volatile(),
|
|
@@ -10223,11 +10932,11 @@ const Config = Schema.object({
|
|
|
10223
10932
|
}).default({});
|
|
10224
10933
|
/** 解析宿主 volatile 引用中的当前值,也兼容直接传入的原始配置对象。 */
|
|
10225
10934
|
function currentConfig(config) {
|
|
10226
|
-
if (!isRecord(config)) return resolveConfig(config);
|
|
10935
|
+
if (!isRecord$1(config)) return resolveConfig(config);
|
|
10227
10936
|
const values = {};
|
|
10228
10937
|
for (const key of Object.keys(DEFAULT_CONFIG)) {
|
|
10229
10938
|
const value = config[key];
|
|
10230
|
-
values[key] = isRecord(value) && typeof value.get === "function" ? value.get() : value;
|
|
10939
|
+
values[key] = isRecord$1(value) && typeof value.get === "function" ? value.get() : value;
|
|
10231
10940
|
}
|
|
10232
10941
|
return resolveConfig(values);
|
|
10233
10942
|
}
|
|
@@ -10237,6 +10946,11 @@ const NUMBER_KEYS = [
|
|
|
10237
10946
|
["reflectThresholdTokens", true],
|
|
10238
10947
|
["compressMaxTokens", true],
|
|
10239
10948
|
["rateLimitWaitMs", true],
|
|
10949
|
+
[
|
|
10950
|
+
"recompressConcurrency",
|
|
10951
|
+
true,
|
|
10952
|
+
1
|
|
10953
|
+
],
|
|
10240
10954
|
["tailMessageCount", true],
|
|
10241
10955
|
[
|
|
10242
10956
|
"progressReminderIdleSteps",
|
|
@@ -10253,7 +10967,7 @@ const NUMBER_KEYS = [
|
|
|
10253
10967
|
function normalizeConfigInput(raw) {
|
|
10254
10968
|
if (raw === void 0 || raw === null) return {};
|
|
10255
10969
|
if (typeof raw === "string" && raw.trim() === "") return {};
|
|
10256
|
-
if (!isRecord(raw)) return {};
|
|
10970
|
+
if (!isRecord$1(raw)) return {};
|
|
10257
10971
|
return raw;
|
|
10258
10972
|
}
|
|
10259
10973
|
/** 解析布尔配置值:缺省 / null / 空串 / 非 boolean 均回退默认值。 */
|
|
@@ -10427,7 +11141,6 @@ function toolcallElement(doc, session, cm, pruner, images) {
|
|
|
10427
11141
|
const call = toolCallBlockOf(session, cm);
|
|
10428
11142
|
const toolName = call === void 0 ? "" : String(call.name ?? "");
|
|
10429
11143
|
if (toolName !== "") el.setAttribute("tool-name", toolName);
|
|
10430
|
-
if (cm.callId) el.setAttribute("callId", cm.callId);
|
|
10431
11144
|
if (call) {
|
|
10432
11145
|
const args = doc.createElement("tool-args");
|
|
10433
11146
|
appendCdataText(doc, args, toolArgsJson(call.arguments));
|
|
@@ -10446,13 +11159,14 @@ function toolcallElement(doc, session, cm, pruner, images) {
|
|
|
10446
11159
|
appendImageComments(doc, el, images);
|
|
10447
11160
|
return el;
|
|
10448
11161
|
}
|
|
10449
|
-
/** 按完整消息类别构建元素(user / assistant 文本条目复用 parts 渲染)。 */
|
|
11162
|
+
/** 按完整消息类别构建元素(user / skill / assistant 文本条目复用 parts 渲染)。 */
|
|
10450
11163
|
function buildElement(doc, session, cm, pruner, images) {
|
|
10451
11164
|
if (cm.type === "toolcall") return toolcallElement(doc, session, cm, pruner, images);
|
|
10452
11165
|
const parts = renderCompleteMessageParts(session, cm, pruner);
|
|
10453
11166
|
images.push(...parts.images);
|
|
10454
|
-
const el = doc.createElement(cm.type === "user" ? "user_message" : "assistant");
|
|
11167
|
+
const el = doc.createElement(cm.type === "user" ? "user_message" : cm.type === "skill" ? "skill_content" : "assistant");
|
|
10455
11168
|
el.setAttribute("index", String(cm.index));
|
|
11169
|
+
if (cm.type === "skill" && cm.skillName !== void 0) el.setAttribute("name", cm.skillName);
|
|
10456
11170
|
if (cm.type === "assistant") el.setAttribute("type", "text");
|
|
10457
11171
|
appendBodyText(doc, el, parts.text);
|
|
10458
11172
|
appendImageComments(doc, el, parts.images);
|
|
@@ -10460,6 +11174,13 @@ function buildElement(doc, session, cm, pruner, images) {
|
|
|
10460
11174
|
}
|
|
10461
11175
|
/** 主渲染失败时的回退元素:按完整消息类别输出最简形态,正文为回退文本。 */
|
|
10462
11176
|
function fallbackElement(doc, cm, text) {
|
|
11177
|
+
if (cm.type === "skill") {
|
|
11178
|
+
const el = doc.createElement("skill_content");
|
|
11179
|
+
el.setAttribute("index", String(cm.index));
|
|
11180
|
+
if (cm.skillName !== void 0) el.setAttribute("name", cm.skillName);
|
|
11181
|
+
appendBodyText(doc, el, text);
|
|
11182
|
+
return el;
|
|
11183
|
+
}
|
|
10463
11184
|
const el = doc.createElement(cm.type === "user" ? "user_message" : "assistant");
|
|
10464
11185
|
el.setAttribute("index", String(cm.index));
|
|
10465
11186
|
if (cm.type !== "user") el.setAttribute("type", cm.type === "toolcall" ? "toolcall" : "text");
|
|
@@ -10762,6 +11483,53 @@ function buildRecallTool(options) {
|
|
|
10762
11483
|
};
|
|
10763
11484
|
}
|
|
10764
11485
|
//#endregion
|
|
11486
|
+
//#region src/recompress-gate.ts
|
|
11487
|
+
/** 当前持有许可的数量。 */
|
|
11488
|
+
let active = 0;
|
|
11489
|
+
/** 排队中的请求(先进先出)。 */
|
|
11490
|
+
const queue = [];
|
|
11491
|
+
/** 按各自上限唤醒队首请求,直到许可用尽。 */
|
|
11492
|
+
function drain() {
|
|
11493
|
+
while (queue.length > 0) {
|
|
11494
|
+
const head = queue[0];
|
|
11495
|
+
if (head === void 0 || active >= Math.max(1, head.limit())) return;
|
|
11496
|
+
queue.shift();
|
|
11497
|
+
head.grant();
|
|
11498
|
+
}
|
|
11499
|
+
}
|
|
11500
|
+
/** 获取一个重压缩许可,返回幂等的 release;signal 中止时拒绝。 */
|
|
11501
|
+
function acquireRecompressSlot(limit, signal) {
|
|
11502
|
+
return new Promise((resolve, reject) => {
|
|
11503
|
+
if (signal?.aborted === true) {
|
|
11504
|
+
reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
|
|
11505
|
+
return;
|
|
11506
|
+
}
|
|
11507
|
+
const grant = () => {
|
|
11508
|
+
signal?.removeEventListener("abort", onAbort);
|
|
11509
|
+
active++;
|
|
11510
|
+
let released = false;
|
|
11511
|
+
resolve(() => {
|
|
11512
|
+
if (released) return;
|
|
11513
|
+
released = true;
|
|
11514
|
+
active--;
|
|
11515
|
+
drain();
|
|
11516
|
+
});
|
|
11517
|
+
};
|
|
11518
|
+
const waiter = {
|
|
11519
|
+
limit,
|
|
11520
|
+
grant
|
|
11521
|
+
};
|
|
11522
|
+
const onAbort = () => {
|
|
11523
|
+
const index = queue.indexOf(waiter);
|
|
11524
|
+
if (index >= 0) queue.splice(index, 1);
|
|
11525
|
+
reject(signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
|
|
11526
|
+
};
|
|
11527
|
+
signal?.addEventListener("abort", onAbort, { once: true });
|
|
11528
|
+
queue.push(waiter);
|
|
11529
|
+
drain();
|
|
11530
|
+
});
|
|
11531
|
+
}
|
|
11532
|
+
//#endregion
|
|
10765
11533
|
//#region src/recompress.ts
|
|
10766
11534
|
/** 命令行用法提示。 */
|
|
10767
11535
|
const USAGE = "用法:/om-recompress <compactionId> <provider> <model> [思考等级]";
|
|
@@ -10813,6 +11581,31 @@ function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
|
|
|
10813
11581
|
}), { skipReasoning });
|
|
10814
11582
|
return buildObserveView(session, shadowedSeqs, { skipReasoning });
|
|
10815
11583
|
}
|
|
11584
|
+
/** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
|
|
11585
|
+
function compactionView(session, compactionId, skipReasoning) {
|
|
11586
|
+
const lifecycle = findLifecycle(session, compactionId);
|
|
11587
|
+
if (lifecycle.phase === void 0 && lifecycle.summary === void 0) return { error: `未找到压缩 ${compactionId}` };
|
|
11588
|
+
const summary = lifecycle.summary;
|
|
11589
|
+
if (summary === void 0 || lifecycle.end === void 0 || lifecycle.end.error !== void 0) return { error: `压缩 ${compactionId} 未成功完成,无法重压缩` };
|
|
11590
|
+
const shadowedSeqs = (summary.shadowedSeqs ?? []).map(Number);
|
|
11591
|
+
if (shadowedSeqs.length === 0) return { error: `压缩 ${compactionId} 缺少 shadowedSeqs,无法重放` };
|
|
11592
|
+
const firstEvent = session.snapshotEvents()[shadowedSeqs[0] ?? -1];
|
|
11593
|
+
const phase = lifecycle.phase ?? (historyTextOf(firstEvent) === void 0 ? "observe" : "reflect");
|
|
11594
|
+
const view = rebuildView(session, phase, shadowedSeqs, skipReasoning);
|
|
11595
|
+
if (typeof view === "string") return { error: view };
|
|
11596
|
+
const { minIndex, maxIndex } = view;
|
|
11597
|
+
if (minIndex === void 0 || maxIndex === void 0) return { error: `压缩 ${compactionId} 的原内容无可定位条目` };
|
|
11598
|
+
const originalChars = summary.shadowedCharCount ?? (phase === "observe" ? seqsCharCount(session, shadowedSeqs) : viewCharCount(view));
|
|
11599
|
+
return {
|
|
11600
|
+
phase,
|
|
11601
|
+
view: {
|
|
11602
|
+
...view,
|
|
11603
|
+
minIndex,
|
|
11604
|
+
maxIndex
|
|
11605
|
+
},
|
|
11606
|
+
originalChars
|
|
11607
|
+
};
|
|
11608
|
+
}
|
|
10816
11609
|
/**
|
|
10817
11610
|
* 对已成功的 compaction 用目标模型重压缩一次。校验失败、压缩循环失败均以
|
|
10818
11611
|
* { ok: false } 返回,不抛错;会话本身不被修改(见文件头说明)。
|
|
@@ -10823,32 +11616,12 @@ async function recompress(ctx, agent, config, request, signal) {
|
|
|
10823
11616
|
ok: false,
|
|
10824
11617
|
error: "重压缩仅支持主会话"
|
|
10825
11618
|
};
|
|
10826
|
-
const
|
|
10827
|
-
if (
|
|
10828
|
-
ok: false,
|
|
10829
|
-
error: `未找到压缩 ${request.compactionId}`
|
|
10830
|
-
};
|
|
10831
|
-
const summary = lifecycle.summary;
|
|
10832
|
-
if (summary === void 0 || lifecycle.end === void 0 || lifecycle.end.error !== void 0) return {
|
|
10833
|
-
ok: false,
|
|
10834
|
-
error: `压缩 ${request.compactionId} 未成功完成,无法重压缩`
|
|
10835
|
-
};
|
|
10836
|
-
const shadowedSeqs = (summary.shadowedSeqs ?? []).map(Number);
|
|
10837
|
-
if (shadowedSeqs.length === 0) return {
|
|
10838
|
-
ok: false,
|
|
10839
|
-
error: `压缩 ${request.compactionId} 缺少 shadowedSeqs,无法重放`
|
|
10840
|
-
};
|
|
10841
|
-
const firstEvent = session.snapshotEvents()[shadowedSeqs[0] ?? -1];
|
|
10842
|
-
const phase = lifecycle.phase ?? (historyTextOf(firstEvent) === void 0 ? "observe" : "reflect");
|
|
10843
|
-
const view = rebuildView(session, phase, shadowedSeqs, config.compressSkipReasoning);
|
|
10844
|
-
if (typeof view === "string") return {
|
|
10845
|
-
ok: false,
|
|
10846
|
-
error: view
|
|
10847
|
-
};
|
|
10848
|
-
if (view.minIndex === void 0 || view.maxIndex === void 0) return {
|
|
11619
|
+
const replay = compactionView(session, request.compactionId, config.compressSkipReasoning);
|
|
11620
|
+
if ("error" in replay) return {
|
|
10849
11621
|
ok: false,
|
|
10850
|
-
error:
|
|
11622
|
+
error: replay.error
|
|
10851
11623
|
};
|
|
11624
|
+
const { phase, view, originalChars } = replay;
|
|
10852
11625
|
if (signal?.aborted === true) return {
|
|
10853
11626
|
ok: false,
|
|
10854
11627
|
error: COMPACTION_ABORTED_ERROR
|
|
@@ -10858,7 +11631,6 @@ async function recompress(ctx, agent, config, request, signal) {
|
|
|
10858
11631
|
model: request.model
|
|
10859
11632
|
};
|
|
10860
11633
|
makeLogger(ctx, config.debug).step(`重压缩:${request.compactionId}(${phase})→ ${target.provider}/${target.model}${request.reasoningEffort === void 0 ? "" : ` · ${request.reasoningEffort}`}`);
|
|
10861
|
-
const originalChars = summary.shadowedCharCount ?? (phase === "observe" ? seqsCharCount(session, shadowedSeqs) : viewCharCount(view));
|
|
10862
11634
|
const outcome = await runCompressionLoop(ctx, session, {
|
|
10863
11635
|
view,
|
|
10864
11636
|
originalChars,
|
|
@@ -10869,7 +11641,7 @@ async function recompress(ctx, agent, config, request, signal) {
|
|
|
10869
11641
|
rateLimitWaitMs: config.rateLimitWaitMs,
|
|
10870
11642
|
skipReasoning: config.compressSkipReasoning,
|
|
10871
11643
|
debug: config.debug,
|
|
10872
|
-
|
|
11644
|
+
retry: true,
|
|
10873
11645
|
...request.reasoningEffort === void 0 ? {} : { reasoningEffort: request.reasoningEffort },
|
|
10874
11646
|
...signal === void 0 ? {} : { signal }
|
|
10875
11647
|
});
|
|
@@ -10909,15 +11681,31 @@ function buildRecompressCommand(ctx, getConfig) {
|
|
|
10909
11681
|
kind: "error",
|
|
10910
11682
|
text: parsed.error
|
|
10911
11683
|
};
|
|
10912
|
-
|
|
10913
|
-
|
|
10914
|
-
|
|
10915
|
-
|
|
10916
|
-
|
|
10917
|
-
|
|
10918
|
-
|
|
10919
|
-
|
|
10920
|
-
|
|
11684
|
+
let release;
|
|
11685
|
+
try {
|
|
11686
|
+
release = await acquireRecompressSlot(() => getConfig().recompressConcurrency, signal);
|
|
11687
|
+
} catch {
|
|
11688
|
+
return {
|
|
11689
|
+
kind: "error",
|
|
11690
|
+
text: describeResult(parsed.request, {
|
|
11691
|
+
ok: false,
|
|
11692
|
+
error: COMPACTION_ABORTED_ERROR
|
|
11693
|
+
})
|
|
11694
|
+
};
|
|
11695
|
+
}
|
|
11696
|
+
try {
|
|
11697
|
+
const result = await recompress(ctx, agent, getConfig(), parsed.request, signal);
|
|
11698
|
+
const text = describeResult(parsed.request, result);
|
|
11699
|
+
return result.ok ? {
|
|
11700
|
+
kind: "success",
|
|
11701
|
+
text
|
|
11702
|
+
} : {
|
|
11703
|
+
kind: "error",
|
|
11704
|
+
text
|
|
11705
|
+
};
|
|
11706
|
+
} finally {
|
|
11707
|
+
release();
|
|
11708
|
+
}
|
|
10921
11709
|
}
|
|
10922
11710
|
};
|
|
10923
11711
|
}
|
|
@@ -11040,16 +11828,128 @@ function ensureSystemReminders(session, messages, reminders, idle = DEFAULT_PROG
|
|
|
11040
11828
|
return result;
|
|
11041
11829
|
}
|
|
11042
11830
|
//#endregion
|
|
11831
|
+
//#region src/thinking-binding.ts
|
|
11832
|
+
/**
|
|
11833
|
+
* Claude thinking 签名前缀绑定修复:Claude 的 thinking 签名绑定其前全部内容,OM 替换后
|
|
11834
|
+
* 保留尾部中压缩前生成的签名失效,请求返回 400。发出请求前剥离这些消息的 reasoning。
|
|
11835
|
+
* 导出 staleAssistantIds / isAnthropicSigned / stripReasoning / sanitizeMessages /
|
|
11836
|
+
* registerThinkingBinding。
|
|
11837
|
+
*
|
|
11838
|
+
* - 分界:表层最后一条 source.kind 为插件 kind 的 user/message,其 seq 恒为 OM 消息最大
|
|
11839
|
+
* - 过期:分界之后 seq 小于分界的 assistant/message,即生成于该次替换之前
|
|
11840
|
+
* - 仅剥离 Anthropic 签名:replayState api 为 Anthropic 协议、模型名含 claude-、
|
|
11841
|
+
* 且带签名或 redacted 的 reasoning;其余模型的签名校验不绑定前缀,保持原样
|
|
11842
|
+
*/
|
|
11843
|
+
/** 签名绑定前缀的 Anthropic 协议(pi-ai replayState.response.api)。 */
|
|
11844
|
+
const ANTHROPIC_APIS = /* @__PURE__ */ new Set(["anthropic-messages", "bedrock-converse-stream"]);
|
|
11845
|
+
/** Claude 模型名:匹配 claude-xx,兼容 anthropic/claude-xx 与 us.anthropic.claude-xx。 */
|
|
11846
|
+
const CLAUDE_MODEL = /\bclaude-/i;
|
|
11847
|
+
/** 判定 JSON 值为普通对象(replayState 为宿主声明的 unknown,须逐层收窄)。 */
|
|
11848
|
+
function isRecord(value) {
|
|
11849
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
11850
|
+
}
|
|
11851
|
+
/** 返回前缀已被最后一条 OM 消息改写的 assistant 消息 id;无 OM 消息时为空。 */
|
|
11852
|
+
function staleAssistantIds(session) {
|
|
11853
|
+
const stale = /* @__PURE__ */ new Set();
|
|
11854
|
+
const events = session.snapshotEvents();
|
|
11855
|
+
const nodes = session.surface.nodes;
|
|
11856
|
+
let boundary = -1;
|
|
11857
|
+
for (let i = nodes.length - 1; i >= 0; i -= 1) {
|
|
11858
|
+
const seq = nodes[i];
|
|
11859
|
+
const event = seq === void 0 ? void 0 : events[seq];
|
|
11860
|
+
if (event?.type === "user/message" && event.data.source?.kind === "plugin:dsh-plugin-om") {
|
|
11861
|
+
boundary = i;
|
|
11862
|
+
break;
|
|
11863
|
+
}
|
|
11864
|
+
}
|
|
11865
|
+
const boundarySeq = nodes[boundary];
|
|
11866
|
+
if (boundarySeq === void 0) return stale;
|
|
11867
|
+
for (const seq of nodes.slice(boundary + 1)) {
|
|
11868
|
+
const event = events[seq];
|
|
11869
|
+
if (event?.type === "assistant/message" && seq < boundarySeq) stale.add(event.data.message.id);
|
|
11870
|
+
}
|
|
11871
|
+
return stale;
|
|
11872
|
+
}
|
|
11873
|
+
/** 判定 assistant 消息带 Claude 经 Anthropic 协议签名的 reasoning。 */
|
|
11874
|
+
function isAnthropicSigned(message) {
|
|
11875
|
+
const { model, replayState } = message.source;
|
|
11876
|
+
if (!CLAUDE_MODEL.test(model) || !isRecord(replayState)) return false;
|
|
11877
|
+
const { response, blocks } = replayState;
|
|
11878
|
+
if (!isRecord(response) || typeof response.api !== "string") return false;
|
|
11879
|
+
if (!ANTHROPIC_APIS.has(response.api) || !Array.isArray(blocks)) return false;
|
|
11880
|
+
return blocks.some((block) => isRecord(block) && block.type === "reasoning" && (typeof block.thinkingSignature === "string" && block.thinkingSignature.length > 0 || block.redacted === true));
|
|
11881
|
+
}
|
|
11882
|
+
/** 去掉 reasoning 块与 replayState,保留 text 与 tool-call;剥离后无内容返回 undefined。 */
|
|
11883
|
+
function stripReasoning(message) {
|
|
11884
|
+
const content = message.content.filter((block) => block.type !== "reasoning");
|
|
11885
|
+
if (content.length === 0) return void 0;
|
|
11886
|
+
const { provider, model } = message.source;
|
|
11887
|
+
return freezeMessage({
|
|
11888
|
+
...message,
|
|
11889
|
+
content,
|
|
11890
|
+
source: {
|
|
11891
|
+
kind: "model",
|
|
11892
|
+
provider,
|
|
11893
|
+
model
|
|
11894
|
+
}
|
|
11895
|
+
});
|
|
11896
|
+
}
|
|
11897
|
+
/** 剥离过期消息的 Anthropic 签名 reasoning;无改动返回 undefined。 */
|
|
11898
|
+
function sanitizeMessages(session, messages) {
|
|
11899
|
+
const stale = staleAssistantIds(session);
|
|
11900
|
+
if (stale.size === 0) return void 0;
|
|
11901
|
+
let changed = false;
|
|
11902
|
+
const result = [];
|
|
11903
|
+
for (const message of messages) {
|
|
11904
|
+
if (message.role === "assistant" && stale.has(message.id) && isAnthropicSigned(message)) {
|
|
11905
|
+
changed = true;
|
|
11906
|
+
const stripped = stripReasoning(message);
|
|
11907
|
+
if (stripped !== void 0) result.push(stripped);
|
|
11908
|
+
continue;
|
|
11909
|
+
}
|
|
11910
|
+
result.push(message);
|
|
11911
|
+
}
|
|
11912
|
+
return changed ? result : void 0;
|
|
11913
|
+
}
|
|
11914
|
+
/**
|
|
11915
|
+
* 注册前置 llm/stream 中间件:会话请求需剥离时以新 options 重新调用 llm.stream,
|
|
11916
|
+
* 保留 agent loop 标记;重新进入的请求直接放行。辅助调用(purpose)不处理。
|
|
11917
|
+
*/
|
|
11918
|
+
function registerThinkingBinding(ctx, logger) {
|
|
11919
|
+
/** 已剥离并重新发出的请求,再次进入时直接放行。 */
|
|
11920
|
+
const rewritten = /* @__PURE__ */ new WeakSet();
|
|
11921
|
+
ctx.on("llm/stream", (options, next) => {
|
|
11922
|
+
if (rewritten.has(options) || options.sessionId === void 0) return next();
|
|
11923
|
+
if (options.purpose !== void 0) return next();
|
|
11924
|
+
const session = ctx.sessions.get(options.sessionId);
|
|
11925
|
+
if (session === void 0) return next();
|
|
11926
|
+
let messages;
|
|
11927
|
+
try {
|
|
11928
|
+
messages = sanitizeMessages(session, options.messages);
|
|
11929
|
+
} catch (error) {
|
|
11930
|
+
logger.warn(`thinking 签名剥离失败,按原请求发送: ${error instanceof Error ? error.message : String(error)}`);
|
|
11931
|
+
return next();
|
|
11932
|
+
}
|
|
11933
|
+
if (messages === void 0) return next();
|
|
11934
|
+
const request = {
|
|
11935
|
+
...options,
|
|
11936
|
+
messages
|
|
11937
|
+
};
|
|
11938
|
+
if (isAgentLoopRequest(options)) markAgentLoopRequest(request);
|
|
11939
|
+
rewritten.add(request);
|
|
11940
|
+
logger.step(`剥离压缩前生成的 Claude thinking 签名后重发请求(会话 ${session.id})`);
|
|
11941
|
+
return ctx.llm.stream(request);
|
|
11942
|
+
}, { prepend: true });
|
|
11943
|
+
}
|
|
11944
|
+
//#endregion
|
|
11043
11945
|
//#region src/index.ts
|
|
11044
11946
|
/** 插件名(Loader 识别入口的稳定标识)。 */
|
|
11045
11947
|
const name = "dsh-plugin-om";
|
|
11046
|
-
/**
|
|
11047
|
-
|
|
11048
|
-
|
|
11049
|
-
|
|
11050
|
-
|
|
11051
|
-
"sessions"
|
|
11052
|
-
];
|
|
11948
|
+
/**
|
|
11949
|
+
* 插件必需的服务依赖:压缩请求(llm)与上下文压力计量(tokenMeter)。
|
|
11950
|
+
* tools / commands / sessions 等为可选能力,缺失时对应功能自动停用。
|
|
11951
|
+
*/
|
|
11952
|
+
const inject = ["llm", "tokenMeter"];
|
|
11053
11953
|
/** 插件激活入口:解析配置、注册工具、接线 pre-step 自动压缩与提醒补发。 */
|
|
11054
11954
|
function apply(ctx, config) {
|
|
11055
11955
|
const resolved = currentConfig(config);
|
|
@@ -11057,39 +11957,51 @@ function apply(ctx, config) {
|
|
|
11057
11957
|
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 ?? "模型默认"}`);
|
|
11058
11958
|
const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
|
|
11059
11959
|
const logModel = (message) => logger.info(message);
|
|
11060
|
-
|
|
11061
|
-
|
|
11062
|
-
|
|
11063
|
-
|
|
11064
|
-
|
|
11065
|
-
|
|
11066
|
-
|
|
11067
|
-
|
|
11068
|
-
|
|
11960
|
+
if (resolved.recallEnabled && ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
|
|
11961
|
+
if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
|
|
11962
|
+
ctx.inject(["tools"], (inner) => {
|
|
11963
|
+
let disposeRecall;
|
|
11964
|
+
/** 当前已注册 recall 对应的语义增强开关与模型目录。 */
|
|
11965
|
+
let registered;
|
|
11966
|
+
/** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
|
|
11967
|
+
const syncTools = () => {
|
|
11968
|
+
const next = currentConfig(config);
|
|
11969
|
+
const semantic = next.recallEnabled && next.semanticRecallEnabled;
|
|
11970
|
+
if (disposeRecall && (!next.recallEnabled || registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
|
|
11971
|
+
disposeRecall();
|
|
11972
|
+
disposeRecall = void 0;
|
|
11973
|
+
registered = void 0;
|
|
11974
|
+
}
|
|
11975
|
+
if (next.recallEnabled && !disposeRecall) {
|
|
11976
|
+
const directory = next.modelDir;
|
|
11977
|
+
disposeRecall = inner.tools.register(buildRecallTool({
|
|
11978
|
+
getPruner: () => inner.get("toolResultPruner"),
|
|
11979
|
+
...semantic ? { semantic: {
|
|
11980
|
+
modelStatus: () => ensureModelReady(directory, warnModel, void 0, logModel),
|
|
11981
|
+
embedder: (texts) => getEmbedder(directory).then((embed) => embed(texts))
|
|
11982
|
+
} } : {}
|
|
11983
|
+
}));
|
|
11984
|
+
registered = {
|
|
11985
|
+
semantic,
|
|
11986
|
+
modelDir: directory
|
|
11987
|
+
};
|
|
11988
|
+
if (semantic) ensureModelReady(directory, warnModel, void 0, logModel);
|
|
11989
|
+
}
|
|
11990
|
+
};
|
|
11991
|
+
syncTools();
|
|
11992
|
+
inner.on("loader/volatile-update", () => syncTools());
|
|
11993
|
+
inner.effect(() => () => {
|
|
11994
|
+
disposeRecall?.();
|
|
11069
11995
|
disposeRecall = void 0;
|
|
11070
|
-
|
|
11071
|
-
|
|
11072
|
-
if (next.recallEnabled && !disposeRecall) {
|
|
11073
|
-
const directory = next.modelDir;
|
|
11074
|
-
disposeRecall = ctx.tools.register(buildRecallTool({
|
|
11075
|
-
getPruner: () => ctx.get("toolResultPruner"),
|
|
11076
|
-
...semantic ? { semantic: {
|
|
11077
|
-
modelStatus: () => ensureModelReady(directory, warnModel, void 0, logModel),
|
|
11078
|
-
embedder: (texts) => getEmbedder(directory).then((embed) => embed(texts))
|
|
11079
|
-
} } : {}
|
|
11080
|
-
}));
|
|
11081
|
-
registered = {
|
|
11082
|
-
semantic,
|
|
11083
|
-
modelDir: directory
|
|
11084
|
-
};
|
|
11085
|
-
if (semantic) ensureModelReady(directory, warnModel, void 0, logModel);
|
|
11086
|
-
}
|
|
11087
|
-
}
|
|
11088
|
-
syncTools();
|
|
11089
|
-
ctx.on("loader/volatile-update", () => syncTools());
|
|
11996
|
+
}, "dsh-plugin-om: recall tool");
|
|
11997
|
+
});
|
|
11090
11998
|
ctx.inject(["commands"], (inner) => {
|
|
11091
11999
|
inner.effect(() => inner.commands.register(buildRecompressCommand(ctx, () => currentConfig(config))), "dsh-plugin-om: recompress command");
|
|
12000
|
+
inner.effect(() => inner.commands.register(buildCompactionEvalCommand(ctx)), "dsh-plugin-om: compaction eval command");
|
|
11092
12001
|
});
|
|
12002
|
+
ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
|
|
12003
|
+
ctx.on("session/disposed", (session) => disposePrecompression(session.id));
|
|
12004
|
+
ctx.effect(() => () => disposeAllPrecompressions(), "dsh-plugin-om: precompression registry");
|
|
11093
12005
|
ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
|
|
11094
12006
|
let outcome = { failed: false };
|
|
11095
12007
|
try {
|