aicodeswitch 1.7.0 → 1.8.0

package/README.md

@@ -97,7 +97,7 @@ Codex的配置覆盖逻辑一模一样。
 
 **有什么用？**
 
-aicodeswitch内部，会根据“源类型”来转换数据。例如，你的供应商API服务接口是OpenAI Chat的数据格式，而你在路由中配置的“路由对象“是Claude Code，那么就意味着，这个供应商API的数据，需要经过转换之后才能被Claude Code正确使用。
+aicodeswitch内部，会根据“源类型”来转换数据。例如，你的供应商API服务接口是OpenAI Chat的数据格式，而你在路由中配置的“客户端工具“是Claude Code，那么就意味着，这个供应商API的数据，需要经过转换之后才能被Claude Code正确使用。
 
 ## 路由管理
 
@@ -105,7 +105,7 @@ aicodeswitch内部，会根据“源类型”来转换数据。例如，你的
 
 路由是aicodeswitch的核心功能，它负责将不同的对象（目前指Claude Code和Codex）的请求，路由到不同的供应商API服务上。
 
-### 什么是“路由对象”？
+### 什么是“客户端工具”？
 
 目前指Claude Code或Codex。
 

package/dist/server/database.js

@@ -58,6 +58,16 @@ class DatabaseManager {
             value: void 0
         });
         this.db = new better_sqlite3_1.default(path_1.default.join(dataPath, 'app.db'));
+        // 启用外键约束（SQLite 默认禁用，必须手动启用才能使 ON DELETE CASCADE 生效）
+        this.db.pragma('foreign_keys = ON');
+        // 配置数据库以确保实时读取最新数据
+        // WAL 模式 + normal 同步模式: 提供最佳的并发性和实时性
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        // 确保读取操作不会看到旧的数据快照
+        // 在 WAL 模式下,默认情况下读取操作不会阻塞写入操作
+        // 设置 read_uncommitted = 0 确保读取最新提交的数据
+        this.db.pragma('read_uncommitted = 0');
         this.logDb = new level_1.Level(path_1.default.join(dataPath, 'logs'), { valueEncoding: 'json' });
         this.accessLogDb = new level_1.Level(path_1.default.join(dataPath, 'access-logs'), { valueEncoding: 'json' });
         this.errorLogDb = new level_1.Level(path_1.default.join(dataPath, 'error-logs'), { valueEncoding: 'json' });
@@ -66,9 +76,68 @@ class DatabaseManager {
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
             this.createTables();
+            yield this.runMigrations();
             yield this.ensureDefaultConfig();
         });
     }
+    runMigrations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = this.db.pragma('table_info(api_services)');
+            // 检查是否有旧的 max_output_tokens 字段（单值版本）
+            const hasOldMaxOutputTokens = columns.some((col) => col.name === 'max_output_tokens');
+            // 检查是否已经有新的 model_limits 字段（JSON 版本）
+            const hasModelLimits = columns.some((col) => col.name === 'model_limits');
+            if (!hasModelLimits) {
+                if (hasOldMaxOutputTokens) {
+                    // 如果有旧字段，先删除旧字段（SQLite 不支持 ALTER TABLE DROP COLUMN，需要重建表）
+                    console.log('[DB] Running migration: Replacing max_output_tokens with model_limits');
+                    yield this.migrateMaxOutputTokensToModelLimits();
+                }
+                else {
+                    // 直接添加新字段
+                    console.log('[DB] Running migration: Adding model_limits column to api_services table');
+                    this.db.exec('ALTER TABLE api_services ADD COLUMN model_limits TEXT;');
+                    console.log('[DB] Migration completed: model_limits column added');
+                }
+            }
+        });
+    }
+    migrateMaxOutputTokensToModelLimits() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // SQLite 不支持直接删除列，需要重建表
+            // 先临时禁用外键约束
+            this.db.pragma('foreign_keys = OFF');
+            this.db.exec(`
+      CREATE TABLE api_services_new (
+        id TEXT PRIMARY KEY,
+        vendor_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        api_url TEXT NOT NULL,
+        api_key TEXT NOT NULL,
+        timeout INTEGER,
+        source_type TEXT,
+        supported_models TEXT,
+        model_limits TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (vendor_id) REFERENCES vendors(id) ON DELETE CASCADE
+      );
+
+      INSERT INTO api_services_new
+      SELECT
+        id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models,
+        NULL, -- model_limits 设为 NULL，旧数据需要手动配置
+        created_at, updated_at
+      FROM api_services;
+
+      DROP TABLE api_services;
+      ALTER TABLE api_services_new RENAME TO api_services;
+    `);
+            // 重新启用外键约束
+            this.db.pragma('foreign_keys = ON');
+            console.log('[DB] Migration completed: Replaced max_output_tokens with model_limits');
+        });
+    }
     createTables() {
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS vendors (
@@ -129,7 +198,7 @@ class DatabaseManager {
             if (!config) {
                 const defaultConfig = {
                     enableLogging: true,
-                    logRetentionDays: 7,
+                    logRetentionDays: 30,
                     maxLogSize: 1000,
                     apiKey: '',
                     enableFailover: true, // 默认启用智能故障切换
@@ -170,12 +239,14 @@ class DatabaseManager {
     }
     // API Service operations
     getAPIServices(vendorId) {
+        // 每次都重新准备语句以确保获取最新数据
         const query = vendorId
             ? 'SELECT * FROM api_services WHERE vendor_id = ? ORDER BY created_at DESC'
             : 'SELECT * FROM api_services ORDER BY created_at DESC';
-        const stmt = vendorId ? this.db.prepare(query).bind(vendorId) : this.db.prepare(query);
-        const rows = stmt.all();
-        return rows.map((row) => ({
+        // 不缓存 prepared statement,每次重新创建以确保读取最新数据
+        const stmt = this.db.prepare(query);
+        const rows = vendorId ? stmt.all(vendorId) : stmt.all();
+        const services = rows.map((row) => ({
             id: row.id,
             vendorId: row.vendor_id,
             name: row.name,
@@ -184,23 +255,33 @@ class DatabaseManager {
             timeout: row.timeout,
             sourceType: row.source_type,
             supportedModels: row.supported_models ? row.supported_models.split(',').map((model) => model.trim()).filter((model) => model.length > 0) : undefined,
+            modelLimits: row.model_limits ? JSON.parse(row.model_limits) : undefined,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         }));
+        // 调试日志: 记录读取的服务信息
+        if (process.env.NODE_ENV === 'development' && services.length > 0) {
+            console.log(`[DB] Read ${services.length} services from database, first service: ${services[0].name} -> ${services[0].apiUrl}`);
+        }
+        return services;
     }
     createAPIService(service) {
         const id = crypto_1.default.randomUUID();
         const now = Date.now();
         this.db
-            .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-            .run(id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, now, now);
+            .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, model_limits, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, now, now);
         return Object.assign(Object.assign({}, service), { id, createdAt: now, updatedAt: now });
     }
     updateAPIService(id, service) {
         const now = Date.now();
         const result = this.db
-            .prepare('UPDATE api_services SET name = ?, api_url = ?, api_key = ?, timeout = ?, source_type = ?, supported_models = ?, updated_at = ? WHERE id = ?')
-            .run(service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, now, id);
+            .prepare('UPDATE api_services SET name = ?, api_url = ?, api_key = ?, timeout = ?, source_type = ?, supported_models = ?, model_limits = ?, updated_at = ? WHERE id = ?')
+            .run(service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, now, id);
+        // 调试日志: 记录更新操作
+        if (result.changes > 0 && process.env.NODE_ENV === 'development') {
+            console.log(`[DB] Updated service ${id}: ${service.name} -> ${service.apiUrl} (timeout: ${service.timeout})`);
+        }
         return result.changes > 0;
     }
     deleteAPIService(id) {
@@ -544,8 +625,8 @@ class DatabaseManager {
                 // Import API services
                 for (const service of importData.apiServices) {
                     this.db
-                        .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-                        .run(service.id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.createdAt, service.updatedAt);
+                        .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, model_limits, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+                        .run(service.id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, service.createdAt, service.updatedAt);
                 }
                 // Import routes
                 for (const route of importData.routes) {

package/dist/server/proxy-server.js

@@ -228,10 +228,24 @@ class ProxyServer {
                     requestHeaders: this.normalizeHeaders(req.headers),
                     requestBody: req.body ? JSON.stringify(req.body) : undefined,
                 });
-                res.status(503).json({
-                    error: 'All services failed',
-                    details: lastError === null || lastError === void 0 ? void 0 : lastError.message
-                });
+                // 根据路径判断目标类型并返回适当的错误格式
+                const isClaudeCode = req.path.startsWith('/claude-code/');
+                if (isClaudeCode) {
+                    const claudeError = {
+                        type: 'error',
+                        error: {
+                            type: 'api_error',
+                            message: 'All API services failed. Please try again later.'
+                        }
+                    };
+                    res.status(503).json(claudeError);
+                }
+                else {
+                    res.status(503).json({
+                        error: 'All services failed',
+                        details: lastError === null || lastError === void 0 ? void 0 : lastError.message
+                    });
+                }
             }
             catch (error) {
                 console.error('Proxy error:', error);
@@ -256,7 +270,21 @@ class ProxyServer {
                     requestHeaders: this.normalizeHeaders(req.headers),
                     requestBody: req.body ? JSON.stringify(req.body) : undefined,
                 });
-                res.status(500).json({ error: error.message });
+                // 根据路径判断目标类型并返回适当的错误格式
+                const isClaudeCode = req.path.startsWith('/claude-code/');
+                if (isClaudeCode) {
+                    const claudeError = {
+                        type: 'error',
+                        error: {
+                            type: 'api_error',
+                            message: error.message || 'Internal server error'
+                        }
+                    };
+                    res.status(500).json(claudeError);
+                }
+                else {
+                    res.status(500).json({ error: error.message });
+                }
             }
         }));
     }
@@ -350,10 +378,24 @@ class ProxyServer {
                     requestHeaders: this.normalizeHeaders(req.headers),
                     requestBody: req.body ? JSON.stringify(req.body) : undefined,
                 });
-                res.status(503).json({
-                    error: 'All services failed',
-                    details: lastError === null || lastError === void 0 ? void 0 : lastError.message
-                });
+                // 根据路径判断目标类型并返回适当的错误格式
+                const isClaudeCode = req.path.startsWith('/claude-code/');
+                if (isClaudeCode) {
+                    const claudeError = {
+                        type: 'error',
+                        error: {
+                            type: 'api_error',
+                            message: 'All API services failed. Please try again later.'
+                        }
+                    };
+                    res.status(503).json(claudeError);
+                }
+                else {
+                    res.status(503).json({
+                        error: 'All services failed',
+                        details: lastError === null || lastError === void 0 ? void 0 : lastError.message
+                    });
+                }
             }
             catch (error) {
                 console.error(`Fixed route error for ${targetType}:`, error);
@@ -415,7 +457,12 @@ class ProxyServer {
      */
     getServiceById(serviceId) {
         const allServices = this.dbManager.getAPIServices();
-        return allServices.find(service => service.id === serviceId);
+        const service = allServices.find(s => s.id === serviceId);
+        // 调试日志: 记录获取的服务信息
+        if (process.env.NODE_ENV === 'development' && service) {
+            console.log(`[Proxy] getServiceById(${serviceId}): ${service.name} -> ${service.apiUrl}`);
+        }
+        return service;
     }
     findMatchingRule(routeId, req) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -726,6 +773,77 @@ class ProxyServer {
     isOpenAIChatSource(sourceType) {
         return sourceType === 'openai-chat' || sourceType === 'deepseek-chat';
     }
+    /**
+     * 判断模型是否应该使用 max_completion_tokens 字段
+     * GPT 的新模型（如 o1 系列）使用 max_completion_tokens
+     */
+    shouldUseMaxCompletionTokens(model) {
+        if (!model)
+            return false;
+        const lowerModel = model.toLowerCase();
+        // o1 系列模型使用 max_completion_tokens
+        return lowerModel.includes('o1-') ||
+            lowerModel.startsWith('o1') ||
+            lowerModel.includes('gpt-4.1') ||
+            lowerModel.includes('gpt-4o') ||
+            lowerModel.startsWith('chatgpt-');
+    }
+    /**
+     * 获取 max tokens 字段的名称
+     */
+    getMaxTokensFieldName(model) {
+        return this.shouldUseMaxCompletionTokens(model) ? 'max_completion_tokens' : 'max_tokens';
+    }
+    /**
+     * 应用 max_output_tokens 限制
+     * 根据服务的 modelLimits 配置，对具体模型应用 max_tokens/max_completion_tokens 限制
+     */
+    applyMaxOutputTokensLimit(body, service) {
+        if (!service.modelLimits || !body || typeof body !== 'object') {
+            return body;
+        }
+        const result = Object.assign({}, body);
+        const model = result.model;
+        if (!model) {
+            return body;
+        }
+        // 查找该模型的限制配置
+        // 支持精确匹配和前缀匹配（例如：gpt-4 可以匹配 gpt-4-turbo）
+        let maxOutputLimit;
+        // 1. 先尝试精确匹配
+        if (typeof service.modelLimits[model] === 'number') {
+            maxOutputLimit = service.modelLimits[model];
+        }
+        else {
+            // 2. 尝试前缀匹配（查找配置中以模型名开头的项）
+            const matchedKey = Object.keys(service.modelLimits).find(key => model.startsWith(key) || key.startsWith(model));
+            if (matchedKey && typeof service.modelLimits[matchedKey] === 'number') {
+                maxOutputLimit = service.modelLimits[matchedKey];
+            }
+        }
+        if (maxOutputLimit === undefined) {
+            // 没有找到配置，直接透传
+            return body;
+        }
+        const maxTokensFieldName = this.getMaxTokensFieldName(model);
+        // 获取请求中的 max_tokens 或 max_completion_tokens 值
+        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}`);
+            result[maxTokensFieldName] = maxOutputLimit;
+            // 如果使用了 max_completion_tokens，清理旧的 max_tokens 字段
+            if (maxTokensFieldName === 'max_completion_tokens' && result.max_tokens !== undefined) {
+                delete result.max_tokens;
+            }
+        }
+        else if (requestedMaxTokens === undefined) {
+            // 如果请求中没有指定 max_tokens，则使用配置的最大值
+            console.log(`[Proxy] Setting ${maxTokensFieldName} to ${maxOutputLimit} for model ${model} in service ${service.name}`);
+            result[maxTokensFieldName] = maxOutputLimit;
+        }
+        return result;
+    }
     applyModelOverride(body, rule) {
         // 如果 targetModel 为空或不存在,保留原始 model(透传)
         if (!rule.targetModel)
@@ -873,7 +991,7 @@ class ProxyServer {
     }
     proxyRequest(req, res, route, rule, service) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             res.locals.skipLog = true;
             const startTime = Date.now();
             const sourceType = (service.sourceType || 'openai-chat');
@@ -948,6 +1066,8 @@ class ProxyServer {
                         return;
                     }
                 }
+                // 应用 max_output_tokens 限制
+                requestBody = this.applyMaxOutputTokensLimit(requestBody, service);
                 const streamRequested = this.isStreamRequested(req, requestBody);
                 // Build the full URL by appending the request path to the service API URL
                 let pathToAppend = req.path;
@@ -974,9 +1094,14 @@ class ProxyServer {
                     config.data = requestBody;
                 }
                 // 记录实际发出的请求信息作为日志的一部分
+                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);
                 upstreamRequestForLog = {
                     url: `${service.apiUrl}${mappedPath}`,
-                    model: (requestBody === null || requestBody === void 0 ? void 0 : requestBody.model) || '',
+                    model: actualModel,
+                    maxTokens: actualMaxTokens,
+                    maxTokensField: maxTokensFieldName,
                 };
                 const response = yield (0, axios_1.default)(config);
                 const responseHeaders = response.headers || {};
@@ -1118,25 +1243,44 @@ class ProxyServer {
             }
             catch (error) {
                 console.error('Proxy error:', error);
-                yield finalizeLog(500, error.message);
+                // 检测是否是 timeout 错误
+                const isTimeout = error.code === 'ECONNABORTED' ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('timeout')) ||
+                    (error.errno && error.errno === 'ETIMEDOUT');
+                const errorMessage = isTimeout
+                    ? 'Request timeout - the upstream API took too long to respond'
+                    : (error.message || 'Internal server error');
+                yield finalizeLog(500, errorMessage);
                 // 根据请求类型返回适当格式的错误响应
                 const streamRequested = this.isStreamRequested(req, req.body || {});
-                if (streamRequested && route.targetType === 'claude-code') {
-                    // 对于 Claude Code 的流式请求，返回 SSE 格式的错误响应
-                    res.setHeader('Content-Type', 'text/event-stream');
-                    res.setHeader('Cache-Control', 'no-cache');
-                    res.setHeader('Connection', 'keep-alive');
-                    res.status(500);
-                    // 发送错误事件
-                    const errorEvent = `event: error\ndata: ${JSON.stringify({ error: error.message })}\n\n`;
-                    const doneEvent = `data: [DONE]\n\n`;
-                    res.write(errorEvent);
-                    res.write(doneEvent);
-                    res.end();
+                if (route.targetType === 'claude-code') {
+                    // 对于 Claude Code，返回符合 Claude API 标准的错误响应
+                    const claudeError = {
+                        type: 'error',
+                        error: {
+                            type: isTimeout ? 'api_error' : 'api_error',
+                            message: errorMessage
+                        }
+                    };
+                    if (streamRequested) {
+                        // 流式请求：使用 SSE 格式
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        res.status(200);
+                        // 发送错误事件（使用 Claude API 的标准格式）
+                        const errorEvent = `event: error\ndata: ${JSON.stringify(claudeError)}\n\n`;
+                        res.write(errorEvent);
+                        res.end();
+                    }
+                    else {
+                        // 非流式请求：返回 JSON 格式
+                        res.status(500).json(claudeError);
+                    }
                 }
                 else {
-                    // 对于非流式请求，返回 JSON 格式的错误响应
-                    res.status(500).json({ error: error.message });
+                    // 对于 Codex，返回 JSON 格式的错误响应
+                    res.status(500).json({ error: errorMessage });
                 }
             }
         });