Delete routes.js

routes.js

@@ -1,608 +0,0 @@
-import express from 'express'
-import fetch from 'node-fetch'
-import { getConfig, getModelById, getEndpointByType, getSystemPrompt, getModelReasoning } from './config.js'
-import { logError, logRequest, logResponse } from './logger.js'
-import { transformToAnthropic, getAnthropicHeaders } from './transformers/request-anthropic.js'
-import { transformToOpenAI, getOpenAIHeaders } from './transformers/request-openai.js'
-import { transformToCommon, getCommonHeaders } from './transformers/request-common.js'
-import { AnthropicResponseTransformer } from './transformers/response-anthropic.js'
-import { OpenAIResponseTransformer } from './transformers/response-openai.js'
-import { getNextProxyAgent } from './proxy-manager.js'
-
-/**
- * 从请求头获取认证信息
- */
-function getAuthHeader(req) {
-  return req.headers.authorization || req.headers.Authorization || req.headers['x-api-key']
-}
-
-const router = express.Router();
-
-/**
- * 将 /v1/responses API 结果转换为 /v1/chat/completions 兼容格式
- * 适用于非流式响应
- */
-function convertResponseToChatCompletion(resp) {
-    if (!resp || typeof resp !== 'object') {
-        throw new Error('Invalid response object');
-    }
-
-    const outputMsg = (resp.output || []).find(o => o.type === 'message');
-    const textBlocks = outputMsg?.content?.filter(c => c.type === 'output_text') || [];
-    const content = textBlocks.map(c => c.text).join('');
-
-    const chatCompletion = {
-        id: resp.id ? resp.id.replace(/^resp_/, 'chatcmpl-') : `chatcmpl-${Date.now()}`,
-        object: 'chat.completion',
-        created: resp.created_at || Math.floor(Date.now() / 1000),
-        model: resp.model || 'unknown-model',
-        choices: [
-            {
-                index: 0,
-                message: {
-                    role: outputMsg?.role || 'assistant',
-                    content: content || ''
-                },
-                finish_reason: resp.status === 'completed' ? 'stop' : 'unknown'
-            }
-        ],
-        usage: {
-            prompt_tokens: resp.usage?.input_tokens ?? 0,
-            completion_tokens: resp.usage?.output_tokens ?? 0,
-            total_tokens: resp.usage?.total_tokens ?? 0
-        }
-    };
-
-    return chatCompletion;
-}
-
-router.get('/v1/models', (req, res) => {
-    try {
-        const config = getConfig()
-        const models = config.models.map(model => ({
-            id: model.id,
-            object: 'model',
-            created: Date.now(),
-            owned_by: model.type,
-            permission: [],
-            root: model.id,
-            parent: null
-        }))
-
-        res.json({
-            object: 'list',
-            data: models
-        })
-    } catch (error) {
-        logError('GET /v1/models', error)
-        res.status(500).json({ error: 'Internal server error' })
-    }
-})
-
-// 标准 OpenAI 聊天补全处理函数（带格式转换）
-async function handleChatCompletions(req, res) {
-    try {
-        const openaiRequest = req.body
-        const modelId = openaiRequest.model
-
-        if (!modelId) {
-            return res.status(400).json({ error: '需要提供 model 参数' })
-        }
-
-        const model = getModelById(modelId)
-        if (!model) {
-            return res.status(404).json({ error: `未找到模型 ${modelId}` })
-        }
-
-        const endpoint = getEndpointByType(model.type)
-        if (!endpoint) {
-            return res.status(500).json({ error: `未找到端点类型 ${model.type}` })
-        }
-
-        // 获取认证信息
-        const authHeader = getAuthHeader(req)
-        if (!authHeader) {
-            return res.status(401).json({
-                error: '未提供认证信息',
-                message: '请在请求头中提供 Authorization 或 x-api-key'
-            })
-        }
-
-        let transformedRequest
-        let headers
-        const clientHeaders = req.headers
-
-        // 转换请求格式
-        if (model.type === 'anthropic') {
-            transformedRequest = transformToAnthropic(openaiRequest)
-            const isStreaming = openaiRequest.stream === true
-            headers = getAnthropicHeaders(authHeader, clientHeaders, isStreaming, modelId)
-        } else if (model.type === 'openai') {
-            transformedRequest = transformToOpenAI(openaiRequest)
-            headers = getOpenAIHeaders(authHeader, clientHeaders)
-        } else if (model.type === 'common') {
-            transformedRequest = transformToCommon(openaiRequest)
-            headers = getCommonHeaders(authHeader, clientHeaders)
-        } else {
-            return res.status(500).json({ error: `未知的端点类型: ${model.type}` })
-        }
-
-        logRequest('POST', endpoint.base_url, headers, transformedRequest)
-
-        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url)
-        const fetchOptions = {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(transformedRequest)
-        }
-
-        if (proxyAgentInfo?.agent) {
-            fetchOptions.agent = proxyAgentInfo.agent
-        }
-
-        const response = await fetch(endpoint.base_url, fetchOptions)
-
-        if (!response.ok) {
-            const errorText = await response.text()
-            logError(`端点错误: ${response.status}`, new Error(errorText))
-            return res.status(response.status).json({
-                error: `端点返回 ${response.status}`,
-                details: errorText
-            })
-        }
-
-        const isStreaming = transformedRequest.stream === true
-
-        if (isStreaming) {
-            res.setHeader('Content-Type', 'text/event-stream')
-            res.setHeader('Cache-Control', 'no-cache')
-            res.setHeader('Connection', 'keep-alive')
-
-            // common 类型直接转发，不使用 transformer
-            if (model.type === 'common') {
-                try {
-                    for await (const chunk of response.body) {
-                        res.write(chunk)
-                    }
-                    res.end()
-                } catch (streamError) {
-                    logError('流错误', streamError)
-                    res.end()
-                }
-            } else {
-                // anthropic 和 openai 类型使用 transformer
-                let transformer
-                if (model.type === 'anthropic') {
-                    transformer = new AnthropicResponseTransformer(modelId, `chatcmpl-${Date.now()}`)
-                } else if (model.type === 'openai') {
-                    transformer = new OpenAIResponseTransformer(modelId, `chatcmpl-${Date.now()}`)
-                }
-
-                try {
-                    for await (const chunk of transformer.transformStream(response.body)) {
-                        res.write(chunk)
-                    }
-                    res.end()
-                } catch (streamError) {
-                    logError('流错误', streamError)
-                    res.end()
-                }
-            }
-        } else {
-            const data = await response.json()
-            if (model.type === 'openai') {
-                try {
-                    const converted = convertResponseToChatCompletion(data)
-                    logResponse(200, null, converted)
-                    res.json(converted)
-                } catch (e) {
-                    logResponse(200, null, data)
-                    res.json(data)
-                }
-            } else {
-                logResponse(200, null, data)
-                res.json(data)
-            }
-        }
-
-    } catch (error) {
-        logError('/v1/chat/completions', error)
-        res.status(500).json({
-            error: '内部服务器错误',
-            message: error.message
-        })
-    }
-}
-
-// 直接转发 OpenAI 请求（不做格式转换）
-async function handleDirectResponses(req, res) {
-    try {
-        const openaiRequest = req.body
-        const modelId = openaiRequest.model
-
-        if (!modelId) {
-            return res.status(400).json({ error: '需要提供 model 参数' })
-        }
-
-        const model = getModelById(modelId)
-        if (!model) {
-            return res.status(404).json({ error: `未找到模型 ${modelId}` })
-        }
-
-        // 只允许 openai 类型端点
-        if (model.type !== 'openai') {
-            return res.status(400).json({
-                error: '无效的端点类型',
-                message: `/v1/responses 接口只支持 openai 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
-            })
-        }
-
-        const endpoint = getEndpointByType(model.type)
-        if (!endpoint) {
-            return res.status(500).json({ error: `未找到端点类型 ${model.type}` })
-        }
-
-        // 获取认证信息
-        const authHeader = getAuthHeader(req);
-        if (!authHeader) {
-            return res.status(401).json({
-                error: '未提供认证信息',
-                message: '请在请求头中提供 Authorization 或 x-api-key'
-            });
-        }
-
-        // 如果是 x-api-key，转换为 Bearer 格式
-        const finalAuthHeader = authHeader.startsWith('Bearer ')
-            ? authHeader
-            : `Bearer ${authHeader}`;
-
-        const clientHeaders = req.headers;
-
-        // 获取 headers
-        const headers = getOpenAIHeaders(finalAuthHeader, clientHeaders);
-
-        // 注入系统提示到 instructions 字段
-        const systemPrompt = getSystemPrompt();
-        const modifiedRequest = { ...openaiRequest };
-        if (systemPrompt) {
-            // 如果已有 instructions，则在前面添加系统提示
-            if (modifiedRequest.instructions) {
-                modifiedRequest.instructions = systemPrompt + modifiedRequest.instructions;
-            } else {
-                // 否则直接设置系统提示
-                modifiedRequest.instructions = systemPrompt;
-            }
-        }
-
-        // 处理reasoning字段
-        const reasoningLevel = getModelReasoning(modelId);
-        if (reasoningLevel === 'auto') {
-            // Auto模式：保持原始请求的reasoning字段不变
-            // 如果原始请求有reasoning字段就保留，没有就不添加
-        } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
-            modifiedRequest.reasoning = {
-                effort: reasoningLevel,
-                summary: 'auto'
-            };
-        } else {
-            // 如果配置是off或无效，移除reasoning字段
-            delete modifiedRequest.reasoning;
-        }
-
-        logRequest('POST', endpoint.base_url, headers, modifiedRequest)
-
-        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url)
-        const fetchOptions = {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(modifiedRequest)
-        }
-
-        if (proxyAgentInfo?.agent) {
-            fetchOptions.agent = proxyAgentInfo.agent
-        }
-
-        const response = await fetch(endpoint.base_url, fetchOptions)
-
-        if (!response.ok) {
-            const errorText = await response.text()
-            logError(`端点错误: ${response.status}`, new Error(errorText))
-            return res.status(response.status).json({
-                error: `端点返回 ${response.status}`,
-                details: errorText
-            })
-        }
-
-        const isStreaming = openaiRequest.stream === true
-
-        if (isStreaming) {
-            res.setHeader('Content-Type', 'text/event-stream')
-            res.setHeader('Cache-Control', 'no-cache')
-            res.setHeader('Connection', 'keep-alive')
-
-            try {
-                for await (const chunk of response.body) {
-                    res.write(chunk)
-                }
-                res.end()
-            } catch (streamError) {
-                logError('流错误', streamError)
-                res.end()
-            }
-        } else {
-            const data = await response.json()
-            logResponse(200, null, data)
-            res.json(data)
-        }
-
-    } catch (error) {
-        logError('/v1/responses', error)
-        res.status(500).json({
-            error: '内部服务器错误',
-            message: error.message
-        })
-    }
-}
-
-// 直接转发 Anthropic 请求（不做格式转换）
-async function handleDirectMessages(req, res) {
-    logInfo('POST /v1/messages');
-
-    try {
-        const anthropicRequest = req.body;
-        const modelId = anthropicRequest.model;
-
-        if (!modelId) {
-            return res.status(400).json({ error: '需要提供 model 参数' });
-        }
-
-        const model = getModelById(modelId);
-        if (!model) {
-            return res.status(404).json({ error: `未找到模型 ${modelId}` });
-        }
-
-        // 只允许 anthropic 类型端点
-        if (model.type !== 'anthropic') {
-            return res.status(400).json({
-                error: '无效的端点类型',
-                message: `/v1/messages 接口只支持 anthropic 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
-            });
-        }
-
-        const endpoint = getEndpointByType(model.type);
-        if (!endpoint) {
-            return res.status(500).json({ error: `未找到端点类型 ${model.type}` });
-        }
-
-        logInfo(`直接转发到 ${model.type} 端点: ${endpoint.base_url}`);
-
-        // 获取认证信息
-        const authHeader = getAuthHeader(req);
-        if (!authHeader) {
-            return res.status(401).json({
-                error: '未提供认证信息',
-                message: '请在请求头中提供 Authorization 或 x-api-key'
-            });
-        }
-
-        // 如果是 x-api-key，转换为 Bearer 格式
-        const finalAuthHeader = authHeader.startsWith('Bearer ')
-            ? authHeader
-            : `Bearer ${authHeader}`;
-
-        const clientHeaders = req.headers;
-
-        // 获取 headers
-        const isStreaming = anthropicRequest.stream === true;
-        const headers = getAnthropicHeaders(finalAuthHeader, clientHeaders, isStreaming, modelId);
-
-        // 注入系统提示到 system 字段
-        const systemPrompt = getSystemPrompt();
-        const modifiedRequest = { ...anthropicRequest };
-
-        // 清理cc中的 "You are Claude Code, Anthropic's official CLI for Claude."
-        if (modifiedRequest.system && Array.isArray(modifiedRequest.system)) {
-            for (const msg of modifiedRequest.system) {
-                if (msg.type === 'text') {
-                    msg.text = msg.text.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.');
-                }
-            }
-        }
-
-        if (systemPrompt) {
-            if (modifiedRequest.system && Array.isArray(modifiedRequest.system)) {
-                // 如果已有 system 数组，则在最前面插入系统提示
-                modifiedRequest.system = [
-                    { type: 'text', text: systemPrompt },
-                    ...modifiedRequest.system
-                ];
-            } else {
-                // 否则创建新的 system 数组
-                modifiedRequest.system = [
-                    { type: 'text', text: systemPrompt }
-                ];
-            }
-        }
-
-        // 处理thinking字段
-        const reasoningLevel = getModelReasoning(modelId);
-        if (reasoningLevel === 'auto') {
-            // Auto模式：保持原始请求的thinking字段不变
-            // 如果原始请求有thinking字段就保留，没有就不添加
-        } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
-            const budgetTokens = {
-                'low': 4096,
-                'medium': 12288,
-                'high': 24576
-            };
-
-            modifiedRequest.thinking = {
-                type: 'enabled',
-                budget_tokens: budgetTokens[reasoningLevel]
-            };
-        } else {
-            // 如果配置是off或无效，移除thinking字段
-            delete modifiedRequest.thinking;
-        }
-
-        logRequest('POST', endpoint.base_url, headers, modifiedRequest);
-        // console.log(modifiedRequest);
-
-        // 转发修改后的请求
-        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url);
-        const fetchOptions = {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(modifiedRequest)
-        };
-
-        if (proxyAgentInfo?.agent) {
-            fetchOptions.agent = proxyAgentInfo.agent;
-        }
-
-        const response = await fetch(endpoint.base_url, fetchOptions);
-
-        logInfo(`响应状态: ${response.status}`);
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            logError(`端点错误: ${response.status}`, new Error(errorText));
-            return res.status(response.status).json({
-                error: `端点返回 ${response.status}`,
-                details: errorText
-            });
-        }
-
-        if (isStreaming) {
-            // 直接转发流式响应，不做任何转换
-            res.setHeader('Content-Type', 'text/event-stream');
-            res.setHeader('Cache-Control', 'no-cache');
-            res.setHeader('Connection', 'keep-alive');
-
-            try {
-                // 直接将原始响应流转发给客户端
-                for await (const chunk of response.body) {
-                    res.write(chunk);
-                }
-                res.end();
-                logInfo('流转发成功');
-            } catch (streamError) {
-                logError('流错误', streamError);
-                res.end();
-            }
-        } else {
-            // 直接转发非流式响应，不做任何转换
-            const data = await response.json();
-            logResponse(200, null, data);
-            res.json(data);
-        }
-
-    } catch (error) {
-        logError('/v1/messages 错误', error);
-        res.status(500).json({
-            error: '内部服务器错误',
-            message: error.message
-        });
-    }
-}
-
-// 处理 Anthropic count_tokens 请求
-async function handleCountTokens(req, res) {
-    logInfo('POST /v1/messages/count_tokens');
-
-    try {
-        const anthropicRequest = req.body;
-        const modelId = anthropicRequest.model;
-
-        if (!modelId) {
-            return res.status(400).json({ error: '需要提供 model 参数' });
-        }
-
-        const model = getModelById(modelId);
-        if (!model) {
-            return res.status(404).json({ error: `未找到模型 ${modelId}` });
-        }
-
-        // 只允许 anthropic 类型端点
-        if (model.type !== 'anthropic') {
-            return res.status(400).json({
-                error: '无效的端点类型',
-                message: `/v1/messages/count_tokens 接口只支持 anthropic 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
-            });
-        }
-
-        const endpoint = getEndpointByType('anthropic');
-        if (!endpoint) {
-            return res.status(500).json({ error: '未找到端点类型 anthropic' });
-        }
-
-        // 获取认证信息
-        const authHeader = getAuthHeader(req);
-        if (!authHeader) {
-            return res.status(401).json({
-                error: '未提供认证信息',
-                message: '请在请求头中提供 Authorization 或 x-api-key'
-            });
-        }
-
-        // 如果是 x-api-key，转换为 Bearer 格式
-        const finalAuthHeader = authHeader.startsWith('Bearer ')
-            ? authHeader
-            : `Bearer ${authHeader}`;
-
-        const clientHeaders = req.headers;
-        const headers = getAnthropicHeaders(finalAuthHeader, clientHeaders, false, modelId);
-
-        // 构建 count_tokens 端点 URL
-        const countTokensUrl = endpoint.base_url.replace('/v1/messages', '/v1/messages/count_tokens');
-
-        // 使用原始请求体
-        const modifiedRequest = { ...anthropicRequest };
-
-        logInfo(`转发到 count_tokens 端点: ${countTokensUrl}`);
-        logRequest('POST', countTokensUrl, headers, modifiedRequest);
-
-        const proxyAgentInfo = getNextProxyAgent(countTokensUrl);
-        const fetchOptions = {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(modifiedRequest)
-        };
-
-        if (proxyAgentInfo?.agent) {
-            fetchOptions.agent = proxyAgentInfo.agent;
-        }
-
-        const response = await fetch(countTokensUrl, fetchOptions);
-
-        logInfo(`响应状态: ${response.status}`);
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            logError(`计数令牌错误: ${response.status}`, new Error(errorText));
-            return res.status(response.status).json({
-                error: `端点返回 ${response.status}`,
-                details: errorText
-            });
-        }
-
-        const data = await response.json();
-        logResponse(200, null, data);
-        res.json(data);
-
-    } catch (error) {
-        logError('/v1/messages/count_tokens 错误', error);
-        res.status(500).json({
-            error: '内部服务器错误',
-            message: error.message
-        });
-    }
-}
-
-// 注册路由
-router.post('/v1/chat/completions', handleChatCompletions);
-router.post('/v1/responses', handleDirectResponses);
-router.post('/v1/messages', handleDirectMessages);
-router.post('/v1/messages/count_tokens', handleCountTokens);
-
-export default router;