feat: 统一参数处理模块 + 多 API 格式参数支持

## 新增文件

### 1. src/utils/parameterNormalizer.js (新建)
统一参数处理模块，将 OpenAI、Claude、Gemini 三种格式的参数统一转换为内部格式：
- normalizeOpenAIParameters() - 规范化 OpenAI 格式参数
- normalizeClaudeParameters() - 规范化 Claude 格式参数（处理 thinking.budget_tokens）
- normalizeGeminiParameters() - 规范化 Gemini 格式参数（处理 thinkingConfig.thinkingBudget）
- toGenerationConfig() - 转换为上游 API 的 generationConfig 格式

### 2. src/utils/converters/common.js (新建)
转换器公共模块，提取三个转换器的公共函数：
- getSignatureContext() - 获取思维签名和工具签名
- pushUserMessage() - 添加用户消息
- findFunctionNameById() - 根据工具调用 ID 查找函数名
- pushFunctionResponse() - 添加函数响应
- createThoughtPart() - 创建带签名的思维 part
- createFunctionCallPart() - 创建带签名的函数调用 part
- processToolName() - 处理工具名称映射
- pushModelMessage() - 添加模型消息
- buildRequestBody() - 构建 Antigravity 请求体
- mergeSystemInstruction() - 合并系统指令

### 3. src/utils/toolConverter.js (新建)
统一工具定义转换模块：
- convertOpenAIToolsToAntigravity() - OpenAI 工具格式转换
- convertClaudeToolsToAntigravity() - Claude 工具格式转换
- convertGeminiToolsToAntigravity() - Gemini 工具格式转换

## 修改文件

### 4. src/server/index.js
- 第 6 行：添加 normalizeClaudeParameters 导入
- 第 659-679 行：Claude API 处理函数使用 normalizeClaudeParameters() 替代手动参数构建
- 第 22-42 行：with429Retry 函数兼容多种错误格式（error.status, error.statusCode, error.response?.status）

### 5. src/utils/utils.js
- 第 5 行：添加 toGenerationConfig 导入
- 第 73-108 行：generateGenerationConfig() 函数重构，使用 toGenerationConfig() 简化逻辑

### 6. src/utils/converters/gemini.js
- 第 6 行：添加 normalizeGeminiParameters, toGenerationConfig 导入
- 第 132-135 行：使用 normalizeGeminiParameters() 和 toGenerationConfig() 替代手动参数处理

### 7. src/utils/converters/openai.js
- 使用 common.js 中的公共函数替代重复代码

### 8. src/utils/converters/claude.js
- 使用 common.js 中的公共函数替代重复代码

### 9. src/utils/memoryManager.js
- 第 10-15 行：添加 setThreshold(thresholdMB) 方法，支持动态设置内存阈值
- 阈值计算：LOW=30%, MEDIUM=60%, HIGH=100%

### 10. src/config/config.js
- defaults.memoryThreshold：默认值从 500 改为 100（MB）

### 11. src/constants/index.js
- 添加 REASONING_EFFORT_MAP 常量导出

### 12. config.json
- 配置文件格式调整

### 13. README.md
- 添加「多 API 格式支持」章节，详细说明三种格式的参数
- 添加「参数规范化模块」文档
- 更新项目结构，包含新增文件
- 更新代码架构章节

README.md

@@ -25,6 +25,9 @@
 - ✅ 对象池复用（减少 50%+ 临时对象创建，降低 GC 频率）
 - ✅ 签名透传控制（可配置是否将 thoughtSignature 透传到客户端）
 - ✅ 预编译二进制文件（支持 Windows/Linux/Android，无需 Node.js 环境）
+- ✅ 多 API 格式支持（OpenAI、Gemini、Claude 三种格式）
+- ✅ 转换器代码复用（公共模块提取，减少重复代码）
+- ✅ 动态内存阈值（根据用户配置自动计算各级别阈值）
 
 ## 环境要求
 
@@ -568,14 +571,17 @@ npm run login
 │   │   ├── imageStorage.js # 图片存储
 │   │   ├── logger.js       # 日志模块
 │   │   ├── memoryManager.js # 智能内存管理
-│   │   ├── openai_generation.js # 生成配置
-│   │   ├── openai_mapping.js    # 请求体构建
-│   │   ├── openai_messages.js   # 消息格式转换
-│   │   ├── openai_signatures.js # 签名常量
-│   │   ├── openai_system.js     # 系统指令提取
-│   │   ├── openai_tools.js      # 工具格式转换
+│   │   ├── parameterNormalizer.js # 统一参数处理
 │   │   ├── paths.js        # 路径工具（支持 pkg 打包）
+│   │   ├── thoughtSignatureCache.js # 签名缓存
+│   │   ├── toolConverter.js # 工具定义转换
+│   │   ├── toolNameCache.js # 工具名称缓存
 │   │   └── utils.js        # 工具函数（重导出）
+│   │   └── converters/     # 格式转换器
+│   │       ├── common.js   # 公共函数
+│   │       ├── openai.js   # OpenAI 格式
+│   │       ├── claude.js   # Claude 格式
+│   │       └── gemini.js   # Gemini 格式
 │   └── AntigravityRequester.js # TLS 指纹请求器封装
 ├── test/
 │   ├── test-request.js     # 请求测试
@@ -641,38 +647,94 @@ messages = [{role: user, content: 你好}]
 - 充分利用 Antigravity 的 SystemInstruction 功能
 - 确保系统提示词的完整性和优先级
 
-## 思考预算（Thinking Budget）
+## 多 API 格式支持
 
-对于支持思考能力的模型（如 gemini-2.0-flash-thinking-exp），可以通过以下方式控制思考深度：
+本服务支持三种 API 格式，每种格式都有完整的参数支持：
 
-### 方式一：使用 reasoning_effort 参数（OpenAI 兼容）
+### OpenAI 格式 (`/v1/chat/completions`)
 
 ```json
 {
   "model": "gemini-2.0-flash-thinking-exp",
+  "max_tokens": 16000,
+  "temperature": 0.7,
+  "top_p": 0.9,
+  "top_k": 40,
+  "thinking_budget": 10000,
   "reasoning_effort": "high",
   "messages": [...]
 }
 ```
 
-| 值 | 思考 Token 预算 |
-|---|----------------|
-| `low` | 1024 |
-| `medium` | 16000 |
-| `high` | 32000 |
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `max_tokens` | 最大输出 token 数 | 32000 |
+| `temperature` | 温度 (0.0-1.0) | 1 |
+| `top_p` | Top-P 采样 | 1 |
+| `top_k` | Top-K 采样 | 50 |
+| `thinking_budget` | 思考预算 (1024-32000) | 1024 |
+| `reasoning_effort` | 思考强度 (`low`/`medium`/`high`) | - |
 
-### 方式二：使用 thinking_budget 参数（精确控制）
+### Claude 格式 (`/v1/messages`)
 
 ```json
 {
-  "model": "gemini-2.0-flash-thinking-exp",
-  "thinking_budget": 24000,
+  "model": "claude-sonnet-4-5-thinking",
+  "max_tokens": 16000,
+  "temperature": 0.7,
+  "top_p": 0.9,
+  "top_k": 40,
+  "thinking": {
+    "type": "enabled",
+    "budget_tokens": 10000
+  },
   "messages": [...]
 }
 ```
 
-- 范围：1024 - 32000
-- 优先级：`thinking_budget` > `reasoning_effort` > 配置文件默认值
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `max_tokens` | 最大输出 token 数 | 32000 |
+| `temperature` | 温度 (0.0-1.0) | 1 |
+| `top_p` | Top-P 采样 | 1 |
+| `top_k` | Top-K 采样 | 50 |
+| `thinking.type` | 思考开关 (`enabled`/`disabled`) | - |
+| `thinking.budget_tokens` | 思考预算 (1024-32000) | 1024 |
+
+### Gemini 格式 (`/v1beta/models/:model:generateContent`)
+
+```json
+{
+  "contents": [...],
+  "generationConfig": {
+    "maxOutputTokens": 16000,
+    "temperature": 0.7,
+    "topP": 0.9,
+    "topK": 40,
+    "thinkingConfig": {
+      "includeThoughts": true,
+      "thinkingBudget": 10000
+    }
+  }
+}
+```
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `maxOutputTokens` | 最大输出 token 数 | 32000 |
+| `temperature` | 温度 (0.0-1.0) | 1 |
+| `topP` | Top-P 采样 | 1 |
+| `topK` | Top-K 采样 | 50 |
+| `thinkingConfig.includeThoughts` | 是否包含思考内容 | true |
+| `thinkingConfig.thinkingBudget` | 思考预算 (1024-32000) | 1024 |
+
+### 统一参数处理
+
+所有三种格式的参数都会被统一规范化处理，确保一致的行为：
+
+1. **参数优先级**：请求参数 > 配置文件默认值
+2. **思考预算优先级**：`thinking_budget`/`budget_tokens`/`thinkingBudget` > `reasoning_effort` > 配置文件默认值
+3. **禁用思考**：设置 `thinking_budget=0` 或 `thinking.type="disabled"` 或 `thinkingConfig.includeThoughts=false`
 
 ### DeepSeek 思考格式兼容
 
@@ -689,6 +751,14 @@ messages = [{role: user, content: 你好}]
 }
 ```
 
+### reasoning_effort 映射
+
+| 值 | 思考 Token 预算 |
+|---|----------------|
+| `low` | 1024 |
+| `medium` | 16000 |
+| `high` | 32000 |
+
 ## 内存优化
 
 本服务经过深度内存优化：
@@ -706,9 +776,20 @@ messages = [{role: user, content: 你好}]
 1. **对象池复用**：流式响应对象通过对象池复用，减少 50%+ 临时对象创建
 2. **预编译常量**：正则表达式、格式字符串等预编译，避免重复创建
 3. **LineBuffer 优化**：高效的流式行分割，避免频繁字符串操作
-4. **自动内存清理**：堆内存超过阈值（默认 100MB）时自动触发 GC
+4. **自动内存清理**：堆内存超过阈值时自动触发 GC
 5. **进程精简**：移除不必要的子进程，统一在主进程处理
 
+### 动态内存阈值
+
+内存压力阈值根据用户配置的 `memoryThreshold`（MB）动态计算：
+
+| 压力级别 | 阈值比例 | 默认值（100MB 配置） | 行为 |
+|---------|---------|---------------------|------|
+| LOW | 30% | 30MB | 正常运行 |
+| MEDIUM | 60% | 60MB | 轻度清理 |
+| HIGH | 100% | 100MB | 积极清理 + GC |
+| CRITICAL | >100% | >100MB | 紧急清理 + 强制 GC |
+
 ### 配置
 
 ```json
@@ -719,7 +800,7 @@ messages = [{role: user, content: 你好}]
 }
 ```
 
-- `memoryThreshold`：触发 GC 的堆内存阈值（MB）
+- `memoryThreshold`：高压力阈值（MB），其他级别按比例自动计算
 
 ## 心跳机制
 
@@ -741,6 +822,58 @@ messages = [{role: user, content: 你好}]
 
 - `heartbeatInterval`：心跳间隔（毫秒），设为 0 禁用心跳
 
+## 代码架构
+
+### 转换器模块
+
+项目支持三种 API 格式（OpenAI、Gemini、Claude），转换器代码经过优化，提取了公共模块：
+
+```
+src/utils/converters/
+├── common.js      # 公共函数（签名处理、消息构建、请求体构建等）
+├── openai.js      # OpenAI 格式转换器
+├── claude.js      # Claude 格式转换器
+└── gemini.js      # Gemini 格式转换器
+```
+
+#### 公共函数
+
+| 函数 | 说明 |
+|------|------|
+| `getSignatureContext()` | 获取思维签名和工具签名 |
+| `pushUserMessage()` | 添加用户消息到消息数组 |
+| `findFunctionNameById()` | 根据工具调用 ID 查找函数名 |
+| `pushFunctionResponse()` | 添加函数响应到消息数组 |
+| `createThoughtPart()` | 创建带签名的思维 part |
+| `createFunctionCallPart()` | 创建带签名的函数调用 part |
+| `processToolName()` | 处理工具名称映射 |
+| `pushModelMessage()` | 添加模型消息到消息数组 |
+| `buildRequestBody()` | 构建 Antigravity 请求体 |
+| `mergeSystemInstruction()` | 合并系统指令 |
+
+### 参数规范化模块
+
+```
+src/utils/parameterNormalizer.js  # 统一参数处理
+```
+
+将 OpenAI、Claude、Gemini 三种格式的参数统一转换为内部格式：
+
+| 函数 | 说明 |
+|------|------|
+| `normalizeOpenAIParameters()` | 规范化 OpenAI 格式参数 |
+| `normalizeClaudeParameters()` | 规范化 Claude 格式参数 |
+| `normalizeGeminiParameters()` | 规范化 Gemini 格式参数 |
+| `toGenerationConfig()` | 转换为上游 API 格式 |
+
+### 工具转换模块
+
+```
+src/utils/toolConverter.js  # 统一的工具定义转换
+```
+
+支持将 OpenAI、Claude、Gemini 三种格式的工具定义转换为 Antigravity 格式。
+
 ## 注意事项
 
 1. 首次使用需要复制 `.env.example` 为 `.env` 并配置

config.json

@@ -4,7 +4,7 @@
     "host": "0.0.0.0",
     "maxRequestSize": "500mb",
     "heartbeatInterval": 15000,
-    "memoryThreshold": 25
+    "memoryThreshold": 50
   },
   "rotation": {
     "strategy": "request_count",

src/config/config.js

@@ -70,7 +70,7 @@ export function buildConfig(jsonConfig) {
       port: jsonConfig.server?.port || DEFAULT_SERVER_PORT,
       host: jsonConfig.server?.host || DEFAULT_SERVER_HOST,
       heartbeatInterval: jsonConfig.server?.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL,
-      memoryThreshold: jsonConfig.server?.memoryThreshold || 500
+      memoryThreshold: jsonConfig.server?.memoryThreshold || 100
     },
     cache: {
       modelListTTL: jsonConfig.cache?.modelListTTL || MODEL_LIST_CACHE_TTL

src/constants/index.js

@@ -37,19 +37,12 @@ export const MODEL_LIST_CACHE_TTL = 60 * 60 * 1000;
 
 // ==================== 内存管理常量 ====================
 
-/**
- * 内存压力阈值（字节）
- */
-export const MEMORY_THRESHOLDS = {
-  /** 低压力阈值 - 15MB */
-  LOW: 15 * 1024 * 1024,
-  /** 中等压力阈值 - 25MB */
-  MEDIUM: 25 * 1024 * 1024,
-  /** 高压力阈值 - 35MB */
-  HIGH: 35 * 1024 * 1024,
-  /** 目标内存 - 20MB */
-  TARGET: 20 * 1024 * 1024
-};
+// 注意：内存压力阈值现在由 memoryManager 根据用户配置的 memoryThreshold 动态计算
+// 用户配置的 memoryThreshold（MB）即为高压力阈值，其他阈值按比例计算：
+// - LOW: 30% 阈值
+// - MEDIUM: 60% 阈值
+// - HIGH: 100% 阈值（用户配置值）
+// - TARGET: 50% 阈值
 
 /**
  * GC 冷却时间（毫秒）

src/server/index.js

@@ -3,6 +3,7 @@ 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 logger from '../utils/logger.js';
 import config from '../config/config.js';
 import tokenManager from '../auth/token_manager.js';
@@ -28,7 +29,8 @@ const with429Retry = async (fn, maxRetries, loggerPrefix = '') => {
     try {
       return await fn(attempt);
     } catch (error) {
-      const status = Number(error.status || error.response?.status);
+      // 兼容多种错误格式：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} 次）`);
@@ -92,7 +94,8 @@ const releaseChunkObject = (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) => {
@@ -143,10 +146,14 @@ const buildGeminiErrorPayload = (error, statusCode) => {
 };
 
 // Gemini 响应构建工具
-const createGeminiResponse = (content, reasoning, toolCalls, finishReason, usage) => {
+const createGeminiResponse = (content, reasoning, reasoningSignature, toolCalls, finishReason, usage) => {
   const parts = [];
   if (reasoning) {
-    parts.push({ text: reasoning, thought: true });
+    const thoughtPart = { text: reasoning, thought: true };
+    if (reasoningSignature && config.passSignatureToClient) {
+      thoughtPart.thoughtSignature = reasoningSignature;
+    }
+    parts.push(thoughtPart);
   }
   if (content) {
     parts.push({ text: content });
@@ -154,12 +161,16 @@ const createGeminiResponse = (content, reasoning, toolCalls, finishReason, usage
   if (toolCalls && toolCalls.length > 0) {
     toolCalls.forEach(tc => {
       try {
-        parts.push({
+        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) {
         // 忽略解析错误
       }
@@ -454,6 +465,9 @@ app.get('/v1beta/models/:model', async (req, res) => {
 });
 
 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) {
@@ -461,8 +475,6 @@ const handleGeminiRequest = async (req, res, modelName, isStream) => {
     }
 
     const requestBody = generateGeminiRequestBody(req.body, modelName, token);
-    const maxRetries = Number(config.retryTimes || 0);
-    const safeRetries = maxRetries > 0 ? Math.floor(maxRetries) : 0;
 
     if (isStream) {
       setStreamHeaders(res);
@@ -478,16 +490,16 @@ const handleGeminiRequest = async (req, res, modelName, isStream) => {
               usageData = data.usage;
             } else if (data.type === 'reasoning') {
               // Gemini 思考内容
-              const chunk = createGeminiResponse(null, data.reasoning_content, null, null, null);
+              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, data.tool_calls, null, null);
+              const chunk = createGeminiResponse(null, null, null, data.tool_calls, null, null);
               writeStreamData(res, chunk);
             } else {
               // 普通文本
-              const chunk = createGeminiResponse(data.content, null, null, null, null);
+              const chunk = createGeminiResponse(data.content, null, null, null, null, null);
               writeStreamData(res, chunk);
             }
           }),
@@ -497,28 +509,36 @@ const handleGeminiRequest = async (req, res, modelName, isStream) => {
 
         // 发送结束块和 usage
         const finishReason = hasToolCall ? "STOP" : "STOP"; // Gemini 工具调用也是 STOP
-        const finalChunk = createGeminiResponse(null, null, null, finishReason, usageData);
+        const finalChunk = createGeminiResponse(null, null, null, null, finishReason, usageData);
         writeStreamData(res, finalChunk);
 
         clearInterval(heartbeatTimer);
         endStream(res);
       } catch (error) {
         clearInterval(heartbeatTimer);
-        throw error;
+        // 流式响应中发送错误
+        if (!res.writableEnded) {
+          const statusCode = Number(error.status) || 500;
+          const errorPayload = buildGeminiErrorPayload(error, statusCode);
+          writeStreamData(res, errorPayload);
+          endStream(res);
+        }
+        logger.error('Gemini 流式请求失败:', error.message);
+        return;
       }
     } else {
       // 非流式
       req.setTimeout(0);
       res.setTimeout(0);
 
-      const { content, reasoningContent, toolCalls, usage } = await with429Retry(
+      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, toolCalls, finishReason, usage);
+      const response = createGeminiResponse(content, reasoningContent, reasoningSignature, toolCalls, finishReason, usage);
       res.json(response);
     }
   } catch (error) {
@@ -572,15 +592,19 @@ const createClaudeStreamEvent = (eventType, data) => {
 };
 
 // Claude 非流式响应构建
-const createClaudeResponse = (id, model, content, reasoning, toolCalls, stopReason, usage) => {
+const createClaudeResponse = (id, model, content, reasoning, reasoningSignature, toolCalls, stopReason, usage) => {
   const contentBlocks = [];
   
   // 思维链内容（如果有）- Claude 格式用 thinking 类型
   if (reasoning) {
-    contentBlocks.push({
+    const thinkingBlock = {
       type: "thinking",
       thinking: reasoning
-    });
+    };
+    if (reasoningSignature && config.passSignatureToClient) {
+      thinkingBlock.signature = reasoningSignature;
+    }
+    contentBlocks.push(thinkingBlock);
   }
   
   // 文本内容
@@ -595,12 +619,16 @@ const createClaudeResponse = (id, model, content, reasoning, toolCalls, stopReas
   if (toolCalls && toolCalls.length > 0) {
     for (const tc of toolCalls) {
       try {
-        contentBlocks.push({
+        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({
@@ -630,7 +658,7 @@ const createClaudeResponse = (id, model, content, reasoning, toolCalls, stopReas
 
 // Claude API 处理函数
 const handleClaudeRequest = async (req, res, isStream) => {
-  const { messages, model, system, tools, max_tokens, temperature, top_p, top_k, ...otherParams } = req.body;
+  const { messages, model, system, tools, ...rawParams } = req.body;
   
   try {
     if (!messages) {
@@ -642,14 +670,8 @@ const handleClaudeRequest = async (req, res, isStream) => {
       throw new Error('没有可用的token，请运行 npm run login 获取token');
     }
     
-    // 构建参数
-    const parameters = {
-      max_tokens: max_tokens || config.defaults.max_tokens,
-      temperature: temperature ?? config.defaults.temperature,
-      top_p: top_p ?? config.defaults.top_p,
-      top_k: top_k ?? config.defaults.top_k,
-      ...otherParams
-    };
+    // 使用统一参数规范化模块处理 Claude 格式参数
+    const parameters = normalizeClaudeParameters(rawParams);
     
     const requestBody = generateClaudeRequestBody(messages, model, parameters, tools, system, token);
     
@@ -691,19 +713,27 @@ const handleClaudeRequest = async (req, res, isStream) => {
               // 思维链内容 - 使用 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: { type: "thinking", thinking: "" }
+                  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: { type: "thinking_delta", thinking: data.reasoning_content || '' }
+                delta: delta
               }));
             } else if (data.type === 'tool_calls') {
               hasToolCall = true;
@@ -719,10 +749,14 @@ const handleClaudeRequest = async (req, res, isStream) => {
               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: { type: "tool_use", id: tc.id, name: tc.function.name, input: {} }
+                    content_block: toolContentBlock
                   }));
                   // 发送 input 增量
                   res.write(createClaudeStreamEvent('content_block_delta', {
@@ -797,14 +831,22 @@ const handleClaudeRequest = async (req, res, isStream) => {
         res.end();
       } catch (error) {
         clearInterval(heartbeatTimer);
-        throw error;
+        // 流式响应中发送错误事件
+        if (!res.writableEnded) {
+          const statusCode = Number(error.status) || 500;
+          const errorPayload = buildClaudeErrorPayload(error, statusCode);
+          res.write(createClaudeStreamEvent('error', errorPayload));
+          res.end();
+        }
+        logger.error('Claude 流式请求失败:', error.message);
+        return;
       }
     } else {
       // 非流式请求
       req.setTimeout(0);
       res.setTimeout(0);
       
-      const { content, reasoningContent, toolCalls, usage } = await with429Retry(
+      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
         () => generateAssistantResponseNoStream(requestBody, token),
         safeRetries,
         'claude.no_stream '
@@ -816,6 +858,7 @@ const handleClaudeRequest = async (req, res, isStream) => {
         model,
         content,
         reasoningContent,
+        reasoningSignature,
         toolCalls,
         stopReason,
         usage

src/utils/converters/claude.js

@@ -1,9 +1,21 @@
 // Claude 格式转换工具
 import config from '../../config/config.js';
-import { generateRequestId } from '../idGenerator.js';
-import { getReasoningSignature } from '../thoughtSignatureCache.js';
-import { setToolNameMapping } from '../toolNameCache.js';
-import { getThoughtSignatureForModel, sanitizeToolName, cleanParameters, modelMapping, isEnableThinking, generateGenerationConfig } from '../utils.js';
+import { convertClaudeToolsToAntigravity } from '../toolConverter.js';
+import {
+  getSignatureContext,
+  pushUserMessage,
+  findFunctionNameById,
+  pushFunctionResponse,
+  createThoughtPart,
+  createFunctionCallPart,
+  processToolName,
+  pushModelMessage,
+  buildRequestBody,
+  mergeSystemInstruction,
+  modelMapping,
+  isEnableThinking,
+  generateGenerationConfig
+} from './common.js';
 
 function extractImagesFromClaudeContent(content) {
   const result = { text: '', images: [] };
@@ -31,16 +43,9 @@ function extractImagesFromClaudeContent(content) {
   return result;
 }
 
-function handleClaudeUserMessage(extracted, antigravityMessages) {
-  antigravityMessages.push({
-    role: 'user',
-    parts: [{ text: extracted.text }, ...extracted.images]
-  });
-}
-
 function handleClaudeAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId) {
-  const lastMessage = antigravityMessages[antigravityMessages.length - 1];
   const content = message.content;
+  const { reasoningSignature, toolSignature } = getSignatureContext(sessionId, actualModelName);
 
   let textContent = '';
   const toolCalls = [];
@@ -52,40 +57,22 @@ function handleClaudeAssistantMessage(message, antigravityMessages, enableThinki
       if (item.type === 'text') {
         textContent += item.text || '';
       } else if (item.type === 'tool_use') {
-        const originalName = item.name;
-        const safeName = sanitizeToolName(originalName);
-        const part = {
-          functionCall: {
-            id: item.id,
-            name: safeName,
-            args: { query: JSON.stringify(item.input || {}) }
-          }
-        };
-        if (sessionId && actualModelName && safeName !== originalName) {
-          setToolNameMapping(sessionId, actualModelName, safeName, originalName);
-        }
-        toolCalls.push(part);
+        const safeName = processToolName(item.name, sessionId, actualModelName);
+        const signature = enableThinking ? toolSignature : null;
+        toolCalls.push(createFunctionCallPart(item.id, safeName, JSON.stringify(item.input || {}), signature));
       }
     }
   }
 
-  const hasToolCalls = toolCalls.length > 0;
   const hasContent = textContent && textContent.trim() !== '';
-
-  if (lastMessage?.role === 'model' && hasToolCalls && !hasContent) {
-    lastMessage.parts.push(...toolCalls);
-  } else {
-    const parts = [];
-    if (enableThinking) {
-      const cachedSig = getReasoningSignature(sessionId, actualModelName);
-      const thoughtSignature = cachedSig || getThoughtSignatureForModel(actualModelName);
-      parts.push({ text: ' ', thought: true });
-      parts.push({ text: ' ', thoughtSignature });
-    }
-    if (hasContent) parts.push({ text: textContent.trimEnd() });
-    parts.push(...toolCalls);
-    antigravityMessages.push({ role: 'model', parts });
+  const parts = [];
+  
+  if (enableThinking) {
+    parts.push(createThoughtPart(' ', reasoningSignature));
   }
+  if (hasContent) parts.push({ text: textContent.trimEnd() });
+
+  pushModelMessage({ parts, toolCalls, hasContent }, antigravityMessages);
 }
 
 function handleClaudeToolResult(message, antigravityMessages) {
@@ -96,21 +83,8 @@ function handleClaudeToolResult(message, antigravityMessages) {
     if (item.type !== 'tool_result') continue;
 
     const toolUseId = item.tool_use_id;
-    let functionName = '';
-    for (let i = antigravityMessages.length - 1; i >= 0; i--) {
-      if (antigravityMessages[i].role === 'model') {
-        const parts = antigravityMessages[i].parts;
-        for (const part of parts) {
-          if (part.functionCall && part.functionCall.id === toolUseId) {
-            functionName = part.functionCall.name;
-            break;
-          }
-        }
-        if (functionName) break;
-      }
-    }
+    const functionName = findFunctionNameById(toolUseId, antigravityMessages);
 
-    const lastMessage = antigravityMessages[antigravityMessages.length - 1];
     let resultContent = '';
     if (typeof item.content === 'string') {
       resultContent = item.content;
@@ -118,19 +92,7 @@ function handleClaudeToolResult(message, antigravityMessages) {
       resultContent = item.content.filter(c => c.type === 'text').map(c => c.text).join('');
     }
 
-    const functionResponse = {
-      functionResponse: {
-        id: toolUseId,
-        name: functionName,
-        response: { output: resultContent }
-      }
-    };
-
-    if (lastMessage?.role === 'user' && lastMessage.parts.some(p => p.functionResponse)) {
-      lastMessage.parts.push(functionResponse);
-    } else {
-      antigravityMessages.push({ role: 'user', parts: [functionResponse] });
-    }
+    pushFunctionResponse(toolUseId, functionName, resultContent, antigravityMessages);
   }
 }
 
@@ -143,7 +105,7 @@ function claudeMessageToAntigravity(claudeMessages, enableThinking, actualModelN
         handleClaudeToolResult(message, antigravityMessages);
       } else {
         const extracted = extractImagesFromClaudeContent(content);
-        handleClaudeUserMessage(extracted, antigravityMessages);
+        pushUserMessage(extracted, antigravityMessages);
       }
     } else if (message.role === 'assistant') {
       handleClaudeAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId);
@@ -152,65 +114,16 @@ function claudeMessageToAntigravity(claudeMessages, enableThinking, actualModelN
   return antigravityMessages;
 }
 
-function convertClaudeToolsToAntigravity(claudeTools, sessionId, actualModelName) {
-  if (!claudeTools || claudeTools.length === 0) return [];
-  return claudeTools.map((tool) => {
-    const rawParams = tool.input_schema || {};
-    const cleanedParams = cleanParameters(rawParams) || {};
-    if (cleanedParams.type === undefined) cleanedParams.type = 'object';
-    if (cleanedParams.type === 'object' && cleanedParams.properties === undefined) cleanedParams.properties = {};
-
-    const originalName = tool.name;
-    const safeName = sanitizeToolName(originalName);
-    if (sessionId && actualModelName && safeName !== originalName) {
-      setToolNameMapping(sessionId, actualModelName, safeName, originalName);
-    }
-
-    return {
-      functionDeclarations: [{
-        name: safeName,
-        description: tool.description || '',
-        parameters: cleanedParams
-      }]
-    };
-  });
-}
-
 export function generateClaudeRequestBody(claudeMessages, modelName, parameters, claudeTools, systemPrompt, token) {
   const enableThinking = isEnableThinking(modelName);
   const actualModelName = modelMapping(modelName);
-
-  const baseSystem = config.systemInstruction || '';
-  let mergedSystem = '';
-  if (config.useContextSystemPrompt && systemPrompt) {
-    const parts = [];
-    if (baseSystem.trim()) parts.push(baseSystem.trim());
-    if (systemPrompt.trim()) parts.push(systemPrompt.trim());
-    mergedSystem = parts.join('\n\n');
-  } else {
-    mergedSystem = baseSystem;
-  }
-
-  const requestBody = {
-    project: token.projectId,
-    requestId: generateRequestId(),
-    request: {
-      contents: claudeMessageToAntigravity(claudeMessages, enableThinking, actualModelName, token.sessionId),
-      tools: convertClaudeToolsToAntigravity(claudeTools, token.sessionId, actualModelName),
-      toolConfig: { functionCallingConfig: { mode: 'VALIDATED' } },
-      generationConfig: generateGenerationConfig(parameters, enableThinking, actualModelName),
-      sessionId: token.sessionId
-    },
-    model: actualModelName,
-    userAgent: 'antigravity'
-  };
-
-  if (mergedSystem) {
-    requestBody.request.systemInstruction = {
-      role: 'user',
-      parts: [{ text: mergedSystem }]
-    };
-  }
-
-  return requestBody;
+  const mergedSystem = mergeSystemInstruction(config.systemInstruction || '', systemPrompt);
+
+  return buildRequestBody({
+    contents: claudeMessageToAntigravity(claudeMessages, enableThinking, actualModelName, token.sessionId),
+    tools: convertClaudeToolsToAntigravity(claudeTools, token.sessionId, actualModelName),
+    generationConfig: generateGenerationConfig(parameters, enableThinking, actualModelName),
+    sessionId: token.sessionId,
+    systemInstruction: mergedSystem
+  }, token, actualModelName);
 }

src/utils/converters/common.js

@@ -0,0 +1,211 @@
+// 转换器公共模块
+import config from '../../config/config.js';
+import { generateRequestId } from '../idGenerator.js';
+import { getReasoningSignature, getToolSignature } from '../thoughtSignatureCache.js';
+import { setToolNameMapping } from '../toolNameCache.js';
+import { getThoughtSignatureForModel, getToolSignatureForModel, sanitizeToolName, modelMapping, isEnableThinking, generateGenerationConfig } from '../utils.js';
+
+/**
+ * 获取签名上下文
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Object} 包含思维签名和工具签名的对象
+ */
+export function getSignatureContext(sessionId, actualModelName) {
+  const cachedReasoningSig = getReasoningSignature(sessionId, actualModelName);
+  const cachedToolSig = getToolSignature(sessionId, actualModelName);
+  
+  return {
+    reasoningSignature: cachedReasoningSig || getThoughtSignatureForModel(actualModelName),
+    toolSignature: cachedToolSig || getToolSignatureForModel(actualModelName)
+  };
+}
+
+/**
+ * 添加用户消息到 antigravityMessages
+ * @param {Object} extracted - 提取的内容 { text, images }
+ * @param {Array} antigravityMessages - 目标消息数组
+ */
+export function pushUserMessage(extracted, antigravityMessages) {
+  antigravityMessages.push({
+    role: 'user',
+    parts: [{ text: extracted.text }, ...extracted.images]
+  });
+}
+
+/**
+ * 根据工具调用 ID 查找函数名
+ * @param {string} toolCallId - 工具调用 ID
+ * @param {Array} antigravityMessages - 消息数组
+ * @returns {string} 函数名
+ */
+export function findFunctionNameById(toolCallId, antigravityMessages) {
+  for (let i = antigravityMessages.length - 1; i >= 0; i--) {
+    if (antigravityMessages[i].role === 'model') {
+      const parts = antigravityMessages[i].parts;
+      for (const part of parts) {
+        if (part.functionCall && part.functionCall.id === toolCallId) {
+          return part.functionCall.name;
+        }
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * 添加函数响应到 antigravityMessages
+ * @param {string} toolCallId - 工具调用 ID
+ * @param {string} functionName - 函数名
+ * @param {string} resultContent - 响应内容
+ * @param {Array} antigravityMessages - 目标消息数组
+ */
+export function pushFunctionResponse(toolCallId, functionName, resultContent, antigravityMessages) {
+  const lastMessage = antigravityMessages[antigravityMessages.length - 1];
+  const functionResponse = {
+    functionResponse: {
+      id: toolCallId,
+      name: functionName,
+      response: { output: resultContent }
+    }
+  };
+
+  if (lastMessage?.role === 'user' && lastMessage.parts.some(p => p.functionResponse)) {
+    lastMessage.parts.push(functionResponse);
+  } else {
+    antigravityMessages.push({ role: 'user', parts: [functionResponse] });
+  }
+}
+
+/**
+ * 创建带签名的思维 part
+ * @param {string} text - 思维文本
+ * @param {string} signature - 签名
+ * @returns {Object} 思维 part
+ */
+export function createThoughtPart(text, signature) {
+  return { text: text || ' ', thought: true, thoughtSignature: signature };
+}
+
+/**
+ * 创建带签名的函数调用 part
+ * @param {string} id - 调用 ID
+ * @param {string} name - 函数名（已清理）
+ * @param {Object|string} args - 参数
+ * @param {string} signature - 签名（可选）
+ * @returns {Object} 函数调用 part
+ */
+export function createFunctionCallPart(id, name, args, signature = null) {
+  const part = {
+    functionCall: {
+      id,
+      name,
+      args: typeof args === 'string' ? { query: args } : args
+    }
+  };
+  if (signature) {
+    part.thoughtSignature = signature;
+  }
+  return part;
+}
+
+/**
+ * 处理工具名称映射
+ * @param {string} originalName - 原始名称
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {string} 清理后的安全名称
+ */
+export function processToolName(originalName, sessionId, actualModelName) {
+  const safeName = sanitizeToolName(originalName);
+  if (sessionId && actualModelName && safeName !== originalName) {
+    setToolNameMapping(sessionId, actualModelName, safeName, originalName);
+  }
+  return safeName;
+}
+
+/**
+ * 添加模型消息到 antigravityMessages
+ * @param {Object} options - 选项
+ * @param {Array} options.parts - 消息 parts
+ * @param {Array} options.toolCalls - 工具调用 parts
+ * @param {boolean} options.hasContent - 是否有文本内容
+ * @param {Array} antigravityMessages - 目标消息数组
+ */
+export function pushModelMessage({ parts, toolCalls, hasContent }, antigravityMessages) {
+  const lastMessage = antigravityMessages[antigravityMessages.length - 1];
+  const hasToolCalls = toolCalls && toolCalls.length > 0;
+
+  if (lastMessage?.role === 'model' && hasToolCalls && !hasContent) {
+    lastMessage.parts.push(...toolCalls);
+  } else {
+    const allParts = [...parts, ...(toolCalls || [])];
+    antigravityMessages.push({ role: 'model', parts: allParts });
+  }
+}
+
+/**
+ * 构建基础请求体
+ * @param {Object} options - 选项
+ * @param {Array} options.contents - 消息内容
+ * @param {Array} options.tools - 工具列表
+ * @param {Object} options.generationConfig - 生成配置
+ * @param {string} options.sessionId - 会话 ID
+ * @param {string} options.systemInstruction - 系统指令
+ * @param {Object} token - Token 对象
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Object} 请求体
+ */
+export function buildRequestBody({ contents, tools, generationConfig, sessionId, systemInstruction }, token, actualModelName) {
+  const requestBody = {
+    project: token.projectId,
+    requestId: generateRequestId(),
+    request: {
+      contents,
+      tools: tools || [],
+      toolConfig: { functionCallingConfig: { mode: 'VALIDATED' } },
+      generationConfig,
+      sessionId
+    },
+    model: actualModelName,
+    userAgent: 'antigravity'
+  };
+
+  if (systemInstruction) {
+    requestBody.request.systemInstruction = {
+      role: 'user',
+      parts: [{ text: systemInstruction }]
+    };
+  }
+
+  return requestBody;
+}
+
+/**
+ * 合并系统指令
+ * @param {string} baseSystem - 基础系统指令
+ * @param {string} contextSystem - 上下文系统指令
+ * @returns {string} 合并后的系统指令
+ */
+export function mergeSystemInstruction(baseSystem, contextSystem) {
+  if (!config.useContextSystemPrompt || !contextSystem) {
+    return baseSystem || '';
+  }
+  
+  const parts = [];
+  if (baseSystem && baseSystem.trim()) parts.push(baseSystem.trim());
+  if (contextSystem && contextSystem.trim()) parts.push(contextSystem.trim());
+  return parts.join('\n\n');
+}
+
+// 重导出常用函数
+export { sanitizeToolName, modelMapping, isEnableThinking, generateGenerationConfig };
+
+// 重导出参数规范化函数
+export {
+  normalizeOpenAIParameters,
+  normalizeClaudeParameters,
+  normalizeGeminiParameters,
+  normalizeParameters,
+  toGenerationConfig
+} from '../parameterNormalizer.js';

src/utils/converters/gemini.js

@@ -1,79 +1,152 @@
 // Gemini 格式转换工具
 import config from '../../config/config.js';
 import { generateRequestId } from '../idGenerator.js';
-import { getReasoningSignature } from '../thoughtSignatureCache.js';
-import { getThoughtSignatureForModel, modelMapping, isEnableThinking } from '../utils.js';
+import { convertGeminiToolsToAntigravity } from '../toolConverter.js';
+import { getSignatureContext, createThoughtPart, modelMapping, isEnableThinking } from './common.js';
+import { normalizeGeminiParameters, toGenerationConfig } from '../parameterNormalizer.js';
+
+/**
+ * 为 functionCall 生成唯一 ID
+ */
+function generateFunctionCallId() {
+  return `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * 处理 functionCall 和 functionResponse 的 ID 匹配
+ */
+function processFunctionCallIds(contents) {
+  const functionCallIds = [];
+  
+  // 收集所有 functionCall 的 ID
+  contents.forEach(content => {
+    if (content.role === 'model' && content.parts && Array.isArray(content.parts)) {
+      content.parts.forEach(part => {
+        if (part.functionCall) {
+          if (!part.functionCall.id) {
+            part.functionCall.id = generateFunctionCallId();
+          }
+          functionCallIds.push(part.functionCall.id);
+        }
+      });
+    }
+  });
+
+  // 为 functionResponse 分配对应的 ID
+  let responseIndex = 0;
+  contents.forEach(content => {
+    if (content.role === 'user' && content.parts && Array.isArray(content.parts)) {
+      content.parts.forEach(part => {
+        if (part.functionResponse) {
+          if (!part.functionResponse.id && responseIndex < functionCallIds.length) {
+            part.functionResponse.id = functionCallIds[responseIndex];
+            responseIndex++;
+          }
+        }
+      });
+    }
+  });
+}
+
+/**
+ * 处理 model 消息中的 thought 和签名
+ */
+function processModelThoughts(content, reasoningSignature, toolSignature) {
+  const parts = content.parts;
+  
+  // 查找 thought 和独立 thoughtSignature 的位置
+  let thoughtIndex = -1;
+  let signatureIndex = -1;
+  let signatureValue = null;
+  
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.thought === true && !part.thoughtSignature) {
+      thoughtIndex = i;
+    }
+    if (part.thoughtSignature && !part.thought) {
+      signatureIndex = i;
+      signatureValue = part.thoughtSignature;
+    }
+  }
+  
+  // 合并或添加 thought 和签名
+  if (thoughtIndex !== -1 && signatureIndex !== -1) {
+    parts[thoughtIndex].thoughtSignature = signatureValue;
+    parts.splice(signatureIndex, 1);
+  } else if (thoughtIndex !== -1 && signatureIndex === -1) {
+    parts[thoughtIndex].thoughtSignature = reasoningSignature;
+  } else if (thoughtIndex === -1) {
+    parts.unshift(createThoughtPart(' ', reasoningSignature));
+  }
+  
+  // 收集独立的签名 parts（用于 functionCall）
+  const standaloneSignatures = [];
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const part = parts[i];
+    if (part.thoughtSignature && !part.thought && !part.functionCall && !part.text) {
+      standaloneSignatures.unshift({ index: i, signature: part.thoughtSignature });
+    }
+  }
+  
+  // 为 functionCall 分配签名
+  let sigIndex = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.functionCall && !part.thoughtSignature) {
+      if (sigIndex < standaloneSignatures.length) {
+        part.thoughtSignature = standaloneSignatures[sigIndex].signature;
+        sigIndex++;
+      } else {
+        part.thoughtSignature = toolSignature;
+      }
+    }
+  }
+  
+  // 移除已使用的独立签名 parts
+  for (let i = standaloneSignatures.length - 1; i >= 0; i--) {
+    if (i < sigIndex) {
+      parts.splice(standaloneSignatures[i].index, 1);
+    }
+  }
+}
 
 export function generateGeminiRequestBody(geminiBody, modelName, token) {
   const enableThinking = isEnableThinking(modelName);
   const actualModelName = modelMapping(modelName);
-
   const request = JSON.parse(JSON.stringify(geminiBody));
 
   if (request.contents && Array.isArray(request.contents)) {
-    const functionCallIds = [];
-    request.contents.forEach(content => {
-      if (content.role === 'model' && content.parts && Array.isArray(content.parts)) {
-        content.parts.forEach(part => {
-          if (part.functionCall) {
-            if (!part.functionCall.id) {
-              part.functionCall.id = `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            }
-            functionCallIds.push(part.functionCall.id);
-          }
-        });
-      }
-    });
-
-    let responseIndex = 0;
-    request.contents.forEach(content => {
-      if (content.role === 'user' && content.parts && Array.isArray(content.parts)) {
-        content.parts.forEach(part => {
-          if (part.functionResponse) {
-            if (!part.functionResponse.id && responseIndex < functionCallIds.length) {
-              part.functionResponse.id = functionCallIds[responseIndex];
-              responseIndex++;
-            }
-          }
-        });
-      }
-    });
+    processFunctionCallIds(request.contents);
 
     if (enableThinking) {
-      const cachedSig = getReasoningSignature(token.sessionId, actualModelName);
-      const thoughtSignature = cachedSig || getThoughtSignatureForModel(actualModelName);
-
+      const { reasoningSignature, toolSignature } = getSignatureContext(token.sessionId, actualModelName);
+      
       request.contents.forEach(content => {
         if (content.role === 'model' && content.parts && Array.isArray(content.parts)) {
-          const hasThought = content.parts.some(p => p.thought === true);
-          if (!hasThought) {
-            content.parts.unshift(
-              { text: ' ', thought: true },
-              { text: ' ', thoughtSignature }
-            );
-          }
+          processModelThoughts(content, reasoningSignature, toolSignature);
         }
       });
     }
   }
 
-  if (!request.generationConfig) {
-    request.generationConfig = {};
-  }
-
-  if (enableThinking) {
-    const defaultThinkingBudget = config.defaults.thinking_budget ?? 1024;
-    if (!request.generationConfig.thinkingConfig) {
-      request.generationConfig.thinkingConfig = {
-        includeThoughts: true,
-        thinkingBudget: defaultThinkingBudget
-      };
-    }
-  }
-
-  request.generationConfig.candidateCount = 1;
+  // 使用统一参数规范化模块处理 Gemini 格式参数
+  const normalizedParams = normalizeGeminiParameters(request.generationConfig || {});
+  
+  // 转换为 generationConfig 格式
+  request.generationConfig = toGenerationConfig(normalizedParams, enableThinking, actualModelName);
   request.sessionId = token.sessionId;
   delete request.safetySettings;
+  
+  // 转换工具定义
+  if (request.tools && Array.isArray(request.tools)) {
+    request.tools = convertGeminiToolsToAntigravity(request.tools, token.sessionId, actualModelName);
+  }
+  
+  // 添加工具配置
+  if (request.tools && request.tools.length > 0 && !request.toolConfig) {
+    request.toolConfig = { functionCallingConfig: { mode: 'VALIDATED' } };
+  }
 
   const existingText = request.systemInstruction?.parts?.[0]?.text || '';
   const mergedText = existingText ? `${config.systemInstruction}\n\n${existingText}` : config.systemInstruction ?? "";

src/utils/converters/openai.js

@@ -1,9 +1,21 @@
 // OpenAI 格式转换工具
 import config from '../../config/config.js';
-import { generateRequestId } from '../idGenerator.js';
-import { getReasoningSignature, getToolSignature } from '../thoughtSignatureCache.js';
-import { setToolNameMapping } from '../toolNameCache.js';
-import { getThoughtSignatureForModel, getToolSignatureForModel, sanitizeToolName, cleanParameters, modelMapping, isEnableThinking, generateGenerationConfig, extractSystemInstruction } from '../utils.js';
+import { extractSystemInstruction } from '../utils.js';
+import { convertOpenAIToolsToAntigravity } from '../toolConverter.js';
+import {
+  getSignatureContext,
+  pushUserMessage,
+  findFunctionNameById,
+  pushFunctionResponse,
+  createThoughtPart,
+  createFunctionCallPart,
+  processToolName,
+  pushModelMessage,
+  buildRequestBody,
+  modelMapping,
+  isEnableThinking,
+  generateGenerationConfig
+} from './common.js';
 
 function extractImagesFromContent(content) {
   const result = { text: '', images: [] };
@@ -32,86 +44,33 @@ function extractImagesFromContent(content) {
   return result;
 }
 
-function handleUserMessage(extracted, antigravityMessages) {
-  antigravityMessages.push({
-    role: 'user',
-    parts: [{ text: extracted.text }, ...extracted.images]
-  });
-}
-
 function handleAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId) {
-  const lastMessage = antigravityMessages[antigravityMessages.length - 1];
   const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
   const hasContent = message.content && message.content.trim() !== '';
+  const { reasoningSignature, toolSignature } = getSignatureContext(sessionId, actualModelName);
 
-  const antigravityTools = hasToolCalls
+  const toolCalls = hasToolCalls
     ? message.tool_calls.map(toolCall => {
-        const originalName = toolCall.function.name;
-        const safeName = sanitizeToolName(originalName);
-        const part = {
-          functionCall: {
-            id: toolCall.id,
-            name: safeName,
-            args: { query: toolCall.function.arguments }
-          }
-        };
-        if (sessionId && actualModelName && safeName !== originalName) {
-          setToolNameMapping(sessionId, actualModelName, safeName, originalName);
-        }
-        if (enableThinking) {
-          const cachedToolSig = getToolSignature(sessionId, actualModelName);
-          part.thoughtSignature = toolCall.thoughtSignature || cachedToolSig || getToolSignatureForModel(actualModelName);
-        }
-        return part;
+        const safeName = processToolName(toolCall.function.name, sessionId, actualModelName);
+        const signature = enableThinking ? (toolCall.thoughtSignature || toolSignature) : null;
+        return createFunctionCallPart(toolCall.id, safeName, toolCall.function.arguments, signature);
       })
     : [];
 
-  if (lastMessage?.role === 'model' && hasToolCalls && !hasContent) {
-    lastMessage.parts.push(...antigravityTools);
-  } else {
-    const parts = [];
-    if (enableThinking) {
-      const cachedSig = getReasoningSignature(sessionId, actualModelName);
-      const thoughtSignature = message.thoughtSignature || cachedSig || getThoughtSignatureForModel(actualModelName);
-      const reasoningText = (typeof message.reasoning_content === 'string' && message.reasoning_content.length > 0) ? message.reasoning_content : ' ';
-      parts.push({ text: reasoningText, thought: true });
-      parts.push({ text: ' ', thoughtSignature });
-    }
-    if (hasContent) parts.push({ text: message.content.trimEnd() });
-    parts.push(...antigravityTools);
-    antigravityMessages.push({ role: 'model', parts });
+  const parts = [];
+  if (enableThinking) {
+    const reasoningText = (typeof message.reasoning_content === 'string' && message.reasoning_content.length > 0)
+      ? message.reasoning_content : ' ';
+    parts.push(createThoughtPart(reasoningText, message.thoughtSignature || reasoningSignature));
   }
+  if (hasContent) parts.push({ text: message.content.trimEnd() });
+
+  pushModelMessage({ parts, toolCalls, hasContent }, antigravityMessages);
 }
 
 function handleToolCall(message, antigravityMessages) {
-  let functionName = '';
-  for (let i = antigravityMessages.length - 1; i >= 0; i--) {
-    if (antigravityMessages[i].role === 'model') {
-      const parts = antigravityMessages[i].parts;
-      for (const part of parts) {
-        if (part.functionCall && part.functionCall.id === message.tool_call_id) {
-          functionName = part.functionCall.name;
-          break;
-        }
-      }
-      if (functionName) break;
-    }
-  }
-
-  const lastMessage = antigravityMessages[antigravityMessages.length - 1];
-  const functionResponse = {
-    functionResponse: {
-      id: message.tool_call_id,
-      name: functionName,
-      response: { output: message.content }
-    }
-  };
-
-  if (lastMessage?.role === 'user' && lastMessage.parts.some(p => p.functionResponse)) {
-    lastMessage.parts.push(functionResponse);
-  } else {
-    antigravityMessages.push({ role: 'user', parts: [functionResponse] });
-  }
+  const functionName = findFunctionNameById(message.tool_call_id, antigravityMessages);
+  pushFunctionResponse(message.tool_call_id, functionName, message.content, antigravityMessages);
 }
 
 function openaiMessageToAntigravity(openaiMessages, enableThinking, actualModelName, sessionId) {
@@ -119,7 +78,7 @@ function openaiMessageToAntigravity(openaiMessages, enableThinking, actualModelN
   for (const message of openaiMessages) {
     if (message.role === 'user' || message.role === 'system') {
       const extracted = extractImagesFromContent(message.content);
-      handleUserMessage(extracted, antigravityMessages);
+      pushUserMessage(extracted, antigravityMessages);
     } else if (message.role === 'assistant') {
       handleAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId);
     } else if (message.role === 'tool') {
@@ -129,34 +88,11 @@ function openaiMessageToAntigravity(openaiMessages, enableThinking, actualModelN
   return antigravityMessages;
 }
 
-function convertOpenAIToolsToAntigravity(openaiTools, sessionId, actualModelName) {
-  if (!openaiTools || openaiTools.length === 0) return [];
-  return openaiTools.map((tool) => {
-    const rawParams = tool.function?.parameters || {};
-    const cleanedParams = cleanParameters(rawParams) || {};
-    if (cleanedParams.type === undefined) cleanedParams.type = 'object';
-    if (cleanedParams.type === 'object' && cleanedParams.properties === undefined) cleanedParams.properties = {};
-
-    const originalName = tool.function?.name;
-    const safeName = sanitizeToolName(originalName);
-    if (sessionId && actualModelName && safeName !== originalName) {
-      setToolNameMapping(sessionId, actualModelName, safeName, originalName);
-    }
-
-    return {
-      functionDeclarations: [{
-        name: safeName,
-        description: tool.function.description,
-        parameters: cleanedParams
-      }]
-    };
-  });
-}
-
 export function generateRequestBody(openaiMessages, modelName, parameters, openaiTools, token) {
   const enableThinking = isEnableThinking(modelName);
   const actualModelName = modelMapping(modelName);
   const mergedSystemInstruction = extractSystemInstruction(openaiMessages);
+  
   let filteredMessages = openaiMessages;
   let startIndex = 0;
   if (config.useContextSystemPrompt) {
@@ -170,26 +106,11 @@ export function generateRequestBody(openaiMessages, modelName, parameters, opena
     }
   }
 
-  const requestBody = {
-    project: token.projectId,
-    requestId: generateRequestId(),
-    request: {
-      contents: openaiMessageToAntigravity(filteredMessages, enableThinking, actualModelName, token.sessionId),
-      tools: convertOpenAIToolsToAntigravity(openaiTools, token.sessionId, actualModelName),
-      toolConfig: { functionCallingConfig: { mode: 'VALIDATED' } },
-      generationConfig: generateGenerationConfig(parameters, enableThinking, actualModelName),
-      sessionId: token.sessionId
-    },
-    model: actualModelName,
-    userAgent: 'antigravity'
-  };
-
-  if (mergedSystemInstruction) {
-    requestBody.request.systemInstruction = {
-      role: 'user',
-      parts: [{ text: mergedSystemInstruction }]
-    };
-  }
-
-  return requestBody;
+  return buildRequestBody({
+    contents: openaiMessageToAntigravity(filteredMessages, enableThinking, actualModelName, token.sessionId),
+    tools: convertOpenAIToolsToAntigravity(openaiTools, token.sessionId, actualModelName),
+    generationConfig: generateGenerationConfig(parameters, enableThinking, actualModelName),
+    sessionId: token.sessionId,
+    systemInstruction: mergedSystemInstruction
+  }, token, actualModelName);
 }

src/utils/memoryManager.js

@@ -1,26 +1,41 @@
 /**
  * 智能内存管理器
  * 采用分级策略，根据内存压力动态调整缓存和对象池
- * 目标：在保证性能的前提下，将内存稳定在 20MB 左右
+ * 阈值基于用户配置的 memoryThreshold（MB）动态计算
  * @module utils/memoryManager
  */
 
 import logger from './logger.js';
-import { MEMORY_THRESHOLDS, GC_COOLDOWN } from '../constants/index.js';
+import { GC_COOLDOWN } from '../constants/index.js';
 
 /**
  * 内存压力级别枚举
  * @enum {string}
  */
 const MemoryPressure = {
-  LOW: 'low',       // < 15MB - 正常运行
-  MEDIUM: 'medium', // 15-25MB - 轻度清理
-  HIGH: 'high',     // 25-35MB - 积极清理
-  CRITICAL: 'critical' // > 35MB - 紧急清理
+  LOW: 'low',       // < 30% 阈值 - 正常运行
+  MEDIUM: 'medium', // 30%-60% 阈值 - 轻度清理
+  HIGH: 'high',     // 60%-100% 阈值 - 积极清理
+  CRITICAL: 'critical' // > 100% 阈值 - 紧急清理
 };
 
-// 使用导入的常量
-const THRESHOLDS = MEMORY_THRESHOLDS;
+/**
+ * 根据用户配置的内存阈值计算各级别阈值
+ * @param {number} thresholdMB - 用户配置的内存阈值（MB），即高压力阈值
+ * @returns {Object} 各级别阈值（字节）
+ */
+function calculateThresholds(thresholdMB) {
+  const highBytes = thresholdMB * 1024 * 1024;
+  return {
+    LOW: Math.floor(highBytes * 0.3),      // 30% 为低压力阈值
+    MEDIUM: Math.floor(highBytes * 0.6),   // 60% 为中等压力阈值
+    HIGH: highBytes,                        // 100% 为高压力阈值（用户配置值）
+    TARGET: Math.floor(highBytes * 0.5)    // 50% 为目标内存
+  };
+}
+
+// 默认阈值（100MB），会在初始化时被配置覆盖
+let THRESHOLDS = calculateThresholds(100);
 
 // 对象池最大大小配置（根据压力调整）
 const POOL_SIZES = {
@@ -45,6 +60,8 @@ class MemoryManager {
     this.gcCooldown = GC_COOLDOWN;
     this.checkInterval = null;
     this.isShuttingDown = false;
+    /** @type {number} 用户配置的内存阈值（MB） */
+    this.configuredThresholdMB = 100;
     
     // 统计信息
     this.stats = {
@@ -54,6 +71,31 @@ class MemoryManager {
     };
   }
 
+  /**
+   * 设置内存阈值（从配置加载）
+   * @param {number} thresholdMB - 内存阈值（MB）
+   */
+  setThreshold(thresholdMB) {
+    if (thresholdMB && thresholdMB > 0) {
+      this.configuredThresholdMB = thresholdMB;
+      THRESHOLDS = calculateThresholds(thresholdMB);
+      logger.info(`内存阈值已设置: ${thresholdMB}MB (LOW: ${Math.floor(THRESHOLDS.LOW/1024/1024)}MB, MEDIUM: ${Math.floor(THRESHOLDS.MEDIUM/1024/1024)}MB, HIGH: ${Math.floor(THRESHOLDS.HIGH/1024/1024)}MB)`);
+    }
+  }
+
+  /**
+   * 获取当前阈值配置
+   */
+  getThresholds() {
+    return {
+      configuredMB: this.configuredThresholdMB,
+      lowMB: Math.floor(THRESHOLDS.LOW / 1024 / 1024),
+      mediumMB: Math.floor(THRESHOLDS.MEDIUM / 1024 / 1024),
+      highMB: Math.floor(THRESHOLDS.HIGH / 1024 / 1024),
+      targetMB: Math.floor(THRESHOLDS.TARGET / 1024 / 1024)
+    };
+  }
+
   /**
    * 启动内存监控
    * @param {number} interval - 检查间隔（毫秒）
@@ -264,7 +306,8 @@ class MemoryManager {
       currentPressure: this.currentPressure,
       currentHeapMB: memory.heapUsedMB,
       peakMemoryMB: Math.round(this.stats.peakMemory / 1024 / 1024 * 10) / 10,
-      poolSizes: this.getPoolSizes()
+      poolSizes: this.getPoolSizes(),
+      thresholds: this.getThresholds()
     };
   }
 }

src/utils/parameterNormalizer.js

@@ -0,0 +1,189 @@
+// 统一参数处理模块
+// 将 OpenAI、Claude、Gemini 三种格式的参数统一转换为内部格式
+
+import config from '../config/config.js';
+import { REASONING_EFFORT_MAP } from '../constants/index.js';
+
+/**
+ * 内部统一参数格式
+ * @typedef {Object} NormalizedParameters
+ * @property {number} max_tokens - 最大输出 token 数
+ * @property {number} temperature - 温度
+ * @property {number} top_p - Top-P 采样
+ * @property {number} top_k - Top-K 采样
+ * @property {number|undefined} thinking_budget - 思考预算（undefined 表示使用默认值）
+ */
+
+/**
+ * 从 OpenAI 格式提取参数
+ * OpenAI 格式参数：
+ * - max_tokens: number
+ * - temperature: number
+ * - top_p: number
+ * - top_k: number (非标准，但支持)
+ * - thinking_budget: number (扩展)
+ * - reasoning_effort: 'low' | 'medium' | 'high' (扩展)
+ * 
+ * @param {Object} params - OpenAI 格式的参数对象
+ * @returns {NormalizedParameters}
+ */
+export function normalizeOpenAIParameters(params = {}) {
+  const normalized = {
+    max_tokens: params.max_tokens ?? config.defaults.max_tokens,
+    temperature: params.temperature ?? config.defaults.temperature,
+    top_p: params.top_p ?? config.defaults.top_p,
+    top_k: params.top_k ?? config.defaults.top_k,
+  };
+
+  // 处理思考预算
+  if (params.thinking_budget !== undefined) {
+    normalized.thinking_budget = params.thinking_budget;
+  } else if (params.reasoning_effort !== undefined) {
+    normalized.thinking_budget = REASONING_EFFORT_MAP[params.reasoning_effort];
+  }
+
+  return normalized;
+}
+
+/**
+ * 从 Claude 格式提取参数
+ * Claude 格式参数：
+ * - max_tokens: number
+ * - temperature: number
+ * - top_p: number
+ * - top_k: number
+ * - thinking: { type: 'enabled' | 'disabled', budget_tokens?: number }
+ * 
+ * @param {Object} params - Claude 格式的参数对象
+ * @returns {NormalizedParameters}
+ */
+export function normalizeClaudeParameters(params = {}) {
+  const { max_tokens, temperature, top_p, top_k, thinking, ...rest } = params;
+  
+  const normalized = {
+    max_tokens: max_tokens ?? config.defaults.max_tokens,
+    temperature: temperature ?? config.defaults.temperature,
+    top_p: top_p ?? config.defaults.top_p,
+    top_k: top_k ?? config.defaults.top_k,
+  };
+
+  // 处理 Claude 的 thinking 参数
+  // 格式: { "type": "enabled", "budget_tokens": 10000 } 或 { "type": "disabled" }
+  if (thinking && typeof thinking === 'object') {
+    if (thinking.type === 'enabled' && thinking.budget_tokens !== undefined) {
+      normalized.thinking_budget = thinking.budget_tokens;
+    } else if (thinking.type === 'disabled') {
+      // 显式禁用思考
+      normalized.thinking_budget = 0;
+    }
+  }
+
+  // 保留其他参数
+  Object.assign(normalized, rest);
+
+  return normalized;
+}
+
+/**
+ * 从 Gemini 格式提取参数
+ * Gemini 格式参数（在 generationConfig 中）：
+ * - temperature: number
+ * - topP: number
+ * - topK: number
+ * - maxOutputTokens: number
+ * - thinkingConfig: { includeThoughts: boolean, thinkingBudget?: number }
+ * 
+ * @param {Object} generationConfig - Gemini 格式的 generationConfig 对象
+ * @returns {NormalizedParameters}
+ */
+export function normalizeGeminiParameters(generationConfig = {}) {
+  const normalized = {
+    max_tokens: generationConfig.maxOutputTokens ?? config.defaults.max_tokens,
+    temperature: generationConfig.temperature ?? config.defaults.temperature,
+    top_p: generationConfig.topP ?? config.defaults.top_p,
+    top_k: generationConfig.topK ?? config.defaults.top_k,
+  };
+
+  // 处理 Gemini 的 thinkingConfig 参数
+  if (generationConfig.thinkingConfig && typeof generationConfig.thinkingConfig === 'object') {
+    if (generationConfig.thinkingConfig.includeThoughts === false) {
+      // 显式禁用思考
+      normalized.thinking_budget = 0;
+    } else if (generationConfig.thinkingConfig.thinkingBudget !== undefined) {
+      normalized.thinking_budget = generationConfig.thinkingConfig.thinkingBudget;
+    }
+  }
+
+  return normalized;
+}
+
+/**
+ * 自动检测格式并规范化参数
+ * @param {Object} params - 原始参数对象
+ * @param {'openai' | 'claude' | 'gemini'} format - API 格式
+ * @returns {NormalizedParameters}
+ */
+export function normalizeParameters(params, format) {
+  switch (format) {
+    case 'openai':
+      return normalizeOpenAIParameters(params);
+    case 'claude':
+      return normalizeClaudeParameters(params);
+    case 'gemini':
+      return normalizeGeminiParameters(params);
+    default:
+      return normalizeOpenAIParameters(params);
+  }
+}
+
+/**
+ * 将规范化参数转换为 Gemini generationConfig 格式
+ * @param {NormalizedParameters} normalized - 规范化后的参数
+ * @param {boolean} enableThinking - 是否启用思考
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Object} Gemini generationConfig 格式
+ */
+export function toGenerationConfig(normalized, enableThinking, actualModelName) {
+  const defaultThinkingBudget = config.defaults.thinking_budget ?? 1024;
+  let thinkingBudget = 0;
+  let actualEnableThinking = enableThinking;
+  
+  if (enableThinking) {
+    if (normalized.thinking_budget !== undefined) {
+      thinkingBudget = normalized.thinking_budget;
+      // 如果用户显式设置 thinking_budget = 0，则禁用思考
+      if (thinkingBudget === 0) {
+        actualEnableThinking = false;
+      }
+    } else {
+      thinkingBudget = defaultThinkingBudget;
+    }
+  }
+
+  const generationConfig = {
+    topP: normalized.top_p,
+    topK: normalized.top_k,
+    temperature: normalized.temperature,
+    candidateCount: 1,
+    maxOutputTokens: normalized.max_tokens,
+    thinkingConfig: {
+      includeThoughts: actualEnableThinking,
+      thinkingBudget: thinkingBudget
+    }
+  };
+
+  // Claude 模型在启用思考时不支持 topP
+  if (actualEnableThinking && actualModelName && actualModelName.includes('claude')) {
+    delete generationConfig.topP;
+  }
+
+  return generationConfig;
+}
+
+export default {
+  normalizeOpenAIParameters,
+  normalizeClaudeParameters,
+  normalizeGeminiParameters,
+  normalizeParameters,
+  toGenerationConfig
+};

src/utils/toolConverter.js

@@ -0,0 +1,128 @@
+// 工具转换公共模块
+import { sanitizeToolName, cleanParameters } from './utils.js';
+import { setToolNameMapping } from './toolNameCache.js';
+
+/**
+ * 将单个工具定义转换为 Antigravity 格式的 functionDeclaration
+ * @param {string} name - 工具名称
+ * @param {string} description - 工具描述
+ * @param {Object} parameters - 工具参数 schema
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Object} functionDeclaration 对象
+ */
+function convertSingleTool(name, description, parameters, sessionId, actualModelName) {
+  const originalName = name;
+  const safeName = sanitizeToolName(originalName);
+  
+  if (sessionId && actualModelName && safeName !== originalName) {
+    setToolNameMapping(sessionId, actualModelName, safeName, originalName);
+  }
+  
+  const rawParams = parameters || {};
+  const cleanedParams = cleanParameters(rawParams) || {};
+  if (cleanedParams.type === undefined) cleanedParams.type = 'object';
+  if (cleanedParams.type === 'object' && cleanedParams.properties === undefined) cleanedParams.properties = {};
+  
+  return {
+    name: safeName,
+    description: description || '',
+    parameters: cleanedParams
+  };
+}
+
+/**
+ * 将 OpenAI 格式的工具列表转换为 Antigravity 格式
+ * OpenAI 格式: [{ type: 'function', function: { name, description, parameters } }]
+ * @param {Array} openaiTools - OpenAI 格式的工具列表
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Array} Antigravity 格式的工具列表
+ */
+export function convertOpenAIToolsToAntigravity(openaiTools, sessionId, actualModelName) {
+  if (!openaiTools || openaiTools.length === 0) return [];
+  
+  return openaiTools.map((tool) => {
+    const func = tool.function || {};
+    const declaration = convertSingleTool(
+      func.name,
+      func.description,
+      func.parameters,
+      sessionId,
+      actualModelName
+    );
+    
+    return {
+      functionDeclarations: [declaration]
+    };
+  });
+}
+
+/**
+ * 将 Claude 格式的工具列表转换为 Antigravity 格式
+ * Claude 格式: [{ name, description, input_schema }]
+ * @param {Array} claudeTools - Claude 格式的工具列表
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Array} Antigravity 格式的工具列表
+ */
+export function convertClaudeToolsToAntigravity(claudeTools, sessionId, actualModelName) {
+  if (!claudeTools || claudeTools.length === 0) return [];
+  
+  return claudeTools.map((tool) => {
+    const declaration = convertSingleTool(
+      tool.name,
+      tool.description,
+      tool.input_schema,
+      sessionId,
+      actualModelName
+    );
+    
+    return {
+      functionDeclarations: [declaration]
+    };
+  });
+}
+
+/**
+ * 将 Gemini 格式的工具列表转换为 Antigravity 格式
+ * Gemini 格式可能是:
+ * 1. [{ functionDeclarations: [{ name, description, parameters }] }]
+ * 2. [{ name, description, parameters }]
+ * @param {Array} geminiTools - Gemini 格式的工具列表
+ * @param {string} sessionId - 会话 ID
+ * @param {string} actualModelName - 实际模型名称
+ * @returns {Array} Antigravity 格式的工具列表
+ */
+export function convertGeminiToolsToAntigravity(geminiTools, sessionId, actualModelName) {
+  if (!geminiTools || geminiTools.length === 0) return [];
+  
+  return geminiTools.map((tool) => {
+    // 格式1: 已经是 functionDeclarations 格式
+    if (tool.functionDeclarations) {
+      return {
+        functionDeclarations: tool.functionDeclarations.map(fd => 
+          convertSingleTool(fd.name, fd.description, fd.parameters, sessionId, actualModelName)
+        )
+      };
+    }
+    
+    // 格式2: 单个工具定义格式
+    if (tool.name) {
+      const declaration = convertSingleTool(
+        tool.name,
+        tool.description,
+        tool.parameters || tool.input_schema,
+        sessionId,
+        actualModelName
+      );
+      
+      return {
+        functionDeclarations: [declaration]
+      };
+    }
+    
+    // 未知格式，原样返回
+    return tool;
+  });
+}

src/utils/utils.js

@@ -2,6 +2,7 @@
 import config from '../config/config.js';
 import os from 'os';
 import { REASONING_EFFORT_MAP, DEFAULT_STOP_SEQUENCES } from '../constants/index.js';
+import { toGenerationConfig } from './parameterNormalizer.js';
 
 // ==================== 签名常量 ====================
 const CLAUDE_THOUGHT_SIGNATURE = 'RXFRRENrZ0lDaEFDR0FJcVFKV1Bvcy9GV20wSmtMV2FmWkFEbGF1ZTZzQTdRcFlTc1NvbklmemtSNFo4c1dqeitIRHBOYW9hS2NYTE1TeTF3bjh2T1RHdE1KVjVuYUNQclZ5cm9DMFNETHk4M0hOSWsrTG1aRUhNZ3hvTTl0ZEpXUDl6UUMzOExxc2ZJakI0UkkxWE1mdWJ1VDQrZnY0Znp0VEoyTlhtMjZKL2daYi9HL1gwcmR4b2x0VE54empLemtLcEp0ZXRia2plb3NBcWlRSWlXUHloMGhVVTk1dHNha1dyNDVWNUo3MTJjZDNxdHQ5Z0dkbjdFaFk4dUllUC9CcThVY2VZZC9YbFpYbDc2bHpEbmdzL2lDZXlNY3NuZXdQMjZBTDRaQzJReXdibVQzbXlSZmpld3ZSaUxxOWR1TVNidHIxYXRtYTJ0U1JIRjI0Z0JwUnpadE1RTmoyMjR4bTZVNUdRNXlOSWVzUXNFNmJzRGNSV0RTMGFVOEZERExybmhVQWZQT2JYMG5lTGR1QnU1VGZOWW9NZglRbTgyUHVqVE1xaTlmN0t2QmJEUUdCeXdyVXR2eUNnTEFHNHNqeWluZDRCOEg3N2ZJamt5blI3Q3ZpQzlIOTVxSENVTCt3K3JzMmsvV0sxNlVsbGlTK0pET3UxWXpPMWRPOUp3V3hEMHd5ZVU0a0Y5MjIxaUE5Z2lUd2djZXhSU2c4TWJVMm1NSjJlaGdlY3g0YjJ3QloxR0FFPQ==';
@@ -71,33 +72,19 @@ export function isEnableThinking(modelName) {
 
 // ==================== 生成配置 ====================
 export function generateGenerationConfig(parameters, enableThinking, actualModelName) {
-  const defaultThinkingBudget = config.defaults.thinking_budget ?? 1024;
-  let thinkingBudget = 0;
-  if (enableThinking) {
-    if (parameters.thinking_budget !== undefined) {
-      thinkingBudget = parameters.thinking_budget;
-    } else if (parameters.reasoning_effort !== undefined) {
-      thinkingBudget = REASONING_EFFORT_MAP[parameters.reasoning_effort] ?? defaultThinkingBudget;
-    } else {
-      thinkingBudget = defaultThinkingBudget;
-    }
-  }
-
-  const generationConfig = {
-    topP: parameters.top_p ?? config.defaults.top_p,
-    topK: parameters.top_k ?? config.defaults.top_k,
-    temperature: parameters.temperature ?? config.defaults.temperature,
-    candidateCount: 1,
-    maxOutputTokens: parameters.max_tokens ?? config.defaults.max_tokens,
-    stopSequences: DEFAULT_STOP_SEQUENCES,
-    thinkingConfig: {
-      includeThoughts: enableThinking,
-      thinkingBudget: thinkingBudget
-    }
-  };
-  if (enableThinking && actualModelName.includes('claude')) {
-    delete generationConfig.topP;
+  // 处理 reasoning_effort 到 thinking_budget 的转换
+  const normalizedParams = { ...parameters };
+  if (normalizedParams.thinking_budget === undefined && normalizedParams.reasoning_effort !== undefined) {
+    const defaultThinkingBudget = config.defaults.thinking_budget ?? 1024;
+    normalizedParams.thinking_budget = REASONING_EFFORT_MAP[normalizedParams.reasoning_effort] ?? defaultThinkingBudget;
   }
+  
+  // 使用统一的参数转换函数
+  const generationConfig = toGenerationConfig(normalizedParams, enableThinking, actualModelName);
+  
+  // 添加 stopSequences
+  generationConfig.stopSequences = DEFAULT_STOP_SEQUENCES;
+  
   return generationConfig;
 }