@myassis/gateway 1.0.90 → 1.0.92

package/dist/config/index.js

@@ -121,8 +121,23 @@ exports.appConfig = {
     enablePrecompression: process.env.ENABLE_PRECOMPRESSION !== 'false',
     /** 回复结束后延迟多久启动预压缩（毫秒），留出时间给用户连续追问 */
     precompressionDelay: parseInt(process.env.PRECOMPRESSION_DELAY || '3000', 10),
-    /** 触发上下文压缩的字符阈值 */
-    summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '60000', 10),
+    /**
+     * 触发上下文压缩的字符阈值。
+     *
+     * 口径是「实际入参字符数」（历史工具输出已按 oldToolContentLimit 折算），
+     * 因此可以贴着 contextMaxChars 设，而不必为截断留出巨大余量。
+     * 旧默认值 60000 是按原始体积设的，换算到实际入参口径后过早触发，
+     * 表现为「没聊几句就开始压缩」。
+     */
+    summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '120000', 10),
+    /**
+     * 触发上下文压缩的消息条数阈值。
+     *
+     * 一轮「用户提问 + 助手带工具回复」就占 2 条，旧值 10 意味着第 5 轮对话
+     * 必定压缩，与内容多少无关 —— 这是「没聊几句就压缩」最直接的原因。
+     * 条数只作为体积估算失真时的兜底，阈值应远高于正常对话轮数。
+     */
+    summaryThreshold: parseInt(process.env.SUMMARY_THRESHOLD || '60', 10),
     appName: '我的助手'
 };
 /**

package/dist/routes/agent.js

@@ -393,6 +393,39 @@ router.get('/sessions/:sessionId/messages/sync', ensureAgentManager, async (req,
         res.status(500).json({ success: false, error: 'Failed to sync messages' });
     }
 });
+/**
+ * GET /api/agent/sessions/:sessionId/state
+ *
+ * 会话的后台运行态。终端在断线期间收不到任何流事件，重连后必须问一次
+ * 「这一轮到底还在跑吗」，否则只能二选一地猜：要么把仍在生成的会话当成
+ * 已结束（加载圆点与计划进度圈凭空消失），要么永远停在加载态。
+ *
+ * 注意要注册在 /messages/:messageId 之前，避免被当成 messageId 匹配。
+ */
+router.get('/sessions/:sessionId/state', ensureAgentManager, async (req, res) => {
+    try {
+        const userId = req.userId;
+        const { sessionId } = req.params;
+        const session = (0, index_js_2.getSessionManager)(userId).getSession(sessionId);
+        if (!session) {
+            return res.status(404).json({ success: false, error: 'Session not found' });
+        }
+        return res.json({
+            success: true,
+            data: {
+                isGenerating: session.isGenerating,
+                // 只在生成中才回消息 id：结束后回它会让终端以为还有流在推进
+                currentMessageId: session.isGenerating ? session.currentMessageId : null,
+                plan: session.plan,
+                planUpdatedAt: session.planUpdatedAt,
+            },
+        });
+    }
+    catch (error) {
+        logger.error(`Get session state error: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to get session state' });
+    }
+});
 /**
  * DELETE /api/agent/sessions/:sessionId/messages/:messageId
  * Delete a specific message

package/dist/services/agent/AgentManager.js

@@ -255,7 +255,9 @@ class AgentManager {
             updatedAt: s.updatedAt,
             messageQueue: s.messageQueue,
             messageQueueAutoExecute: s.messageQueueAutoExecute,
-            plan: s.plan
+            plan: s.plan,
+            isGenerating: s.isGenerating,
+            currentMessageId: s.isGenerating ? s.currentMessageId : null
         }));
     }
     /**

package/dist/services/memory/MemoryManager.js

@@ -31,10 +31,9 @@ const dataService_js_1 = require("../dataService.js");
 const index_js_1 = require("../../stores/index.js");
 const LLMClient_js_1 = require("../llm/LLMClient.js");
 const index_js_2 = require("../../config/index.js");
-const ContextBuilder_js_1 = require("./ContextBuilder.js");
 const ToolLedger_js_1 = require("./ToolLedger.js");
 const DEFAULT_CONFIG = {
-    summaryThreshold: 10,
+    summaryThreshold: index_js_2.appConfig.summaryThreshold,
     summaryTriggerChars: index_js_2.appConfig.summaryTriggerChars,
     enabled: true,
 };
@@ -74,6 +73,43 @@ const sendSSE = (res, data) => {
     res.write(`data: ${JSON.stringify(data)}\n\n`);
     res.flush?.();
 };
+/**
+ * 估算「会话消息实际进入上下文后」的字符数。
+ *
+ * 不能直接用 estimateChars：它算的是原始体积，而历史消息里的工具输出
+ * 在 LLMClient.mapMessages 中每条只保留 oldToolContentLimit（默认 500）字符。
+ * 用原始体积判断压缩，会把一条 8000 字符的工具输出按 8000 计，
+ * 而它实际只占 500 —— 于是「没聊几句就开始压缩」：一轮 11 次工具调用的
+ * 会话，原始体积轻松破 6 万，实际入参却不到 1 万。
+ *
+ * 这里按真实入参口径折算，让压缩阈值和它想控制的对象是同一个东西。
+ */
+function estimateContextChars(messages) {
+    const limit = index_js_2.appConfig.oldToolContentLimit;
+    let total = 0;
+    for (const message of messages || []) {
+        if (typeof message.content === 'string')
+            total += message.content.length;
+        else if (message.content)
+            total += JSON.stringify(message.content).length;
+        if (message.reasoning_content)
+            total += String(message.reasoning_content).length;
+        for (const group of (message.toolCalls || [])) {
+            total += (group?.content?.length || 0) + (group?.reasoningContent?.length || 0);
+            for (const item of (group?.toolCalls || [])) {
+                total += (item?.toolName?.length || 0);
+                // 参数会被 clipJsonArguments 截断，但下限就是 limit 量级，按 limit 计
+                total += Math.min(String(item?.input ?? '').length, limit);
+                // 输出在 mapMessages 里被硬截断到 limit
+                total += Math.min(String(item?.output ?? '').length, limit);
+            }
+        }
+        for (const att of (message.attachments || [])) {
+            total += (att?.url?.length || 0) + (att?.name?.length || 0);
+        }
+    }
+    return total;
+}
 /**
  * 记忆管理器
  * 实现总结式记忆：当对话超过一定长度时，自动生成对话摘要
@@ -134,8 +170,9 @@ class MemoryManager {
             return false;
         if (messages.length >= this.config.summaryThreshold)
             return true;
-        // 单条工具结果可能极大，条数少也可能远超上下文预算
-        return (0, ContextBuilder_js_1.estimateChars)(messages) >= this.config.summaryTriggerChars;
+        // 单条工具结果可能极大，条数少也可能远超上下文预算。
+        // 按「实际入参口径」估算：历史工具输出会被截断，用原始体积会严重高估。
+        return estimateContextChars(messages) >= this.config.summaryTriggerChars;
     }
     /**
      * 取得“最后一条被摘要消息”的时间戳作为摘要边界。

package/dist/services/session/Session.js

@@ -714,7 +714,27 @@ class Session {
         // 这里预先取到 WebSocketService，把每个 SSE 事件同步给该用户的其他连接，
         // 从而让所有终端看到同一份会话流。子 Agent 的内部流不需要同步。
         const wsService = childAgent ? null : await this.getWebSocketService();
-        /** 把 SSE 事件镜像给当前用户的其他终端（排除发起端，避免重复渲染） */
+        // SSE 通道是否还活着。
+        //
+        // 中继模式下隧道一断，这条回环响应会被直接销毁，而本轮生成仍在后台跑。
+        // 此时发起端拿不到任何后续事件：SSE 已断，而它又因 excludeClientId 被
+        // 排除在 WebSocket 镜像之外，界面上的加载圆点与计划进度圈会凭空消失。
+        // 所以 SSE 一断就取消排除，让发起端也从镜像里接着收。
+        let sseAlive = !!res;
+        if (res && typeof res.on === 'function') {
+            res.on('close', () => {
+                if (!sseAlive)
+                    return;
+                sseAlive = false;
+                logger.warn(`会话 ${this.id} 的 SSE 已断开，本轮生成继续，后续事件改由 WebSocket 镜像下发`);
+            });
+        }
+        /**
+         * 把 SSE 事件镜像给当前用户的其他终端。
+         *
+         * SSE 还活着时排除发起端（它已从 SSE 收到同样的事件，不排除会渲染两遍）；
+         * SSE 已断开时不再排除，发起端重连 WebSocket 后就能接着看完本轮。
+         */
         const mirrorToOtherClients = (data) => {
             if (!wsService)
                 return;
@@ -730,7 +750,7 @@ class Session {
                         assistantMessageId,
                         event: data,
                     },
-                }, { excludeClientId: clientId });
+                }, { excludeClientId: sseAlive ? clientId : undefined });
             }
             catch (error) {
                 logger.error('SSE mirror error:', error);
@@ -758,7 +778,8 @@ class Session {
         // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式），但仍同步给其他终端
         const sendSSE = (res, data) => {
             mirrorToOtherClients(data);
-            if (!res)
+            // 连接已断开时不再写入：写只会抛错刷日志，内容已改由镜像下发
+            if (!res || !sseAlive)
                 return;
             try {
                 res.write(`data: ${JSON.stringify(data)}\n\n`);
@@ -770,7 +791,7 @@ class Session {
         };
         // 心跳机制：每 15 秒发送一次心跳，防止连接超时
         const heartbeatInterval = setInterval(() => {
-            if (res && !res.destroyed) {
+            if (res && sseAlive && !res.destroyed) {
                 sendSSE(res, { type: 'heartbeat' });
             }
             else {

package/package.json

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