@nickyzj2023/ai 1.2.0 → 1.3.1

package/README.md

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

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { i as defineModel, n as get_weather_default, o as runAgent, r as get_time_default } from "./src-BJFCp7ur.mjs";
+import { a as get_time_default, c as runAgent, i as get_weather_default, o as defineModel, r as loadMCPTools } from "./src-DEDOOez9.mjs";
 import { extractErrorMessage } from "@nickyzj2023/utils";
 import readline from "node:readline";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -162,16 +162,23 @@ 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/cli.ts
 /** 启动交互对话：配置来自全局配置文件，环境变量可临时覆盖 */
-const startChat = () => {
+const startChat = async () => {
 	const config = loadConfig();
 	if (!config) {
 		console.error("请先运行 `ai setup` 配置一个模型");
@@ -179,7 +186,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

@@ -1,3 +1,4 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
 //#region src/types.d.ts
 type Model = {
   baseUrl: string;
@@ -148,126 +149,156 @@ declare const _default: ToolDefinition;
 //#region src/tools/get-weather.d.ts
 declare const _default$1: ToolDefinition;
 //#endregion
+//#region src/tools/mcp.d.ts
+type McpServer = {
+  type: "streamable_http" | "sse";
+  url: string;
+  headers?: Record<string, any>;
+  ignoredToolNames?: string[];
+};
+declare class MCPRouter {
+  private entries;
+  /** 注册一个新的MCP客户端 */
+  addClient(name: string, url: string, options?: Omit<McpServer, "type" | "url">): Promise<Client<{
+    method: string;
+    params?: {
+      [x: string]: unknown;
+      _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+          taskId: string;
+        } | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    method: string;
+    params?: {
+      [x: string]: unknown;
+      _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+          taskId: string;
+        } | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    [x: string]: unknown;
+    _meta?: {
+      [x: string]: unknown;
+      progressToken?: string | number | undefined;
+      "io.modelcontextprotocol/related-task"?: {
+        taskId: string;
+      } | undefined;
+    } | undefined;
+  }> | undefined>;
+  /** 返回OpenAI API兼容的tools数组 */
+  getTools(): Promise<ToolDefinition[]>;
+}
+/**
+ * 把传入的MCPServer列表转换成OpenAI API兼容的tools数组
+ */
+declare const loadMCPTools: (mcpServers: Record<string, McpServer>) => Promise<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
@@ -282,4 +313,4 @@ declare const defineModel: (config: Model) => Model;
  */
 declare const defineTool: (name: ToolDefinition["function"]["name"], description: ToolDefinition["function"]["description"], properties: ToolDefinition["function"]["parameters"]["properties"], execute: ToolDefinition["execute"]) => ToolDefinition;
 //#endregion
-export { type AgentEvent, type AudioContent, type ChatCompletionsChunk, type ContentPart, type FinishReason, type ImageContent, type LLMEvent, type Message, type Modality, type Model, type TextContent, type ToolCall, type ToolDefinition, type Usage, type VideoContent, compact, defineModel, defineTool, _default as getTime, _default$1 as getWeather, runAgent };
+export { type AgentEvent, type AudioContent, type ChatCompletionsChunk, type ContentPart, type FinishReason, type ImageContent, type LLMEvent, MCPRouter, McpServer, type Message, type Modality, type Model, type TextContent, type ToolCall, type ToolDefinition, type Usage, type VideoContent, compact, defineModel, defineTool, _default as getTime, _default$1 as getWeather, loadMCPTools, runAgent };

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";
-export { compact, defineModel, defineTool, get_time_default as getTime, get_weather_default as getWeather, runAgent };
+import { a as get_time_default, c as runAgent, i as get_weather_default, n as MCPRouter, o as defineModel, r as loadMCPTools, s as defineTool, t as compact } from "./src-DEDOOez9.mjs";
+export { MCPRouter, compact, defineModel, defineTool, get_time_default as getTime, get_weather_default as getWeather, loadMCPTools, runAgent };

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

@@ -1,4 +1,6 @@
-import { createXMLText, fetcher, logger, parseSSE, pick, to } from "@nickyzj2023/utils";
+import { createXMLText, extractErrorMessage, fetcher, isObject, logger, omit, parseSSE, pick, to } from "@nickyzj2023/utils";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 //#region src/llm.ts
 /**
 * 分离ToolDefinition中的valid/invalid字段，前者可以传给模型，后者用于本地运算
@@ -229,248 +231,258 @@ var get_weather_default = defineTool("get_weather", "查询指定城市的天气
 	return fetcher("https://wttr.in", { params: { format: "j1" } }).get(`/${city}`);
 });
 //#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"]));
+			logger(`已激活MCP客户端：${name}`);
+		} catch (e) {
+			logger(`MCP服务器${name}连接失败，跳过：${extractErrorMessage(e)}`);
+		}
+	}));
+	return router.getTools();
+};
+//#endregion
 //#region src/utils/compact/helper.ts
 /**
-* 判断消息是否为带有工具调用的 assistant 消息
+* 校验assistant(tool_calls)消息
+*/
+const isToolCalls = (message) => {
+	return message?.role === "assistant" && Array.isArray(message.tool_calls);
+};
+/**
+* 校验多模态消息
 */
-const hasToolCalls = (message) => 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);
-	}
-	if (summarizableIndices.length === 0) {
-		logger("没有可总结的消息");
-		return;
+		return 0;
 	}
-	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 };
+export { get_time_default as a, runAgent as c, get_weather_default as i, MCPRouter as n, defineModel as o, loadMCPTools as r, defineTool as s, compact as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nickyzj2023/ai",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "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": {