aicodeswitch 2.0.8 → 2.0.10

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### 2.0.10 (2026-02-03)
+
+### 2.0.9 (2026-02-02)
+
 ### 2.0.8 (2026-02-02)
 
 ### 2.0.7 (2026-02-02)

package/CLAUDE.md

@@ -163,7 +163,21 @@ aicos version            # Show current version information
 ### Logging
 - Request logs: Detailed API call records with token usage
 - Access logs: System access records
-- Error logs: Error and exception records
+- Error logs: Error and exception records (includes upstream request information when available)
+- **Session Management**:
+  - Tracks user sessions based on session ID (Claude Code: `metadata.user_id`, Codex: `headers.session_id`)
+  - Auto-generates session title from first user message content:
+    - Extracts text from first user message
+    - Cleans up whitespace and newlines
+    - Intelligently truncates at word boundaries (max 100 chars)
+    - Adds "..." for truncated titles
+  - Records first request time, last request time, request count, and total tokens per session
+
+### Usage Limits Auto-Sync
+- **Service-Level Limits**: API services can have token and request count limits configured
+- **Auto-Sync to Rules**: When an API service's usage limits are modified, all rules using that service are automatically updated with the new limits
+- **Inheritance Detection**: When editing a rule, the system detects if the rule's limits match the service's limits and displays them as "inherited" (read-only)
+- **Manual Override**: Rules can be configured with custom limits that differ from the service defaults
 
 ## Development Tips
 
@@ -197,3 +211,4 @@ aicos version            # Show current version information
 * 所有对话请使用中文。生成代码中的文案及相关注释根据代码原本的语言生成。
 * 在服务端，直接使用 __dirname 来获取当前目录，不要使用 process.cwd()
 * 每次有新的变化时，你需要更新 CLAUDE.md 来让文档保持最新。
+* 禁止在项目中使用依赖GPU的css样式处理。

package/bin/stop.js

@@ -18,9 +18,8 @@ const stop = async (options = {}) => {
 
   // 第一步：如果 PID 文件存在，优先通过 PID 文件停止服务器
   if (fs.existsSync(PID_FILE)) {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
     try {
-      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
-
       const processInfo = await getProcessInfo(pid);
       if (!silent) {
         console.log('\n' + chalk.gray(`Process found: ${chalk.white(pid)} (${chalk.gray(processInfo)})`));

package/dist/server/database.js

@@ -264,6 +264,13 @@ class DatabaseManager {
                 this.db.exec('ALTER TABLE api_services ADD COLUMN auth_type TEXT DEFAULT NULL;');
                 console.log('[DB] Migration completed: auth_type column added');
             }
+            // 检查rules表是否有is_disabled字段（临时屏蔽功能）
+            const hasIsDisabled = rulesColumns.some((col) => col.name === 'is_disabled');
+            if (!hasIsDisabled) {
+                console.log('[DB] Running migration: Adding is_disabled column to rules table');
+                this.db.exec('ALTER TABLE rules ADD COLUMN is_disabled INTEGER DEFAULT 0;');
+                console.log('[DB] Migration completed: is_disabled column added');
+            }
         });
     }
     migrateMaxOutputTokensToModelLimits() {
@@ -378,10 +385,13 @@ class DatabaseManager {
         total_tokens_used INTEGER DEFAULT 0,
         reset_interval INTEGER,
         last_reset_at INTEGER,
+        token_reset_base_time INTEGER,
         request_count_limit INTEGER,
         total_requests_used INTEGER DEFAULT 0,
         request_reset_interval INTEGER,
         request_last_reset_at INTEGER,
+        request_reset_base_time INTEGER,
+        is_disabled INTEGER DEFAULT 0,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL,
         FOREIGN KEY (route_id) REFERENCES routes(id) ON DELETE CASCADE,
@@ -515,8 +525,47 @@ class DatabaseManager {
         if (result.changes > 0 && process.env.NODE_ENV === 'development') {
             console.log(`[DB] Updated service ${id}: ${service.name} -> ${service.apiUrl}`);
         }
+        // 如果更新成功，检查是否需要同步更新关联规则的超量限制
+        if (result.changes > 0) {
+            this.syncRulesWithServiceLimits(id, service);
+        }
         return result.changes > 0;
     }
+    /**
+     * 同步更新使用该服务的规则的超量限制
+     * 当API服务的超量限制修改时，自动更新所有使用该服务的规则
+     */
+    syncRulesWithServiceLimits(serviceId, service) {
+        // 获取所有使用该服务的规则
+        const rules = this.db.prepare('SELECT id FROM rules WHERE target_service_id = ?').all(serviceId);
+        if (rules.length === 0) {
+            return; // 没有规则使用此服务，无需同步
+        }
+        const now = Date.now();
+        const ruleIds = rules.map(r => r.id);
+        // Token超量限制同步
+        if (service.enableTokenLimit !== undefined || service.tokenLimit !== undefined ||
+            service.tokenResetInterval !== undefined || service.tokenResetBaseTime !== undefined) {
+            // 获取当前服务的最新配置
+            const currentService = this.db.prepare('SELECT enable_token_limit, token_limit, token_reset_interval, token_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
+            if (currentService && currentService.enable_token_limit === 1) {
+                // 启用了Token超量限制，同步到所有规则
+                this.db.prepare('UPDATE rules SET token_limit = ?, reset_interval = ?, token_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.token_limit, currentService.token_reset_interval, currentService.token_reset_base_time, now, serviceId);
+                console.log(`[DB] Synced token limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
+            }
+        }
+        // 请求次数超量限制同步
+        if (service.enableRequestLimit !== undefined || service.requestCountLimit !== undefined ||
+            service.requestResetInterval !== undefined || service.requestResetBaseTime !== undefined) {
+            // 获取当前服务的最新配置
+            const currentService = this.db.prepare('SELECT enable_request_limit, request_count_limit, request_reset_interval, request_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
+            if (currentService && currentService.enable_request_limit === 1) {
+                // 启用了请求次数超量限制，同步到所有规则
+                this.db.prepare('UPDATE rules SET request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.request_count_limit, currentService.request_reset_interval, currentService.request_reset_base_time, now, serviceId);
+                console.log(`[DB] Synced request count limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
+            }
+        }
+    }
     deleteAPIService(id) {
         const result = this.db.prepare('DELETE FROM api_services WHERE id = ?').run(id);
         return result.changes > 0;
@@ -592,6 +641,7 @@ class DatabaseManager {
             requestResetInterval: row.request_reset_interval,
             requestLastResetAt: row.request_last_reset_at,
             requestResetBaseTime: row.request_reset_base_time,
+            isDisabled: row.is_disabled === 1,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         }));
@@ -619,6 +669,7 @@ class DatabaseManager {
             requestResetInterval: row.request_reset_interval,
             requestLastResetAt: row.request_last_reset_at,
             requestResetBaseTime: row.request_reset_base_time,
+            isDisabled: row.is_disabled === 1,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         };
@@ -627,21 +678,41 @@ class DatabaseManager {
         const id = crypto_1.default.randomUUID();
         const now = Date.now();
         this.db
-            .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout || null, route.tokenLimit || null, route.totalTokensUsed || 0, route.resetInterval || null, route.lastResetAt || null, route.tokenResetBaseTime || null, route.requestCountLimit || null, route.totalRequestsUsed || 0, route.requestResetInterval || null, route.requestLastResetAt || null, route.requestResetBaseTime || null, now, now);
+            .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, is_disabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout || null, route.tokenLimit || null, route.totalTokensUsed || 0, route.resetInterval || null, route.lastResetAt || null, route.tokenResetBaseTime || null, route.requestCountLimit || null, route.totalRequestsUsed || 0, route.requestResetInterval || null, route.requestLastResetAt || null, route.requestResetBaseTime || null, route.isDisabled ? 1 : 0, now, now);
         return Object.assign(Object.assign({}, route), { id, createdAt: now, updatedAt: now });
     }
     updateRule(id, route) {
         const now = Date.now();
         const result = this.db
-            .prepare('UPDATE rules SET content_type = ?, target_service_id = ?, target_model = ?, replaced_model = ?, sort_order = ?, timeout = ?, token_limit = ?, reset_interval = ?, token_reset_base_time = ?, request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, updated_at = ? WHERE id = ?')
-            .run(route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout !== undefined ? route.timeout : null, route.tokenLimit !== undefined ? route.tokenLimit : null, route.resetInterval !== undefined ? route.resetInterval : null, route.tokenResetBaseTime !== undefined ? route.tokenResetBaseTime : null, route.requestCountLimit !== undefined ? route.requestCountLimit : null, route.requestResetInterval !== undefined ? route.requestResetInterval : null, route.requestResetBaseTime !== undefined ? route.requestResetBaseTime : null, now, id);
+            .prepare('UPDATE rules SET content_type = ?, target_service_id = ?, target_model = ?, replaced_model = ?, sort_order = ?, timeout = ?, token_limit = ?, reset_interval = ?, token_reset_base_time = ?, request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, is_disabled = ?, updated_at = ? WHERE id = ?')
+            .run(route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout !== undefined ? route.timeout : null, route.tokenLimit !== undefined ? route.tokenLimit : null, route.resetInterval !== undefined ? route.resetInterval : null, route.tokenResetBaseTime !== undefined ? route.tokenResetBaseTime : null, route.requestCountLimit !== undefined ? route.requestCountLimit : null, route.requestResetInterval !== undefined ? route.requestResetInterval : null, route.requestResetBaseTime !== undefined ? route.requestResetBaseTime : null, route.isDisabled !== undefined ? (route.isDisabled ? 1 : 0) : null, now, id);
         return result.changes > 0;
     }
     deleteRule(id) {
         const result = this.db.prepare('DELETE FROM rules WHERE id = ?').run(id);
         return result.changes > 0;
     }
+    /**
+     * 切换规则的临时屏蔽状态
+     * @param ruleId 规则ID
+     * @returns 是否成功
+     */
+    toggleRuleDisabled(ruleId) {
+        const rule = this.getRule(ruleId);
+        if (!rule) {
+            return { success: false, isDisabled: false };
+        }
+        const now = Date.now();
+        const newDisabledState = !rule.isDisabled;
+        const result = this.db
+            .prepare('UPDATE rules SET is_disabled = ?, updated_at = ? WHERE id = ?')
+            .run(newDisabledState ? 1 : 0, now, ruleId);
+        return {
+            success: result.changes > 0,
+            isDisabled: newDisabledState
+        };
+    }
     /**
      * 增加规则的token使用量
      * @param ruleId 规则ID
@@ -1095,8 +1166,8 @@ class DatabaseManager {
                 // Import rules
                 for (const rule of importData.rules) {
                     this.db
-                        .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.targetModel || null, rule.replacedModel || null, rule.sortOrder || 0, rule.timeout || null, rule.tokenLimit || null, rule.totalTokensUsed || 0, rule.resetInterval || null, rule.lastResetAt || null, rule.tokenResetBaseTime || null, rule.requestCountLimit || null, rule.totalRequestsUsed || 0, rule.requestResetInterval || null, rule.requestLastResetAt || null, rule.requestResetBaseTime || null, rule.createdAt, rule.updatedAt);
+                        .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, is_disabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.targetModel || null, rule.replacedModel || null, rule.sortOrder || 0, rule.timeout || null, rule.tokenLimit || null, rule.totalTokensUsed || 0, rule.resetInterval || null, rule.lastResetAt || null, rule.tokenResetBaseTime || null, rule.requestCountLimit || null, rule.totalRequestsUsed || 0, rule.requestResetInterval || null, rule.requestLastResetAt || null, rule.requestResetBaseTime || null, rule.isDisabled ? 1 : 0, rule.createdAt, rule.updatedAt);
                 }
                 // Update config
                 this.updateConfig(importData.config);

package/dist/server/main.js

@@ -69,8 +69,8 @@ function getProxyAgent() {
 }
 const app = (0, express_1.default)();
 app.use((0, cors_1.default)());
-app.use(express_1.default.json({ limit: '10mb' }));
-app.use(express_1.default.urlencoded({ extended: true }));
+app.use(express_1.default.json({ limit: 'Infinity' }));
+app.use(express_1.default.urlencoded({ extended: true, limit: 'Infinity' }));
 const asyncHandler = (handler) => (req, res, next) => {
     Promise.resolve(handler(req, res, next)).catch(next);
 };
@@ -760,6 +760,7 @@ const registerRoutes = (dbManager, proxyServer) => {
     app.delete('/api/rules/:id', (req, res) => res.json(dbManager.deleteRule(req.params.id)));
     app.put('/api/rules/:id/reset-tokens', (req, res) => res.json(dbManager.resetRuleTokenUsage(req.params.id)));
     app.put('/api/rules/:id/reset-requests', (req, res) => res.json(dbManager.resetRuleRequestCount(req.params.id)));
+    app.put('/api/rules/:id/toggle-disable', (req, res) => res.json(dbManager.toggleRuleDisabled(req.params.id)));
     // 解除规则的黑名单状态
     app.put('/api/rules/:id/clear-blacklist', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const { id } = req.params;
@@ -1391,6 +1392,16 @@ app.use((err, _req, res, _next) => {
     console.error(err);
     res.status(500).json({ error: err.message || 'Internal server error' });
 });
+// 全局未捕获异常处理 - 防止服务崩溃
+process.on('uncaughtException', (error) => {
+    console.error('[Uncaught Exception] 服务遇到未捕获的异常:', error);
+    console.error('[Uncaught Exception] 堆栈信息:', error.stack);
+    // 不退出进程，继续运行
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[Unhandled Rejection] 服务遇到未处理的 Promise 拒绝:', reason);
+    // 不退出进程，继续运行
+});
 start().catch((error) => {
     console.error('Failed to start server:', error);
     process.exit(1);

package/dist/server/proxy-server.js

@@ -627,6 +627,10 @@ class ProxyServer {
             const rules = this.getRulesByRouteId(routeId);
             if (!rules || rules.length === 0)
                 return undefined;
+            // 过滤掉被屏蔽的规则
+            const enabledRules = rules.filter(rule => !rule.isDisabled);
+            if (enabledRules.length === 0)
+                return undefined;
             const body = req.body;
             const requestModel = body === null || body === void 0 ? void 0 : body.model;
             // 1. 首先查找 model-mapping 类型的规则，按 sortOrder 降序匹配
@@ -643,8 +647,8 @@ class ProxyServer {
                     // 检查并重置到期的规则
                     this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                     this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                    // 检查token限制
-                    if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                    // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                    if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                         continue; // 跳过超限规则
                     }
                     // 检查请求次数限制
@@ -666,8 +670,8 @@ class ProxyServer {
                 // 检查并重置到期的规则
                 this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                 this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                // 检查token限制
-                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                     continue; // 跳过超限规则
                 }
                 // 检查请求次数限制
@@ -687,8 +691,8 @@ class ProxyServer {
                 // 检查并重置到期的规则
                 this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                 this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                // 检查token限制
-                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                     continue; // 跳过超限规则
                 }
                 // 检查请求次数限制
@@ -704,22 +708,26 @@ class ProxyServer {
         const rules = this.getRulesByRouteId(routeId);
         if (!rules || rules.length === 0)
             return [];
+        // 过滤掉被屏蔽的规则
+        const enabledRules = rules.filter(rule => !rule.isDisabled);
+        if (enabledRules.length === 0)
+            return [];
         const body = req.body;
         const requestModel = body === null || body === void 0 ? void 0 : body.model;
         const candidates = [];
         // 1. Model mapping rules
         if (requestModel) {
-            const modelMappingRules = rules.filter(rule => rule.contentType === 'model-mapping' &&
+            const modelMappingRules = enabledRules.filter(rule => rule.contentType === 'model-mapping' &&
                 rule.replacedModel &&
                 requestModel.includes(rule.replacedModel));
             candidates.push(...modelMappingRules);
         }
         // 2. Content type specific rules
         const contentType = this.determineContentType(req);
-        const contentTypeRules = rules.filter(rule => rule.contentType === contentType);
+        const contentTypeRules = enabledRules.filter(rule => rule.contentType === contentType);
         candidates.push(...contentTypeRules);
         // 3. Default rules
-        const defaultRules = rules.filter(rule => rule.contentType === 'default');
+        const defaultRules = enabledRules.filter(rule => rule.contentType === 'default');
         candidates.push(...defaultRules);
         // 4. 检查并重置到期的规则
         candidates.forEach(rule => {
@@ -729,9 +737,9 @@ class ProxyServer {
         // 5. 过滤掉超过限制的规则（仅在有多个候选规则时）
         if (candidates.length > 1) {
             const filteredCandidates = candidates.filter(rule => {
-                // 检查token限制
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
                 if (rule.tokenLimit && rule.totalTokensUsed !== undefined) {
-                    if (rule.totalTokensUsed >= rule.tokenLimit) {
+                    if (rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                         return false;
                     }
                 }
@@ -1239,6 +1247,7 @@ class ProxyServer {
     /**
      * 提取会话标题（默认方法）
      * 对于新会话，尝试从第一条消息的内容中提取标题
+     * 优化：使用第一条用户消息的完整内容，并智能截取
      */
     defaultExtractSessionTitle(request, sessionId) {
         var _a;
@@ -1254,21 +1263,51 @@ class ProxyServer {
             const firstUserMessage = messages.find((msg) => msg.role === 'user');
             if (firstUserMessage) {
                 const content = firstUserMessage.content;
+                let rawText = '';
                 if (typeof content === 'string') {
-                    // 截取前50个字符作为标题
-                    return content.slice(0, 50).trim();
+                    rawText = content;
                 }
                 else if (Array.isArray(content)) {
                     // 处理结构化内容（如图片+文本）
                     const textBlock = content.find((block) => (block === null || block === void 0 ? void 0 : block.type) === 'text');
                     if (textBlock === null || textBlock === void 0 ? void 0 : textBlock.text) {
-                        return textBlock.text.slice(0, 50).trim();
+                        rawText = textBlock.text;
                     }
                 }
+                if (rawText) {
+                    return this.formatSessionTitle(rawText);
+                }
             }
         }
         return undefined;
     }
+    /**
+     * 格式化会话标题
+     * - 去除多余空白和换行符
+     * - 智能截取，在单词边界处截断
+     * - 限制最大长度为100个字符
+     */
+    formatSessionTitle(text) {
+        // 去除多余空白和换行符，替换为单个空格
+        let formatted = text
+            .replace(/\s+/g, ' ') // 多个空白字符替换为单个空格
+            .replace(/[\r\n]+/g, ' ') // 换行符替换为空格
+            .trim();
+        // 限制最大长度
+        const maxLength = 100;
+        if (formatted.length <= maxLength) {
+            return formatted;
+        }
+        // 在单词边界处截断
+        let truncated = formatted.slice(0, maxLength);
+        const lastSpaceIndex = truncated.lastIndexOf(' ');
+        if (lastSpaceIndex > maxLength * 0.7) {
+            // 如果最后一个空格位置在长度的70%之后，在空格处截断
+            truncated = truncated.slice(0, lastSpaceIndex);
+        }
+        // 添加省略号
+        return truncated.trim() + '...';
+    }
     /**
      * 根据源工具类型和目标API类型,映射请求路径
      * @param sourceTool 源工具类型 (claude-code 或 codex)
@@ -1533,13 +1572,53 @@ class ProxyServer {
                             }
                             // 收集stream chunks（每个chunk是一个完整的SSE事件）
                             streamChunksForLog = eventCollector.getChunks();
+                            console.log('[Proxy] Stream request finished, collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
                             void finalizeLog(res.statusCode);
                         });
-                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => {
+                        // 监听 res 的错误事件
+                        res.on('error', (err) => {
+                            console.error('[Proxy] Response stream error:', err);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => __awaiter(this, void 0, void 0, function* () {
                             if (error) {
-                                void finalizeLog(500, error.message);
+                                console.error('[Proxy] Pipeline error for claude-code:', error);
+                                // 记录到错误日志
+                                try {
+                                    yield this.dbManager.addErrorLog({
+                                        timestamp: Date.now(),
+                                        method: req.method,
+                                        path: req.path,
+                                        statusCode: 500,
+                                        errorMessage: error.message || 'Stream processing error',
+                                        errorStack: error.stack,
+                                        requestHeaders: this.normalizeHeaders(req.headers),
+                                        requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                        upstreamRequest: upstreamRequestForLog,
+                                    });
+                                }
+                                catch (logError) {
+                                    console.error('[Proxy] Failed to log error:', logError);
+                                }
+                                // 尝试向客户端发送错误事件
+                                try {
+                                    if (!res.writableEnded) {
+                                        const errorEvent = `event: error\ndata: ${JSON.stringify({
+                                            type: 'error',
+                                            error: {
+                                                type: 'api_error',
+                                                message: 'Stream processing error occurred'
+                                            }
+                                        })}\n\n`;
+                                        res.write(errorEvent);
+                                        res.end();
+                                    }
+                                }
+                                catch (writeError) {
+                                    console.error('[Proxy] Failed to send error event:', writeError);
+                                }
+                                yield finalizeLog(500, error.message);
                             }
-                        });
+                        }));
                         return;
                     }
                     if (targetType === 'codex' && this.isClaudeSource(sourceType)) {
@@ -1564,21 +1643,62 @@ class ProxyServer {
                                 }
                             }
                             streamChunksForLog = eventCollector.getChunks();
+                            console.log('[Proxy] Codex stream request finished, collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
                             void finalizeLog(res.statusCode);
                         });
-                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => {
+                        // 监听 res 的错误事件
+                        res.on('error', (err) => {
+                            console.error('[Proxy] Response stream error:', err);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => __awaiter(this, void 0, void 0, function* () {
                             if (error) {
-                                void finalizeLog(500, error.message);
+                                console.error('[Proxy] Pipeline error for codex:', error);
+                                // 记录到错误日志
+                                try {
+                                    yield this.dbManager.addErrorLog({
+                                        timestamp: Date.now(),
+                                        method: req.method,
+                                        path: req.path,
+                                        statusCode: 500,
+                                        errorMessage: error.message || 'Stream processing error',
+                                        errorStack: error.stack,
+                                        requestHeaders: this.normalizeHeaders(req.headers),
+                                        requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                        upstreamRequest: upstreamRequestForLog,
+                                    });
+                                }
+                                catch (logError) {
+                                    console.error('[Proxy] Failed to log error:', logError);
+                                }
+                                // 尝试向客户端发送错误事件
+                                try {
+                                    if (!res.writableEnded) {
+                                        const errorEvent = `data: ${JSON.stringify({
+                                            error: 'Stream processing error occurred'
+                                        })}\n\n`;
+                                        res.write(errorEvent);
+                                        res.end();
+                                    }
+                                }
+                                catch (writeError) {
+                                    console.error('[Proxy] Failed to send error event:', writeError);
+                                }
+                                yield finalizeLog(500, error.message);
                             }
-                        });
+                        }));
                         return;
                     }
                     // 默认stream处理(无转换)
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
                     responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
                     this.copyResponseHeaders(responseHeaders, res);
+                    // 监听 res 的错误事件
+                    res.on('error', (err) => {
+                        console.error('[Proxy] Response stream error:', err);
+                    });
                     res.on('finish', () => {
                         streamChunksForLog = eventCollector.getChunks();
+                        console.log('[Proxy] Default stream request finished, collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
                         // 尝试从event collector中提取usage信息
                         const extractedUsage = eventCollector.extractUsage();
                         if (extractedUsage) {
@@ -1586,11 +1706,29 @@ class ProxyServer {
                         }
                         void finalizeLog(res.statusCode);
                     });
-                    (0, stream_1.pipeline)(response.data, eventCollector, res, (error) => {
+                    (0, stream_1.pipeline)(response.data, eventCollector, res, (error) => __awaiter(this, void 0, void 0, function* () {
                         if (error) {
-                            void finalizeLog(500, error.message);
+                            console.error('[Proxy] Pipeline error (default stream):', error);
+                            // 记录到错误日志
+                            try {
+                                yield this.dbManager.addErrorLog({
+                                    timestamp: Date.now(),
+                                    method: req.method,
+                                    path: req.path,
+                                    statusCode: 500,
+                                    errorMessage: error.message || 'Stream processing error',
+                                    errorStack: error.stack,
+                                    requestHeaders: this.normalizeHeaders(req.headers),
+                                    requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                    upstreamRequest: upstreamRequestForLog,
+                                });
+                            }
+                            catch (logError) {
+                                console.error('[Proxy] Failed to log error:', logError);
+                            }
+                            yield finalizeLog(500, error.message);
                         }
-                    });
+                    }));
                     return;
                 }
                 let responseData = response.data;
@@ -1658,6 +1796,7 @@ class ProxyServer {
                     usageForLog = this.extractTokenUsage(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
                     // 记录原始响应体
                     responseBodyForLog = typeof responseData === 'string' ? responseData : JSON.stringify(responseData);
+                    console.log('[Proxy] Non-stream response logged, body length:', (responseBodyForLog === null || responseBodyForLog === void 0 ? void 0 : responseBodyForLog.length) || 0);
                     this.copyResponseHeaders(responseHeaders, res);
                     if (contentType.includes('application/json')) {
                         res.status(response.status).json(responseData);