aicodeswitch 3.6.2 → 3.9.1

package/dist/server/main.js

@@ -104,7 +104,7 @@ const asyncHandler = (handler) => (req, res, next) => {
         next(err);
     });
 };
-const writeClaudeConfig = (dbManager, enableAgentTeams) => __awaiter(void 0, void 0, void 0, function* () {
+const writeClaudeConfig = (dbManager, enableAgentTeams, enableBypassPermissionsSupport) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const homeDir = os_1.default.homedir();
         const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
@@ -153,6 +153,13 @@ const writeClaudeConfig = (dbManager, enableAgentTeams) => __awaiter(void 0, voi
         const claudeSettings = {
             env: claudeSettingsEnv
         };
+        // 如果开启对bypassPermissions的支持，添加对应的配置项
+        if (enableBypassPermissionsSupport) {
+            claudeSettings.permissions = {
+                defaultMode: "bypassPermissions"
+            };
+            claudeSettings.skipDangerousModePermissionPrompt = true;
+        }
         fs_1.default.writeFileSync(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2));
         // Claude Code .claude.json
         const claudeJsonPath = path_1.default.join(homeDir, '.claude.json');
@@ -243,10 +250,80 @@ const updateClaudeAgentTeamsConfig = (enableAgentTeams) => __awaiter(void 0, voi
         return false;
     }
 });
-const writeCodexConfig = (dbManager) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * 更新Claude Code配置中的bypassPermissions支持设置
+ * 此函数假设配置文件已经被代理覆盖，直接修改配置而不重新备份
+ */
+const updateClaudeBypassPermissionsSupportConfig = (enableBypassPermissionsSupport) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        const claudeSettingsPath = path_1.default.join(homeDir, '.claude/settings.json');
+        // 检查配置文件是否存在
+        if (!fs_1.default.existsSync(claudeSettingsPath)) {
+            console.error('Claude settings.json does not exist');
+            return false;
+        }
+        // 读取当前配置
+        const currentContent = fs_1.default.readFileSync(claudeSettingsPath, 'utf-8');
+        const currentConfig = JSON.parse(currentContent);
+        // 检查是否是代理配置
+        const configStatus = (0, config_metadata_1.checkClaudeConfigStatus)();
+        if (!configStatus.isOverwritten) {
+            console.error('Claude config is not overwritten by proxy. Please activate a route first.');
+            return false;
+        }
+        // 更新或删除bypassPermissions支持配置项
+        if (enableBypassPermissionsSupport) {
+            currentConfig.permissions = {
+                defaultMode: "bypassPermissions"
+            };
+            currentConfig.skipDangerousModePermissionPrompt = true;
+        }
+        else {
+            delete currentConfig.permissions;
+            delete currentConfig.skipDangerousModePermissionPrompt;
+        }
+        // 写入更新后的配置
+        fs_1.default.writeFileSync(claudeSettingsPath, JSON.stringify(currentConfig, null, 2));
+        // 更新元数据中的当前配置hash
+        const metadata = (0, config_metadata_1.loadMetadata)('claude');
+        if (metadata && metadata.files[0]) {
+            metadata.files[0].currentHash = (0, crypto_1.createHash)('sha256')
+                .update(fs_1.default.readFileSync(claudeSettingsPath, 'utf-8'))
+                .digest('hex');
+            metadata.timestamp = Date.now();
+            (0, config_metadata_1.saveMetadata)(metadata);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to update Claude bypassPermissions support config:', error);
+        return false;
+    }
+});
+const VALID_CODEX_REASONING_EFFORTS = ['low', 'medium', 'high'];
+const DEFAULT_CODEX_REASONING_EFFORT = 'high';
+const isCodexReasoningEffort = (value) => {
+    return typeof value === 'string' && VALID_CODEX_REASONING_EFFORTS.includes(value);
+};
+const buildCodexConfigToml = (modelReasoningEffort) => {
+    const localPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+    return `model_provider = "aicodeswitch"
+model = "gpt-5.1-codex"
+model_reasoning_effort = "${modelReasoningEffort}"
+disable_response_storage = true
+
+
+[model_providers.aicodeswitch]
+name = "aicodeswitch"
+base_url = "http://${host}:${localPort}/codex"
+wire_api = "responses"
+requires_openai_auth = true
+`;
+};
+const writeCodexConfig = (dbManager_1, ...args_1) => __awaiter(void 0, [dbManager_1, ...args_1], void 0, function* (dbManager, modelReasoningEffort = DEFAULT_CODEX_REASONING_EFFORT) {
     try {
         const homeDir = os_1.default.homedir();
-        const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
         const config = dbManager.getConfig();
         // Codex config.toml
         const codexDir = path_1.default.join(homeDir, '.codex');
@@ -277,19 +354,7 @@ const writeCodexConfig = (dbManager) => __awaiter(void 0, void 0, void 0, functi
         if (!fs_1.default.existsSync(codexDir)) {
             fs_1.default.mkdirSync(codexDir, { recursive: true });
         }
-        const codexConfig = `model_provider = "aicodeswitch"
-model = "gpt-5.1-codex"
-model_reasoning_effort = "high"
-disable_response_storage = true
-
-
-[model_providers.aicodeswitch]
-name = "aicodeswitch"
-base_url = "http://${host}:${port}/codex"
-wire_api = "responses"
-requires_openai_auth = true
-`;
-        fs_1.default.writeFileSync(codexConfigPath, codexConfig);
+        fs_1.default.writeFileSync(codexConfigPath, buildCodexConfigToml(modelReasoningEffort));
         // Codex auth.json
         const codexAuthPath = path_1.default.join(codexDir, 'auth.json');
         // 同样处理 auth.json 的备份
@@ -308,7 +373,7 @@ requires_openai_auth = true
             configType: 'codex',
             timestamp: Date.now(),
             originalHash: originalConfigHash,
-            proxyMarker: `http://${host}:${port}/codex`,
+            proxyMarker: `http://${host}:${process.env.PORT ? parseInt(process.env.PORT, 10) : 4567}/codex`,
             files: [
                 {
                     originalPath: codexConfigPath,
@@ -329,6 +394,35 @@ requires_openai_auth = true
         return false;
     }
 });
+const updateCodexReasoningEffortConfig = (modelReasoningEffort) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        const codexConfigPath = path_1.default.join(homeDir, '.codex/config.toml');
+        if (!fs_1.default.existsSync(codexConfigPath)) {
+            console.error('Codex config.toml does not exist');
+            return false;
+        }
+        const configStatus = (0, config_metadata_1.checkCodexConfigStatus)();
+        if (!configStatus.isOverwritten) {
+            console.error('Codex config is not overwritten by proxy. Please activate a route first.');
+            return false;
+        }
+        fs_1.default.writeFileSync(codexConfigPath, buildCodexConfigToml(modelReasoningEffort));
+        const metadata = (0, config_metadata_1.loadMetadata)('codex');
+        if (metadata && metadata.files[0]) {
+            metadata.files[0].currentHash = (0, crypto_1.createHash)('sha256')
+                .update(fs_1.default.readFileSync(codexConfigPath, 'utf-8'))
+                .digest('hex');
+            metadata.timestamp = Date.now();
+            (0, config_metadata_1.saveMetadata)(metadata);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to update Codex reasoning effort config:', error);
+        return false;
+    }
+});
 const restoreClaudeConfig = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const homeDir = os_1.default.homedir();
@@ -1381,11 +1475,16 @@ ${instruction}
     })));
     app.post('/api/write-config/claude', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const enableAgentTeams = req.body.enableAgentTeams;
-        const result = yield writeClaudeConfig(dbManager, enableAgentTeams);
+        const enableBypassPermissionsSupport = req.body.enableBypassPermissionsSupport;
+        const result = yield writeClaudeConfig(dbManager, enableAgentTeams, enableBypassPermissionsSupport);
         res.json(result);
     })));
-    app.post('/api/write-config/codex', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield writeCodexConfig(dbManager);
+    app.post('/api/write-config/codex', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const requestedEffort = req.body.modelReasoningEffort;
+        const modelReasoningEffort = isCodexReasoningEffort(requestedEffort)
+            ? requestedEffort
+            : DEFAULT_CODEX_REASONING_EFFORT;
+        const result = yield writeCodexConfig(dbManager, modelReasoningEffort);
         res.json(result);
     })));
     // 更新Claude Code配置中的Agent Teams设置（当路由已激活时）
@@ -1394,6 +1493,21 @@ ${instruction}
         const result = yield updateClaudeAgentTeamsConfig(enableAgentTeams);
         res.json(result);
     })));
+    // 更新Claude Code配置中的bypassPermissions支持设置（当路由已激活时）
+    app.post('/api/update-claude-bypass-permissions-support', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const { enableBypassPermissionsSupport } = req.body;
+        const result = yield updateClaudeBypassPermissionsSupportConfig(enableBypassPermissionsSupport);
+        res.json(result);
+    })));
+    app.post('/api/update-codex-reasoning-effort', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const requestedEffort = req.body.modelReasoningEffort;
+        if (!isCodexReasoningEffort(requestedEffort)) {
+            res.status(400).json({ error: 'Invalid modelReasoningEffort' });
+            return;
+        }
+        const result = yield updateCodexReasoningEffortConfig(requestedEffort);
+        res.json(result);
+    })));
     app.post('/api/restore-config/claude', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const result = yield restoreClaudeConfig();
         res.json(result);

package/dist/server/original-config-reader.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOriginalConfig = exports.readCodexOriginalConfig = exports.readClaudeOriginalConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const types_1 = require("../types");
+/**
+ * TOML 解析器（简单实现，仅用于解析 Codex config.toml）
+ */
+const parseToml = (content) => {
+    const result = {};
+    let currentSection = result;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // 跳过空行和注释
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // 检查是否是 section
+        const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            const sectionPath = sectionMatch[1].split('.');
+            currentSection = result;
+            for (const key of sectionPath) {
+                if (!currentSection[key]) {
+                    currentSection[key] = {};
+                }
+                currentSection = currentSection[key];
+            }
+            continue;
+        }
+        // 解析键值对
+        const kvMatch = trimmed.match(/^([^=]+)=(.*)$/);
+        if (kvMatch) {
+            const key = kvMatch[1].trim();
+            let value = kvMatch[2].trim();
+            // 移除引号
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            // 尝试转换为布尔值
+            if (value === 'true') {
+                value = true;
+            }
+            else if (value === 'false') {
+                value = false;
+            }
+            currentSection[key] = value;
+        }
+    }
+    return result;
+};
+/**
+ * 读取 Claude Code 原始配置
+ * 从备份文件或当前配置文件中读取（如果未激活路由）
+ */
+const readClaudeOriginalConfig = () => {
+    var _a, _b, _c;
+    try {
+        const homeDir = os_1.default.homedir();
+        const settingsPath = path_1.default.join(homeDir, '.claude/settings.json');
+        const settingsBakPath = path_1.default.join(homeDir, '.claude/settings.json.aicodeswitch_backup');
+        // 优先读取备份文件（原始配置）
+        let configPath = settingsBakPath;
+        if (!fs_1.default.existsSync(configPath)) {
+            // 如果没有备份，尝试读取当前配置
+            configPath = settingsPath;
+            if (!fs_1.default.existsSync(configPath)) {
+                console.log('No Claude config file found');
+                return null;
+            }
+        }
+        const content = fs_1.default.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        // 提取配置信息
+        const baseUrl = ((_a = config.env) === null || _a === void 0 ? void 0 : _a.ANTHROPIC_BASE_URL) || 'https://api.anthropic.com';
+        const apiKey = ((_b = config.env) === null || _b === void 0 ? void 0 : _b.ANTHROPIC_AUTH_TOKEN) || ((_c = config.env) === null || _c === void 0 ? void 0 : _c.ANTHROPIC_API_KEY) || '';
+        if (!apiKey) {
+            console.log('No API key found in Claude config');
+            return null;
+        }
+        return {
+            apiUrl: baseUrl,
+            apiKey: apiKey,
+            authType: types_1.AuthType.AUTH_TOKEN,
+            sourceType: 'claude',
+        };
+    }
+    catch (error) {
+        console.error('Failed to read Claude original config:', error);
+        return null;
+    }
+};
+exports.readClaudeOriginalConfig = readClaudeOriginalConfig;
+/**
+ * 读取 Codex 原始配置
+ * 从备份文件或当前配置文件中读取（如果未激活路由）
+ */
+const readCodexOriginalConfig = () => {
+    try {
+        const homeDir = os_1.default.homedir();
+        const configPath = path_1.default.join(homeDir, '.codex/config.toml');
+        const configBakPath = path_1.default.join(homeDir, '.codex/config.toml.aicodeswitch_backup');
+        const authPath = path_1.default.join(homeDir, '.codex/auth.json');
+        // 优先读取备份文件（原始配置）
+        let tomlPath = configBakPath;
+        if (!fs_1.default.existsSync(tomlPath)) {
+            // 如果没有备份，尝试读取当前配置
+            tomlPath = configPath;
+            if (!fs_1.default.existsSync(tomlPath)) {
+                console.log('No Codex config file found');
+                return null;
+            }
+        }
+        const tomlContent = fs_1.default.readFileSync(tomlPath, 'utf-8');
+        const config = parseToml(tomlContent);
+        // 提取 base_url
+        let baseUrl = '';
+        let model = config.model;
+        // 从 model_providers 中查找配置
+        if (config.model_providers) {
+            const providerName = config.model_provider;
+            if (providerName && config.model_providers[providerName]) {
+                baseUrl = config.model_providers[providerName].base_url;
+            }
+        }
+        if (!baseUrl) {
+            console.log('No base_url found in Codex config');
+            return null;
+        }
+        // 读取 API key（从 auth.json）
+        let apiKey = '';
+        if (fs_1.default.existsSync(authPath)) {
+            try {
+                const authContent = fs_1.default.readFileSync(authPath, 'utf-8');
+                const authConfig = JSON.parse(authContent);
+                // Codex 的 auth.json 可能包含多个 provider 的 key
+                // 尝试读取常见的字段
+                apiKey = authConfig.api_key || authConfig.openai_api_key || authConfig.key || '';
+            }
+            catch (error) {
+                console.error('Failed to read Codex auth.json:', error);
+            }
+        }
+        if (!apiKey) {
+            console.log('No API key found in Codex auth.json');
+            return null;
+        }
+        return {
+            apiUrl: baseUrl,
+            apiKey: apiKey,
+            authType: types_1.AuthType.API_KEY,
+            sourceType: 'openai',
+            model: model,
+        };
+    }
+    catch (error) {
+        console.error('Failed to read Codex original config:', error);
+        return null;
+    }
+};
+exports.readCodexOriginalConfig = readCodexOriginalConfig;
+/**
+ * 根据目标类型读取原始配置
+ */
+const readOriginalConfig = (targetType) => {
+    if (targetType === 'claude-code') {
+        return (0, exports.readClaudeOriginalConfig)();
+    }
+    else if (targetType === 'codex') {
+        return (0, exports.readCodexOriginalConfig)();
+    }
+    return null;
+};
+exports.readOriginalConfig = readOriginalConfig;

package/dist/server/proxy-server.js

@@ -57,6 +57,7 @@ const gemini_1 = require("./transformers/gemini");
 const types_1 = require("../types");
 const mcp_image_handler_1 = require("./mcp-image-handler");
 const type_migration_1 = require("./type-migration");
+const original_config_reader_1 = require("./original-config-reader");
 const SUPPORTED_TARGETS = ['claude-code', 'codex'];
 class ProxyServer {
     constructor(dbManager, app) {
@@ -135,7 +136,13 @@ class ProxyServer {
             try {
                 const route = this.findMatchingRoute(req);
                 if (!route) {
-                    return res.status(404).json({ error: 'No matching route found' });
+                    // 没有找到激活的路由，尝试使用原始配置
+                    const fallbackResult = yield this.handleFallbackToOriginalConfig(req, res);
+                    if (fallbackResult) {
+                        return; // 成功使用原始配置处理请求
+                    }
+                    // 如果原始配置也不可用，返回错误
+                    return res.status(404).json({ error: 'No matching route found and no original config available' });
                 }
                 // 高智商命令检测和会话状态管理
                 const highIqCommand = this.detectHighIqCommand(req.body);
@@ -646,6 +653,110 @@ class ProxyServer {
         const activeRoutes = this.getActiveRoutes();
         return activeRoutes.find(route => route.targetType === targetType && route.isActive);
     }
+    /**
+     * 当没有激活的路由时，fallback 到原始配置
+     * @returns true 表示成功处理，false 表示无法处理
+     */
+    handleFallbackToOriginalConfig(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 确定目标类型
+            let targetType;
+            if (req.path.startsWith('/claude-code/')) {
+                targetType = 'claude-code';
+            }
+            else if (req.path.startsWith('/codex/')) {
+                targetType = 'codex';
+            }
+            if (!targetType) {
+                return false;
+            }
+            // 读取原始配置
+            const originalConfig = (0, original_config_reader_1.readOriginalConfig)(targetType);
+            if (!originalConfig) {
+                console.log(`[FALLBACK] No original config available for ${targetType}`);
+                return false;
+            }
+            // 检查原始配置的 API URL 是否指向本系统（避免死循环）
+            if (this.isLocalProxyUrl(originalConfig.apiUrl, targetType)) {
+                console.error(`[FALLBACK] Original config points to local proxy, rejecting to avoid loop: ${originalConfig.apiUrl}`);
+                return false;
+            }
+            console.log(`[FALLBACK] Using original config for ${targetType}: ${originalConfig.apiUrl}`);
+            try {
+                // 创建临时的路由对象（用于传递给 proxyRequest）
+                const tempRoute = {
+                    id: 'fallback-route',
+                    name: 'Fallback to Original Config',
+                    targetType: targetType,
+                    isActive: true,
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                };
+                // 创建临时的规则对象
+                const tempRule = {
+                    id: 'fallback-rule',
+                    routeId: 'fallback-route',
+                    contentType: 'default',
+                    targetServiceId: 'fallback-service',
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                };
+                // 创建临时的服务对象
+                const tempService = {
+                    id: 'fallback-service',
+                    name: 'Original Config',
+                    apiUrl: originalConfig.apiUrl,
+                    apiKey: originalConfig.apiKey,
+                    authType: originalConfig.authType,
+                    sourceType: originalConfig.sourceType || (targetType === 'claude-code' ? 'claude' : 'openai'),
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                };
+                // 调用 proxyRequest 处理请求，并标记使用原始配置
+                yield this.proxyRequest(req, res, tempRoute, tempRule, tempService, {
+                    useOriginalConfig: true,
+                });
+                return true;
+            }
+            catch (error) {
+                console.error('[FALLBACK] Failed to use original config:', error);
+                return false;
+            }
+        });
+    }
+    /**
+     * 检查 API URL 是否指向本系统的代理服务
+     * 用于避免 fallback 时的死循环
+     */
+    isLocalProxyUrl(apiUrl, targetType) {
+        try {
+            const url = new URL(apiUrl);
+            // 检查是否是 localhost 或 127.0.0.1
+            const isLocalhost = url.hostname === 'localhost' ||
+                url.hostname === '127.0.0.1' ||
+                url.hostname === '::1' ||
+                url.hostname === '0.0.0.0';
+            if (!isLocalhost) {
+                return false;
+            }
+            // 检查端口是否是本系统的端口（默认 4567）
+            const serverPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+            const urlPort = url.port ? parseInt(url.port, 10) : (url.protocol === 'https:' ? 443 : 80);
+            const isSamePort = urlPort === serverPort;
+            if (!isSamePort) {
+                return false;
+            }
+            // 检查路径是否包含本系统的代理路径
+            const proxyPath = `/${targetType}`;
+            const hasProxyPath = url.pathname.startsWith(proxyPath) ||
+                url.pathname === proxyPath;
+            return hasProxyPath;
+        }
+        catch (error) {
+            // URL 解析失败，认为不是本地代理 URL
+            return false;
+        }
+    }
     findRouteByTargetType(targetType) {
         const activeRoutes = this.getActiveRoutes();
         return activeRoutes.find(route => route.targetType === targetType && route.isActive);
@@ -1551,6 +1662,22 @@ class ProxyServer {
     isChatType(sourceType) {
         return sourceType.endsWith('-chat') || sourceType === 'gemini';
     }
+    /**
+     * 构建 OpenAI Responses 类型的完整 URL
+     * - baseUrl 以 /v{number} 结尾时，直接拼接请求路径
+     * - baseUrl 不带版本时，自动补 /v1 再拼接请求路径
+     * - 兼容请求路径本身已携带版本前缀（如 /v1/responses）场景
+     */
+    buildOpenAIResponsesUrl(baseUrl, mappedPath) {
+        const trimmedBase = baseUrl.trim().replace(/\/+$/, '');
+        const normalizedPath = mappedPath.startsWith('/') || mappedPath === '' ? mappedPath : `/${mappedPath}`;
+        const baseHasVersionSuffix = /\/v\d+$/i.test(trimmedBase);
+        const pathHasVersionPrefix = /^\/v\d+(?:\/|$)/i.test(normalizedPath);
+        if (baseHasVersionSuffix || pathHasVersionPrefix) {
+            return `${trimmedBase}${normalizedPath}`;
+        }
+        return `${trimmedBase}/v1${normalizedPath}`;
+    }
     /**
      * 构建 Gemini API 的完整 URL
      * 用户只填写 base 地址（如 https://generativelanguage.googleapis.com）
@@ -1938,6 +2065,7 @@ class ProxyServer {
             const targetType = route.targetType;
             const failoverEnabled = (options === null || options === void 0 ? void 0 : options.failoverEnabled) === true;
             const forwardedToServiceName = options === null || options === void 0 ? void 0 : options.forwardedToServiceName;
+            const useOriginalConfig = (options === null || options === void 0 ? void 0 : options.useOriginalConfig) === true;
             let requestBody = req.body || {};
             let usageForLog;
             let logged = false;
@@ -2106,6 +2234,7 @@ class ProxyServer {
                     vendorId: service.vendorId,
                     vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
                     requestModel,
+                    tags: useOriginalConfig ? ['使用原始配置'] : undefined,
                     responseHeaders: responseHeadersForLog,
                     responseBody: responseBodyForLog,
                     streamChunks: streamChunksForLog,
@@ -2282,6 +2411,10 @@ class ProxyServer {
                     const model = requestBody.model || rule.targetModel || 'gemini-pro';
                     upstreamUrl = this.buildGeminiUrl(service.apiUrl, model, streamRequested);
                 }
+                else if (sourceType === 'openai') {
+                    // OpenAI Responses 兼容模式：自动处理 baseUrl 是否包含 /v{number}
+                    upstreamUrl = this.buildOpenAIResponsesUrl(service.apiUrl, mappedPath);
+                }
                 else if (this.isChatType(sourceType) || this.isGeminiChatSource(sourceType)) {
                     // Chat 类型（包括 gemini-chat）直接使用用户配置的完整 URL
                     upstreamUrl = service.apiUrl;

package/dist/server/transformers/claude-openai.js

@@ -446,11 +446,11 @@ const transformClaudeRequestToOpenAIChat = (body, targetModel) => {
             openaiBody.thinking = { type: claudeThinking.type };
         }
         // 为 OpenAI Responses API 添加 reasoning 配置
-        // 映射关系：enabled->medium, disabled->minimal, auto->low
+        // 映射关系：enabled->medium, disabled->low, auto->low
         if (claudeThinking.type) {
             const effortMap = {
                 'enabled': 'medium',
-                'disabled': 'minimal',
+                'disabled': 'low',
                 'auto': 'low'
             };
             openaiBody.reasoning = {