alemonjs-aichat 1.0.37 → 1.0.39

package/lib/config.js

@@ -5,6 +5,7 @@ import { redis } from './redis.js';
 
 const TOOL_LOOP_TTL_SECONDS = 600;
 const TOOL_LOOP_STALE_MS = TOOL_LOOP_TTL_SECONDS * 1000;
+const DEFAULT_CAPI_CONTEXT_LIMIT = 256000;
 class db {
     redis;
     systemPrompt = "";
@@ -207,6 +208,19 @@ class db {
     }
     /** --------------------------------------------------------- */
     /** 工具相关配置 */
+    /** 获取 CAPI 自动压缩上下文长度 */
+    async getCAPIContextLimit(guid) {
+        const raw = await this.redis.get(`ai:capi_context_limit:${guid}`);
+        const limit = Number(raw);
+        return Number.isFinite(limit) && limit > 0
+            ? Math.floor(limit)
+            : DEFAULT_CAPI_CONTEXT_LIMIT;
+    }
+    /** 设置 CAPI 自动压缩上下文长度 */
+    async setCAPIContextLimit(guid, limit) {
+        const normalized = Math.max(1, Math.floor(limit));
+        await this.redis.set(`ai:capi_context_limit:${guid}`, String(normalized));
+    }
     /** 获取工具开关状态 */
     async getToolSwitch(guid) {
         return (await this.redis.get(`ai:tool:switch:${guid}`)) || "1";
@@ -239,6 +253,14 @@ class db {
     async setToolPromptArgsSwitch(guid, enable) {
         await this.redis.set(`ai:tool_prompt_args:switch:${guid}`, enable ? "1" : "0");
     }
+    /** 工具调用前是否发送模型返回的 content */
+    async getToolCallContentSwitch(guid) {
+        return (await this.redis.get(`ai:tool_call_content:switch:${guid}`)) || "0";
+    }
+    /** 设置工具调用前 content 发送开关状态 */
+    async setToolCallContentSwitch(guid, enable) {
+        await this.redis.set(`ai:tool_call_content:switch:${guid}`, enable ? "1" : "0");
+    }
     /** --------------------------------------------------------- */
     /** 获取复杂输出开关状态 */
     async getComplexOutput(guid) {
@@ -1189,4 +1211,4 @@ class db {
 }
 const redisClient = new db(redis);
 
-export { redisClient as default };
+export { DEFAULT_CAPI_CONTEXT_LIMIT, redisClient as default };

package/lib/data/help.json.js

@@ -1,7 +1,7 @@
 var title = "IA聊天插件";
 var desc = "一个基于AI的聊天插件，支持多种AI模型和丰富的功能配置，适用于各种聊天场景。";
 var name = "alemonjs-aichat";
-var version = "v1.0.32";
+var version = "v1.0.39";
 var by = "AlemonJS";
 var list = [
 	{
@@ -136,6 +136,14 @@ var list = [
 				{
 					cmd: "/清空对话",
 					desc: "清空当前页面的对话记录。"
+				},
+				{
+					cmd: "/设置AI上下文长度 [256k|1m]",
+					desc: "设置 CAPI 模式自动压缩上下文的长度，默认 256k。"
+				},
+				{
+					cmd: "/撤回",
+					desc: "引用一条消息发送撤回指令，自动撤回被引用的消息。"
 				}
 			]
 		}
@@ -200,6 +208,10 @@ var list = [
 				{
 					cmd: "/[开启|关闭]工具提示详情",
 					desc: "开启或关闭工具调用提示详情功能。开启后工具调用的提示消息会包含更多的详情信息。"
+				},
+				{
+					cmd: "/[开启|关闭]工具调用内容",
+					desc: "开启或关闭工具调用前模型返回内容的发送。开启后会发送工具调用响应中 content 的内容。"
 				}
 			]
 		}

package/lib/image/conponent/AiConfig.js

@@ -9,6 +9,8 @@ const cmds = [
     { cmd: "/切换模型 <模型名称>", desc: "切换当前使用的AI模型" },
     { cmd: "/<开启|关闭>仅艾特触发", desc: "开启或关闭仅艾特触发功能" },
     { cmd: "/<开启|关闭>工具", desc: "开启或关闭AI工具" },
+    { cmd: "/<开启|关闭>工具调用内容", desc: "开启或关闭工具调用前内容发送" },
+    { cmd: "/设置AI上下文长度 256k", desc: "设置CAPI自动压缩上下文长度" },
     { cmd: "/<开启|关闭>复杂输出", desc: "开启或关闭复杂输出" },
     { cmd: "/<开启|关闭>好感度", desc: "开启或关闭好感度系统" },
     { cmd: "/清空对话", desc: "清空当前对话历史" },
@@ -76,7 +78,11 @@ function App(data) {
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u603B\u5F00\u5173", value: data.tools }),
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A", value: data.toolPromptSwitch }),
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u64A4\u56DE", value: data.toolPromptRevokeSwitch }),
-                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u4F20\u53C2", value: data.toolPromptArgsSwitch })),
+                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u4F20\u53C2", value: data.toolPromptArgsSwitch }),
+                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u8C03\u7528\u5185\u5BB9", value: data.toolCallContentSwitch }),
+                        React.createElement("div", { className: "flex items-center justify-between py-2 px-2 rounded-lg bg-white/5" },
+                            React.createElement("span", { className: " text-white/70" }, "CAPI\u4E0A\u4E0B\u6587\u957F\u5EA6"),
+                            React.createElement("span", { className: "px-3 py-0.5 rounded-full text-xs font-mono font-medium border bg-cyan-500/20 text-cyan-300 border-cyan-500/30" }, data.capiContextLimit))),
                     React.createElement("div", { className: "pt-2 border-t border-white/10" },
                         React.createElement("div", { className: "flex items-center justify-between py-2" },
                             React.createElement("span", { className: " text-white/60" }, "\u5F53\u524D\u4F7F\u7528\u6A21\u578B"),

package/lib/middleware/mw.js

@@ -177,6 +177,7 @@ var mw = onMiddleware(selects, async (event, next) => {
         // 处理回复消息
         const replyData = event.value.message.find((item) => item.type === "reply");
         if (replyData) {
+            event["replyMessageId"] = String(replyData.data.id);
             const msg = await onebotClient.getMsg({
                 message_id: Number(replyData.data.id),
             });
@@ -233,6 +234,7 @@ var mw = onMiddleware(selects, async (event, next) => {
         })
             .join("");
         if (event.replyId && event.replyId !== "-1") {
+            event["replyMessageId"] = String(event.replyId);
             const replyMsg = await client.getMessage(event.replyId);
             console.log("获取回复", replyMsg);
             if (replyMsg) {
@@ -276,6 +278,7 @@ var mw = onMiddleware(selects, async (event, next) => {
                 ? [CDN_URL + event.value.fileMeta.url]
                 : [];
         if (event.value.replyToId) {
+            event["replyMessageId"] = String(event.value.replyToId);
             const channelMessages = await client.request({
                 method: "GET",
                 url: `/channels/${event.ChannelId}/messages/${event.value.replyToId}`,

package/lib/response/config/res.js

@@ -54,44 +54,60 @@ const archiveCurrentConversation = async (guid, reason, aiConfig) => {
         reason,
     });
 };
-const formatTokenValue = (value) => {
+const statusNumberFormatter = new Intl.NumberFormat("zh-CN");
+const formatNumberValue = (value) => {
     return typeof value === "number" && Number.isFinite(value)
-        ? String(value)
+        ? statusNumberFormatter.format(value)
         : "未知";
 };
-const formatAIContextStatus = (stats) => {
+const formatTokenValue = (value) => {
+    return formatNumberValue(value);
+};
+const formatContextLimit = (tokens) => {
+    if (tokens >= 1000000 && tokens % 1000000 === 0) {
+        return `${tokens / 1000000}m`;
+    }
+    if (tokens >= 1000 && tokens % 1000 === 0) {
+        return `${tokens / 1000}k`;
+    }
+    return `${tokens}`;
+};
+const formatAIContextStatus = (stats, capiContextLimit) => {
     if (!stats) {
-        return "当前会话还没有 CAPI 上下文统计。";
+        return `当前会话还没有 CAPI 上下文统计。\nCAPI上下文长度: ${formatContextLimit(capiContextLimit)}`;
     }
     const updatedAt = new Date(stats.updatedAt).toLocaleString("zh-CN", {
         hour12: false,
     });
     const usageNote = stats.usageAvailable
         ? ""
-        : "\n提示: 最近一次请求未返回 usage, 实际 token 统计可能不完整。";
+        : "提示: 最近一次请求未返回 usage, 实际 token 统计可能不完整。";
+    const divider = "················";
     return [
         "当前AI状态：",
+        divider,
         `模式: ${stats.mode.toUpperCase()}`,
         `模型: ${stats.model || "未知"}`,
         `更新时间: ${updatedAt}`,
-        `请求次数: ${stats.requestCount}`,
-        "",
+        `请求次数: ${formatNumberValue(stats.requestCount)}`,
+        divider,
         "最近一次上下文：",
-        `消息数: ${stats.contextMessageCount}`,
-        `上下文字符数: ${stats.contextCharLength}`,
-        `上下文估算token: ${stats.estimatedContextTokens}`,
+        `CAPI上下文长度: ${formatContextLimit(capiContextLimit)}`,
+        `消息数: ${formatNumberValue(stats.contextMessageCount)}`,
+        `上下文字符数: ${formatNumberValue(stats.contextCharLength)}`,
+        `上下文估算token: ${formatTokenValue(stats.estimatedContextTokens)}`,
         `输入token: ${formatTokenValue(stats.promptTokens)}`,
         `输出token: ${formatTokenValue(stats.completionTokens)}`,
         `总token: ${formatTokenValue(stats.totalTokens)}`,
         `缓存命中token: ${formatTokenValue(stats.cachedTokens)}`,
         `缓存未命中token: ${formatTokenValue(stats.cacheMissTokens)}`,
-        "",
+        divider,
         "当前会话累计：",
-        `输入token: ${stats.totalPromptTokens}`,
-        `输出token: ${stats.totalCompletionTokens}`,
-        `总token: ${stats.totalTokensUsed}`,
-        `缓存命中token: ${stats.totalCachedTokens}`,
-        `缓存未命中token: ${stats.totalCacheMissTokens}`,
+        `输入token: ${formatTokenValue(stats.totalPromptTokens)}`,
+        `输出token: ${formatTokenValue(stats.totalCompletionTokens)}`,
+        `总token: ${formatTokenValue(stats.totalTokensUsed)}`,
+        `缓存命中token: ${formatTokenValue(stats.totalCachedTokens)}`,
+        `缓存未命中token: ${formatTokenValue(stats.totalCacheMissTokens)}`,
         usageNote,
     ]
         .filter((line) => line !== "")
@@ -104,7 +120,8 @@ var res = onResponse(selects, async (e, next) => {
     // 查看AI状态
     if (/^(\/|#)ai状态$/i.test(e.msg)) {
         const stats = await redisClient.getAIContextStats(e.guid);
-        message.send(format(Text(formatAIContextStatus(stats))));
+        const capiContextLimit = await redisClient.getCAPIContextLimit(e.guid);
+        message.send(format(Text(formatAIContextStatus(stats, capiContextLimit))));
     }
     // 查看AI配置
     if (/^(\/|#)(ai配置|当前提示词|查看提示词)$/i.test(e.msg)) {
@@ -121,6 +138,8 @@ var res = onResponse(selects, async (e, next) => {
         const toolPromptSwitch = await redisClient.getToolPromptSwitch(e.guid); // 工具提示开关
         const toolPromptRevokeSwitch = await redisClient.getToolPromptRevokeSwitch(e.guid); // 工具提示撤回开关
         const toolPromptArgsSwitch = await redisClient.getToolPromptArgsSwitch(e.guid); // 工具提示传参开关
+        const toolCallContentSwitch = await redisClient.getToolCallContentSwitch(e.guid); // 工具调用内容发送开关
+        const capiContextLimit = await redisClient.getCAPIContextLimit(e.guid);
         // 发送消息
         try {
             const scale = await redisClient.getRenderPrecision(e.guid);
@@ -141,6 +160,8 @@ var res = onResponse(selects, async (e, next) => {
                 toolPromptSwitch: toolPromptSwitch == "1",
                 toolPromptRevokeSwitch: toolPromptRevokeSwitch == "1",
                 toolPromptArgsSwitch: toolPromptArgsSwitch == "1",
+                toolCallContentSwitch: toolCallContentSwitch == "1",
+                capiContextLimit: formatContextLimit(capiContextLimit),
             }, {
                 playwright: {
                     context: { deviceScaleFactor: scale },
@@ -150,11 +171,11 @@ var res = onResponse(selects, async (e, next) => {
                 message.send(format(Image(img)));
             }
             else {
-                message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
+                message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`工具调用内容: ${toolCallContentSwitch == "1" ? "开启" : "关闭"}\n`), Text(`CAPI上下文长度: ${formatContextLimit(capiContextLimit)}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
             }
         }
         catch (error) {
-            message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
+            message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`工具调用内容: ${toolCallContentSwitch == "1" ? "开启" : "关闭"}\n`), Text(`CAPI上下文长度: ${formatContextLimit(capiContextLimit)}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
         }
     }
     // 查看AI列表

package/lib/response/revoke/res.js

@@ -0,0 +1,34 @@
+import { useMessage, Text } from 'alemonjs';
+
+const selects = onSelects(["message.create", "private.message.create"]);
+const normalizeMessageId = (value) => {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text === "" || text === "-1" ? undefined : text;
+};
+const getReplyMessageId = (e) => {
+    const replySegment = Array.isArray(e.value?.message)
+        ? e.value.message.find((item) => item?.type === "reply")
+        : undefined;
+    return (normalizeMessageId(e.replyMessageId) ||
+        normalizeMessageId(replySegment?.data?.id) ||
+        normalizeMessageId(e.replyId) ||
+        normalizeMessageId(e.value?.replyToId) ||
+        normalizeMessageId(e.reply?.message_id) ||
+        normalizeMessageId(e.reply?.id));
+};
+var res = onResponse(selects, async (e) => {
+    const [message] = useMessage(e);
+    const targetMessageId = getReplyMessageId(e);
+    if (!targetMessageId) {
+        await message.send(format(Text("请引用一条消息后再发送 /撤回")));
+        return;
+    }
+    const result = await message.delete({ messageId: targetMessageId });
+    if (result.code !== 2000) {
+        await message.send(format(Text("撤回失败，可能是平台不支持或机器人没有权限")));
+    }
+});
+
+export { res as default, selects };

package/lib/response/setting/res.js

@@ -8,6 +8,21 @@ const value = getConfigValue().aiChat || {};
 const selects = onSelects(["message.create", "private.message.create"]);
 // inline regex checks are used in-place; keep `test` as shorthand
 const test = /(\/|#)测试$/i;
+const capiContextLimitCommand = /^(#|\/)设置(AI)?上下文(长度)? ?([0-9]+)(k|m)$/i;
+const formatContextLimit = (tokens) => {
+    if (tokens >= 1000000 && tokens % 1000000 === 0) {
+        return `${tokens / 1000000}m`;
+    }
+    if (tokens >= 1000 && tokens % 1000 === 0) {
+        return `${tokens / 1000}k`;
+    }
+    return `${tokens}`;
+};
+const parseContextLimit = (value, unit) => {
+    const count = Number(value);
+    const multiplier = unit.toLowerCase() === "m" ? 1000000 : 1000;
+    return Math.floor(count * multiplier);
+};
 var res = onResponse(selects, async (e, next) => {
     // 创建
     const [message] = useMessage(e);
@@ -281,6 +296,23 @@ var res = onResponse(selects, async (e, next) => {
         message.send(format(Text(`已将当前 AI 的模型修改为 ${modelName.trim()} !`)));
         return;
     }
+    // 设置 CAPI 自动压缩上下文长度
+    if (capiContextLimitCommand.test(e.msg)) {
+        const match = e.msg.match(capiContextLimitCommand);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/设置AI上下文长度 256k 进行设置")));
+            return;
+        }
+        const [, , , , value, unit] = match;
+        const limit = parseContextLimit(value, unit);
+        if (!Number.isFinite(limit) || limit <= 0) {
+            message.send(format(Text("上下文长度必须大于 0，例如：/设置AI上下文长度 256k")));
+            return;
+        }
+        await redisClient.setCAPIContextLimit(e.guid, limit);
+        message.send(format(Text(`已设置 CAPI 上下文长度为 ${formatContextLimit(limit)}，接近 90% 时会自动压缩上下文。`)));
+        return;
+    }
     // 设置复杂输出开关
     if (/(\/|#)(关闭|开启)复杂(输出|回复)$/i.test(e.msg)) {
         const match = e.msg.match(/(\/|#)(关闭|开启)复杂(输出|回复)$/i);
@@ -493,6 +525,22 @@ var res = onResponse(selects, async (e, next) => {
         message.send(format(Text(`已${enable ? "开启" : "关闭"}工具提示详情功能 !`)));
         return;
     }
+    // 控制工具调用前 content 发送开关
+    if (/(\/|#)(开启|关闭)工具调用内容$/i.test(e.msg)) {
+        if (!e.IsMaster) {
+            return;
+        }
+        const match = e.msg.match(/(\/|#)(开启|关闭)工具调用内容$/i);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/开启工具调用内容 或 /关闭工具调用内容 进行设置")));
+            return;
+        }
+        const [, , action] = match;
+        const enable = action === "开启";
+        await redisClient.setToolCallContentSwitch(e.guid, enable);
+        message.send(format(Text(`已${enable ? "开启" : "关闭"}工具调用内容发送功能 !`)));
+        return;
+    }
     // 控制工具开关
     if (/(\/|#)(开启|关闭)工具(.*)$/i.test(e.msg)) {
         if (!e.IsMaster) {

package/lib/response/zreply/capi.js

@@ -3,13 +3,16 @@ import { log } from 'console';
 import OpenAi from 'openai';
 import { TTSClient } from '../../api/tts.js';
 import { availableTools } from '../../api/aitools.js';
-import redisClient from '../../config.js';
+import redisClient, { DEFAULT_CAPI_CONTEXT_LIMIT } from '../../config.js';
 import { getChatConfig, shouldSkipAIReply, buildUserMessage, getDeepThoughtReasoning } from './getChatConfig.js';
 import { createTTSMessage } from './tts.js';
 import { parseAIReply } from './tools.js';
 
 const selects = onSelects(["message.create", "private.message.create"]);
 let currentModel = "派蒙-默认"; // 默认音色
+const CAPI_CONTEXT_COMPRESSION_RATIO = 0.9;
+const CAPI_CONTEXT_RETAIN_RATIO = 0.35;
+const AUTO_SUMMARY_DETAIL_MAX_LENGTH = 2000;
 const sendAIReply = async (reply, cfg, e, message) => {
     const aireply = await parseAIReply(reply, cfg, e, message);
     console.log("aireply", aireply);
@@ -55,6 +58,69 @@ const getTextLength = (value) => {
     }
     return 0;
 };
+const estimateContextTokens = (value) => {
+    return Math.ceil(getTextLength(value) / 4);
+};
+const trimText = (text, maxLength) => {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength)}...`;
+};
+const takeTailMessagesWithinTokenBudget = (history, tokenBudget) => {
+    const kept = [];
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        kept.unshift(history[index]);
+        if (estimateContextTokens(kept) > tokenBudget) {
+            kept.shift();
+            break;
+        }
+    }
+    return kept;
+};
+const buildAutoSummaryMessage = (record) => {
+    const summary = record?.summary || "较早对话已自动归档";
+    const detail = trimText(record?.detail || record?.transcript || "无详细摘要", AUTO_SUMMARY_DETAIL_MAX_LENGTH);
+    return {
+        role: "system",
+        content: [
+            "【自动压缩上下文】",
+            `较早对话已归档为 ${record?.id || "未知ID"}，当前上下文只保留摘要和最近消息。`,
+            `摘要: ${summary}`,
+            `详细信息: ${detail}`,
+            "如需更完整内容，可按归档ID或关键词调用 MemoryOperation 检索历史归档。",
+        ].join("\n"),
+    };
+};
+const prepareCapiMessagesForRequest = async (guid, systemMessage, currentMessages) => {
+    const limit = await redisClient.getCAPIContextLimit(guid);
+    const threshold = Math.floor(limit * CAPI_CONTEXT_COMPRESSION_RATIO);
+    const estimatedTokens = estimateContextTokens(currentMessages);
+    if (estimatedTokens < threshold) {
+        return currentMessages;
+    }
+    const history = await redisClient.getAIChatHistory(guid);
+    if (history.length === 0) {
+        return currentMessages;
+    }
+    const archived = await redisClient.archiveAIChatHistory(guid, {
+        reason: "auto_context_compress",
+    });
+    if (!archived) {
+        return currentMessages;
+    }
+    const minRetainBudget = Math.min(Math.floor(DEFAULT_CAPI_CONTEXT_LIMIT * 0.05), Math.floor(limit * 0.5));
+    const retainBudget = Math.max(Math.floor(limit * CAPI_CONTEXT_RETAIN_RATIO), minRetainBudget);
+    const keptHistory = takeTailMessagesWithinTokenBudget(history, retainBudget);
+    const compressedHistory = [buildAutoSummaryMessage(archived), ...keptHistory];
+    await redisClient.setAIChatHistory(guid, compressedHistory);
+    const rebuiltMessages = [systemMessage, ...compressedHistory];
+    const pendingMessages = currentMessages.slice(Math.max(1 + history.length, 1));
+    rebuiltMessages.push(...pendingMessages);
+    log(`CAPI上下文接近上限，已自动压缩：${estimatedTokens}/${limit} tokens，归档ID:${archived.id}`);
+    return rebuiltMessages;
+};
 const getNumber = (value) => {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 };
@@ -84,7 +150,7 @@ const recordCapiContextStats = async (guid, model, messages, completion) => {
         model,
         contextMessageCount: messages.length,
         contextCharLength,
-        estimatedContextTokens: Math.ceil(contextCharLength / 4),
+        estimatedContextTokens: estimateContextTokens(messages),
         promptTokens,
         completionTokens,
         totalTokens: getNumber(usage?.total_tokens),
@@ -110,14 +176,16 @@ const CApiReply = async (e) => {
             apiKey: cfg.config.key,
             timeout: 300000,
         });
+        const systemMessage = {
+            role: "system",
+            content: cfg.systemPrompt + `\n性格约束:${cfg.config.systemPrompt}`,
+        };
         let messages = [
-            {
-                role: "system",
-                content: cfg.systemPrompt + `\n性格约束:${cfg.config.systemPrompt}`,
-            },
+            systemMessage,
             ...cfg.historyMessages,
             usermessage,
         ];
+        messages = await prepareCapiMessagesForRequest(e.guid, systemMessage, messages);
         const createParams = {
             model: cfg.config.model,
             messages: messages,
@@ -165,7 +233,9 @@ const CApiReply = async (e) => {
             return;
         }
         await redisClient.addAIChatHistory(e.guid, usermessage);
-        if (res.choices[0].message?.tool_calls && fullContent.trim() !== "") {
+        if (cfg.toolConfig.toolCallContentSwitch === "1" &&
+            res.choices[0].message?.tool_calls &&
+            fullContent.trim() !== "") {
             await sendAIReply(fullContent, cfg, e, message);
         }
         // 检查是否有工具调用需要处理
@@ -180,6 +250,7 @@ const CApiReply = async (e) => {
                     if (pendingGuidanceMessages.length === 0) {
                         break;
                     }
+                    messages = await prepareCapiMessagesForRequest(e.guid, systemMessage, messages);
                     log("工具调用完成后收到补充引导，继续请求模型：", pendingGuidanceMessages.length);
                     const params = {
                         model: cfg.config.model,
@@ -284,6 +355,7 @@ const CApiReply = async (e) => {
                 if (guidanceMessages.length > 0) {
                     log("工具调用期间收到补充引导：", guidanceMessages.length);
                 }
+                messages = await prepareCapiMessagesForRequest(e.guid, systemMessage, messages);
                 const params = {
                     model: cfg.config.model,
                     messages: messages,

package/lib/response/zreply/getChatConfig.js

@@ -60,6 +60,8 @@ const getChatConfig = async (e) => {
     const atTriggerSwitch = await redisClient.getAtTriggerSwitch(e.guid);
     /** 历史消息 */
     const historyMessages = await redisClient.getAIChatHistory(e.guid);
+    /** CAPI 自动压缩上下文长度 */
+    const capiContextLimit = await redisClient.getCAPIContextLimit(e.guid);
     /** 好感度信息 */
     const affections = await redisClient.getAffectionLevelAll(e.guid);
     /** 工具相关配置 */
@@ -75,6 +77,8 @@ const getChatConfig = async (e) => {
         toolPromptRevokeSwitch: await redisClient.getToolPromptRevokeSwitch(e.guid),
         /** 工具提示传参开关 */
         toolPromptArgsSwitch: await redisClient.getToolPromptArgsSwitch(e.guid),
+        /** 工具调用前 content 发送开关 */
+        toolCallContentSwitch: await redisClient.getToolCallContentSwitch(e.guid),
     };
     /** 技能列表 */
     const skills = loadSkills();
@@ -83,33 +87,34 @@ const getChatConfig = async (e) => {
     /** 机器人昵称 */
     const botName = e.bot.nickname || "小咸鱼";
     const memoryPrompt = relevantMemoryContext
-        ? `
-  ## 系统预检索记忆
-  以下内容是系统根据当前话题自动检索到的相关长期记忆和历史归档, 回答时优先参考与当前话题直接相关的部分; 如果与用户本轮最新表述冲突, 以用户本轮消息为准
-  ${relevantMemoryContext}
+        ? `
+  ## 系统预检索记忆
+  以下内容是系统根据当前话题自动检索到的相关长期记忆和历史归档, 回答时优先参考与当前话题直接相关的部分; 如果与用户本轮最新表述冲突, 以用户本轮消息为准
+  ${relevantMemoryContext}
   `
         : "";
     /** 系统提示词 */
-    const systemPrompt = `
-  # AI助手回复规范
-  请严格按照以下规范进行回复, 不要添加任何不必要的内容, 也不要删除或修改规范中的任何内容, 以确保回复能够被正确解析和处理
-  
-  ## 技能
-  在遇到用户需要执行特定操作时,先获取对应的技能,如果有可用技能,获取该技能,并严格按照技能文档要求的格式调用, 不要添加任何多余的内容, 也不要删除或修改规范中的任何内容, 以确保技能能够被正确解析和处理
-  当没有技能可以应对需求时, 就自行挑选合适的工具函数来完成用户的需求
-  如果用户提到本地仓库、知识库、参考项目、之前克隆过的项目，或者你准备说"本地没有"、"仓库里没有"、"没找到"之类的话，必须先检查 public/{guid} 内现有内容，优先搜索 knowledge/ 目录；至少先调用一次 AgentSearchFiles、AgentListFiles 或读取相关技能后再下结论
-  如果你不知道之前项目所在的 guid，先调用 AgentListWorkspaces 找到 public/ 下已有工作目录，再继续用 AgentListFiles、AgentSearchFiles 或 AgentReadFileLines；不要用 exec 查 public/{guid}，因为 exec 的默认工作目录不是那里
-  如果用户要查看分支、确认当前分支、查看远端或切换分支，优先使用 AgentGitOperation，不要自己拼 git commit、push、pull、merge、rebase、reset 等命令
-  如果用户在继续之前的话题、问你记不记得、提到上次/刚才/之前聊过的内容，先参考“系统预检索记忆”；如果系统预检索内容还不够，再调用 MemoryOperation，优先使用 chatHistory 的 search:关键词 或 guid:id 去补充历史上下文，然后再回答
-  
-  调用执行脚本类型的工具时, 务必确保脚本安全, 不得执行对服务器有伤害的脚本
-  ---
-  技能列表:
-  ${skills.map((skill) => `- ${skill.name}: ${skill.description}`).join("\n")}
-  ---
-  ${memoryPrompt}
-  
-  ## 关于回复格式:
+    const systemPrompt = `
+  # AI助手回复规范
+  请严格按照以下规范进行回复, 不要添加任何不必要的内容, 也不要删除或修改规范中的任何内容, 以确保回复能够被正确解析和处理
+  
+  ## 技能
+  在遇到用户需要执行特定操作时,先获取对应的技能,如果有可用技能,获取该技能,并严格按照技能文档要求的格式调用, 不要添加任何多余的内容, 也不要删除或修改规范中的任何内容, 以确保技能能够被正确解析和处理
+  当没有技能可以应对需求时, 就自行挑选合适的工具函数来完成用户的需求
+  如果用户提到本地仓库、知识库、参考项目、之前克隆过的项目，或者你准备说"本地没有"、"仓库里没有"、"没找到"之类的话，必须先检查 public/{guid} 内现有内容，优先搜索 knowledge/ 目录；至少先调用一次 AgentSearchFiles、AgentListFiles 或读取相关技能后再下结论
+  如果你不知道之前项目所在的 guid，先调用 AgentListWorkspaces 找到 public/ 下已有工作目录，再继续用 AgentListFiles、AgentSearchFiles 或 AgentReadFileLines；不要用 exec 查 public/{guid}，因为 exec 的默认工作目录不是那里
+  如果用户需要直接执行服务器运维指令、查看服务状态、管理 Docker/PM2/systemctl、查看日志或部署服务，使用 RunServerCommand；它会自动审核指令安全，不要改用 exec。调用 RunServerCommand 时 reviewGuid 必填，必须传下方环境信息里的“当前群号(reviewGuid)”，不要传 public/{guid} 工作目录ID
+  如果用户要查看分支、确认当前分支、查看远端或切换分支，优先使用 AgentGitOperation，不要自己拼 git commit、push、pull、merge、rebase、reset 等命令
+  如果用户在继续之前的话题、问你记不记得、提到上次/刚才/之前聊过的内容，先参考“系统预检索记忆”；如果系统预检索内容还不够，再调用 MemoryOperation，优先使用 chatHistory 的 search:关键词 或 guid:id 去补充历史上下文，然后再回答
+  
+  调用执行脚本类型的工具时, 务必确保脚本安全, 不得执行对服务器有伤害的脚本
+  ---
+  技能列表:
+  ${skills.map((skill) => `- ${skill.name}: ${skill.description}`).join("\n")}
+  ---
+  ${memoryPrompt}
+  
+  ## 关于回复格式:
   ### 用户发言
   - 格式: [私聊]用户昵称(用户id)(发送时间):消息内容
   当场景为私聊时, 用户昵称前方会出现[私聊]标识
@@ -158,15 +163,15 @@ const getChatConfig = async (e) => {
   #### 基础状态信息:
   这里的信息会实时变化,根据需要进行获取使用
   当前群时间:${getGroupTimeString()}
-  当前群号:${e.guid}
+  当前群号(reviewGuid):${e.guid}
   当前群名称:${e.GroupName || "无"}
   当前聊天平台:${e.Platform}
   当前框架:alemonjs-aichat
   ${e.ClientError ? `当前错误信息:${e.ClientError}` : ""}
   `;
-    const RapiSystemPrompt = `
-请严格按照以下规范进行回复, 以确保回复能够被正确解析和处理
-1. 文本消息：
+    const RapiSystemPrompt = `
+请严格按照以下规范进行回复, 以确保回复能够被正确解析和处理
+1. 文本消息：
 ${botName}::text<<<EOF
 文本内容
 EOF
@@ -185,14 +190,14 @@ ${botName}::audio voice=音色 内容
 =====================
 
 - 不允许使用任何其他格式
-- 不允许输出解释说明
-- 不允许夹杂 markdown
-- tool调用前可以先输出一行说明
-- 每一条输出必须独立一行
-- 允许多段输出叠加, 例如:
-${botName}::text 这是第一条消息
-${botName}::text 这是第二条消息
-${memoryPrompt ? `\n【系统预检索记忆】\n${relevantMemoryContext}\n` : ""}
+- 不允许输出解释说明
+- 不允许夹杂 markdown
+- tool调用前可以先输出一行说明
+- 每一条输出必须独立一行
+- 允许多段输出叠加, 例如:
+${botName}::text 这是第一条消息
+${botName}::text 这是第二条消息
+${memoryPrompt ? `\n【系统预检索记忆】\n${relevantMemoryContext}\n` : ""}
   `;
     return {
         /** AI配置 */
@@ -220,6 +225,8 @@ ${memoryPrompt ? `\n【系统预检索记忆】\n${relevantMemoryContext}\n` : "
         skills,
         /** 历史消息 */
         historyMessages,
+        /** CAPI 自动压缩上下文长度 */
+        capiContextLimit,
         /** 好感度信息 */
         affections,
         /** 工具配置 */

package/lib/response/zreply/tools.js

@@ -1,4 +1,4 @@
-import { format, Audio, Mention, Text, ImageURL, ImageFile } from 'alemonjs';
+import { format, Audio, ImageURL, ImageFile, Text, Mention } from 'alemonjs';
 import redisClient from '../../config.js';
 import { TTSClient } from '../../api/tts.js';
 import { createTTSMessage } from './tts.js';