dsh-plugin-om 0.0.48 → 0.0.50
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 +14 -7
- package/dist/client/OmCompactionCard.d.ts +8 -1
- package/dist/client/OmCompactionCard.d.ts.map +1 -1
- package/dist/client/OmWarningCard.d.ts +2 -2
- package/dist/client/definition.d.ts +10 -6
- package/dist/client/definition.d.ts.map +1 -1
- package/dist/client/index.d.ts +1 -1
- package/dist/client/index.d.ts.map +1 -1
- package/dist/client/locales.d.ts +1 -0
- package/dist/client/locales.d.ts.map +1 -1
- package/dist/client.js +98 -46
- package/dist/client.js.map +1 -1
- package/dist/compaction-log.d.ts +17 -24
- package/dist/compaction-log.d.ts.map +1 -1
- package/dist/compress-loop.d.ts.map +1 -1
- package/dist/compress.d.ts +4 -2
- package/dist/compress.d.ts.map +1 -1
- package/dist/degrade.d.ts +6 -5
- package/dist/degrade.d.ts.map +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +206 -194
- package/dist/om-event.d.ts +27 -14
- package/dist/om-event.d.ts.map +1 -1
- package/dist/system-reminder.d.ts +2 -2
- package/dist/system-reminder.d.ts.map +1 -1
- package/dist/types.d.ts +9 -16
- package/dist/types.d.ts.map +1 -1
- package/package.json +4 -2
package/dist/index.mjs
CHANGED
|
@@ -190,162 +190,149 @@ function phaseLabel(phase) {
|
|
|
190
190
|
function compressionRecordLabel(phase, rounds, success) {
|
|
191
191
|
return `OM 压缩${success ? "会话记录" : "失败日志"}(${phaseLabel(phase)} · ${rounds} 轮)`;
|
|
192
192
|
}
|
|
193
|
-
/**
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
function
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
const sum = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
|
|
208
|
-
const merged = {
|
|
209
|
-
inputTokens: (total.inputTokens ?? 0) + (round.usage.inputTokens ?? 0),
|
|
210
|
-
outputTokens: (total.outputTokens ?? 0) + (round.usage.outputTokens ?? 0)
|
|
211
|
-
};
|
|
212
|
-
const cacheRead = sum(total.cacheReadTokens, round.usage.cacheReadTokens);
|
|
213
|
-
const cacheWrite = sum(total.cacheWriteTokens, round.usage.cacheWriteTokens);
|
|
214
|
-
const reasoning = sum(total.reasoningTokens, round.usage.reasoningTokens);
|
|
215
|
-
if (cacheRead !== void 0) merged.cacheReadTokens = cacheRead;
|
|
216
|
-
if (cacheWrite !== void 0) merged.cacheWriteTokens = cacheWrite;
|
|
217
|
-
if (reasoning !== void 0) merged.reasoningTokens = reasoning;
|
|
218
|
-
total = merged;
|
|
219
|
-
}
|
|
220
|
-
return total;
|
|
193
|
+
/**
|
|
194
|
+
* 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
|
|
195
|
+
* 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
|
|
196
|
+
* time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
|
|
197
|
+
* 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
|
|
198
|
+
*/
|
|
199
|
+
function seedEvent(type, seq, time, data, surfaceOp) {
|
|
200
|
+
return {
|
|
201
|
+
type,
|
|
202
|
+
seq,
|
|
203
|
+
time,
|
|
204
|
+
data,
|
|
205
|
+
...surfaceOp === void 0 ? {} : { surfaceOp }
|
|
206
|
+
};
|
|
221
207
|
}
|
|
222
208
|
/**
|
|
223
|
-
*
|
|
224
|
-
*
|
|
209
|
+
* 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
|
|
210
|
+
* 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
|
|
211
|
+
* 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
|
|
212
|
+
* 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
|
|
213
|
+
* 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
|
|
214
|
+
* 轮结束时刻与循环结束时刻。
|
|
225
215
|
*/
|
|
226
|
-
function
|
|
227
|
-
const
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
}
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
216
|
+
function buildCompressionSeed(messages, stats, label) {
|
|
217
|
+
const seed = [];
|
|
218
|
+
const push = (type, time, data, surfaceOp) => {
|
|
219
|
+
seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
|
|
220
|
+
};
|
|
221
|
+
let cursor = stats.startedAt;
|
|
222
|
+
const at = (time) => {
|
|
223
|
+
cursor = Math.max(cursor, time);
|
|
224
|
+
return cursor;
|
|
225
|
+
};
|
|
226
|
+
const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
|
|
227
|
+
push("subagent/descriptor", at(stats.startedAt), {
|
|
228
|
+
version: SUBAGENT_DESCRIPTOR_VERSION,
|
|
229
|
+
mode: "one-shot",
|
|
230
|
+
provider: COMPACTION_LOG_PROVIDER,
|
|
231
|
+
label
|
|
232
|
+
});
|
|
233
|
+
push("turn/start", at(stats.startedAt), { turn: 1 });
|
|
234
|
+
let step = 0;
|
|
235
|
+
let assistantIndex = 0;
|
|
236
|
+
let stepTime = stats.startedAt;
|
|
237
|
+
let pending = [];
|
|
238
|
+
const closeStep = () => {
|
|
239
|
+
if (step === 0) return;
|
|
240
|
+
for (const call of pending) {
|
|
241
|
+
if (executed.has(call.id)) continue;
|
|
242
|
+
const repair = createToolResultMessage({
|
|
243
|
+
callId: call.id,
|
|
244
|
+
content: [{
|
|
245
|
+
type: "text",
|
|
246
|
+
text: "压缩循环未执行此工具调用"
|
|
247
|
+
}],
|
|
248
|
+
isError: true
|
|
249
|
+
});
|
|
250
|
+
push("tool/result", at(stepTime), {
|
|
251
|
+
turn: 1,
|
|
252
|
+
step,
|
|
253
|
+
message: {
|
|
254
|
+
...repair,
|
|
255
|
+
id: `forked-tool-result-${call.id}-${uuid()}`
|
|
256
|
+
},
|
|
257
|
+
error: {
|
|
258
|
+
name: "ToolNotStartedError",
|
|
259
|
+
code: "TOOL_NOT_STARTED"
|
|
260
|
+
}
|
|
261
|
+
}, "append");
|
|
262
|
+
}
|
|
263
|
+
push("step/end", at(stepTime), {
|
|
264
|
+
turn: 1,
|
|
265
|
+
step
|
|
266
|
+
});
|
|
267
|
+
pending = [];
|
|
268
|
+
};
|
|
269
|
+
for (const message of messages) if (message.role === "assistant") {
|
|
270
|
+
closeStep();
|
|
271
|
+
step += 1;
|
|
272
|
+
const round = stats.rounds[assistantIndex];
|
|
273
|
+
assistantIndex += 1;
|
|
274
|
+
const startAt = round?.startedAt ?? stepTime;
|
|
275
|
+
const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
|
|
276
|
+
push("step/start", at(startAt), {
|
|
277
|
+
turn: 1,
|
|
278
|
+
step
|
|
279
|
+
});
|
|
280
|
+
const assistant = message;
|
|
281
|
+
const assistantTime = at(completedAt);
|
|
282
|
+
push("assistant/message", assistantTime, {
|
|
283
|
+
turn: 1,
|
|
284
|
+
step,
|
|
285
|
+
message: assistant,
|
|
286
|
+
stream: [],
|
|
287
|
+
...round?.usage === void 0 ? {} : { usage: round.usage }
|
|
288
|
+
}, "append");
|
|
289
|
+
stepTime = assistantTime;
|
|
290
|
+
pending = assistant.content.filter((block) => block.type === "tool-call");
|
|
291
|
+
for (const call of pending) {
|
|
292
|
+
if (!executed.has(call.id)) continue;
|
|
293
|
+
push("tool/call", at(stepTime), {
|
|
294
|
+
turn: 1,
|
|
295
|
+
step,
|
|
296
|
+
callId: call.id,
|
|
297
|
+
name: call.name,
|
|
298
|
+
arguments: call.arguments
|
|
299
|
+
});
|
|
300
|
+
}
|
|
301
|
+
} else if (message.role === "tool") push("tool/result", at(stepTime), {
|
|
302
|
+
turn: 1,
|
|
303
|
+
step,
|
|
304
|
+
message
|
|
305
|
+
}, "append");
|
|
306
|
+
else push("user/message", at(step === 0 ? stats.startedAt : stepTime), message, "append");
|
|
307
|
+
closeStep();
|
|
308
|
+
push("turn/end", at(stats.completedAt), {
|
|
309
|
+
turn: 1,
|
|
310
|
+
reason: { kind: "completed" }
|
|
251
311
|
});
|
|
312
|
+
return seed;
|
|
252
313
|
}
|
|
253
314
|
/**
|
|
254
|
-
*
|
|
255
|
-
*
|
|
256
|
-
* cwd
|
|
257
|
-
*
|
|
258
|
-
*
|
|
259
|
-
*
|
|
260
|
-
* 落盘自身绝不抛错,任何失败仅 logger.warn 并返回 undefined。
|
|
315
|
+
* 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
|
|
316
|
+
* ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
|
|
317
|
+
* delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
|
|
318
|
+
* om-compaction-log,label 含压缩阶段与轮数),flush 持久化,在父会话登记
|
|
319
|
+
* subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
|
|
320
|
+
* logger.warn 并返回 undefined。
|
|
261
321
|
*/
|
|
262
322
|
async function recordCompressionSession(ctx, parentSession, options) {
|
|
263
323
|
const logger = makeLogger(ctx, options.debug);
|
|
264
324
|
try {
|
|
265
325
|
const header = parentSession.header;
|
|
266
|
-
const child = ctx.sessions.create(SessionId(`om-compaction-log-${uuid()}`), { meta: {
|
|
267
|
-
...header.cwd === void 0 ? {} : { cwd: header.cwd },
|
|
268
|
-
parentSession: parentSession.id,
|
|
269
|
-
origin: "subagent",
|
|
270
|
-
delegationDepth: (header.delegationDepth ?? 0) + 1
|
|
271
|
-
} });
|
|
272
326
|
const label = compressionRecordLabel(options.phase, options.stats.rounds.length, options.success);
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
const executed = new Set(options.messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
|
|
282
|
-
let pending = [];
|
|
283
|
-
const closeStep = () => {
|
|
284
|
-
if (step === 0) return;
|
|
285
|
-
for (const call of pending) {
|
|
286
|
-
if (executed.has(call.id)) continue;
|
|
287
|
-
const repair = createToolResultMessage({
|
|
288
|
-
callId: call.id,
|
|
289
|
-
content: [{
|
|
290
|
-
type: "text",
|
|
291
|
-
text: "压缩循环未执行此工具调用"
|
|
292
|
-
}],
|
|
293
|
-
isError: true
|
|
294
|
-
});
|
|
295
|
-
child.append("tool/result", {
|
|
296
|
-
turn: 1,
|
|
297
|
-
step,
|
|
298
|
-
message: {
|
|
299
|
-
...repair,
|
|
300
|
-
id: `forked-tool-result-${call.id}-${uuid()}`
|
|
301
|
-
},
|
|
302
|
-
error: {
|
|
303
|
-
name: "ToolNotStartedError",
|
|
304
|
-
code: "TOOL_NOT_STARTED"
|
|
305
|
-
}
|
|
306
|
-
}, { surfaceOp: "append" });
|
|
307
|
-
}
|
|
308
|
-
child.append("step/end", {
|
|
309
|
-
turn: 1,
|
|
310
|
-
step
|
|
311
|
-
});
|
|
312
|
-
pending = [];
|
|
313
|
-
};
|
|
314
|
-
for (const message of options.messages) if (message.role === "assistant") {
|
|
315
|
-
closeStep();
|
|
316
|
-
step += 1;
|
|
317
|
-
child.append("step/start", {
|
|
318
|
-
turn: 1,
|
|
319
|
-
step
|
|
320
|
-
});
|
|
321
|
-
child.append("assistant/message", {
|
|
322
|
-
turn: 1,
|
|
323
|
-
step,
|
|
324
|
-
message,
|
|
325
|
-
stream: []
|
|
326
|
-
}, { surfaceOp: "append" });
|
|
327
|
-
pending = message.content.filter((block) => block.type === "tool-call");
|
|
328
|
-
for (const call of pending) {
|
|
329
|
-
if (!executed.has(call.id)) continue;
|
|
330
|
-
child.append("tool/call", {
|
|
331
|
-
turn: 1,
|
|
332
|
-
step,
|
|
333
|
-
callId: call.id,
|
|
334
|
-
name: call.name,
|
|
335
|
-
arguments: call.arguments
|
|
336
|
-
});
|
|
327
|
+
const seed = buildCompressionSeed(options.messages, options.stats, label);
|
|
328
|
+
const child = ctx.sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
|
|
329
|
+
seed,
|
|
330
|
+
meta: {
|
|
331
|
+
...header.cwd === void 0 ? {} : { cwd: header.cwd },
|
|
332
|
+
parentSession: parentSession.id,
|
|
333
|
+
origin: "subagent",
|
|
334
|
+
delegationDepth: (header.delegationDepth ?? 0) + 1
|
|
337
335
|
}
|
|
338
|
-
} else if (message.role === "tool") child.append("tool/result", {
|
|
339
|
-
turn: 1,
|
|
340
|
-
step,
|
|
341
|
-
message
|
|
342
|
-
}, { surfaceOp: "append" });
|
|
343
|
-
else child.append("user/message", message, { surfaceOp: "append" });
|
|
344
|
-
closeStep();
|
|
345
|
-
child.append("user/message", makeStatsMessage(formatCompressionStats(options.phase, options.success, options.stats)), { surfaceOp: "append" });
|
|
346
|
-
child.append("turn/end", {
|
|
347
|
-
turn: 1,
|
|
348
|
-
reason: { kind: "completed" }
|
|
349
336
|
});
|
|
350
337
|
const persistence = ctx.get("sessionPersistence");
|
|
351
338
|
if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
|
|
@@ -9024,7 +9011,6 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9024
9011
|
};
|
|
9025
9012
|
const recordSessionId = async (success, stats) => recordCompressionSession(ctx, session, {
|
|
9026
9013
|
phase: options.phase,
|
|
9027
|
-
target: options.target,
|
|
9028
9014
|
messages,
|
|
9029
9015
|
stats,
|
|
9030
9016
|
success,
|
|
@@ -9144,18 +9130,30 @@ async function runCompressionLoop(ctx, session, options) {
|
|
|
9144
9130
|
}
|
|
9145
9131
|
//#endregion
|
|
9146
9132
|
//#region src/om-event.ts
|
|
9147
|
-
/**
|
|
9133
|
+
/** om 信封 text 前缀:标识该 feedback/record 记录由本插件写入。 */
|
|
9134
|
+
const OM_EVENT_PREFIX = "om:1:";
|
|
9135
|
+
/**
|
|
9136
|
+
* 解码一条会话事件为 om 私有事件:仅识别 feedback/record 中带 om 信封前缀的
|
|
9137
|
+
* text;前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
|
|
9138
|
+
*/
|
|
9148
9139
|
function readOmEvent(event) {
|
|
9149
|
-
if (event === void 0 || event === null) return void 0;
|
|
9150
|
-
const
|
|
9151
|
-
if (
|
|
9152
|
-
|
|
9153
|
-
|
|
9154
|
-
|
|
9155
|
-
|
|
9140
|
+
if (event === void 0 || event === null || event.type !== "feedback/record") return void 0;
|
|
9141
|
+
const text = event.data.text;
|
|
9142
|
+
if (typeof text !== "string" || !text.startsWith("om:1:")) return void 0;
|
|
9143
|
+
let envelope;
|
|
9144
|
+
try {
|
|
9145
|
+
envelope = JSON.parse(text.slice(5));
|
|
9146
|
+
} catch {
|
|
9147
|
+
return;
|
|
9148
|
+
}
|
|
9149
|
+
if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) return void 0;
|
|
9150
|
+
const { kind, ...rest } = envelope;
|
|
9151
|
+
switch (kind) {
|
|
9152
|
+
case "om/warning": {
|
|
9153
|
+
const { problem, message } = rest;
|
|
9156
9154
|
if (typeof problem !== "string" || typeof message !== "string") return void 0;
|
|
9157
9155
|
return {
|
|
9158
|
-
kind
|
|
9156
|
+
kind,
|
|
9159
9157
|
data: {
|
|
9160
9158
|
problem,
|
|
9161
9159
|
message
|
|
@@ -9163,20 +9161,20 @@ function readOmEvent(event) {
|
|
|
9163
9161
|
seq: event.seq
|
|
9164
9162
|
};
|
|
9165
9163
|
}
|
|
9166
|
-
case "
|
|
9167
|
-
const { triggerMessageIndex } =
|
|
9164
|
+
case "om/observe-pending": {
|
|
9165
|
+
const { triggerMessageIndex } = rest;
|
|
9168
9166
|
if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
|
|
9169
9167
|
return {
|
|
9170
|
-
kind
|
|
9168
|
+
kind,
|
|
9171
9169
|
data: { triggerMessageIndex },
|
|
9172
9170
|
seq: event.seq
|
|
9173
9171
|
};
|
|
9174
9172
|
}
|
|
9175
|
-
case "
|
|
9176
|
-
const { pendingSeq } =
|
|
9173
|
+
case "om/observe-invalidate": {
|
|
9174
|
+
const { pendingSeq } = rest;
|
|
9177
9175
|
if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
|
|
9178
9176
|
return {
|
|
9179
|
-
kind
|
|
9177
|
+
kind,
|
|
9180
9178
|
data: { pendingSeq },
|
|
9181
9179
|
seq: event.seq
|
|
9182
9180
|
};
|
|
@@ -9184,9 +9182,16 @@ function readOmEvent(event) {
|
|
|
9184
9182
|
default: return;
|
|
9185
9183
|
}
|
|
9186
9184
|
}
|
|
9187
|
-
/**
|
|
9185
|
+
/** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
|
|
9186
|
+
function encodeOmEvent(kind, data) {
|
|
9187
|
+
return `${OM_EVENT_PREFIX}${JSON.stringify({
|
|
9188
|
+
kind,
|
|
9189
|
+
...data
|
|
9190
|
+
})}`;
|
|
9191
|
+
}
|
|
9192
|
+
/** 追加一条 om 私有事件(借用 feedback/record,log-only,不进 surface),返回事件 seq。 */
|
|
9188
9193
|
function appendOmEvent(session, kind, data) {
|
|
9189
|
-
return session.append(kind, data).seq;
|
|
9194
|
+
return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
|
|
9190
9195
|
}
|
|
9191
9196
|
function findOmEvents(session, kind) {
|
|
9192
9197
|
const result = [];
|
|
@@ -9202,35 +9207,36 @@ function findOmEvents(session, kind) {
|
|
|
9202
9207
|
* 降级报告:压缩流程中的挂载失败统一出口。
|
|
9203
9208
|
* 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
|
|
9204
9209
|
*
|
|
9205
|
-
*
|
|
9206
|
-
*
|
|
9207
|
-
*
|
|
9208
|
-
*
|
|
9209
|
-
*
|
|
9210
|
-
*
|
|
9210
|
+
* - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
|
|
9211
|
+
* 并向会话日志追加 log-only 的 om 警告事件(借用 feedback/record 的 om 信封,
|
|
9212
|
+
* 见 om-event.ts;客户端渲染为「功能降级」警告行);
|
|
9213
|
+
* 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
|
|
9214
|
+
* - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
|
|
9215
|
+
* - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
|
|
9211
9216
|
*/
|
|
9212
|
-
/** 各降级问题面向用户的简短说明(
|
|
9217
|
+
/** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
|
|
9213
9218
|
const DEGRADE_PROBLEMS = {
|
|
9214
9219
|
"systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
|
|
9215
9220
|
"tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
|
|
9216
9221
|
"reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
|
|
9217
9222
|
};
|
|
9218
9223
|
/**
|
|
9219
|
-
* 报告一次挂载失败类降级:console.warn
|
|
9220
|
-
* 出现时,向会话日志追加 log-only
|
|
9221
|
-
*
|
|
9224
|
+
* 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
|
|
9225
|
+
* 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
|
|
9226
|
+
* 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
|
|
9227
|
+
* 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
|
|
9222
9228
|
*/
|
|
9223
9229
|
function reportDegrade(session, logger, problem) {
|
|
9224
9230
|
const message = DEGRADE_PROBLEMS[problem];
|
|
9225
9231
|
let first = true;
|
|
9226
9232
|
try {
|
|
9227
|
-
first = !findOmEvents(session, "
|
|
9233
|
+
first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
|
|
9228
9234
|
} catch {}
|
|
9229
9235
|
if (!first) return;
|
|
9230
9236
|
console.warn(`${PLUGIN_LABEL}: ${message}`);
|
|
9231
9237
|
logger.warn(message);
|
|
9232
9238
|
try {
|
|
9233
|
-
appendOmEvent(session, "
|
|
9239
|
+
appendOmEvent(session, "om/warning", {
|
|
9234
9240
|
problem,
|
|
9235
9241
|
message
|
|
9236
9242
|
});
|
|
@@ -9244,7 +9250,7 @@ function reportDegrade(session, logger, problem) {
|
|
|
9244
9250
|
/**
|
|
9245
9251
|
* 两级自动压缩(观察/反思)与 compaction 生命周期提交。
|
|
9246
9252
|
* 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
|
|
9247
|
-
* findObservePending / reflectPass / observePass / maybeCompress。
|
|
9253
|
+
* hasHistoryBlock / findObservePending / reflectPass / observePass / maybeCompress。
|
|
9248
9254
|
*
|
|
9249
9255
|
* - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
|
|
9250
9256
|
* 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
|
|
@@ -9258,8 +9264,8 @@ function reportDegrade(session, logger, problem) {
|
|
|
9258
9264
|
* tailMessageCount 时,把压缩边界至触发点的全部消息作为压缩视图替换为新 <history>
|
|
9259
9265
|
* 块(旧块保留),等待期间的新消息成为下一轮未压缩尾部(延迟窗口内压力允许
|
|
9260
9266
|
* 短暂超阈值);tailMessageCount=0 时触发当轮直接执行(不落待定标记)
|
|
9261
|
-
* - 待定标记以 log-only
|
|
9262
|
-
*
|
|
9267
|
+
* - 待定标记以 log-only om 信封事件(借用 feedback/record,kind 为 om/observe-pending /
|
|
9268
|
+
* om/observe-invalidate,见 om-event.ts)持久化在会话日志中(重启后从日志恢复);
|
|
9263
9269
|
* 压缩失败保留待定,下个 pre-step 直接重试执行
|
|
9264
9270
|
* - 两级在 pre-step 阻塞串行执行(先反思后观察);仅主会话生效;omEnabled=false 关闭
|
|
9265
9271
|
* - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
|
|
@@ -9274,7 +9280,7 @@ function reportDegrade(session, logger, problem) {
|
|
|
9274
9280
|
* - 提交走宿主 compaction/* 生命周期事件(start 带 phase → summary → 替换消息 → end),
|
|
9275
9281
|
* 失败补 end(error,实际报错 + 诊断子会话 sessionId);替换消息 source 标记插件标识供 UI 认领
|
|
9276
9282
|
* - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
|
|
9277
|
-
* log-only
|
|
9283
|
+
* log-only om 警告事件(借用 feedback/record,客户端渲染功能降级警告行,每会话同一
|
|
9278
9284
|
* 问题至多一次);
|
|
9279
9285
|
* 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 压力数据
|
|
9280
9286
|
* 缺失时本轮跳过观察)
|
|
@@ -9446,9 +9452,14 @@ function historySection(session) {
|
|
|
9446
9452
|
boundarySeq
|
|
9447
9453
|
};
|
|
9448
9454
|
}
|
|
9455
|
+
/** 表层是否存在合法 <history> 压缩日志块。 */
|
|
9456
|
+
function hasHistoryBlock(session) {
|
|
9457
|
+
for (const seq of session.surface.nodes) if (historyTextOf(session.snapshotEvents()[seq]) !== void 0) return true;
|
|
9458
|
+
return false;
|
|
9459
|
+
}
|
|
9449
9460
|
/**
|
|
9450
|
-
* 查找当前活跃的观察压缩待定标记:按日志顺序取最后一条
|
|
9451
|
-
* 其后须无引用它的
|
|
9461
|
+
* 查找当前活跃的观察压缩待定标记:按日志顺序取最后一条 om/observe-pending 信封事件,
|
|
9462
|
+
* 其后须无引用它的 om/observe-invalidate(已失效),且其后的压缩边界 seq 不大于标记
|
|
9452
9463
|
* seq(边界后移说明标记期间已发生过压缩,标记过期——兜底「执行成功但失效标记未写出」
|
|
9453
9464
|
* 的崩溃窗口)。无活跃标记返回 undefined。
|
|
9454
9465
|
*/
|
|
@@ -9458,24 +9469,24 @@ function findObservePending(session) {
|
|
|
9458
9469
|
const event = session.snapshotEvents()[seq];
|
|
9459
9470
|
if (!event) continue;
|
|
9460
9471
|
const om = readOmEvent(event);
|
|
9461
|
-
if (om?.kind === "
|
|
9472
|
+
if (om?.kind === "om/observe-pending") pending = {
|
|
9462
9473
|
seq,
|
|
9463
9474
|
triggerMessageIndex: om.data.triggerMessageIndex
|
|
9464
9475
|
};
|
|
9465
|
-
else if (om?.kind === "
|
|
9476
|
+
else if (om?.kind === "om/observe-invalidate" && pending !== void 0 && om.data.pendingSeq === pending.seq) pending = void 0;
|
|
9466
9477
|
}
|
|
9467
9478
|
if (pending === void 0) return void 0;
|
|
9468
9479
|
const { boundarySeq } = historySection(session);
|
|
9469
9480
|
if (boundarySeq !== void 0 && boundarySeq > pending.seq) return void 0;
|
|
9470
9481
|
return pending;
|
|
9471
9482
|
}
|
|
9472
|
-
/** 追加观察压缩待定标记(log-only
|
|
9483
|
+
/** 追加观察压缩待定标记(log-only om 信封事件):记录触发点完整消息 index,返回事件 seq。 */
|
|
9473
9484
|
function appendObservePending(session, triggerMessageIndex) {
|
|
9474
|
-
return appendOmEvent(session, "
|
|
9485
|
+
return appendOmEvent(session, "om/observe-pending", { triggerMessageIndex });
|
|
9475
9486
|
}
|
|
9476
|
-
/** 追加观察压缩待定失效标记(log-only
|
|
9487
|
+
/** 追加观察压缩待定失效标记(log-only om 信封事件):声明指定 pending 已失效,返回事件 seq。 */
|
|
9477
9488
|
function appendObserveInvalidate(session, pendingSeq) {
|
|
9478
|
-
return appendOmEvent(session, "
|
|
9489
|
+
return appendOmEvent(session, "om/observe-invalidate", { pendingSeq });
|
|
9479
9490
|
}
|
|
9480
9491
|
/** 当前打开中的 turn 号(最近 turn/start 且未被 turn/end 关闭);无则 null。 */
|
|
9481
9492
|
function openTurnOf(session) {
|
|
@@ -10751,11 +10762,11 @@ function wrap(lines) {
|
|
|
10751
10762
|
const PROGRESS_REMINDER = {
|
|
10752
10763
|
kind: PROGRESS_REMINDER_SOURCE_KIND,
|
|
10753
10764
|
text: wrap([
|
|
10754
|
-
"
|
|
10755
|
-
"-
|
|
10756
|
-
"-
|
|
10757
|
-
"-
|
|
10758
|
-
"-
|
|
10765
|
+
"在工作过程中同步输出文本,简洁记录关键结论与后续规划。思考内容不计入记录。",
|
|
10766
|
+
"- 每个阶段性工作开始前记录一次,一个阶段通常是 1-5 个工具调用",
|
|
10767
|
+
"- 禁止连续 10 个以上工具调用而无记录",
|
|
10768
|
+
"- 记录后在同一回复中继续调用工具,不要停下等待",
|
|
10769
|
+
"- 最终答案仅总结结果,不能替代这些记录"
|
|
10759
10770
|
])
|
|
10760
10771
|
};
|
|
10761
10772
|
/** 完整消息定义提醒。 */
|
|
@@ -10776,11 +10787,11 @@ function systemReminderMessage(reminder) {
|
|
|
10776
10787
|
}
|
|
10777
10788
|
});
|
|
10778
10789
|
}
|
|
10779
|
-
/**
|
|
10780
|
-
function activeSystemReminders(config) {
|
|
10790
|
+
/** 按配置与当前表层是否有 history 块返回应注入的提醒,顺序固定:进度在前,定义在后。 */
|
|
10791
|
+
function activeSystemReminders(config, hasHistory) {
|
|
10781
10792
|
const reminders = [];
|
|
10782
10793
|
if (config.omEnabled) reminders.push(PROGRESS_REMINDER);
|
|
10783
|
-
if (config.
|
|
10794
|
+
if (config.recallEnabled || hasHistory) reminders.push(DEFINITION_REMINDER);
|
|
10784
10795
|
return reminders;
|
|
10785
10796
|
}
|
|
10786
10797
|
/** 消息是否为指定提醒的当前文本。 */
|
|
@@ -10868,7 +10879,8 @@ function apply(ctx, config) {
|
|
|
10868
10879
|
return { kind: "reject" };
|
|
10869
10880
|
}
|
|
10870
10881
|
const decision = await next();
|
|
10871
|
-
const
|
|
10882
|
+
const hasHistory = hasHistoryBlock(agent.session);
|
|
10883
|
+
const reminders = activeSystemReminders(currentConfig(config), hasHistory);
|
|
10872
10884
|
if (decision.kind === "enter" && !signal.aborted && reminders.length > 0 && isMainSession(agent.session)) return {
|
|
10873
10885
|
...decision,
|
|
10874
10886
|
messages: ensureSystemReminders(agent.session, decision.messages, reminders)
|
package/dist/om-event.d.ts
CHANGED
|
@@ -1,35 +1,45 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* om
|
|
3
|
-
* 导出 OmEventKind / OmEventPayloadMap / OmEvent /
|
|
2
|
+
* om 事件借用通道:插件私有事件以宿主已知类型 feedback/record 持久化。
|
|
3
|
+
* 导出 OM_EVENT_PREFIX / OmEventKind / OmEventPayloadMap / OmEvent /
|
|
4
4
|
* appendOmEvent / readOmEvent / findOmEvents。
|
|
5
|
+
*
|
|
6
|
+
* 背景:持久化读取路径拒绝 KNOWN_SESSION_EVENT_TYPES 目录之外的未知类型
|
|
7
|
+
* (dsh-session-persistence 的 assertEventsSupported),而 Session.append 不提供
|
|
8
|
+
* ignorable 标记的写入途径,插件自定义事件类型会使含该事件的会话无法加载。
|
|
9
|
+
* feedback/record(dsh-command-feedback 声明)是目录内 log-only 审计事件,所有者
|
|
10
|
+
* invariant 声明其无跨事件关系、无运行时不变量、永不进入模型上下文,故选为承载
|
|
11
|
+
* 类型:插件数据以 `om:1:` 前缀 + JSON 信封写入其 text 字段,解码失败按非 om
|
|
12
|
+
* 记录处理(含用户自写的真实反馈记录)。
|
|
5
13
|
*/
|
|
6
14
|
import type { Session, SessionEvent } from './types.ts';
|
|
7
|
-
/** om
|
|
15
|
+
/** om 信封 text 前缀:标识该 feedback/record 记录由本插件写入。 */
|
|
16
|
+
export declare const OM_EVENT_PREFIX = "om:1:";
|
|
17
|
+
/** om 私有事件类别(信封 kind 字段)。 */
|
|
8
18
|
export type OmEventKind =
|
|
9
19
|
/** 功能降级警告(degrade.ts 报告,客户端渲染「功能降级」警告行)。 */
|
|
10
|
-
'
|
|
20
|
+
'om/warning'
|
|
11
21
|
/** 观察压缩待定标记(compress.ts 观察触发时追加)。 */
|
|
12
|
-
| '
|
|
22
|
+
| 'om/observe-pending'
|
|
13
23
|
/** 观察压缩待定失效标记(压缩执行完成后追加,声明待定可重新触发)。 */
|
|
14
|
-
| '
|
|
15
|
-
/**
|
|
24
|
+
| 'om/observe-invalidate';
|
|
25
|
+
/** 各类别信封载荷(kind 之外的 JSON 字段)。 */
|
|
16
26
|
export type OmEventPayloadMap = {
|
|
17
|
-
'
|
|
27
|
+
'om/warning': {
|
|
18
28
|
/** 降级问题标识(会话内去重键,取值见 degrade.ts)。 */
|
|
19
29
|
problem: string;
|
|
20
30
|
/** 面向用户的简短说明。 */
|
|
21
31
|
message: string;
|
|
22
32
|
};
|
|
23
|
-
'
|
|
33
|
+
'om/observe-pending': {
|
|
24
34
|
/** 触发点:追加时的最后一条完整消息 index。 */
|
|
25
35
|
triggerMessageIndex: number;
|
|
26
36
|
};
|
|
27
|
-
'
|
|
28
|
-
/** 被失效的
|
|
37
|
+
'om/observe-invalidate': {
|
|
38
|
+
/** 被失效的 om/observe-pending 事件 seq。 */
|
|
29
39
|
pendingSeq: number;
|
|
30
40
|
};
|
|
31
41
|
};
|
|
32
|
-
/** 一条解码后的 om
|
|
42
|
+
/** 一条解码后的 om 私有事件:类别、载荷与承载事件在日志中的 seq。 */
|
|
33
43
|
export type OmEvent = {
|
|
34
44
|
[K in OmEventKind]: {
|
|
35
45
|
kind: K;
|
|
@@ -37,9 +47,12 @@ export type OmEvent = {
|
|
|
37
47
|
seq: number;
|
|
38
48
|
};
|
|
39
49
|
}[OmEventKind];
|
|
40
|
-
/**
|
|
50
|
+
/**
|
|
51
|
+
* 解码一条会话事件为 om 私有事件:仅识别 feedback/record 中带 om 信封前缀的
|
|
52
|
+
* text;前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
|
|
53
|
+
*/
|
|
41
54
|
export declare function readOmEvent(event: SessionEvent | undefined | null): OmEvent | undefined;
|
|
42
|
-
/** 追加一条 om
|
|
55
|
+
/** 追加一条 om 私有事件(借用 feedback/record,log-only,不进 surface),返回事件 seq。 */
|
|
43
56
|
export declare function appendOmEvent<K extends OmEventKind>(session: Session, kind: K, data: OmEventPayloadMap[K]): number;
|
|
44
57
|
/** 读取日志中全部 om 私有事件(按日志顺序)。 */
|
|
45
58
|
export declare function findOmEvents(session: Session): OmEvent[];
|
package/dist/om-event.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"om-event.d.ts","sourceRoot":"","sources":["../src/om-event.ts"],"names":[],"mappings":"AAAA
|
|
1
|
+
{"version":3,"file":"om-event.d.ts","sourceRoot":"","sources":["../src/om-event.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAExD,kDAAkD;AAClD,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC,6BAA6B;AAC7B,MAAM,MAAM,WAAW;AACrB,4CAA4C;AAC1C,YAAY;AACd,qCAAqC;GACnC,oBAAoB;AACtB,uCAAuC;GACrC,uBAAuB,CAAC;AAE5B,iCAAiC;AACjC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE;QACZ,qCAAqC;QACrC,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,oBAAoB,EAAE;QACpB,8BAA8B;QAC9B,mBAAmB,EAAE,MAAM,CAAC;KAC7B,CAAC;IACF,uBAAuB,EAAE;QACvB,sCAAsC;QACtC,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,OAAO,GAAG;KACnB,CAAC,IAAI,WAAW,GAAG;QAAE,IAAI,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;CACzE,CAAC,WAAW,CAAC,CAAC;AAEf;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAiCvF;AAOD,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,CAAC,SAAS,WAAW,EACjD,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACzB,MAAM,CAER;AAED,8BAA8B;AAC9B,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAAC;AAC1D,2CAA2C;AAC3C,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAChD,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,GACN,KAAK,CAAC;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC"}
|
|
@@ -25,8 +25,8 @@ export declare const PROGRESS_REMINDER: SystemReminder;
|
|
|
25
25
|
export declare const DEFINITION_REMINDER: SystemReminder;
|
|
26
26
|
/** 构造一条新的提醒消息。 */
|
|
27
27
|
export declare function systemReminderMessage(reminder: SystemReminder): UserMessage;
|
|
28
|
-
/**
|
|
29
|
-
export declare function activeSystemReminders(config: Pick<PluginConfig, 'omEnabled' | 'recallEnabled'
|
|
28
|
+
/** 按配置与当前表层是否有 history 块返回应注入的提醒,顺序固定:进度在前,定义在后。 */
|
|
29
|
+
export declare function activeSystemReminders(config: Pick<PluginConfig, 'omEnabled' | 'recallEnabled'>, hasHistory: boolean): SystemReminder[];
|
|
30
30
|
/**
|
|
31
31
|
* 保证本 step 之后的消息列表中每种指定提醒各有一条当前文本:本 step 已带上或表层已有则跳过,
|
|
32
32
|
* 否则按顺序追加到末尾。返回新数组,不修改入参。
|