feat: 错误信息返回客户端、自动重试、工具调用格式适配、思考模型多轮工具调用

文件改动:

src/server/index.js:
- 新增 with429Retry() 通用重试工具函数，处理 429 状态码自动重试
- 新增 buildOpenAIErrorPayload() 构造 OpenAI 兼容错误响应
- 错误信息直接返回客户端：HTTP 状态码 + { error: { message, type, code } }
- 流式/非流式请求均使用 with429Retry 包装，支持配置重试次数
- 移除旧的错误处理逻辑，改为标准 OpenAI 错误格式

src/utils/utils.js:
- 新增 sanitizeToolName() 规范工具名称为 Vertex 要求格式 ^[a-zA-Z0-9_-]{1,128}$
- 新增 DEFAULT_THOUGHT_SIGNATURE 思维链签名占位常量
- handleAssistantMessage() 新增 enableThinking 参数
- 思考模型多轮工具调用支持：历史 assistant 消息补充思考块 + 签名块
- openaiMessageToAntigravity() 传递 enableThinking 参数
- convertOpenAIToolsToAntigravity() 使用 sanitizeToolName 规范工具名

src/api/client.js:
- 新增 createApiError() 创建带状态码的 API 错误对象
- handleErrorResponse() 使用 createApiError 抛出错误，保留原始状态码和响应体

src/config/config.js:
- 新增 retryTimes 配置项，默认 3 次重试

config.json:
- other 新增 retryTimes: 3 配置

public/index.html:
- 新增 429重试次数 配置输入框

public/app.js:
- loadConfig() 加载 retryTimes 配置
- 表单提交时保存 retryTimes 配置

API.md:
- 新增 429 自动重试配置说明文档

API.md

@@ -259,11 +259,28 @@ curl http://localhost:8045/v1/chat/completions \
   -d '{
     "model": "gemini-2.5-pro",
     "messages": [{"role": "user", "content": "证明勾股定理"}],
-    "stream": true,
+      "stream": true,
     "thinking_budget": 24000
   }'
 ```
 
+### 429 自动重试配置
+
+所有 429 重试次数仅通过服务端配置控制：
+
+- 全局默认重试次数（服务端配置）：
+  - 文件：`config.json` 中的 `other.retryTimes`
+  - 示例：
+    ```json
+    "other": {
+      "timeout": 300000,
+      "retryTimes": 3,
+      "skipProjectIdFetch": false,
+      "useNativeAxios": false
+    }
+    ```
+  - 服务器始终使用这里配置的值作为 429 时的重试次数（默认 3 次）。
+
 ### 思维链响应格式
 
 思维链内容通过 `reasoning_content` 字段输出（兼容 DeepSeek 格式）：

config.json

@@ -29,6 +29,7 @@
   },
   "other": {
     "timeout": 300000,
+    "retryTimes": 3,
     "skipProjectIdFetch": false,
     "useNativeAxios": false
   }

public/app.js

@@ -1242,6 +1242,7 @@ async function loadConfig() {
             }
             if (json.other) {
                 if (form.elements['TIMEOUT']) form.elements['TIMEOUT'].value = json.other.timeout ?? '';
+                if (form.elements['RETRY_TIMES']) form.elements['RETRY_TIMES'].value = json.other.retryTimes ?? '';
                 if (form.elements['SKIP_PROJECT_ID_FETCH']) form.elements['SKIP_PROJECT_ID_FETCH'].value = json.other.skipProjectIdFetch ? 'true' : 'false';
             }
             // 加载轮询策略配置
@@ -1298,6 +1299,10 @@ document.getElementById('configForm').addEventListener('submit', async (e) => {
                 jsonConfig.defaults.thinkingBudget = Number.isNaN(num) ? undefined : num;
             }
             else if (key === 'TIMEOUT') jsonConfig.other.timeout = parseInt(value) || undefined;
+            else if (key === 'RETRY_TIMES') {
+                const num = parseInt(value);
+                jsonConfig.other.retryTimes = Number.isNaN(num) ? undefined : num;
+            }
             else if (key === 'SKIP_PROJECT_ID_FETCH') jsonConfig.other.skipProjectIdFetch = value === 'true';
             else if (key === 'ROTATION_STRATEGY') jsonConfig.rotation.strategy = value || undefined;
             else if (key === 'ROTATION_REQUEST_COUNT') jsonConfig.rotation.requestCount = parseInt(value) || undefined;

public/index.html

@@ -173,6 +173,10 @@
                                         <label>超时(ms)</label>
                                         <input type="number" name="TIMEOUT" placeholder="300000">
                                     </div>
+                                    <div class="form-group compact">
+                                        <label>429重试次数</label>
+                                        <input type="number" name="RETRY_TIMES" placeholder="0">
+                                    </div>
                                     <div class="form-group compact">
                                         <label>跳过验证</label>
                                         <select name="SKIP_PROJECT_ID_FETCH">

src/api/client.js

@@ -196,6 +196,15 @@ function buildRequesterConfig(headers, body = null) {
   return reqConfig;
 }
 
+// 统一构造上游 API 错误对象，方便服务器层识别并透传
+function createApiError(message, status, rawBody) {
+  const err = new Error(message);
+  err.status = status;
+  err.rawBody = rawBody;
+  err.isUpstreamApiError = true;
+  return err;
+}
+
 // 统一错误处理
 async function handleApiError(error, token) {
   const status = error.response?.status || error.status || 'Unknown';
@@ -215,13 +224,13 @@ async function handleApiError(error, token) {
   
   if (status === 403) {
     if (JSON.stringify(errorBody).includes("The caller does not")){
-      throw new Error(`超出模型最大上下文。错误详情: ${errorBody}`);
+      throw createApiError(`超出模型最大上下文。错误详情: ${errorBody}`, status, errorBody);
     }
     tokenManager.disableCurrentToken(token);
-    throw new Error(`该账号没有使用权限，已自动禁用。错误详情: ${errorBody}`);
+    throw createApiError(`该账号没有使用权限，已自动禁用。错误详情: ${errorBody}`, status, errorBody);
   }
   
-  throw new Error(`API请求失败 (${status}): ${errorBody}`);
+  throw createApiError(`API请求失败 (${status}): ${errorBody}`, status, errorBody);
 }
 
 // 转换 functionCall 为 OpenAI 格式（使用对象池）

src/config/config.js

@@ -90,6 +90,8 @@ const config = {
   },
   useNativeAxios: jsonConfig.other?.useNativeAxios !== false,
   timeout: jsonConfig.other?.timeout || 300000,
+  // 默认 429 重试次数（统一配置，0 表示不重试，默认 3 次）
+  retryTimes: Number.isFinite(jsonConfig.other?.retryTimes) ? jsonConfig.other.retryTimes : 3,
   proxy: getProxyConfig(),
   systemInstruction: process.env.SYSTEM_INSTRUCTION || '',
   skipProjectIdFetch: jsonConfig.other?.skipProjectIdFetch === true

src/server/index.js

@@ -16,6 +16,27 @@ const __dirname = path.dirname(__filename);
 
 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) {
+      const status = Number(error.status || 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 || 15000; // 从配置读取心跳间隔
 const SSE_HEARTBEAT = Buffer.from(': heartbeat\n\n');
@@ -94,10 +115,44 @@ const writeStreamData = (res, data) => {
 
 // 工具函数：结束流式响应
 const endStream = (res) => {
+  if (res.writableEnded) return;
   res.write(SSE_DONE);
   res.end();
 };
 
+// OpenAI 兼容错误响应构造
+const buildOpenAIErrorPayload = (error, statusCode) => {
+  if (error.isUpstreamApiError && error.rawBody) {
+    try {
+      const raw = typeof error.rawBody === 'string' ? JSON.parse(error.rawBody) : error.rawBody;
+      const inner = raw.error || raw;
+      return {
+        error: {
+          message: inner.message || error.message || 'Upstream API error',
+          type: inner.type || 'upstream_api_error',
+          code: inner.code ?? statusCode
+        }
+      };
+    } catch {
+      return {
+        error: {
+          message: error.rawBody || error.message || 'Upstream API error',
+          type: 'upstream_api_error',
+          code: statusCode
+        }
+      };
+    }
+  }
+
+  return {
+    error: {
+      message: error.message || 'Internal server error',
+      type: 'server_error',
+      code: statusCode
+    }
+  };
+};
+
 app.use(cors());
 app.use(express.json({ limit: config.security.maxRequestSize }));
 
@@ -192,55 +247,68 @@ app.post('/v1/chat/completions', async (req, res) => {
     //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) {
-          //console.log(JSON.stringify(requestBody,null,2));
-          const { content, usage } = await generateAssistantResponseNoStream(requestBody, token);
+          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 generateAssistantResponse(requestBody, token, (data) => {
-            if (data.type === 'usage') {
-              usageData = data.usage;
-            } else if (data.type === 'reasoning') {
-              // DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
-              const delta = { reasoning_content: data.reasoning_content };
-              writeStreamData(res, createStreamChunk(id, created, model, delta));
-            } else if (data.type === 'tool_calls') {
-              hasToolCall = true;
-              // OpenAI 流式 schema 要求每个 tool_call 带有 index 字段
-              const toolCallsWithIndex = data.tool_calls.map((toolCall, index) => ({
-                index,
-                ...toolCall
-              }));
-              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));
-            }
-          });
+
+          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 };
+                writeStreamData(res, createStreamChunk(id, created, model, delta));
+              } else if (data.type === 'tool_calls') {
+                hasToolCall = true;
+                const toolCallsWithIndex = data.tool_calls.map((toolCall, index) => ({ index, ...toolCall }));
+                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 });
         }
-      } finally {
+
         clearInterval(heartbeatTimer);
         endStream(res);
+      } catch (error) {
+        clearInterval(heartbeatTimer);
+        throw error;
       }
     } else {
       // 非流式请求：设置较长超时，避免大模型响应超时
       req.setTimeout(0); // 禁用请求超时
       res.setTimeout(0); // 禁用响应超时
       
-      const { content, reasoningContent, toolCalls, usage } = await generateAssistantResponseNoStream(requestBody, token);
+      const { content, reasoningContent, 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;
@@ -265,29 +333,15 @@ app.post('/v1/chat/completions', async (req, res) => {
     }
   } catch (error) {
     logger.error('生成响应失败:', error.message);
-    if (!res.headersSent) {
-      const { id, created } = createResponseMeta();
-      const errorContent = `错误: ${error.message}`;
-      
-      if (stream) {
-        setStreamHeaders(res);
-        writeStreamData(res, createStreamChunk(id, created, model, { content: errorContent }));
-        writeStreamData(res, createStreamChunk(id, created, model, {}, 'stop'));
-        endStream(res);
-      } else {
-        res.json({
-          id,
-          object: 'chat.completion',
-          created,
-          model,
-          choices: [{
-            index: 0,
-            message: { role: 'assistant', content: errorContent },
-            finish_reason: 'stop'
-          }]
-        });
-      }
+    // 如果已经开始写响应，就不再追加错误内容，避免协议冲突
+    if (res.headersSent) {
+      return;
     }
+
+    // OpenAI 兼容错误返回：HTTP 状态码 + { error: { message, type, code } }
+    const statusCode = Number(error.status) || 500;
+    const errorPayload = buildOpenAIErrorPayload(error, statusCode);
+    return res.status(statusCode).json(errorPayload);
   }
 });
 

src/utils/utils.js

@@ -3,6 +3,9 @@ import tokenManager from '../auth/token_manager.js';
 import { generateRequestId } from './idGenerator.js';
 import os from 'os';
 
+// 思维链签名占位（用于启用思考模型但没有真实签名时）
+const DEFAULT_THOUGHT_SIGNATURE = 'RXFRRENrZ0lDaEFDR0FJcVFKV1Bvcy9GV20wSmtMV2FmWkFEbGF1ZTZzQTdRcFlTc1NvbklmemtSNFo4c1dqeitIRHBOYW9hS2NYTE1TeTF3bjh2T1RHdE1KVjVuYUNQclZ5cm9DMFNETHk4M0hOSWsrTG1aRUhNZ3hvTTl0ZEpXUDl6UUMzOExxc2ZJakI0UkkxWE1mdWJ1VDQrZnY0Znp0VEoyTlhtMjZKL2daYi9HL1gwcmR4b2x0VE54empLemtLcEp0ZXRia2plb3NBcWlRSWlXUHloMGhVVTk1dHNha1dyNDVWNUo3MTJjZDNxdHQ5Z0dkbjdFaFk4dUllUC9CcThVY2VZZC9YbFpYbDc2bHpEbmdzL2lDZXlNY3NuZXdQMjZBTDRaQzJReXdibVQzbXlSZmpld3ZSaUxxOWR1TVNidHIxYXRtYTJ0U1JIRjI0Z0JwUnpadE1RTmoyMjR4bTZVNUdRNXlOSWVzUXNFNmJzRGNSV0RTMGFVOEZERExybmhVQWZQT2JYMG5lTGR1QnU1VGZOWW9NZGlRbTgyUHVqVE1xaTlmN0t2QmJEUUdCeXdyVXR2eUNnTEFHNHNqeWluZDRCOEg3N2ZJamt5blI3Q3ZpQzlIOTVxSENVTCt3K3JzMmsvV0sxNlVsbGlTK0pET3UxWXpPMWRPOUp3V3hEMHd5ZVU0a0Y5MjIxaUE5Z2lUd2djZXhSU2c4TWJVMm1NSjJlaGdlY3g0YjJ3QloxR0FFPQ==';
+
 function extractImagesFromContent(content) {
   const result = { text: '', images: [] };
 
@@ -50,7 +53,25 @@ function handleUserMessage(extracted, antigravityMessages){
     ]
   })
 }
-function handleAssistantMessage(message, antigravityMessages){
+// 将工具名称规范为 Vertex 要求的格式：^[a-zA-Z0-9_-]{1,128}$
+function sanitizeToolName(name) {
+  if (!name || typeof name !== 'string') {
+    return 'tool';
+  }
+  // 替换非法字符为下划线
+  let cleaned = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  // 去掉首尾多余下划线
+  cleaned = cleaned.replace(/^_+|_+$/g, '');
+  if (!cleaned) {
+    cleaned = 'tool';
+  }
+  // 限制最大长度 128
+  if (cleaned.length > 128) {
+    cleaned = cleaned.slice(0, 128);
+  }
+  return cleaned;
+}
+function handleAssistantMessage(message, antigravityMessages, enableThinking){
   const lastMessage = antigravityMessages[antigravityMessages.length - 1];
   const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
   const hasContent = message.content && message.content.trim() !== '';
@@ -58,17 +79,42 @@ function handleAssistantMessage(message, antigravityMessages){
   const antigravityTools = hasToolCalls ? message.tool_calls.map(toolCall => ({
     functionCall: {
       id: toolCall.id,
-      name: toolCall.function.name,
+      name: sanitizeToolName(toolCall.function.name),
       args: {
         query: toolCall.function.arguments
       }
     }
   })) : [];
-  
+
   if (lastMessage?.role === "model" && hasToolCalls && !hasContent){
     lastMessage.parts.push(...antigravityTools)
   }else{
     const parts = [];
+
+    // 对于启用思考的模型，在历史 assistant 消息中补一个思考块 + 签名块
+    // 结构示例：
+    // {
+    //   "role": "model",
+    //   "parts": [
+    //     { "text": "␈", "thought": true },
+    //     { "text": "␈", "thoughtSignature": "..." },
+    //     { "text": "正常回复..." }
+    //   ]
+    // }
+    if (enableThinking) {
+      // 默认思考内容不能是完全空字符串，否则上游会要求 thinking 字段
+      // 这里用一个不可见的退格符作为占位，实际展示时等价于“空思考块”
+      let reasoningText = '';
+      if (typeof message.reasoning_content === 'string' && message.reasoning_content.length > 0) {
+        reasoningText = message.reasoning_content;
+      } else {
+        reasoningText = ' '; // 退格符占位
+      }
+      parts.push({ text: reasoningText, thought: true });
+      // 思维链签名占位，避免上游校验缺少签名字段
+      parts.push({ text: ' ', thoughtSignature: DEFAULT_THOUGHT_SIGNATURE });
+    }
+
     if (hasContent) parts.push({ text: message.content.trimEnd() });
     parts.push(...antigravityTools);
     
@@ -115,7 +161,7 @@ function handleToolCall(message, antigravityMessages){
     });
   }
 }
-function openaiMessageToAntigravity(openaiMessages){
+function openaiMessageToAntigravity(openaiMessages, enableThinking){
   const antigravityMessages = [];
   for (const message of openaiMessages) {
     if (message.role === "user") {
@@ -126,7 +172,7 @@ function openaiMessageToAntigravity(openaiMessages){
       const extracted = extractImagesFromContent(message.content);
       handleUserMessage(extracted, antigravityMessages);
     } else if (message.role === "assistant") {
-      handleAssistantMessage(message, antigravityMessages);
+      handleAssistantMessage(message, antigravityMessages, enableThinking);
     } else if (message.role === "tool") {
       handleToolCall(message, antigravityMessages);
     }
@@ -279,10 +325,12 @@ function convertOpenAIToolsToAntigravity(openaiTools){
       cleanedParams.properties = {};
     }
 
+    const safeName = sanitizeToolName(tool.function?.name);
+
     return {
       functionDeclarations: [
         {
-          name: tool.function.name,
+          name: safeName,
           description: tool.function.description,
           parameters: cleanedParams
         }
@@ -334,7 +382,7 @@ function generateRequestBody(openaiMessages,modelName,parameters,openaiTools,tok
     project: token.projectId,
     requestId: generateRequestId(),
     request: {
-      contents: openaiMessageToAntigravity(filteredMessages),
+      contents: openaiMessageToAntigravity(filteredMessages, enableThinking),
       tools: convertOpenAIToolsToAntigravity(openaiTools),
       toolConfig: {
         functionCallingConfig: {