aicodeswitch 3.0.3 → 3.0.4

package/dist/server/proxy-server.js

@@ -53,6 +53,7 @@ const streaming_1 = require("./transformers/streaming");
 const chunk_collector_1 = require("./transformers/chunk-collector");
 const rules_status_service_1 = require("./rules-status-service");
 const claude_openai_1 = require("./transformers/claude-openai");
+const gemini_1 = require("./transformers/gemini");
 const types_1 = require("../types");
 const SUPPORTED_TARGETS = ['claude-code', 'codex'];
 class ProxyServer {
@@ -1039,8 +1040,26 @@ class ProxyServer {
     isOpenAIChatSource(sourceType) {
         return sourceType === 'openai-chat' || sourceType === 'openai-responses' || sourceType === 'deepseek-reasoning-chat';
     }
+    /** 判断是否为 Gemini 类型 */
+    isGeminiSource(sourceType) {
+        return sourceType === 'gemini';
+    }
     isChatType(sourceType) {
-        return sourceType.endsWith('-chat');
+        return sourceType.endsWith('-chat') || sourceType === 'gemini';
+    }
+    /**
+     * 构建 Gemini API 的完整 URL
+     * 用户只填写 base 地址（如 https://generativelanguage.googleapis.com）
+     * 需要根据模型名称拼接成完整的 URL
+     */
+    buildGeminiUrl(baseUrl, model, streamRequested) {
+        // 移除末尾的斜杠
+        const base = baseUrl.replace(/\/$/, '');
+        // 移除模型名称中可能包含的 models/ 前缀
+        const modelName = model.replace(/^models\//, '');
+        // 根据是否流式选择 endpoint
+        const endpoint = streamRequested ? 'streamGenerateContent' : 'generateContent';
+        return `${base}/v1beta/models/${modelName}:${endpoint}`;
     }
     /**
      * 判断模型是否应该使用 max_completion_tokens 字段
@@ -1130,7 +1149,7 @@ class ProxyServer {
         const headers = {};
         for (const [key, value] of Object.entries(req.headers)) {
             // 排除原始认证头，防止与代理设置的认证头冲突
-            if (['host', 'connection', 'content-length', 'authorization', 'x-api-key', 'x-anthropic-api-key', 'anthropic-api-key'].includes(key.toLowerCase())) {
+            if (['host', 'connection', 'content-length', 'authorization', 'x-api-key', 'x-anthropic-api-key', 'anthropic-api-key', 'x-goog-api-key'].includes(key.toLowerCase())) {
                 continue;
             }
             if (typeof value === 'string') {
@@ -1145,8 +1164,11 @@ class ProxyServer {
         }
         // 确定认证方式：优先使用服务配置的 authType，否则根据 sourceType 自动判断
         const authType = service.authType || types_1.AuthType.AUTO;
-        const useXApiKey = authType === types_1.AuthType.API_KEY || (authType === types_1.AuthType.AUTO && this.isClaudeSource(sourceType));
-        if (useXApiKey) {
+        if (authType === types_1.AuthType.G_API_KEY || (authType === types_1.AuthType.AUTO && this.isGeminiSource(sourceType))) {
+            // 使用 x-goog-api-key 认证（适用于 Google Gemini API）
+            headers['x-goog-api-key'] = service.apiKey;
+        }
+        else if (authType === types_1.AuthType.API_KEY || (authType === types_1.AuthType.AUTO && this.isClaudeSource(sourceType))) {
             // 使用 x-api-key 认证（适用于 claude-chat, claude-code 及某些需要 x-api-key 的 openai-chat 兼容 API）
             headers['x-api-key'] = service.apiKey;
             if (this.isClaudeSource(sourceType) || authType === types_1.AuthType.API_KEY) {
@@ -1511,6 +1533,9 @@ class ProxyServer {
                     else if (this.isOpenAIChatSource(sourceType)) {
                         requestBody = (0, claude_openai_1.transformClaudeRequestToOpenAIChat)(requestBody, rule.targetModel);
                     }
+                    else if (this.isGeminiSource(sourceType)) {
+                        requestBody = (0, gemini_1.transformClaudeRequestToGemini)(requestBody);
+                    }
                     else {
                         res.status(400).json({ error: 'Unsupported source type for Claude Code.' });
                         yield finalizeLog(400, 'Unsupported source type for Claude Code');
@@ -1524,6 +1549,9 @@ class ProxyServer {
                     else if (this.isClaudeSource(sourceType)) {
                         requestBody = (0, claude_openai_1.transformClaudeRequestToOpenAIChat)(requestBody, rule.targetModel);
                     }
+                    else if (this.isGeminiSource(sourceType)) {
+                        requestBody = (0, gemini_1.transformOpenAIChatRequestToGemini)(requestBody);
+                    }
                     else {
                         res.status(400).json({ error: 'Unsupported source type for Codex.' });
                         yield finalizeLog(400, 'Unsupported source type for Codex');
@@ -1543,9 +1571,22 @@ class ProxyServer {
                 }
                 // 根据源工具类型和目标API类型,映射请求路径
                 const mappedPath = this.mapRequestPath(route.targetType, sourceType, pathToAppend);
+                // 构建上游 URL
+                let upstreamUrl;
+                if (this.isGeminiSource(sourceType)) {
+                    // Gemini 类型需要特殊处理：根据模型拼接完整 URL
+                    const model = requestBody.model || rule.targetModel || 'gemini-pro';
+                    upstreamUrl = this.buildGeminiUrl(service.apiUrl, model, streamRequested);
+                }
+                else if (this.isChatType(sourceType)) {
+                    upstreamUrl = service.apiUrl;
+                }
+                else {
+                    upstreamUrl = `${service.apiUrl}${mappedPath}`;
+                }
                 const config = {
                     method: req.method,
-                    url: this.isChatType(sourceType) ? service.apiUrl : `${service.apiUrl}${mappedPath}`,
+                    url: upstreamUrl,
                     headers: this.buildUpstreamHeaders(req, service, sourceType, streamRequested),
                     timeout: rule.timeout || 3000000, // 默认300秒
                     validateStatus: () => true,
@@ -1592,7 +1633,7 @@ class ProxyServer {
                 // const actualMaxTokens = requestBody?.[maxTokensFieldName] || requestBody?.max_tokens;
                 const upstreamHeaders = this.buildUpstreamHeaders(req, service, sourceType, streamRequested);
                 upstreamRequestForLog = {
-                    url: this.isChatType(sourceType) ? service.apiUrl : `${service.apiUrl}${mappedPath}`,
+                    url: upstreamUrl,
                     // model: actualModel,
                     // [maxTokensFieldName]: actualMaxTokens,
                     headers: upstreamHeaders,
@@ -1809,6 +1850,194 @@ class ProxyServer {
                         }));
                         return;
                     }
+                    // Gemini -> Claude Code 流式转换
+                    if (targetType === 'claude-code' && this.isGeminiSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
+                        const converter = new streaming_1.GeminiToClaudeEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        const finalizeChunks = () => {
+                            const usage = converter.getUsage();
+                            if (usage) {
+                                usageForLog = {
+                                    inputTokens: usage.input_tokens,
+                                    outputTokens: usage.output_tokens,
+                                    cacheReadInputTokens: usage.cache_read_input_tokens,
+                                };
+                            }
+                            else {
+                                const extractedUsage = eventCollector.extractUsage();
+                                if (extractedUsage) {
+                                    usageForLog = this.extractTokenUsage(extractedUsage);
+                                }
+                            }
+                            streamChunksForLog = eventCollector.getChunks();
+                            responseBodyForLog = streamChunksForLog.join('\n');
+                            console.log('[Proxy] Gemini stream request finished (claude-code), collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
+                            void finalizeLog(res.statusCode);
+                        };
+                        eventCollector.on('finish', () => {
+                            console.log('[Proxy] EventCollector finished (gemini->claude-code), collecting chunks...');
+                            finalizeChunks();
+                        });
+                        res.on('finish', () => {
+                            console.log('[Proxy] Response finished (gemini->claude-code)');
+                            if (!streamChunksForLog) {
+                                console.log('[Proxy] Chunks not collected yet, forcing collection...');
+                                finalizeChunks();
+                            }
+                        });
+                        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* () {
+                            var _a;
+                            if (error) {
+                                console.error('[Proxy] Pipeline error for gemini->claude-code:', error);
+                                try {
+                                    const vendors = this.dbManager.getVendors();
+                                    const vendor = vendors.find(v => v.id === service.vendorId);
+                                    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,
+                                        ruleId: rule.id,
+                                        targetType,
+                                        targetServiceId: service.id,
+                                        targetServiceName: service.name,
+                                        targetModel: rule.targetModel,
+                                        vendorId: service.vendorId,
+                                        vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+                                        requestModel: (_a = req.body) === null || _a === void 0 ? void 0 : _a.model,
+                                        responseTime: Date.now() - startTime,
+                                    });
+                                }
+                                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;
+                    }
+                    // Gemini -> Codex 流式转换
+                    if (targetType === 'codex' && this.isGeminiSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
+                        const converter = new streaming_1.GeminiToOpenAIChatEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        const finalizeChunks = () => {
+                            const usage = converter.getUsage();
+                            if (usage) {
+                                usageForLog = {
+                                    inputTokens: usage.prompt_tokens,
+                                    outputTokens: usage.completion_tokens,
+                                    totalTokens: usage.total_tokens,
+                                };
+                            }
+                            else {
+                                const extractedUsage = eventCollector.extractUsage();
+                                if (extractedUsage) {
+                                    usageForLog = this.extractTokenUsage(extractedUsage);
+                                }
+                            }
+                            streamChunksForLog = eventCollector.getChunks();
+                            responseBodyForLog = streamChunksForLog.join('\n');
+                            console.log('[Proxy] Gemini stream request finished (codex), collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
+                            void finalizeLog(res.statusCode);
+                        };
+                        eventCollector.on('finish', () => {
+                            console.log('[Proxy] EventCollector finished (gemini->codex), collecting chunks...');
+                            finalizeChunks();
+                        });
+                        res.on('finish', () => {
+                            console.log('[Proxy] Response finished (gemini->codex)');
+                            if (!streamChunksForLog) {
+                                console.log('[Proxy] Chunks not collected yet, forcing collection...');
+                                finalizeChunks();
+                            }
+                        });
+                        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* () {
+                            var _a;
+                            if (error) {
+                                console.error('[Proxy] Pipeline error for gemini->codex:', error);
+                                try {
+                                    const vendors = this.dbManager.getVendors();
+                                    const vendor = vendors.find(v => v.id === service.vendorId);
+                                    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,
+                                        ruleId: rule.id,
+                                        targetType,
+                                        targetServiceId: service.id,
+                                        targetServiceName: service.name,
+                                        targetModel: rule.targetModel,
+                                        vendorId: service.vendorId,
+                                        vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+                                        requestModel: (_a = req.body) === null || _a === void 0 ? void 0 : _a.model,
+                                        responseTime: Date.now() - startTime,
+                                    });
+                                }
+                                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 parser = new streaming_1.SSEParserTransform();
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
@@ -1940,12 +2169,24 @@ class ProxyServer {
                     responseBodyForLog = JSON.stringify(converted);
                     res.status(response.status).json(converted);
                 }
+                else if (targetType === 'claude-code' && this.isGeminiSource(sourceType)) {
+                    const converted = (0, gemini_1.transformGeminiResponseToClaude)(responseData, rule.targetModel);
+                    usageForLog = (0, gemini_1.extractTokenUsageFromGeminiUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usageMetadata);
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
                 else if (targetType === 'codex' && this.isClaudeSource(sourceType)) {
                     const converted = (0, claude_openai_1.transformClaudeResponseToOpenAIChat)(responseData);
                     usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
                     responseBodyForLog = JSON.stringify(converted);
                     res.status(response.status).json(converted);
                 }
+                else if (targetType === 'codex' && this.isGeminiSource(sourceType)) {
+                    const converted = (0, gemini_1.transformGeminiResponseToOpenAIChat)(responseData, rule.targetModel);
+                    usageForLog = (0, gemini_1.extractTokenUsageFromGeminiUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usageMetadata);
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
                 else {
                     usageForLog = this.extractTokenUsage(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
                     // 记录原始响应体