protocol-proxy 2.1.5 → 2.2.0

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

@@ -122,14 +122,13 @@ function convertMessage(msg, idMap) {
     }
 
     // user 消息含 tool_result → 拆分为多个 tool 消息
+    // OpenAI 要求 tool 消息紧跟 assistant tool_calls，user text 放在 tool 之后
     if (msg.role === 'user' && toolResults.length > 0) {
       const result = [];
-      // OpenAI 要求 tool 消息紧跟 assistant，user text 如果有的话应该放在 tool 之前
-      // 但通常 tool_result 消息不会有额外的 user text
+      result.push(...toolResults);
       if (textParts.length > 0) {
         result.push({ role: 'user', content: textParts.join('') });
       }
-      result.push(...toolResults);
       return result;
     }
 

package/lib/proxy-server.js

@@ -2,6 +2,7 @@ const express = require('express');
 const { detectInboundProtocol } = require('./detector');
 const o2a = require('./converters/openai-to-anthropic');
 const a2o = require('./converters/anthropic-to-openai');
+const { recordUsage } = require('./stats-store');
 
 function createProxyApp(proxyConfigOrGetter) {
   const getProxyConfig = typeof proxyConfigOrGetter === 'function'
@@ -35,6 +36,47 @@ function createProxyApp(proxyConfigOrGetter) {
     return reasoningCache.get(getReasoningKey(msg));
   }
 
+  function estimateTokens(text) {
+    if (!text) return 0;
+    let tokens = 0;
+    for (let i = 0; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      // CJK 字符 ~1.5 token/字
+      if (code >= 0x4E00 && code <= 0x9FFF) tokens += 1.5;
+      // 全角标点等 ~1 token
+      else if (code >= 0x3000 && code <= 0x303F) tokens += 1;
+      // 其他（ASCII 字母、数字、标点、空格）~0.25 token
+      else tokens += 0.25;
+    }
+    return Math.ceil(tokens);
+  }
+
+  function estimateInputTokens(body) {
+    if (!body?.messages) return 0;
+    let text = '';
+    for (const msg of body.messages) {
+      if (typeof msg.content === 'string') {
+        text += msg.content;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.text) text += block.text;
+          if (block.type === 'tool_result' && block.content) {
+            text += typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+          }
+        }
+      }
+      if (msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          text += (tc.function?.arguments || '') + (tc.function?.name || '');
+        }
+      }
+    }
+    if (body.tools) {
+      text += JSON.stringify(body.tools);
+    }
+    return estimateTokens(text);
+  }
+
   function injectReasoningToMessages(messages) {
     if (!Array.isArray(messages)) return;
     for (const msg of messages) {
@@ -119,11 +161,18 @@ function createProxyApp(proxyConfigOrGetter) {
 
       const targetBody = convertReq(req.body, effectiveModel);
 
+      const isAzure = !!target.azureDeployment;
+
+      // 流式请求时注入 stream_options 以获取 usage 统计（Azure 不支持）
+      if (isStream && targetProtocol === 'openai' && !isAzure) {
+        targetBody.stream_options = { include_usage: true };
+      }
+
       // 注入 reasoning_content（针对 DeepSeek 等 reasoning model）
       injectReasoningToMessages(targetBody.messages);
 
       // 构建目标 URL
-      const targetUrl = buildTargetUrl(target.providerUrl, targetProtocol, req.path);
+      const targetUrl = buildTargetUrl(target, req.path);
       console.log(`[${requestId}] 🔗 ${targetUrl} | model=${effectiveModel}`);
 
       // 构建请求头
@@ -133,7 +182,11 @@ function createProxyApp(proxyConfigOrGetter) {
       };
 
       if (targetProtocol === 'openai') {
-        headers['Authorization'] = `Bearer ${target.apiKey}`;
+        if (isAzure) {
+          headers['api-key'] = target.apiKey;
+        } else {
+          headers['Authorization'] = `Bearer ${target.apiKey}`;
+        }
       } else if (targetProtocol === 'anthropic') {
         headers['X-Api-Key'] = target.apiKey;
         headers['Anthropic-Version'] = '2023-06-01';
@@ -155,8 +208,8 @@ function createProxyApp(proxyConfigOrGetter) {
         return res.send(errBody);
       }
 
-      // 流式响应
-      if (isStream && fetchRes.headers.get('content-type')?.includes('text/event-stream')) {
+      // 流式响应（以客户端请求意图为准，不依赖上游 Content-Type）
+      if (isStream) {
         res.setHeader('Content-Type', 'text/event-stream');
         res.setHeader('Cache-Control', 'no-cache');
         res.setHeader('Connection', 'keep-alive');
@@ -164,6 +217,9 @@ function createProxyApp(proxyConfigOrGetter) {
         const sseConverter = createSSEConv ? createSSEConv(effectiveModel) : null;
         const reader = fetchRes.body.getReader();
         const decoder = new TextDecoder();
+        let streamUsage = null;
+        let responseText = '';
+        let toolCallCount = 0;
 
         req.on('close', () => {
           try { reader.cancel(); } catch (err) { /* ignore */ }
@@ -174,6 +230,23 @@ function createProxyApp(proxyConfigOrGetter) {
             const { done, value } = await reader.read();
             if (done) break;
             const chunk = decoder.decode(value, { stream: true });
+            // 从流中提取 usage 和响应内容
+            const lines = chunk.split('\n');
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed.startsWith('data:') || trimmed === 'data: [DONE]') continue;
+              try {
+                const d = JSON.parse(trimmed.slice(5).trim());
+                if (d.usage) streamUsage = d.usage;
+                const delta = d.choices?.[0]?.delta;
+                if (delta?.content) responseText += delta.content;
+                if (delta?.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    if (tc.function?.name) toolCallCount++;
+                  }
+                }
+              } catch { /* ignore */ }
+            }
             if (sseConverter) {
               const converted = sseConverter.convertChunk(chunk);
               if (converted) res.write(converted);
@@ -181,6 +254,18 @@ function createProxyApp(proxyConfigOrGetter) {
               res.write(chunk);
             }
           }
+
+          if (streamUsage) {
+            recordUsage(proxyConfig.id, proxyConfig.target?.providerName, req.body?.model, streamUsage, false);
+          } else if (responseText || toolCallCount > 0) {
+            // 上游未返回 usage，从响应内容估算
+            const inputTokens = estimateInputTokens(req.body);
+            const outputTokens = estimateTokens(responseText) + toolCallCount * 15;
+            recordUsage(proxyConfig.id, proxyConfig.target?.providerName, req.body?.model, {
+              prompt_tokens: inputTokens,
+              completion_tokens: outputTokens,
+            }, true);
+          }
           if (sseConverter) {
             const flushed = sseConverter.flush();
             if (flushed) res.write(flushed);
@@ -195,6 +280,7 @@ function createProxyApp(proxyConfigOrGetter) {
 
       const responseBody = await fetchRes.json();
       extractReasoningFromResponse(responseBody);
+      recordUsage(proxyConfig.id, proxyConfig.target?.providerName, req.body?.model, responseBody.usage);
       const convertedBody = convertRes(responseBody);
       res.json(convertedBody);
 
@@ -207,16 +293,21 @@ function createProxyApp(proxyConfigOrGetter) {
   return app;
 }
 
-function buildTargetUrl(providerUrl, targetProtocol, originalPath) {
-  const base = providerUrl.replace(/\/$/, '');
+function buildTargetUrl(target, originalPath) {
+  const base = target.providerUrl.replace(/\/$/, '');
   const hasV1Suffix = base.endsWith('/v1');
 
-  if (targetProtocol === 'openai') {
+  if (target.protocol === 'openai') {
+    // Azure OpenAI
+    if (target.azureDeployment) {
+      const ver = target.azureApiVersion || '2024-02-01';
+      return `${base}/openai/deployments/${target.azureDeployment}/chat/completions?api-version=${ver}`;
+    }
     if (hasV1Suffix) return `${base}/chat/completions`;
     return `${base}/v1/chat/completions`;
   }
 
-  if (targetProtocol === 'anthropic') {
+  if (target.protocol === 'anthropic') {
     if (hasV1Suffix) return `${base}/messages`;
     return `${base}/v1/messages`;
   }

package/lib/stats-store.js

@@ -0,0 +1,287 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const STATS_PATH = path.join(os.homedir(), '.protocol-proxy', 'stats.json');
+const FLUSH_INTERVAL = 5000;
+
+// ==================== 内存缓冲 + 定时刷盘 ====================
+
+let buffer = {};
+let dirty = false;
+
+function bufferKey(period, date, statsKey) {
+  return `${period}:${date}:${statsKey}`;
+}
+
+function addToBuffer(period, date, statsKey, prompt, completion, estimated) {
+  const bk = bufferKey(period, date, statsKey);
+  if (!buffer[bk]) {
+    buffer[bk] = { period, date, key: statsKey, prompt: 0, completion: 0, requests: 0, estimated: false };
+  }
+  buffer[bk].prompt += prompt;
+  buffer[bk].completion += completion;
+  buffer[bk].requests += 1;
+  if (estimated) buffer[bk].estimated = true;
+  dirty = true;
+}
+
+function flush() {
+  const stats = readStats();
+  if (!dirty) return stats;
+  if (!stats.daily) stats.daily = {};
+  if (!stats.monthly) stats.monthly = {};
+
+  for (const entry of Object.values(buffer)) {
+    const bucket = stats[entry.period];
+    if (!bucket[entry.date]) bucket[entry.date] = {};
+    if (!bucket[entry.date][entry.key]) {
+      bucket[entry.date][entry.key] = { prompt: 0, completion: 0, requests: 0, estimated: false };
+    }
+    const target = bucket[entry.date][entry.key];
+    target.prompt += entry.prompt;
+    target.completion += entry.completion;
+    target.requests += entry.requests;
+    if (entry.estimated) target.estimated = true;
+  }
+
+  buffer = {};
+  dirty = false;
+  writeStats(stats);
+  return stats;
+}
+
+setInterval(flush, FLUSH_INTERVAL);
+
+// ==================== 文件读写 ====================
+
+function readStats() {
+  try {
+    if (!fs.existsSync(STATS_PATH)) return {};
+    return JSON.parse(fs.readFileSync(STATS_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeStats(data) {
+  try {
+    const dir = path.dirname(STATS_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const tmp = STATS_PATH + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data), 'utf-8');
+    fs.renameSync(tmp, STATS_PATH);
+  } catch (err) {
+    console.error('[Stats] 写入失败:', err.message);
+  }
+}
+
+// ==================== 日期工具 ====================
+
+function dateKey(d) {
+  return d.getFullYear() + '-' +
+    String(d.getMonth() + 1).padStart(2, '0') + '-' +
+    String(d.getDate()).padStart(2, '0');
+}
+
+function monthKey(d) {
+  return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0');
+}
+
+function yearKey(d) {
+  return String(d.getFullYear());
+}
+
+// ==================== 分层合并 ====================
+
+function mergeIfNeeded() {
+  const stats = flush();
+  let changed = false;
+
+  const currentMonth = monthKey(new Date()); // "2026-05"
+  const currentYear = String(new Date().getFullYear());
+
+  // 日 → 月：非当月的日级数据合并为月级
+  if (stats.daily) {
+    const toMerge = {};
+    for (const [dk, bucket] of Object.entries(stats.daily)) {
+      const mk = dk.slice(0, 7); // "2026-05-09" → "2026-05"
+      if (mk >= currentMonth) continue; // 当月的保留
+      if (!toMerge[mk]) toMerge[mk] = {};
+      for (const [key, val] of Object.entries(bucket)) {
+        if (!toMerge[mk][key]) toMerge[mk][key] = { prompt: 0, completion: 0, requests: 0, estimated: false };
+        const t = toMerge[mk][key];
+        t.prompt += val.prompt;
+        t.completion += val.completion;
+        t.requests += val.requests;
+        if (val.estimated) t.estimated = true;
+      }
+      delete stats.daily[dk];
+      changed = true;
+    }
+
+    if (!stats.monthly) stats.monthly = {};
+    for (const [mk, entries] of Object.entries(toMerge)) {
+      if (!stats.monthly[mk]) stats.monthly[mk] = {};
+      for (const [key, val] of Object.entries(entries)) {
+        if (!stats.monthly[mk][key]) {
+          stats.monthly[mk][key] = { prompt: 0, completion: 0, requests: 0, estimated: false };
+        }
+        const t = stats.monthly[mk][key];
+        t.prompt += val.prompt;
+        t.completion += val.completion;
+        t.requests += val.requests;
+        if (val.estimated) t.estimated = true;
+      }
+    }
+  }
+
+  // 月 → 年：非当年的月级数据合并为年级
+  if (stats.monthly) {
+    const toMerge = {};
+    for (const [mk, bucket] of Object.entries(stats.monthly)) {
+      const yk = mk.slice(0, 4);
+      if (yk >= currentYear) continue; // 当年的保留
+      if (!toMerge[yk]) toMerge[yk] = {};
+      for (const [key, val] of Object.entries(bucket)) {
+        if (!toMerge[yk][key]) toMerge[yk][key] = { prompt: 0, completion: 0, requests: 0, estimated: false };
+        const t = toMerge[yk][key];
+        t.prompt += val.prompt;
+        t.completion += val.completion;
+        t.requests += val.requests;
+        if (val.estimated) t.estimated = true;
+      }
+      delete stats.monthly[mk];
+      changed = true;
+    }
+
+    if (!stats.yearly) stats.yearly = {};
+    for (const [yk, entries] of Object.entries(toMerge)) {
+      if (!stats.yearly[yk]) stats.yearly[yk] = {};
+      for (const [key, val] of Object.entries(entries)) {
+        if (!stats.yearly[yk][key]) {
+          stats.yearly[yk][key] = { prompt: 0, completion: 0, requests: 0, estimated: false };
+        }
+        const t = stats.yearly[yk][key];
+        t.prompt += val.prompt;
+        t.completion += val.completion;
+        t.requests += val.requests;
+        if (val.estimated) t.estimated = true;
+      }
+    }
+  }
+
+  if (changed) writeStats(stats);
+}
+
+// ==================== 记录用量 ====================
+
+function recordUsage(proxyId, provider, model, usage, estimated = false) {
+  if (!proxyId || !usage) return;
+  const prompt = usage.prompt_tokens || usage.input_tokens || 0;
+  const completion = usage.completion_tokens || usage.output_tokens || 0;
+  if (!prompt && !completion) return;
+
+  const now = new Date();
+  const dk = dateKey(now);
+  const mk = monthKey(now);
+
+  const prov = provider || 'unknown';
+  const mdl = model || 'unknown';
+  const keys = [
+    `p:${proxyId}`,
+    `p:${proxyId}:${prov}`,
+    `p:${proxyId}:${prov}:${mdl}`,
+  ];
+
+  for (const period of ['daily', 'monthly']) {
+    const bucket = period === 'daily' ? dk : mk;
+    for (const key of keys) {
+      addToBuffer(period, bucket, key, prompt, completion, estimated);
+    }
+  }
+}
+
+// ==================== 查询统计 ====================
+
+function getStats(opts = {}) {
+  mergeIfNeeded();
+  const { range = 'daily', startDate, endDate, proxyId } = opts;
+  const stats = readStats();
+  const src = stats[range] || {};
+
+  const dates = Object.keys(src).filter(d => {
+    if (startDate && d < startDate) return false;
+    if (endDate && d > endDate) return false;
+    return true;
+  }).sort();
+
+  const summary = { prompt: 0, completion: 0, requests: 0, estimatedCount: 0 };
+  const byProvider = {};
+  const byModel = {};
+
+  for (const date of dates) {
+    const bucket = src[date];
+    for (const [key, val] of Object.entries(bucket)) {
+      if (!matchPrefix(key, proxyId)) continue;
+
+      summary.prompt += val.prompt;
+      summary.completion += val.completion;
+      summary.requests += val.requests;
+      if (val.estimated) summary.estimatedCount += val.requests;
+
+      const parts = key.split(':');
+      if (parts.length >= 3) {
+        const prov = parts[2];
+        if (!byProvider[prov]) byProvider[prov] = { prompt: 0, completion: 0, requests: 0, estimatedCount: 0 };
+        byProvider[prov].prompt += val.prompt;
+        byProvider[prov].completion += val.completion;
+        byProvider[prov].requests += val.requests;
+        if (val.estimated) byProvider[prov].estimatedCount += val.requests;
+      }
+      if (parts.length >= 4) {
+        const prov = parts[2];
+        const mdl = parts.slice(3).join(':');
+        const mk = prov + '/' + mdl;
+        if (!byModel[mk]) byModel[mk] = { provider: prov, model: mdl, prompt: 0, completion: 0, requests: 0, estimatedCount: 0 };
+        byModel[mk].prompt += val.prompt;
+        byModel[mk].completion += val.completion;
+        byModel[mk].requests += val.requests;
+        if (val.estimated) byModel[mk].estimatedCount += val.requests;
+      }
+    }
+  }
+
+  return {
+    range,
+    dates,
+    summary: {
+      ...summary,
+      total: summary.prompt + summary.completion,
+      hasEstimated: summary.estimatedCount > 0,
+    },
+    byProvider: Object.entries(byProvider)
+      .map(([name, v]) => ({ name, ...v, total: v.prompt + v.completion, hasEstimated: v.estimatedCount > 0 }))
+      .sort((a, b) => b.total - a.total),
+    byModel: Object.values(byModel)
+      .map(v => ({ ...v, total: v.prompt + v.completion, hasEstimated: v.estimatedCount > 0 }))
+      .sort((a, b) => b.total - a.total),
+  };
+}
+
+function matchPrefix(key, proxyId) {
+  if (!proxyId) return true;
+  const prefix = 'p:' + proxyId;
+  if (key.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (key[i] !== prefix[i]) return false;
+  }
+  return key.length === prefix.length || key[prefix.length] === ':';
+}
+
+// 进程退出时刷盘
+process.on('exit', flush);
+process.on('SIGINT', () => { flush(); process.exit(0); });
+process.on('SIGTERM', () => { flush(); process.exit(0); });
+
+module.exports = { recordUsage, getStats, flush };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protocol-proxy",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "OpenAI / Anthropic 协议转换透明代理",
   "main": "server.js",
   "bin": {