@myassis/gateway 1.0.81 → 1.0.82

package/dist/config/index.js

@@ -91,6 +91,10 @@ exports.appConfig = {
     oldToolContentLimit: parseInt(process.env.OLD_TOOL_CONTENT_LIMIT || '500', 10),
     /** 单次请求内最大工具调用轮数 */
     maxToolRounds: parseInt(process.env.MAX_TOOL_ROUNDS || '200', 10),
+    /** 是否启用后台预压缩：回复结束后预先生成摘要，降低下一轮首字延迟 */
+    enablePrecompression: process.env.ENABLE_PRECOMPRESSION !== 'false',
+    /** 回复结束后延迟多久启动预压缩（毫秒），留出时间给用户连续追问 */
+    precompressionDelay: parseInt(process.env.PRECOMPRESSION_DELAY || '3000', 10),
     /** 触发上下文压缩的字符阈值 */
     summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '60000', 10),
     appName: '我的助手'

package/dist/services/memory/MemoryManager.js

@@ -38,6 +38,15 @@ const DEFAULT_CONFIG = {
     summaryTriggerChars: index_js_2.appConfig.summaryTriggerChars,
     enabled: true,
 };
+/**
+ * 会话级压缩任务表：sessionId -> 进行中的压缩任务。
+ *
+ * 前台请求与后台预压缩共用这张表，确保同一会话同一时刻只有一次摘要生成：
+ * 否则两边会各自调用一次摘要模型（浪费配额），并竞争写入 lastMessageSummary。
+ */
+const compressionTasks = new Map();
+/** 后台预压缩的中断控制器，用于会话删除时取消 */
+const backgroundAborts = new Map();
 /** SSE 辅助方法：res 为 null 时跳过写入（本地执行模式） */
 const sendSSE = (res, data) => {
     if (!res)
@@ -103,7 +112,10 @@ class MemoryManager {
             return fallback;
         return summarized[summarized.length - 1].createdAt;
     }
-    async getHistoryMessagesAsync() {
+    /**
+     * 制定压缩计划：只做判断与切分，不触发任何模型调用。
+     */
+    plan() {
         const keep = index_js_2.appConfig.historyKeep;
         // 复制数组：getMessages() 返回的是会话内部的活引用，不可原地修改
         let messages = [...this.session.getMessages()];
@@ -111,29 +123,25 @@ class MemoryManager {
             // 子 agent 的最后一条消息由调用方单独拼接，此处排除
             messages = messages.slice(0, -1);
         }
-        if (!this.shouldSummarize(messages)) {
-            return messages;
-        }
-        if (messages.length <= keep) {
-            return messages;
+        const empty = {
+            action: 'none', toSummarize: [], ledger: [], retained: messages,
+            newBoundaryAt: 0, prevBoundaryAt: null, prevLedger: [], prevRetained: messages,
+        };
+        if (!this.shouldSummarize(messages) || messages.length <= keep) {
+            return empty;
         }
-        const hasSummary = this.session.lastMessageSummary;
-        if (!hasSummary) {
-            // 首次摘要生成
+        if (!this.session.lastMessageSummary) {
             const toSummarize = messages.slice(0, -keep);
-            const summary = await this.generateSummaryAsync(toSummarize, null);
-            if (!summary) {
-                // 摘要失败/被中断：退回原始历史，不写入残缺摘要
-                return messages;
-            }
-            const boundary = this.boundaryOf(toSummarize, Date.now());
-            this.session.lastMessageSummary = summary;
-            this.session.lastMessageSummaryAt = boundary;
-            this.session.save();
-            return [
-                this.toSummaryMessage(summary, boundary, '', toSummarize),
-                ...messages.slice(-keep),
-            ];
+            return {
+                action: 'first',
+                toSummarize,
+                ledger: toSummarize,
+                retained: messages.slice(-keep),
+                newBoundaryAt: this.boundaryOf(toSummarize, Date.now()),
+                prevBoundaryAt: null,
+                prevLedger: [],
+                prevRetained: messages,
+            };
         }
         // 增量摘要：边界之后的消息才是“新消息”
         const boundaryAt = this.session.lastMessageSummaryAt;
@@ -141,29 +149,163 @@ class MemoryManager {
         // 边界之前的消息已被摘要取代，其工具调用需通过账本保留
         const omitted = messages.filter((m) => m.createdAt <= boundaryAt);
         if (!this.shouldSummarize(newMessages) || newMessages.length <= keep) {
-            return [
-                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, '', omitted),
-                ...newMessages,
-            ];
+            return {
+                action: 'reuse',
+                toSummarize: [], ledger: [], retained: [],
+                newBoundaryAt: boundaryAt,
+                prevBoundaryAt: boundaryAt,
+                prevLedger: omitted,
+                prevRetained: newMessages,
+            };
         }
-        // 新消息超过阈值，基于旧摘要增量重算
         const toSummarize = newMessages.slice(0, -keep);
-        const summary = await this.generateSummaryAsync(toSummarize, this.session.lastMessageSummary);
-        if (!summary) {
-            return [
-                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, '', omitted),
-                ...newMessages,
-            ];
+        return {
+            action: 'incremental',
+            toSummarize,
+            ledger: [...omitted, ...toSummarize],
+            retained: newMessages.slice(-keep),
+            newBoundaryAt: this.boundaryOf(toSummarize, boundaryAt),
+            prevBoundaryAt: boundaryAt,
+            prevLedger: omitted,
+            prevRetained: newMessages,
+        };
+    }
+    /**
+     * 执行压缩计划并写入会话。
+     *
+     * @returns 摘要文本；null 表示失败/中断（调用方应沿用旧摘要或原始历史）
+     */
+    async runPlan(plan) {
+        if (plan.action !== 'first' && plan.action !== 'incremental')
+            return null;
+        const summary = await this.generateSummaryAsync(plan.toSummarize, plan.action === 'incremental' ? this.session.lastMessageSummary : null);
+        if (!summary)
+            return null;
+        // 并发保护：若边界已被其他压缩任务推进，说明有更新的摘要，放弃本次结果
+        if (plan.prevBoundaryAt !== null
+            && this.session.lastMessageSummaryAt !== plan.prevBoundaryAt) {
+            logger.info('摘要边界已被其他任务推进，丢弃本次压缩结果');
+            return null;
         }
-        const nextBoundary = this.boundaryOf(toSummarize, boundaryAt);
         this.session.lastMessageSummary = summary;
-        this.session.lastMessageSummaryAt = nextBoundary;
+        this.session.lastMessageSummaryAt = plan.newBoundaryAt;
         this.session.save();
+        return summary;
+    }
+    async getHistoryMessagesAsync() {
+        // 若后台预压缩正在进行，等它完成即可直接复用结果，避免重复调用摘要模型
+        const pending = compressionTasks.get(this.session.id);
+        if (pending) {
+            logger.debug('等待进行中的压缩任务完成');
+            try {
+                await pending;
+            }
+            catch {
+                // 后台任务失败不影响前台，重新按当前状态决策
+            }
+        }
+        const plan = this.plan();
+        if (plan.action === 'none') {
+            return plan.retained;
+        }
+        if (plan.action === 'reuse') {
+            return [
+                this.toSummaryMessage(this.session.lastMessageSummary, plan.prevBoundaryAt, '', plan.prevLedger),
+                ...plan.prevRetained,
+            ];
+        }
+        // 前台压缩同样登记到任务表，阻止后台预压缩重复执行
+        const task = this.runPlan(plan);
+        compressionTasks.set(this.session.id, task.then(() => undefined, () => undefined));
+        let summary = null;
+        try {
+            summary = await task;
+        }
+        finally {
+            compressionTasks.delete(this.session.id);
+        }
+        if (!summary) {
+            // 摘要失败/被中断：沿用旧摘要或退回原始历史，不写入残缺摘要
+            if (plan.action === 'incremental') {
+                return [
+                    this.toSummaryMessage(this.session.lastMessageSummary, plan.prevBoundaryAt, '', plan.prevLedger),
+                    ...plan.prevRetained,
+                ];
+            }
+            return plan.prevRetained;
+        }
         return [
-            this.toSummaryMessage(summary, nextBoundary, '', [...omitted, ...toSummarize]),
-            ...newMessages.slice(-keep),
+            this.toSummaryMessage(summary, plan.newBoundaryAt, '', plan.ledger),
+            ...plan.retained,
         ];
     }
+    /**
+     * 是否值得后台预压缩：仅当确实需要生成新摘要时才启动。
+     */
+    needsPrecompression() {
+        const action = this.plan().action;
+        return action === 'first' || action === 'incremental';
+    }
+    // ========== 后台预压缩 ==========
+    /**
+     * 在上一轮回复结束后于后台预先生成摘要，让下一轮请求直接命中结果。
+     *
+     * 设计要点：
+     * - 与前台共用 compressionTasks 表，同一会话不会重复调用摘要模型；
+     * - 失败只记日志，绝不抛出：预压缩是纯优化，失败时前台会自行压缩；
+     * - 使用独立 AbortController，不受上一轮请求的 signal 影响
+     *   （否则请求结束时 signal 被 abort，后台任务会立刻死掉）。
+     */
+    static schedulePrecompression(session) {
+        if (!index_js_2.appConfig.enablePrecompression)
+            return;
+        if (compressionTasks.has(session.id))
+            return;
+        // 正在生成时不预压缩：消息还会继续追加，此刻的摘要边界会立即过期
+        if (session.isGenerating)
+            return;
+        const controller = new AbortController();
+        const manager = new MemoryManager(session, controller.signal, true, null);
+        if (!manager.needsPrecompression())
+            return;
+        logger.info(`启动后台预压缩: session=${session.id}`);
+        backgroundAborts.set(session.id, controller);
+        const task = (async () => {
+            const startedAt = Date.now();
+            try {
+                const plan = manager.plan();
+                if (plan.action !== 'first' && plan.action !== 'incremental')
+                    return;
+                const summary = await manager.runPlan(plan);
+                if (summary) {
+                    logger.info(`后台预压缩完成: session=${session.id} 耗时=${Date.now() - startedAt}ms`);
+                }
+                else {
+                    logger.info(`后台预压缩未产生新摘要: session=${session.id}`);
+                }
+            }
+            catch (error) {
+                // 预压缩失败不影响任何用户可见行为
+                logger.warn(`后台预压缩失败: session=${session.id} ${error?.message}`);
+            }
+            finally {
+                compressionTasks.delete(session.id);
+                backgroundAborts.delete(session.id);
+            }
+        })();
+        compressionTasks.set(session.id, task);
+    }
+    /**
+     * 取消会话的后台预压缩（会话删除或用户重新发起请求时调用）
+     */
+    static cancelPrecompression(sessionId) {
+        const controller = backgroundAborts.get(sessionId);
+        if (controller) {
+            controller.abort();
+            backgroundAborts.delete(sessionId);
+            logger.debug(`已取消后台预压缩: session=${sessionId}`);
+        }
+    }
     /**
      * 格式化工具调用内容，提取关键信息供摘要模型理解
      */

package/dist/services/session/Session.js

@@ -114,6 +114,8 @@ class Session {
     unreadCount = 0;
     currentMessageId = null;
     abortController = null;
+    /** 后台预压缩的延迟定时器 */
+    precompressionTimer = null;
     toInsertMessages;
     constructor(data) {
         this.id = data.id;
@@ -549,6 +551,8 @@ class Session {
         if (this.isPlanCompleted()) {
             this.clearPlan();
         }
+        // 新请求到来：放弃排队中的预压缩，避免与前台压缩重复调用摘要模型
+        this.abortPrecompression();
         // Add user message
         this.getAbortController();
         this.isGenerating = true;
@@ -1058,14 +1062,55 @@ class Session {
                 if (this.currentMessageId !== null) {
                     this.saveMessage();
                 }
+                // 后台预压缩：本轮已结束，提前生成摘要让下一轮直接命中，降低首字延迟。
+                // 延迟启动是为了给用户的连续追问让路（追问会取消它）。
+                this.schedulePrecompression();
             }
         }
     }
+    /**
+     * 延迟调度后台预压缩。
+     *
+     * 不 await：预压缩是纯优化，绝不能阻塞本轮请求的收尾。
+     */
+    schedulePrecompression() {
+        if (!index_js_2.appConfig.enablePrecompression)
+            return;
+        this.cancelPrecompressionTimer();
+        this.precompressionTimer = setTimeout(() => {
+            this.precompressionTimer = null;
+            try {
+                MemoryManager_js_1.MemoryManager.schedulePrecompression(this);
+            }
+            catch (error) {
+                logger.warn('调度后台预压缩失败:', error?.message);
+            }
+        }, index_js_2.appConfig.precompressionDelay);
+        // 不阻止进程退出
+        this.precompressionTimer.unref?.();
+    }
+    /** 取消尚未触发的预压缩定时器 */
+    cancelPrecompressionTimer() {
+        if (this.precompressionTimer) {
+            clearTimeout(this.precompressionTimer);
+            this.precompressionTimer = null;
+        }
+    }
+    /**
+     * 用户发起新请求或会话销毁时，放弃排队中/进行中的预压缩。
+     *
+     * 前台会自行压缩，且新消息会使预压缩的边界立即过期。
+     */
+    abortPrecompression() {
+        this.cancelPrecompressionTimer();
+        MemoryManager_js_1.MemoryManager.cancelPrecompression(this.id);
+    }
     /**
      * 停止当前正在进行的生成
      */
     stopGenerating() {
         this.isGenerating = false;
+        this.abortPrecompression();
         // 停止生成后清除计划，避免 Desktop 的进度圈停留在未完成状态
         this.clearPlan();
         if (this.abortController) {

package/dist/services/session/SessionManager.js

@@ -149,6 +149,8 @@ class SessionManager {
         const session = this.sessions.get(sessionId);
         if (!session)
             return false;
+        // 先取消后台预压缩：否则任务完成后会向已删除的会话写入摘要
+        session.abortPrecompression();
         SessionStore_js_1.sessionStore.transaction(() => {
             SessionStore_js_1.sessionStore.deleteMessagesBySessionId(sessionId);
             SessionStore_js_1.sessionStore.deleteSession(sessionId);

package/package.json

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