coding-tool-x 3.5.4 → 3.5.6

package/src/server/gemini-proxy-server.js

@@ -15,6 +15,7 @@ const { getEffectiveApiKey } = require('./services/gemini-channels');
 const { persistProxyRequestSnapshot } = require('./services/request-logger');
 const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
 const { redirectModel: redirectModelBase, resolveTargetUrl } = require('./services/base/proxy-utils');
+const { parseSSEUsage, parseNonStreamingUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
 const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
 
 let proxyServer = null;
@@ -207,6 +208,14 @@ async function startGeminiProxyServer(options = {}) {
             // 替换 URL 中的模型名称
             req.url = req.url.replace(`/models/${originalModel}`, `/models/${redirectedModel}`);
 
+            // 将原始模型和重定向模型存入 metadata，用于日志记录
+            const meta = requestMetadata.get(req);
+            if (meta) {
+              meta.originalModel = originalModel;
+              meta.redirectedModel = redirectedModel;
+              meta.modelFromUrl = redirectedModel;
+            }
+
             // 只在重定向规则变化时打印日志（避免每次请求都打印）
             const cachedRedirects = printedGeminiRedirectCache.get(channel.id) || {};
             if (cachedRedirects[originalModel] !== redirectedModel) {
@@ -306,14 +315,7 @@ async function startGeminiProxyServer(options = {}) {
       });
 
       let buffer = '';
-      let tokenData = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cachedTokens: 0,
-        reasoningTokens: 0,
-        totalTokens: 0,
-        model: ''
-      };
+      let tokenData = createTokenData();
       let usageRecorded = false;
       const parsedStream = createDecodedStream(proxyRes);
 
@@ -333,6 +335,8 @@ async function startGeminiProxyServer(options = {}) {
           tokens: {
             input: tokenData.inputTokens,
             output: tokenData.outputTokens,
+            cacheCreation: tokenData.cacheCreation,
+            cacheRead: tokenData.cacheRead,
             cached: tokenData.cachedTokens,
             reasoning: tokenData.reasoningTokens,
             total: tokenData.totalTokens
@@ -341,7 +345,7 @@ async function startGeminiProxyServer(options = {}) {
           broadcastLog,
           recordRequest: recordGeminiRequest,
           recordSuccess,
-          allowBroadcast: !isResponseClosed
+          allowBroadcast: true
         });
 
         if (!result) {
@@ -353,7 +357,6 @@ async function startGeminiProxyServer(options = {}) {
       }
 
       parsedStream.on('data', (chunk) => {
-        // 如果响应已关闭，停止处理
         if (isResponseClosed) {
           return;
         }
@@ -362,56 +365,34 @@ async function startGeminiProxyServer(options = {}) {
 
         // 检查是否是 SSE 流
         if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          // 处理 SSE 事件
           const events = buffer.split('\n\n');
           buffer = events.pop() || '';
 
-          events.forEach((eventText, index) => {
+          events.forEach((eventText) => {
             if (!eventText.trim()) return;
 
             try {
               const lines = eventText.split('\n');
+              let eventType = '';
               let data = '';
 
               lines.forEach(line => {
-                if (line.startsWith('data:')) {
+                if (line.startsWith('event:')) {
+                  eventType = line.substring(6).trim();
+                } else if (line.startsWith('data:')) {
                   data = line.substring(5).trim();
                 }
               });
 
-              if (!data) return;
-
-              if (data === '[DONE]') return;
+              if (!data || data === '[DONE]') return;
 
               const parsed = JSON.parse(data);
+              const usage = parseSSEUsage(parsed, eventType);
+              mergeUsageIntoTokenData(tokenData, usage);
 
-              // 提取模型信息
-              if (parsed.model && !tokenData.model) {
-                tokenData.model = parsed.model;
-              }
-
-              // 提取 usage 信息 (支持 OpenAI 和 Gemini 原生格式)
-              if (parsed.usage) {
-                tokenData.inputTokens = parsed.usage.prompt_tokens || parsed.usage.input_tokens || 0;
-                tokenData.outputTokens = parsed.usage.completion_tokens || parsed.usage.output_tokens || 0;
-                tokenData.totalTokens = parsed.usage.total_tokens || 0;
-
-                // Gemini 可能包含缓存信息
-                if (parsed.usage.prompt_tokens_details) {
-                  tokenData.cachedTokens = parsed.usage.prompt_tokens_details.cached_tokens || 0;
-                }
-              } else if (parsed.usageMetadata) {
-                tokenData.inputTokens = parsed.usageMetadata.promptTokenCount || 0;
-                tokenData.outputTokens = parsed.usageMetadata.candidatesTokenCount || 0;
-                tokenData.totalTokens = parsed.usageMetadata.totalTokenCount || 0;
-
-                // Gemini 缓存信息
-                if (parsed.usageMetadata.cachedContentTokenCount) {
-                  tokenData.cachedTokens = parsed.usageMetadata.cachedContentTokenCount;
-                }
+              if (usage.isDone) {
+                recordUsageIfReady();
               }
-
-              recordUsageIfReady();
             } catch (err) {
               // 忽略解析错误
             }
@@ -424,30 +405,8 @@ async function startGeminiProxyServer(options = {}) {
         if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
           try {
             const parsed = JSON.parse(buffer);
-            if (parsed.model) {
-              tokenData.model = parsed.model;
-            }
-
-            // OpenAI 格式
-            if (parsed.usage) {
-              tokenData.inputTokens = parsed.usage.prompt_tokens || parsed.usage.input_tokens || 0;
-              tokenData.outputTokens = parsed.usage.completion_tokens || parsed.usage.output_tokens || 0;
-              tokenData.totalTokens = parsed.usage.total_tokens || 0;
-
-              if (parsed.usage.prompt_tokens_details) {
-                tokenData.cachedTokens = parsed.usage.prompt_tokens_details.cached_tokens || 0;
-              }
-            }
-            // Gemini 原生格式
-            else if (parsed.usageMetadata) {
-              tokenData.inputTokens = parsed.usageMetadata.promptTokenCount || 0;
-              tokenData.outputTokens = parsed.usageMetadata.candidatesTokenCount || 0;
-              tokenData.totalTokens = parsed.usageMetadata.totalTokenCount || 0;
-
-              if (parsed.usageMetadata.cachedContentTokenCount) {
-                tokenData.cachedTokens = parsed.usageMetadata.cachedContentTokenCount;
-              }
-            }
+            const usage = parseNonStreamingUsage(parsed);
+            mergeUsageIntoTokenData(tokenData, usage);
           } catch (err) {
             // 忽略解析错误
           }

package/src/server/index.js

@@ -21,7 +21,7 @@ const { startProxyServer } = require('./proxy-server');
 const { startCodexProxyServer } = require('./codex-proxy-server');
 const { startGeminiProxyServer } = require('./gemini-proxy-server');
 const { startOpenCodeProxyServer, collectProxyModelList } = require('./opencode-proxy-server');
-const { createRemoteMutationGuard } = require('./services/network-access');
+const { createRemoteMutationGuard, isRemoteMutationAllowed } = require('./services/network-access');
 const { createApiRequestLogger } = require('./services/request-logger');
 
 function getInquirer() {
@@ -132,7 +132,9 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
 
   const app = express();
   const lanMode = host === '0.0.0.0';
-  const allowRemoteMutation = process.env.CC_TOOL_ALLOW_REMOTE_WRITE === 'true';
+  const allowRemoteMutation = lanMode
+    ? isRemoteMutationAllowed(process.env.CC_TOOL_ALLOW_REMOTE_WRITE)
+    : true;
 
   // Middleware
   app.use(express.json({ limit: '100mb' }));
@@ -156,7 +158,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     app.use('/api', createRemoteMutationGuard({
       enabled: true,
       allowRemoteMutation,
-      message: '出于安全考虑，LAN 模式默认仅允许本机执行写操作。可设置 CC_TOOL_ALLOW_REMOTE_WRITE=true 覆盖。'
+      message: '当前已禁用 LAN 远程写操作，可设置 CC_TOOL_ALLOW_REMOTE_WRITE=true 重新开启。'
     }));
 
   }
@@ -283,7 +285,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   console.log(`   ws://localhost:${port}/ws\n`);
 
   if (host === '0.0.0.0' && !allowRemoteMutation) {
-    console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作默认禁用'));
+    console.log(chalk.yellow('   [LOCK] 已禁用 LAN 远程写操作 (CC_TOOL_ALLOW_REMOTE_WRITE=false)'));
   }
   // 自动恢复代理状态
   autoRestoreProxies();

package/src/server/opencode-proxy-server.js

@@ -22,6 +22,7 @@ const { persistProxyRequestSnapshot, loadClaudeRequestTemplate } = require('./se
 const { probeModelAvailability, fetchModelsFromProvider } = require('./services/model-detector');
 const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
 const { redirectModel, resolveTargetUrl } = require('./services/base/proxy-utils');
+const { parseSSEUsage, parseNonStreamingUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
 const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
 
 let proxyServer = null;
@@ -4322,6 +4323,13 @@ async function startOpenCodeProxyServer(options = {}) {
             // 更新 rawBody 以匹配修改后的 body
             req.rawBody = Buffer.from(JSON.stringify(req.body));
 
+            // 将原始模型和重定向模型存入 metadata，用于日志记录
+            const meta = requestMetadata.get(req);
+            if (meta) {
+              meta.originalModel = originalModel;
+              meta.redirectedModel = redirectedModel;
+            }
+
             // 只在重定向规则变化时打印日志（避免每次请求都打印）
             const cachedRedirects = printedRedirectCache.get(channel.id) || {};
             if (cachedRedirects[originalModel] !== redirectedModel) {
@@ -4456,14 +4464,7 @@ async function startOpenCodeProxyServer(options = {}) {
       });
 
       let buffer = '';
-      let tokenData = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cachedTokens: 0,
-        reasoningTokens: 0,
-        totalTokens: 0,
-        model: ''
-      };
+      let tokenData = createTokenData();
       let usageRecorded = false;
 
       function recordUsageIfReady() {
@@ -4478,6 +4479,8 @@ async function startOpenCodeProxyServer(options = {}) {
           tokens: {
             input: tokenData.inputTokens,
             output: tokenData.outputTokens,
+            cacheCreation: tokenData.cacheCreation,
+            cacheRead: tokenData.cacheRead,
             cached: tokenData.cachedTokens,
             reasoning: tokenData.reasoningTokens,
             total: tokenData.totalTokens
@@ -4486,7 +4489,7 @@ async function startOpenCodeProxyServer(options = {}) {
           broadcastLog,
           recordRequest: recordOpenCodeRequest,
           recordSuccess,
-          allowBroadcast: !isResponseClosed
+          allowBroadcast: true
         });
 
         if (!result) {
@@ -4498,7 +4501,6 @@ async function startOpenCodeProxyServer(options = {}) {
       }
 
       proxyRes.on('data', (chunk) => {
-        // 如果响应已关闭，停止处理
         if (isResponseClosed) {
           return;
         }
@@ -4507,64 +4509,34 @@ async function startOpenCodeProxyServer(options = {}) {
 
         // 检查是否是 SSE 流
         if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          // 处理 SSE 事件
           const events = buffer.split('\n\n');
           buffer = events.pop() || '';
 
-          events.forEach((eventText, index) => {
+          events.forEach((eventText) => {
             if (!eventText.trim()) return;
 
             try {
               const lines = eventText.split('\n');
+              let eventType = '';
               let data = '';
 
               lines.forEach(line => {
-                if (line.startsWith('data:')) {
+                if (line.startsWith('event:')) {
+                  eventType = line.substring(6).trim();
+                } else if (line.startsWith('data:')) {
                   data = line.substring(5).trim();
                 }
               });
 
-              if (!data) return;
-
-              if (data === '[DONE]') return;
+              if (!data || data === '[DONE]') return;
 
               const parsed = JSON.parse(data);
+              const usage = parseSSEUsage(parsed, eventType);
+              mergeUsageIntoTokenData(tokenData, usage);
 
-              // OpenAI Responses API: 在 response.completed 事件中获取 usage
-              if (parsed.type === 'response.completed' && parsed.response) {
-                // 从 response 对象中提取模型和 usage
-                if (parsed.response.model) {
-                  tokenData.model = parsed.response.model;
-                }
-
-                if (parsed.response.usage) {
-                  tokenData.inputTokens = parsed.response.usage.input_tokens || 0;
-                  tokenData.outputTokens = parsed.response.usage.output_tokens || 0;
-                  tokenData.totalTokens = parsed.response.usage.total_tokens || 0;
-
-                  // 提取详细信息
-                  if (parsed.response.usage.input_tokens_details) {
-                    tokenData.cachedTokens = parsed.response.usage.input_tokens_details.cached_tokens || 0;
-                  }
-                  if (parsed.response.usage.output_tokens_details) {
-                    tokenData.reasoningTokens = parsed.response.usage.output_tokens_details.reasoning_tokens || 0;
-                  }
-                }
-              }
-
-              // 兼容其他格式：直接在顶层的 model 和 usage
-              if (parsed.model && !tokenData.model) {
-                tokenData.model = parsed.model;
-              }
-
-              if (parsed.usage && tokenData.inputTokens === 0) {
-                // 兼容 Responses API 和 Chat Completions API
-                tokenData.inputTokens = parsed.usage.input_tokens || parsed.usage.prompt_tokens || 0;
-                tokenData.outputTokens = parsed.usage.output_tokens || parsed.usage.completion_tokens || 0;
-                tokenData.totalTokens = parsed.usage.total_tokens || (tokenData.inputTokens + tokenData.outputTokens);
+              if (usage.isDone) {
+                recordUsageIfReady();
               }
-
-              recordUsageIfReady();
             } catch (err) {
               // 忽略解析错误
             }
@@ -4577,15 +4549,8 @@ async function startOpenCodeProxyServer(options = {}) {
         if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
           try {
             const parsed = JSON.parse(buffer);
-            if (parsed.model) {
-              tokenData.model = parsed.model;
-            }
-            if (parsed.usage) {
-              // 兼容两种格式
-              tokenData.inputTokens = parsed.usage.input_tokens || parsed.usage.prompt_tokens || 0;
-              tokenData.outputTokens = parsed.usage.output_tokens || parsed.usage.completion_tokens || 0;
-              tokenData.totalTokens = parsed.usage.total_tokens || (tokenData.inputTokens + tokenData.outputTokens);
-            }
+            const usage = parseNonStreamingUsage(parsed);
+            mergeUsageIntoTokenData(tokenData, usage);
           } catch (err) {
             // 忽略解析错误
           }

package/src/server/proxy-server.js

@@ -20,6 +20,7 @@ const { getEffectiveApiKey } = require('./services/channels');
 const { persistProxyRequestSnapshot, persistClaudeRequestTemplate } = require('./services/request-logger');
 const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
 const { redirectModel } = require('./services/base/proxy-utils');
+const { parseSSEUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
 const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
 
 let proxyServer = null;
@@ -294,6 +295,13 @@ async function startProxyServer(options = {}) {
             // 更新 rawBody 以匹配修改后的 body
             req.rawBody = Buffer.from(JSON.stringify(req.body));
 
+            // 将原始模型和重定向模型存入 metadata，用于日志记录
+            const meta = requestMetadata.get(req);
+            if (meta) {
+              meta.originalModel = originalModel;
+              meta.redirectedModel = redirectedModel;
+            }
+
             // 只在重定向规则变化时打印日志（避免每次请求都打印）
             const cachedRedirects = printedRedirectCache.get(channel.id) || {};
             if (cachedRedirects[originalModel] !== redirectedModel) {
@@ -387,13 +395,7 @@ async function startProxyServer(options = {}) {
       });
 
       let buffer = '';
-      let tokenData = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheCreation: 0,
-        cacheRead: 0,
-        model: ''
-      };
+      let tokenData = createTokenData();
       let usageRecorded = false;
       const parsedStream = createDecodedStream(proxyRes);
 
@@ -408,13 +410,16 @@ async function startProxyServer(options = {}) {
             input: tokenData.inputTokens,
             output: tokenData.outputTokens,
             cacheCreation: tokenData.cacheCreation,
-            cacheRead: tokenData.cacheRead
+            cacheRead: tokenData.cacheRead,
+            cached: tokenData.cachedTokens,
+            reasoning: tokenData.reasoningTokens,
+            total: tokenData.totalTokens
           },
           calculateCost,
           broadcastLog,
           recordRequest,
           recordSuccess,
-          allowBroadcast: !isResponseClosed
+          allowBroadcast: true
         });
 
         if (!result) return false;
@@ -446,30 +451,13 @@ async function startProxyServer(options = {}) {
               }
             });
 
-            if (!data) return;
+            if (!data || data === '[DONE]') return;
 
             const parsed = JSON.parse(data);
+            const usage = parseSSEUsage(parsed, eventType);
+            mergeUsageIntoTokenData(tokenData, usage);
 
-            if (eventType === 'message_start' && parsed.message && parsed.message.model) {
-              tokenData.model = parsed.message.model;
-            }
-
-            if (parsed.usage) {
-              if (parsed.usage.input_tokens !== undefined) {
-                tokenData.inputTokens = parsed.usage.input_tokens;
-              }
-              if (parsed.usage.output_tokens !== undefined) {
-                tokenData.outputTokens = parsed.usage.output_tokens;
-              }
-              if (parsed.usage.cache_creation_input_tokens !== undefined) {
-                tokenData.cacheCreation = parsed.usage.cache_creation_input_tokens;
-              }
-              if (parsed.usage.cache_read_input_tokens !== undefined) {
-                tokenData.cacheRead = parsed.usage.cache_read_input_tokens;
-              }
-            }
-
-            if (eventType === 'message_stop') {
+            if (usage.isDone) {
               recordUsageIfReady();
             }
           } catch (err) {

package/src/server/services/base/response-usage-parser.js

@@ -0,0 +1,187 @@
+/**
+ * response-usage-parser.js - 统一响应解析器
+ *
+ * 从各种 AI 提供商（Claude / OpenAI / Gemini）的 SSE 事件和
+ * 非流式 JSON 响应中提取模型名称和 token 用量信息。
+ *
+ * 所有 proxy server 共用此模块，避免重复代码，
+ * 并确保模型重定向后仍能正确解析不同格式的响应。
+ */
+
+/**
+ * 从单个 SSE 事件的 parsed JSON 中提取 model 和 token 信息。
+ * 自动检测 Claude / OpenAI / Gemini 格式。
+ *
+ * @param {object} parsed - JSON.parse 后的事件数据
+ * @param {string} [eventType=''] - SSE event: 行的值（如 'message_start'）
+ * @returns {{ model: string|null, tokens: object|null, isDone: boolean }}
+ */
+function parseSSEUsage(parsed, eventType) {
+  if (!parsed || typeof parsed !== 'object') {
+    return { model: null, tokens: null, isDone: false };
+  }
+
+  let model = null;
+  let tokens = null;
+  let isDone = false;
+
+  // === Claude SSE 格式 ===
+  // event: message_start → parsed.message.model
+  // event: message_delta / message_stop → parsed.usage
+  if (eventType === 'message_start' && parsed.message && parsed.message.model) {
+    model = parsed.message.model;
+  }
+  if (eventType === 'message_stop') {
+    isDone = true;
+  }
+
+  // === OpenAI Responses API 格式 ===
+  // data: {"type": "response.completed", "response": {"model", "usage": {...}}}
+  if (parsed.type === 'response.completed' && parsed.response) {
+    if (parsed.response.model) {
+      model = parsed.response.model;
+    }
+    if (parsed.response.usage) {
+      tokens = {
+        input: parsed.response.usage.input_tokens || 0,
+        output: parsed.response.usage.output_tokens || 0,
+        total: parsed.response.usage.total_tokens || 0,
+      };
+      if (parsed.response.usage.input_tokens_details &&
+          parsed.response.usage.input_tokens_details.cached_tokens !== undefined) {
+        tokens.cached = parsed.response.usage.input_tokens_details.cached_tokens;
+      }
+      if (parsed.response.usage.output_tokens_details &&
+          parsed.response.usage.output_tokens_details.reasoning_tokens !== undefined) {
+        tokens.reasoning = parsed.response.usage.output_tokens_details.reasoning_tokens;
+      }
+    }
+    isDone = true;
+  }
+
+  // === parsed.usage（Claude 原生 + OpenAI Chat Completions 共用） ===
+  if (!tokens && parsed.usage) {
+    const t = {};
+
+    // Claude 格式字段
+    if (parsed.usage.input_tokens !== undefined) {
+      t.input = parsed.usage.input_tokens;
+    }
+    if (parsed.usage.output_tokens !== undefined) {
+      t.output = parsed.usage.output_tokens;
+    }
+    if (parsed.usage.cache_creation_input_tokens !== undefined) {
+      t.cacheCreation = parsed.usage.cache_creation_input_tokens;
+    }
+    if (parsed.usage.cache_read_input_tokens !== undefined) {
+      t.cacheRead = parsed.usage.cache_read_input_tokens;
+    }
+
+    // OpenAI Chat Completions 格式字段（fallback）
+    if (t.input === undefined && parsed.usage.prompt_tokens !== undefined) {
+      t.input = parsed.usage.prompt_tokens;
+    }
+    if (t.output === undefined && parsed.usage.completion_tokens !== undefined) {
+      t.output = parsed.usage.completion_tokens;
+    }
+    if (parsed.usage.total_tokens !== undefined) {
+      t.total = parsed.usage.total_tokens;
+    }
+
+    // OpenAI detailed breakdowns
+    if (parsed.usage.input_tokens_details &&
+        parsed.usage.input_tokens_details.cached_tokens !== undefined) {
+      t.cached = parsed.usage.input_tokens_details.cached_tokens;
+    }
+    if (parsed.usage.output_tokens_details &&
+        parsed.usage.output_tokens_details.reasoning_tokens !== undefined) {
+      t.reasoning = parsed.usage.output_tokens_details.reasoning_tokens;
+    }
+
+    // Gemini cache in OpenAI compat mode
+    if (parsed.usage.prompt_tokens_details &&
+        parsed.usage.prompt_tokens_details.cached_tokens !== undefined) {
+      t.cached = parsed.usage.prompt_tokens_details.cached_tokens;
+    }
+
+    if (Object.keys(t).length > 0) {
+      tokens = t;
+    }
+  }
+
+  // === Gemini Native 格式 ===
+  // parsed.usageMetadata.{promptTokenCount, candidatesTokenCount, ...}
+  if (!tokens && parsed.usageMetadata) {
+    tokens = {
+      input: parsed.usageMetadata.promptTokenCount || 0,
+      output: parsed.usageMetadata.candidatesTokenCount || 0,
+      total: parsed.usageMetadata.totalTokenCount || 0,
+    };
+    if (parsed.usageMetadata.cachedContentTokenCount) {
+      tokens.cached = parsed.usageMetadata.cachedContentTokenCount;
+    }
+  }
+
+  // === 通用 model fallback ===
+  if (!model && parsed.model) {
+    model = parsed.model;
+  }
+
+  return { model, tokens, isDone };
+}
+
+/**
+ * 从完整的非流式 JSON 响应中提取 model 和 token 信息。
+ *
+ * @param {object} parsed - JSON.parse 后的完整响应
+ * @returns {{ model: string|null, tokens: object|null, isDone: boolean }}
+ */
+function parseNonStreamingUsage(parsed) {
+  return parseSSEUsage(parsed, '');
+}
+
+/**
+ * 将解析结果合并到 tokenData 对象。
+ *
+ * @param {object} tokenData - 各 proxy 的 tokenData 累积对象
+ * @param {{ model: string|null, tokens: object|null, isDone: boolean }} usage - parseSSEUsage 的返回值
+ */
+function mergeUsageIntoTokenData(tokenData, usage) {
+  if (usage.model) {
+    tokenData.model = usage.model;
+  }
+  if (usage.tokens) {
+    if (usage.tokens.input !== undefined) tokenData.inputTokens = usage.tokens.input;
+    if (usage.tokens.output !== undefined) tokenData.outputTokens = usage.tokens.output;
+    if (usage.tokens.cacheCreation !== undefined) tokenData.cacheCreation = usage.tokens.cacheCreation;
+    if (usage.tokens.cacheRead !== undefined) tokenData.cacheRead = usage.tokens.cacheRead;
+    if (usage.tokens.cached !== undefined) tokenData.cachedTokens = usage.tokens.cached;
+    if (usage.tokens.reasoning !== undefined) tokenData.reasoningTokens = usage.tokens.reasoning;
+    if (usage.tokens.total !== undefined) tokenData.totalTokens = usage.tokens.total;
+  }
+}
+
+/**
+ * 创建统一的 tokenData 初始结构。
+ *
+ * @returns {object}
+ */
+function createTokenData() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreation: 0,
+    cacheRead: 0,
+    cachedTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    model: ''
+  };
+}
+
+module.exports = {
+  parseSSEUsage,
+  parseNonStreamingUsage,
+  mergeUsageIntoTokenData,
+  createTokenData
+};