aicodeswitch 3.9.4 → 4.0.0

package/dist/server/rules-status-service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RulesStatusWS = exports.rulesStatusBroadcaster = exports.RulesStatusBroadcaster = void 0;
 exports.createRulesStatusWSServer = createRulesStatusWSServer;
@@ -25,9 +34,9 @@ class RulesStatusWS {
         });
     }
     /**
-     * 发送规则状态消息到客户端
+     * 发送消息到客户端
      */
-    sendStatus(message) {
+    sendMessage(message) {
         if (this.ws.readyState === ws_1.WebSocket.OPEN) {
             this.ws.send(JSON.stringify(message));
         }
@@ -46,24 +55,155 @@ class RulesStatusBroadcaster {
             writable: true,
             value: new Set()
         });
-        Object.defineProperty(this, "activeRules", {
+        Object.defineProperty(this, "ruleStates", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
-        }); // routeId -> Set of ruleIds
+        }); // ruleId -> RuleStatusData
         Object.defineProperty(this, "ruleTimeouts", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "idleDebounceTimeouts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "syncInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "blacklistChecker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         Object.defineProperty(this, "INACTIVITY_TIMEOUT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10000
+        }); // 10秒无活动后标记为空闲
+        Object.defineProperty(this, "IDLE_DEBOUNCE_DELAY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3000
+        }); // idle 广播延迟3秒，避免对话快速进入 in_use 时闪烁
+        Object.defineProperty(this, "SYNC_INTERVAL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10000
+        }); // 每10秒全量同步一次
+        Object.defineProperty(this, "ERROR_RECOVERY_TIMEOUT", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 30000
-        }); // 30秒无活动后标记为空闲
+        }); // error 状态30秒后自动恢复
+        // 启动全量状态同步定时器
+        this.startSyncInterval();
+    }
+    /**
+     * 设置黑名单检查函数
+     */
+    setBlacklistChecker(checker) {
+        this.blacklistChecker = checker;
+    }
+    /**
+     * 启动全量状态同步定时器
+     */
+    startSyncInterval() {
+        this.syncInterval = setInterval(() => {
+            this.checkSuspendedRulesAndBroadcast();
+        }, this.SYNC_INTERVAL);
+    }
+    /**
+     * 检查 suspended 和 error 状态的规则是否已恢复，然后广播全量状态
+     */
+    checkSuspendedRulesAndBroadcast() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.clients.size === 0) {
+                return;
+            }
+            const now = Date.now();
+            // 1. 检查所有 error 状态的规则，如果超过恢复时间则自动恢复为 idle
+            this.ruleStates.forEach((data, ruleId) => {
+                if (data.status === 'error' &&
+                    data.timestamp &&
+                    now - data.timestamp > this.ERROR_RECOVERY_TIMEOUT) {
+                    console.log(`[RulesStatusBroadcaster] 规则 ${ruleId} 错误状态已超时，自动恢复为 idle 状态`);
+                    this.ruleStates.set(ruleId, {
+                        ruleId,
+                        status: 'idle',
+                        routeId: data.routeId,
+                        timestamp: now,
+                    });
+                }
+            });
+            // 2. 检查所有 suspended 状态的规则，如果黑名单已过期则恢复为 idle
+            if (this.blacklistChecker) {
+                const suspendedRules = [];
+                this.ruleStates.forEach((data, ruleId) => {
+                    if (data.status === 'suspended' &&
+                        data.serviceId &&
+                        data.routeId &&
+                        data.contentType) {
+                        suspendedRules.push({
+                            ruleId,
+                            serviceId: data.serviceId,
+                            routeId: data.routeId,
+                            contentType: data.contentType,
+                        });
+                    }
+                });
+                // 检查每个 suspended 规则的黑名单状态
+                for (const { ruleId, serviceId, routeId, contentType } of suspendedRules) {
+                    try {
+                        const isBlacklisted = yield this.blacklistChecker(serviceId, routeId, contentType);
+                        if (!isBlacklisted) {
+                            // 黑名单已过期，恢复为 idle 状态
+                            console.log(`[RulesStatusBroadcaster] 规则 ${ruleId} 黑名单已过期，恢复为 idle 状态`);
+                            this.ruleStates.set(ruleId, {
+                                ruleId,
+                                status: 'idle',
+                                routeId,
+                                contentType,
+                                timestamp: now,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.error(`[RulesStatusBroadcaster] 检查黑名单状态失败:`, error);
+                    }
+                }
+            }
+            // 广播全量状态
+            this.broadcastAllRulesStatus();
+        });
+    }
+    /**
+     * 广播所有规则状态（全量同步）
+     */
+    broadcastAllRulesStatus() {
+        if (this.clients.size === 0) {
+            return;
+        }
+        const allStatuses = Array.from(this.ruleStates.values());
+        const message = {
+            type: 'all_rules_status',
+            data: allStatuses,
+            timestamp: Date.now(),
+        };
+        this.broadcastMessage(message);
     }
     /**
      * 添加客户端
@@ -71,6 +211,16 @@ class RulesStatusBroadcaster {
     addClient(client) {
         this.clients.add(client);
         console.log(`[RulesStatusBroadcaster] 客户端已连接，当前客户端数: ${this.clients.size}`);
+        // 新客户端连接时，立即发送当前所有规则状态
+        const allStatuses = Array.from(this.ruleStates.values());
+        if (allStatuses.length > 0) {
+            const message = {
+                type: 'all_rules_status',
+                data: allStatuses,
+                timestamp: Date.now(),
+            };
+            client.sendMessage(message);
+        }
     }
     /**
      * 移除客户端
@@ -80,86 +230,158 @@ class RulesStatusBroadcaster {
         console.log(`[RulesStatusBroadcaster] 客户端已断开，当前客户端数: ${this.clients.size}`);
     }
     /**
-     * 标记规则正在使用
+     * 清除规则的超时定时器
      */
-    markRuleInUse(routeId, ruleId) {
-        // 添加到活动规则集合
-        if (!this.activeRules.has(routeId)) {
-            this.activeRules.set(routeId, new Set());
-        }
-        this.activeRules.get(routeId).add(ruleId);
-        // 清除之前的超时定时器
-        const timeoutKey = `${routeId}:${ruleId}`;
+    clearRuleTimeout(timeoutKey) {
         const existingTimeout = this.ruleTimeouts.get(timeoutKey);
         if (existingTimeout) {
             clearTimeout(existingTimeout);
+            this.ruleTimeouts.delete(timeoutKey);
+        }
+    }
+    /**
+     * 清除规则的 idle debounce 定时器
+     */
+    clearIdleDebounce(timeoutKey) {
+        const existing = this.idleDebounceTimeouts.get(timeoutKey);
+        if (existing) {
+            clearTimeout(existing);
+            this.idleDebounceTimeouts.delete(timeoutKey);
         }
-        // 广播状态
-        this.broadcastStatus({
+    }
+    /**
+     * 更新规则状态并广播
+     */
+    updateRuleStatus(data) {
+        // 更新本地状态
+        this.ruleStates.set(data.ruleId, data);
+        // 广播单个规则状态更新
+        const message = {
             type: 'rule_status',
-            data: {
-                ruleId,
-                status: 'in_use',
-                timestamp: Date.now(),
-            },
+            data,
+        };
+        this.broadcastMessage(message);
+    }
+    /**
+     * 标记规则正在使用
+     */
+    markRuleInUse(routeId, ruleId) {
+        const timeoutKey = `${routeId}:${ruleId}`;
+        // 清除之前的超时定时器和 idle debounce
+        this.clearRuleTimeout(timeoutKey);
+        this.clearIdleDebounce(timeoutKey);
+        // 更新状态并广播
+        this.updateRuleStatus({
+            ruleId,
+            status: 'in_use',
+            routeId,
+            timestamp: Date.now(),
         });
-        // 设置超时定时器，如果30秒内没有新活动则标记为空闲
+        // 设置超时定时器，如果10秒内没有新活动则标记为空闲
         const timeout = setTimeout(() => {
             this.markRuleIdle(routeId, ruleId);
         }, this.INACTIVITY_TIMEOUT);
         this.ruleTimeouts.set(timeoutKey, timeout);
     }
     /**
-     * 标记规则空闲
+     * 标记规则空闲（带1秒 debounce，避免对话快速进入 in_use 时状态闪烁）
      */
     markRuleIdle(routeId, ruleId) {
         const timeoutKey = `${routeId}:${ruleId}`;
         // 清除超时定时器
-        const existingTimeout = this.ruleTimeouts.get(timeoutKey);
-        if (existingTimeout) {
-            clearTimeout(existingTimeout);
-            this.ruleTimeouts.delete(timeoutKey);
-        }
-        // 从活动规则集合中移除
-        if (this.activeRules.has(routeId)) {
-            this.activeRules.get(routeId).delete(ruleId);
-            if (this.activeRules.get(routeId).size === 0) {
-                this.activeRules.delete(routeId);
-            }
-        }
-        // 广播空闲状态
-        this.broadcastStatus({
-            type: 'rule_status',
-            data: {
+        this.clearRuleTimeout(timeoutKey);
+        // 清除已有的 idle debounce，重新计时
+        this.clearIdleDebounce(timeoutKey);
+        const debounce = setTimeout(() => {
+            this.idleDebounceTimeouts.delete(timeoutKey);
+            this.updateRuleStatus({
                 ruleId,
                 status: 'idle',
+                routeId,
                 timestamp: Date.now(),
-            },
+            });
+        }, this.IDLE_DEBOUNCE_DELAY);
+        this.idleDebounceTimeouts.set(timeoutKey, debounce);
+    }
+    /**
+     * 标记规则错误
+     */
+    markRuleError(routeId, ruleId, errorMessage) {
+        const timeoutKey = `${routeId}:${ruleId}`;
+        // 清除超时定时器和 idle debounce，避免 error 状态被延迟的 idle 覆盖
+        this.clearRuleTimeout(timeoutKey);
+        this.clearIdleDebounce(timeoutKey);
+        // 更新状态并广播
+        this.updateRuleStatus({
+            ruleId,
+            status: 'error',
+            routeId,
+            errorMessage,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 标记规则被挂起（进入黑名单）
+     */
+    markRuleSuspended(routeId, ruleId, serviceId, contentType, errorMessage, errorType) {
+        const timeoutKey = `${routeId}:${ruleId}`;
+        // 清除超时定时器和 idle debounce，避免 suspended 状态被延迟的 idle 覆盖
+        this.clearRuleTimeout(timeoutKey);
+        this.clearIdleDebounce(timeoutKey);
+        // 更新状态并广播，同时存储 routeId、serviceId 和 contentType 用于恢复检查
+        this.updateRuleStatus({
+            ruleId,
+            status: 'suspended',
+            routeId,
+            serviceId,
+            contentType,
+            errorMessage,
+            errorType,
+            timestamp: Date.now(),
         });
     }
     /**
      * 广播规则使用量更新
      */
     broadcastUsageUpdate(ruleId, totalTokensUsed, totalRequestsUsed) {
-        this.broadcastStatus({
-            type: 'rule_status',
-            data: {
-                ruleId,
-                status: 'in_use',
-                totalTokensUsed,
-                totalRequestsUsed,
-                timestamp: Date.now(),
-            },
+        // 获取当前状态，保留其他字段
+        const currentStatus = this.ruleStates.get(ruleId);
+        this.updateRuleStatus({
+            ruleId,
+            status: (currentStatus === null || currentStatus === void 0 ? void 0 : currentStatus.status) || 'in_use',
+            routeId: currentStatus === null || currentStatus === void 0 ? void 0 : currentStatus.routeId,
+            contentType: currentStatus === null || currentStatus === void 0 ? void 0 : currentStatus.contentType,
+            totalTokensUsed,
+            totalRequestsUsed,
+            timestamp: Date.now(),
         });
     }
+    /**
+     * 清除指定规则的状态
+     */
+    clearRuleStatus(ruleId) {
+        this.ruleStates.delete(ruleId);
+    }
+    /**
+     * 获取当前活动的规则列表
+     */
+    getActiveRules() {
+        const activeRuleIds = [];
+        this.ruleStates.forEach((data, ruleId) => {
+            if (data.status === 'in_use') {
+                activeRuleIds.push(ruleId);
+            }
+        });
+        return activeRuleIds;
+    }
     /**
      * 广播消息到所有客户端
      */
-    broadcastStatus(message) {
+    broadcastMessage(message) {
         const deadClients = [];
         this.clients.forEach((client) => {
             try {
-                client.sendStatus(message);
+                client.sendMessage(message);
             }
             catch (error) {
                 console.error('[RulesStatusBroadcaster] 发送消息失败:', error);
@@ -172,10 +394,19 @@ class RulesStatusBroadcaster {
         });
     }
     /**
-     * 获取当前活动的规则列表
+     * 销毁广播器（清理定时器）
      */
-    getActiveRules() {
-        return new Map(this.activeRules);
+    destroy() {
+        if (this.syncInterval) {
+            clearInterval(this.syncInterval);
+            this.syncInterval = null;
+        }
+        this.ruleTimeouts.forEach((timeout) => clearTimeout(timeout));
+        this.ruleTimeouts.clear();
+        this.idleDebounceTimeouts.forEach((timeout) => clearTimeout(timeout));
+        this.idleDebounceTimeouts.clear();
+        this.ruleStates.clear();
+        this.clients.clear();
     }
 }
 exports.RulesStatusBroadcaster = RulesStatusBroadcaster;

package/dist/server/transformers/chunk-collector.js

@@ -2,6 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSEEventCollectorTransform = exports.ChunkCollectorTransform = void 0;
 const stream_1 = require("stream");
+/**
+ * 检测是否是客户端断开相关的错误（这些错误是正常的，不应记录为错误）
+ */
+function isClientDisconnectError(error) {
+    const code = error === null || error === void 0 ? void 0 : error.code;
+    const message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+    return (code === 'ERR_STREAM_PREMATURE_CLOSE' ||
+        code === 'ERR_STREAM_UNABLE_TO_PIPE' ||
+        code === 'ERR_STREAM_DESTROYED' ||
+        message.includes('premature close'));
+}
 /**
  * ChunkCollectorTransform - 收集stream chunks用于日志记录
  * 这个Transform会记录所有经过它的数据块,同时将数据原封不动地传递给下一个stream
@@ -22,7 +33,12 @@ class ChunkCollectorTransform extends stream_1.Transform {
             value: false
         });
         this.on('error', (err) => {
-            console.error('[ChunkCollectorTransform] Stream error:', err);
+            if (isClientDisconnectError(err)) {
+                console.warn('[ChunkCollectorTransform] Stream closed (client disconnected)');
+            }
+            else {
+                console.error('[ChunkCollectorTransform] Stream error:', err);
+            }
             this.errorEmitted = true;
         });
     }
@@ -98,7 +114,12 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             value: false
         });
         this.on('error', (err) => {
-            console.error('[SSEEventCollectorTransform] Stream error:', err);
+            if (isClientDisconnectError(err)) {
+                console.warn('[SSEEventCollectorTransform] Stream closed (client disconnected)');
+            }
+            else {
+                console.error('[SSEEventCollectorTransform] Stream error:', err);
+            }
             this.errorEmitted = true;
         });
     }
@@ -108,7 +129,7 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             return;
         }
         try {
-            // 如果是对象（来自 SSEParserTransform），先转换为字符串格式进行处理
+            // 如果是对象（来自 SSEParserTransform 或上游转换器），先转换为字符串格式进行处理
             if (typeof chunk === 'object' && chunk !== null) {
                 const sseEvent = chunk;
                 const lines = [];
@@ -136,7 +157,7 @@ class SSEEventCollectorTransform extends stream_1.Transform {
                     }
                     this.flushEvent();
                 }
-                // 将原始对象传递给下一个stream
+                // 对象模式下保持原样透传，避免影响后续转换器读取 event/data 字段
                 this.push(chunk);
             }
             else {
@@ -161,6 +182,7 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             }
             // 刷新最后一个事件
             this.flushEvent();
+            // 不调用 this.end()，让 Node.js 自动管理流的生命周期
             callback();
         }
         catch (error) {