protocol-proxy 2.8.0 → 2.8.2

package/lib/converters/anthropic-to-openai.js

@@ -82,12 +82,15 @@ function convertMessage(msg, idMap) {
   // 处理 content 数组
   if (Array.isArray(msg.content)) {
     const textParts = [];
+    const thinkingParts = [];
     const toolResults = [];
     const toolUses = [];
 
     for (const block of msg.content) {
       if (block.type === 'text') {
         textParts.push(block.text);
+      } else if (block.type === 'thinking') {
+        thinkingParts.push(block.thinking);
       } else if (block.type === 'tool_result') {
         // 使用映射后的 OpenAI 格式 id
         const openaiId = idMap?.get(block.tool_use_id) || block.tool_use_id;
@@ -112,13 +115,15 @@ function convertMessage(msg, idMap) {
 
     // assistant 消息含 tool_use → 需要拆分为 assistant + tool
     if (msg.role === 'assistant' && toolUses.length > 0) {
-      const result = [];
-      result.push({
+      const assistantMsg = {
         role: 'assistant',
         content: textParts.join('') || '',
         tool_calls: toolUses,
-      });
-      return result;
+      };
+      if (thinkingParts.length > 0) {
+        assistantMsg.reasoning_content = thinkingParts.join('');
+      }
+      return [assistantMsg];
     }
 
     // user 消息含 tool_result → 拆分为多个 tool 消息
@@ -133,7 +138,11 @@ function convertMessage(msg, idMap) {
     }
 
     // 普通情况
-    return { role: msg.role, content: textParts.join('') };
+    const out = { role: msg.role, content: textParts.join('') };
+    if (msg.role === 'assistant' && thinkingParts.length > 0) {
+      out.reasoning_content = thinkingParts.join('');
+    }
+    return out;
   }
 
   return { role: msg.role, content: msg.content };

package/lib/proxy-server.js

@@ -8,6 +8,7 @@ const a2g = require('./converters/anthropic-to-gemini');
 const g2a = require('./converters/gemini-to-anthropic');
 const { recordUsage } = require('./stats-store');
 const logger = require('./logger');
+const requestLog = require('./request-log');
 
 function createProxyApp(proxyConfigOrGetter) {
   const getProxyConfig = typeof proxyConfigOrGetter === 'function'
@@ -81,9 +82,13 @@ function createProxyApp(proxyConfigOrGetter) {
   function injectReasoningToMessages(messages) {
     if (!Array.isArray(messages)) return;
     for (const msg of messages) {
-      if (msg.role === 'assistant' && msg.reasoning_content === undefined) {
+      if (msg.role === 'assistant' && (msg.reasoning_content === undefined || msg.reasoning_content === null)) {
         const reasoning = getReasoning(msg);
-        msg.reasoning_content = reasoning || '';
+        if (reasoning) {
+          msg.reasoning_content = reasoning;
+        } else {
+          delete msg.reasoning_content;
+        }
       }
     }
   }
@@ -343,6 +348,7 @@ function createProxyApp(proxyConfigOrGetter) {
 
   async function handleRequest(req, res) {
     const requestId = `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const requestStart = Date.now();
     const proxyConfig = getProxyConfig();
     const inboundProtocol = detectInboundProtocol(req, req.body);
     const candidates = buildCandidates(proxyConfig);
@@ -353,6 +359,8 @@ function createProxyApp(proxyConfigOrGetter) {
 
     const isStream = req.body?.stream === true;
     const proxyId = proxyConfig.id || 'default';
+    const clientIP = req.ip || req.socket?.remoteAddress || '';
+    const proxyName = proxyConfig.name || '';
     const inboundModel = req.body?.model;
     const effectiveModel = proxyConfig.target?.defaultModel || inboundModel;
     const baseRequestBody = effectiveModel ? { ...req.body, model: effectiveModel } : { ...req.body };
@@ -448,6 +456,7 @@ function createProxyApp(proxyConfigOrGetter) {
 
       const maxKeyRetries = (candidate.apiKeys || []).filter(k => typeof k === 'object' ? k.enabled !== false : true).length || 1;
       let lastKeyError = null;
+      let keyLabel = '';
 
       for (let keyAttempt = 0; keyAttempt < maxKeyRetries; keyAttempt++) {
         const currentKey = selectKey(candidate.providerId, candidate.apiKeys || []);
@@ -471,7 +480,7 @@ function createProxyApp(proxyConfigOrGetter) {
           method: 'POST',
           headers: keyHeaders,
           body: JSON.stringify(targetBody),
-          signal: AbortSignal.timeout(300000),
+          signal: AbortSignal.timeout(proxyConfig.timeout || 300000),
         });
 
         if (!fetchRes.ok) {
@@ -493,7 +502,7 @@ function createProxyApp(proxyConfigOrGetter) {
         recordSuccess(proxyId, candidate.providerId, Date.now() - startedAt);
         const keyEntry = (candidate.apiKeys || []).find(k => (typeof k === 'string' ? k : k.key) === currentKey);
         const alias = keyEntry && typeof keyEntry === 'object' ? keyEntry.alias : '';
-        const keyLabel = alias ? `${alias}(…${currentKey.slice(-4)})` : (currentKey ? `…${currentKey.slice(-4)}` : '-');
+        keyLabel = alias ? `${alias}(…${currentKey.slice(-4)})` : (currentKey ? `…${currentKey.slice(-4)}` : '-');
         logger.log(`[${requestId}] ✓ ${candidate.providerName} | model=${candidateModel || '(default)'} key=${keyLabel} (${Date.now() - startedAt}ms)`);
 
         if (isStream) {
@@ -506,6 +515,7 @@ function createProxyApp(proxyConfigOrGetter) {
           const decoder = new TextDecoder();
           let streamUsage = null;
           let responseText = '';
+          let reasoningText = '';
           let toolCallCount = 0;
 
           req.on('close', () => {
@@ -525,6 +535,7 @@ function createProxyApp(proxyConfigOrGetter) {
                   if (d.usage) streamUsage = d.usage;
                   const delta = d.choices?.[0]?.delta;
                   if (delta?.content) responseText += delta.content;
+                  if (delta?.reasoning_content) reasoningText += delta.reasoning_content;
                   if (delta?.tool_calls) {
                     for (const tc of delta.tool_calls) {
                       if (tc.function?.name) toolCallCount++;
@@ -541,8 +552,26 @@ function createProxyApp(proxyConfigOrGetter) {
               }
             }
 
+            // Cache reasoning_content from streaming response for future requests
+            if (reasoningText && responseText) {
+              const msg = { content: responseText, tool_calls: null };
+              setReasoning(msg, reasoningText);
+            }
+
             if (streamUsage) {
               recordUsage(proxyConfig.id, candidate.providerName, candidateModel, streamUsage, false);
+              requestLog.add({
+                id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+                inboundProtocol, targetProtocol: candidate.protocol,
+                providerName: candidate.providerName, model: candidateModel || '',
+                status: 'success', upstreamStatusCode: null,
+                latencyMs: Date.now() - startedAt,
+                promptTokens: streamUsage.prompt_tokens || streamUsage.input_tokens || 0,
+                completionTokens: streamUsage.completion_tokens || streamUsage.output_tokens || 0,
+                totalTokens: (streamUsage.prompt_tokens || streamUsage.input_tokens || 0)
+                           + (streamUsage.completion_tokens || streamUsage.output_tokens || 0),
+                isEstimated: false, stream: true, keyAlias: keyLabel, errorMessage: null, clientIP,
+              });
             } else if (responseText || toolCallCount > 0) {
               const inputTokens = estimateInputTokens(req.body);
               const outputTokens = estimateTokens(responseText) + toolCallCount * 15;
@@ -550,6 +579,16 @@ function createProxyApp(proxyConfigOrGetter) {
                 prompt_tokens: inputTokens,
                 completion_tokens: outputTokens,
               }, true);
+              requestLog.add({
+                id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+                inboundProtocol, targetProtocol: candidate.protocol,
+                providerName: candidate.providerName, model: candidateModel || '',
+                status: 'success', upstreamStatusCode: null,
+                latencyMs: Date.now() - startedAt,
+                promptTokens: inputTokens, completionTokens: outputTokens,
+                totalTokens: inputTokens + outputTokens,
+                isEstimated: true, stream: true, keyAlias: keyLabel, errorMessage: null, clientIP,
+              });
             }
 
             if (sseConverter) {
@@ -559,6 +598,15 @@ function createProxyApp(proxyConfigOrGetter) {
           } catch (err) {
             recordFailure(proxyId, candidate.providerId);
             logger.error(`[${requestId}] Stream error:`, err.message);
+            requestLog.add({
+              id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+              inboundProtocol, targetProtocol: candidate.protocol,
+              providerName: candidate.providerName, model: candidateModel || '',
+              status: 'failure', upstreamStatusCode: null,
+              latencyMs: Date.now() - startedAt,
+              promptTokens: 0, completionTokens: 0, totalTokens: 0, isEstimated: false,
+              stream: true, keyAlias: keyLabel, errorMessage: err.message, clientIP,
+            });
             if (!res.writableEnded) {
               try {
                 res.write(`data: ${JSON.stringify({ error: { message: err.message, type: 'proxy_error' } })}\n\n`);
@@ -574,6 +622,18 @@ function createProxyApp(proxyConfigOrGetter) {
         extractReasoningFromResponse(responseBody);
         extractAnthropicThinking(responseBody);
         recordUsage(proxyConfig.id, candidate.providerName, candidateModel, responseBody.usage);
+        requestLog.add({
+          id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+          inboundProtocol, targetProtocol: candidate.protocol,
+          providerName: candidate.providerName, model: candidateModel || '',
+          status: 'success', upstreamStatusCode: fetchRes.status,
+          latencyMs: Date.now() - startedAt,
+          promptTokens: responseBody.usage?.prompt_tokens || responseBody.usage?.input_tokens || 0,
+          completionTokens: responseBody.usage?.completion_tokens || responseBody.usage?.output_tokens || 0,
+          totalTokens: (responseBody.usage?.prompt_tokens || responseBody.usage?.input_tokens || 0)
+                     + (responseBody.usage?.completion_tokens || responseBody.usage?.output_tokens || 0),
+          isEstimated: false, stream: false, keyAlias: keyLabel, errorMessage: null, clientIP,
+        });
         const convertedBody = convertRes(responseBody);
         return res.json(convertedBody);
       } catch (err) {
@@ -584,6 +644,15 @@ function createProxyApp(proxyConfigOrGetter) {
         }
         recordFailure(proxyId, candidate.providerId);
         logger.error(`[${requestId}] ✗ ${candidate.providerName} | model=${candidateModel || '(default)'} - ${err.message}`);
+        requestLog.add({
+          id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+          inboundProtocol, targetProtocol: candidate.protocol,
+          providerName: candidate.providerName, model: candidateModel || '',
+          status: 'failure', upstreamStatusCode: err?.status || null,
+          latencyMs: Date.now() - startedAt,
+          promptTokens: 0, completionTokens: 0, totalTokens: 0, isEstimated: false,
+          stream: isStream, keyAlias: keyLabel, errorMessage: err.message, clientIP,
+        });
         if (err?.status && !isRetryableStatus(err.status)) {
           return res.status(err.status).json({ error: err.message });
         }
@@ -596,10 +665,27 @@ function createProxyApp(proxyConfigOrGetter) {
       if (lastKeyError) {
         recordFailure(proxyId, candidate.providerId);
         logger.error(`[${requestId}] ✗ ${candidate.providerName} | all keys rate-limited (429)`);
+        requestLog.add({
+          id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+          inboundProtocol, targetProtocol: candidate.protocol,
+          providerName: candidate.providerName, model: candidateModel || '',
+          status: '429', upstreamStatusCode: 429,
+          latencyMs: Date.now() - startedAt,
+          promptTokens: 0, completionTokens: 0, totalTokens: 0, isEstimated: false,
+          stream: isStream, keyAlias: keyLabel, errorMessage: 'All keys rate-limited', clientIP,
+        });
       }
     } // end candidate loop
 
     logger.error(`[${requestId}] 所有供应商均失败`);
+    requestLog.add({
+      id: requestId, proxyId, proxyName, method: req.method, path: req.path,
+      inboundProtocol, targetProtocol: '', providerName: 'N/A', model: effectiveModel || '',
+      status: 'failure', upstreamStatusCode: null,
+      latencyMs: Date.now() - requestStart,
+      promptTokens: 0, completionTokens: 0, totalTokens: 0, isEstimated: false,
+      stream: isStream, keyAlias: '', errorMessage: 'All providers failed', clientIP,
+    });
     return res.status(502).json({ error: 'All providers failed' });
   }
 

package/lib/request-log.js

@@ -0,0 +1,27 @@
+const MAX_ENTRIES = 1000;
+
+const entries = [];
+let listener = null;
+
+function add(entry) {
+  entry.timestamp = entry.timestamp || new Date().toISOString();
+  entries.unshift(entry);
+  if (entries.length > MAX_ENTRIES) entries.pop();
+  if (listener) {
+    try { listener(entry); } catch { /* ignore */ }
+  }
+}
+
+function getAll(limit) {
+  return entries.slice(0, limit || MAX_ENTRIES);
+}
+
+function getCount() {
+  return entries.length;
+}
+
+function onEntry(callback) {
+  listener = callback;
+}
+
+module.exports = { add, getAll, getCount, onEntry, MAX_ENTRIES };

package/lib/stats-store.js

@@ -29,6 +29,7 @@ function addToBuffer(period, date, statsKey, prompt, completion, estimated) {
 function flush() {
   const stats = readStats();
   if (!dirty) return stats;
+  if (!stats.hourly) stats.hourly = {};
   if (!stats.daily) stats.daily = {};
   if (!stats.monthly) stats.monthly = {};
 
@@ -92,15 +93,31 @@ function yearKey(d) {
   return String(d.getFullYear());
 }
 
+function hourKey(d) {
+  return dateKey(d) + '-' + String(d.getHours()).padStart(2, '0');
+}
+
 // ==================== 分层合并 ====================
 
 function mergeIfNeeded() {
   const stats = flush();
   let changed = false;
 
+  const todayStr = dateKey(new Date());
   const currentMonth = monthKey(new Date()); // "2026-05"
   const currentYear = String(new Date().getFullYear());
 
+  // 小时级：清理昨天及更早的数据（daily 已有汇总，hourly 仅保留当天）
+  if (stats.hourly) {
+    const todayStart = todayStr + '-00';
+    for (const hk of Object.keys(stats.hourly)) {
+      if (hk < todayStart) {
+        delete stats.hourly[hk];
+        changed = true;
+      }
+    }
+  }
+
   // 日 → 月：非当月的日级数据合并为月级
   if (stats.daily) {
     const toMerge = {};
@@ -183,6 +200,7 @@ function recordUsage(proxyId, provider, model, usage, estimated = false) {
   if (!prompt && !completion) return;
 
   const now = new Date();
+  const hk = hourKey(now);
   const dk = dateKey(now);
   const mk = monthKey(now);
 
@@ -195,6 +213,7 @@ function recordUsage(proxyId, provider, model, usage, estimated = false) {
   ];
 
   for (const key of keys) {
+    addToBuffer('hourly', hk, key, prompt, completion, estimated);
     addToBuffer('daily', dk, key, prompt, completion, estimated);
   }
 }
@@ -208,9 +227,14 @@ function getStats(opts = {}) {
   const stats = readStats();
   const src = stats[range] || {};
 
+  // hourly keys are "YYYY-MM-DD-HH", need to pad day-level dates for comparison
+  const isHourly = range === 'hourly';
+  const filterStart = startDate ? (isHourly ? startDate + '-00' : startDate) : null;
+  const filterEnd = endDate ? (isHourly ? endDate + '-99' : endDate) : null;
+
   const dates = Object.keys(src).filter(d => {
-    if (startDate && d < startDate) return false;
-    if (endDate && d > endDate) return false;
+    if (filterStart && d < filterStart) return false;
+    if (filterEnd && d > filterEnd) return false;
     return true;
   }).sort();
 

package/lib/ws-server.js

@@ -0,0 +1,46 @@
+const logger = require('./logger');
+
+let wss = null;
+let WebSocketServer = null;
+
+function init(httpServer) {
+  try {
+    const ws = require('ws');
+    WebSocketServer = ws.WebSocketServer || ws.Server;
+    wss = new WebSocketServer({ server: httpServer });
+
+    wss.on('connection', (ws) => {
+      logger.log('[WS] Client connected');
+      try { ws.send(JSON.stringify({ type: 'connected', count: getClientCount() })); } catch { /* ignore */ }
+      ws.on('close', () => { logger.log('[WS] Client disconnected'); });
+    });
+
+    logger.log('[WS] WebSocket server initialized');
+  } catch (err) {
+    logger.error('[WS] Failed to initialize WebSocket server:', err.message);
+    wss = null;
+  }
+}
+
+function broadcast(data) {
+  if (!wss) return;
+  const msg = JSON.stringify(data);
+  for (const client of wss.clients) {
+    if (client.readyState === 1 /* OPEN */) {
+      try { client.send(msg); } catch { /* ignore */ }
+    }
+  }
+}
+
+function getClientCount() {
+  return wss ? wss.clients.size : 0;
+}
+
+function close() {
+  if (wss) {
+    try { wss.close(); } catch { /* ignore */ }
+    wss = null;
+  }
+}
+
+module.exports = { init, broadcast, getClientCount, close };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protocol-proxy",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "OpenAI / Anthropic 协议转换透明代理",
   "main": "server.js",
   "bin": {
@@ -27,7 +27,8 @@
   },
   "dependencies": {
     "cors": "^2.8.5",
-    "express": "^4.19.2"
+    "express": "^4.19.2",
+    "ws": "^8.20.1"
   },
   "devDependencies": {
     "pkg": "^5.8.1"
@@ -48,4 +49,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}