aicodeswitch 1.10.2 → 2.0.1

package/dist/server/proxy-server.js

@@ -48,22 +48,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyServer = void 0;
 const axios_1 = __importDefault(require("axios"));
 const stream_1 = require("stream");
+const crypto_1 = __importDefault(require("crypto"));
 const streaming_1 = require("./transformers/streaming");
 const chunk_collector_1 = require("./transformers/chunk-collector");
 const claude_openai_1 = require("./transformers/claude-openai");
 const SUPPORTED_TARGETS = ['claude-code', 'codex'];
-// 需要排除的路径模式（非业务请求）
-const IGNORED_PATHS = [
-    '/favicon.ico',
-    '/robots.txt',
-    '/sitemap.xml',
-];
-/**
- * 检查路径是否应该被忽略
- */
-function shouldIgnorePath(path) {
-    return IGNORED_PATHS.some(ignored => path === ignored || path.startsWith(ignored + '?'));
-}
 class ProxyServer {
     constructor(dbManager, app) {
         Object.defineProperty(this, "app", {
@@ -104,125 +93,30 @@ class ProxyServer {
             writable: true,
             value: void 0
         });
+        // 请求去重缓存：用于防止同一个请求被重复计数（如网络重试）
+        // key: requestHash, value: timestamp
+        Object.defineProperty(this, "requestDedupeCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "DEDUPE_CACHE_TTL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 60000
+        }); // 去重缓存1分钟过期
         this.dbManager = dbManager;
         this.config = dbManager.getConfig();
         this.app = app;
     }
-    setupMiddleware() {
-        // Access logging middleware
-        this.app.use((req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // 忽略非业务请求
-            if (shouldIgnorePath(req.path)) {
-                return next();
-            }
-            // Capture client info
-            const clientIp = ((_a = req.headers['x-forwarded-for']) === null || _a === void 0 ? void 0 : _a.split(',')[0]) || req.socket.remoteAddress || '';
-            const userAgent = req.headers['user-agent'] || '';
-            const startTime = Date.now();
-            const originalSend = res.send.bind(res);
-            const originalJson = res.json.bind(res);
-            const accessLog = this.dbManager.addAccessLog({
-                timestamp: Date.now(),
-                method: req.method,
-                path: req.path,
-                clientIp,
-                userAgent,
-            });
-            const updateLog = (res, data) => {
-                const responseTime = Date.now() - startTime;
-                accessLog.then((accessLogId) => {
-                    const updateData = {
-                        responseTime,
-                    };
-                    let errorMessage = '';
-                    if (res instanceof Error) {
-                        updateData.error = res.message;
-                        errorMessage = res.message;
-                    }
-                    else if (res.statusCode >= 400) {
-                        updateData.statusCode = res.statusCode;
-                        updateData.error = res.statusMessage;
-                        // @ts-ignore
-                        updateData.responseHeaders = this.normalizeResponseHeaders(res.headers || {});
-                        errorMessage = res.statusMessage;
-                    }
-                    else {
-                        updateData.statusCode = res.statusCode;
-                        // @ts-ignore
-                        updateData.responseHeaders = this.normalizeResponseHeaders(res.headers || {});
-                        updateData.responseBody = data ? JSON.stringify(data) : undefined;
-                    }
-                    this.dbManager.updateAccessLog(accessLogId, updateData);
-                    // 记录错误日志
-                    if (res instanceof Error || res.statusCode >= 400) {
-                        this.dbManager.addErrorLog({
-                            timestamp: Date.now(),
-                            method: req.method,
-                            path: req.path,
-                            statusCode: 503,
-                            errorMessage,
-                            requestHeaders: this.normalizeHeaders(req.headers),
-                            requestBody: req.body ? JSON.stringify(req.body) : undefined,
-                            responseBody: data ? JSON.stringify(data) : undefined,
-                            // @ts-ignore
-                            responseHeaders: res.headers ? this.normalizeResponseHeaders(res.headers) : undefined,
-                            responseTime,
-                        });
-                    }
-                });
-            };
-            res.send = (data) => {
-                res.send = originalSend;
-                updateLog(res, data);
-                return originalSend(data);
-            };
-            res.json = (data) => {
-                res.json = originalJson;
-                updateLog(res, data);
-                return originalJson(data);
-            };
-            res.on('error', (err) => {
-                updateLog(err);
-            });
-            next();
-        }));
-        // Logging middleware (legacy RequestLog)
-        this.app.use((req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            const startTime = Date.now();
-            const originalSend = res.send.bind(res);
-            // 忽略非业务请求，并且只记录支持的编程工具请求
-            if (!shouldIgnorePath(req.path) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
-                res.send = (data) => {
-                    var _a;
-                    res.send = originalSend;
-                    if (!res.locals.skipLog && ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
-                        const responseTime = Date.now() - startTime;
-                        this.dbManager.addLog({
-                            timestamp: Date.now(),
-                            method: req.method,
-                            path: req.path,
-                            headers: this.normalizeHeaders(req.headers),
-                            body: req.body ? JSON.stringify(req.body) : undefined,
-                            statusCode: res.statusCode,
-                            responseTime,
-                        });
-                    }
-                    return res.send(data);
-                };
-            }
-            next();
-        }));
-        // Fixed route handlers
-        this.app.use('/claude-code/', this.createFixedRouteHandler('claude-code'));
-        this.app.use('/claude-code', this.createFixedRouteHandler('claude-code'));
-        this.app.use('/codex/', this.createFixedRouteHandler('codex'));
-        this.app.use('/codex', this.createFixedRouteHandler('codex'));
+    initialize() {
         // Dynamic proxy middleware
         this.app.use((req, res, next) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e;
-            // 根路径 / 不应该被代理中间件处理,应该传递给静态文件服务
-            if (req.path === '/') {
+            // 仅处理支持的目标路径
+            if (!SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                 return next();
             }
             try {
@@ -296,7 +190,7 @@ class ProxyServer {
                 // 所有服务都失败了
                 console.error('All services failed');
                 // 记录日志
-                if (((_d = this.config) === null || _d === void 0 ? void 0 : _d.enableLogging) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
+                if (((_d = this.config) === null || _d === void 0 ? void 0 : _d.enableLogging) !== false && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                     yield this.dbManager.addLog({
                         timestamp: Date.now(),
                         method: req.method,
@@ -338,7 +232,7 @@ class ProxyServer {
             }
             catch (error) {
                 console.error('Proxy error:', error);
-                if (((_e = this.config) === null || _e === void 0 ? void 0 : _e.enableLogging) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
+                if (((_e = this.config) === null || _e === void 0 ? void 0 : _e.enableLogging) !== false && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                     yield this.dbManager.addLog({
                         timestamp: Date.now(),
                         method: req.method,
@@ -377,6 +271,13 @@ class ProxyServer {
             }
         }));
     }
+    addProxyRoutes() {
+        // Fixed route handlers
+        this.app.use('/claude-code/', this.createFixedRouteHandler('claude-code'));
+        this.app.use('/claude-code', this.createFixedRouteHandler('claude-code'));
+        this.app.use('/codex/', this.createFixedRouteHandler('codex'));
+        this.app.use('/codex', this.createFixedRouteHandler('codex'));
+    }
     createFixedRouteHandler(targetType) {
         return (req, res) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e;
@@ -459,7 +360,7 @@ class ProxyServer {
                 // 所有服务都失败了
                 console.error('All services failed');
                 // 记录日志
-                if (((_d = this.config) === null || _d === void 0 ? void 0 : _d.enableLogging) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
+                if (((_d = this.config) === null || _d === void 0 ? void 0 : _d.enableLogging) !== false && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                     yield this.dbManager.addLog({
                         timestamp: Date.now(),
                         method: req.method,
@@ -501,7 +402,7 @@ class ProxyServer {
             }
             catch (error) {
                 console.error(`Fixed route error for ${targetType}:`, error);
-                if (((_e = this.config) === null || _e === void 0 ? void 0 : _e.enableLogging) && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
+                if (((_e = this.config) === null || _e === void 0 ? void 0 : _e.enableLogging) !== false && SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                     yield this.dbManager.addLog({
                         timestamp: Date.now(),
                         method: req.method,
@@ -542,24 +443,115 @@ class ProxyServer {
         const routeRules = this.dbManager.getRules(routeId);
         return routeRules.sort((a, b) => (b.sortOrder || 0) - (a.sortOrder || 0));
     }
-    findMatchingRoute(_req) {
-        // Find active route based on targetType - for now, return the first active route
-        // This can be extended later based on specific routing logic
+    findMatchingRoute(req) {
+        // 根据请求路径确定目标类型
+        let targetType;
+        if (req.path.startsWith('/claude-code/')) {
+            targetType = 'claude-code';
+        }
+        else if (req.path.startsWith('/codex/')) {
+            targetType = 'codex';
+        }
+        if (!targetType) {
+            return undefined;
+        }
+        // 返回匹配目标类型且处于活跃状态的路由
         const activeRoutes = this.getActiveRoutes();
-        return activeRoutes.find(route => route.isActive);
+        return activeRoutes.find(route => route.targetType === targetType && route.isActive);
     }
     findRouteByTargetType(targetType) {
         const activeRoutes = this.getActiveRoutes();
         return activeRoutes.find(route => route.targetType === targetType && route.isActive);
     }
+    /**
+     * 计算请求内容的哈希值，用于去重
+     * 基于请求的关键字段生成唯一标识
+     */
+    computeRequestHash(req) {
+        const body = req.body;
+        if (!body)
+            return null;
+        // 提取关键信息用于哈希
+        const messages = body.messages;
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            return null;
+        }
+        // 只使用最后几条消息的内容来生成哈希（避免整个历史过长）
+        const lastMessages = messages.slice(-3).map((msg) => ({
+            role: msg.role,
+            // 对消息内容进行简化处理，避免token差异导致哈希不同
+            content: this.normalizeMessageContent(msg.content)
+        }));
+        // 包含其他可能影响计费的字段
+        const keyFields = {
+            messages: lastMessages,
+            model: body.model,
+            stream: body.stream
+        };
+        return crypto_1.default.createHash('md5').update(JSON.stringify(keyFields)).digest('hex');
+    }
+    /**
+     * 规范化消息内容，去除细微差异
+     */
+    normalizeMessageContent(content) {
+        if (typeof content === 'string') {
+            // 去除首尾空白，限制长度
+            return content.trim().slice(0, 500);
+        }
+        if (Array.isArray(content)) {
+            // 对于数组类型内容（如图片+文本），只提取文本部分
+            const textParts = content
+                .filter((item) => (item === null || item === void 0 ? void 0 : item.type) === 'text')
+                .map((item) => { var _a; return ((_a = item.text) === null || _a === void 0 ? void 0 : _a.trim().slice(0, 500)) || ''; })
+                .join('|');
+            return textParts;
+        }
+        return String(content || '').slice(0, 500);
+    }
+    /**
+     * 检查请求是否已经被处理过（去重）
+     */
+    isRequestProcessed(hash) {
+        if (!hash)
+            return false;
+        const timestamp = this.requestDedupeCache.get(hash);
+        if (timestamp === undefined) {
+            // 未处理过，记录并返回false
+            this.requestDedupeCache.set(hash, Date.now());
+            return false;
+        }
+        // 检查是否过期
+        const now = Date.now();
+        if (now - timestamp > this.DEDUPE_CACHE_TTL) {
+            // 缓存已过期，视为新请求
+            this.requestDedupeCache.set(hash, now);
+            return false;
+        }
+        // 在缓存期内，视为重复请求
+        return true;
+    }
+    /**
+     * 清理过期的去重缓存
+     */
+    cleanExpiredDedupeCache() {
+        const now = Date.now();
+        for (const [hash, timestamp] of this.requestDedupeCache.entries()) {
+            if (now - timestamp > this.DEDUPE_CACHE_TTL) {
+                this.requestDedupeCache.delete(hash);
+            }
+        }
+    }
     /**
      * 根据GLM计费逻辑判断请求是否应该计费
      * 核心规则：
      * 1. 最后一条消息必须是 role: "user"
      * 2. 上一条消息不能是包含 tool_calls 的 assistant 消息（即不是工具回传）
+     * 3. 上一条消息应该是 assistant（正常的对话流程），而非连续的 user 消息
+     * 4. 避免历史消息重复计数：检查消息序列是否符合正常的对话模式
      */
-    shouldChargeRequest(requestBody) {
-        const messages = requestBody === null || requestBody === void 0 ? void 0 : requestBody.messages;
+    shouldChargeRequest(req) {
+        const body = req.body;
+        const messages = body === null || body === void 0 ? void 0 : body.messages;
         if (!messages || !Array.isArray(messages) || messages.length === 0) {
             return false;
         }
@@ -567,13 +559,54 @@ class ProxyServer {
         if (lastMessage.role !== 'user') {
             return false;
         }
-        if (messages.length > 1) {
-            const previousMessage = messages[messages.length - 2];
-            if (previousMessage.role === 'assistant' && previousMessage.tool_calls) {
-                return false;
+        // 规则1：只有一条消息，这是新会话的开始，应该计费
+        if (messages.length === 1) {
+            return true;
+        }
+        const previousMessage = messages[messages.length - 2];
+        // 规则2：上一条消息是 assistant 且包含 tool_calls，说明这是工具回调，不应计费
+        if (previousMessage.role === 'assistant' && previousMessage.tool_calls) {
+            return false;
+        }
+        // 规则3：上一条消息不是 user，说明是正常的 user->assistant->user 流程，应该计费
+        if (previousMessage.role !== 'user') {
+            return true;
+        }
+        // 规则4：上一条消息也是 user（连续的 user 消息）
+        // 这种情况下需要进一步判断：
+        // - 如果倒数第三条是 assistant，可能是用户连续发送的消息，只计最后一条
+        // - 检查两条 user 消息的内容是否相同，相同则可能是历史重放
+        if (messages.length >= 3) {
+            const thirdLastMessage = messages[messages.length - 3];
+            // 正常的对话流程: ... assistant, user, user
+            // 这种情况说明最后一条 user 消息是在 assistant 之后的新消息，应该计费
+            if (thirdLastMessage.role === 'assistant') {
+                return true;
             }
         }
-        return true;
+        // 规则5：检查是否有连续的 user 消息内容相同（可能的重复）
+        const lastContent = this.normalizeMessageContent(lastMessage.content);
+        const prevContent = this.normalizeMessageContent(previousMessage.content);
+        if (lastContent === prevContent && lastContent.length > 0) {
+            // 两条连续的 user 消息内容相同，可能是重复，不应计费
+            return false;
+        }
+        // 规则6：如果上一条是 user，但没有 assistant 在中间，可能是异常的对话流
+        // 为了安全起见，检查再往前是否有 assistant
+        for (let i = messages.length - 3; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg.role === 'assistant') {
+                // 找到了最近的 assistant，说明当前是新的对话轮次，应该计费
+                return true;
+            }
+            if (msg.role === 'user') {
+                // 还是 user 消息，继续往前找
+                continue;
+            }
+            // 其他 role（如 system），继续
+        }
+        // 没有找到 assistant，可能是异常情况，不计费
+        return false;
     }
     /**
      * 从数据库实时获取服务配置
@@ -955,11 +988,15 @@ class ProxyServer {
         addText(body === null || body === void 0 ? void 0 : body.prompt);
         return length;
     }
+    /** 判断是否为 Claude 相关类型（使用 x-api-key 认证） */
     isClaudeSource(sourceType) {
-        return sourceType === 'claude-chat';
+        return sourceType === 'claude-chat' || sourceType === 'claude-code';
     }
     isOpenAIChatSource(sourceType) {
-        return sourceType === 'openai-chat' || sourceType === 'deepseek-chat';
+        return sourceType === 'openai-chat' || sourceType === 'openai-responses' || sourceType === 'deepseek-reasoning-chat';
+    }
+    isChatType(sourceType) {
+        return sourceType.endsWith('-chat');
     }
     /**
      * 判断模型是否应该使用 max_completion_tokens 字段
@@ -1018,7 +1055,7 @@ class ProxyServer {
         const requestedMaxTokens = result[maxTokensFieldName] || result.max_tokens;
         // 如果请求中指定了 max_tokens，并且超过配置的限制，则限制为配置的最大值
         if (typeof requestedMaxTokens === 'number' && requestedMaxTokens > maxOutputLimit) {
-            console.log(`[Proxy] Limiting ${maxTokensFieldName} from ${requestedMaxTokens} to ${maxOutputLimit} for model ${model} in service ${service.name}`);
+            // console.log(`[Proxy] Limiting ${maxTokensFieldName} from ${requestedMaxTokens} to ${maxOutputLimit} for model ${model} in service ${service.name}`);
             result[maxTokensFieldName] = maxOutputLimit;
             // 如果使用了 max_completion_tokens，清理旧的 max_tokens 字段
             if (maxTokensFieldName === 'max_completion_tokens' && result.max_tokens !== undefined) {
@@ -1027,7 +1064,7 @@ class ProxyServer {
         }
         else if (requestedMaxTokens === undefined) {
             // 如果请求中没有指定 max_tokens，则使用配置的最大值
-            console.log(`[Proxy] Setting ${maxTokensFieldName} to ${maxOutputLimit} for model ${model} in service ${service.name}`);
+            // console.log(`[Proxy] Setting ${maxTokensFieldName} to ${maxOutputLimit} for model ${model} in service ${service.name}`);
             result[maxTokensFieldName] = maxOutputLimit;
         }
         return result;
@@ -1061,11 +1098,19 @@ class ProxyServer {
         if (streamRequested) {
             headers.accept = 'text/event-stream';
         }
-        if (this.isClaudeSource(sourceType)) {
+        // 确定认证方式：优先使用服务配置的 authType，否则根据 sourceType 自动判断
+        const authType = service.authType || 'auto';
+        const useXApiKey = authType === 'x-api-key' || (authType === 'auto' && this.isClaudeSource(sourceType));
+        if (useXApiKey) {
+            // 使用 x-api-key 认证（适用于 claude-chat, claude-code 及某些需要 x-api-key 的 openai-chat 兼容 API）
             headers['x-api-key'] = service.apiKey;
-            headers['anthropic-version'] = headers['anthropic-version'] || '2023-06-01';
+            if (this.isClaudeSource(sourceType) || authType === 'x-api-key') {
+                // 仅在明确配置或 Claude 源时添加 anthropic-version
+                headers['anthropic-version'] = headers['anthropic-version'] || '2023-06-01';
+            }
         }
         else {
+            // 使用 Authorization 认证（适用于 openai-chat, openai-responses, deepseek-reasoning-chat 等）
             delete headers['anthropic-version'];
             delete headers['anthropic-beta'];
             headers.authorization = `Bearer ${service.apiKey}`;
@@ -1142,6 +1187,62 @@ class ProxyServer {
         }
         return undefined;
     }
+    /**
+     * 从请求中提取 session ID（默认方法）
+     * Claude Code: metadata.user_id
+     * Codex: headers.session_id
+     */
+    defaultExtractSessionId(request, type) {
+        var _a, _b;
+        if (type === 'claude-code') {
+            // Claude Code 使用 metadata.user_id
+            return ((_b = (_a = request.body) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.user_id) || null;
+        }
+        else if (type === 'codex') {
+            // Codex 使用 headers.session_id
+            const sessionId = request.headers['session_id'];
+            if (typeof sessionId === 'string') {
+                return sessionId;
+            }
+            if (Array.isArray(sessionId)) {
+                return sessionId[0] || null;
+            }
+        }
+        return null;
+    }
+    /**
+     * 提取会话标题（默认方法）
+     * 对于新会话，尝试从第一条消息的内容中提取标题
+     */
+    defaultExtractSessionTitle(request, sessionId) {
+        var _a;
+        const existingSession = this.dbManager.getSession(sessionId);
+        if (existingSession) {
+            // 已存在的会话，保持原有标题
+            return existingSession.title;
+        }
+        // 新会话，从消息内容提取标题
+        const messages = (_a = request.body) === null || _a === void 0 ? void 0 : _a.messages;
+        if (Array.isArray(messages) && messages.length > 0) {
+            // 查找第一条 user 消息
+            const firstUserMessage = messages.find((msg) => msg.role === 'user');
+            if (firstUserMessage) {
+                const content = firstUserMessage.content;
+                if (typeof content === 'string') {
+                    // 截取前50个字符作为标题
+                    return content.slice(0, 50).trim();
+                }
+                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();
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
     /**
      * 根据源工具类型和目标API类型,映射请求路径
      * @param sourceTool 源工具类型 (claude-code 或 codex)
@@ -1195,8 +1296,13 @@ class ProxyServer {
             let actuallyUsedProxy = false; // 标记是否实际使用了代理
             const finalizeLog = (statusCode, error) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
-                if (logged || !((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging))
+                if (logged)
+                    return;
+                // 检查是否启用日志记录（默认启用）
+                const enableLogging = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging) !== false; // 默认为 true
+                if (!enableLogging) {
                     return;
+                }
                 // 只记录来自编程工具的请求
                 if (!SUPPORTED_TARGETS.some(target => req.path.startsWith(`/${target}/`))) {
                     return;
@@ -1232,6 +1338,26 @@ class ProxyServer {
                     streamChunks: streamChunksForLog,
                     upstreamRequest: upstreamRequestForLog,
                 });
+                // Session 索引逻辑
+                const sessionId = this.defaultExtractSessionId(req, targetType);
+                if (sessionId) {
+                    const totalTokens = ((usageForLog === null || usageForLog === void 0 ? void 0 : usageForLog.inputTokens) || 0) + ((usageForLog === null || usageForLog === void 0 ? void 0 : usageForLog.outputTokens) || 0) +
+                        ((usageForLog === null || usageForLog === void 0 ? void 0 : usageForLog.totalTokens) || 0);
+                    const sessionTitle = this.defaultExtractSessionTitle(req, sessionId);
+                    this.dbManager.upsertSession({
+                        id: sessionId,
+                        targetType,
+                        title: sessionTitle,
+                        firstRequestAt: startTime,
+                        lastRequestAt: Date.now(),
+                        vendorId: service.vendorId,
+                        vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+                        serviceId: service.id,
+                        serviceName: service.name,
+                        model: requestModel || rule.targetModel,
+                        totalTokens,
+                    });
+                }
                 // 更新规则的token使用量（只在成功请求时更新）
                 if (usageForLog && statusCode < 400) {
                     const totalTokens = (usageForLog.inputTokens || 0) + (usageForLog.outputTokens || 0);
@@ -1240,8 +1366,17 @@ class ProxyServer {
                     }
                 }
                 // 更新规则的请求次数（只在成功请求时更新）
-                if (statusCode < 400 && this.shouldChargeRequest(req.body)) {
-                    this.dbManager.incrementRuleRequestCount(rule.id, 1);
+                if (statusCode < 400 && this.shouldChargeRequest(req)) {
+                    // 计算请求哈希用于去重
+                    const requestHash = this.computeRequestHash(req);
+                    // 检查是否是重复请求（如网络重试）
+                    if (!this.isRequestProcessed(requestHash)) {
+                        this.dbManager.incrementRuleRequestCount(rule.id, 1);
+                    }
+                    // 定期清理过期缓存
+                    if (Math.random() < 0.01) { // 1%概率清理，避免每次都清理
+                        this.cleanExpiredDedupeCache();
+                    }
                 }
             });
             try {
@@ -1286,7 +1421,7 @@ class ProxyServer {
                 const mappedPath = this.mapRequestPath(route.targetType, sourceType, pathToAppend);
                 const config = {
                     method: req.method,
-                    url: `${service.apiUrl}${mappedPath}`,
+                    url: this.isChatType(sourceType) ? service.apiUrl : `${service.apiUrl}${mappedPath}`,
                     headers: this.buildUpstreamHeaders(req, service, sourceType, streamRequested),
                     timeout: rule.timeout || 3000000, // 默认300秒
                     validateStatus: () => true,
@@ -1328,13 +1463,16 @@ class ProxyServer {
                     }
                 }
                 // 记录实际发出的请求信息作为日志的一部分
-                const actualModel = (requestBody === null || requestBody === void 0 ? void 0 : requestBody.model) || '';
-                const maxTokensFieldName = this.getMaxTokensFieldName(actualModel);
-                const actualMaxTokens = (requestBody === null || requestBody === void 0 ? void 0 : requestBody[maxTokensFieldName]) || (requestBody === null || requestBody === void 0 ? void 0 : requestBody.max_tokens);
+                // const actualModel = requestBody?.model || '';
+                // const maxTokensFieldName = this.getMaxTokensFieldName(actualModel);
+                // const actualMaxTokens = requestBody?.[maxTokensFieldName] || requestBody?.max_tokens;
+                const upstreamHeaders = this.buildUpstreamHeaders(req, service, sourceType, streamRequested);
                 upstreamRequestForLog = {
-                    url: `${service.apiUrl}${mappedPath}`,
-                    model: actualModel,
-                    [maxTokensFieldName]: actualMaxTokens,
+                    url: this.isChatType(sourceType) ? service.apiUrl : `${service.apiUrl}${mappedPath}`,
+                    // model: actualModel,
+                    // [maxTokensFieldName]: actualMaxTokens,
+                    headers: upstreamHeaders,
+                    body: requestBody || undefined,
                 };
                 if (actuallyUsedProxy) {
                     upstreamRequestForLog.useProxy = true;
@@ -1440,6 +1578,33 @@ class ProxyServer {
                     usageForLog = this.extractTokenUsage(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
                     // 记录错误响应体
                     responseBodyForLog = typeof responseData === 'string' ? responseData : JSON.stringify(responseData);
+                    // 将 4xx/5xx 错误记录到错误日志
+                    // 确保 errorDetail 总是字符串类型
+                    let errorDetail;
+                    if (typeof (responseData === null || responseData === void 0 ? void 0 : responseData.error) === 'string') {
+                        errorDetail = responseData.error;
+                    }
+                    else if (typeof (responseData === null || responseData === void 0 ? void 0 : responseData.message) === 'string') {
+                        errorDetail = responseData.message;
+                    }
+                    else if (responseData === null || responseData === void 0 ? void 0 : responseData.error) {
+                        errorDetail = JSON.stringify(responseData.error);
+                    }
+                    else {
+                        errorDetail = JSON.stringify(responseData);
+                    }
+                    yield this.dbManager.addErrorLog({
+                        timestamp: Date.now(),
+                        method: req.method,
+                        path: req.path,
+                        statusCode: response.status,
+                        errorMessage: `Upstream API returned ${response.status}: ${errorDetail}`,
+                        errorStack: undefined,
+                        requestHeaders: this.normalizeHeaders(req.headers),
+                        requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                        responseHeaders: responseHeadersForLog,
+                        responseBody: responseBodyForLog,
+                    });
                     this.copyResponseHeaders(responseHeaders, res);
                     if (contentType.includes('application/json')) {
                         res.status(response.status).json(responseData);
@@ -1486,7 +1651,18 @@ class ProxyServer {
                 const errorMessage = isTimeout
                     ? 'Request timeout - the upstream API took too long to respond'
                     : (error.message || 'Internal server error');
-                yield finalizeLog(500, errorMessage);
+                // 将错误记录到错误日志
+                yield this.dbManager.addErrorLog({
+                    timestamp: Date.now(),
+                    method: req.method,
+                    path: req.path,
+                    statusCode: isTimeout ? 504 : 500,
+                    errorMessage: errorMessage,
+                    errorStack: error.stack,
+                    requestHeaders: this.normalizeHeaders(req.headers),
+                    requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                });
+                yield finalizeLog(isTimeout ? 504 : 500, errorMessage);
                 // 根据请求类型返回适当格式的错误响应
                 const streamRequested = this.isStreamRequested(req, req.body || {});
                 if (route.targetType === 'claude-code') {
@@ -1554,9 +1730,9 @@ class ProxyServer {
             this.config = config;
         });
     }
-    initialize() {
+    registerProxyRoutes() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.setupMiddleware();
+            this.addProxyRoutes();
             yield this.reloadRoutes();
         });
     }