Merge pull request #67 from ZhaoShanGeng/binary-build

.github/workflows/docker-publish.yml

@@ -72,6 +72,7 @@ jobs:
           tags: |
             type=ref,event=branch,suffix=${{ matrix.tag_suffix }}
             type=raw,value=binary${{ matrix.tag_suffix }},enable=true
+            type=raw,value=latest${{ matrix.tag_suffix }},enable=${{ github.ref == 'refs/heads/binary-build' }}
 
       - name: Build and push (${{ matrix.arch }})
         uses: docker/build-push-action@v5

API.md

@@ -162,7 +162,7 @@ curl http://localhost:8045/v1/chat/completions \
 | `top_p` | number | ❌ | Top P 参数，默认 1 |
 | `top_k` | number | ❌ | Top K 参数，默认 50 |
 | `max_tokens` | number | ❌ | 最大 token 数，默认 32000 |
-| `thinking_budget` | number | ❌ | 思考预算（仅对思考模型生效），可为 0 或 1024-32000，默认 16000（0 表示关闭思考预算限制） |
+| `thinking_budget` | number | ❌ | 思考预算（仅对思考模型生效），可为 0 或 1024-32000，默认 1024（0 表示关闭思考预算限制） |
 | `reasoning_effort` | string | ❌ | 思维链强度（OpenAI 格式），可选值：`low`(1024)、`medium`(16000)、`high`(32000) |
 | `tools` | array | ❌ | 工具列表（Function Calling） |
 
@@ -246,8 +246,8 @@ curl http://localhost:8045/v1/chat/completions \
 
 | reasoning_effort | thinking_budget | 说明 |
 |-----------------|-----------------|------|
-| `low` | 1024 | 快速响应，适合简单问题 |
-| `medium` | 16000 | 平衡模式（默认） |
+| `low` | 1024 | 快速响应，适合简单问题（默认） |
+| `medium` | 16000 | 平衡模式 |
 | `high` | 32000 | 深度思考，适合复杂推理 |
 
 ### 使用 thinking_budget（直接数值）
@@ -505,6 +505,53 @@ for await (const chunk of stream) {
 }
 ```
 
+## 配置选项
+
+### passSignatureToClient
+
+控制是否将 `thoughtSignature` 透传到客户端响应中。
+
+在 `config.json` 中配置：
+
+```json
+{
+  "other": {
+    "passSignatureToClient": false
+  }
+}
+```
+
+- `false`（默认）：不透传签名，响应中不包含 `thoughtSignature` 字段
+- `true`：透传签名，响应中包含 `thoughtSignature` 字段
+
+**启用透传后的响应示例**：
+
+```json
+{
+  "choices": [{
+    "delta": {
+      "reasoning_content": "让我思考...",
+      "thoughtSignature": "RXFRRENrZ0lDaEFD..."
+    }
+  }]
+}
+```
+
+### useContextSystemPrompt
+
+控制是否将请求中的 system 消息合并到 SystemInstruction。
+
+```json
+{
+  "other": {
+    "useContextSystemPrompt": false
+  }
+}
+```
+
+- `false`（默认）：仅使用全局 `SYSTEM_INSTRUCTION` 环境变量
+- `true`：将请求开头连续的 system 消息与全局配置合并
+
 ## 注意事项
 
 1. 所有 `/v1/*` 请求必须携带有效的 API Key
@@ -515,3 +562,4 @@ for await (const chunk of stream) {
 6. 图片生成仅支持 `gemini-3-pro-image` 模型
 7. 模型列表会缓存 1 小时，可通过配置调整
 8. 思维链内容通过 `reasoning_content` 字段输出（兼容 DeepSeek 格式）
+9. 默认轮询策略为 `request_count`，每 50 次请求切换 Token

README.md

@@ -23,6 +23,8 @@
 - ✅ 隐私模式（自动隐藏敏感信息）
 - ✅ 内存优化（从 8+ 进程减少为 2 个进程，内存占用从 100MB+ 降为 50MB+）
 - ✅ 对象池复用（减少 50%+ 临时对象创建，降低 GC 频率）
+- ✅ 签名透传控制（可配置是否将 thoughtSignature 透传到客户端）
+- ✅ 预编译二进制文件（支持 Windows/Linux/Android，无需 Node.js 环境）
 
 ## 环境要求
 
@@ -75,6 +77,114 @@ npm start
 
 服务将在 `http://localhost:8045` 启动。
 
+## 二进制文件部署（推荐）
+
+无需安装 Node.js，直接下载预编译的二进制文件即可运行。
+
+### 下载二进制文件
+
+从 [GitHub Releases](https://github.com/ZhaoShanGeng/antigravity2api-nodejs/releases) 下载对应平台的二进制文件：
+
+| 平台 | 文件名 |
+|------|--------|
+| Windows x64 | `antigravity2api-win-x64.exe` |
+| Linux x64 | `antigravity2api-linux-x64` |
+| Linux ARM64 | `antigravity2api-linux-arm64` |
+| macOS x64 | `antigravity2api-macos-x64` |
+| macOS ARM64 | `antigravity2api-macos-arm64` |
+
+### 准备配置文件
+
+将以下文件放在二进制文件同目录下：
+
+```
+├── antigravity2api-win-x64.exe  # 二进制文件
+├── .env                          # 环境变量配置（必需）
+├── config.json                   # 基础配置（必需）
+├── public/                       # 静态文件目录（必需）
+│   ├── index.html
+│   ├── style.css
+│   ├── assets/
+│   │   └── bg.jpg
+│   └── js/
+│       ├── auth.js
+│       ├── config.js
+│       ├── main.js
+│       ├── quota.js
+│       ├── tokens.js
+│       ├── ui.js
+│       └── utils.js
+└── data/                         # 数据目录（自动创建）
+    └── accounts.json
+```
+
+### 配置环境变量
+
+创建 `.env` 文件：
+
+```env
+API_KEY=sk-your-api-key
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=admin123
+JWT_SECRET=your-jwt-secret-key-change-this-in-production
+# IMAGE_BASE_URL=http://your-domain.com
+# PROXY=http://127.0.0.1:7890
+```
+
+### 运行
+
+**Windows**：
+```bash
+# 直接双击运行，或在命令行执行
+antigravity2api-win-x64.exe
+```
+
+**Linux/macOS**：
+```bash
+# 添加执行权限
+chmod +x antigravity2api-linux-x64
+
+# 运行
+./antigravity2api-linux-x64
+```
+
+### 二进制部署说明
+
+- **无需 Node.js**：二进制文件已包含 Node.js 运行时
+- **配置文件**：`.env` 和 `config.json` 必须与二进制文件在同一目录
+- **静态文件**：`public/` 目录必须与二进制文件在同一目录
+- **数据持久化**：`data/` 目录会自动创建，用于存储 Token 数据
+- **跨平台**：支持 Windows、Linux、macOS（x64 和 ARM64）
+
+### 作为系统服务运行（Linux）
+
+创建 systemd 服务文件 `/etc/systemd/system/antigravity2api.service`：
+
+```ini
+[Unit]
+Description=Antigravity2API Service
+After=network.target
+
+[Service]
+Type=simple
+User=www-data
+WorkingDirectory=/opt/antigravity2api
+ExecStart=/opt/antigravity2api/antigravity2api-linux-x64
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+启动服务：
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable antigravity2api
+sudo systemctl start antigravity2api
+```
+
 ## Docker 部署
 
 ### 使用 Docker Compose（推荐）
@@ -365,7 +475,9 @@ curl http://localhost:8045/v1/chat/completions \
   "other": {
     "timeout": 300000,         // 请求超时时间（毫秒）
     "skipProjectIdFetch": false,// 跳过 ProjectId 获取，直接随机生成（仅 Pro 账号有效）
-    "useNativeAxios": false    // 使用原生 axios 而非 AntigravityRequester
+    "useNativeAxios": false,   // 使用原生 axios 而非 AntigravityRequester
+    "useContextSystemPrompt": false, // 是否将请求中的 system 消息合并到 SystemInstruction
+    "passSignatureToClient": false   // 是否将 thoughtSignature 透传到客户端
   }
 }
 ```
@@ -375,8 +487,8 @@ curl http://localhost:8045/v1/chat/completions \
 | 策略 | 说明 |
 |------|------|
 | `round_robin` | 均衡负载：每次请求后切换到下一个 Token |
-| `quota_exhausted` | 额度耗尽才切换：持续使用当前 Token 直到额度用完 |
-| `request_count` | 自定义次数：每个 Token 使用指定次数后切换 |
+| `quota_exhausted` | 额度耗尽才切换：持续使用当前 Token 直到额度用完（高性能优化） |
+| `request_count` | 自定义次数：每个 Token 使用指定次数后切换（默认策略） |
 
 ### 2. .env（敏感配置）
 
@@ -425,10 +537,12 @@ npm run login
 │   └── refresh-tokens.js   # Token 刷新脚本
 ├── src/
 │   ├── api/
-│   │   └── client.js       # API 调用逻辑（含模型列表缓存）
+│   │   ├── client.js       # API 调用逻辑（含模型列表缓存）
+│   │   └── stream_parser.js # 流式响应解析（对象池优化）
 │   ├── auth/
 │   │   ├── jwt.js          # JWT 认证
 │   │   ├── token_manager.js # Token 管理（含轮询策略）
+│   │   ├── token_store.js  # Token 文件存储（异步读写）
 │   │   └── quota_manager.js # 额度缓存管理
 │   ├── routes/
 │   │   ├── admin.js        # 管理接口路由
@@ -441,6 +555,7 @@ npm run login
 │   │   ├── config.js       # 配置加载
 │   │   └── init-env.js     # 环境变量初始化
 │   ├── constants/
+│   │   ├── index.js        # 应用常量定义
 │   │   └── oauth.js        # OAuth 常量
 │   ├── server/
 │   │   └── index.js        # 主服务器（含内存管理和心跳）
@@ -448,10 +563,19 @@ npm run login
 │   │   ├── configReloader.js # 配置热重载
 │   │   ├── deepMerge.js    # 深度合并工具
 │   │   ├── envParser.js    # 环境变量解析
+│   │   ├── errors.js       # 统一错误处理
 │   │   ├── idGenerator.js  # ID 生成器
 │   │   ├── imageStorage.js # 图片存储
 │   │   ├── logger.js       # 日志模块
-│   │   └── utils.js        # 工具函数
+│   │   ├── memoryManager.js # 智能内存管理
+│   │   ├── openai_generation.js # 生成配置
+│   │   ├── openai_mapping.js    # 请求体构建
+│   │   ├── openai_messages.js   # 消息格式转换
+│   │   ├── openai_signatures.js # 签名常量
+│   │   ├── openai_system.js     # 系统指令提取
+│   │   ├── openai_tools.js      # 工具格式转换
+│   │   ├── paths.js        # 路径工具（支持 pkg 打包）
+│   │   └── utils.js        # 工具函数（重导出）
 │   └── AntigravityRequester.js # TLS 指纹请求器封装
 ├── test/
 │   ├── test-request.js     # 请求测试

config.json

@@ -7,7 +7,7 @@
     "memoryThreshold": 25
   },
   "rotation": {
-    "strategy": "round_robin",
+    "strategy": "request_count",
     "requestCount": 50
   },
   "api": {
@@ -32,6 +32,7 @@
     "retryTimes": 3,
     "skipProjectIdFetch": false,
     "useNativeAxios": false,
-    "useContextSystemPrompt": false
+    "useContextSystemPrompt": false,
+    "passSignatureToClient": false
   }
 }

package.json

@@ -47,7 +47,10 @@
       "scripts/**/*.js"
     ],
     "assets": [
-      "public/**/*",
+      "public/*.html",
+      "public/*.css",
+      "public/js/**/*",
+      "public/assets/**/*",
       "src/bin/**/*",
       ".env.example",
       "config.json"

public/index.html

@@ -4,21 +4,61 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
     <title>Token 管理</title>
-    <!-- 引入 MiSans 字体 -->
-    <link rel="stylesheet" href="https://font.sec.miui.com/font/css?family=MiSans:100,200,300,400,450,500,600,650,700,900:Chinese_Simplify,Latin&display=swap">
-    <!-- 引入 Ubuntu Mono 等宽字体 -->
-    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Ubuntu+Mono:wght@400;700&display=swap">
-    <link rel="stylesheet" href="style.css">
+    <!-- 防止页面闪烁：在渲染前根据登录状态和Tab状态设置初始显示 -->
     <script>
-        // 页面加载前检查登录状态，避免闪现
-        if (localStorage.getItem('authToken')) {
-            document.documentElement.classList.add('logged-in');
-        }
+        (function() {
+            var isLoggedIn = localStorage.getItem('authToken');
+            var currentTab = localStorage.getItem('currentTab') || 'tokens';
+            var classes = ['auth-ready'];
+            if (isLoggedIn) classes.push('logged-in');
+            if (currentTab === 'settings') classes.push('tab-settings');
+            document.documentElement.className = classes.join(' ');
+            // 检测字体加载
+            if ('fonts' in document) {
+                document.fonts.ready.then(function() {
+                    document.documentElement.classList.add('fonts-loaded');
+                });
+            } else {
+                // 后备方案：延迟添加
+                setTimeout(function() {
+                    document.documentElement.classList.add('fonts-loaded');
+                }, 1000);
+            }
+        })();
     </script>
     <style>
-        .logged-in #loginForm { display: none !important; }
-        .logged-in #mainContent { display: flex !important; }
+/* 防止闪烁的关键样式 - 来自 binary-build */
+html:not(.auth-ready) #loginForm,
+html:not(.auth-ready) #mainContent { visibility: hidden; }
+/* 登录状态显示控制 - 合并两个分支 *
+.logged-in #loginForm { display: none !important; }
+.logged-in #mainContent { display: flex !important; }
+html:not(.logged-in) #mainContent { display: none !important; }
+/* Tab状态管理 - 来自 binary-build */
+html.tab-settings #tokensPage { display: none !important; }
+html.tab-settings #settingsPage { display: block !important; }
+html.tab-settings .tab[data-tab="tokens"] { 
+    background: transparent !important;
+    color: var(--text-light, #888) !important; 
+}
+html.tab-settings .tab[data-tab="settings"] { 
+    background: var(--primary, #4f46e5) !important; 
+    color: white !important; 
+}
     </style>
+    <!-- 主样式表 - 优先加载 -->
+    <link rel="stylesheet" href="style.css">
+    <!-- 预连接字体服务器 -->
+    <link rel="preconnect" href="https://font.sec.miui.com" crossorigin>
+    <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <!-- 字体异步加载 - 不阻塞渲染 -->
+    <link rel="stylesheet" href="https://font.sec.miui.com/font/css?family=MiSans:400,500,600,700:Chinese_Simplify,Latin&display=swap" media="print" onload="this.media='all'">
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Ubuntu+Mono:wght@400;700&display=swap" media="print" onload="this.media='all'">
+    <noscript>
+        <link rel="stylesheet" href="https://font.sec.miui.com/font/css?family=MiSans:400,500,600,700:Chinese_Simplify,Latin&display=swap">
+        <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Ubuntu+Mono:wght@400;700&display=swap">
+    </noscript>
 </head>
 <body>
     <div class="container">
@@ -42,11 +82,10 @@
         <div id="mainContent" class="main-content hidden">
             <div class="header">
             <div class="tabs">
-                <button class="tab active" onclick="switchTab('tokens')">🎯 Token</button>
-                <button class="tab" onclick="switchTab('settings')">⚙️ 设置</button>
+                <button class="tab active" data-tab="tokens" onclick="switchTab('tokens')">🎯 Token</button>
+                <button class="tab" data-tab="settings" onclick="switchTab('settings')">⚙️ 设置</button>
             </div>
                 <div class="header-right">
-                    <span class="server-info" id="serverInfo"></span>
                     <button onclick="logout()">🚪 退出</button>
                 </div>
             </div>
@@ -175,6 +214,13 @@
                                             <span class="slider"></span>
                                         </label>
                                     </div>
+                                    <div class="form-group compact switch-group">
+                                        <label>透传签名 <span class="help-tip" data-tooltip="将响应中的thoughtSignature透传到客户端">?</span></label>
+                                        <label class="switch">
+                                            <input type="checkbox" name="PASS_SIGNATURE_TO_CLIENT">
+                                            <span class="slider"></span>
+                                        </label>
+                                    </div>
                                 </div>
                                 <div class="form-group compact">
                                     <label>系统提示词</label>
@@ -244,12 +290,12 @@
     </div>
 
     <!-- 按依赖顺序加载模块 -->
-    <script src="js/utils.js"></script>
-    <script src="js/ui.js"></script>
-    <script src="js/auth.js"></script>
-    <script src="js/quota.js"></script>
-    <script src="js/tokens.js"></script>
-    <script src="js/config.js"></script>
-    <script src="js/main.js"></script>
+    <script src="js/utils.js" defer></script>
+    <script src="js/ui.js" defer></script>
+    <script src="js/auth.js" defer></script>
+    <script src="js/quota.js" defer></script>
+    <script src="js/tokens.js" defer></script>
+    <script src="js/config.js" defer></script>
+    <script src="js/main.js" defer></script>
 </body>
 </html>

public/js/config.js

@@ -46,11 +46,6 @@ async function loadConfig() {
             const form = document.getElementById('configForm');
             const { env, json } = data.data;
             
-            const serverInfo = document.getElementById('serverInfo');
-            if (serverInfo && json.server) {
-                serverInfo.textContent = `${json.server.host || '0.0.0.0'}:${json.server.port || 8045}`;
-            }
-            
             Object.entries(env).forEach(([key, value]) => {
                 const input = form.elements[key];
                 if (input) input.value = value || '';
@@ -76,6 +71,7 @@ async function loadConfig() {
                 if (form.elements['SKIP_PROJECT_ID_FETCH']) form.elements['SKIP_PROJECT_ID_FETCH'].checked = json.other.skipProjectIdFetch || false;
                 if (form.elements['USE_NATIVE_AXIOS']) form.elements['USE_NATIVE_AXIOS'].checked = json.other.useNativeAxios !== false;
                 if (form.elements['USE_CONTEXT_SYSTEM_PROMPT']) form.elements['USE_CONTEXT_SYSTEM_PROMPT'].checked = json.other.useContextSystemPrompt || false;
+                if (form.elements['PASS_SIGNATURE_TO_CLIENT']) form.elements['PASS_SIGNATURE_TO_CLIENT'].checked = json.other.passSignatureToClient || false;
             }
             if (json.rotation) {
                 if (form.elements['ROTATION_STRATEGY']) {
@@ -114,6 +110,7 @@ async function saveConfig(e) {
     jsonConfig.other.skipProjectIdFetch = form.elements['SKIP_PROJECT_ID_FETCH']?.checked || false;
     jsonConfig.other.useNativeAxios = form.elements['USE_NATIVE_AXIOS']?.checked || false;
     jsonConfig.other.useContextSystemPrompt = form.elements['USE_CONTEXT_SYSTEM_PROMPT']?.checked || false;
+    jsonConfig.other.passSignatureToClient = form.elements['PASS_SIGNATURE_TO_CLIENT']?.checked || false;
     
     Object.entries(allConfig).forEach(([key, value]) => {
         if (sensitiveKeys.includes(key)) {
@@ -137,7 +134,7 @@ async function saveConfig(e) {
                 const num = parseInt(value);
                 jsonConfig.other.retryTimes = Number.isNaN(num) ? undefined : num;
             }
-            else if (key === 'SKIP_PROJECT_ID_FETCH' || key === 'USE_NATIVE_AXIOS' || key === 'USE_CONTEXT_SYSTEM_PROMPT') {
+            else if (key === 'SKIP_PROJECT_ID_FETCH' || key === 'USE_NATIVE_AXIOS' || key === 'USE_CONTEXT_SYSTEM_PROMPT' || key === 'PASS_SIGNATURE_TO_CLIENT') {
                 // 跳过，已在上面处理
             }
             else if (key === 'ROTATION_STRATEGY') jsonConfig.rotation.strategy = value || undefined;

public/js/main.js

@@ -7,8 +7,12 @@ initSensitiveInfo();
 // 如果已登录，显示主内容
 if (authToken) {
     showMainContent();
+    restoreTabState(); // 恢复Tab状态
     loadTokens();
-    loadConfig();
+    // 只有在设置页面时才加载配置
+    if (localStorage.getItem('currentTab') === 'settings') {
+        loadConfig();
+    }
 }
 
 // 登录表单提交

public/js/ui.js

@@ -52,17 +52,45 @@ function hideLoading() {
     if (overlay) overlay.remove();
 }
 
-function switchTab(tab) {
+function switchTab(tab, saveState = true) {
+    // 更新html元素的class以防止闪烁
+    if (tab === 'settings') {
+        document.documentElement.classList.add('tab-settings');
+    } else {
+        document.documentElement.classList.remove('tab-settings');
+    }
+    
+    // 移除所有tab的active状态
     document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-    event.target.classList.add('active');
     
+    // 找到对应的tab按钮并激活
+    const targetTab = document.querySelector(`.tab[data-tab="${tab}"]`);
+    if (targetTab) {
+        targetTab.classList.add('active');
+    }
+    
+    // 隐藏所有页面
     document.getElementById('tokensPage').classList.add('hidden');
     document.getElementById('settingsPage').classList.add('hidden');
     
+    // 显示对应页面
     if (tab === 'tokens') {
         document.getElementById('tokensPage').classList.remove('hidden');
     } else if (tab === 'settings') {
         document.getElementById('settingsPage').classList.remove('hidden');
         loadConfig();
     }
+    
+    // 保存当前Tab状态到localStorage
+    if (saveState) {
+        localStorage.setItem('currentTab', tab);
+    }
+}
+
+// 恢复Tab状态
+function restoreTabState() {
+    const savedTab = localStorage.getItem('currentTab');
+    if (savedTab && (savedTab === 'tokens' || savedTab === 'settings')) {
+        switchTab(savedTab, false);
+    }
 }

public/style.css

@@ -26,7 +26,7 @@
 
 * { margin: 0; padding: 0; box-sizing: border-box; }
 
-/* 固定背景图片 - 使用静态风景图（清晰无模糊） */
+/* 固定背景图片 - 使用本地图片（快速加载） */
 body::before {
     content: '';
     position: fixed;
@@ -34,7 +34,8 @@ body::before {
     left: 0;
     right: 0;
     bottom: 0;
-    background-image: url('https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=1920&q=80');
+    background-color: var(--bg);
+    background-image: url('assets/bg.jpg');
     background-size: cover;
     background-position: center;
     background-repeat: no-repeat;
@@ -88,7 +89,7 @@ html {
     font-size: var(--font-size-base);
 }
 body {
-    font-family: 'Ubuntu Mono', 'MiSans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, 'Noto Sans', sans-serif, 'Ubuntu Mono', 'MiSans';
     background: var(--bg);
     color: var(--text);
     line-height: 1.5;
@@ -102,6 +103,11 @@ body {
     font-weight: 400;
 }
 
+/* 字体加载完成后应用 */
+.fonts-loaded body {
+    font-family: 'Ubuntu Mono', 'MiSans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+
 /* 确保所有元素继承字体 */
 *, *::before, *::after {
     font-family: inherit;
@@ -161,16 +167,16 @@ label {
     color: var(--text); 
     font-size: 0.875rem; 
 }
-input, select, textarea { 
-    width: 100%; 
-    min-height: 40px; 
-    padding: 0.5rem 0.75rem 0.5rem 0.5rem !important; 
-    border: 1.5px solid var(--border); 
-    border-radius: 0.5rem; 
-    font-size: 0.875rem; 
-    background: var(--card); 
-    color: var(--text); 
-    transition: all 0.2s; 
+input, select, textarea {
+    width: 100%;
+    min-height: 40px;
+    padding: 0.5rem 0.75rem;
+    border: 1.5px solid var(--border);
+    border-radius: 0.5rem;
+    font-size: 0.875rem;
+    background: var(--card);
+    color: var(--text);
+    transition: all 0.2s;
 }
 input:focus, select:focus, textarea:focus {
     outline: none;
@@ -493,7 +499,7 @@ button.loading::after {
 .inline-edit-input {
     flex: 1;
     min-height: 24px;
-    padding: 0.125rem 0.375rem 0.125rem 0.5rem;
+    padding: 0.125rem 0.375rem;
     font-size: 0.75rem;
     border: 1px solid var(--primary);
     border-radius: 0.25rem;
@@ -607,13 +613,13 @@ button.loading::after {
 .form-group.compact input,
 .form-group.compact select {
     min-height: 36px;
-    padding: 0.375rem 0.5rem 0.375rem 0.75rem;
+    padding: 0.375rem 0.5rem;
     font-size: 0.8rem;
 }
 .form-group.compact textarea {
     min-height: 60px;
     max-height: 300px;
-    padding: 0.375rem 0.5rem 0.375rem 0.75rem;
+    padding: 0.375rem 0.5rem;
     font-size: 0.8rem;
     resize: vertical;
     height: auto;

scripts/build.js

@@ -98,8 +98,9 @@ const pkgJson = {
   pkg: {
     assets: [
       toSlash(path.join(rootDir, 'public', '*.html')),
-      toSlash(path.join(rootDir, 'public', '*.js')),
       toSlash(path.join(rootDir, 'public', '*.css')),
+      toSlash(path.join(rootDir, 'public', 'js', '*.js')),
+      toSlash(path.join(rootDir, 'public', 'assets', '*')),
       toSlash(path.join(rootDir, 'src', 'bin', '*'))
     ]
   }
@@ -189,18 +190,12 @@ try {
     if (fs.existsSync(publicDestDir)) {
       fs.rmSync(publicDestDir, { recursive: true, force: true });
     }
-    fs.mkdirSync(publicDestDir, { recursive: true });
-    const publicFiles = fs.readdirSync(publicSrcDir);
-    for (const file of publicFiles) {
-      if (file === 'images') continue; // 跳过 images 目录
-      const srcPath = path.join(publicSrcDir, file);
-      const destPath = path.join(publicDestDir, file);
-      const stat = fs.statSync(srcPath);
-      if (stat.isFile()) {
-        fs.copyFileSync(srcPath, destPath);
-      } else if (stat.isDirectory()) {
-        fs.cpSync(srcPath, destPath, { recursive: true });
-      }
+    // 直接全复制 public 目录
+    fs.cpSync(publicSrcDir, publicDestDir, { recursive: true });
+    // 删除 images 目录（运行时生成，不需要打包）
+    const imagesDir = path.join(publicDestDir, 'images');
+    if (fs.existsSync(imagesDir)) {
+      fs.rmSync(imagesDir, { recursive: true, force: true });
     }
     console.log('  ✓ Copied public directory');
   }

src/api/client.js

@@ -1,9 +1,19 @@
 import tokenManager from '../auth/token_manager.js';
 import config from '../config/config.js';
-import { generateToolCallId } from '../utils/idGenerator.js';
 import AntigravityRequester from '../AntigravityRequester.js';
 import { saveBase64Image } from '../utils/imageStorage.js';
 import logger from '../utils/logger.js';
+import memoryManager, { MemoryPressure } from '../utils/memoryManager.js';
+import { buildAxiosRequestConfig } from '../utils/httpClient.js';
+import { MODEL_LIST_CACHE_TTL } from '../constants/index.js';
+import { createApiError, UpstreamApiError } from '../utils/errors.js';
+import {
+  getLineBuffer,
+  releaseLineBuffer,
+  parseAndEmitStreamChunk,
+  convertToToolCall,
+  registerStreamMemoryCleanup
+} from './stream_parser.js';
 import memoryManager, { MemoryPressure, registerMemoryPoolCleanup } from '../utils/memoryManager.js';
 import { buildAxiosRequestConfig, httpRequest, httpStreamRequest } from '../utils/httpClient.js';
 import { setReasoningSignature, setToolSignature } from '../utils/thoughtSignatureCache.js';
@@ -16,7 +26,7 @@ let useAxios = false;
 // ==================== 模型列表缓存（智能管理） ====================
 // 缓存过期时间根据内存压力动态调整
 const getModelCacheTTL = () => {
-  const baseTTL = config.cache?.modelListTTL || 60 * 60 * 1000;
+  const baseTTL = config.cache?.modelListTTL || MODEL_LIST_CACHE_TTL;
   const pressure = memoryManager.currentPressure;
   // 高压力时缩短缓存时间
   if (pressure === MemoryPressure.CRITICAL) return Math.min(baseTTL, 5 * 60 * 1000);
@@ -71,75 +81,10 @@ if (config.useNativeAxios === true) {
   }
 }
 
-// ==================== 零拷贝优化 ====================
-
-// 预编译的常量（避免重复创建字符串）
-const DATA_PREFIX = 'data: ';
-const DATA_PREFIX_LEN = DATA_PREFIX.length;
-
-// 高效的行分割器（零拷贝，避免 split 创建新数组）
-// 使用对象池复用 LineBuffer 实例
-class LineBuffer {
-  constructor() {
-    this.buffer = '';
-    this.lines = [];
-  }
-  
-  // 追加数据并返回完整的行
-  append(chunk) {
-    this.buffer += chunk;
-    this.lines.length = 0; // 重用数组
-    
-    let start = 0;
-    let end;
-    while ((end = this.buffer.indexOf('\n', start)) !== -1) {
-      this.lines.push(this.buffer.slice(start, end));
-      start = end + 1;
-    }
-    
-    // 保留未完成的部分
-    this.buffer = start < this.buffer.length ? this.buffer.slice(start) : '';
-    return this.lines;
-  }
-  
-  // 清空缓冲区（用于归还到池之前）
-  clear() {
-    this.buffer = '';
-    this.lines.length = 0;
-  }
-}
-
-// LineBuffer 对象池
-const lineBufferPool = [];
-const getLineBuffer = () => {
-  const buffer = lineBufferPool.pop();
-  if (buffer) {
-    buffer.clear();
-    return buffer;
-  }
-  return new LineBuffer();
-};
-const releaseLineBuffer = (buffer) => {
-  const maxSize = memoryManager.getPoolSizes().lineBuffer;
-  if (lineBufferPool.length < maxSize) {
-    buffer.clear();
-    lineBufferPool.push(buffer);
-  }
-};
-
-// 对象池：复用 toolCall 对象
-const toolCallPool = [];
-const getToolCallObject = () => toolCallPool.pop() || { id: '', type: 'function', function: { name: '', arguments: '' } };
-const releaseToolCallObject = (obj) => {
-  const maxSize = memoryManager.getPoolSizes().toolCall;
-  if (toolCallPool.length < maxSize) toolCallPool.push(obj);
-};
-
-// 注册内存清理回调
+// 注册对象池与模型缓存的内存清理回调
 function registerMemoryCleanup() {
-  // 使用通用池清理工具，避免重复 while-pop 逻辑
-  registerMemoryPoolCleanup(toolCallPool, () => memoryManager.getPoolSizes().toolCall);
-  registerMemoryPoolCleanup(lineBufferPool, () => memoryManager.getPoolSizes().lineBuffer);
+  // 由流式解析模块管理自身对象池大小
+  registerStreamMemoryCleanup();
 
   memoryManager.registerCleanup((pressure) => {
     // 高压力或紧急时清理模型缓存
@@ -153,7 +98,6 @@ function registerMemoryCleanup() {
       }
     }
     
-    // 紧急时强制清理模型缓存
     if (pressure === MemoryPressure.CRITICAL && modelListCache) {
       modelListCache = null;
       modelListCacheTime = 0;
@@ -188,14 +132,6 @@ 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) {
@@ -225,88 +161,6 @@ async function handleApiError(error, token) {
   throw createApiError(`API请求失败 (${status}): ${errorBody}`, status, errorBody);
 }
 
-// 转换 functionCall 为 OpenAI 格式（使用对象池）
-// 会尝试将安全工具名还原为原始工具名
-function convertToToolCall(functionCall, sessionId, model) {
-  const toolCall = getToolCallObject();
-  toolCall.id = functionCall.id || generateToolCallId();
-  let name = functionCall.name;
-  if (sessionId && model) {
-    const original = getOriginalToolName(sessionId, model, functionCall.name);
-    if (original) name = original;
-  }
-  toolCall.function.name = name;
-  toolCall.function.arguments = JSON.stringify(functionCall.args);
-  return toolCall;
-}
-
-// 解析并发送流式响应片段（会修改 state 并触发 callback）
-// 支持 DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
-// 同时透传 thoughtSignature，方便客户端后续复用
-function parseAndEmitStreamChunk(line, state, callback) {
-  if (!line.startsWith(DATA_PREFIX)) return;
-  
-  try {
-    const data = JSON.parse(line.slice(DATA_PREFIX_LEN));
-    //console.log(JSON.stringify(data));
-    const parts = data.response?.candidates?.[0]?.content?.parts;
-    
-    if (parts) {
-      for (const part of parts) {
-        if (part.thought === true) {
-          // 思维链内容 - 使用 DeepSeek 格式的 reasoning_content
-          // 缓存最新的签名，方便后续片段缺省时复用，并写入全局缓存
-          if (part.thoughtSignature) {
-            state.reasoningSignature = part.thoughtSignature;
-            if (state.sessionId && state.model) {
-              setReasoningSignature(state.sessionId, state.model, part.thoughtSignature);
-            }
-          }
-          callback({
-            type: 'reasoning',
-            reasoning_content: part.text || '',
-            thoughtSignature: part.thoughtSignature || state.reasoningSignature || null
-          });
-        } else if (part.text !== undefined) {
-          // 普通文本内容
-          callback({ type: 'text', content: part.text });
-        } else if (part.functionCall) {
-          // 工具调用，透传工具签名，并写入全局缓存
-          const toolCall = convertToToolCall(part.functionCall, state.sessionId, state.model);
-          if (part.thoughtSignature) {
-            toolCall.thoughtSignature = part.thoughtSignature;
-            if (state.sessionId && state.model) {
-              setToolSignature(state.sessionId, state.model, part.thoughtSignature);
-            }
-          }
-          state.toolCalls.push(toolCall);
-        }
-      }
-    }
-    
-    // 响应结束时发送工具调用和使用统计
-    if (data.response?.candidates?.[0]?.finishReason) {
-      if (state.toolCalls.length > 0) {
-        callback({ type: 'tool_calls', tool_calls: state.toolCalls });
-        state.toolCalls = [];
-      }
-      // 提取 token 使用统计
-      const usage = data.response?.usageMetadata;
-      if (usage) {
-        callback({
-          type: 'usage',
-          usage: {
-            prompt_tokens: usage.promptTokenCount || 0,
-            completion_tokens: usage.candidatesTokenCount || 0,
-            total_tokens: usage.totalTokenCount || 0
-          }
-        });
-      }
-    }
-  } catch (e) {
-    // 忽略 JSON 解析错误
-  }
-}
 
 // ==================== 导出函数 ====================
 

src/api/stream_parser.js

@@ -0,0 +1,156 @@
+import memoryManager, { registerMemoryPoolCleanup } from '../utils/memoryManager.js';
+import { generateToolCallId } from '../utils/idGenerator.js';
+import { setReasoningSignature, setToolSignature } from '../utils/thoughtSignatureCache.js';
+import { getOriginalToolName } from '../utils/toolNameCache.js';
+
+// 预编译的常量（避免重复创建字符串）
+const DATA_PREFIX = 'data: ';
+const DATA_PREFIX_LEN = DATA_PREFIX.length;
+
+// 高效的行分割器（零拷贝，避免 split 创建新数组）
+// 使用对象池复用 LineBuffer 实例
+class LineBuffer {
+  constructor() {
+    this.buffer = '';
+    this.lines = [];
+  }
+  
+  // 追加数据并返回完整的行
+  append(chunk) {
+    this.buffer += chunk;
+    this.lines.length = 0; // 重用数组
+    
+    let start = 0;
+    let end;
+    while ((end = this.buffer.indexOf('\n', start)) !== -1) {
+      this.lines.push(this.buffer.slice(start, end));
+      start = end + 1;
+    }
+    
+    // 保留未完成的部分
+    this.buffer = start < this.buffer.length ? this.buffer.slice(start) : '';
+    return this.lines;
+  }
+  
+  clear() {
+    this.buffer = '';
+    this.lines.length = 0;
+  }
+}
+
+// LineBuffer 对象池
+const lineBufferPool = [];
+const getLineBuffer = () => {
+  const buffer = lineBufferPool.pop();
+  if (buffer) {
+    buffer.clear();
+    return buffer;
+  }
+  return new LineBuffer();
+};
+const releaseLineBuffer = (buffer) => {
+  const maxSize = memoryManager.getPoolSizes().lineBuffer;
+  if (lineBufferPool.length < maxSize) {
+    buffer.clear();
+    lineBufferPool.push(buffer);
+  }
+};
+
+// toolCall 对象池
+const toolCallPool = [];
+const getToolCallObject = () => toolCallPool.pop() || { id: '', type: 'function', function: { name: '', arguments: '' } };
+const releaseToolCallObject = (obj) => {
+  const maxSize = memoryManager.getPoolSizes().toolCall;
+  if (toolCallPool.length < maxSize) toolCallPool.push(obj);
+};
+
+// 注册内存清理回调（供外部统一调用）
+function registerStreamMemoryCleanup() {
+  registerMemoryPoolCleanup(toolCallPool, () => memoryManager.getPoolSizes().toolCall);
+  registerMemoryPoolCleanup(lineBufferPool, () => memoryManager.getPoolSizes().lineBuffer);
+}
+
+// 转换 functionCall 为 OpenAI 格式（使用对象池）
+// 会尝试将安全工具名还原为原始工具名
+function convertToToolCall(functionCall, sessionId, model) {
+  const toolCall = getToolCallObject();
+  toolCall.id = functionCall.id || generateToolCallId();
+  let name = functionCall.name;
+  if (sessionId && model) {
+    const original = getOriginalToolName(sessionId, model, functionCall.name);
+    if (original) name = original;
+  }
+  toolCall.function.name = name;
+  toolCall.function.arguments = JSON.stringify(functionCall.args);
+  return toolCall;
+}
+
+// 解析并发送流式响应片段（会修改 state 并触发 callback）
+// 支持 DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
+// 同时透传 thoughtSignature，方便客户端后续复用
+function parseAndEmitStreamChunk(line, state, callback) {
+  if (!line.startsWith(DATA_PREFIX)) return;
+  
+  try {
+    const data = JSON.parse(line.slice(DATA_PREFIX_LEN));
+    const parts = data.response?.candidates?.[0]?.content?.parts;
+    
+    if (parts) {
+      for (const part of parts) {
+        if (part.thought === true) {
+          if (part.thoughtSignature) {
+            state.reasoningSignature = part.thoughtSignature;
+            if (state.sessionId && state.model) {
+              setReasoningSignature(state.sessionId, state.model, part.thoughtSignature);
+            }
+          }
+          callback({
+            type: 'reasoning',
+            reasoning_content: part.text || '',
+            thoughtSignature: part.thoughtSignature || state.reasoningSignature || null
+          });
+        } else if (part.text !== undefined) {
+          callback({ type: 'text', content: part.text });
+        } else if (part.functionCall) {
+          const toolCall = convertToToolCall(part.functionCall, state.sessionId, state.model);
+          if (part.thoughtSignature) {
+            toolCall.thoughtSignature = part.thoughtSignature;
+            if (state.sessionId && state.model) {
+              setToolSignature(state.sessionId, state.model, part.thoughtSignature);
+            }
+          }
+          state.toolCalls.push(toolCall);
+        }
+      }
+    }
+    
+    if (data.response?.candidates?.[0]?.finishReason) {
+      if (state.toolCalls.length > 0) {
+        callback({ type: 'tool_calls', tool_calls: state.toolCalls });
+        state.toolCalls = [];
+      }
+      const usage = data.response?.usageMetadata;
+      if (usage) {
+        callback({
+          type: 'usage',
+          usage: {
+            prompt_tokens: usage.promptTokenCount || 0,
+            completion_tokens: usage.candidatesTokenCount || 0,
+            total_tokens: usage.totalTokenCount || 0
+          }
+        });
+      }
+    }
+  } catch {
+    // 忽略 JSON 解析错误
+  }
+}
+
+export {
+  getLineBuffer,
+  releaseLineBuffer,
+  parseAndEmitStreamChunk,
+  convertToToolCall,
+  registerStreamMemoryCleanup,
+  releaseToolCallObject
+};

src/auth/oauth_manager.js

@@ -82,7 +82,7 @@ class OAuthManager {
     if (config.skipProjectIdFetch) {
       const projectId = generateProjectId();
       log.info('已跳过API验证，使用随机生成的projectId: ' + projectId);
-      return { projectId, hasQuota: false };
+      return { projectId, hasQuota: true };
     }
 
     // 尝试从API获取projectId

src/auth/quota_manager.js

@@ -1,30 +1,20 @@
 import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { log } from '../utils/logger.js';
 import memoryManager, { MemoryPressure } from '../utils/memoryManager.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 获取数据目录（支持 pkg 打包环境）
-function getDataDir() {
-  // 检测是否在 pkg 打包环境中运行
-  if (process.pkg) {
-    // pkg 环境：使用可执行文件所在目录的 data 子目录
-    const execDir = path.dirname(process.execPath);
-    return path.join(execDir, 'data');
-  }
-  // 普通环境：使用项目根目录的 data 子目录
-  return path.join(__dirname, '..', '..', 'data');
-}
+import { getDataDir } from '../utils/paths.js';
+import { QUOTA_CACHE_TTL, QUOTA_CLEANUP_INTERVAL } from '../constants/index.js';
 
 class QuotaManager {
+  /**
+   * @param {string} filePath - 额度数据文件路径
+   */
   constructor(filePath = path.join(getDataDir(), 'quotas.json')) {
     this.filePath = filePath;
+    /** @type {Map<string, {lastUpdated: number, models: Object}>} */
     this.cache = new Map();
-    this.CACHE_TTL = 5 * 60 * 1000; // 5分钟缓存
-    this.CLEANUP_INTERVAL = 60 * 60 * 1000; // 1小时清理一次
+    this.CACHE_TTL = QUOTA_CACHE_TTL;
+    this.CLEANUP_INTERVAL = QUOTA_CLEANUP_INTERVAL;
     this.cleanupTimer = null;
     this.ensureFileExists();
     this.loadFromFile();

src/auth/token_manager.js

@@ -1,53 +1,15 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import axios from 'axios';
 import { log } from '../utils/logger.js';
 import { generateSessionId, generateProjectId } from '../utils/idGenerator.js';
 import config, { getConfigJson } from '../config/config.js';
 import { OAUTH_CONFIG } from '../constants/oauth.js';
 import { buildAxiosRequestConfig } from '../utils/httpClient.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 检测是否在 pkg 打包环境中运行
-const isPkg = typeof process.pkg !== 'undefined';
-
-// 获取数据目录路径
-// pkg 环境下使用可执行文件所在目录或当前工作目录
-function getDataDir() {
-  if (isPkg) {
-    // pkg 环境：优先使用可执行文件旁边的 data 目录
-    const exeDir = path.dirname(process.execPath);
-    const exeDataDir = path.join(exeDir, 'data');
-    // 检查是否可以在该目录创建文件
-    try {
-      if (!fs.existsSync(exeDataDir)) {
-        fs.mkdirSync(exeDataDir, { recursive: true });
-      }
-      return exeDataDir;
-    } catch (e) {
-      // 如果无法创建，尝试当前工作目录
-      const cwdDataDir = path.join(process.cwd(), 'data');
-      try {
-        if (!fs.existsSync(cwdDataDir)) {
-          fs.mkdirSync(cwdDataDir, { recursive: true });
-        }
-        return cwdDataDir;
-      } catch (e2) {
-        // 最后使用用户主目录
-        const homeDataDir = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.antigravity', 'data');
-        if (!fs.existsSync(homeDataDir)) {
-          fs.mkdirSync(homeDataDir, { recursive: true });
-        }
-        return homeDataDir;
-      }
-    }
-  }
-  // 开发环境
-  return path.join(__dirname, '..', '..', 'data');
-}
+import {
+  DEFAULT_REQUEST_COUNT_PER_TOKEN,
+  TOKEN_REFRESH_BUFFER
+} from '../constants/index.js';
+import TokenStore from './token_store.js';
+import { TokenError } from '../utils/errors.js';
 
 // 轮询策略枚举
 const RotationStrategy = {
@@ -56,37 +18,43 @@ const RotationStrategy = {
   REQUEST_COUNT: 'request_count'        // 自定义次数后切换
 };
 
+/**
+ * Token 管理器
+ * 负责 Token 的存储、轮询、刷新等功能
+ */
 class TokenManager {
-  constructor(filePath = path.join(getDataDir(), 'accounts.json')) {
-    this.filePath = filePath;
+  /**
+   * @param {string} filePath - Token 数据文件路径
+   */
+  constructor(filePath) {
+    this.store = new TokenStore(filePath);
+    /** @type {Array<Object>} */
     this.tokens = [];
+    /** @type {number} */
     this.currentIndex = 0;
     
     // 轮询策略相关 - 使用原子操作避免锁
+    /** @type {string} */
     this.rotationStrategy = RotationStrategy.ROUND_ROBIN;
-    this.requestCountPerToken = 50;  // request_count 策略下每个token请求次数后切换
-    this.tokenRequestCounts = new Map();  // 记录每个token的请求次数
+    /** @type {number} */
+    this.requestCountPerToken = DEFAULT_REQUEST_COUNT_PER_TOKEN;
+    /** @type {Map<string, number>} */
+    this.tokenRequestCounts = new Map();
     
-    this.ensureFileExists();
-    this.initialize();
-  }
-
-  ensureFileExists() {
-    const dir = path.dirname(this.filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    if (!fs.existsSync(this.filePath)) {
-      fs.writeFileSync(this.filePath, '[]', 'utf8');
-      log.info('✓ 已创建账号配置文件');
-    }
+    // 针对额度耗尽策略的可用 token 索引缓存（优化大规模账号场景）
+    /** @type {number[]} */
+    this.availableQuotaTokenIndices = [];
+    /** @type {number} */
+    this.currentQuotaIndex = 0;
+
+    /** @type {Promise<void>|null} */
+    this._initPromise = null;
   }
 
-  async initialize() {
+  async _initialize() {
     try {
       log.info('正在初始化token管理器...');
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      let tokenArray = JSON.parse(data);
+      const tokenArray = await this.store.readAll();
       
       this.tokens = tokenArray.filter(token => token.enable !== false).map(token => ({
         ...token,
@@ -95,6 +63,7 @@ class TokenManager {
       
       this.currentIndex = 0;
       this.tokenRequestCounts.clear();
+      this._rebuildAvailableQuotaTokens();
       
       // 加载轮询策略配置
       this.loadRotationConfig();
@@ -110,6 +79,9 @@ class TokenManager {
         } else {
           log.info(`轮询策略: ${this.rotationStrategy}`);
         }
+        
+        // 并发刷新所有过期的 token
+        await this._refreshExpiredTokensConcurrently();
       }
     } catch (error) {
       log.error('初始化token失败:', error.message);
@@ -117,6 +89,77 @@ class TokenManager {
     }
   }
 
+  /**
+   * 并发刷新所有过期的 token
+   * @private
+   */
+  async _refreshExpiredTokensConcurrently() {
+    const expiredTokens = this.tokens.filter(token => this.isExpired(token));
+    if (expiredTokens.length === 0) {
+      return;
+    }
+
+    log.info(`发现 ${expiredTokens.length} 个过期token，开始并发刷新...`);
+    const startTime = Date.now();
+
+    const results = await Promise.allSettled(
+      expiredTokens.map(token => this._refreshTokenSafe(token))
+    );
+
+    let successCount = 0;
+    let failCount = 0;
+    const tokensToDisable = [];
+
+    results.forEach((result, index) => {
+      const token = expiredTokens[index];
+      if (result.status === 'fulfilled') {
+        if (result.value === 'success') {
+          successCount++;
+        } else if (result.value === 'disable') {
+          tokensToDisable.push(token);
+          failCount++;
+        }
+      } else {
+        failCount++;
+        log.error(`...${token.access_token?.slice(-8) || 'unknown'} 刷新失败:`, result.reason?.message || result.reason);
+      }
+    });
+
+    // 批量禁用失效的 token
+    for (const token of tokensToDisable) {
+      this.disableToken(token);
+    }
+
+    const elapsed = Date.now() - startTime;
+    log.info(`并发刷新完成: 成功 ${successCount}, 失败 ${failCount}, 耗时 ${elapsed}ms`);
+  }
+
+  /**
+   * 安全刷新单个 token（不抛出异常）
+   * @param {Object} token - Token 对象
+   * @returns {Promise<'success'|'disable'|'skip'>} 刷新结果
+   * @private
+   */
+  async _refreshTokenSafe(token) {
+    try {
+      await this.refreshToken(token);
+      return 'success';
+    } catch (error) {
+      if (error.statusCode === 403 || error.statusCode === 400) {
+        log.warn(`...${token.access_token?.slice(-8) || 'unknown'}: Token 已失效，将被禁用`);
+        return 'disable';
+      }
+      throw error;
+    }
+  }
+
+  async _ensureInitialized() {
+    if (!this._initPromise) {
+      this._initPromise = this._initialize();
+    }
+    return this._initPromise;
+  }
+
   // 加载轮询策略配置
   loadRotationConfig() {
     try {
@@ -147,6 +190,33 @@ class TokenManager {
     }
   }
 
+  // 重建额度耗尽策略下的可用 token 列表
+  _rebuildAvailableQuotaTokens() {
+    this.availableQuotaTokenIndices = [];
+    this.tokens.forEach((token, index) => {
+      if (token.enable !== false && token.hasQuota !== false) {
+        this.availableQuotaTokenIndices.push(index);
+      }
+    });
+
+    if (this.availableQuotaTokenIndices.length === 0) {
+      this.currentQuotaIndex = 0;
+    } else {
+      this.currentQuotaIndex = this.currentQuotaIndex % this.availableQuotaTokenIndices.length;
+    }
+  }
+
+  // 从额度耗尽策略的可用列表中移除指定下标
+  _removeQuotaIndex(tokenIndex) {
+    const pos = this.availableQuotaTokenIndices.indexOf(tokenIndex);
+    if (pos !== -1) {
+      this.availableQuotaTokenIndices.splice(pos, 1);
+      if (this.currentQuotaIndex >= this.availableQuotaTokenIndices.length) {
+        this.currentQuotaIndex = 0;
+      }
+    }
+  }
+
   async fetchProjectId(token) {
     const response = await axios(buildAxiosRequestConfig({
       method: 'POST',
@@ -163,10 +233,15 @@ class TokenManager {
     return response.data?.cloudaicompanionProject;
   }
 
+  /**
+   * 检查 Token 是否过期
+   * @param {Object} token - Token 对象
+   * @returns {boolean} 是否过期
+   */
   isExpired(token) {
     if (!token.timestamp || !token.expires_in) return true;
     const expiresAt = token.timestamp + (token.expires_in * 1000);
-    return Date.now() >= expiresAt - 300000;
+    return Date.now() >= expiresAt - TOKEN_REFRESH_BUFFER;
   }
 
   async refreshToken(token) {
@@ -197,37 +272,19 @@ class TokenManager {
       this.saveToFile(token);
       return token;
     } catch (error) {
-      throw { statusCode: error.response?.status, message: error.response?.data || error.message };
+      const statusCode = error.response?.status;
+      const rawBody = error.response?.data;
+      const suffix = token.access_token ? token.access_token.slice(-8) : null;
+      const message = typeof rawBody === 'string' ? rawBody : (rawBody?.error?.message || error.message || '刷新 token 失败');
+      throw new TokenError(message, suffix, statusCode || 500);
     }
   }
 
   saveToFile(tokenToUpdate = null) {
-    try {
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      const allTokens = JSON.parse(data);
-      
-      // 如果指定了要更新的token，直接更新它
-      if (tokenToUpdate) {
-        const index = allTokens.findIndex(t => t.refresh_token === tokenToUpdate.refresh_token);
-        if (index !== -1) {
-          const { sessionId, ...tokenToSave } = tokenToUpdate;
-          allTokens[index] = tokenToSave;
-        }
-      } else {
-        // 否则更新内存中的所有token
-        this.tokens.forEach(memToken => {
-          const index = allTokens.findIndex(t => t.refresh_token === memToken.refresh_token);
-          if (index !== -1) {
-            const { sessionId, ...tokenToSave } = memToken;
-            allTokens[index] = tokenToSave;
-          }
-        });
-      }
-      
-      fs.writeFileSync(this.filePath, JSON.stringify(allTokens, null, 2), 'utf8');
-    } catch (error) {
-      log.error('保存文件失败:', error.message);
-    }
+    // 保持与旧接口同步调用方式一致，内部使用异步写入
+    this.store.mergeActiveTokens(this.tokens, tokenToUpdate).catch((error) => {
+      log.error('保存账号配置文件失败:', error.message);
+    });
   }
 
   disableToken(token) {
@@ -236,6 +293,8 @@ class TokenManager {
     this.saveToFile();
     this.tokens = this.tokens.filter(t => t.refresh_token !== token.refresh_token);
     this.currentIndex = this.currentIndex % Math.max(this.tokens.length, 1);
+    // tokens 结构发生变化时，重建额度耗尽策略下的可用列表
+    this._rebuildAvailableQuotaTokens();
   }
 
   // 原子操作：获取并递增请求计数
@@ -284,8 +343,11 @@ class TokenManager {
     this.saveToFile(token);
     log.warn(`...${token.access_token.slice(-8)}: 额度已耗尽，标记为无额度`);
     
-    // 如果是额度耗尽策略，立即切换到下一个token
     if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED) {
+      const tokenIndex = this.tokens.findIndex(t => t.refresh_token === token.refresh_token);
+      if (tokenIndex !== -1) {
+        this._removeQuotaIndex(tokenIndex);
+      }
       this.currentIndex = (this.currentIndex + 1) % Math.max(this.tokens.length, 1);
     }
   }
@@ -297,79 +359,173 @@ class TokenManager {
     log.info(`...${token.access_token.slice(-8)}: 额度已恢复`);
   }
 
+  /**
+   * 准备单个 token（刷新 + 获取 projectId）
+   * @param {Object} token - Token 对象
+   * @returns {Promise<'ready'|'skip'|'disable'>} 处理结果
+   * @private
+   */
+  async _prepareToken(token) {
+    // 刷新过期 token
+    if (this.isExpired(token)) {
+      await this.refreshToken(token);
+    }
+
+    // 获取 projectId
+    if (!token.projectId) {
+      if (config.skipProjectIdFetch) {
+        token.projectId = generateProjectId();
+        this.saveToFile(token);
+        log.info(`...${token.access_token.slice(-8)}: 使用随机生成的projectId: ${token.projectId}`);
+      } else {
+        const projectId = await this.fetchProjectId(token);
+        if (projectId === undefined) {
+          log.warn(`...${token.access_token.slice(-8)}: 无资格获取projectId，禁用账号`);
+          return 'disable';
+        }
+        token.projectId = projectId;
+        this.saveToFile(token);
+      }
+    }
+
+    return 'ready';
+  }
+
+  /**
+   * 处理 token 准备过程中的错误
+   * @param {Error} error - 错误对象
+   * @param {Object} token - Token 对象
+   * @returns {'disable'|'skip'} 处理结果
+   * @private
+   */
+  _handleTokenError(error, token) {
+    const suffix = token.access_token?.slice(-8) || 'unknown';
+    if (error.statusCode === 403 || error.statusCode === 400) {
+      log.warn(`...${suffix}: Token 已失效或错误，已自动禁用该账号`);
+      return 'disable';
+    }
+    log.error(`...${suffix} 操作失败:`, error.message);
+    return 'skip';
+  }
+
+  /**
+   * 重置所有 token 的额度状态
+   * @private
+   */
+  _resetAllQuotas() {
+    log.warn('所有token额度已耗尽，重置额度状态');
+    this.tokens.forEach(t => {
+      t.hasQuota = true;
+    });
+    this.saveToFile();
+    this._rebuildAvailableQuotaTokens();
+  }
+
   async getToken() {
+    await this._ensureInitialized();
     if (this.tokens.length === 0) return null;
 
+    // 针对额度耗尽策略做单独的高性能处理
+    if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED) {
+      return this._getTokenForQuotaExhaustedStrategy();
+    }
+
+    return this._getTokenForDefaultStrategy();
+  }
+
+  /**
+   * 额度耗尽策略的 token 获取
+   * @private
+   */
+  async _getTokenForQuotaExhaustedStrategy() {
+    // 如果当前没有可用 token，尝试重置额度
+    if (this.availableQuotaTokenIndices.length === 0) {
+      this._resetAllQuotas();
+    }
+
+    const totalAvailable = this.availableQuotaTokenIndices.length;
+    if (totalAvailable === 0) {
+      return null;
+    }
+
+    const startIndex = this.currentQuotaIndex % totalAvailable;
+
+    for (let i = 0; i < totalAvailable; i++) {
+      const listIndex = (startIndex + i) % totalAvailable;
+      const tokenIndex = this.availableQuotaTokenIndices[listIndex];
+      const token = this.tokens[tokenIndex];
+
+      try {
+        const result = await this._prepareToken(token);
+        if (result === 'disable') {
+          this.disableToken(token);
+          this._rebuildAvailableQuotaTokens();
+          if (this.tokens.length === 0 || this.availableQuotaTokenIndices.length === 0) {
+            return null;
+          }
+          continue;
+        }
+
+        this.currentIndex = tokenIndex;
+        this.currentQuotaIndex = listIndex;
+        return token;
+      } catch (error) {
+        const action = this._handleTokenError(error, token);
+        if (action === 'disable') {
+          this.disableToken(token);
+          this._rebuildAvailableQuotaTokens();
+          if (this.tokens.length === 0 || this.availableQuotaTokenIndices.length === 0) {
+            return null;
+          }
+        }
+        // skip: 继续尝试下一个 token
+      }
+    }
+
+    // 所有可用 token 都不可用，重置额度状态
+    this._resetAllQuotas();
+    return this.tokens[0] || null;
+  }
+
+  /**
+   * 默认策略（round_robin / request_count）的 token 获取
+   * @private
+   */
+  async _getTokenForDefaultStrategy() {
     const totalTokens = this.tokens.length;
     const startIndex = this.currentIndex;
 
     for (let i = 0; i < totalTokens; i++) {
       const index = (startIndex + i) % totalTokens;
       const token = this.tokens[index];
-      
-      // 额度耗尽策略：跳过无额度的token
-      if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED && token.hasQuota === false) {
-        continue;
-      }
-      
+
       try {
-        if (this.isExpired(token)) {
-          await this.refreshToken(token);
-        }
-        if (!token.projectId) {
-          if (config.skipProjectIdFetch) {
-            token.projectId = generateProjectId();
-            this.saveToFile(token);
-            log.info(`...${token.access_token.slice(-8)}: 使用随机生成的projectId: ${token.projectId}`);
-          } else {
-            try {
-              const projectId = await this.fetchProjectId(token);
-              if (projectId === undefined) {
-                log.warn(`...${token.access_token.slice(-8)}: 无资格获取projectId，跳过保存`);
-                this.disableToken(token);
-                if (this.tokens.length === 0) return null;
-                continue;
-              }
-              token.projectId = projectId;
-              this.saveToFile(token);
-            } catch (error) {
-              log.error(`...${token.access_token.slice(-8)}: 获取projectId失败:`, error.message);
-              continue;
-            }
-          }
+        const result = await this._prepareToken(token);
+        if (result === 'disable') {
+          this.disableToken(token);
+          if (this.tokens.length === 0) return null;
+          continue;
         }
-        
+
         // 更新当前索引
         this.currentIndex = index;
-        
+
         // 根据策略决定是否切换
         if (this.shouldRotate(token)) {
-          this.currentIndex = (this.currentIndex + 1) % totalTokens;
+          this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
         }
-        
+
         return token;
       } catch (error) {
-        if (error.statusCode === 403 || error.statusCode === 400) {
-          log.warn(`...${token.access_token.slice(-8)}: Token 已失效或错误，已自动禁用该账号`);
+        const action = this._handleTokenError(error, token);
+        if (action === 'disable') {
           this.disableToken(token);
           if (this.tokens.length === 0) return null;
-        } else {
-          log.error(`...${token.access_token.slice(-8)} 刷新失败:`, error.message);
         }
+        // skip: 继续尝试下一个 token
       }
     }
 
-    // 如果所有token都无额度，重置所有token的额度状态并重试
-    if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED) {
-      log.warn('所有token额度已耗尽，重置额度状态');
-      this.tokens.forEach(t => {
-        t.hasQuota = true;
-      });
-      this.saveToFile();
-      // 返回第一个可用token
-      return this.tokens[0] || null;
-    }
-
     return null;
   }
 
@@ -382,15 +538,14 @@ class TokenManager {
 
   // API管理方法
   async reload() {
-    await this.initialize();
+    this._initPromise = this._initialize();
+    await this._initPromise;
     log.info('Token已热重载');
   }
 
-  addToken(tokenData) {
+  async addToken(tokenData) {
     try {
-      this.ensureFileExists();
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      const allTokens = JSON.parse(data);
+      const allTokens = await this.store.readAll();
       
       const newToken = {
         access_token: tokenData.access_token,
@@ -411,9 +566,9 @@ class TokenManager {
       }
       
       allTokens.push(newToken);
-      fs.writeFileSync(this.filePath, JSON.stringify(allTokens, null, 2), 'utf8');
+      await this.store.writeAll(allTokens);
       
-      this.reload();
+      await this.reload();
       return { success: true, message: 'Token添加成功' };
     } catch (error) {
       log.error('添加Token失败:', error.message);
@@ -421,11 +576,9 @@ class TokenManager {
     }
   }
 
-  updateToken(refreshToken, updates) {
+  async updateToken(refreshToken, updates) {
     try {
-      this.ensureFileExists();
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      const allTokens = JSON.parse(data);
+      const allTokens = await this.store.readAll();
       
       const index = allTokens.findIndex(t => t.refresh_token === refreshToken);
       if (index === -1) {
@@ -433,9 +586,9 @@ class TokenManager {
       }
       
       allTokens[index] = { ...allTokens[index], ...updates };
-      fs.writeFileSync(this.filePath, JSON.stringify(allTokens, null, 2), 'utf8');
+      await this.store.writeAll(allTokens);
       
-      this.reload();
+      await this.reload();
       return { success: true, message: 'Token更新成功' };
     } catch (error) {
       log.error('更新Token失败:', error.message);
@@ -443,20 +596,18 @@ class TokenManager {
     }
   }
 
-  deleteToken(refreshToken) {
+  async deleteToken(refreshToken) {
     try {
-      this.ensureFileExists();
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      const allTokens = JSON.parse(data);
+      const allTokens = await this.store.readAll();
       
       const filteredTokens = allTokens.filter(t => t.refresh_token !== refreshToken);
       if (filteredTokens.length === allTokens.length) {
         return { success: false, message: 'Token不存在' };
       }
       
-      fs.writeFileSync(this.filePath, JSON.stringify(filteredTokens, null, 2), 'utf8');
+      await this.store.writeAll(filteredTokens);
       
-      this.reload();
+      await this.reload();
       return { success: true, message: 'Token删除成功' };
     } catch (error) {
       log.error('删除Token失败:', error.message);
@@ -464,11 +615,9 @@ class TokenManager {
     }
   }
 
-  getTokenList() {
+  async getTokenList() {
     try {
-      this.ensureFileExists();
-      const data = fs.readFileSync(this.filePath, 'utf8');
-      const allTokens = JSON.parse(data);
+      const allTokens = await this.store.readAll();
       
       return allTokens.map(token => ({
         refresh_token: token.refresh_token,

src/auth/token_store.js

@@ -0,0 +1,117 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getDataDir } from '../utils/paths.js';
+import { FILE_CACHE_TTL } from '../constants/index.js';
+import { log } from '../utils/logger.js';
+
+/**
+ * 负责 token 文件的读写与简单缓存
+ * 不关心业务字段，只处理 JSON 数组的加载和保存
+ */
+class TokenStore {
+  constructor(filePath = path.join(getDataDir(), 'accounts.json')) {
+    this.filePath = filePath;
+    this._cache = null;
+    this._cacheTime = 0;
+    this._cacheTTL = FILE_CACHE_TTL;
+  }
+
+  async _ensureFileExists() {
+    const dir = path.dirname(this.filePath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (e) {
+      // 目录已存在等情况忽略
+    }
+
+    try {
+      await fs.access(this.filePath);
+    } catch (e) {
+      // 文件不存在时创建空数组
+      await fs.writeFile(this.filePath, '[]', 'utf8');
+      log.info('✓ 已创建账号配置文件');
+    }
+  }
+
+  _isCacheValid() {
+    if (!this._cache) return false;
+    const now = Date.now();
+    return (now - this._cacheTime) < this._cacheTTL;
+  }
+
+  /**
+   * 读取全部 token（包含禁用的），带简单内存缓存
+   * @returns {Promise<Array<object>>}
+   */
+  async readAll() {
+    if (this._isCacheValid()) {
+      return this._cache;
+    }
+
+    await this._ensureFileExists();
+    try {
+      const data = await fs.readFile(this.filePath, 'utf8');
+      const parsed = JSON.parse(data || '[]');
+      if (!Array.isArray(parsed)) {
+        log.warn('账号配置文件格式异常，已重置为空数组');
+        this._cache = [];
+      } else {
+        this._cache = parsed;
+      }
+    } catch (error) {
+      log.error('读取账号配置文件失败:', error.message);
+      this._cache = [];
+    }
+    this._cacheTime = Date.now();
+    return this._cache;
+  }
+
+  /**
+   * 覆盖写入全部 token，更新缓存
+   * @param {Array<object>} tokens
+   */
+  async writeAll(tokens) {
+    await this._ensureFileExists();
+    const normalized = Array.isArray(tokens) ? tokens : [];
+    try {
+      await fs.writeFile(this.filePath, JSON.stringify(normalized, null, 2), 'utf8');
+      this._cache = normalized;
+      this._cacheTime = Date.now();
+    } catch (error) {
+      log.error('保存账号配置文件失败:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * 根据内存中的启用 token 列表，将对应记录合并回文件
+   * - 仅按 refresh_token 匹配并更新已有记录
+   * - 未出现在 activeTokens 中的记录（例如已禁用账号）保持不变
+   * @param {Array<object>} activeTokens - 内存中的启用 token 列表（可能包含 sessionId）
+   * @param {object|null} tokenToUpdate - 如果只需要单个更新，可传入该 token 以减少遍历
+   */
+  async mergeActiveTokens(activeTokens, tokenToUpdate = null) {
+    const allTokens = [...await this.readAll()];
+
+    const applyUpdate = (targetToken) => {
+      if (!targetToken) return;
+      const index = allTokens.findIndex(t => t.refresh_token === targetToken.refresh_token);
+      if (index !== -1) {
+        const { sessionId, ...plain } = targetToken;
+        allTokens[index] = { ...allTokens[index], ...plain };
+      }
+    };
+
+    if (tokenToUpdate) {
+      applyUpdate(tokenToUpdate);
+    } else if (Array.isArray(activeTokens) && activeTokens.length > 0) {
+      for (const memToken of activeTokens) {
+        applyUpdate(memToken);
+      }
+    }
+
+    await this.writeAll(allTokens);
+  }
+}
+
+export default TokenStore;

src/config/config.js

@@ -1,65 +1,26 @@
 import dotenv from 'dotenv';
 import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import log from '../utils/logger.js';
 import { deepMerge } from '../utils/deepMerge.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 检测是否在 pkg 打包环境中运行
-const isPkg = typeof process.pkg !== 'undefined';
-
-// 获取配置文件路径
-// pkg 环境下使用可执行文件所在目录或当前工作目录
-function getConfigPaths() {
-  if (isPkg) {
-    // pkg 环境：优先使用可执行文件旁边的配置文件
-    const exeDir = path.dirname(process.execPath);
-    const cwdDir = process.cwd();
-    
-    // 查找 .env 文件
-    let envPath = path.join(exeDir, '.env');
-    if (!fs.existsSync(envPath)) {
-      const cwdEnvPath = path.join(cwdDir, '.env');
-      if (fs.existsSync(cwdEnvPath)) {
-        envPath = cwdEnvPath;
-      }
-    }
-    
-    // 查找 config.json 文件
-    let configJsonPath = path.join(exeDir, 'config.json');
-    if (!fs.existsSync(configJsonPath)) {
-      const cwdConfigPath = path.join(cwdDir, 'config.json');
-      if (fs.existsSync(cwdConfigPath)) {
-        configJsonPath = cwdConfigPath;
-      }
-    }
-    
-    // 查找 .env.example 文件
-    let examplePath = path.join(exeDir, '.env.example');
-    if (!fs.existsSync(examplePath)) {
-      const cwdExamplePath = path.join(cwdDir, '.env.example');
-      if (fs.existsSync(cwdExamplePath)) {
-        examplePath = cwdExamplePath;
-      }
-    }
-    
-    return { envPath, configJsonPath, examplePath };
-  }
-  
-  // 开发环境
-  return {
-    envPath: path.join(__dirname, '../../.env'),
-    configJsonPath: path.join(__dirname, '../../config.json'),
-    examplePath: path.join(__dirname, '../../.env.example')
-  };
-}
+import { getConfigPaths } from '../utils/paths.js';
+import {
+  DEFAULT_SERVER_PORT,
+  DEFAULT_SERVER_HOST,
+  DEFAULT_HEARTBEAT_INTERVAL,
+  DEFAULT_TIMEOUT,
+  DEFAULT_RETRY_TIMES,
+  DEFAULT_MAX_REQUEST_SIZE,
+  DEFAULT_MAX_IMAGES,
+  MODEL_LIST_CACHE_TTL,
+  DEFAULT_GENERATION_PARAMS,
+  DEFAULT_ADMIN_USERNAME,
+  DEFAULT_ADMIN_PASSWORD,
+  DEFAULT_JWT_SECRET
+} from '../constants/index.js';
 
 const { envPath, configJsonPath, examplePath } = getConfigPaths();
 
-// 确保 .env 存在
+// 确保 .env 存在（如果缺失则从 .env.example 复制一份）
 if (!fs.existsSync(envPath)) {
   if (fs.existsSync(examplePath)) {
     fs.copyFileSync(examplePath, envPath);
@@ -100,24 +61,26 @@ export function getProxyConfig() {
 
 /**
  * 从 JSON 和环境变量构建配置对象
+ * @param {Object} jsonConfig - JSON 配置对象
+ * @returns {Object} 完整配置对象
  */
 export function buildConfig(jsonConfig) {
   return {
     server: {
-      port: jsonConfig.server?.port || 8045,
-      host: jsonConfig.server?.host || '0.0.0.0',
-      heartbeatInterval: jsonConfig.server?.heartbeatInterval || 15000,
+      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
     },
     cache: {
-      modelListTTL: jsonConfig.cache?.modelListTTL || 60 * 60 * 1000
+      modelListTTL: jsonConfig.cache?.modelListTTL || MODEL_LIST_CACHE_TTL
     },
     rotation: {
       strategy: jsonConfig.rotation?.strategy || 'round_robin',
       requestCount: jsonConfig.rotation?.requestCount || 10
     },
     imageBaseUrl: process.env.IMAGE_BASE_URL || null,
-    maxImages: jsonConfig.other?.maxImages || 10,
+    maxImages: jsonConfig.other?.maxImages || DEFAULT_MAX_IMAGES,
     api: {
       url: jsonConfig.api?.url || 'https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:streamGenerateContent?alt=sse',
       modelsUrl: jsonConfig.api?.modelsUrl || 'https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:fetchAvailableModels',
@@ -126,28 +89,29 @@ export function buildConfig(jsonConfig) {
       userAgent: jsonConfig.api?.userAgent || 'antigravity/1.11.3 windows/amd64'
     },
     defaults: {
-      temperature: jsonConfig.defaults?.temperature || 1,
-      top_p: jsonConfig.defaults?.topP || 0.85,
-      top_k: jsonConfig.defaults?.topK || 50,
-      max_tokens: jsonConfig.defaults?.maxTokens || 32000,
-      thinking_budget: jsonConfig.defaults?.thinkingBudget ?? 1024
+      temperature: jsonConfig.defaults?.temperature ?? DEFAULT_GENERATION_PARAMS.temperature,
+      top_p: jsonConfig.defaults?.topP ?? DEFAULT_GENERATION_PARAMS.top_p,
+      top_k: jsonConfig.defaults?.topK ?? DEFAULT_GENERATION_PARAMS.top_k,
+      max_tokens: jsonConfig.defaults?.maxTokens ?? DEFAULT_GENERATION_PARAMS.max_tokens,
+      thinking_budget: jsonConfig.defaults?.thinkingBudget ?? DEFAULT_GENERATION_PARAMS.thinking_budget
     },
     security: {
-      maxRequestSize: jsonConfig.server?.maxRequestSize || '50mb',
+      maxRequestSize: jsonConfig.server?.maxRequestSize || DEFAULT_MAX_REQUEST_SIZE,
       apiKey: process.env.API_KEY || null
     },
     admin: {
-      username: process.env.ADMIN_USERNAME || 'admin',
-      password: process.env.ADMIN_PASSWORD || 'admin123',
-      jwtSecret: process.env.JWT_SECRET || 'your-jwt-secret-key-change-this-in-production'
+      username: process.env.ADMIN_USERNAME || DEFAULT_ADMIN_USERNAME,
+      password: process.env.ADMIN_PASSWORD || DEFAULT_ADMIN_PASSWORD,
+      jwtSecret: process.env.JWT_SECRET || DEFAULT_JWT_SECRET
     },
     useNativeAxios: jsonConfig.other?.useNativeAxios !== false,
-    timeout: jsonConfig.other?.timeout || 300000,
-    retryTimes: Number.isFinite(jsonConfig.other?.retryTimes) ? jsonConfig.other.retryTimes : 3,
+    timeout: jsonConfig.other?.timeout || DEFAULT_TIMEOUT,
+    retryTimes: Number.isFinite(jsonConfig.other?.retryTimes) ? jsonConfig.other.retryTimes : DEFAULT_RETRY_TIMES,
     proxy: getProxyConfig(),
     systemInstruction: process.env.SYSTEM_INSTRUCTION || '',
     skipProjectIdFetch: jsonConfig.other?.skipProjectIdFetch === true,
-    useContextSystemPrompt: jsonConfig.other?.useContextSystemPrompt === true
+    useContextSystemPrompt: jsonConfig.other?.useContextSystemPrompt === true,
+    passSignatureToClient: jsonConfig.other?.passSignatureToClient === true
   };
 }
 

src/constants/index.js

@@ -0,0 +1,190 @@
+/**
+ * 应用常量定义
+ * @module constants
+ */
+
+// ==================== 缓存相关常量 ====================
+
+/**
+ * 文件缓存有效期（毫秒）
+ * @type {number}
+ */
+export const FILE_CACHE_TTL = 5000;
+
+/**
+ * 文件保存延迟（毫秒）- 用于 debounce
+ * @type {number}
+ */
+export const FILE_SAVE_DELAY = 1000;
+
+/**
+ * 额度缓存有效期（毫秒）- 5分钟
+ * @type {number}
+ */
+export const QUOTA_CACHE_TTL = 5 * 60 * 1000;
+
+/**
+ * 额度清理间隔（毫秒）- 1小时
+ * @type {number}
+ */
+export const QUOTA_CLEANUP_INTERVAL = 60 * 60 * 1000;
+
+/**
+ * 模型列表缓存默认有效期（毫秒）- 1小时
+ * @type {number}
+ */
+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
+};
+
+/**
+ * GC 冷却时间（毫秒）
+ * @type {number}
+ */
+export const GC_COOLDOWN = 10000;
+
+/**
+ * 默认内存检查间隔（毫秒）
+ * @type {number}
+ */
+export const MEMORY_CHECK_INTERVAL = 30000;
+
+// ==================== 服务器相关常量 ====================
+
+/**
+ * 默认心跳间隔（毫秒）
+ * @type {number}
+ */
+export const DEFAULT_HEARTBEAT_INTERVAL = 15000;
+
+/**
+ * 默认服务器端口
+ * @type {number}
+ */
+export const DEFAULT_SERVER_PORT = 8045;
+
+/**
+ * 默认服务器主机
+ * @type {string}
+ */
+export const DEFAULT_SERVER_HOST = '0.0.0.0';
+
+/**
+ * 默认请求超时（毫秒）
+ * @type {number}
+ */
+export const DEFAULT_TIMEOUT = 300000;
+
+/**
+ * 默认重试次数
+ * @type {number}
+ */
+export const DEFAULT_RETRY_TIMES = 3;
+
+/**
+ * 默认最大请求体大小
+ * @type {string}
+ */
+export const DEFAULT_MAX_REQUEST_SIZE = '50mb';
+
+// ==================== Token 轮询相关常量 ====================
+
+/**
+ * 默认每个 Token 请求次数后切换
+ * @type {number}
+ */
+export const DEFAULT_REQUEST_COUNT_PER_TOKEN = 50;
+
+/**
+ * Token 过期提前刷新时间（毫秒）- 5分钟
+ * @type {number}
+ */
+export const TOKEN_REFRESH_BUFFER = 300000;
+
+// ==================== 生成参数默认值 ====================
+
+/**
+ * 默认生成参数
+ */
+export const DEFAULT_GENERATION_PARAMS = {
+  temperature: 1,
+  top_p: 0.85,
+  top_k: 50,
+  max_tokens: 32000,
+  thinking_budget: 1024
+};
+
+/**
+ * reasoning_effort 到 thinkingBudget 的映射
+ */
+export const REASONING_EFFORT_MAP = {
+  low: 1024,
+  medium: 16000,
+  high: 32000
+};
+
+// ==================== 图片相关常量 ====================
+
+/**
+ * 默认最大保留图片数量
+ * @type {number}
+ */
+export const DEFAULT_MAX_IMAGES = 10;
+
+/**
+ * MIME 类型到文件扩展名映射
+ */
+export const MIME_TO_EXT = {
+  'image/jpeg': 'jpg',
+  'image/png': 'png',
+  'image/gif': 'gif',
+  'image/webp': 'webp'
+};
+
+// ==================== 停止序列 ====================
+
+/**
+ * 默认停止序列
+ * @type {string[]}
+ */
+export const DEFAULT_STOP_SEQUENCES = [
+  '<|user|>',
+  '<|bot|>',
+  '<|context_request|>',
+  '<|endoftext|>',
+  '<|end_of_turn|>'
+];
+
+// ==================== 管理员默认配置 ====================
+
+/**
+ * 默认管理员用户名
+ * @type {string}
+ */
+export const DEFAULT_ADMIN_USERNAME = 'admin';
+
+/**
+ * 默认管理员密码
+ * @type {string}
+ */
+export const DEFAULT_ADMIN_PASSWORD = 'admin123';
+
+/**
+ * 默认 JWT 密钥（生产环境应更改）
+ * @type {string}
+ */
+export const DEFAULT_JWT_SECRET = 'your-jwt-secret-key-change-this-in-production';

src/routes/admin.js

@@ -1,5 +1,4 @@
 import express from 'express';
-import fs from 'fs';
 import { generateToken, authMiddleware } from '../auth/jwt.js';
 import tokenManager from '../auth/token_manager.js';
 import quotaManager from '../auth/quota_manager.js';
@@ -10,38 +9,9 @@ import { parseEnvFile, updateEnvFile } from '../utils/envParser.js';
 import { reloadConfig } from '../utils/configReloader.js';
 import { deepMerge } from '../utils/deepMerge.js';
 import { getModelsWithQuotas } from '../api/client.js';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { getEnvPath } from '../utils/paths.js';
 import dotenv from 'dotenv';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 检测是否在 pkg 打包环境中运行
-const isPkg = typeof process.pkg !== 'undefined';
-
-// 获取 .env 文件路径
-// pkg 环境下使用可执行文件所在目录或当前工作目录
-function getEnvPath() {
-  if (isPkg) {
-    // pkg 环境：优先使用可执行文件旁边的 .env
-    const exeDir = path.dirname(process.execPath);
-    const exeEnvPath = path.join(exeDir, '.env');
-    if (fs.existsSync(exeEnvPath)) {
-      return exeEnvPath;
-    }
-    // 其次使用当前工作目录的 .env
-    const cwdEnvPath = path.join(process.cwd(), '.env');
-    if (fs.existsSync(cwdEnvPath)) {
-      return cwdEnvPath;
-    }
-    // 返回可执行文件目录的路径（即使不存在）
-    return exeEnvPath;
-  }
-  // 开发环境
-  return path.join(__dirname, '../../.env');
-}
-
 const envPath = getEnvPath();
 
 const router = express.Router();
@@ -59,12 +29,17 @@ router.post('/login', (req, res) => {
 });
 
 // Token管理API - 需要JWT认证
-router.get('/tokens', authMiddleware, (req, res) => {
-  const tokens = tokenManager.getTokenList();
-  res.json({ success: true, data: tokens });
+router.get('/tokens', authMiddleware, async (req, res) => {
+  try {
+    const tokens = await tokenManager.getTokenList();
+    res.json({ success: true, data: tokens });
+  } catch (error) {
+    logger.error('获取Token列表失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
 });
 
-router.post('/tokens', authMiddleware, (req, res) => {
+router.post('/tokens', authMiddleware, async (req, res) => {
   const { access_token, refresh_token, expires_in, timestamp, enable, projectId, email } = req.body;
   if (!access_token || !refresh_token) {
     return res.status(400).json({ success: false, message: 'access_token和refresh_token必填' });
@@ -75,21 +50,36 @@ router.post('/tokens', authMiddleware, (req, res) => {
   if (projectId) tokenData.projectId = projectId;
   if (email) tokenData.email = email;
   
-  const result = tokenManager.addToken(tokenData);
-  res.json(result);
+  try {
+    const result = await tokenManager.addToken(tokenData);
+    res.json(result);
+  } catch (error) {
+    logger.error('添加Token失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
 });
 
-router.put('/tokens/:refreshToken', authMiddleware, (req, res) => {
+router.put('/tokens/:refreshToken', authMiddleware, async (req, res) => {
   const { refreshToken } = req.params;
   const updates = req.body;
-  const result = tokenManager.updateToken(refreshToken, updates);
-  res.json(result);
+  try {
+    const result = await tokenManager.updateToken(refreshToken, updates);
+    res.json(result);
+  } catch (error) {
+    logger.error('更新Token失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
 });
 
-router.delete('/tokens/:refreshToken', authMiddleware, (req, res) => {
+router.delete('/tokens/:refreshToken', authMiddleware, async (req, res) => {
   const { refreshToken } = req.params;
-  const result = tokenManager.deleteToken(refreshToken);
-  res.json(result);
+  try {
+    const result = await tokenManager.deleteToken(refreshToken);
+    res.json(result);
+  } catch (error) {
+    logger.error('删除Token失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
 });
 
 router.post('/tokens/reload', authMiddleware, async (req, res) => {
@@ -202,7 +192,7 @@ router.get('/tokens/:refreshToken/quotas', authMiddleware, async (req, res) => {
   try {
     const { refreshToken } = req.params;
     const forceRefresh = req.query.refresh === 'true';
-    const tokens = tokenManager.getTokenList();
+    const tokens = await tokenManager.getTokenList();
     let tokenData = tokens.find(t => t.refresh_token === refreshToken);
     
     if (!tokenData) {

src/server/index.js

@@ -1,8 +1,6 @@
 import express from 'express';
 import cors from 'cors';
 import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
 import { generateAssistantResponse, generateAssistantResponseNoStream, getAvailableModels, generateImageForSD, closeRequester } from '../api/client.js';
 import { generateRequestBody, generateGeminiRequestBody, generateClaudeRequestBody, prepareImageRequest } from '../utils/utils.js';
 import logger from '../utils/logger.js';
@@ -11,53 +9,12 @@ import tokenManager from '../auth/token_manager.js';
 import adminRouter from '../routes/admin.js';
 import sdRouter from '../routes/sd.js';
 import memoryManager, { registerMemoryPoolCleanup } from '../utils/memoryManager.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 检测是否在 pkg 打包环境中运行
-const isPkg = typeof process.pkg !== 'undefined';
-
-// 获取静态文件目录
-// pkg 环境下使用可执行文件所在目录的 public 文件夹
-// 开发环境下使用项目根目录的 public 文件夹
-function getPublicDir() {
-  if (isPkg) {
-    // pkg 环境：优先使用可执行文件旁边的 public 目录
-    const exeDir = path.dirname(process.execPath);
-    const exePublicDir = path.join(exeDir, 'public');
-    if (fs.existsSync(exePublicDir)) {
-      return exePublicDir;
-    }
-    // 其次使用当前工作目录的 public 目录
-    const cwdPublicDir = path.join(process.cwd(), 'public');
-    if (fs.existsSync(cwdPublicDir)) {
-      return cwdPublicDir;
-    }
-    // 最后使用打包内的 public 目录（通过 snapshot）
-    return path.join(__dirname, '../../public');
-  }
-  // 开发环境
-  return path.join(__dirname, '../../public');
-}
+import { getPublicDir, getRelativePath } from '../utils/paths.js';
+import { DEFAULT_HEARTBEAT_INTERVAL, MEMORY_CHECK_INTERVAL } from '../constants/index.js';
+import { buildOpenAIErrorPayload, errorHandler, ValidationError } from '../utils/errors.js';
 
 const publicDir = getPublicDir();
 
-// 计算相对路径用于日志显示
-function getRelativePath(absolutePath) {
-  if (isPkg) {
-    const exeDir = path.dirname(process.execPath);
-    if (absolutePath.startsWith(exeDir)) {
-      return '.' + absolutePath.slice(exeDir.length).replace(/\\/g, '/');
-    }
-    const cwdDir = process.cwd();
-    if (absolutePath.startsWith(cwdDir)) {
-      return '.' + absolutePath.slice(cwdDir.length).replace(/\\/g, '/');
-    }
-  }
-  return absolutePath;
-}
-
 logger.info(`静态文件目录: ${getRelativePath(publicDir)}`);
 
 const app = express();
@@ -84,7 +41,7 @@ const with429Retry = async (fn, maxRetries, loggerPrefix = '') => {
 };
 
 // ==================== 心跳机制（防止 CF 超时） ====================
-const HEARTBEAT_INTERVAL = config.server.heartbeatInterval || 15000; // 从配置读取心跳间隔
+const HEARTBEAT_INTERVAL = config.server.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
 const SSE_HEARTBEAT = Buffer.from(': heartbeat\n\n');
 
 // 创建心跳定时器
@@ -136,7 +93,7 @@ const releaseChunkObject = (obj) => {
 registerMemoryPoolCleanup(chunkPool, () => memoryManager.getPoolSizes().chunk);
 
 // 启动内存管理器
-memoryManager.start(30000);
+memoryManager.start(MEMORY_CHECK_INTERVAL);
 
 const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
   const chunk = getChunkObject();
@@ -152,11 +109,6 @@ const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
 // 工具函数：零拷贝写入流式数据
 const writeStreamData = (res, data) => {
   const json = JSON.stringify(data);
-  // 释放对象回池
-  const delta = { reasoning_content: data.reasoning_content };
-  if (data.thoughtSignature) {
-    delta.thoughtSignature = data.thoughtSignature;
-  }
   res.write(SSE_PREFIX);
   res.write(json);
   res.write(SSE_SUFFIX);
@@ -169,38 +121,6 @@ const endStream = (res) => {
   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
-    }
-  };
-};
 
 // Gemini 兼容错误响应构造
 const buildGeminiErrorPayload = (error, statusCode) => {
@@ -278,12 +198,8 @@ app.use(express.static(publicDir));
 // 管理路由
 app.use('/admin', adminRouter);
 
-app.use((err, req, res, next) => {
-  if (err.type === 'entity.too.large') {
-    return res.status(413).json({ error: `请求体过大，最大支持 ${config.security.maxRequestSize}` });
-  }
-  next(err);
-});
+// 使用统一错误处理中间件
+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'];
@@ -390,13 +306,21 @@ app.post('/v1/chat/completions', async (req, res) => {
                 usageData = data.usage;
               } else if (data.type === 'reasoning') {
                 const delta = { reasoning_content: data.reasoning_content };
-                if (data.thoughtSignature) {
+                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) => ({ index, ...toolCall }));
+                // 根据配置决定是否透传工具调用中的签名
+                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 {
@@ -430,9 +354,16 @@ app.post('/v1/chat/completions', async (req, res) => {
       // DeepSeek 格式：reasoning_content 在 content 之前
       const message = { role: 'assistant' };
       if (reasoningContent) message.reasoning_content = reasoningContent;
-      if (reasoningSignature) message.thoughtSignature = reasoningSignature;
+      if (reasoningSignature && config.passSignatureToClient) message.thoughtSignature = reasoningSignature;
       message.content = content;
-      if (toolCalls.length > 0) message.tool_calls = toolCalls;
+      if (toolCalls.length > 0) {
+        // 根据配置决定是否透传工具调用中的签名
+        if (config.passSignatureToClient) {
+          message.tool_calls = toolCalls;
+        } else {
+          message.tool_calls = toolCalls.map(({ thoughtSignature, ...rest }) => rest);
+        }
+      }
       
       // 使用预构建的响应对象，减少内存分配
       const response = {

src/utils/errors.js

@@ -0,0 +1,231 @@
+/**
+ * 统一错误处理模块
+ * @module utils/errors
+ */
+
+/**
+ * 应用错误基类
+ */
+export class AppError extends Error {
+  /**
+   * @param {string} message - 错误消息
+   * @param {number} statusCode - HTTP 状态码
+   * @param {string} type - 错误类型
+   */
+  constructor(message, statusCode = 500, type = 'server_error') {
+    super(message);
+    this.name = 'AppError';
+    this.statusCode = statusCode;
+    this.type = type;
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * 上游 API 错误
+ */
+export class UpstreamApiError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   * @param {number} statusCode - HTTP 状态码
+   * @param {string|Object} rawBody - 原始响应体
+   */
+  constructor(message, statusCode, rawBody = null) {
+    super(message, statusCode, 'upstream_api_error');
+    this.name = 'UpstreamApiError';
+    this.rawBody = rawBody;
+    this.isUpstreamApiError = true;
+  }
+}
+
+/**
+ * 认证错误
+ */
+export class AuthenticationError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   */
+  constructor(message = '认证失败') {
+    super(message, 401, 'authentication_error');
+    this.name = 'AuthenticationError';
+  }
+}
+
+/**
+ * 授权错误
+ */
+export class AuthorizationError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   */
+  constructor(message = '无权限访问') {
+    super(message, 403, 'authorization_error');
+    this.name = 'AuthorizationError';
+  }
+}
+
+/**
+ * 验证错误
+ */
+export class ValidationError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   * @param {Object} details - 验证详情
+   */
+  constructor(message = '请求参数无效', details = null) {
+    super(message, 400, 'validation_error');
+    this.name = 'ValidationError';
+    this.details = details;
+  }
+}
+
+/**
+ * 资源未找到错误
+ */
+export class NotFoundError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   */
+  constructor(message = '资源未找到') {
+    super(message, 404, 'not_found');
+    this.name = 'NotFoundError';
+  }
+}
+
+/**
+ * 速率限制错误
+ */
+export class RateLimitError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   * @param {number} retryAfter - 重试等待时间（秒）
+   */
+  constructor(message = '请求过于频繁', retryAfter = null) {
+    super(message, 429, 'rate_limit_error');
+    this.name = 'RateLimitError';
+    this.retryAfter = retryAfter;
+  }
+}
+
+/**
+ * Token 相关错误
+ */
+export class TokenError extends AppError {
+  /**
+   * @param {string} message - 错误消息
+   * @param {string} tokenSuffix - Token 后缀（用于日志）
+   * @param {number} statusCode - HTTP 状态码
+   */
+  constructor(message, tokenSuffix = null, statusCode = 500) {
+    super(message, statusCode, 'token_error');
+    this.name = 'TokenError';
+    this.tokenSuffix = tokenSuffix;
+  }
+}
+
+/**
+ * 创建上游 API 错误（工厂函数）
+ * @param {string} message - 错误消息
+ * @param {number} status - HTTP 状态码
+ * @param {string|Object} rawBody - 原始响应体
+ * @returns {UpstreamApiError}
+ */
+export function createApiError(message, status, rawBody) {
+  return new UpstreamApiError(message, status, rawBody);
+}
+
+/**
+ * 构建 OpenAI 兼容的错误响应
+ * @param {Error} error - 错误对象
+ * @param {number} statusCode - HTTP 状态码
+ * @returns {{error: {message: string, type: string, code: number}}}
+ */
+export function buildOpenAIErrorPayload(error, statusCode) {
+  // 处理上游 API 错误
+  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
+        }
+      };
+    }
+  }
+
+  // 处理应用错误
+  if (error instanceof AppError) {
+    return {
+      error: {
+        message: error.message,
+        type: error.type,
+        code: error.statusCode
+      }
+    };
+  }
+
+  // 处理通用错误
+  return {
+    error: {
+      message: error.message || 'Internal server error',
+      type: 'server_error',
+      code: statusCode
+    }
+  };
+}
+
+/**
+ * Express 错误处理中间件
+ * @param {Error} err - 错误对象
+ * @param {import('express').Request} req - 请求对象
+ * @param {import('express').Response} res - 响应对象
+ * @param {import('express').NextFunction} next - 下一个中间件
+ */
+export function errorHandler(err, req, res, next) {
+  // 如果响应��发送，交给默认处理
+  if (res.headersSent) {
+    return next(err);
+  }
+
+  // 处理请求体过大错误
+  if (err.type === 'entity.too.large') {
+    return res.status(413).json({
+      error: {
+        message: '请求体过大',
+        type: 'payload_too_large',
+        code: 413
+      }
+    });
+  }
+
+  // 确定状态码
+  const statusCode = err.statusCode || err.status || 500;
+  
+  // 构建错误响应
+  const errorPayload = buildOpenAIErrorPayload(err, statusCode);
+  
+  return res.status(statusCode).json(errorPayload);
+}
+
+/**
+ * 异步路由包装器（自动捕获异步错误）
+ * @param {Function} fn - 异步路由处理函数
+ * @returns {Function} 包装后的路由处理函数
+ */
+export function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}

src/utils/imageStorage.js

@@ -1,48 +1,9 @@
 import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import config from '../config/config.js';
 import { getDefaultIp } from './utils.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 检测是否在 pkg 打包环境中运行
-const isPkg = typeof process.pkg !== 'undefined';
-
-// 获取图片存储目录
-// pkg 环境下使用可执行文件所在目录或当前工作目录
-function getImageDir() {
-  if (isPkg) {
-    // pkg 环境：优先使用可执行文件旁边的 public/images 目录
-    const exeDir = path.dirname(process.execPath);
-    const exeImageDir = path.join(exeDir, 'public', 'images');
-    try {
-      if (!fs.existsSync(exeImageDir)) {
-        fs.mkdirSync(exeImageDir, { recursive: true });
-      }
-      return exeImageDir;
-    } catch (e) {
-      // 如果无法创建，尝试当前工作目录
-      const cwdImageDir = path.join(process.cwd(), 'public', 'images');
-      try {
-        if (!fs.existsSync(cwdImageDir)) {
-          fs.mkdirSync(cwdImageDir, { recursive: true });
-        }
-        return cwdImageDir;
-      } catch (e2) {
-        // 最后使用用户主目录
-        const homeImageDir = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.antigravity', 'images');
-        if (!fs.existsSync(homeImageDir)) {
-          fs.mkdirSync(homeImageDir, { recursive: true });
-        }
-        return homeImageDir;
-      }
-    }
-  }
-  // 开发环境
-  return path.join(__dirname, '../../public/images');
-}
+import { getImageDir, isPkg } from './paths.js';
+import { MIME_TO_EXT } from '../constants/index.js';
 
 const IMAGE_DIR = getImageDir();
 
@@ -51,14 +12,6 @@ if (!isPkg && !fs.existsSync(IMAGE_DIR)) {
   fs.mkdirSync(IMAGE_DIR, { recursive: true });
 }
 
-// MIME 类型到文件扩展名映射
-const MIME_TO_EXT = {
-  'image/jpeg': 'jpg',
-  'image/png': 'png',
-  'image/gif': 'gif',
-  'image/webp': 'webp'
-};
-
 /**
  * 清理超过限制数量的旧图片
  * @param {number} maxCount - 最大保留图片数量

src/utils/memoryManager.js

@@ -2,11 +2,16 @@
  * 智能内存管理器
  * 采用分级策略，根据内存压力动态调整缓存和对象池
  * 目标：在保证性能的前提下，将内存稳定在 20MB 左右
+ * @module utils/memoryManager
  */
 
 import logger from './logger.js';
+import { MEMORY_THRESHOLDS, GC_COOLDOWN } from '../constants/index.js';
 
-// 内存压力级别
+/**
+ * 内存压力级别枚举
+ * @enum {string}
+ */
 const MemoryPressure = {
   LOW: 'low',       // < 15MB - 正常运行
   MEDIUM: 'medium', // 15-25MB - 轻度清理
@@ -14,13 +19,8 @@ const MemoryPressure = {
   CRITICAL: 'critical' // > 35MB - 紧急清理
 };
 
-// 阈值配置（字节）
-const THRESHOLDS = {
-  LOW: 15 * 1024 * 1024,      // 15MB
-  MEDIUM: 25 * 1024 * 1024,   // 25MB
-  HIGH: 35 * 1024 * 1024,     // 35MB
-  TARGET: 20 * 1024 * 1024    // 20MB 目标
-};
+// 使用导入的常量
+const THRESHOLDS = MEMORY_THRESHOLDS;
 
 // 对象池最大大小配置（根据压力调整）
 const POOL_SIZES = {
@@ -30,12 +30,19 @@ const POOL_SIZES = {
   [MemoryPressure.CRITICAL]: { chunk: 5, toolCall: 3, lineBuffer: 1 }
 };
 
+/**
+ * 内存管理器类
+ */
 class MemoryManager {
   constructor() {
+    /** @type {string} */
     this.currentPressure = MemoryPressure.LOW;
+    /** @type {Set<Function>} */
     this.cleanupCallbacks = new Set();
+    /** @type {number} */
     this.lastGCTime = 0;
-    this.gcCooldown = 10000; // GC 冷却时间 10秒
+    /** @type {number} */
+    this.gcCooldown = GC_COOLDOWN;
     this.checkInterval = null;
     this.isShuttingDown = false;
     

src/utils/openai_generation.js

@@ -0,0 +1,58 @@
+import config from '../config/config.js';
+import { REASONING_EFFORT_MAP, DEFAULT_STOP_SEQUENCES } from '../constants/index.js';
+
+function modelMapping(modelName) {
+  if (modelName === 'claude-sonnet-4-5-thinking') {
+    return 'claude-sonnet-4-5';
+  } else if (modelName === 'claude-opus-4-5') {
+    return 'claude-opus-4-5-thinking';
+  } else if (modelName === 'gemini-2.5-flash-thinking') {
+    return 'gemini-2.5-flash';
+  }
+  return modelName;
+}
+
+function isEnableThinking(modelName) {
+  return modelName.includes('-thinking') ||
+    modelName === 'gemini-2.5-pro' ||
+    modelName.startsWith('gemini-3-pro-') ||
+    modelName === 'rev19-uic3-1p' ||
+    modelName === 'gpt-oss-120b-medium';
+}
+
+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;
+  }
+  return generationConfig;
+}
+
+export {
+  modelMapping,
+  isEnableThinking,
+  generateGenerationConfig
+};

src/utils/openai_mapping.js

@@ -0,0 +1,81 @@
+import config from '../config/config.js';
+import { generateRequestId } from './idGenerator.js';
+import { openaiMessageToAntigravity } from './openai_messages.js';
+import { extractSystemInstruction } from './openai_system.js';
+import { convertOpenAIToolsToAntigravity } from './openai_tools.js';
+import { modelMapping, isEnableThinking, generateGenerationConfig } from './openai_generation.js';
+import os from 'os';
+
+function generateRequestBody(openaiMessages, modelName, parameters, openaiTools, token) {
+  const enableThinking = isEnableThinking(modelName);
+  const actualModelName = modelMapping(modelName);
+  const mergedSystemInstruction = extractSystemInstruction(openaiMessages);
+
+  let startIndex = 0;
+  if (config.useContextSystemPrompt) {
+    for (let i = 0; i < openaiMessages.length; i++) {
+      if (openaiMessages[i].role === 'system') {
+        startIndex = i + 1;
+      } else {
+        break;
+      }
+    }
+  }
+  const filteredMessages = openaiMessages.slice(startIndex);
+
+  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;
+}
+
+function prepareImageRequest(requestBody) {
+  if (!requestBody || !requestBody.request) return requestBody;
+  requestBody.request.generationConfig = { candidateCount: 1 };
+  requestBody.requestType = 'image_gen';
+  delete requestBody.request.systemInstruction;
+  delete requestBody.request.tools;
+  delete requestBody.request.toolConfig;
+  return requestBody;
+}
+
+function getDefaultIp() {
+  const interfaces = os.networkInterfaces();
+  for (const iface of Object.values(interfaces)) {
+    for (const inter of iface) {
+      if (inter.family === 'IPv4' && !inter.internal) {
+        return inter.address;
+      }
+    }
+  }
+  return '127.0.0.1';
+}
+
+export {
+  generateRequestId,
+  generateRequestBody,
+  prepareImageRequest,
+  getDefaultIp
+};

src/utils/openai_messages.js

@@ -0,0 +1,178 @@
+import { getReasoningSignature, getToolSignature } from './thoughtSignatureCache.js';
+import { setToolNameMapping } from './toolNameCache.js';
+import { getThoughtSignatureForModel, getToolSignatureForModel } from './openai_signatures.js';
+
+function extractImagesFromContent(content) {
+  const result = { text: '', images: [] };
+  if (typeof content === 'string') {
+    result.text = content;
+    return result;
+  }
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === 'text') {
+        result.text += item.text;
+      } else if (item.type === 'image_url') {
+        const imageUrl = item.image_url?.url || '';
+        const match = imageUrl.match(/^data:image\/(\w+);base64,(.+)$/);
+        if (match) {
+          const format = match[1];
+          const base64Data = match[2];
+          result.images.push({
+            inlineData: {
+              mimeType: `image/${format}`,
+              data: base64Data
+            }
+          });
+        }
+      }
+    }
+  }
+  return result;
+}
+
+function handleUserMessage(extracted, antigravityMessages) {
+  antigravityMessages.push({
+    role: 'user',
+    parts: [
+      { text: extracted.text },
+      ...extracted.images
+    ]
+  });
+}
+
+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';
+  }
+  if (cleaned.length > 128) {
+    cleaned = cleaned.slice(0, 128);
+  }
+  return cleaned;
+}
+
+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 antigravityTools = 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;
+      })
+    : [];
+
+  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);
+      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 });
+    }
+
+    if (hasContent) parts.push({ text: message.content.trimEnd() });
+    parts.push(...antigravityTools);
+
+    antigravityMessages.push({
+      role: 'model',
+      parts
+    });
+  }
+}
+
+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]
+    });
+  }
+}
+
+function openaiMessageToAntigravity(openaiMessages, enableThinking, actualModelName, sessionId) {
+  const antigravityMessages = [];
+  for (const message of openaiMessages) {
+    if (message.role === 'user' || message.role === 'system') {
+      const extracted = extractImagesFromContent(message.content);
+      handleUserMessage(extracted, antigravityMessages);
+    } else if (message.role === 'assistant') {
+      handleAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId);
+    } else if (message.role === 'tool') {
+      handleToolCall(message, antigravityMessages);
+    }
+  }
+  return antigravityMessages;
+}
+
+export {
+  extractImagesFromContent,
+  handleUserMessage,
+  sanitizeToolName,
+  handleAssistantMessage,
+  handleToolCall,
+  openaiMessageToAntigravity
+};

src/utils/openai_signatures.js

@@ -0,0 +1,28 @@
+const CLAUDE_THOUGHT_SIGNATURE = 'RXFRRENrZ0lDaEFDR0FJcVFKV1Bvcy9GV20wSmtMV2FmWkFEbGF1ZTZzQTdRcFlTc1NvbklmemtSNFo4c1dqeitIRHBOYW9hS2NYTE1TeTF3bjh2T1RHdE1KVjVuYUNQclZ5cm9DMFNETHk4M0hOSWsrTG1aRUhNZ3hvTTl0ZEpXUDl6UUMzOExxc2ZJakI0UkkxWE1mdWJ1VDQrZnY0Znp0VEoyTlhtMjZKL2daYi9HL1gwcmR4b2x0VE54empLemtLcEp0ZXRia2plb3NBcWlRSWlXUHloMGhVVTk1dHNha1dyNDVWNUo3MTJjZDNxdHQ5Z0dkbjdFaFk4dUllUC9CcThVY2VZZC9YbFpYbDc2bHpEbmdzL2lDZXlNY3NuZXdQMjZBTDRaQzJReXdibVQzbXlSZmpld3ZSaUxxOWR1TVNidHIxYXRtYTJ0U1JIRjI0Z0JwUnpadE1RTmoyMjR4bTZVNUdRNXlOSWVzUXNFNmJzRGNSV0RTMGFVOEZERExybmhVQWZQT2JYMG5lTGR1QnU1VGZOWW9NZglRbTgyUHVqVE1xaTlmN0t2QmJEUUdCeXdyVXR2eUNnTEFHNHNqeWluZDRCOEg3N2ZJamt5blI3Q3ZpQzlIOTVxSENVTCt3K3JzMmsvV0sxNlVsbGlTK0pET3UxWXpPMWRPOUp3V3hEMHd5ZVU0a0Y5MjIxaUE5Z2lUd2djZXhSU2c4TWJVMm1NSjJlaGdlY3g0YjJ3QloxR0FFPQ==';
+const GEMINI_THOUGHT_SIGNATURE = 'EqAHCp0HAXLI2nygRbdzD4Vgzxxi7tbM87zIRkNgPLqTj+Jxv9mY8Q0G87DzbTtvsIFhWB0RZMoEK6ntm5GmUe6ADtxHk4zgHUs/FKqTu8tzUdPRDrKn3KCAtFW4LJqijZoFxNKMyQRmlgPUX4tGYE7pllD77UK6SjCwKhKZoSVZLMiPXP9YFktbida1Q5upXMrzG1t8abPmpFo983T/rgWlNqJp+Fb+bsoH0zuSpmU4cPKO3LIGsxBhvRhM/xydahZD+VpEX7TEJAN58z1RomFyx9u0IR7ukwZr2UyoNA+uj8OChUDFupQsVwbm3XE1UAt22BGvfYIyyZ42fxgOgsFFY+AZ72AOufcmZb/8vIw3uEUgxHczdl+NGLuS4Hsy/AAntdcH9sojSMF3qTf+ZK1FMav23SPxUBtU5T9HCEkKqQWRnMsVGYV1pupFisWo85hRLDTUipxVy9ug1hN8JBYBNmGLf8KtWLhVp7Z11PIAZj3C6HzoVyiVeuiorwNrn0ZaaXNe+y5LHuDF0DNZhrIfnXByq6grLLSAv4fTLeCJvfGzTWWyZDMbVXNx1HgumKq8calP9wv33t0hfEaOlcmfGIyh1J/N+rOGR0WXcuZZP5/VsFR44S2ncpwTPT+MmR0PsjocDenRY5m/X4EXbGGkZ+cfPnWoA64bn3eLeJTwxl9W1ZbmYS6kjpRGUMxExgRNOzWoGISddHCLcQvN7o50K8SF5k97rxiS5q4rqDmqgRPXzQTQnZyoL3dCxScX9cvLSjNCZDcotonDBAWHfkXZ0/EmFiONQcLJdANtAjwoA44Mbn50gubrTsNd7d0Rm/hbNEh/ZceUalV5MMcl6tJtahCJoybQMsnjWuBXl7cXiKmqAvxTDxIaBgQBYAo4FrbV4zQv35zlol+O3YiyjJn/U0oBeO5pEcH1d0vnLgYP71jZVY2FjWRKnDR9aw4JhiuqAa+i0tupkBy+H4/SVwHADFQq6wcsL8qvXlwktJL9MIAoaXDkIssw6gKE9EuGd7bSO9f+sA8CZ0I8LfJ3jcHUsE/3qd4pFrn5RaET56+1p8ZHZDDUQ0p1okApUCCYsC2WuL6O9P4fcg3yitAA/AfUUNjHKANE+ANneQ0efMG7fx9bvI+iLbXgPupApoov24JRkmhHsrJiu9bp+G/pImd2PNv7ArunJ6upl0VAUWtRyLWyGfdl6etGuY8vVJ7JdWEQ8aWzRK3g6e+8YmDtP5DAfw==';
+const CLAUDE_TOOL_SIGNATURE = 'RXVNQkNrZ0lDaEFDR0FJcVFLZGsvMnlyR0VTbmNKMXEyTFIrcWwyY2ozeHhoZHRPb0VOYWJ2VjZMSnE2MlBhcEQrUWdIM3ZWeHBBUG9rbGN1aXhEbXprZTcvcGlkbWRDQWs5MWcrTVNERnRhbWJFOU1vZWZGc1pWSGhvTUxsMXVLUzRoT3BIaWwyeXBJakNYa05EVElMWS9talprdUxvRjFtMmw5dnkrbENhSDNNM3BYNTM0K1lRZ0NaWTQvSUNmOXo4SkhZVzU2Sm1WcTZBcVNRUURBRGVMV1BQRXk1Q0JsS0dCZXlNdHp2NGRJQVlGbDFSMDBXNGhqNHNiSWNKeGY0UGZVQTBIeE1mZjJEYU5BRXdrWUJ4MmNzRFMrZGM1N1hnUlVNblpkZ0hTVHVNaGdod1lBUT09';
+const GEMINI_TOOL_SIGNATURE = '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';
+
+const DEFAULT_THOUGHT_SIGNATURE = CLAUDE_THOUGHT_SIGNATURE;
+const DEFAULT_TOOL_SIGNATURE = CLAUDE_TOOL_SIGNATURE;
+
+function getThoughtSignatureForModel(actualModelName) {
+  if (!actualModelName) return DEFAULT_THOUGHT_SIGNATURE;
+  const lower = actualModelName.toLowerCase();
+  if (lower.includes('claude')) return CLAUDE_THOUGHT_SIGNATURE;
+  if (lower.includes('gemini')) return GEMINI_THOUGHT_SIGNATURE;
+  return DEFAULT_THOUGHT_SIGNATURE;
+}
+
+function getToolSignatureForModel(actualModelName) {
+  if (!actualModelName) return DEFAULT_TOOL_SIGNATURE;
+  const lower = actualModelName.toLowerCase();
+  if (lower.includes('claude')) return CLAUDE_TOOL_SIGNATURE;
+  if (lower.includes('gemini')) return GEMINI_TOOL_SIGNATURE;
+  return DEFAULT_TOOL_SIGNATURE;
+}
+
+export {
+  getThoughtSignatureForModel,
+  getToolSignatureForModel
+};

src/utils/openai_system.js

@@ -0,0 +1,33 @@
+import config from '../config/config.js';
+
+function extractSystemInstruction(openaiMessages) {
+  const baseSystem = config.systemInstruction || '';
+  if (!config.useContextSystemPrompt) {
+    return baseSystem;
+  }
+  const systemTexts = [];
+  for (const message of openaiMessages) {
+    if (message.role === 'system') {
+      const content = typeof message.content === 'string'
+        ? message.content
+        : (Array.isArray(message.content)
+            ? message.content.filter(item => item.type === 'text').map(item => item.text).join('')
+            : '');
+      if (content.trim()) {
+        systemTexts.push(content.trim());
+      }
+    } else {
+      break;
+    }
+  }
+  const parts = [];
+  if (baseSystem.trim()) {
+    parts.push(baseSystem.trim());
+  }
+  if (systemTexts.length > 0) {
+    parts.push(systemTexts.join('\n\n'));
+  }
+  return parts.join('\n\n');
+}
+
+export { extractSystemInstruction };

src/utils/openai_tools.js

@@ -0,0 +1,83 @@
+import { setToolNameMapping } from './toolNameCache.js';
+
+const EXCLUDED_KEYS = new Set([
+  '$schema',
+  'additionalProperties',
+  'minLength',
+  'maxLength',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'exclusiveMaximum',
+  'exclusiveMinimum',
+  'const',
+  'anyOf',
+  'oneOf',
+  'allOf',
+  'any_of',
+  'one_of',
+  'all_of'
+]);
+
+function cleanParameters(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  const cleaned = Array.isArray(obj) ? [] : {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (EXCLUDED_KEYS.has(key)) continue;
+    const cleanedValue = (value && typeof value === 'object') ? cleanParameters(value) : value;
+    cleaned[key] = cleanedValue;
+  }
+  return cleaned;
+}
+
+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';
+  }
+  if (cleaned.length > 128) {
+    cleaned = cleaned.slice(0, 128);
+  }
+  return cleaned;
+}
+
+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 {
+  cleanParameters,
+  sanitizeToolName,
+  convertOpenAIToolsToAntigravity
+};

src/utils/paths.js

@@ -0,0 +1,218 @@
+/**
+ * 路径工具模块
+ * 统一处理 pkg 打包环境和开发环境下的路径获取
+ * @module utils/paths
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 检测是否在 pkg 打包环境中运行
+ * @type {boolean}
+ */
+export const isPkg = typeof process.pkg !== 'undefined';
+
+/**
+ * 获取项目根目录
+ * @returns {string} 项目根目录路径
+ */
+export function getProjectRoot() {
+  if (isPkg) {
+    return path.dirname(process.execPath);
+  }
+  return path.join(__dirname, '../..');
+}
+
+/**
+ * 获取数据目录路径
+ * pkg 环境下使用可执行文件所在目录或当前工作目录
+ * @returns {string} 数据目录路径
+ */
+export function getDataDir() {
+  if (isPkg) {
+    // pkg 环境：优先使用可执行文件旁边的 data 目录
+    const exeDir = path.dirname(process.execPath);
+    const exeDataDir = path.join(exeDir, 'data');
+    // 检查是否可以在该目录创建文件
+    try {
+      if (!fs.existsSync(exeDataDir)) {
+        fs.mkdirSync(exeDataDir, { recursive: true });
+      }
+      return exeDataDir;
+    } catch (e) {
+      // 如果无法创建，尝试当前工作目录
+      const cwdDataDir = path.join(process.cwd(), 'data');
+      try {
+        if (!fs.existsSync(cwdDataDir)) {
+          fs.mkdirSync(cwdDataDir, { recursive: true });
+        }
+        return cwdDataDir;
+      } catch (e2) {
+        // 最后使用用户主目录
+        const homeDataDir = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.antigravity', 'data');
+        if (!fs.existsSync(homeDataDir)) {
+          fs.mkdirSync(homeDataDir, { recursive: true });
+        }
+        return homeDataDir;
+      }
+    }
+  }
+  // 开发环境
+  return path.join(__dirname, '..', '..', 'data');
+}
+
+/**
+ * 获取公共静态文件目录
+ * @returns {string} public 目录路径
+ */
+export function getPublicDir() {
+  if (isPkg) {
+    // pkg 环境：优先使用可执行文件旁边的 public 目录
+    const exeDir = path.dirname(process.execPath);
+    const exePublicDir = path.join(exeDir, 'public');
+    if (fs.existsSync(exePublicDir)) {
+      return exePublicDir;
+    }
+    // 其次使用当前工作目录的 public 目录
+    const cwdPublicDir = path.join(process.cwd(), 'public');
+    if (fs.existsSync(cwdPublicDir)) {
+      return cwdPublicDir;
+    }
+    // 最后使用打包内的 public 目录（通过 snapshot）
+    return path.join(__dirname, '../../public');
+  }
+  // 开发环境
+  return path.join(__dirname, '../../public');
+}
+
+/**
+ * 获取图片存储目录
+ * @returns {string} 图片目录路径
+ */
+export function getImageDir() {
+  if (isPkg) {
+    // pkg 环境：优先使用可执行文件旁边的 public/images 目录
+    const exeDir = path.dirname(process.execPath);
+    const exeImageDir = path.join(exeDir, 'public', 'images');
+    try {
+      if (!fs.existsSync(exeImageDir)) {
+        fs.mkdirSync(exeImageDir, { recursive: true });
+      }
+      return exeImageDir;
+    } catch (e) {
+      // 如果无法创建，尝试当前工作目录
+      const cwdImageDir = path.join(process.cwd(), 'public', 'images');
+      try {
+        if (!fs.existsSync(cwdImageDir)) {
+          fs.mkdirSync(cwdImageDir, { recursive: true });
+        }
+        return cwdImageDir;
+      } catch (e2) {
+        // 最后使用用户主目录
+        const homeImageDir = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.antigravity', 'images');
+        if (!fs.existsSync(homeImageDir)) {
+          fs.mkdirSync(homeImageDir, { recursive: true });
+        }
+        return homeImageDir;
+      }
+    }
+  }
+  // 开发环境
+  return path.join(__dirname, '../../public/images');
+}
+
+/**
+ * 获取 .env 文件路径
+ * @returns {string} .env 文件路径
+ */
+export function getEnvPath() {
+  if (isPkg) {
+    // pkg 环境：优先使用可执行文件旁边的 .env
+    const exeDir = path.dirname(process.execPath);
+    const exeEnvPath = path.join(exeDir, '.env');
+    if (fs.existsSync(exeEnvPath)) {
+      return exeEnvPath;
+    }
+    // 其次使用当前工作目录的 .env
+    const cwdEnvPath = path.join(process.cwd(), '.env');
+    if (fs.existsSync(cwdEnvPath)) {
+      return cwdEnvPath;
+    }
+    // 返回可执行文件目录的路径（即使不存在）
+    return exeEnvPath;
+  }
+  // 开发环境
+  return path.join(__dirname, '../../.env');
+}
+
+/**
+ * 获取配置文件路径集合
+ * @returns {{envPath: string, configJsonPath: string, examplePath: string}} 配置文件路径
+ */
+export function getConfigPaths() {
+  if (isPkg) {
+    // pkg 环境：优先使用可执行文件旁边的配置文件
+    const exeDir = path.dirname(process.execPath);
+    const cwdDir = process.cwd();
+    
+    // 查找 .env 文件
+    let envPath = path.join(exeDir, '.env');
+    if (!fs.existsSync(envPath)) {
+      const cwdEnvPath = path.join(cwdDir, '.env');
+      if (fs.existsSync(cwdEnvPath)) {
+        envPath = cwdEnvPath;
+      }
+    }
+    
+    // 查找 config.json 文件
+    let configJsonPath = path.join(exeDir, 'config.json');
+    if (!fs.existsSync(configJsonPath)) {
+      const cwdConfigPath = path.join(cwdDir, 'config.json');
+      if (fs.existsSync(cwdConfigPath)) {
+        configJsonPath = cwdConfigPath;
+      }
+    }
+    
+    // 查找 .env.example 文件
+    let examplePath = path.join(exeDir, '.env.example');
+    if (!fs.existsSync(examplePath)) {
+      const cwdExamplePath = path.join(cwdDir, '.env.example');
+      if (fs.existsSync(cwdExamplePath)) {
+        examplePath = cwdExamplePath;
+      }
+    }
+    
+    return { envPath, configJsonPath, examplePath };
+  }
+  
+  // 开发环境
+  return {
+    envPath: path.join(__dirname, '../../.env'),
+    configJsonPath: path.join(__dirname, '../../config.json'),
+    examplePath: path.join(__dirname, '../../.env.example')
+  };
+}
+
+/**
+ * 计算相对路径用于日志显示
+ * @param {string} absolutePath - 绝对路径
+ * @returns {string} 相对路径或原路径
+ */
+export function getRelativePath(absolutePath) {
+  if (isPkg) {
+    const exeDir = path.dirname(process.execPath);
+    if (absolutePath.startsWith(exeDir)) {
+      return '.' + absolutePath.slice(exeDir.length).replace(/\\/g, '/');
+    }
+    const cwdDir = process.cwd();
+    if (absolutePath.startsWith(cwdDir)) {
+      return '.' + absolutePath.slice(cwdDir.length).replace(/\\/g, '/');
+    }
+  }
+  return absolutePath;
+}

src/utils/utils.js

@@ -865,4 +865,4 @@ export{
   generateClaudeRequestBody,
   prepareImageRequest,
   getDefaultIp
-}
+}