@myassis/gateway 1.0.88 → 1.0.90

package/dist/config/index.js

@@ -103,6 +103,20 @@ exports.appConfig = {
     oldToolContentLimit: parseInt(process.env.OLD_TOOL_CONTENT_LIMIT || '500', 10),
     /** 单次请求内最大工具调用轮数 */
     maxToolRounds: parseInt(process.env.MAX_TOOL_ROUNDS || '200', 10),
+    /**
+     * 轮内压缩触发阈值（字符）。
+     *
+     * 会话级压缩只在轮次开始时做一次，而一轮内的工具循环可能上百次，
+     * 体积完全可能在轮内涨破预算。超过此阈值就在轮内先做摘要，
+     * 而不是等到裁剪到最重级别仍超限、把整轮请求打断。
+     */
+    turnCompactTriggerChars: parseInt(process.env.TURN_COMPACT_TRIGGER_CHARS || '144000', 10),
+    /** 轮内压缩时保留原文的最近工具调用轮数 */
+    turnCompactKeepPairs: parseInt(process.env.TURN_COMPACT_KEEP_PAIRS || '3', 10),
+    /** 单轮请求内最多做几次轮内压缩，防止摘要模型被反复调用 */
+    maxInTurnCompactions: parseInt(process.env.MAX_IN_TURN_COMPACTIONS || '4', 10),
+    /** 模型瞬时故障（空回复 / 超时 / 网络抖动）的自动重试次数 */
+    transientModelRetries: parseInt(process.env.TRANSIENT_MODEL_RETRIES || '2', 10),
     /** 是否启用后台预压缩：回复结束后预先生成摘要，降低下一轮首字延迟 */
     enablePrecompression: process.env.ENABLE_PRECOMPRESSION !== 'false',
     /** 回复结束后延迟多久启动预压缩（毫秒），留出时间给用户连续追问 */

package/dist/services/memory/ContextBuilder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextTrimLevel = exports.buildContext = exports.estimateTokens = exports.estimateChars = exports.TrimLevel = void 0;
+exports.nextTrimLevel = exports.planTurnCompaction = exports.buildContext = exports.estimateTokens = exports.estimateChars = exports.TrimLevel = void 0;
 const shared_1 = require("@myassis/shared");
 const index_js_1 = require("../../config/index.js");
 const ToolLedger_js_1 = require("./ToolLedger.js");
@@ -391,6 +391,30 @@ function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.con
     return { messages: working, chars, level, trimmed: level > TrimLevel.None };
 }
 exports.buildContext = buildContext;
+/**
+ * 规划「轮内压缩」：在一轮请求内部把最早的工具调用折叠成可摘要的区间。
+ *
+ * 为什么需要它：buildContext 的裁剪是**无损事实、有损内容**的（截断、骨架化、
+ * 账本化），一旦裁到最高级别仍超预算就只能抛 exceed max message tokens，
+ * 本轮直接失败 —— 表现为用户看到的「会话中断」。轮内压缩把已经完成的工具
+ * 调用交给摘要模型转成一段文字，从根上降低体积，让长任务能一直跑下去。
+ *
+ * @param messages    请求态消息数组
+ * @param protectFrom 该下标之前是历史/摘要区，不参与折叠
+ * @param keepPairs   末尾保留原文的工具调用轮数
+ * @returns null 表示可折叠的量太少，不值得调用摘要模型
+ */
+function planTurnCompaction(messages, protectFrom, keepPairs) {
+    const pairs = collectToolPairs(messages, protectFrom);
+    const foldCount = pairs.length - Math.max(1, keepPairs);
+    // 至少要折叠 2 轮才有意义：折 1 轮省下的体积通常抵不上一次摘要调用
+    if (foldCount < 2)
+        return null;
+    const start = pairs[0].start;
+    const end = pairs[foldCount - 1].end;
+    return { start, end, foldable: messages.slice(start, end) };
+}
+exports.planTurnCompaction = planTurnCompaction;
 /** 依据当前级别推导下一个更重的裁剪级别，用于超限重试 */
 function nextTrimLevel(level) {
     if (level < TrimLevel.Aggressive)

package/dist/services/memory/MemoryManager.js

@@ -44,6 +44,26 @@ const DEFAULT_CONFIG = {
  * 前台请求与后台预压缩共用这张表，确保同一会话同一时刻只有一次摘要生成：
  * 否则两边会各自调用一次摘要模型（浪费配额），并竞争写入 lastMessageSummary。
  */
+/**
+ * 轮内压缩提示词头部。
+ *
+ * 与会话摘要提示词刻意不同：这里压缩的是**未完成任务的中间过程**，
+ * 目标是「让同一个模型能接着干」，所以要求输出交接说明而非概述 ——
+ * 概述会丢掉文件路径、失败尝试这些防止重复劳动的关键事实。
+ */
+const TURN_COMPACT_PROMPT_HEAD = `你正在压缩一个**正在进行中**的任务的中间过程，供同一个模型继续接着往下做。
+输出会替换掉这些原始记录，因此必须是「可据此继续工作」的交接说明，而不是概述。
+
+必须保留：
+1. 已确认的事实与结论（文件路径、函数名、配置项、报错原文关键片段、数据结论）
+2. 已经做过的修改（改了哪个文件的哪一处，改成了什么）
+3. 已经排除的可能性与失败的尝试（标注 ⚠️，避免重复走弯路）
+4. 尚未完成的下一步
+
+不要写客套话，不要建议用户做什么，直接输出要点。
+
+=== 中间过程 ===
+`;
 const compressionTasks = new Map();
 /** 后台预压缩的中断控制器，用于会话删除时取消 */
 const backgroundAborts = new Map();
@@ -255,6 +275,64 @@ class MemoryManager {
             ...plan.retained,
         ];
     }
+    /**
+     * 轮内压缩：把一轮请求内已完成的工具调用摘要成一条 assistant 消息。
+     *
+     * 与会话级压缩的区别：
+     * - 会话级压缩只在轮次开始时执行，输入是持久化的会话消息；
+     * - 轮内压缩发生在工具循环**进行中**，输入是尚未落库的请求态消息
+     *   （assistant(tool_calls) + tool 结果），因此不能改写会话摘要边界，
+     *   只返回文本由调用方就地替换消息区间。
+     *
+     * 摘要失败返回 null，调用方回退到分级裁剪，绝不因此中断本轮。
+     */
+    async compactTurnSegmentAsync(segment) {
+        if (!segment || segment.length === 0)
+            return null;
+        if (!this.childAgent) {
+            this.emitSSE({ type: 'context_compressing' });
+        }
+        const ledger = (0, ToolLedger_js_1.renderRequestLedger)(segment);
+        const transcript = segment.map((m) => {
+            if (m.role === 'tool') {
+                const body = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+                const name = m.tool_call_name || m.tool_call_id || '?';
+                return '工具结果(' + name + '): ' + (body ? body.slice(0, 4000) : '');
+            }
+            const calls = Array.isArray(m.tool_calls)
+                ? m.tool_calls
+                    .map((tc) => {
+                    const name = tc?.function?.name || tc?.toolName || '?';
+                    const args = String(tc?.function?.arguments || tc?.input || '').slice(0, 800);
+                    return name + '(' + args + ')';
+                })
+                    .join('; ')
+                : '';
+            const text = typeof m.content === 'string' ? m.content : '';
+            return '助手: ' + text + (calls ? '\n[调用: ' + calls + ']' : '');
+        }).join('\n\n').slice(0, 60000);
+        const prompt = TURN_COMPACT_PROMPT_HEAD + transcript;
+        try {
+            const models = await this.getSummaryModels();
+            const llmClient = new LLMClient_js_1.LLMClient(models, [{ role: 'user', content: prompt }], this.signal, [], 600000);
+            if (this.session.useSystemMode) {
+                const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
+                llmClient.setSystemMode(true, this.session.selectModelId, getServerBaseUrl(), getRequestToken());
+            }
+            const response = await llmClient.Chat();
+            const content = (response.content || '').trim();
+            if (!content) {
+                logger.warn('轮内压缩摘要为空，回退到分级裁剪');
+                return null;
+            }
+            return '【中间过程已压缩】以下是本轮此前工作的交接说明：\n' + content
+                + (ledger ? '\n\n' + ledger : '');
+        }
+        catch (error) {
+            logger.warn('轮内压缩失败，回退到分级裁剪: ' + (error?.message || error));
+            return null;
+        }
+    }
     /**
      * 是否值得后台预压缩：仅当确实需要生成新摘要时才启动。
      */

package/dist/services/session/Session.js

@@ -840,6 +840,8 @@ class Session {
             : (await dataService_js_1.modelsService.list(token)).data.map(x => (0, models_js_1.toModel)(x));
         // 工具调用轮次计数，防止无限循环
         let toolRound = 0;
+        // 达到工具轮上限后置位：强制模型停止调用工具、直接产出最终回复
+        let forceFinalize = false;
         // 计划模式：距上次调用 updatePlan 已经过的工具轮次，用于在中间过程强制提醒模型同步进度
         let roundsSincePlanUpdate = 0;
         // 计划模式：收尾时提醒模型补完计划的次数，避免反复提醒导致死循环
@@ -852,19 +854,82 @@ class Session {
             return text.includes('exceed max message tokens')
                 || text.includes('context_length_exceeded');
         };
+        /**
+         * 判断错误是否为「瞬时故障」：重试同一请求就可能成功。
+         *
+         * 模型返回空内容、网关超时、连接被重置都属于这类。它们过去会直接
+         * 冒泡成 SSE error，让界面留下一个空气泡等用户手动点「继续」；
+         * 而这类错误恰恰是最适合自动重试的。
+         */
+        const isTransientFailure = (error) => {
+            const text = String(error?.message || error);
+            if (text === 'aborted')
+                return false;
+            return text.includes('model return empty content')
+                || text.includes('Request timed out')
+                || text.includes('fetch failed')
+                || text.includes('ECONNRESET')
+                || text.includes('socket hang up')
+                || text.includes('All models are unavailable');
+        };
+        /** 本轮已执行的轮内压缩次数，受 maxInTurnCompactions 限制 */
+        let inTurnCompactions = 0;
+        /**
+         * 轮内压缩：把本轮已完成的旧工具调用换成一段摘要文本。
+         *
+         * 直接原地改写 messages（请求态数组），使后续所有轮次都受益。
+         * 不触碰 this.messages / 会话摘要边界：那是会话级压缩的职责，
+         * 这里只影响「发给模型的内容」，界面上的工具调用记录完整保留。
+         *
+         * @returns 是否真的压缩成功
+         */
+        const compactInTurn = async () => {
+            if (inTurnCompactions >= index_js_2.appConfig.maxInTurnCompactions)
+                return false;
+            const plan = (0, ContextBuilder_js_1.planTurnCompaction)(messages, messagesLength, index_js_2.appConfig.turnCompactKeepPairs);
+            if (!plan)
+                return false;
+            const summary = await memoryManager.compactTurnSegmentAsync(plan.foldable);
+            if (!summary)
+                return false;
+            inTurnCompactions++;
+            // 用一条 assistant 消息替换整个区间：不能用 tool 角色（缺少配对的
+            // tool_calls 会被严格校验的厂商判为非法请求），也不能只删不补
+            // （模型会忘记自己做过什么而重复调用工具）。
+            messages.splice(plan.start, plan.end - plan.start, {
+                role: 'assistant',
+                content: summary,
+                attachments: [],
+            });
+            logger.info(`轮内压缩完成: 折叠 ${plan.end - plan.start} 条消息，第 ${inTurnCompactions} 次`);
+            // 压缩后体积已降下来，裁剪级别回落到最轻，让模型重新看到完整的近期输出
+            trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
+            return true;
+        };
         /**
          * 调用模型：先按预算裁剪上下文，超限时逐级加重裁剪后重试。
          *
+         * 三层自愈，逐级升级，任一层成功就继续本轮，不把问题抛给用户：
+         * 1. 预防：估算体积超过 turnCompactTriggerChars 就先做轮内压缩；
+         * 2. 超限：先尝试轮内压缩（有损内容、保留事实），再退化为分级裁剪；
+         * 3. 瞬时故障：空回复 / 超时 / 网络抖动按 transientModelRetries 自动重试。
+         *
          * 裁剪只作用于投影副本，不会修改 messages / this.messages 中的原始数据。
          */
         const callModel = async () => {
-            let lastError;
+            let transientRetries = 0;
             while (true) {
+                // 预防式压缩：等到厂商报超限才处理已经太晚（那意味着一次废掉的请求，
+                // 且部分厂商在超限时返回的是难以识别的 400），这里提前把体积降下来。
+                if ((0, ContextBuilder_js_1.estimateChars)(messages) > index_js_2.appConfig.turnCompactTriggerChars) {
+                    await compactInTurn();
+                }
                 const built = (0, ContextBuilder_js_1.buildContext)(messages, messagesLength, index_js_2.appConfig.contextMaxChars, trimLevel);
                 if (built.trimmed) {
                     logger.debug(`上下文裁剪: level=${built.level} chars=${built.chars}`);
                 }
-                const llmClient = new LLMClient_js_1.LLMClient(models, built.messages, this.abortController.signal, tools);
+                // 收尾阶段不再下发工具定义：只要工具还在，模型大概率继续调用而不收尾
+                const llmClient = new LLMClient_js_1.LLMClient(models, built.messages, this.abortController.signal, forceFinalize ? [] : tools);
                 llmClient.setPreferredModel(this.selectModelId);
                 // 系统模式：转发到 Server LLM 代理
                 if (this.useSystemMode) {
@@ -875,14 +940,27 @@ class Session {
                     return await llmClient.Chat();
                 }
                 catch (error) {
-                    lastError = error;
-                    if (!isContextOverflow(error))
+                    if (this.abortController?.signal?.aborted)
                         throw error;
-                    const next = (0, ContextBuilder_js_1.nextTrimLevel)(trimLevel);
-                    if (next === null)
-                        throw error;
-                    logger.warn(`上下文超限，加重裁剪重试: ${trimLevel} -> ${next}`);
-                    trimLevel = next;
+                    if (isContextOverflow(error)) {
+                        // 先试无损度更高的轮内压缩，它能真正减少体积而不是继续截断
+                        if (await compactInTurn())
+                            continue;
+                        const next = (0, ContextBuilder_js_1.nextTrimLevel)(trimLevel);
+                        if (next === null)
+                            throw error;
+                        logger.warn(`上下文超限，加重裁剪重试: ${trimLevel} -> ${next}`);
+                        trimLevel = next;
+                        continue;
+                    }
+                    if (isTransientFailure(error) && transientRetries < index_js_2.appConfig.transientModelRetries) {
+                        transientRetries++;
+                        logger.warn(`模型瞬时故障，自动重试 ${transientRetries}/${index_js_2.appConfig.transientModelRetries}: ${error?.message}`);
+                        // 退避一下再重试：紧接着重发大概率撞上同一个瞬时故障
+                        await sleep(800 * transientRetries);
+                        continue;
+                    }
+                    throw error;
                 }
             }
         };
@@ -902,8 +980,14 @@ class Session {
             if (llmResult.toolCalls && llmResult.toolCalls.length > 0) {
                 toolRound++;
                 if (toolRound > index_js_2.appConfig.maxToolRounds) {
-                    logger.warn(`工具调用轮次超过上限 ${index_js_2.appConfig.maxToolRounds}，终止本轮`);
-                    throw new Error(`工具调用轮次超过上限（${index_js_2.appConfig.maxToolRounds}），已终止以防无限循环`);
+                    // 不能直接抛错：抛错会走 SSE error 分支，本轮已完成的工作只剩一个
+                    // 报错气泡，用户只能手动点「继续」重来。改为置位收尾标记，让模型
+                    // 基于已有结果向用户交付进展，本轮正常 complete。
+                    //
+                    // 提示消息不在这里追加：此刻 assistant(tool_calls) 与其 tool 结果
+                    // 还没入队，插进去会破坏配对，被严格校验的厂商判为非法请求。
+                    logger.warn(`工具调用轮次超过上限 ${index_js_2.appConfig.maxToolRounds}，转入收尾`);
+                    forceFinalize = true;
                 }
                 messages.push({
                     role: 'assistant',
@@ -1199,6 +1283,16 @@ class Session {
                     });
                     roundsSincePlanUpdate = 0;
                 }
+                // 工具轮上限：工具结果已全部入队，此刻插入收尾指令是安全的
+                if (forceFinalize) {
+                    messages.push({
+                        role: 'user',
+                        content: `[系统] 本轮工具调用已达上限（${index_js_2.appConfig.maxToolRounds} 轮）。`
+                            + `请立即停止调用任何工具，基于已经获得的结果向用户汇报：已完成什么、`
+                            + `当前结论是什么、还剩哪些未完成的步骤。`,
+                        attachments: [],
+                    });
+                }
                 // 继续下一轮（带上工具结果继续调用模型）
                 return await processModelResponse();
             }

package/dist/services/tools/edit.js

@@ -152,7 +152,7 @@ const editTool = {
     },
     handler: async (args) => {
         try {
-            if (typeof args === 'string') {
+            if (typeof args === 'string' && args.length > 1024) {
                 return { success: false, errorMessage: `参数过大 (${(args.length / 1024).toFixed(1)}KB)，大文件请分批进行edit 操作` };
             }
             const { path: filePath, edits } = args;

package/dist/services/tools/file.js

@@ -138,7 +138,7 @@ exports.fileTool = {
         try {
             // 如果 args 是原始 JSON 字符串（上游 parseAruments 解析失败时原样返回），
             // 先做轻量级检查：大文件写入时字符串极长，直接拦截避免 JSON.parse 爆内存
-            if (typeof args === 'string') {
+            if (typeof args === 'string' && args.length > 1024) {
                 return { success: false, errorMessage: `参数过大 (${(args.length / 1024).toFixed(1)}KB)，大文件写入请分批进行或使用多次 edit 操作` };
             }
             const { action, path: filePath, content, searchQuery, maxResults = 50, excludeDirs, caseSensitive = false, wholeWord = false } = args;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myassis/gateway",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {