dsh-plugin-om 0.0.19 → 0.0.21

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
+import { toJSONSchema } from "zod/v4/core";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
@@ -7368,7 +7369,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.onWarningStopParsing = onWarningStopParsing;
 }));
 //#endregion
-//#region src/summarize.ts
+//#region src/rate-limit.ts
 var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	var conventions = require_conventions();
 	exports.assign = conventions.assign;
@@ -7409,12 +7410,77 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.onWarningStopParsing = domParser.onWarningStopParsing;
 })))();
 /**
+* 全局限流门（插件进程级共享状态）：任一摘要请求遇 429 限流后记录时间戳，
+* 此后所有摘要请求在发出前先等待到「最近一次 429 + rateLimitWaitMs」之后——
+* 并行压缩时其他块的下一次请求同样受限。等待期间 signal 中止则立即放弃。
+*
+* 门在进入时与等待结束时都会重读最近限流时间戳：等待期间发生新的 429 会顺延
+* 冷却期（循环等待直到通过或中止）。
+*/
+/** 最近一次 429 限流的时间戳（ms；null = 未遇过限流，门直接放行）。 */
+let lastRateLimitAt = null;
+/**
+* 判定错误信息是否为 429 限流：匹配 429（独立数字）或 rate limit（空格/连字符/
+* 下划线分隔与 camelCase 均可），大小写不敏感。
+*/
+function isRateLimitError(message) {
+	return /\b429\b|rate[\s_-]?limit/i.test(message);
+}
+/** 记录一次 429 限流：把冷却期起点更新为当前时间。 */
+function noteRateLimit() {
+	lastRateLimitAt = Date.now();
+}
+/** 可中止延时：等待满 ms 返回 true；等待期间 signal 中止返回 false。 */
+function delay(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve(false);
+			return;
+		}
+		/** 定时器句柄（正常到点或中止清理用）。 */
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve(true);
+		}, ms);
+		/** 中止监听（到点立即返回 false）。 */
+		const onAbort = () => {
+			cleanup();
+			resolve(false);
+		};
+		/** 清理定时器与中止监听。 */
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* 限流等待门：处于 429 冷却期（最近一次 429 + waitMs 未到）时等待到期限，
+* 通过后返回 true；等待期间 signal 中止返回 false。未遇过限流或冷却期已过
+* 立即放行。waitMs ≤ 0 视为不限流。
+*/
+async function gateRateLimit(waitMs, signal) {
+	if (waitMs <= 0) return true;
+	while (lastRateLimitAt !== null) {
+		/** 距冷却期结束的剩余等待（≤ 0 表示已过冷却期）。 */
+		const remaining = lastRateLimitAt + waitMs - Date.now();
+		if (remaining <= 0) return true;
+		if (!await delay(remaining, signal)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/summarize.ts
+/**
 * 共享压缩提示词（观察/反思同一套）：定义 history 块（模型消息 + index 的表达形式）、
 * 完整消息定义、要求压缩（完整保留用户消息 / reasoning 仅参考 / 关联 assistant 合并 /
 * index/start/end 连续）、输出格式（一个合法 <history> 块，无 reasoning）、数据源说明。
+* mode 控制【摘要粒度】：无参为通用提示词（反思调用）；'summary' 要求简单摘要（较早分块）；
+* 'detailed' 要求越往后越细（最后一块保留细节）。观察分块时除最后一块外均用 'summary'。
 */
-function buildHistoryPrompt() {
-	return [
+function buildHistoryPrompt(mode) {
+	const lines = [
 		"把下方的 <history> 消息记录压缩为一份更紧凑的 <history> 压缩日志。不用工具、不展示思考、不输出多余文字。",
 		"",
 		"【history 块定义】",
@@ -7450,7 +7516,14 @@ function buildHistoryPrompt() {
 		`</${HISTORY_TAG}>`,
 		"",
 		"【数据源】下方的 <history> 消息记录是本次要压缩的全部消息；压缩结果作为一个新的 <history> 块输出。"
-	].join("\n");
+	];
+	if (mode !== void 0) {
+		const granularity = mode === "summary" ? "【摘要粒度】本条为较早的消息，做简单摘要即可：概括要点，不必展开细节；但用户消息仍逐条保留原文，不概括、不省略。" : "【摘要粒度】本条为最近的消息，越往后越细：靠近末尾的完整消息保留更多细节（关键文件、改动与结论），前面的可适当从简；但用户消息始终逐条保留原文，不概括、不省略。";
+		const marker = "【输出格式】只输出一个 <history> 包裹的合法 XML 日志块";
+		const markerIndex = lines.findIndex((line) => line.includes(marker));
+		if (markerIndex !== -1) lines.splice(markerIndex, 0, granularity);
+	}
+	return lines.join("\n");
 }
 /** 渲染用户消息条目（DOM 元素）：文本块原样；图片/文件等非文本块以注释补充（说明传入了什么）。 */
 function renderUserEntry(doc, session, cm) {
@@ -7803,6 +7876,9 @@ function extractSummaryLog(raw, expected) {
 * 失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）均记录日志并重试，总共最多尝试
 * options.maxAttempts 次（默认 SUMMARY_DEFAULT_MAX_ATTEMPTS）；全部尝试失败返回 null
 * （不产生任何日志变更）。输出长度受 maxTokens 限制。
+* 每次请求发出前先过全局限流等待门（gateRateLimit）：任一请求遇 429 后，后续所有
+* 摘要请求（含并行中的其他调用方）在「最近一次 429 + options.rateLimitWaitMs」之前
+* 不会发出（缺省 RATE_LIMIT_WAIT_MS_DEFAULT）。
 */
 async function runSummarySubagent(ctx, agent, instruction, contextText, maxTokens, target, debug, signal, options) {
 	/** 当前会话。 */
@@ -7818,6 +7894,12 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前 signal 已中止），放弃本次摘要`);
 			return null;
 		}
+		/** 限流冷却时长（ms；调用方未传时用默认值）。 */
+		const rateLimitWaitMs = options?.rateLimitWaitMs ?? 6e4;
+		if (!await gateRateLimit(rateLimitWaitMs, signal)) {
+			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前限流等待被 signal 中止），放弃本次摘要`);
+			return null;
+		}
 		logger.step(`摘要调用开始（第 ${attempt}/${maxAttempts} 次，provider ${target.provider}，model ${target.model}，maxTokens ${maxTokens}）`);
 		try {
 			/** 摘要请求选项（new 方式组装）。 */
@@ -7847,6 +7929,10 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 		} catch (error) {
 			/** 错误信息（统一为字符串）。 */
 			const message = error instanceof Error ? error.message : String(error);
+			if (isRateLimitError(message)) {
+				noteRateLimit();
+				logger.warn(`摘要调用触发限流（429，第 ${attempt}/${maxAttempts} 次），下一次请求前至少等待 ${rateLimitWaitMs}ms`);
+			}
 			lastFailure = { error: message };
 			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，忽略本次摘要"));
 		}
@@ -7859,11 +7945,11 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 //#region src/compress.ts
 /**
 * 自动压缩（OM 观察/反思两级阈值，思路参考 Mastra Observational Memory）：
-*  - 观察：未压缩消息 tokens ≥ 窗口 × thresholdRatio → 直连 ctx.llm.stream() 摘要
-*    （new 方式：共享提示词作为 system、被压缩消息渲染为 <history> 块输入）把未压缩消息
+*  - 观察：未压缩消息 tokens ≥ observeThresholdTokens（默认 100000）→ 直连 ctx.llm.stream()
+*    摘要（new 方式：共享提示词作为 system、被压缩消息渲染为 <history> 块输入）把未压缩消息
 *    压缩为观察日志，作为独立的新 <history> 块，只精确替换被压缩的新消息区间（旧块原地
 *    保留，多块并存按序排列；不再把旧+新合并进一条消息）；
-*  - 反思：全部 <history> 块 tokens 合计 ≥ 窗口 × historyMergeRatio（默认 0.2）→
+*  - 反思：全部 <history> 块 tokens 合计 ≥ reflectThresholdTokens（默认 30000）→
 *    同上摘要调用精简合并（输入为多个块拼接，共用同一套提示词），把整个块区段合并为一条。
 * 两级检查在 pre-step 阻塞串行执行（先反思后观察），避免压缩失败或重复压缩。
 * 自动压缩由配置键 omEnabled 开关（false 时关闭；recall 工具不受影响）。
@@ -7890,6 +7976,103 @@ function estimateTextTokens(text) {
 	return Math.ceil(text.length / 4);
 }
 /**
+* 有界并发池：最多 limit 个任务同时运行（limit 非法时按 1 处理），任务按 index 顺序
+* 取用，结果数组与 items 按 index 对齐（任务自身以返回值表达失败，不在此抛出）。
+* items 为空返回空数组。
+*/
+async function runWithConcurrency(items, limit, task) {
+	/** 结果数组（按 index 对齐）。 */
+	const results = new Array(items.length);
+	/** 下一个待处理任务的下标（worker 间共享取号）。 */
+	let next = 0;
+	/** worker 数量（clamp 到 [1, items.length]）。 */
+	const workerCount = Math.max(1, Math.min(Math.floor(limit), items.length));
+	/** 各 worker：循环取号执行任务直到取尽。 */
+	const workers = Array.from({ length: workerCount }, async () => {
+		while (next < items.length) {
+			/** 本 worker 领取的任务下标。 */
+			const index = next;
+			next += 1;
+			results[index] = await task(items[index], index);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+/**
+* 按 token 边界把完整消息序列分块（观察并行压缩用）：完整消息不跨块——
+* 一条完整消息（含其 thinking/text/toolcall&result 全部 seqs）必然整体落在同一块，
+* 单条超界的消息独立成块。空输入返回空数组。
+*/
+function chunkCompleteMessages(session, cms, tokenBoundary, estimateMessage) {
+	if (cms.length === 0) return [];
+	/** 分块结果。 */
+	const chunks = [];
+	/** 当前块。 */
+	let current = [];
+	/** 当前块累计 token（按各完整消息 seqs 的派生消息估算合计）。 */
+	let currentTokens = 0;
+	for (const cm of cms) {
+		/** 当前完整消息的 token 估算（其全部表层 seqs 的派生消息估算之和）。 */
+		let cmTokens = 0;
+		for (const seq of cm.seqs) {
+			/** 表层事件（seq 缺失跳过）。 */
+			const event = session.events[seq];
+			/** 派生消息（用于 token 估算）。 */
+			const message = event ? session.deriveEventMessage(event) : null;
+			if (message) cmTokens += estimateMessage(message);
+		}
+		if (current.length > 0 && currentTokens + cmTokens > tokenBoundary) {
+			chunks.push(current);
+			current = [];
+			currentTokens = 0;
+		}
+		current.push(cm);
+		currentTokens += cmTokens;
+	}
+	if (current.length > 0) chunks.push(current);
+	return chunks;
+}
+/**
+* 合并分块摘要为单个 <history> 块：剥离各块的 <history> 开/闭标签（保留块内全部内容），
+* 以统一的开标签（带 tip 属性）与闭标签包裹拼接。块内内容原样保留（含格式说明注释）。
+*/
+function mergeChunkReports(parts) {
+	/** 各块内层内容（剥离外壳失败时原样保留该块文本）。 */
+	const inners = [];
+	for (const part of parts) {
+		/** 首个 <history 开标签位置。 */
+		const open = part.indexOf(`<${HISTORY_TAG}`);
+		/** 开标签右括号位置。 */
+		const gt = open === -1 ? -1 : part.indexOf(">", open);
+		/** 最后一个 </history> 闭标签位置。 */
+		const close = part.lastIndexOf(`</${HISTORY_TAG}>`);
+		if (open === -1 || gt === -1 || close === -1 || close <= gt) {
+			inners.push(part);
+			continue;
+		}
+		inners.push(part.slice(gt + 1, close));
+	}
+	return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${inners.join("\n").trim()}\n</${HISTORY_TAG}>`;
+}
+/** 合并多块摘要的 token usage（同名数字字段求和；全部为空返回 undefined）。 */
+function mergeUsage(usages) {
+	if (usages.length === 0) return void 0;
+	/** 合并结果（必填字段从 0 起累加）。 */
+	const out = {
+		inputTokens: 0,
+		outputTokens: 0
+	};
+	for (const u of usages) {
+		out.inputTokens += u.inputTokens;
+		out.outputTokens += u.outputTokens;
+		if (u.cacheReadTokens !== void 0) out.cacheReadTokens = (out.cacheReadTokens ?? 0) + u.cacheReadTokens;
+		if (u.cacheWriteTokens !== void 0) out.cacheWriteTokens = (out.cacheWriteTokens ?? 0) + u.cacheWriteTokens;
+		if (u.reasoningTokens !== void 0) out.reasoningTokens = (out.reasoningTokens ?? 0) + u.reasoningTokens;
+	}
+	return out;
+}
+/**
 * 反思输入块引用的最大完整消息 index（解析全部条目取最大 end；无条目返回 -1）。
 * 反思输出必须覆盖输入引用的完整 index 区间（0..max），连续性校验据此约束。
 */
@@ -8124,24 +8307,24 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
 	});
 }
 /**
-* 反思：全部 <history> 块 tokens 合计 ≥ 窗口 × historyMergeRatio 时，摘要调用
+* 反思：全部 <history> 块 tokens 合计 ≥ reflectThresholdTokens 时，摘要调用
 * 精简合并（多个块拼接为输入，与观察共用同一套提示词），把整个块区段替换为一条
 * 更紧凑的摘要。失败不产生部分替换。
 */
-async function reflectPass(ctx, agent, config, window, target, signal) {
+async function reflectPass(ctx, agent, config, target, signal) {
 	/** 当前会话。 */
 	const session = agent.session;
 	/** 插件日志门面。 */
 	const logger = makeLogger(ctx, config.debug);
-	logger.step(`反思检查（窗口 ${window} × historyMergeRatio ${config.historyMergeRatio}）`);
+	logger.step(`反思检查（反思阈值 ${config.reflectThresholdTokens} tokens）`);
 	/** 全部 <history> 压缩日志块（按表层顺序；无则跳过）。 */
 	const { blocks } = historySection(session);
 	if (blocks.length === 0) {
 		logger.step("反思：无 <history> 压缩日志，跳过");
 		return;
 	}
-	/** 反思阈值（窗口 × historyMergeRatio 向下取整）。 */
-	const threshold = Math.floor(window * config.historyMergeRatio);
+	/** 反思阈值（配置的绝对 token 数）。 */
+	const threshold = config.reflectThresholdTokens;
 	/** 全部块 token 估算合计（摘要总长）。 */
 	const tokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
 	/** 被压缩块区段的字符数合计（压缩前内文长度；UI 标题统计用，与观察路径一致只计内容不计标签）。 */
@@ -8186,7 +8369,8 @@ async function reflectPass(ctx, agent, config, window, target, signal) {
 		expected: expectedEnd < 0 ? { start: 0 } : {
 			start: 0,
 			end: expectedEnd
-		}
+		},
+		rateLimitWaitMs: config.rateLimitWaitMs
 	});
 	if (summaryResult === null || summaryResult.text.trim().length === 0) {
 		logger.step("反思：摘要调用失败/无输出，追加 compaction/end(error)");
@@ -8213,7 +8397,7 @@ async function reflectPass(ctx, agent, config, window, target, signal) {
 			provider: target.provider,
 			model: target.model,
 			maxTokens: config.compressMaxTokens,
-			attemptCount: summaryResult.attemptCount,
+			attemptCount: summaryResult.attemptCount - 1,
 			...summaryResult.usage === void 0 ? {} : { usage: summaryResult.usage }
 		});
 		logger.step("反思提交：替换整个 <history> 块区段为合并摘要");
@@ -8235,17 +8419,17 @@ async function reflectPass(ctx, agent, config, window, target, signal) {
 	}
 }
 /**
-* 观察：未压缩消息 tokens ≥ 窗口 × thresholdRatio 时，摘要调用把未压缩消息压缩为
+* 观察：未压缩消息 tokens ≥ observeThresholdTokens 时，摘要调用把未压缩消息压缩为
 * 观察日志，追加到旧摘要并替换被压缩消息区间。失败不产生部分替换。
 */
-async function observePass(ctx, agent, config, window, tailCount, target, signal) {
+async function observePass(ctx, agent, config, tailCount, target, signal) {
 	/** 当前会话。 */
 	const session = agent.session;
 	/** 插件日志门面。 */
 	const logger = makeLogger(ctx, config.debug);
-	logger.step(`观察检查（窗口 ${window} × thresholdRatio ${config.thresholdRatio}，尾部保留 ${tailCount} 条）`);
-	/** 观察阈值（窗口 × thresholdRatio 向下取整）。 */
-	const threshold = Math.floor(window * config.thresholdRatio);
+	logger.step(`观察检查（观察阈值 ${config.observeThresholdTokens} tokens，尾部保留 ${tailCount} 条）`);
+	/** 观察阈值（配置的绝对 token 数）。 */
+	const threshold = config.observeThresholdTokens;
 	/** 未压缩消息 token 估算（最后一个 <history> 块之后；其前视为已压缩）。 */
 	const uncompressedTokens = measureUncompressedTokens(session, ctx.tokenMeter);
 	if (uncompressedTokens < threshold) {
@@ -8282,10 +8466,9 @@ async function observePass(ctx, agent, config, window, tailCount, target, signal
 	const startIndex = inRangeCms[0]?.index ?? 0;
 	const endIndex = inRangeCms[inRangeCms.length - 1]?.index ?? startIndex;
 	logger.step(`观察：保留旧块 ${blocks.length} 条，替换新消息 [${replaceSeqs[0]}..${range.end}]（${replaceSeqs.length} 条），尾部保留 ${tailCount} 条（不压缩、不进日志），新消息 index ${startIndex}..${endIndex}`);
-	/** 共享提示词（观察/反思同一套）。 */
-	const instruction = buildHistoryPrompt();
-	/** 渲染输入：本次要压缩的完整消息（合法 <history> 块，含绝对 index；不含尾部；系统消息渲染为 <sys> 空块，本插件自产消息不占位）。 */
-	const contextText = renderMessages(session, replaceSeqs);
+	/** 按 observeChunkTokens 边界把完整消息分块（完整消息不跨块；每块独立并行压缩）。 */
+	const chunks = chunkCompleteMessages(session, inRangeCms, config.observeChunkTokens, (message) => ctx.tokenMeter.estimateMessage(message));
+	logger.step(`观察：${inRangeCms.length} 条完整消息按 ${config.observeChunkTokens} tokens 边界分为 ${chunks.length} 块（最多 ${config.observeChunkParallelism} 块并行，每块摘要 maxTokens ${config.observeChunkMaxTokens}，除最后一块外要求简单摘要）`);
 	/** 本次压缩生命周期（compactionId + 当前轮次；start 在摘要调用前开启，UI 压缩中提示）。 */
 	const lifecycle = {
 		compactionId: newCompactionId(),
@@ -8300,23 +8483,39 @@ async function observePass(ctx, agent, config, window, tailCount, target, signal
 		logger.warn(`观察压缩启动失败: ${message}`);
 		return;
 	}
-	/** 观察摘要结果（null 表示失败/跳过）。 */
-	const summaryResult = await runSummarySubagent(ctx, agent, instruction, contextText, config.compressMaxTokens, target, config.debug, signal, {
-		maxAttempts: config.compressRetryCount + 1,
-		expected: {
-			start: startIndex,
-			end: endIndex
-		}
+	/** 各块摘要结果（有界并发池，最多 observeChunkParallelism 块同时进行；null = 该块失败；结果按块顺序）。 */
+	const chunkResults = await runWithConcurrency(chunks, config.observeChunkParallelism, async (chunk, index) => {
+		/** 该块提示词（较早块简单摘要；最后一块越往后越细）。 */
+		const instruction = buildHistoryPrompt(index === chunks.length - 1 ? "detailed" : "summary");
+		/** 该块渲染输入（块内完整消息的 seqs；合法 <history> 块，含绝对 index）。 */
+		const contextText = renderMessages(session, chunk.flatMap((cm) => cm.seqs));
+		/** 该块覆盖的完整消息 index 区间（连续性校验预期）。 */
+		const start = chunk[0]?.index ?? 0;
+		const end = chunk[chunk.length - 1]?.index ?? start;
+		return runSummarySubagent(ctx, agent, instruction, contextText, config.observeChunkMaxTokens, target, config.debug, signal, {
+			maxAttempts: config.compressRetryCount + 1,
+			expected: {
+				start,
+				end
+			},
+			rateLimitWaitMs: config.rateLimitWaitMs
+		});
 	});
-	if (summaryResult === null || summaryResult.text.trim().length === 0) {
-		logger.step("观察：摘要调用失败/无输出，追加 compaction/end(error)");
+	if (chunkResults.find((r) => r === null || r.text.trim().length === 0) !== void 0) {
+		logger.step("观察：分块摘要存在失败/无输出，不产生部分替换，追加 compaction/end(error)");
 		try {
 			appendCompactionEnd(session, lifecycle, "摘要调用失败/无输出");
 		} catch {}
 		return;
 	}
-	/** 观察摘要文本（独立新块；旧块保留，不再合并）。 */
-	const report = summaryResult.text;
+	/** 成功结果（上方已排除 null/空输出；每块已独立校验并规范化）。 */
+	const okResults = chunkResults;
+	/** 合并各块摘要为单个带 tip 的 <history> 块（剥离各块外壳拼接内层；不再整体校验）。 */
+	const report = mergeChunkReports(okResults.map((r) => r.text));
+	/** 重试次数合计（各块重试次数之和；每块重试次数 = 该块成功尝试次数 - 1）。 */
+	const attemptCount = okResults.reduce((sum, r) => sum + (r.attemptCount - 1), 0);
+	/** token usage 合计（各块求和；全部缺省为 undefined）。 */
+	const usage = mergeUsage(okResults.map((r) => r.usage).filter((u) => u !== void 0));
 	/** 被替换表层节点的 token 估算合计（仅新消息区间）。 */
 	const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
 		/** 当前表层事件。 */
@@ -8348,9 +8547,9 @@ async function observePass(ctx, agent, config, window, tailCount, target, signal
 			shadowedCharCount,
 			provider: target.provider,
 			model: target.model,
-			maxTokens: config.compressMaxTokens,
-			attemptCount: summaryResult.attemptCount,
-			...summaryResult.usage === void 0 ? {} : { usage: summaryResult.usage }
+			maxTokens: config.observeChunkMaxTokens,
+			attemptCount,
+			...usage === void 0 ? {} : { usage }
 		});
 		logger.step("观察提交：替换被压缩新消息区间为 <history>（旧块保留）");
 		appendHistoryMessage(session, report, [summarySeq, ...replaceSeqs], {
@@ -8391,27 +8590,12 @@ async function maybeCompress(ctx, agent, config, signal) {
 		return;
 	}
 	logger.step(`会话路由：provider ${target.provider}，model ${target.model}`);
-	/** 模型容量信息（contextWindow 决定两级阈值）。 */
-	let info;
-	try {
-		info = await ctx.llm.resolveModelInfo(target.provider, target.model, signal);
-	} catch (error) {
-		logger.warn(`解析模型容量失败: ${error instanceof Error ? error.message : String(error)}`);
-		return;
-	}
-	/** 模型上下文窗口大小（非法值视为无法压缩）。 */
-	const window = info.context?.contextWindow;
-	if (typeof window !== "number" || !Number.isFinite(window) || window <= 0) {
-		logger.step(`模型上下文窗口非法（${String(window)}），跳过压缩`);
-		return;
-	}
-	logger.step(`模型上下文窗口 ${window} tokens，开始两级压缩（先反思后观察）`);
 	/** 尾部保留条数（config.tailMessageCount，缺省 10）。 */
 	const tailCount = config.tailMessageCount;
 	logger.step("反思 pass 开始");
-	await reflectPass(ctx, agent, config, window, target, signal);
+	await reflectPass(ctx, agent, config, target, signal);
 	logger.step("反思 pass 结束，观察 pass 开始");
-	await observePass(ctx, agent, config, window, tailCount, target, signal);
+	await observePass(ctx, agent, config, tailCount, target, signal);
 	logger.step("观察 pass 结束，压缩流程完成");
 }
 //#endregion
@@ -8654,9 +8838,13 @@ function cosineSimilarity(a, b) {
 */
 /** 默认配置（冻结对象，resolveConfig 合并的基底；debug 缺省值在解析时按 NODE_ENV 判定）。 */
 const DEFAULT_CONFIG = Object.freeze({
-	thresholdRatio: .1,
-	historyMergeRatio: .2,
+	observeThresholdTokens: 1e5,
+	reflectThresholdTokens: 3e4,
 	compressMaxTokens: 1e4,
+	observeChunkTokens: 3e4,
+	observeChunkMaxTokens: 5e3,
+	observeChunkParallelism: 2,
+	rateLimitWaitMs: 6e4,
 	tailMessageCount: 10,
 	compressRetryCount: 10,
 	omEnabled: true,
@@ -8667,9 +8855,13 @@ const DEFAULT_CONFIG = Object.freeze({
 });
 /** 数值键校验参数表：键名 + [integer]。不限制取值区间——用户提供的值按原样接受（便于调试）。 */
 const NUMBER_KEYS = [
-	["thresholdRatio", false],
-	["historyMergeRatio", false],
+	["observeThresholdTokens", true],
+	["reflectThresholdTokens", true],
 	["compressMaxTokens", true],
+	["observeChunkTokens", true],
+	["observeChunkMaxTokens", true],
+	["observeChunkParallelism", true],
+	["rateLimitWaitMs", true],
 	["tailMessageCount", true],
 	["compressRetryCount", true]
 ];
@@ -8719,6 +8911,21 @@ function resolveConfig(raw) {
 	return Object.freeze(config);
 }
 //#endregion
+//#region src/json-schema.ts
+/**
+* zod schema → 工具 wire 参数 JSON Schema 的转换工具。
+*
+* 官方 API（如 api.deepseek.com 的 /chat/completions）要求 tools[].function.parameters
+* 为根级带 type:'object' 的标准 JSON Schema；工具的参数定义统一由 zod 的 toJSONSchema
+* 生成，避免手写属性 map 与执行期解析 schema 双份定义漂移。剥除 $schema 元键与
+* additionalProperties：未知键不在 wire 层拒绝，执行期仍由 zod 解析剥离。
+*/
+/** 由 zod schema 生成 wire 参数 JSON Schema（根 type:'object'，含 properties/required 与 describe 描述）。 */
+function parametersFromZod(schema) {
+	const { $schema: _schema, additionalProperties: _additional, ...rest } = toJSONSchema(schema);
+	return rest;
+}
+//#endregion
 //#region src/recall.ts
 /**
 * recall 工具：按「完整消息」序号（index）回看原始会话（start/end 为完整消息 index，
@@ -8728,17 +8935,19 @@ function resolveConfig(raw) {
 * recall 自身不设输出上限：超大的工具结果由 tool-result-pruner 裁剪（pruneContent），
 * 输出 token 由 pruner 配置控制。
 *
-* 参数由 zod schema（recallArgsSchema）在 execute 入口校验：start 必填（number），
-* end/offset 至少提供一个；非法参数抛出可读错误。
+* 参数由 zod schema（recallArgsSchema）统一描述：wire 参数 JSON Schema（根 type:'object'，
+* 各字段描述来自 .describe()）直接发给模型，execute 入口再做运行时校验（start 必填；
+* end/offset 至少提供一个；非法参数抛出可读错误）。
 */
 /**
 * recall 工具参数 schema：start 必填（number）；end 与 offset 至少提供一个
 * （二者同时给出时 end 优先，与 execute 语义一致）；未知键自动剥离。
+* 各字段描述经 .describe() 透传到 wire JSON Schema（生成见 json-schema.ts）。
 */
 const recallArgsSchema = z.object({
-	start: z.number(),
-	end: z.number().optional(),
-	offset: z.number().optional()
+	start: z.number().describe("完整消息序号（index），作为基准边界，和 end 或 offset 配合，指定区间；end 与 offset 至少提供一个（同时给出时 end 优先）。"),
+	end: z.number().optional().describe("与 offset 互斥，指定区间的另一个边界。"),
+	offset: z.number().optional().describe("与 end 互斥。相对 start 的步数：正数向后、负数向前。")
 }).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
 /**
 * 解析并校验 recall 调用参数：校验失败时抛出首个校验问题的可读消息
@@ -8758,21 +8967,7 @@ function buildRecallTool(getPruner) {
 	return {
 		name: "recall",
 		description: `${COMPLETE_MESSAGE_DEFINITION}此工具可以精确查询完整消息。用index指定一个区间，返回区间内所有完整消息的内容。`,
-		parameters: {
-			start: {
-				type: "number",
-				description: "完整消息序号（index），作为基准边界，和end或offset配合，指定区间",
-				required: true
-			},
-			end: {
-				type: "number",
-				description: "与 offset 互斥，指定区间的另一个边界。"
-			},
-			offset: {
-				type: "number",
-				description: "与 end 互斥。相对 start 的步数：正数向后、负数向前。"
-			}
-		},
+		parameters: parametersFromZod(recallArgsSchema),
 		output: {
 			schema: { type: "string" },
 			render: (_args, value) => [{
@@ -8840,6 +9035,8 @@ function buildRecallTool(getPruner) {
 *
 * - 参数：query 必填；top_k（默认 3，1-10）；start/end/offset 限定检索区间
 *   （意义同 recall：start 为基准边界，end 与 offset 二选一；end 优先）。
+*   wire 参数 JSON Schema 由本 schema 经 toJSONSchema 生成（各字段描述来自 .describe()，
+*   见 json-schema.ts）。
 * - 区间缺省（start 未提供）→ 检索全部消息；区间不合法（start/end 越界等）→
 *   不报错，回退全量检索并在输出中明确告知（模型可见）。
 * - 向量：本地 ONNX embedding（embedding.ts，懒加载 + 批量）；相似度 = cosine。
@@ -8849,11 +9046,11 @@ function buildRecallTool(getPruner) {
 */
 /** recall-semantic 工具参数 schema：query 必填；top_k 默认 3（1-10）；区间参数均可选。 */
 const semanticRecallArgsSchema = z.object({
-	query: z.string(),
-	top_k: z.number().int().min(1).max(10).optional(),
-	start: z.number().optional(),
-	end: z.number().optional(),
-	offset: z.number().optional()
+	query: z.string().describe("描述要找的内容的自然语言 query（可混用中英文与代码术语，如 \"修复 retry backoff 的逻辑\"），不能为空。"),
+	top_k: z.number().int().min(1).max(10).optional().describe("返回最匹配的完整消息条数（1-10，默认 3）。"),
+	start: z.number().optional().describe("完整消息序号（index），可选。作为基准边界，和end或offset配合，指定搜索区间。"),
+	end: z.number().optional().describe("必须和start配合使用，与 offset 互斥，指定搜索区间的另一个边界。"),
+	offset: z.number().optional().describe("必须和start配合使用，与 end 互斥。相对 start 的步数：正数向后、负数向前。")
 }).refine((args) => args.query.trim().length > 0, { message: "query 不能为空" });
 /** 解析并校验参数：失败时抛出可读错误（普通 Error 而非 ZodError）。 */
 function parseSemanticRecallArgs(raw) {
@@ -8948,29 +9145,7 @@ function buildSemanticRecallTool(options) {
 	return {
 		name: "recall-semantic",
 		description: `${COMPLETE_MESSAGE_DEFINITION}此工具可以按自然语言含义，检索最符合的完整消息。默认在全消息范围搜索，可以指定区间。`,
-		parameters: {
-			query: {
-				type: "string",
-				description: "描述要找的内容的自然语言 query（可混用中英文与代码术语，如 \"修复 retry backoff 的逻辑\"）。",
-				required: true
-			},
-			top_k: {
-				type: "number",
-				description: "返回最匹配的完整消息条数（1-10，默认 3）。"
-			},
-			start: {
-				type: "number",
-				description: "完整消息序号（index），可选。作为基准边界，和end或offset配合，指定搜索区间。"
-			},
-			end: {
-				type: "number",
-				description: "必须和start配合使用，与 offset 互斥，指定搜索区间的另一个边界。"
-			},
-			offset: {
-				type: "number",
-				description: "必须和start配合使用，与 end 互斥。相对 start 的步数：正数向后、负数向前。"
-			}
-		},
+		parameters: parametersFromZod(semanticRecallArgsSchema),
 		output: {
 			schema: { type: "string" },
 			render: (_args, value) => [{
@@ -9066,8 +9241,8 @@ function buildSemanticRecallTool(options) {
 *    按语义在全部完整消息（含被压缩/遮蔽）中检索，返回最匹配的完整消息与匹配说明
 *    （本地 ONNX embedding，模型随插件打包，懒加载）
 *  - compress.ts 自动压缩（OM 观察/反思两级阈值）：pre-step 阻塞串行执行——
-*    反思（摘要 ≥ 窗口 × historyMergeRatio 时摘要调用精简合并 <history>）、
-*    观察（未压缩消息 ≥ 窗口 × thresholdRatio 时摘要调用压缩为观察日志并追加）
+*    反思（<history> 块 tokens 合计 ≥ reflectThresholdTokens 时摘要调用精简合并）、
+*    观察（未压缩消息 tokens ≥ observeThresholdTokens 时摘要调用压缩为观察日志并追加）
 *
 * 约束：不引入自定义会话事件类型——压缩复用宿主已知的 compaction/* 生命周期事件
 * （start/summary/end）与 checkpoint 标记，结果写入消息记录与轨迹。
@@ -9092,7 +9267,7 @@ function apply(ctx, config) {
 	const resolved = resolveConfig(config);
 	/** 插件日志门面（step=debug 按配置 debug 开关输出；info/warn 始终输出）。 */
 	const logger = makeLogger(ctx, resolved.debug);
-	logger.step(`apply 启动：thresholdRatio=${String(resolved.thresholdRatio)} historyMergeRatio=${String(resolved.historyMergeRatio)} compressMaxTokens=${String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} omEnabled=${String(resolved.omEnabled)} debug=${String(resolved.debug)}`);
+	logger.step(`apply 启动：observeThresholdTokens=${String(resolved.observeThresholdTokens)} reflectThresholdTokens=${String(resolved.reflectThresholdTokens)} compressMaxTokens=${String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} omEnabled=${String(resolved.omEnabled)} debug=${String(resolved.debug)}`);
 	if (resolved.recallEnabled) ctx.tools.register(buildRecallTool(() => ctx.get("toolResultPruner")));
 	if (resolved.semanticRecallEnabled) {
 		const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);

package/dist/json-schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * zod schema → 工具 wire 参数 JSON Schema 的转换工具。
+ *
+ * 官方 API（如 api.deepseek.com 的 /chat/completions）要求 tools[].function.parameters
+ * 为根级带 type:'object' 的标准 JSON Schema；工具的参数定义统一由 zod 的 toJSONSchema
+ * 生成，避免手写属性 map 与执行期解析 schema 双份定义漂移。剥除 $schema 元键与
+ * additionalProperties：未知键不在 wire 层拒绝，执行期仍由 zod 解析剥离。
+ */
+import { type $ZodType } from 'zod/v4/core';
+/** 由 zod schema 生成 wire 参数 JSON Schema（根 type:'object'，含 properties/required 与 describe 描述）。 */
+export declare function parametersFromZod<T extends $ZodType>(schema: T): Record<string, unknown>;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,aAAa,CAAC;AAE1D,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIxF"}