@myassis/gateway 1.0.92 → 1.0.94

package/dist/services/WebSocketService.js

@@ -206,6 +206,9 @@ class WebSocketService {
             if (options.excludeClientId && client.clientId === options.excludeClientId) {
                 return;
             }
+            if (options.onlyClientId && client.clientId !== options.onlyClientId) {
+                return;
+            }
             sent = this.sendToConnection(client, message) || sent;
         });
         return sent;

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

@@ -47,6 +47,16 @@ const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
  * 广播出去会让多个终端同时弹窗并重复回传批准结果。
  */
 const NON_MIRRORED_SSE_EVENTS = new Set(['heartbeat', 'approval_pending']);
+/**
+ * 只属于发起终端的事件类型。
+ *
+ * 这些事件不能广播（否则多终端重复弹窗），但也不能丢：
+ * 中继模式下 SSE 一旦被隐式关闭，approval_pending 写不出去，
+ * 发起端永远不弹确认框，而 registerApprovalWaiter 会一直堵到
+ * 5 分钟超时，整轮对话看起来就是“卡住”。
+ * 因此 SSE 不可用时改成定向走 WebSocket 补送给同一个发起终端。
+ */
+const ORIGINATOR_ONLY_SSE_EVENTS = new Set(['approval_pending']);
 // 批准等待缓存：token -> { resolve, reject, expiresAt }
 const approvalWaiters = new Map();
 /**
@@ -120,6 +130,17 @@ class Session {
     isGenerating = false;
     unreadCount = 0;
     currentMessageId = null;
+    /**
+     * 镜像事件序号（会话级单调递增）。
+     *
+     * WebSocket 镜像是 fire-and-forget：连接不在 OPEN（重连窗口）或中继流
+     * 被中止时，sendToUser 会静默丢弃，接收端无从得知。带上序号后，
+     * 终端一旦发现跳号就能立即触发补拉，而不是靠「连接是否断过」猜。
+     *
+     * 不持久化：它只用于检测单次进程内的事件连续性，网关重启后
+     * 终端会因 WebSocket 重连而重置基准。
+     */
+    mirrorSeq = 0;
     abortController = null;
     /** 后台预压缩的延迟定时器 */
     precompressionTimer = null;
@@ -741,6 +762,9 @@ class Session {
             if (NON_MIRRORED_SSE_EVENTS.has(data?.type))
                 return;
             try {
+                // 序号在「决定要发」后才抬：被过滤掉的事件不占号，
+                // 否则接收端会把正常的过滤看成丢包。
+                this.mirrorSeq += 1;
                 wsService.sendToUser(String(this.userId), {
                     type: 'session_stream',
                     payload: {
@@ -748,6 +772,7 @@ class Session {
                         agentId: this.agentId,
                         userMessageId,
                         assistantMessageId,
+                        streamSeq: this.mirrorSeq,
                         event: data,
                     },
                 }, { excludeClientId: sseAlive ? clientId : undefined });
@@ -775,12 +800,48 @@ class Session {
         // 把镜像函数传进去，使该事件也能同步到其他终端。
         const memoryManager = new MemoryManager_js_1.MemoryManager(this, this.abortController.signal, childAgent, res, mirrorToOtherClients);
         const historyMessages = await memoryManager.getHistoryMessagesAsync();
+        /**
+         * 将只属于发起终端的事件改走 WebSocket 补送。
+         *
+         * 不占用 mirrorSeq：该序号是会话级镜像流的连续编号，
+         * 定向补送若占一个号，其他终端就会把它当成丢包而误报缺口。
+         */
+        const sendToOriginator = (data) => {
+            if (!wsService)
+                return;
+            try {
+                // 没有 clientId（老版终端）时退回广播：审批 token 只能兑付一次，
+                // 重复回传会被忽略，比没人收到而卡 5 分钟更可接受。
+                const delivered = wsService.sendToUser(String(this.userId), {
+                    type: 'session_stream',
+                    payload: {
+                        sessionId: this.id,
+                        agentId: this.agentId,
+                        userMessageId,
+                        assistantMessageId,
+                        event: data,
+                    },
+                }, clientId ? { onlyClientId: clientId } : {});
+                if (!delivered) {
+                    logger.warn(`会话 ${this.id} 的 ${data?.type} 事件无法下发：SSE 已断且无可用 WebSocket 连接`);
+                }
+            }
+            catch (error) {
+                logger.error('SSE originator fallback error:', error);
+            }
+        };
         // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式），但仍同步给其他终端
         const sendSSE = (res, data) => {
             mirrorToOtherClients(data);
             // 连接已断开时不再写入：写只会抛错刷日志，内容已改由镜像下发
-            if (!res || !sseAlive)
+            if (!res || !sseAlive) {
+                // 镜像不负责的那几类事件，在 SSE 不可用时需要定向补送；
+                // heartbeat 是 SSE 保活专用，没了 SSE 也就不需要补送。
+                if (ORIGINATOR_ONLY_SSE_EVENTS.has(data?.type)) {
+                    sendToOriginator(data);
+                }
                 return;
+            }
             try {
                 res.write(`data: ${JSON.stringify(data)}\n\n`);
                 res.flush?.();

package/package.json

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