coding-tool-x 3.6.7 → 3.6.8

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

@@ -15,7 +15,14 @@ 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 {
+  parseSSEUsage,
+  parseNonStreamingUsage,
+  splitSSEEvents,
+  parseSSEEventText,
+  mergeUsageIntoTokenData,
+  createTokenData
+} = require('./services/base/response-usage-parser');
 const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
 
 let proxyServer = null;
@@ -47,6 +54,12 @@ const PRICING = {
 };
 
 const GEMINI_BASE_PRICING = DEFAULT_CONFIG.pricing.gemini;
+const jsonBodyParser = express.json({
+  limit: '100mb',
+  verify: (req, res, buf) => {
+    req.rawBody = Buffer.from(buf);
+  }
+});
 
 // resolveGeminiTarget replaced by resolveTargetUrl from proxy-utils
 const resolveGeminiTarget = resolveTargetUrl;
@@ -56,6 +69,129 @@ function redirectModel(originalModel, channel) {
   return redirectModelBase(originalModel, channel, { useTierFallback: false });
 }
 
+function shouldParseJson(req) {
+  const contentType = req.headers['content-type'] || '';
+  return req.method === 'POST' && contentType.includes('application/json');
+}
+
+function isVertexAiV1Channel(channel) {
+  return String(channel?.apiFormat || '').trim().toLowerCase() === 'vertex_ai_v1';
+}
+
+function stripVertexFunctionResponseIdsFromParts(parts) {
+  if (!Array.isArray(parts)) return false;
+  let changed = false;
+
+  for (const part of parts) {
+    if (!part || typeof part !== 'object' || Array.isArray(part)) continue;
+    const functionResponse = part.functionResponse || part.function_response;
+    if (!functionResponse || typeof functionResponse !== 'object' || Array.isArray(functionResponse)) continue;
+    if (Object.prototype.hasOwnProperty.call(functionResponse, 'id')) {
+      delete functionResponse.id;
+      changed = true;
+    }
+  }
+
+  return changed;
+}
+
+function stripVertexFunctionResponseIds(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return false;
+  let changed = false;
+
+  if (Array.isArray(body.contents)) {
+    for (const content of body.contents) {
+      changed = stripVertexFunctionResponseIdsFromParts(content?.parts) || changed;
+    }
+  }
+
+  if (Array.isArray(body.cachedContent?.contents)) {
+    for (const content of body.cachedContent.contents) {
+      changed = stripVertexFunctionResponseIdsFromParts(content?.parts) || changed;
+    }
+  }
+
+  return changed;
+}
+
+function buildVertexAiV1Path(baseUrl, requestPath) {
+  let basePath = '';
+  try {
+    basePath = new URL(baseUrl).pathname.replace(/\/+$/, '');
+  } catch (_) {
+    basePath = String(baseUrl || '').replace(/\/+$/, '');
+  }
+
+  if (!basePath) {
+    return requestPath;
+  }
+
+  const actionMatch = String(requestPath || '').match(/\/models\/([^/:?]+)(:[^?]*)?(\?.*)?$/);
+  if (!actionMatch) {
+    return requestPath;
+  }
+
+  const encodedModel = actionMatch[1];
+  const suffix = actionMatch[2] || '';
+  const query = actionMatch[3] || '';
+  if (basePath.includes('/publishers/google')) {
+    return `/models/${encodedModel}${suffix}${query}`;
+  }
+  return `${basePath}/models/${encodedModel}${suffix}${query}`;
+}
+
+function parseJsonSafely(value) {
+  try {
+    return JSON.parse(value);
+  } catch (_) {
+    return null;
+  }
+}
+
+function extractGeminiUpstreamErrorMessage(rawBody, statusCode) {
+  const body = String(rawBody || '').trim();
+  const fallback = `Gemini upstream error: HTTP ${statusCode || 500}`;
+
+  if (!body) {
+    return fallback;
+  }
+
+  const parsed = parseJsonSafely(body);
+  const message = parsed?.error?.message
+    || parsed?.message
+    || (typeof parsed?.error === 'string' ? parsed.error : '')
+    || '';
+
+  if (message) {
+    return `Gemini upstream error (${statusCode || parsed?.error?.code || 500}): ${message}`;
+  }
+
+  const sseDataLine = body
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .find(line => line.startsWith('data:'));
+  if (sseDataLine) {
+    const eventPayload = sseDataLine.slice(5).trim();
+    if (eventPayload && eventPayload !== '[DONE]') {
+      const eventJson = parseJsonSafely(eventPayload);
+      const eventMessage = eventJson?.error?.message
+        || eventJson?.message
+        || (typeof eventJson?.error === 'string' ? eventJson.error : '')
+        || '';
+      if (eventMessage) {
+        return `Gemini upstream error (${statusCode || eventJson?.error?.code || 500}): ${eventMessage}`;
+      }
+    }
+  }
+
+  return `Gemini upstream error (${statusCode || 500}): ${body.slice(0, 500)}`;
+}
+
+function isHttpErrorStatus(statusCode) {
+  const code = Number(statusCode);
+  return Number.isFinite(code) && (code < 200 || code >= 300);
+}
+
 /**
  * 计算请求成本
  */
@@ -109,6 +245,14 @@ async function startGeminiProxyServer(options = {}) {
     currentPort = port;
 
     proxyApp = express();
+
+    proxyApp.use((req, res, next) => {
+      if (shouldParseJson(req)) {
+        return jsonBodyParser(req, res, next);
+      }
+      return next();
+    });
+
     const proxy = httpProxy.createProxyServer({});
 
     proxy.on('proxyReq', (proxyReq, req) => {
@@ -138,6 +282,15 @@ async function startGeminiProxyServer(options = {}) {
       if (!proxyReq.getHeader('content-type')) {
         proxyReq.setHeader('content-type', 'application/json');
       }
+
+      if (shouldParseJson(req) && (req.rawBody || req.body)) {
+        const bodyBuffer = req.rawBody
+          ? Buffer.isBuffer(req.rawBody) ? req.rawBody : Buffer.from(req.rawBody)
+          : Buffer.from(JSON.stringify(req.body));
+        proxyReq.setHeader('Content-Length', bodyBuffer.length);
+        proxyReq.write(bodyBuffer);
+        proxyReq.end();
+      }
     });
 
     proxyApp.use(async (req, res) => {
@@ -224,6 +377,20 @@ async function startGeminiProxyServer(options = {}) {
           }
         }
 
+        let bodyMutated = false;
+
+        if (isVertexAiV1Channel(channel) && stripVertexFunctionResponseIds(req.body)) {
+          bodyMutated = true;
+        }
+
+        if (isVertexAiV1Channel(channel)) {
+          req.url = buildVertexAiV1Path(channel.baseUrl, req.url);
+        }
+
+        if (bodyMutated) {
+          req.rawBody = Buffer.from(JSON.stringify(req.body));
+        }
+
         const target = resolveGeminiTarget(channel.baseUrl, req.url);
 
         proxy.web(req, res, {
@@ -315,6 +482,8 @@ async function startGeminiProxyServer(options = {}) {
       let buffer = '';
       let tokenData = createTokenData();
       let usageRecorded = false;
+      const upstreamStatusCode = Number(proxyRes.statusCode) || 200;
+      const isUpstreamError = isHttpErrorStatus(upstreamStatusCode);
       const parsedStream = createDecodedStream(proxyRes);
 
       function recordUsageIfReady() {
@@ -362,30 +531,19 @@ async function startGeminiProxyServer(options = {}) {
         buffer += chunk.toString('utf8');
 
         // 检查是否是 SSE 流
-        if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          const events = buffer.split('\n\n');
-          buffer = events.pop() || '';
+        if (!isUpstreamError && proxyRes.headers['content-type']?.includes('text/event-stream')) {
+          const parsedEvents = splitSSEEvents(buffer);
+          buffer = parsedEvents.remainder;
 
-          events.forEach((eventText) => {
+          parsedEvents.events.forEach((eventText) => {
             if (!eventText.trim()) return;
 
             try {
-              const lines = eventText.split('\n');
-              let eventType = '';
-              let data = '';
-
-              lines.forEach(line => {
-                if (line.startsWith('event:')) {
-                  eventType = line.substring(6).trim();
-                } else if (line.startsWith('data:')) {
-                  data = line.substring(5).trim();
-                }
-              });
+              const event = parseSSEEventText(eventText);
+              if (!event) return;
 
-              if (!data || data === '[DONE]') return;
-
-              const parsed = JSON.parse(data);
-              const usage = parseSSEUsage(parsed, eventType);
+              const parsed = JSON.parse(event.data);
+              const usage = parseSSEUsage(parsed, event.eventType);
               mergeUsageIntoTokenData(tokenData, usage);
 
               if (usage.isDone) {
@@ -399,6 +557,26 @@ async function startGeminiProxyServer(options = {}) {
       });
 
       parsedStream.on('end', () => {
+        if (isUpstreamError) {
+          const message = extractGeminiUpstreamErrorMessage(buffer, upstreamStatusCode);
+          const error = new Error(buffer.trim() || message);
+          recordFailure(metadata.channelId, 'gemini', error);
+          publishFailureLog({
+            source: 'gemini',
+            metadata,
+            message,
+            error,
+            statusCode: upstreamStatusCode,
+            stage: 'upstream_response',
+            broadcastLog
+          });
+
+          if (!isResponseClosed) {
+            requestMetadata.delete(req);
+          }
+          return;
+        }
+
         // 如果不是流式响应，尝试从完整响应中解析
         if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
           try {
@@ -568,5 +746,11 @@ module.exports = {
   stopGeminiProxyServer,
   getGeminiProxyStatus,
   clearGeminiRedirectCache,
-  calculateCost
+  calculateCost,
+  _test: {
+    buildVertexAiV1Path,
+    extractGeminiUpstreamErrorMessage,
+    isHttpErrorStatus,
+    stripVertexFunctionResponseIds
+  }
 };

package/src/server/index.js

@@ -213,6 +213,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   app.use('/api/config', require('./api/config'));
   app.use('/api/convert', require('./api/convert'));
   app.use('/api/statistics', require('./api/statistics'));
+  app.use('/api/claude/statistics', require('./api/claude-statistics'));
   app.use('/api/codex/statistics', require('./api/codex-statistics'));
   app.use('/api/gemini/statistics', require('./api/gemini-statistics'));
   app.use('/api/pm2-autostart', require('./api/pm2-autostart')());