aicodeswitch 3.9.4 → 4.0.1

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

@@ -1,197 +1,311 @@
 "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;
-// @ts-ignore - ws 类型声明可能需要手动安装 @types/ws
-const ws_1 = require("ws");
+exports.rulesStatusBroadcaster = exports.RulesStatusBroadcaster = void 0;
 /**
- * 规则状态 WebSocket 连接管理
+ * 规则状态管理服务
+ * 负责管理所有规则的状态（使用中、空闲、错误、挂起）
  */
-class RulesStatusWS {
-    constructor(ws, req) {
-        Object.defineProperty(this, "ws", {
+class RulesStatusBroadcaster {
+    constructor() {
+        Object.defineProperty(this, "ruleStates", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        });
-        this.ws = ws;
-        console.log(`[RulesStatusWS] 新的 WebSocket 连接: ${req.socket.remoteAddress}`);
-        this.ws.on('close', () => {
-            console.log(`[RulesStatusWS] WebSocket 连接关闭`);
-        });
-        this.ws.on('error', (err) => {
-            console.error(`[RulesStatusWS] WebSocket 错误:`, err);
-        });
-    }
-    /**
-     * 发送规则状态消息到客户端
-     */
-    sendStatus(message) {
-        if (this.ws.readyState === ws_1.WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(message));
-        }
-    }
-}
-exports.RulesStatusWS = RulesStatusWS;
-/**
- * 规则状态广播服务
- * 管理所有连接的客户端，负责广播规则使用状态
- */
-class RulesStatusBroadcaster {
-    constructor() {
-        Object.defineProperty(this, "clients", {
+            value: new Map()
+        }); // ruleId -> RuleStatusData
+        Object.defineProperty(this, "ruleTimeouts", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Set()
+            value: new Map()
         });
-        Object.defineProperty(this, "activeRules", {
+        Object.defineProperty(this, "idleDebounceTimeouts", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
-        }); // routeId -> Set of ruleIds
-        Object.defineProperty(this, "ruleTimeouts", {
+        });
+        Object.defineProperty(this, "syncInterval", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            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秒检查一次 suspended 和 error 状态
+        Object.defineProperty(this, "ERROR_RECOVERY_TIMEOUT", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 30000
-        }); // 30秒无活动后标记为空闲
+        }); // error 状态30秒后自动恢复
+        // 启动定期状态检查定时器
+        this.startSyncInterval();
     }
     /**
-     * 添加客户端
+     * 设置黑名单检查函数
      */
-    addClient(client) {
-        this.clients.add(client);
-        console.log(`[RulesStatusBroadcaster] 客户端已连接，当前客户端数: ${this.clients.size}`);
+    setBlacklistChecker(checker) {
+        this.blacklistChecker = checker;
     }
     /**
-     * 移除客户端
+     * 启动定期状态检查定时器
      */
-    removeClient(client) {
-        this.clients.delete(client);
-        console.log(`[RulesStatusBroadcaster] 客户端已断开，当前客户端数: ${this.clients.size}`);
+    startSyncInterval() {
+        this.syncInterval = setInterval(() => {
+            this.checkSuspendedAndErrorRules();
+        }, this.SYNC_INTERVAL);
     }
     /**
-     * 标记规则正在使用
+     * 检查 suspended 和 error 状态的规则是否已恢复
      */
-    markRuleInUse(routeId, ruleId) {
-        // 添加到活动规则集合
-        if (!this.activeRules.has(routeId)) {
-            this.activeRules.set(routeId, new Set());
-        }
-        this.activeRules.get(routeId).add(ruleId);
-        // 清除之前的超时定时器
-        const timeoutKey = `${routeId}:${ruleId}`;
+    checkSuspendedAndErrorRules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * 清除规则的超时定时器
+     */
+    clearRuleTimeout(timeoutKey) {
         const existingTimeout = this.ruleTimeouts.get(timeoutKey);
         if (existingTimeout) {
             clearTimeout(existingTimeout);
+            this.ruleTimeouts.delete(timeoutKey);
         }
-        // 广播状态
-        this.broadcastStatus({
-            type: 'rule_status',
-            data: {
-                ruleId,
-                status: 'in_use',
-                timestamp: Date.now(),
-            },
+    }
+    /**
+     * 清除规则的 idle debounce 定时器
+     */
+    clearIdleDebounce(timeoutKey) {
+        const existing = this.idleDebounceTimeouts.get(timeoutKey);
+        if (existing) {
+            clearTimeout(existing);
+            this.idleDebounceTimeouts.delete(timeoutKey);
+        }
+    }
+    /**
+     * 更新规则状态
+     */
+    updateRuleStatus(data) {
+        // 更新本地状态
+        this.ruleStates.set(data.ruleId, data);
+    }
+    /**
+     * 标记规则正在使用
+     */
+    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);
     }
     /**
-     * 标记规则空闲
+     * 标记规则空闲（带3秒 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);
     }
     /**
-     * 广播规则使用量更新
+     * 标记规则错误
      */
-    broadcastUsageUpdate(ruleId, totalTokensUsed, totalRequestsUsed) {
-        this.broadcastStatus({
-            type: 'rule_status',
-            data: {
-                ruleId,
-                status: 'in_use',
-                totalTokensUsed,
-                totalRequestsUsed,
-                timestamp: Date.now(),
-            },
+    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(),
         });
     }
     /**
-     * 广播消息到所有客户端
+     * 标记规则被挂起（进入黑名单）
      */
-    broadcastStatus(message) {
-        const deadClients = [];
-        this.clients.forEach((client) => {
-            try {
-                client.sendStatus(message);
-            }
-            catch (error) {
-                console.error('[RulesStatusBroadcaster] 发送消息失败:', error);
-                deadClients.push(client);
-            }
+    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(),
         });
-        // 清理断开的客户端
-        deadClients.forEach((client) => {
-            this.removeClient(client);
+    }
+    /**
+     * 更新规则使用量
+     */
+    updateRuleUsage(ruleId, totalTokensUsed, totalRequestsUsed) {
+        // 获取当前状态，保留其他字段
+        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() {
-        return new Map(this.activeRules);
+        const activeRuleIds = [];
+        this.ruleStates.forEach((data, ruleId) => {
+            if (data.status === 'in_use') {
+                activeRuleIds.push(ruleId);
+            }
+        });
+        return activeRuleIds;
+    }
+    /**
+     * 获取所有规则的状态（用于 HTTP 轮询）
+     */
+    getAllRuleStatuses() {
+        return Array.from(this.ruleStates.values());
+    }
+    /**
+     * 销毁广播器（清理定时器）
+     */
+    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();
     }
 }
 exports.RulesStatusBroadcaster = RulesStatusBroadcaster;
 // 全局单例
 exports.rulesStatusBroadcaster = new RulesStatusBroadcaster();
-/**
- * 创建 WebSocket 服务器用于规则状态
- */
-function createRulesStatusWSServer() {
-    const wss = new ws_1.WebSocketServer({ noServer: true });
-    wss.on('connection', (ws, req) => {
-        const wsHandler = new RulesStatusWS(ws, req);
-        exports.rulesStatusBroadcaster.addClient(wsHandler);
-        ws.on('close', () => {
-            exports.rulesStatusBroadcaster.removeClient(wsHandler);
-        });
-    });
-    return wss;
-}

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

@@ -2,6 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSEEventCollectorTransform = exports.ChunkCollectorTransform = void 0;
 const stream_1 = require("stream");
+const string_decoder_1 = require("string_decoder");
+/**
+ * 检测是否是客户端断开相关的错误（这些错误是正常的，不应记录为错误）
+ */
+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
@@ -21,8 +33,19 @@ class ChunkCollectorTransform extends stream_1.Transform {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "stringDecoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new string_decoder_1.StringDecoder('utf8')
+        });
         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;
         });
     }
@@ -37,7 +60,8 @@ class ChunkCollectorTransform extends stream_1.Transform {
                 this.chunks.push(JSON.stringify(chunk));
             }
             else {
-                this.chunks.push(chunk.toString('utf8'));
+                // 使用 StringDecoder 正确处理多字节字符边界，避免中文乱码
+                this.chunks.push(this.stringDecoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
             }
             // 将chunk传递给下一个stream
             this.push(chunk);
@@ -48,6 +72,20 @@ class ChunkCollectorTransform extends stream_1.Transform {
             callback();
         }
     }
+    _flush(callback) {
+        try {
+            // 处理 StringDecoder 中剩余的字节
+            const remaining = this.stringDecoder.end();
+            if (remaining) {
+                this.chunks.push(remaining);
+            }
+            callback();
+        }
+        catch (error) {
+            console.error('[ChunkCollectorTransform] Error in _flush:', error);
+            callback();
+        }
+    }
     /**
      * 获取收集的所有chunks
      */
@@ -97,8 +135,19 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "stringDecoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new string_decoder_1.StringDecoder('utf8')
+        });
         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 +157,7 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             return;
         }
         try {
-            // 如果是对象（来自 SSEParserTransform），先转换为字符串格式进行处理
+            // 如果是对象（来自 SSEParserTransform 或上游转换器），先转换为字符串格式进行处理
             if (typeof chunk === 'object' && chunk !== null) {
                 const sseEvent = chunk;
                 const lines = [];
@@ -136,12 +185,12 @@ class SSEEventCollectorTransform extends stream_1.Transform {
                     }
                     this.flushEvent();
                 }
-                // 将原始对象传递给下一个stream
+                // 对象模式下保持原样透传，避免影响后续转换器读取 event/data 字段
                 this.push(chunk);
             }
             else {
-                // Buffer/string 模式
-                this.buffer += chunk.toString('utf8');
+                // Buffer/string 模式 - 使用 StringDecoder 正确处理多字节字符边界
+                this.buffer += this.stringDecoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
                 this.processBuffer();
                 // 将chunk传递给下一个stream
                 this.push(chunk);
@@ -155,12 +204,18 @@ class SSEEventCollectorTransform extends stream_1.Transform {
     }
     _flush(callback) {
         try {
+            // 处理 StringDecoder 中剩余的字节
+            const remaining = this.stringDecoder.end();
+            if (remaining) {
+                this.buffer += remaining;
+            }
             // 处理剩余的buffer
             if (this.buffer.trim()) {
                 this.processBuffer();
             }
             // 刷新最后一个事件
             this.flushEvent();
+            // 不调用 this.end()，让 Node.js 自动管理流的生命周期
             callback();
         }
         catch (error) {
@@ -259,8 +314,8 @@ class SSEEventCollectorTransform extends stream_1.Transform {
                     }
                 }
                 // 4. 直接在顶级的usage字段
-                if (data.input_tokens !== undefined || data.output_tokens !== undefined ||
-                    data.prompt_tokens !== undefined || data.completion_tokens !== undefined) {
+                if ((data === null || data === void 0 ? void 0 : data.input_tokens) !== undefined || (data === null || data === void 0 ? void 0 : data.output_tokens) !== undefined ||
+                    (data === null || data === void 0 ? void 0 : data.prompt_tokens) !== undefined || (data === null || data === void 0 ? void 0 : data.completion_tokens) !== undefined) {
                     return data;
                 }
             }