拆分index.js路由，分为claude、gemini、openai，并且支持生图

src/routes/claude.js

@@ -0,0 +1,20 @@
+/**
+ * Claude API 路由
+ * 处理 /v1/messages 端点
+ */
+
+import { Router } from 'express';
+import { handleClaudeRequest } from '../server/handlers/claude.js';
+
+const router = Router();
+
+/**
+ * POST /v1/messages
+ * 处理 Claude 消息请求
+ */
+router.post('/messages', (req, res) => {
+  const isStream = req.body.stream === true;
+  handleClaudeRequest(req, res, isStream);
+});
+
+export default router;

src/routes/gemini.js

@@ -0,0 +1,42 @@
+/**
+ * Gemini API 路由
+ * 处理 /v1beta/models/* 端点
+ */
+
+import { Router } from 'express';
+import { handleGeminiModelsList, handleGeminiModelDetail, handleGeminiRequest } from '../server/handlers/gemini.js';
+
+const router = Router();
+
+/**
+ * GET /v1beta/models
+ * 获取模型列表（Gemini格式）
+ */
+router.get('/models', handleGeminiModelsList);
+
+/**
+ * GET /v1beta/models/:model
+ * 获取单个模型详情（Gemini格式）
+ */
+router.get('/models/:model', handleGeminiModelDetail);
+
+/**
+ * POST /v1beta/models/:model:streamGenerateContent
+ * 流式生成内容
+ */
+router.post('/models/:model\\:streamGenerateContent', (req, res) => {
+  const modelName = req.params.model;
+  handleGeminiRequest(req, res, modelName, true);
+});
+
+/**
+ * POST /v1beta/models/:model:generateContent
+ * 生成内容（支持通过 alt=sse 参数启用流式）
+ */
+router.post('/models/:model\\:generateContent', (req, res) => {
+  const modelName = req.params.model;
+  const isStream = req.query.alt === 'sse';
+  handleGeminiRequest(req, res, modelName, isStream);
+});
+
+export default router;

src/routes/openai.js

@@ -0,0 +1,33 @@
+/**
+ * OpenAI API 路由
+ * 处理 /v1/chat/completions 和 /v1/models 端点
+ */
+
+import { Router } from 'express';
+import { getAvailableModels } from '../api/client.js';
+import { handleOpenAIRequest } from '../server/handlers/openai.js';
+import logger from '../utils/logger.js';
+
+const router = Router();
+
+/**
+ * GET /v1/models
+ * 获取可用模型列表
+ */
+router.get('/models', async (req, res) => {
+  try {
+    const models = await getAvailableModels();
+    res.json(models);
+  } catch (error) {
+    logger.error('获取模型列表失败:', error.message);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /v1/chat/completions
+ * 处理聊天补全请求
+ */
+router.post('/chat/completions', handleOpenAIRequest);
+
+export default router;

src/server/handlers/claude.js

@@ -0,0 +1,368 @@
+/**
+ * Claude 格式处理器
+ * 处理 /v1/messages 请求，支持流式和非流式响应
+ */
+
+import { generateAssistantResponse, generateAssistantResponseNoStream } from '../../api/client.js';
+import { generateClaudeRequestBody, prepareImageRequest } from '../../utils/utils.js';
+import { normalizeClaudeParameters } from '../../utils/parameterNormalizer.js';
+import { buildClaudeErrorPayload } from '../../utils/errors.js';
+import logger from '../../utils/logger.js';
+import config from '../../config/config.js';
+import tokenManager from '../../auth/token_manager.js';
+import {
+  setStreamHeaders,
+  createHeartbeat,
+  with429Retry
+} from '../stream.js';
+
+/**
+ * 创建 Claude 流式事件
+ * @param {string} eventType - 事件类型
+ * @param {Object} data - 事件数据
+ * @returns {string}
+ */
+export const createClaudeStreamEvent = (eventType, data) => {
+  return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+};
+
+/**
+ * 创建 Claude 非流式响应
+ * @param {string} id - 消息ID
+ * @param {string} model - 模型名称
+ * @param {string|null} content - 文本内容
+ * @param {string|null} reasoning - 思维链内容
+ * @param {string|null} reasoningSignature - 思维链签名
+ * @param {Array|null} toolCalls - 工具调用
+ * @param {string} stopReason - 停止原因
+ * @param {Object|null} usage - 使用量统计
+ * @returns {Object}
+ */
+export const createClaudeResponse = (id, model, content, reasoning, reasoningSignature, toolCalls, stopReason, usage) => {
+  const contentBlocks = [];
+  
+  // 思维链内容（如果有）- Claude 格式用 thinking 类型
+  if (reasoning) {
+    const thinkingBlock = {
+      type: "thinking",
+      thinking: reasoning
+    };
+    if (reasoningSignature && config.passSignatureToClient) {
+      thinkingBlock.signature = reasoningSignature;
+    }
+    contentBlocks.push(thinkingBlock);
+  }
+  
+  // 文本内容
+  if (content) {
+    contentBlocks.push({
+      type: "text",
+      text: content
+    });
+  }
+  
+  // 工具调用
+  if (toolCalls && toolCalls.length > 0) {
+    for (const tc of toolCalls) {
+      try {
+        const toolBlock = {
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments)
+        };
+        if (tc.thoughtSignature && config.passSignatureToClient) {
+          toolBlock.signature = tc.thoughtSignature;
+        }
+        contentBlocks.push(toolBlock);
+      } catch (e) {
+        // 解析失败时传入空对象
+        contentBlocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: {}
+        });
+      }
+    }
+  }
+
+  return {
+    id: id,
+    type: "message",
+    role: "assistant",
+    content: contentBlocks,
+    model: model,
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: usage ? {
+      input_tokens: usage.prompt_tokens || 0,
+      output_tokens: usage.completion_tokens || 0
+    } : { input_tokens: 0, output_tokens: 0 }
+  };
+};
+
+/**
+ * 处理 Claude 格式的聊天请求
+ * @param {Request} req - Express请求对象
+ * @param {Response} res - Express响应对象
+ * @param {boolean} isStream - 是否流式响应
+ */
+export const handleClaudeRequest = async (req, res, isStream) => {
+  const { messages, model, system, tools, ...rawParams } = req.body;
+  
+  try {
+    if (!messages) {
+      return res.status(400).json(buildClaudeErrorPayload({ message: 'messages is required' }, 400));
+    }
+    
+    const token = await tokenManager.getToken();
+    if (!token) {
+      throw new Error('没有可用的token，请运行 npm run login 获取token');
+    }
+    
+    // 使用统一参数规范化模块处理 Claude 格式参数
+    const parameters = normalizeClaudeParameters(rawParams);
+    
+    const isImageModel = model.includes('-image');
+    const requestBody = generateClaudeRequestBody(messages, model, parameters, tools, system, token);
+    
+    if (isImageModel) {
+      prepareImageRequest(requestBody);
+    }
+    
+    const msgId = `msg_${Date.now()}`;
+    const maxRetries = Number(config.retryTimes || 0);
+    const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
+    
+    if (isStream) {
+      setStreamHeaders(res);
+      const heartbeatTimer = createHeartbeat(res);
+      
+      try {
+        let contentIndex = 0;
+        let usageData = null;
+        let hasToolCall = false;
+        let currentBlockType = null;
+        let reasoningSent = false;
+        
+        // 发送 message_start
+        res.write(createClaudeStreamEvent('message_start', {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: model,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+          }
+        }));
+        
+        if (isImageModel) {
+          // 生���模型：使用非流式获取结果后以流式格式返回
+          const { content, usage } = await with429Retry(
+            () => generateAssistantResponseNoStream(requestBody, token),
+            safeRetries,
+            'claude.stream.image '
+          );
+          
+          // 发送文本块
+          res.write(createClaudeStreamEvent('content_block_start', {
+            type: "content_block_start",
+            index: 0,
+            content_block: { type: "text", text: "" }
+          }));
+          res.write(createClaudeStreamEvent('content_block_delta', {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: content || '' }
+          }));
+          res.write(createClaudeStreamEvent('content_block_stop', {
+            type: "content_block_stop",
+            index: 0
+          }));
+          
+          // 发送 message_delta 和 message_stop
+          res.write(createClaudeStreamEvent('message_delta', {
+            type: "message_delta",
+            delta: { stop_reason: 'end_turn', stop_sequence: null },
+            usage: usage ? { output_tokens: usage.completion_tokens || 0 } : { output_tokens: 0 }
+          }));
+          res.write(createClaudeStreamEvent('message_stop', {
+            type: "message_stop"
+          }));
+          
+          clearInterval(heartbeatTimer);
+          res.end();
+          return;
+        }
+        
+        await with429Retry(
+          () => generateAssistantResponse(requestBody, token, (data) => {
+            if (data.type === 'usage') {
+              usageData = data.usage;
+            } else if (data.type === 'reasoning') {
+              // 思维链内容 - 使用 thinking 类型
+              if (!reasoningSent) {
+                // 开始思维块
+                const contentBlock = { type: "thinking", thinking: "" };
+                if (data.thoughtSignature && config.passSignatureToClient) {
+                  contentBlock.signature = data.thoughtSignature;
+                }
+                res.write(createClaudeStreamEvent('content_block_start', {
+                  type: "content_block_start",
+                  index: contentIndex,
+                  content_block: contentBlock
+                }));
+                currentBlockType = 'thinking';
+                reasoningSent = true;
+              }
+              // 发送思维增量
+              const delta = { type: "thinking_delta", thinking: data.reasoning_content || '' };
+              if (data.thoughtSignature && config.passSignatureToClient) {
+                delta.signature = data.thoughtSignature;
+              }
+              res.write(createClaudeStreamEvent('content_block_delta', {
+                type: "content_block_delta",
+                index: contentIndex,
+                delta: delta
+              }));
+            } else if (data.type === 'tool_calls') {
+              hasToolCall = true;
+              // 结束之前的块（如果有）
+              if (currentBlockType) {
+                res.write(createClaudeStreamEvent('content_block_stop', {
+                  type: "content_block_stop",
+                  index: contentIndex
+                }));
+                contentIndex++;
+              }
+              // 工具调用
+              for (const tc of data.tool_calls) {
+                try {
+                  const inputObj = JSON.parse(tc.function.arguments);
+                  const toolContentBlock = { type: "tool_use", id: tc.id, name: tc.function.name, input: {} };
+                  if (tc.thoughtSignature && config.passSignatureToClient) {
+                    toolContentBlock.signature = tc.thoughtSignature;
+                  }
+                  res.write(createClaudeStreamEvent('content_block_start', {
+                    type: "content_block_start",
+                    index: contentIndex,
+                    content_block: toolContentBlock
+                  }));
+                  // 发送 input 增量
+                  res.write(createClaudeStreamEvent('content_block_delta', {
+                    type: "content_block_delta",
+                    index: contentIndex,
+                    delta: { type: "input_json_delta", partial_json: JSON.stringify(inputObj) }
+                  }));
+                  res.write(createClaudeStreamEvent('content_block_stop', {
+                    type: "content_block_stop",
+                    index: contentIndex
+                  }));
+                  contentIndex++;
+                } catch (e) {
+                  // 解析失败，跳过
+                }
+              }
+              currentBlockType = null;
+            } else {
+              // 普通文本内容
+              if (currentBlockType === 'thinking') {
+                // 结束思维块
+                res.write(createClaudeStreamEvent('content_block_stop', {
+                  type: "content_block_stop",
+                  index: contentIndex
+                }));
+                contentIndex++;
+                currentBlockType = null;
+              }
+              if (currentBlockType !== 'text') {
+                // 开始文本块
+                res.write(createClaudeStreamEvent('content_block_start', {
+                  type: "content_block_start",
+                  index: contentIndex,
+                  content_block: { type: "text", text: "" }
+                }));
+                currentBlockType = 'text';
+              }
+              // 发送文本增量
+              res.write(createClaudeStreamEvent('content_block_delta', {
+                type: "content_block_delta",
+                index: contentIndex,
+                delta: { type: "text_delta", text: data.content || '' }
+              }));
+            }
+          }),
+          safeRetries,
+          'claude.stream '
+        );
+        
+        // 结束最后一个内容块
+        if (currentBlockType) {
+          res.write(createClaudeStreamEvent('content_block_stop', {
+            type: "content_block_stop",
+            index: contentIndex
+          }));
+        }
+        
+        // 发送 message_delta
+        const stopReason = hasToolCall ? 'tool_use' : 'end_turn';
+        res.write(createClaudeStreamEvent('message_delta', {
+          type: "message_delta",
+          delta: { stop_reason: stopReason, stop_sequence: null },
+          usage: usageData ? { output_tokens: usageData.completion_tokens || 0 } : { output_tokens: 0 }
+        }));
+        
+        // 发送 message_stop
+        res.write(createClaudeStreamEvent('message_stop', {
+          type: "message_stop"
+        }));
+        
+        clearInterval(heartbeatTimer);
+        res.end();
+      } catch (error) {
+        clearInterval(heartbeatTimer);
+        if (!res.writableEnded) {
+          const statusCode = error.statusCode || error.status || 500;
+          res.write(createClaudeStreamEvent('error', buildClaudeErrorPayload(error, statusCode)));
+          res.end();
+        }
+        logger.error('Claude 流式请求失败:', error.message);
+        return;
+      }
+    } else {
+      // 非流式请求
+      req.setTimeout(0);
+      res.setTimeout(0);
+      
+      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
+        () => generateAssistantResponseNoStream(requestBody, token),
+        safeRetries,
+        'claude.no_stream '
+      );
+      
+      const stopReason = toolCalls.length > 0 ? 'tool_use' : 'end_turn';
+      const response = createClaudeResponse(
+        msgId,
+        model,
+        content,
+        reasoningContent,
+        reasoningSignature,
+        toolCalls,
+        stopReason,
+        usage
+      );
+      
+      res.json(response);
+    }
+  } catch (error) {
+    logger.error('Claude 请求失败:', error.message);
+    if (res.headersSent) return;
+    const statusCode = error.statusCode || error.status || 500;
+    res.status(statusCode).json(buildClaudeErrorPayload(error, statusCode));
+  }
+};

src/server/handlers/gemini.js

@@ -0,0 +1,264 @@
+/**
+ * Gemini 格式处理器
+ * 处理 /v1beta/models/* 请求，支持流式和非流式响应
+ */
+
+import { generateAssistantResponse, generateAssistantResponseNoStream, getAvailableModels } from '../../api/client.js';
+import { generateGeminiRequestBody, prepareImageRequest } from '../../utils/utils.js';
+import { buildGeminiErrorPayload } from '../../utils/errors.js';
+import logger from '../../utils/logger.js';
+import config from '../../config/config.js';
+import tokenManager from '../../auth/token_manager.js';
+import {
+  setStreamHeaders,
+  createHeartbeat,
+  writeStreamData,
+  endStream,
+  with429Retry
+} from '../stream.js';
+
+/**
+ * 创建 Gemini 格式响应
+ * @param {string|null} content - 文本内容
+ * @param {string|null} reasoning - 思维链内容
+ * @param {string|null} reasoningSignature - 思维链签名
+ * @param {Array|null} toolCalls - 工具调用
+ * @param {string|null} finishReason - 结束原因
+ * @param {Object|null} usage - 使用量统计
+ * @returns {Object}
+ */
+export const createGeminiResponse = (content, reasoning, reasoningSignature, toolCalls, finishReason, usage) => {
+  const parts = [];
+  
+  if (reasoning) {
+    const thoughtPart = { text: reasoning, thought: true };
+    if (reasoningSignature && config.passSignatureToClient) {
+      thoughtPart.thoughtSignature = reasoningSignature;
+    }
+    parts.push(thoughtPart);
+  }
+  
+  if (content) {
+    parts.push({ text: content });
+  }
+  
+  if (toolCalls && toolCalls.length > 0) {
+    toolCalls.forEach(tc => {
+      try {
+        const functionCallPart = {
+          functionCall: {
+            name: tc.function.name,
+            args: JSON.parse(tc.function.arguments)
+          }
+        };
+        if (tc.thoughtSignature && config.passSignatureToClient) {
+          functionCallPart.thoughtSignature = tc.thoughtSignature;
+        }
+        parts.push(functionCallPart);
+      } catch (e) {
+        // 忽略解析错误
+      }
+    });
+  }
+
+  const response = {
+    candidates: [{
+      content: {
+        parts: parts,
+        role: "model"
+      },
+      finishReason: finishReason || "STOP",
+      index: 0
+    }]
+  };
+
+  if (usage) {
+    response.usageMetadata = {
+      promptTokenCount: usage.prompt_tokens,
+      candidatesTokenCount: usage.completion_tokens,
+      totalTokenCount: usage.total_tokens
+    };
+  }
+  
+  return response;
+};
+
+/**
+ * 将 OpenAI 模型列表转换为 Gemini 格式
+ * @param {Object} openaiModels - OpenAI格式模型列表
+ * @returns {Object}
+ */
+export const convertToGeminiModelList = (openaiModels) => {
+  const models = openaiModels.data.map(model => ({
+    name: `models/${model.id}`,
+    version: "001",
+    displayName: model.id,
+    description: "Imported model",
+    inputTokenLimit: 32768, // 默认值
+    outputTokenLimit: 8192, // 默认值
+    supportedGenerationMethods: ["generateContent", "countTokens"],
+    temperature: 0.9,
+    topP: 1.0,
+    topK: 40
+  }));
+  return { models };
+};
+
+/**
+ * 获取 Gemini 格式模型列表
+ * @param {Request} req - Express请求对象
+ * @param {Response} res - Express响应对象
+ */
+export const handleGeminiModelsList = async (req, res) => {
+  try {
+    const openaiModels = await getAvailableModels();
+    const geminiModels = convertToGeminiModelList(openaiModels);
+    res.json(geminiModels);
+  } catch (error) {
+    logger.error('获取模型列表失败:', error.message);
+    res.status(500).json({ error: { code: 500, message: error.message, status: "INTERNAL" } });
+  }
+};
+
+/**
+ * 获取单个模型详情（Gemini格式）
+ * @param {Request} req - Express请求对象
+ * @param {Response} res - Express响应对象
+ */
+export const handleGeminiModelDetail = async (req, res) => {
+  try {
+    const modelId = req.params.model.replace(/^models\//, '');
+    const openaiModels = await getAvailableModels();
+    const model = openaiModels.data.find(m => m.id === modelId);
+    
+    if (model) {
+      const geminiModel = {
+        name: `models/${model.id}`,
+        version: "001",
+        displayName: model.id,
+        description: "Imported model",
+        inputTokenLimit: 32768,
+        outputTokenLimit: 8192,
+        supportedGenerationMethods: ["generateContent", "countTokens"],
+        temperature: 0.9,
+        topP: 1.0,
+        topK: 40
+      };
+      res.json(geminiModel);
+    } else {
+      res.status(404).json({ error: { code: 404, message: `Model ${modelId} not found`, status: "NOT_FOUND" } });
+    }
+  } catch (error) {
+    logger.error('获取模型详情失败:', error.message);
+    res.status(500).json({ error: { code: 500, message: error.message, status: "INTERNAL" } });
+  }
+};
+
+/**
+ * 处理 Gemini 格式的聊天请求
+ * @param {Request} req - Express请求对象
+ * @param {Response} res - Express响应对象
+ * @param {string} modelName - 模型名称
+ * @param {boolean} isStream - 是否流式响应
+ */
+export const handleGeminiRequest = async (req, res, modelName, isStream) => {
+  const maxRetries = Number(config.retryTimes || 0);
+  const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
+  
+  try {
+    const token = await tokenManager.getToken();
+    if (!token) {
+      throw new Error('没有可用的token，请运行 npm run login 获取token');
+    }
+
+    const isImageModel = modelName.includes('-image');
+    const requestBody = generateGeminiRequestBody(req.body, modelName, token);
+    
+    if (isImageModel) {
+      prepareImageRequest(requestBody);
+    }
+
+    if (isStream) {
+      setStreamHeaders(res);
+      const heartbeatTimer = createHeartbeat(res);
+
+      try {
+        if (isImageModel) {
+          // 生图模型：使用非流式获取结果后一次性返回
+          const { content, usage } = await with429Retry(
+            () => generateAssistantResponseNoStream(requestBody, token),
+            safeRetries,
+            'gemini.stream.image '
+          );
+          const chunk = createGeminiResponse(content, null, null, null, 'STOP', usage);
+          writeStreamData(res, chunk);
+          clearInterval(heartbeatTimer);
+          endStream(res);
+          return;
+        }
+        
+        let usageData = null;
+        let hasToolCall = false;
+
+        await with429Retry(
+          () => generateAssistantResponse(requestBody, token, (data) => {
+            if (data.type === 'usage') {
+              usageData = data.usage;
+            } else if (data.type === 'reasoning') {
+              // Gemini 思考内容
+              const chunk = createGeminiResponse(null, data.reasoning_content, data.thoughtSignature, null, null, null);
+              writeStreamData(res, chunk);
+            } else if (data.type === 'tool_calls') {
+              hasToolCall = true;
+              // Gemini 工具调用
+              const chunk = createGeminiResponse(null, null, null, data.tool_calls, null, null);
+              writeStreamData(res, chunk);
+            } else {
+              // 普通文本
+              const chunk = createGeminiResponse(data.content, null, null, null, null, null);
+              writeStreamData(res, chunk);
+            }
+          }),
+          safeRetries,
+          'gemini.stream '
+        );
+
+        // 发送结束块和 usage
+        const finishReason = hasToolCall ? "STOP" : "STOP"; // Gemini 工具调用也是 STOP
+        const finalChunk = createGeminiResponse(null, null, null, null, finishReason, usageData);
+        writeStreamData(res, finalChunk);
+
+        clearInterval(heartbeatTimer);
+        endStream(res);
+      } catch (error) {
+        clearInterval(heartbeatTimer);
+        if (!res.writableEnded) {
+          const statusCode = error.statusCode || error.status || 500;
+          writeStreamData(res, buildGeminiErrorPayload(error, statusCode));
+          endStream(res);
+        }
+        logger.error('Gemini 流式请求失败:', error.message);
+        return;
+      }
+    } else {
+      // 非流式
+      req.setTimeout(0);
+      res.setTimeout(0);
+
+      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
+        () => generateAssistantResponseNoStream(requestBody, token),
+        safeRetries,
+        'gemini.no_stream '
+      );
+
+      const finishReason = toolCalls.length > 0 ? "STOP" : "STOP";
+      const response = createGeminiResponse(content, reasoningContent, reasoningSignature, toolCalls, finishReason, usage);
+      res.json(response);
+    }
+  } catch (error) {
+    logger.error('Gemini 请求失败:', error.message);
+    if (res.headersSent) return;
+    const statusCode = error.statusCode || error.status || 500;
+    res.status(statusCode).json(buildGeminiErrorPayload(error, statusCode));
+  }
+};

src/server/handlers/openai.js

@@ -0,0 +1,181 @@
+/**
+ * OpenAI 格式处理器
+ * 处理 /v1/chat/completions 请求，支持流式和非流式响应
+ */
+
+import { generateAssistantResponse, generateAssistantResponseNoStream } from '../../api/client.js';
+import { generateRequestBody, prepareImageRequest } from '../../utils/utils.js';
+import { buildOpenAIErrorPayload } from '../../utils/errors.js';
+import logger from '../../utils/logger.js';
+import config from '../../config/config.js';
+import tokenManager from '../../auth/token_manager.js';
+import {
+  createResponseMeta,
+  setStreamHeaders,
+  createHeartbeat,
+  getChunkObject,
+  releaseChunkObject,
+  writeStreamData,
+  endStream,
+  with429Retry
+} from '../stream.js';
+
+/**
+ * 创建流式数据块
+ * 支持 DeepSeek 格式的 reasoning_content
+ * @param {string} id - 响应ID
+ * @param {number} created - 创建时间戳
+ * @param {string} model - 模型名称
+ * @param {Object} delta - 增量内容
+ * @param {string|null} finish_reason - 结束原因
+ * @returns {Object}
+ */
+export const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
+  const chunk = getChunkObject();
+  chunk.id = id;
+  chunk.object = 'chat.completion.chunk';
+  chunk.created = created;
+  chunk.model = model;
+  chunk.choices[0].delta = delta;
+  chunk.choices[0].finish_reason = finish_reason;
+  return chunk;
+};
+
+/**
+ * 处理 OpenAI 格式的聊天请求
+ * @param {Request} req - Express请求对象
+ * @param {Response} res - Express响应对象
+ */
+export const handleOpenAIRequest = async (req, res) => {
+  const { messages, model, stream = false, tools, ...params } = req.body;
+  
+  try {
+    if (!messages) {
+      return res.status(400).json({ error: 'messages is required' });
+    }
+    
+    const token = await tokenManager.getToken();
+    if (!token) {
+      throw new Error('没有可用的token，请运行 npm run login 获取token');
+    }
+    
+    const isImageModel = model.includes('-image');
+    const requestBody = generateRequestBody(messages, model, params, tools, token);
+    
+    if (isImageModel) {
+      prepareImageRequest(requestBody);
+    }
+    
+    const { id, created } = createResponseMeta();
+    const maxRetries = Number(config.retryTimes || 0);
+    const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
+    
+    if (stream) {
+      setStreamHeaders(res);
+      
+      // 启动心跳，防止 Cloudflare 超时断连
+      const heartbeatTimer = createHeartbeat(res);
+
+      try {
+        if (isImageModel) {
+          const { content, usage } = await with429Retry(
+            () => generateAssistantResponseNoStream(requestBody, token),
+            safeRetries,
+            'chat.stream.image '
+          );
+          writeStreamData(res, createStreamChunk(id, created, model, { content }));
+          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, 'stop'), usage });
+        } else {
+          let hasToolCall = false;
+          let usageData = null;
+
+          await with429Retry(
+            () => generateAssistantResponse(requestBody, token, (data) => {
+              if (data.type === 'usage') {
+                usageData = data.usage;
+              } else if (data.type === 'reasoning') {
+                const delta = { reasoning_content: data.reasoning_content };
+                if (data.thoughtSignature && config.passSignatureToClient) {
+                  delta.thoughtSignature = data.thoughtSignature;
+                }
+                writeStreamData(res, createStreamChunk(id, created, model, delta));
+              } else if (data.type === 'tool_calls') {
+                hasToolCall = true;
+                // 根据配置决定是否透传工具调用中的签名
+                const toolCallsWithIndex = data.tool_calls.map((toolCall, index) => {
+                  if (config.passSignatureToClient) {
+                    return { index, ...toolCall };
+                  } else {
+                    const { thoughtSignature, ...rest } = toolCall;
+                    return { index, ...rest };
+                  }
+                });
+                const delta = { tool_calls: toolCallsWithIndex };
+                writeStreamData(res, createStreamChunk(id, created, model, delta));
+              } else {
+                const delta = { content: data.content };
+                writeStreamData(res, createStreamChunk(id, created, model, delta));
+              }
+            }),
+            safeRetries,
+            'chat.stream '
+          );
+
+          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, hasToolCall ? 'tool_calls' : 'stop'), usage: usageData });
+        }
+
+        clearInterval(heartbeatTimer);
+        endStream(res);
+      } catch (error) {
+        clearInterval(heartbeatTimer);
+        throw error;
+      }
+    } else {
+      // 非流式请求：设置较长超时，避免大模型响应超时
+      req.setTimeout(0); // 禁用请求超时
+      res.setTimeout(0); // 禁用响应超时
+      
+      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
+        () => generateAssistantResponseNoStream(requestBody, token),
+        safeRetries,
+        'chat.no_stream '
+      );
+      
+      // DeepSeek 格式：reasoning_content 在 content 之前
+      const message = { role: 'assistant' };
+      if (reasoningContent) message.reasoning_content = reasoningContent;
+      if (reasoningSignature && config.passSignatureToClient) message.thoughtSignature = reasoningSignature;
+      message.content = content;
+      
+      if (toolCalls.length > 0) {
+        // 根据配置决定是否透传工具调用中的签名
+        if (config.passSignatureToClient) {
+          message.tool_calls = toolCalls;
+        } else {
+          message.tool_calls = toolCalls.map(({ thoughtSignature, ...rest }) => rest);
+        }
+      }
+      
+      // 使用预构建的响应对象，减少内存分配
+      const response = {
+        id,
+        object: 'chat.completion',
+        created,
+        model,
+        choices: [{
+          index: 0,
+          message,
+          finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop'
+        }],
+        usage
+      };
+      
+      res.json(response);
+    }
+  } catch (error) {
+    logger.error('生成响应失败:', error.message);
+    if (res.headersSent) return;
+    const statusCode = error.statusCode || error.status || 500;
+    return res.status(statusCode).json(buildOpenAIErrorPayload(error, statusCode));
+  }
+};

src/server/index.js

@@ -1,18 +1,26 @@
+/**
+ * 服务器主入口
+ * Express 应用配置、中间件、路由挂载、服务器启动和关闭
+ */
+
 import express from 'express';
 import cors from 'cors';
 import path from 'path';
-import { generateAssistantResponse, generateAssistantResponseNoStream, getAvailableModels, generateImageForSD, closeRequester } from '../api/client.js';
-import { generateRequestBody, generateGeminiRequestBody, generateClaudeRequestBody, prepareImageRequest } from '../utils/utils.js';
-import { normalizeClaudeParameters } from '../utils/parameterNormalizer.js';
+import { closeRequester } from '../api/client.js';
 import logger from '../utils/logger.js';
 import config from '../config/config.js';
-import tokenManager from '../auth/token_manager.js';
+import memoryManager from '../utils/memoryManager.js';
+import { getPublicDir, getRelativePath } from '../utils/paths.js';
+import { MEMORY_CHECK_INTERVAL } from '../constants/index.js';
+import { errorHandler } from '../utils/errors.js';
+import { getChunkPoolSize, clearChunkPool } from './stream.js';
+
+// 路由模块
 import adminRouter from '../routes/admin.js';
 import sdRouter from '../routes/sd.js';
-import memoryManager, { registerMemoryPoolCleanup } from '../utils/memoryManager.js';
-import { getPublicDir, getRelativePath } from '../utils/paths.js';
-import { DEFAULT_HEARTBEAT_INTERVAL, MEMORY_CHECK_INTERVAL } from '../constants/index.js';
-import { buildOpenAIErrorPayload, buildGeminiErrorPayload, buildClaudeErrorPayload, errorHandler, ValidationError } from '../utils/errors.js';
+import openaiRouter from '../routes/openai.js';
+import geminiRouter from '../routes/gemini.js';
+import claudeRouter from '../routes/claude.js';
 
 const publicDir = getPublicDir();
 
@@ -20,167 +28,11 @@ logger.info(`静态文件目录: ${getRelativePath(publicDir)}`);
 
 const app = express();
 
-// ==================== 通用重试工具（处理 429） ====================
-const with429Retry = async (fn, maxRetries, loggerPrefix = '') => {
-  const retries = Number.isFinite(maxRetries) && maxRetries > 0 ? Math.floor(maxRetries) : 0;
-  let attempt = 0;
-  // 首次执行 + 最多 retries 次重试
-  while (true) {
-    try {
-      return await fn(attempt);
-    } catch (error) {
-      // 兼容多种错误格式：error.status, error.statusCode, error.response?.status
-      const status = Number(error.status || error.statusCode || error.response?.status);
-      if (status === 429 && attempt < retries) {
-        const nextAttempt = attempt + 1;
-        logger.warn(`${loggerPrefix}收到 429，正在进行第 ${nextAttempt} 次重试（共 ${retries} 次）`);
-        attempt = nextAttempt;
-        continue;
-      }
-      throw error;
-    }
-  }
-};
-
-// ==================== 心跳机制（防止 CF 超时） ====================
-const HEARTBEAT_INTERVAL = config.server.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
-const SSE_HEARTBEAT = Buffer.from(': heartbeat\n\n');
-
-// 创建心跳定时器
-const createHeartbeat = (res) => {
-  const timer = setInterval(() => {
-    if (!res.writableEnded) {
-      res.write(SSE_HEARTBEAT);
-    } else {
-      clearInterval(timer);
-    }
-  }, HEARTBEAT_INTERVAL);
-  
-  // 响应结束时清理
-  res.on('close', () => clearInterval(timer));
-  res.on('finish', () => clearInterval(timer));
-  
-  return timer;
-};
-
-// 预编译的常量字符串（避免重复创建）
-const SSE_PREFIX = Buffer.from('data: ');
-const SSE_SUFFIX = Buffer.from('\n\n');
-const SSE_DONE = Buffer.from('data: [DONE]\n\n');
-
-// 工具函数：生成响应元数据
-const createResponseMeta = () => ({
-  id: `chatcmpl-${Date.now()}`,
-  created: Math.floor(Date.now() / 1000)
-});
-
-// 工具函数：设置流式响应头
-const setStreamHeaders = (res) => {
-  res.setHeader('Content-Type', 'text/event-stream');
-  res.setHeader('Cache-Control', 'no-cache');
-  res.setHeader('Connection', 'keep-alive');
-  res.setHeader('X-Accel-Buffering', 'no'); // 禁用 nginx 缓冲
-};
-
-// 工具函数：构建流式数据块（使用动态对象池减少 GC）
-// 支持 DeepSeek 格式的 reasoning_content
-const chunkPool = [];
-const getChunkObject = () => chunkPool.pop() || { choices: [{ index: 0, delta: {}, finish_reason: null }] };
-const releaseChunkObject = (obj) => {
-  const maxSize = memoryManager.getPoolSizes().chunk;
-  if (chunkPool.length < maxSize) chunkPool.push(obj);
-};
-
-// 注册内存清理回调（使用统一工具收缩对象池）
-registerMemoryPoolCleanup(chunkPool, () => memoryManager.getPoolSizes().chunk);
-
-// 设置内存阈值（从配置加载）并启动内存管理器
+// ==================== 内存管理 ====================
 memoryManager.setThreshold(config.server.memoryThreshold);
 memoryManager.start(MEMORY_CHECK_INTERVAL);
 
-const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
-  const chunk = getChunkObject();
-  chunk.id = id;
-  chunk.object = 'chat.completion.chunk';
-  chunk.created = created;
-  chunk.model = model;
-  chunk.choices[0].delta = delta;
-  chunk.choices[0].finish_reason = finish_reason;
-  return chunk;
-};
-
-// 工具函数：零拷贝写入流式数据
-const writeStreamData = (res, data) => {
-  const json = JSON.stringify(data);
-  res.write(SSE_PREFIX);
-  res.write(json);
-  res.write(SSE_SUFFIX);
-};
-
-// 工具函数：结束流式响应
-const endStream = (res) => {
-  if (res.writableEnded) return;
-  res.write(SSE_DONE);
-  res.end();
-};
-
-
-
-
-// Gemini 响应构建工具
-const createGeminiResponse = (content, reasoning, reasoningSignature, toolCalls, finishReason, usage) => {
-  const parts = [];
-  if (reasoning) {
-    const thoughtPart = { text: reasoning, thought: true };
-    if (reasoningSignature && config.passSignatureToClient) {
-      thoughtPart.thoughtSignature = reasoningSignature;
-    }
-    parts.push(thoughtPart);
-  }
-  if (content) {
-    parts.push({ text: content });
-  }
-  if (toolCalls && toolCalls.length > 0) {
-    toolCalls.forEach(tc => {
-      try {
-        const functionCallPart = {
-          functionCall: {
-            name: tc.function.name,
-            args: JSON.parse(tc.function.arguments)
-          }
-        };
-        if (tc.thoughtSignature && config.passSignatureToClient) {
-          functionCallPart.thoughtSignature = tc.thoughtSignature;
-        }
-        parts.push(functionCallPart);
-      } catch (e) {
-        // 忽略解析错误
-      }
-    });
-  }
-
-  const response = {
-    candidates: [{
-      content: {
-        parts: parts,
-        role: "model"
-      },
-      finishReason: finishReason || "STOP",
-      index: 0
-    }]
-  };
-
-  if (usage) {
-    response.usageMetadata = {
-      promptTokenCount: usage.prompt_tokens,
-      candidatesTokenCount: usage.completion_tokens,
-      totalTokenCount: usage.total_tokens
-    };
-  }
-  
-  return response;
-};
-
+// ==================== 基础中间件 ====================
 app.use(cors());
 app.use(express.json({ limit: config.security.maxRequestSize }));
 
@@ -194,9 +46,15 @@ app.use('/admin', adminRouter);
 // 使用统一错误处理中间件
 app.use(errorHandler);
 
+// ==================== 请求日志中间件 ====================
 app.use((req, res, next) => {
-  const ignorePaths = ['/images', '/favicon.ico', '/.well-known', '/sdapi/v1/options', '/sdapi/v1/samplers', '/sdapi/v1/schedulers', '/sdapi/v1/upscalers', '/sdapi/v1/latent-upscale-modes', '/sdapi/v1/sd-vae', '/sdapi/v1/sd-modules'];
-  if (!ignorePaths.some(path => req.path.startsWith(path))) {
+  const ignorePaths = [
+    '/images', '/favicon.ico', '/.well-known',
+    '/sdapi/v1/options', '/sdapi/v1/samplers', '/sdapi/v1/schedulers',
+    '/sdapi/v1/upscalers', '/sdapi/v1/latent-upscale-modes',
+    '/sdapi/v1/sd-vae', '/sdapi/v1/sd-modules'
+  ];
+  if (!ignorePaths.some(p => req.path.startsWith(p))) {
     const start = Date.now();
     res.on('finish', () => {
       logger.request(req.method, req.path, res.statusCode, Date.now() - start);
@@ -204,8 +62,11 @@ app.use((req, res, next) => {
   }
   next();
 });
+
+// SD API 路由
 app.use('/sdapi/v1', sdRouter);
 
+// ==================== API Key 验证中间件 ====================
 app.use((req, res, next) => {
   if (req.path.startsWith('/v1/')) {
     const apiKey = config.security?.apiKey;
@@ -221,15 +82,18 @@ app.use((req, res, next) => {
   next();
 });
 
-app.get('/v1/models', async (req, res) => {
-  try {
-    const models = await getAvailableModels();
-    res.json(models);
-  } catch (error) {
-    logger.error('获取模型列表失败:', error.message);
-    res.status(500).json({ error: error.message });
-  }
-});
+// ==================== API 路由 ====================
+
+// OpenAI 兼容 API
+app.use('/v1', openaiRouter);
+
+// Gemini 兼容 API
+app.use('/v1beta', geminiRouter);
+
+// Claude 兼容 API（/v1/messages 由 claudeRouter 处理）
+app.use('/v1', claudeRouter);
+
+// ==================== 系统端点 ====================
 
 // 内存监控端点
 app.get('/v1/memory', (req, res) => {
@@ -242,7 +106,7 @@ app.get('/v1/memory', (req, res) => {
     arrayBuffers: usage.arrayBuffers,
     pressure: memoryManager.getCurrentPressure(),
     poolSizes: memoryManager.getPoolSizes(),
-    chunkPoolSize: chunkPool.length
+    chunkPoolSize: getChunkPoolSize()
   });
 });
 
@@ -251,585 +115,7 @@ app.get('/health', (req, res) => {
   res.json({ status: 'ok', uptime: process.uptime() });
 });
 
-
-
-app.post('/v1/chat/completions', async (req, res) => {
-  const { messages, model, stream = false, tools, ...params} = req.body;
-  try {
-    if (!messages) {
-      return res.status(400).json({ error: 'messages is required' });
-    }
-    const token = await tokenManager.getToken();
-    if (!token) {
-      throw new Error('没有可用的token，请运行 npm run login 获取token');
-    }
-    const isImageModel = model.includes('-image');
-    const requestBody = generateRequestBody(messages, model, params, tools, token);
-    if (isImageModel) {
-      prepareImageRequest(requestBody);
-    }
-    //console.log(JSON.stringify(requestBody,null,2))
-    
-    const { id, created } = createResponseMeta();
-    const maxRetries = Number(config.retryTimes || 0);
-    const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
-    
-    if (stream) {
-      setStreamHeaders(res);
-      
-      // 启动心跳，防止 Cloudflare 超时断连
-      const heartbeatTimer = createHeartbeat(res);
-
-      try {
-        if (isImageModel) {
-          const { content, usage } = await with429Retry(
-            () => generateAssistantResponseNoStream(requestBody, token),
-            safeRetries,
-            'chat.stream.image '
-          );
-          writeStreamData(res, createStreamChunk(id, created, model, { content }));
-          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, 'stop'), usage });
-        } else {
-          let hasToolCall = false;
-          let usageData = null;
-
-          await with429Retry(
-            () => generateAssistantResponse(requestBody, token, (data) => {
-              if (data.type === 'usage') {
-                usageData = data.usage;
-              } else if (data.type === 'reasoning') {
-                const delta = { reasoning_content: data.reasoning_content };
-                if (data.thoughtSignature && config.passSignatureToClient) {
-                  delta.thoughtSignature = data.thoughtSignature;
-                }
-                writeStreamData(res, createStreamChunk(id, created, model, delta));
-              } else if (data.type === 'tool_calls') {
-                hasToolCall = true;
-                // 根据配置决定是否透传工具调用中的签名
-                const toolCallsWithIndex = data.tool_calls.map((toolCall, index) => {
-                  if (config.passSignatureToClient) {
-                    return { index, ...toolCall };
-                  } else {
-                    const { thoughtSignature, ...rest } = toolCall;
-                    return { index, ...rest };
-                  }
-                });
-                const delta = { tool_calls: toolCallsWithIndex };
-                writeStreamData(res, createStreamChunk(id, created, model, delta));
-              } else {
-                const delta = { content: data.content };
-                writeStreamData(res, createStreamChunk(id, created, model, delta));
-              }
-            }),
-            safeRetries,
-            'chat.stream '
-          );
-
-          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, hasToolCall ? 'tool_calls' : 'stop'), usage: usageData });
-        }
-
-        clearInterval(heartbeatTimer);
-        endStream(res);
-      } catch (error) {
-        clearInterval(heartbeatTimer);
-        throw error;
-      }
-    } else {
-      // 非流式请求：设置较长超时，避免大模型响应超时
-      req.setTimeout(0); // 禁用请求超时
-      res.setTimeout(0); // 禁用响应超时
-      
-      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
-        () => generateAssistantResponseNoStream(requestBody, token),
-        safeRetries,
-        'chat.no_stream '
-      );
-      // DeepSeek 格式：reasoning_content 在 content 之前
-      const message = { role: 'assistant' };
-      if (reasoningContent) message.reasoning_content = reasoningContent;
-      if (reasoningSignature && config.passSignatureToClient) message.thoughtSignature = reasoningSignature;
-      message.content = content;
-      if (toolCalls.length > 0) {
-        // 根据配置决定是否透传工具调用中的签名
-        if (config.passSignatureToClient) {
-          message.tool_calls = toolCalls;
-        } else {
-          message.tool_calls = toolCalls.map(({ thoughtSignature, ...rest }) => rest);
-        }
-      }
-      
-      // 使用预构建的响应对象，减少内存分配
-      const response = {
-        id,
-        object: 'chat.completion',
-        created,
-        model,
-        choices: [{
-          index: 0,
-          message,
-          finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop'
-        }],
-        usage
-      };
-      
-      res.json(response);
-    }
-  } catch (error) {
-    logger.error('生成响应失败:', error.message);
-    if (res.headersSent) return;
-    const statusCode = error.statusCode || error.status || 500;
-    return res.status(statusCode).json(buildOpenAIErrorPayload(error, statusCode));
-  }
-});
-
-// Gemini 模型列表格式转换
-const convertToGeminiModelList = (openaiModels) => {
-  const models = openaiModels.data.map(model => ({
-    name: `models/${model.id}`,
-    version: "001",
-    displayName: model.id,
-    description: "Imported model",
-    inputTokenLimit: 32768, // 默认值
-    outputTokenLimit: 8192, // 默认值
-    supportedGenerationMethods: ["generateContent", "countTokens"],
-    temperature: 0.9,
-    topP: 1.0,
-    topK: 40
-  }));
-  return { models };
-};
-
-// Gemini API 路由
-app.get('/v1beta/models', async (req, res) => {
-  try {
-    const openaiModels = await getAvailableModels();
-    const geminiModels = convertToGeminiModelList(openaiModels);
-    res.json(geminiModels);
-  } catch (error) {
-    logger.error('获取模型列表失败:', error.message);
-    res.status(500).json({ error: { code: 500, message: error.message, status: "INTERNAL" } });
-  }
-});
-
-app.get('/v1beta/models/:model', async (req, res) => {
-  try {
-    const modelId = req.params.model.replace(/^models\//, '');
-    const openaiModels = await getAvailableModels();
-    const model = openaiModels.data.find(m => m.id === modelId);
-    
-    if (model) {
-      const geminiModel = {
-        name: `models/${model.id}`,
-        version: "001",
-        displayName: model.id,
-        description: "Imported model",
-        inputTokenLimit: 32768,
-        outputTokenLimit: 8192,
-        supportedGenerationMethods: ["generateContent", "countTokens"],
-        temperature: 0.9,
-        topP: 1.0,
-        topK: 40
-      };
-      res.json(geminiModel);
-    } else {
-      res.status(404).json({ error: { code: 404, message: `Model ${modelId} not found`, status: "NOT_FOUND" } });
-    }
-  } catch (error) {
-    logger.error('获取模型详情失败:', error.message);
-    res.status(500).json({ error: { code: 500, message: error.message, status: "INTERNAL" } });
-  }
-});
-
-const handleGeminiRequest = async (req, res, modelName, isStream) => {
-  const maxRetries = Number(config.retryTimes || 0);
-  const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
-  
-  try {
-    const token = await tokenManager.getToken();
-    if (!token) {
-      throw new Error('没有可用的token，请运行 npm run login 获取token');
-    }
-
-    const requestBody = generateGeminiRequestBody(req.body, modelName, token);
-
-    if (isStream) {
-      setStreamHeaders(res);
-      const heartbeatTimer = createHeartbeat(res);
-
-      try {
-        let usageData = null;
-        let hasToolCall = false;
-
-        await with429Retry(
-          () => generateAssistantResponse(requestBody, token, (data) => {
-            if (data.type === 'usage') {
-              usageData = data.usage;
-            } else if (data.type === 'reasoning') {
-              // Gemini 思考内容
-              const chunk = createGeminiResponse(null, data.reasoning_content, data.thoughtSignature, null, null, null);
-              writeStreamData(res, chunk);
-            } else if (data.type === 'tool_calls') {
-              hasToolCall = true;
-              // Gemini 工具调用
-              const chunk = createGeminiResponse(null, null, null, data.tool_calls, null, null);
-              writeStreamData(res, chunk);
-            } else {
-              // 普通文本
-              const chunk = createGeminiResponse(data.content, null, null, null, null, null);
-              writeStreamData(res, chunk);
-            }
-          }),
-          safeRetries,
-          'gemini.stream '
-        );
-
-        // 发送结束块和 usage
-        const finishReason = hasToolCall ? "STOP" : "STOP"; // Gemini 工具调用也是 STOP
-        const finalChunk = createGeminiResponse(null, null, null, null, finishReason, usageData);
-        writeStreamData(res, finalChunk);
-
-        clearInterval(heartbeatTimer);
-        endStream(res);
-      } catch (error) {
-        clearInterval(heartbeatTimer);
-        if (!res.writableEnded) {
-          const statusCode = error.statusCode || error.status || 500;
-          writeStreamData(res, buildGeminiErrorPayload(error, statusCode));
-          endStream(res);
-        }
-        logger.error('Gemini 流式请求失败:', error.message);
-        return;
-      }
-    } else {
-      // 非流式
-      req.setTimeout(0);
-      res.setTimeout(0);
-
-      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
-        () => generateAssistantResponseNoStream(requestBody, token),
-        safeRetries,
-        'gemini.no_stream '
-      );
-
-      const finishReason = toolCalls.length > 0 ? "STOP" : "STOP";
-      const response = createGeminiResponse(content, reasoningContent, reasoningSignature, toolCalls, finishReason, usage);
-      res.json(response);
-    }
-  } catch (error) {
-    logger.error('Gemini 请求失败:', error.message);
-    if (res.headersSent) return;
-    const statusCode = error.statusCode || error.status || 500;
-    res.status(statusCode).json(buildGeminiErrorPayload(error, statusCode));
-  }
-};
-
-app.post('/v1beta/models/:model\\:streamGenerateContent', (req, res) => {
-  const modelName = req.params.model;
-  handleGeminiRequest(req, res, modelName, true);
-});
-
-app.post('/v1beta/models/:model\\:generateContent', (req, res) => {
-  const modelName = req.params.model;
-  const isStream = req.query.alt === 'sse';
-  handleGeminiRequest(req, res, modelName, isStream);
-});
-
-// ==================== Claude API ====================
-
-
-
-// Claude 流式响应工具
-const createClaudeStreamEvent = (eventType, data) => {
-  return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
-};
-
-// Claude 非流式响应构建
-const createClaudeResponse = (id, model, content, reasoning, reasoningSignature, toolCalls, stopReason, usage) => {
-  const contentBlocks = [];
-  
-  // 思维链内容（如果有）- Claude 格式用 thinking 类型
-  if (reasoning) {
-    const thinkingBlock = {
-      type: "thinking",
-      thinking: reasoning
-    };
-    if (reasoningSignature && config.passSignatureToClient) {
-      thinkingBlock.signature = reasoningSignature;
-    }
-    contentBlocks.push(thinkingBlock);
-  }
-  
-  // 文本内容
-  if (content) {
-    contentBlocks.push({
-      type: "text",
-      text: content
-    });
-  }
-  
-  // 工具调用
-  if (toolCalls && toolCalls.length > 0) {
-    for (const tc of toolCalls) {
-      try {
-        const toolBlock = {
-          type: "tool_use",
-          id: tc.id,
-          name: tc.function.name,
-          input: JSON.parse(tc.function.arguments)
-        };
-        if (tc.thoughtSignature && config.passSignatureToClient) {
-          toolBlock.signature = tc.thoughtSignature;
-        }
-        contentBlocks.push(toolBlock);
-      } catch (e) {
-        // 解析失败时传入空对象
-        contentBlocks.push({
-          type: "tool_use",
-          id: tc.id,
-          name: tc.function.name,
-          input: {}
-        });
-      }
-    }
-  }
-
-  return {
-    id: id,
-    type: "message",
-    role: "assistant",
-    content: contentBlocks,
-    model: model,
-    stop_reason: stopReason,
-    stop_sequence: null,
-    usage: usage ? {
-      input_tokens: usage.prompt_tokens || 0,
-      output_tokens: usage.completion_tokens || 0
-    } : { input_tokens: 0, output_tokens: 0 }
-  };
-};
-
-// Claude API 处理函数
-const handleClaudeRequest = async (req, res, isStream) => {
-  const { messages, model, system, tools, ...rawParams } = req.body;
-  
-  try {
-    if (!messages) {
-      return res.status(400).json(buildClaudeErrorPayload({ message: 'messages is required' }, 400));
-    }
-    
-    const token = await tokenManager.getToken();
-    if (!token) {
-      throw new Error('没有可用的token，请运行 npm run login 获取token');
-    }
-    
-    // 使用统一参数规范化模块处理 Claude 格式参数
-    const parameters = normalizeClaudeParameters(rawParams);
-    
-    const requestBody = generateClaudeRequestBody(messages, model, parameters, tools, system, token);
-    
-    const msgId = `msg_${Date.now()}`;
-    const maxRetries = Number(config.retryTimes || 0);
-    const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
-    
-    if (isStream) {
-      setStreamHeaders(res);
-      const heartbeatTimer = createHeartbeat(res);
-      
-      try {
-        let contentIndex = 0;
-        let usageData = null;
-        let hasToolCall = false;
-        let currentBlockType = null;
-        let reasoningSent = false;
-        
-        // 发送 message_start
-        res.write(createClaudeStreamEvent('message_start', {
-          type: "message_start",
-          message: {
-            id: msgId,
-            type: "message",
-            role: "assistant",
-            content: [],
-            model: model,
-            stop_reason: null,
-            stop_sequence: null,
-            usage: { input_tokens: 0, output_tokens: 0 }
-          }
-        }));
-        
-        await with429Retry(
-          () => generateAssistantResponse(requestBody, token, (data) => {
-            if (data.type === 'usage') {
-              usageData = data.usage;
-            } else if (data.type === 'reasoning') {
-              // 思维链内容 - 使用 thinking 类型
-              if (!reasoningSent) {
-                // 开始思维块
-                const contentBlock = { type: "thinking", thinking: "" };
-                if (data.thoughtSignature && config.passSignatureToClient) {
-                  contentBlock.signature = data.thoughtSignature;
-                }
-                res.write(createClaudeStreamEvent('content_block_start', {
-                  type: "content_block_start",
-                  index: contentIndex,
-                  content_block: contentBlock
-                }));
-                currentBlockType = 'thinking';
-                reasoningSent = true;
-              }
-              // 发送思维增量
-              const delta = { type: "thinking_delta", thinking: data.reasoning_content || '' };
-              if (data.thoughtSignature && config.passSignatureToClient) {
-                delta.signature = data.thoughtSignature;
-              }
-              res.write(createClaudeStreamEvent('content_block_delta', {
-                type: "content_block_delta",
-                index: contentIndex,
-                delta: delta
-              }));
-            } else if (data.type === 'tool_calls') {
-              hasToolCall = true;
-              // 结束之前的块（如果有）
-              if (currentBlockType) {
-                res.write(createClaudeStreamEvent('content_block_stop', {
-                  type: "content_block_stop",
-                  index: contentIndex
-                }));
-                contentIndex++;
-              }
-              // 工具调用
-              for (const tc of data.tool_calls) {
-                try {
-                  const inputObj = JSON.parse(tc.function.arguments);
-                  const toolContentBlock = { type: "tool_use", id: tc.id, name: tc.function.name, input: {} };
-                  if (tc.thoughtSignature && config.passSignatureToClient) {
-                    toolContentBlock.signature = tc.thoughtSignature;
-                  }
-                  res.write(createClaudeStreamEvent('content_block_start', {
-                    type: "content_block_start",
-                    index: contentIndex,
-                    content_block: toolContentBlock
-                  }));
-                  // 发送 input 增量
-                  res.write(createClaudeStreamEvent('content_block_delta', {
-                    type: "content_block_delta",
-                    index: contentIndex,
-                    delta: { type: "input_json_delta", partial_json: JSON.stringify(inputObj) }
-                  }));
-                  res.write(createClaudeStreamEvent('content_block_stop', {
-                    type: "content_block_stop",
-                    index: contentIndex
-                  }));
-                  contentIndex++;
-                } catch (e) {
-                  // 解析失败，跳过
-                }
-              }
-              currentBlockType = null;
-            } else {
-              // 普通文本内容
-              if (currentBlockType === 'thinking') {
-                // 结束思维块
-                res.write(createClaudeStreamEvent('content_block_stop', {
-                  type: "content_block_stop",
-                  index: contentIndex
-                }));
-                contentIndex++;
-                currentBlockType = null;
-              }
-              if (currentBlockType !== 'text') {
-                // 开始文本块
-                res.write(createClaudeStreamEvent('content_block_start', {
-                  type: "content_block_start",
-                  index: contentIndex,
-                  content_block: { type: "text", text: "" }
-                }));
-                currentBlockType = 'text';
-              }
-              // 发送文本增量
-              res.write(createClaudeStreamEvent('content_block_delta', {
-                type: "content_block_delta",
-                index: contentIndex,
-                delta: { type: "text_delta", text: data.content || '' }
-              }));
-            }
-          }),
-          safeRetries,
-          'claude.stream '
-        );
-        
-        // 结束最后一个内容块
-        if (currentBlockType) {
-          res.write(createClaudeStreamEvent('content_block_stop', {
-            type: "content_block_stop",
-            index: contentIndex
-          }));
-        }
-        
-        // 发送 message_delta
-        const stopReason = hasToolCall ? 'tool_use' : 'end_turn';
-        res.write(createClaudeStreamEvent('message_delta', {
-          type: "message_delta",
-          delta: { stop_reason: stopReason, stop_sequence: null },
-          usage: usageData ? { output_tokens: usageData.completion_tokens || 0 } : { output_tokens: 0 }
-        }));
-        
-        // 发送 message_stop
-        res.write(createClaudeStreamEvent('message_stop', {
-          type: "message_stop"
-        }));
-        
-        clearInterval(heartbeatTimer);
-        res.end();
-      } catch (error) {
-        clearInterval(heartbeatTimer);
-        if (!res.writableEnded) {
-          const statusCode = error.statusCode || error.status || 500;
-          res.write(createClaudeStreamEvent('error', buildClaudeErrorPayload(error, statusCode)));
-          res.end();
-        }
-        logger.error('Claude 流式请求失败:', error.message);
-        return;
-      }
-    } else {
-      // 非流式请求
-      req.setTimeout(0);
-      res.setTimeout(0);
-      
-      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
-        () => generateAssistantResponseNoStream(requestBody, token),
-        safeRetries,
-        'claude.no_stream '
-      );
-      
-      const stopReason = toolCalls.length > 0 ? 'tool_use' : 'end_turn';
-      const response = createClaudeResponse(
-        msgId,
-        model,
-        content,
-        reasoningContent,
-        reasoningSignature,
-        toolCalls,
-        stopReason,
-        usage
-      );
-      
-      res.json(response);
-    }
-  } catch (error) {
-    logger.error('Claude 请求失败:', error.message);
-    if (res.headersSent) return;
-    const statusCode = error.statusCode || error.status || 500;
-    res.status(statusCode).json(buildClaudeErrorPayload(error, statusCode));
-  }
-};
-
-// Claude Messages API 端点
-app.post('/v1/messages', (req, res) => {
-  const isStream = req.body.stream === true;
-  handleClaudeRequest(req, res, isStream);
-});
-
+// ==================== 服务器启动 ====================
 const server = app.listen(config.server.port, config.server.host, () => {
   logger.info(`服务器已启动: ${config.server.host}:${config.server.port}`);
 });
@@ -847,6 +133,7 @@ server.on('error', (error) => {
   }
 });
 
+// ==================== 优雅关闭 ====================
 const shutdown = () => {
   logger.info('正在关闭服务器...');
   
@@ -859,7 +146,7 @@ const shutdown = () => {
   logger.info('已关闭子进程请求器');
   
   // 清理对象池
-  chunkPool.length = 0;
+  clearChunkPool();
   logger.info('已清理对象池');
   
   server.close(() => {
@@ -877,7 +164,7 @@ const shutdown = () => {
 process.on('SIGINT', shutdown);
 process.on('SIGTERM', shutdown);
 
-// 未捕获异常处理
+// ==================== 异常处理 ====================
 process.on('uncaughtException', (error) => {
   logger.error('未捕获异常:', error.message);
   // 不立即退出，让当前请求完成

src/server/stream.js

@@ -0,0 +1,145 @@
+/**
+ * SSE 流式响应和心跳机制工具模块
+ * 提供统一的流式响应处理、心跳保活、429重试等功能
+ */
+
+import config from '../config/config.js';
+import logger from '../utils/logger.js';
+import memoryManager, { registerMemoryPoolCleanup } from '../utils/memoryManager.js';
+import { DEFAULT_HEARTBEAT_INTERVAL } from '../constants/index.js';
+
+// ==================== 心跳机制（防止 CF 超时） ====================
+const HEARTBEAT_INTERVAL = config.server.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
+const SSE_HEARTBEAT = Buffer.from(': heartbeat\n\n');
+
+/**
+ * 创建心跳定时器
+ * @param {Response} res - Express响应对象
+ * @returns {NodeJS.Timeout} 定时器
+ */
+export const createHeartbeat = (res) => {
+  const timer = setInterval(() => {
+    if (!res.writableEnded) {
+      res.write(SSE_HEARTBEAT);
+    } else {
+      clearInterval(timer);
+    }
+  }, HEARTBEAT_INTERVAL);
+  
+  // 响应结束时清理
+  res.on('close', () => clearInterval(timer));
+  res.on('finish', () => clearInterval(timer));
+  
+  return timer;
+};
+
+// ==================== 预编译的常量字符串（避免重复创建） ====================
+const SSE_PREFIX = Buffer.from('data: ');
+const SSE_SUFFIX = Buffer.from('\n\n');
+const SSE_DONE = Buffer.from('data: [DONE]\n\n');
+
+/**
+ * 生成响应元数据
+ * @returns {{id: string, created: number}}
+ */
+export const createResponseMeta = () => ({
+  id: `chatcmpl-${Date.now()}`,
+  created: Math.floor(Date.now() / 1000)
+});
+
+/**
+ * 设置流式响应头
+ * @param {Response} res - Express响应对象
+ */
+export const setStreamHeaders = (res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no'); // 禁用 nginx 缓冲
+};
+
+// ==================== 对象池（减少 GC） ====================
+const chunkPool = [];
+
+/**
+ * 从对象池获取 chunk 对象
+ * @returns {Object}
+ */
+export const getChunkObject = () => chunkPool.pop() || { choices: [{ index: 0, delta: {}, finish_reason: null }] };
+
+/**
+ * 释放 chunk 对象回对象池
+ * @param {Object} obj 
+ */
+export const releaseChunkObject = (obj) => {
+  const maxSize = memoryManager.getPoolSizes().chunk;
+  if (chunkPool.length < maxSize) chunkPool.push(obj);
+};
+
+// 注册内存清理回调
+registerMemoryPoolCleanup(chunkPool, () => memoryManager.getPoolSizes().chunk);
+
+/**
+ * 获取当前对象池大小（用于监控）
+ * @returns {number}
+ */
+export const getChunkPoolSize = () => chunkPool.length;
+
+/**
+ * 清空对象池
+ */
+export const clearChunkPool = () => {
+  chunkPool.length = 0;
+};
+
+/**
+ * 零拷贝写入流式数据
+ * @param {Response} res - Express响应对象
+ * @param {Object} data - 要发送的数据
+ */
+export const writeStreamData = (res, data) => {
+  const json = JSON.stringify(data);
+  res.write(SSE_PREFIX);
+  res.write(json);
+  res.write(SSE_SUFFIX);
+};
+
+/**
+ * 结束流式响应
+ * @param {Response} res - Express响应对象
+ */
+export const endStream = (res) => {
+  if (res.writableEnded) return;
+  res.write(SSE_DONE);
+  res.end();
+};
+
+// ==================== 通用重试工具（处理 429） ====================
+
+/**
+ * 带 429 重试的执行器
+ * @param {Function} fn - 要执行的异步函数，接收 attempt 参数
+ * @param {number} maxRetries - 最大重试次数
+ * @param {string} loggerPrefix - 日志前缀
+ * @returns {Promise<any>}
+ */
+export const with429Retry = async (fn, maxRetries, loggerPrefix = '') => {
+  const retries = Number.isFinite(maxRetries) && maxRetries > 0 ? Math.floor(maxRetries) : 0;
+  let attempt = 0;
+  // 首次执行 + 最多 retries 次重试
+  while (true) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      // 兼容多种错误格式：error.status, error.statusCode, error.response?.status
+      const status = Number(error.status || error.statusCode || error.response?.status);
+      if (status === 429 && attempt < retries) {
+        const nextAttempt = attempt + 1;
+        logger.warn(`${loggerPrefix}收到 429，正在进行第 ${nextAttempt} 次重试（共 ${retries} 次）`);
+        attempt = nextAttempt;
+        continue;
+      }
+      throw error;
+    }
+  }
+};