coding-tool-x 3.5.3 → 3.5.5

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
+};

package/src/server/services/mcp-client.js

@@ -204,6 +204,8 @@ class McpClient extends EventEmitter {
     // HTTP/SSE transport state
     this._sseAbortController = null;
     this._httpSessionUrl = null;
+    this._httpSessionId = null;
+    this._negotiatedProtocolVersion = MCP_PROTOCOL_VERSION;
   }
 
   // --------------------------------------------------------------------------
@@ -249,11 +251,12 @@ class McpClient extends EventEmitter {
       }
     });
 
+    this._negotiatedProtocolVersion = result.protocolVersion || MCP_PROTOCOL_VERSION;
     this._serverCapabilities = result.capabilities || {};
     this._serverInfo = result.serverInfo || {};
 
     // Send initialized notification (no response expected)
-    this._notify('notifications/initialized', {});
+    await this._notify('notifications/initialized', {});
 
     this._initialized = true;
     this.emit('initialized', result);
@@ -654,11 +657,18 @@ class McpClient extends EventEmitter {
             'Content-Type': 'application/json',
             'Content-Length': Buffer.byteLength(body),
             'Accept': 'application/json, text/event-stream',
+            ...(msg.method !== 'initialize'
+              ? {
+                'MCP-Protocol-Version': this._negotiatedProtocolVersion || MCP_PROTOCOL_VERSION,
+                ...(this._httpSessionId ? { 'Mcp-Session-Id': this._httpSessionId } : {})
+              }
+              : {}),
             ...this._spec.headers
           }
         };
 
         const req = client.request(options, (res) => {
+          this._captureHttpResponseMetadata(res);
           let data = '';
           res.on('data', (chunk) => { data += chunk.toString(); });
           res.on('end', () => {
@@ -669,7 +679,19 @@ class McpClient extends EventEmitter {
               return;
             }
 
+            const isNotification = msg.id === undefined || msg.id === null;
             const contentType = res.headers['content-type'] || '';
+            const trimmedData = data.trim();
+
+            if (!trimmedData) {
+              if (isNotification || res.statusCode === 202 || res.statusCode === 204) {
+                resolve();
+                return;
+              }
+
+              reject(new McpClientError('Empty HTTP response for request'));
+              return;
+            }
 
             // JSON response (direct response to JSON-RPC)
             if (contentType.includes('application/json')) {
@@ -690,12 +712,6 @@ class McpClient extends EventEmitter {
               return;
             }
 
-            // Accepted with no body (202, notifications)
-            if (res.statusCode === 202 || !data.trim()) {
-              resolve();
-              return;
-            }
-
             // Try parsing as JSON anyway
             try {
               const parsed = JSON.parse(data);
@@ -761,6 +777,8 @@ class McpClient extends EventEmitter {
   /** @private */
   _disconnectHttp() {
     this._httpSessionUrl = null;
+    this._httpSessionId = null;
+    this._negotiatedProtocolVersion = MCP_PROTOCOL_VERSION;
   }
 
   // --------------------------------------------------------------------------
@@ -807,7 +825,7 @@ class McpClient extends EventEmitter {
   }
 
   /** @private */
-  _notify(method, params) {
+  async _notify(method, params) {
     const msg = {
       jsonrpc: JSONRPC_VERSION,
       method,
@@ -817,14 +835,20 @@ class McpClient extends EventEmitter {
     try {
       if (this._type === 'stdio') {
         this._sendStdio(msg);
+        return;
       } else {
-        // Fire-and-forget for HTTP notifications
-        this._sendHttp(msg).catch((err) => {
-          this.emit('error', new McpClientError(`Notification send failed: ${err.message}`));
-        });
+        await this._sendHttp(msg);
       }
     } catch (err) {
-      this.emit('error', new McpClientError(`Notification send failed: ${err.message}`));
+      throw new McpClientError(`Notification send failed: ${err.message}`);
+    }
+  }
+
+  /** @private */
+  _captureHttpResponseMetadata(res) {
+    const sessionId = res && res.headers ? res.headers['mcp-session-id'] : null;
+    if (typeof sessionId === 'string' && sessionId.trim()) {
+      this._httpSessionId = sessionId.trim();
     }
   }
 

package/src/server/services/proxy-log-helper.js

@@ -64,12 +64,14 @@ function buildSuccessLogPayload({
   requestId,
   channel,
   model,
+  originalModel,
+  redirectedModel,
   tokens,
   cost = 0,
   timestamp = Date.now()
 }) {
   const normalized = normalizeUsageTokens(source, tokens);
-  return {
+  const payload = {
     type: 'log',
     status: 'success',
     id: requestId,
@@ -87,6 +89,13 @@ function buildSuccessLogPayload({
     source: normalizeToolSource(source),
     timestamp
   };
+  if (originalModel) {
+    payload.originalModel = originalModel;
+  }
+  if (redirectedModel) {
+    payload.redirectedModel = redirectedModel;
+  }
+  return payload;
 }
 
 function buildFailureLogPayload({
@@ -160,6 +169,8 @@ function publishUsageLog({
       requestId,
       channel: metadata.channel,
       model,
+      originalModel: metadata.originalModel,
+      redirectedModel: metadata.redirectedModel,
       tokens: normalizedTokens,
       cost,
       timestamp
@@ -167,7 +178,7 @@ function publishUsageLog({
   }
 
   if (typeof recordRequest === 'function') {
-    recordRequest({
+    const entry = {
       id: requestId,
       timestamp: new Date(metadata.startTime || timestamp).toISOString(),
       toolType: normalizedSource === 'claude' ? 'claude-code' : normalizedSource,
@@ -186,7 +197,14 @@ function publishUsageLog({
       duration: Math.max(0, timestamp - toNumber(metadata.startTime || timestamp)),
       success: true,
       cost
-    });
+    };
+    if (metadata.originalModel) {
+      entry.originalModel = metadata.originalModel;
+    }
+    if (metadata.redirectedModel) {
+      entry.redirectedModel = metadata.redirectedModel;
+    }
+    recordRequest(entry);
   }
 
   if (typeof recordSuccess === 'function' && metadata.channelId) {

package/src/server/services/statistics-service.js

@@ -242,6 +242,13 @@ function recordRequest(requestData) {
       session,
       project
     };
+    // 如果有模型重定向信息，记录到日志中
+    if (requestData.originalModel) {
+      logEntry.originalModel = requestData.originalModel;
+    }
+    if (requestData.redirectedModel) {
+      logEntry.redirectedModel = requestData.redirectedModel;
+    }
     appendRequestLog(logEntry);
 
     // 2. 更新总体统计