@nickyzj2023/ai 1.2.0 → 1.3.0

package/README.md

@@ -1,6 +1,6 @@
 # ai
 
-男生自用MyPi Coding Agent，0外部依赖
+男生自用MyPi Coding Agent
 
 ## 安装
 

package/dist/cli.mjs

@@ -1,9 +1,11 @@
-import { i as defineModel, n as get_weather_default, o as runAgent, r as get_time_default } from "./src-BJFCp7ur.mjs";
-import { extractErrorMessage } from "@nickyzj2023/utils";
+import { a as defineTool, i as defineModel, n as get_weather_default, o as runAgent, r as get_time_default } from "./src-Dm0rwYe2.mjs";
+import { extractErrorMessage, isObject, omit } from "@nickyzj2023/utils";
 import readline from "node:readline";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 //#region src/utils/config.ts
 /**
 * 获取全局配置文件路径（Windows/macOS/Linux通用）
@@ -162,16 +164,78 @@ var TUI = class {
 		this.preparePrint("tool_result");
 		process.stdout.write(this.colorize(`[工具结果：${name}] ${result}`, "90"));
 	}
+	formatter = new Intl.NumberFormat("en-US", {
+		notation: "compact",
+		maximumFractionDigits: 1
+	});
+	format(number) {
+		return this.formatter.format(number);
+	}
 	/** 打印轮次结束原因、token消耗 */
 	printFinish(finishReason, usage) {
 		this.preparePrint("done");
-		process.stdout.write(this.colorize(`[本轮结束：${finishReason}] ${usage ? `输入${usage.prompt_tokens}tok，输出${usage.completion_tokens}tok，总共${usage.total_tokens}tok` : ""}${finishReason === "stop" ? "\n\n" : "\n"}`, "90"));
+		process.stdout.write(this.colorize(`[本轮结束：${finishReason}] ${usage ? `输入${this.format(usage.prompt_tokens)}token，输出${this.format(usage.completion_tokens)}token，总共${this.format(usage.total_tokens)}token` : ""}${finishReason === "stop" ? "\n\n" : "\n"}`, "90"));
 	}
 };
 //#endregion
+//#region src/tools/mcp.ts
+/** 全局单例MCP加载器 */
+let router = null;
+var MCPRouter = class {
+	entries = /* @__PURE__ */ new Map();
+	/** 注册一个新的MCP客户端 */
+	async addClient(name, url, options) {
+		if (this.entries.has(name)) return;
+		const transport = new StreamableHTTPClientTransport(new URL(url), { requestInit: { headers: options?.headers } });
+		const client = new Client({
+			name,
+			version: "1.0.0"
+		});
+		await client.connect(transport);
+		const { tools } = await client.listTools();
+		const normalizedTools = tools.filter((tool) => !options?.ignoredToolNames?.includes(tool.name)).map((tool) => {
+			const _properties = { ...tool.inputSchema.properties ?? {} };
+			tool.inputSchema.required?.forEach((key) => {
+				if (isObject(_properties[key])) _properties[key] = {
+					..._properties[key],
+					required: true
+				};
+			});
+			return defineTool(tool.name, tool.description ?? "", _properties, (args) => client.callTool({
+				name: tool.name,
+				arguments: args
+			}));
+		});
+		this.entries.set(name, {
+			client,
+			tools: normalizedTools
+		});
+		return client;
+	}
+	/** 返回OpenAI API兼容的tools数组 */
+	async getTools() {
+		return [...this.entries.values()].flatMap((e) => e.tools);
+	}
+};
+/**
+* 把传入的MCPServer列表转换成OpenAI API兼容的tools数组
+*/
+const loadMCPTools = async (mcpServers) => {
+	router ||= new MCPRouter();
+	await Promise.allSettled(Object.entries(mcpServers).map(async ([name, server]) => {
+		try {
+			await router?.addClient(name, server.url, omit(server, ["type", "url"]));
+			console.log(`已加载MCP工具：${name}`);
+		} catch (e) {
+			console.error(`MCP服务器${name}连接失败，跳过：${extractErrorMessage(e)}`);
+		}
+	}));
+	return router.getTools();
+};
+//#endregion
 //#region src/cli.ts
 /** 启动交互对话：配置来自全局配置文件，环境变量可临时覆盖 */
-const startChat = () => {
+const startChat = async () => {
 	const config = loadConfig();
 	if (!config) {
 		console.error("请先运行 `ai setup` 配置一个模型");
@@ -179,7 +243,12 @@ const startChat = () => {
 	}
 	const model = defineModel(config);
 	const messages = [];
-	const tools = [get_weather_default, get_time_default];
+	const mcpTools = await loadMCPTools(config.mcpServers);
+	const tools = [
+		get_weather_default,
+		get_time_default,
+		...mcpTools
+	];
 	const tui = new TUI(async (input) => {
 		messages.push({
 			role: "user",

package/dist/index.d.mts

@@ -150,124 +150,102 @@ declare const _default$1: ToolDefinition;
 //#endregion
 //#region src/utils/compact/types.d.ts
 declare namespace Compact {
-  type ReplacerOfToolResultContent = (content: Message["content"], options?: Record<string, any>) => Promise<Message["content"]> | Message["content"];
-  type ReplacerOfMediaContent = (content: Message["content"], options?: Record<string, any>) => Promise<Message["content"]> | Message["content"];
+  type Options = {
+    /** 提供token消耗情况时，能更准确地判断上下文是否达到阈值 */
+    usage?: Usage;
+    /**
+     * 各种压缩方式统一保留的最近消息条数
+     * @default 10
+     * @remarks 压缩工具调用结果、压缩媒体消息、总结消息、硬删除兜底都会保留最近keepCount条消息不处理
+     */
+    keepCount?: number;
+    /**
+     * 压缩工具/媒体消息时做个标记，防止下次重复压缩
+     * @default "[已压缩]"
+     */
+    compactedMessageMark?: string;
+    /**
+     * 上下文>总上下文*ratio时压缩工具调用结果
+     * @default 0.6
+     */
+    ratioToCompactToolResults?: number;
+    /**
+     * 如何压缩工具调用结果
+     * @default 让其他模型返回简化后的工具结果
+     */
+    replacerOfToolResultContent?: Compact.ReplacerOfToolResultContent;
+    /**
+     * 上下文>总上下文*ratio时压缩图片/音频/视频消息
+     * @default 0.7
+     */
+    ratioToCompactMedia?: number;
+    /**
+     * 如何压缩媒体消息
+     * @default 让其他模型用自然语言简短描述一遍
+     */
+    replacerOfMediaContent?: Compact.ReplacerOfMediaContent;
+    /**
+     * 上下文>总上下文*ratio时总结消息
+     * @default 0.8
+     * @remarks 如果总结成功，会把keepCount以前的消息压成一条用户消息
+     */
+    ratioToSummarize?: number;
+    /**
+     * 总结消息时的配置项
+     * @default { systemPrompt: "你现在的任务是总结历史消息" }
+     */
+    summarizeOptions?: Partial<Compact.SummarizeOptions>;
+  };
+  type ReplacerOfToolResultContent = (content: Message["content"], options?: Record<string, any>) => Promise<string> | string;
+  type ReplacerOfMediaContent = (content: Message["content"], options?: Record<string, any>) => Promise<string> | string;
   type SummarizeOptions = {
-    /** 用什么模型总结 */
-    model: Model;
-    /** 用于指导大模型如何总结消息的提示词 */
+    /** 指导大模型如何总结消息 */
     systemPrompt: string;
+    model: Model;
   };
-  /**
-   * compactMessages 的返回值，告知调用方各压缩动作是否执行
-   * @remarks
-   * 这些字段是"操作级"标志：为 true 只代表对应操作已执行，不代表一定产生了效果。
-   * 例如 hasSummarized 为 true 只代表进入了总结流程，是否真的总结成功，
-   * 应由调用方检查消息数组里是否出现含 `<summary>` 标签的消息来判断。
-   */
-  type CompactResult = {
-    /** 是否执行了压缩工具调用结果 */
-    hasCompactedToolResult: boolean;
-    /** 是否执行了压缩图片/音频/视频消息 */
+  type Result = {
+    /** 是否压缩了工具调用结果 */
+    hasCompactedToolResults: boolean;
+    /** 是否压缩了图片/音频/视频消息 */
     hasCompactedMedia: boolean;
-    /** 是否执行了清理软删除残留的占位消息 */
-    hasClearedSoftDeletedMessages: boolean;
-    /** 是否执行了总结消息操作（是否真的总结，请检查消息中是否出现`<summary>`标签） */
+    /** 是否总结了消息 */
     hasSummarized: boolean;
-    /** 是否执行了兜底硬删除较早消息 */
-    hasDeletedOldMessages: boolean;
+    /** 是否丢弃了一些旧消息（最终兜底策略） */
+    hasDiscardMessages: boolean;
   };
 }
 //#endregion
 //#region src/utils/compact/strategy.d.ts
-declare const softDeleteToolResults: (messages: Message[], options: {
+/**
+ * @returns 实际处理了几条消息
+ */
+declare const compactToolResults: (compressible: Message[], options: {
   replacer?: Compact.ReplacerOfToolResultContent;
   mark: string;
   model?: Model;
-}) => Promise<Message[]>;
-declare const softDeleteOldMediaMessages: (messages: Message[], options: {
+}) => Promise<number>;
+/**
+ * @returns 实际处理了几条消息
+ */
+declare const compactMediaMessages: (compressible: Message[], options: {
   replacer?: Compact.ReplacerOfMediaContent;
-  mark: string;
   model?: Model;
-}) => Promise<Message[]>;
+}) => Promise<number>;
+declare const summarizeMessages: (compressible: Message[], options: Compact.SummarizeOptions) => Promise<number>;
 /**
- * 清理软删除后残留的占位消息（信息在软删除时已丢失，此时删除不损失任何额外信息）
- * @param messages 可压缩区消息数组，直接原地删除
- * @param softDeleted 本轮被软删过的消息引用集合
- * @remarks
- * tool消息不能单独删除：OpenAI API要求assistant(tool_calls)与tool消息按tool_call_id配对，
- * 单独删掉tool会让assistant(tool_calls)变成孤立消息，后续请求返回400。
- * 因此遇到被软删的tool消息时，必须把整个assistant(tool_calls) + tool配对组一起删除。
- * 组内多条tool被软删时，集合去重后只会删除一次。
+ * 最终的兜底压缩策略，从头删除旧消息，直到第二个回调函数返回true（达成目标）
  */
-declare const hardDeleteSoftMessages: (messages: Message[], softDeleted: ReadonlySet<Message>) => void;
-declare const summarizeMessages: (messages: Message[], options: Compact.SummarizeOptions) => Promise<void>;
-declare const hardDeleteOldMessages: (messages: Message[]) => void;
+declare const discardMessagesUntil: (compressible: Message[], until: (compressible: Message[]) => boolean) => number;
 //#endregion
 //#region src/utils/compact/index.d.ts
 /**
  * 自动优化上下文，类似AI Coding Agent的/compact命令
  */
-declare const compact: ((messages: Message[], model: Model, options?: {
-  /** 提供token消耗情况时，能更准确地判断上下文是否达到阈值 */
-  usage?: Usage;
-  /**
-   * 各种压缩方式统一保留的最近消息条数
-   * @default 10
-   * @remarks 压缩工具调用结果、压缩媒体消息、总结消息、硬删除兜底都会保留最近keepCount条消息不处理
-   */
-  keepCount?: number;
-  /**
-   * 上下文>总上下文*ratio时压缩工具调用结果
-   * @default 0.5
-   */
-  ratioToCompactToolResult?: number;
-  /**
-   * 如何压缩工具调用结果，例如让其他模型返回精简后的工具结果
-   * @default (content) => "（已被消费）"
-   */
-  replacerOfToolResultContent?: Compact.ReplacerOfToolResultContent;
-  /**
-   * 上下文>总上下文*ratio时压缩图片/音频/视频消息
-   * @default 0.6
-   */
-  ratioToCompactMedia?: number;
-  /**
-   * 如何压缩媒体消息，例如让其他模型用自然语言简短描述一遍
-   * @default (content) => "（已被丢弃）"
-   */
-  replacerOfMediaContent?: Compact.ReplacerOfMediaContent;
-  /**
-   * 用于标记哪些消息被软删除了
-   */
-  softDeletedMessageMark?: string;
-  /**
-   * 上下文>总上下文*ratio时清理软删除残留的占位消息
-   * @default 0.7
-   * @remarks
-   * 软删除（ratioToCompactToolResult/ratioToCompactMedia）只替换content不删消息，
-   * 该选项负责把残留的占位消息真正移除。信息在软删除时已丢失，清理不损失任何额外信息。
-   * 阈值应介于ratioToCompactMedia与ratioToSummarize之间：
-   * 太早则媒体软删还没执行、无残留可清；太晚则总结/硬删除兜底已处理整个压缩区，清理失去意义
-   */
-  ratioToClearSoftDeletedMessages?: number;
-  /**
-   * 上下文>总上下文*ratio时总结消息
-   * @default 0.8
-   * @remarks 如果总结成功，会把keepCount(默认10，见顶层选项)以前的消息压成一条消息；如果总结失败，会采取兜底压缩方法：硬删除keepCount以前的消息
-   */
-  ratioToSummarize?: number;
-  /**
-   * 总结消息时的配置项
-   * @default { model: undefined, systemPrompt: "总结历史消息" }
-   */
-  summarizeOptions?: Partial<Compact.SummarizeOptions>;
-}) => Promise<Compact.CompactResult>) & {
+declare const compact: ((messages: Message[], model: Model, options?: Compact.Options) => Promise<Compact.Result>) & {
+  compactToolResults: typeof compactToolResults;
+  compactMediaMessages: typeof compactMediaMessages;
   summarizeMessages: typeof summarizeMessages;
-  softDeleteToolResults: typeof softDeleteToolResults;
-  softDeleteOldMediaMessages: typeof softDeleteOldMediaMessages;
-  hardDeleteSoftMessages: typeof hardDeleteSoftMessages;
-  hardDeleteOldMessages: typeof hardDeleteOldMessages;
+  discardMessagesUntil: typeof discardMessagesUntil;
 };
 //#endregion
 //#region src/utils/helper.d.ts

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { a as defineTool, i as defineModel, n as get_weather_default, o as runAgent, r as get_time_default, t as compact } from "./src-BJFCp7ur.mjs";
+import { a as defineTool, i as defineModel, n as get_weather_default, o as runAgent, r as get_time_default, t as compact } from "./src-Dm0rwYe2.mjs";
 export { compact, defineModel, defineTool, get_time_default as getTime, get_weather_default as getWeather, runAgent };

package/dist/{src-BJFCp7ur.mjs → src-Dm0rwYe2.mjs}

@@ -231,246 +231,201 @@ var get_weather_default = defineTool("get_weather", "查询指定城市的天气
 //#endregion
 //#region src/utils/compact/helper.ts
 /**
-* 判断消息是否为带有工具调用的 assistant 消息
+* 校验assistant(tool_calls)消息
 */
-const hasToolCalls = (message) => message?.role === "assistant" && Array.isArray(message.tool_calls);
+const isToolCalls = (message) => {
+	return message?.role === "assistant" && Array.isArray(message.tool_calls);
+};
+/**
+* 校验多模态消息
+*/
+const isMediaMessage = (message) => {
+	const MEDIA_TYPES = [
+		"image_url",
+		"input_audio",
+		"video_url"
+	];
+	return message && Array.isArray(message.content) && message.content.some((part) => MEDIA_TYPES.includes(part.type));
+};
 /**
-* 查找tool消息所属的 assistant(tool_calls) + tool 配对组范围
+* 查找assistant(tool_calls) + tool配对组范围
 * @param messages 消息数组
-* @param toolIndex tool消息的索引
-* @returns 配对组范围 [startIndex, endIndex)（含组头assistant与其后连续的全部tool消息）；
-* 找不到配对组头时返回 null
-* @remarks 配对组约定：组头是assistant(tool_calls)，组内是紧随其后的连续tool消息。
-* 删除或切分tool消息时都应整组处理，否则会留下孤立消息导致OpenAI API返回400。
-* 组内任意一条tool消息都能定位到整组，供上层按整组范围批量操作
+* @param toolIndex 组内任意tool消息下标
+* @returns 下标数组[组头assistant(tool_calls), 组内最后一个tool)，找不到组头时返回null
 */
 const findToolGroupRange = (messages, toolIndex) => {
 	let groupStart = toolIndex;
 	while (groupStart > 0 && messages[groupStart - 1]?.role === "tool") groupStart--;
-	if (!hasToolCalls(messages[groupStart - 1])) return null;
+	if (!isToolCalls(messages[groupStart - 1])) return null;
 	let groupEnd = groupStart;
 	while (groupEnd < messages.length && messages[groupEnd]?.role === "tool") groupEnd++;
 	return [groupStart - 1, groupEnd];
 };
 //#endregion
 //#region src/utils/compact/strategy.ts
-/** 默认的软删除多模态消息策略：让大模型精简消息内容 */
+/** 默认的压缩工具结果策略：让大模型精简消息内容 */
 const defaultReplacerOfToolResultContent = async (content, options) => {
-	const { mark, model } = options ?? {};
+	const { model } = options ?? {};
 	const messages = [{
 		role: "user",
 		content
 	}, {
 		role: "user",
-		content: "请用一两句话对上条消息做个“省流”"
+		content: "请用一两句话简述上条消息"
 	}];
-	let simplifiedContent = mark;
+	let simplifiedContent = "";
 	for await (const e of runAgent(model, messages, [])) if (e.type === "content_delta") simplifiedContent += e.delta;
+	else if (e.type === "error") throw new Error(e.message);
 	return simplifiedContent;
 };
-const softDeleteToolResults = async (messages, options) => {
-	const { replacer = defaultReplacerOfToolResultContent, mark, model } = options ?? {};
-	if (!replacer && !model) return [];
-	const softDeleted = [];
-	for (const message of messages) if (message?.role === "tool" && typeof message.content === "string") {
+/**
+* @returns 实际处理了几条消息
+*/
+const compactToolResults = async (compressible, options) => {
+	const { replacer, mark, model } = options ?? {};
+	if (!replacer && !model) return 0;
+	const _replacer = replacer || defaultReplacerOfToolResultContent;
+	let count = 0;
+	for (const message of compressible) if (message?.role === "tool" && typeof message.content === "string") {
 		if (message.content.startsWith(mark)) continue;
-		message.content = await replacer(message.content, {
-			mark,
-			model
-		});
-		softDeleted.push(message);
+		message.content = mark + await _replacer(message.content, { model });
+		count++;
 	}
-	if (softDeleted.length > 0) logger(`软删除了${softDeleted.length}条工具调用结果消息`);
-	return softDeleted;
+	if (count > 0) logger(`压缩了${count}条工具调用结果`);
+	return count;
 };
-/** 默认的软删除多模态消息策略：让大模型精简消息内容 */
+/** 默认的压缩多模态消息策略：让大模型精简消息内容 */
 const defaultReplacerOfMediaContent = async (content, options) => {
-	const { mark, model } = options ?? {};
+	const { model } = options ?? {};
 	const messages = [{
 		role: "user",
 		content
 	}, {
 		role: "user",
-		content: "请用一两句话描述上方的多模态消息"
+		content: "请用一两句话简述上方的多模态消息"
 	}];
-	let simplifiedContent = mark;
+	let simplifiedContent = "";
 	for await (const e of runAgent(model, messages, [])) if (e.type === "content_delta") simplifiedContent += e.delta;
+	else if (e.type === "error") throw new Error(e.message);
 	return simplifiedContent;
 };
-const softDeleteOldMediaMessages = async (messages, options) => {
-	const { replacer = defaultReplacerOfMediaContent, mark, model } = options ?? {};
-	if (!replacer && !model) return [];
-	const mediaTypes = [
-		"image_url",
-		"input_audio",
-		"video_url"
-	];
-	const softDeleted = [];
-	for (const message of messages) if (message && Array.isArray(message.content) && message.content.some((part) => mediaTypes.includes(part.type))) {
-		message.content = await replacer(message.content, {
-			mark,
-			model
-		});
-		softDeleted.push(message);
-	}
-	if (softDeleted.length > 0) logger(`软删除了${softDeleted.length}条旧图片/音频/视频消息`);
-	return softDeleted;
-};
 /**
-* 清理软删除后残留的占位消息（信息在软删除时已丢失，此时删除不损失任何额外信息）
-* @param messages 可压缩区消息数组，直接原地删除
-* @param softDeleted 本轮被软删过的消息引用集合
-* @remarks
-* tool消息不能单独删除：OpenAI API要求assistant(tool_calls)与tool消息按tool_call_id配对，
-* 单独删掉tool会让assistant(tool_calls)变成孤立消息，后续请求返回400。
-* 因此遇到被软删的tool消息时，必须把整个assistant(tool_calls) + tool配对组一起删除。
-* 组内多条tool被软删时，集合去重后只会删除一次。
+* @returns 实际处理了几条消息
 */
-const hardDeleteSoftMessages = (messages, softDeleted) => {
-	const deleteIndices = /* @__PURE__ */ new Set();
-	for (let i = 0; i < messages.length; i++) {
-		const message = messages[i];
-		if (!message || !softDeleted.has(message)) continue;
-		if (message.role === "tool") {
-			const range = findToolGroupRange(messages, i);
-			if (range) {
-				const [start, end] = range;
-				for (let k = start; k < end; k++) deleteIndices.add(k);
-			} else deleteIndices.add(i);
-		} else deleteIndices.add(i);
+const compactMediaMessages = async (compressible, options) => {
+	const { replacer, model } = options ?? {};
+	if (!replacer && !model) return 0;
+	const _replacer = replacer || defaultReplacerOfMediaContent;
+	let count = 0;
+	for (const message of compressible) if (isMediaMessage(message)) {
+		const compacted = await _replacer(message.content, { model });
+		message.content = createXMLText("media", compacted);
+		count++;
 	}
-	const sortedIndices = [...deleteIndices].sort((a, b) => b - a);
-	for (const index of sortedIndices) if (index !== void 0) messages.splice(index, 1);
-	if (deleteIndices.size > 0) logger(`清理了${deleteIndices.size}条软删除残留消息`);
+	if (count > 0) logger(`压缩了${count}条多模态消息`);
+	return count;
 };
-const summarizeMessages = async (messages, options) => {
+const summarizeMessages = async (compressible, options) => {
 	const { model, systemPrompt } = options ?? {};
-	if (messages.length === 0) {
+	const summarizable = compressible.slice(1);
+	if (summarizable.length === 0) {
 		logger("消息太少，无需总结");
-		return;
-	}
-	const summarizableIndices = [];
-	const summarizingMessages = [];
-	for (let i = 0; i < messages.length; i++) {
-		const message = messages[i];
-		if (!message) continue;
-		if (i === 0 && message.role === "system") continue;
-		if (hasToolCalls(message)) {
-			let j = i + 1;
-			while (j < messages.length && messages[j]?.role === "tool") j++;
-			const group = messages.slice(i, j);
-			for (let k = i; k < j; k++) summarizableIndices.push(k);
-			summarizingMessages.push(...group);
-			i = j - 1;
-			continue;
-		}
-		if (message.role === "tool") continue;
-		summarizableIndices.push(i);
-		summarizingMessages.push(message);
+		return 0;
 	}
-	if (summarizableIndices.length === 0) {
-		logger("没有可总结的消息");
-		return;
-	}
-	summarizingMessages.push({
+	const count = summarizable.length;
+	summarizable.push({
 		role: "system",
 		content: systemPrompt
 	}, {
 		role: "user",
-		content: "开始总结"
+		content: "开始总结上下文"
 	});
 	let summarized = "";
 	let usage;
-	for await (const e of runAgent(model, summarizingMessages, [])) if (e.type === "content_delta") summarized += e.delta;
+	for await (const e of runAgent(model, summarizable, [])) if (e.type === "content_delta") summarized += e.delta;
 	else if (e.type === "done") usage = e.usage;
-	logger(`总结了${summarizingMessages.length}条消息，消耗：`, usage);
-	const firstIndex = summarizableIndices[0] ?? 0;
-	for (let i = summarizableIndices.length - 1; i >= 0; i--) {
-		const index = summarizableIndices[i];
-		if (index !== void 0) messages.splice(index, 1);
-	}
-	messages.splice(firstIndex, 0, {
+	else if (e.type === "error") throw new Error(e.message);
+	compressible.splice(1, Infinity, {
 		role: "user",
 		content: createXMLText("summary", summarized)
 	});
+	logger(`总结了${count}条消息，消耗：`, usage);
+	return count;
 };
-const hardDeleteOldMessages = (messages) => {
-	const startIndex = messages.findIndex((message) => message.role === "user");
-	if (startIndex < 0) {
-		logger("消息太少，无需硬删除");
-		return;
+/**
+* 最终的兜底压缩策略，从头删除旧消息，直到第二个回调函数返回true（达成目标）
+*/
+const discardMessagesUntil = (compressible, until) => {
+	let count = 0;
+	while (compressible.length > 0 && !until(compressible)) {
+		let endIndex = Math.max(1, Math.floor(compressible.length / 10));
+		if (compressible[endIndex]?.role === "tool") {
+			const range = findToolGroupRange(compressible, endIndex);
+			if (range) endIndex = range[1];
+			else while (compressible[endIndex]?.role === "tool") endIndex++;
+		}
+		count += compressible.splice(0, endIndex).length;
 	}
-	const deletedCount = messages.length - startIndex;
-	messages.splice(startIndex, deletedCount);
-	logger(`硬删除了${deletedCount}条较早的消息`);
+	logger(`丢弃了${count}条旧消息`);
+	return count;
 };
 /**
 * 自动优化上下文，类似AI Coding Agent的/compact命令
 */
 const compact = Object.assign(async (messages, model, options) => {
-	const { usage, keepCount = 10, ratioToCompactToolResult = .5, replacerOfToolResultContent, ratioToCompactMedia = .6, replacerOfMediaContent, ratioToClearSoftDeletedMessages = .7, softDeletedMessageMark = "[已简化]", ratioToSummarize = .8, summarizeOptions } = options ?? {};
+	const { usage, keepCount = 10, compactedMessageMark = "[已简化]", ratioToCompactToolResults = .6, replacerOfToolResultContent, ratioToCompactMedia = .7, replacerOfMediaContent, ratioToSummarize = .8, summarizeOptions } = options ?? {};
 	const context = model?.context ?? 131072;
 	const tokens = usage?.total_tokens ?? estimateTokens(messages);
 	const result = {
-		hasCompactedToolResult: false,
+		hasCompactedToolResults: false,
 		hasCompactedMedia: false,
-		hasClearedSoftDeletedMessages: false,
 		hasSummarized: false,
-		hasDeletedOldMessages: false
+		hasDiscardMessages: false
 	};
-	let endIndex = Math.max(0, messages.length - keepCount);
+	const startIndex = 1;
+	let endIndex = Math.max(startIndex, messages.length - keepCount);
 	if (messages[endIndex]?.role === "tool") {
 		const range = findToolGroupRange(messages, endIndex);
 		if (range) endIndex = range[1];
 		else while (messages[endIndex]?.role === "tool") endIndex++;
 	}
-	const compressible = messages.slice(0, endIndex);
-	const reserved = messages.slice(endIndex);
-	const softDeleted = /* @__PURE__ */ new Set();
-	if (tokens > context * ratioToCompactToolResult) {
-		const softDeletedMessages = await softDeleteToolResults(compressible, {
-			replacer: replacerOfToolResultContent,
-			mark: softDeletedMessageMark,
-			model
-		});
-		for (const message of softDeletedMessages) softDeleted.add(message);
-		result.hasCompactedToolResult = true;
-	}
-	if (tokens > context * ratioToCompactMedia) {
-		const softDeletedMessages = await softDeleteOldMediaMessages(compressible, {
-			replacer: replacerOfMediaContent,
-			mark: softDeletedMessageMark,
-			model
-		});
-		for (const message of softDeletedMessages) softDeleted.add(message);
-		result.hasCompactedMedia = true;
-	}
-	if (tokens > context * ratioToClearSoftDeletedMessages) {
-		hardDeleteSoftMessages(compressible, softDeleted);
-		result.hasClearedSoftDeletedMessages = true;
-		messages.splice(0, messages.length, ...compressible, ...reserved);
-	}
+	endIndex = Math.max(startIndex, endIndex);
+	const reservedStart = messages.slice(0, startIndex);
+	const compressible = messages.slice(startIndex, endIndex);
+	const reservedEnd = messages.slice(endIndex);
+	if (tokens > context * ratioToCompactToolResults) result.hasCompactedToolResults = await compactToolResults(compressible, {
+		replacer: replacerOfToolResultContent,
+		mark: compactedMessageMark,
+		model
+	}) > 0;
+	if (tokens > context * ratioToCompactMedia) result.hasCompactedMedia = await compactMediaMessages(compressible, {
+		replacer: replacerOfMediaContent,
+		model
+	}) > 0;
 	if (tokens > context * ratioToSummarize) {
 		const { systemPrompt = "你现在的任务是总结历史消息" } = summarizeOptions ?? {};
-		const [error] = await to(summarizeMessages(compressible, {
+		const [error, count] = await to(summarizeMessages(compressible, {
 			model,
 			systemPrompt
 		}));
-		result.hasSummarized = true;
-		if (error) {
-			logger(`总结失败（${error.message}），改用硬删除兜底`);
-			hardDeleteOldMessages(compressible);
-			result.hasDeletedOldMessages = true;
-		}
-		messages.splice(0, messages.length, ...compressible, ...reserved);
+		if (!error) result.hasSummarized = count > 0;
+		else result.hasDiscardMessages = discardMessagesUntil(compressible, (compressible) => {
+			if (compressible.length === 0) return true;
+			const tempMessages = [
+				...reservedStart,
+				...compressible,
+				...reservedEnd
+			];
+			return estimateTokens(tempMessages) < context * ratioToSummarize;
+		}) > 0;
+		messages.splice(0, Infinity, ...reservedStart, ...compressible, ...reservedEnd);
 	}
 	return result;
 }, {
+	compactToolResults,
+	compactMediaMessages,
 	summarizeMessages,
-	softDeleteToolResults,
-	softDeleteOldMediaMessages,
-	hardDeleteSoftMessages,
-	hardDeleteOldMessages
+	discardMessagesUntil
 });
 //#endregion
 export { defineTool as a, defineModel as i, get_weather_default as n, runAgent as o, get_time_default as r, compact as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nickyzj2023/ai",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "我的“pi”，参考了pi-from-scratch",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -32,6 +32,7 @@
     "typescript": "^7.0.2"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@nickyzj2023/utils": "link:../utils"
   },
   "scripts": {