@myassis/gateway 1.0.91 → 1.0.93

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/relay/RelayClient.js

@@ -43,6 +43,7 @@ class RelayClient {
     stopped = false;
     /** Server 在 HELLO_ACK 中下发的参数，未收到前用协议默认值 */
     initialWindowSize = protocol_js_1.INITIAL_WINDOW_SIZE;
+    wsInitialWindowSize = protocol_js_1.WS_INITIAL_WINDOW_SIZE;
     maxConcurrentStreams = protocol_js_1.MAX_CONCURRENT_STREAMS;
     /**
      * 启动中继。
@@ -350,6 +351,11 @@ class RelayClient {
             this.initialWindowSize = ack.initialWindowSize;
         if (ack.maxConcurrentStreams > 0)
             this.maxConcurrentStreams = ack.maxConcurrentStreams;
+        // 旧 Server 不下发该字段：回退到 HTTP 窗口，与改造前行为一致。
+        // 两侧必须用同一个值，否则接收方会把合法数据当成「对端超发」。
+        this.wsInitialWindowSize = ack.wsInitialWindowSize > 0
+            ? ack.wsInitialWindowSize
+            : this.initialWindowSize;
         this.failureCount = 0;
         this.lastError = undefined;
         this.connectedAt = Date.now();
@@ -461,8 +467,9 @@ class RelayClient {
             return;
         }
         const open = (0, protocol_js_1.decodeJsonPayload)(payload);
-        const sendWindow = new protocol_js_1.SendWindow(this.initialWindowSize);
-        const recvWindow = new protocol_js_1.ReceiveWindow(this.initialWindowSize);
+        // WS 没有逗条背压，窗口耗尽只能中止整条流，因此用更宽的专用窗口
+        const sendWindow = new protocol_js_1.SendWindow(this.wsInitialWindowSize);
+        const recvWindow = new protocol_js_1.ReceiveWindow(this.wsInitialWindowSize);
         const socket = new LoopbackForwarder_js_1.LoopbackWebSocket(this.localPort, open.path, open.headers, {
             onOpen: () => {
                 // 回环连上后无需额外通知：远端 WS 在 Server 侧已经 accept，

package/dist/services/relay/protocol.js

@@ -9,7 +9,7 @@
  * CI 会校验本文件与源文件的一致性，不一致将导致构建失败。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripHopByHopHeaders = exports.checkGatewayFeatures = exports.checkProtocolVersion = exports.ReceiveWindow = exports.SendWindow = exports.StreamIdAllocator = exports.decodeWsData = exports.encodeWsDataFrames = exports.MAX_WS_DATA_CHUNK = exports.WS_DATA_PREFIX_SIZE = exports.WsDataKind = exports.splitIntoFrames = exports.decodeJsonPayload = exports.decodeFrame = exports.encodeJsonFrame = exports.encodeFrame = exports.RelayProtocolError = exports.AbortReason = exports.isControlFrame = exports.isKnownFrameType = exports.frameTypeName = exports.FrameType = exports.CONTROL_STREAM_ID = exports.PING_TIMEOUT_MS = exports.PING_INTERVAL_MS = exports.MAX_CONCURRENT_STREAMS = exports.INITIAL_WINDOW_SIZE = exports.MAX_FRAME_PAYLOAD = exports.FRAME_HEADER_SIZE = exports.RELAY_REQUIRED_FEATURE = exports.RELAY_MIN_PROTOCOL_VERSION = exports.RELAY_PROTOCOL_VERSION = void 0;
+exports.stripHopByHopHeaders = exports.checkGatewayFeatures = exports.checkProtocolVersion = exports.ReceiveWindow = exports.SendWindow = exports.StreamIdAllocator = exports.decodeWsData = exports.encodeWsDataFrames = exports.MAX_WS_DATA_CHUNK = exports.WS_DATA_PREFIX_SIZE = exports.WsDataKind = exports.splitIntoFrames = exports.decodeJsonPayload = exports.decodeFrame = exports.encodeJsonFrame = exports.encodeFrame = exports.RelayProtocolError = exports.AbortReason = exports.isControlFrame = exports.isKnownFrameType = exports.frameTypeName = exports.FrameType = exports.CONTROL_STREAM_ID = exports.PING_TIMEOUT_MS = exports.PING_INTERVAL_MS = exports.MAX_CONCURRENT_STREAMS = exports.WS_INITIAL_WINDOW_SIZE = exports.INITIAL_WINDOW_SIZE = exports.MAX_FRAME_PAYLOAD = exports.FRAME_HEADER_SIZE = exports.RELAY_REQUIRED_FEATURE = exports.RELAY_MIN_PROTOCOL_VERSION = exports.RELAY_PROTOCOL_VERSION = void 0;
 /**
  * 中继帧协议（单源实现）
  * ============================================================
@@ -55,8 +55,29 @@ exports.FRAME_HEADER_SIZE = 5;
  * 偏小是有意为之：帧越小，SSE/流式响应的转发粒度越细，首字延迟越低。
  */
 exports.MAX_FRAME_PAYLOAD = 64 * 1024;
-/** 每条流的初始接收窗口（信用式流控） */
+/**
+ * HTTP 流的初始接收窗口（信用式流控）。
+ *
+ * 保持 256KB：HTTP 流有真正的背压——信用耗尽会 req.pause() 暂停
+ * 上游，等 WINDOW_UPDATE 回来再继续，窗口小只影响吞吐不会丢数据，
+ * 而帧细粒度对 SSE 首字延迟有利。
+ */
 exports.INITIAL_WINDOW_SIZE = 256 * 1024;
+/**
+ * WebSocket 流的初始接收窗口。
+ *
+ * 必须远大于 HTTP 窗口，因为 WS 没有背压可用：ws 库不支持逗条
+ * 暂停，一条消息发不下去就只能 abortStream（见
+ * RelayHub.forwardWebSocket 与 RelayClient.onWsOpen 里的 QUOTA_EXCEEDED 分支）。
+ * 一旦中止，终端的通知通道就断了，那一段的会话镜像事件全丢。
+ *
+ * 现实触发条件：会话镜像会把含 base64 附件的用户消息整条下发，
+ * 一张 5MB 的图经 base64 膨胀约 4/3 后接近 7MB，瞬时打穿 256KB。
+ *
+ * 16MB 不是预分配：窗口只是「允许对端在未收到确认前先发多少」。
+ * 而且 WS 流数量等于在线终端数（个位数），不是 MAX_CONCURRENT_STREAMS。
+ */
+exports.WS_INITIAL_WINDOW_SIZE = 16 * 1024 * 1024;
 /** 单条隧道允许的最大并发流数 */
 exports.MAX_CONCURRENT_STREAMS = 64;
 /** 心跳间隔与超时（毫秒） */

package/dist/services/session/Session.js

@@ -120,6 +120,17 @@ class Session {
     isGenerating = false;
     unreadCount = 0;
     currentMessageId = null;
+    /**
+     * 镜像事件序号（会话级单调递增）。
+     *
+     * WebSocket 镜像是 fire-and-forget：连接不在 OPEN（重连窗口）或中继流
+     * 被中止时，sendToUser 会静默丢弃，接收端无从得知。带上序号后，
+     * 终端一旦发现跳号就能立即触发补拉，而不是靠「连接是否断过」猜。
+     *
+     * 不持久化：它只用于检测单次进程内的事件连续性，网关重启后
+     * 终端会因 WebSocket 重连而重置基准。
+     */
+    mirrorSeq = 0;
     abortController = null;
     /** 后台预压缩的延迟定时器 */
     precompressionTimer = null;
@@ -714,13 +725,36 @@ 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;
             if (NON_MIRRORED_SSE_EVENTS.has(data?.type))
                 return;
             try {
+                // 序号在「决定要发」后才抬：被过滤掉的事件不占号，
+                // 否则接收端会把正常的过滤看成丢包。
+                this.mirrorSeq += 1;
                 wsService.sendToUser(String(this.userId), {
                     type: 'session_stream',
                     payload: {
@@ -728,9 +762,10 @@ class Session {
                         agentId: this.agentId,
                         userMessageId,
                         assistantMessageId,
+                        streamSeq: this.mirrorSeq,
                         event: data,
                     },
-                }, { excludeClientId: clientId });
+                }, { excludeClientId: sseAlive ? clientId : undefined });
             }
             catch (error) {
                 logger.error('SSE mirror error:', error);
@@ -758,7 +793,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 +806,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.91",
+  "version": "1.0.93",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {