protocol-proxy 2.3.4 → 2.4.0

package/lib/proxy-server.js

@@ -7,6 +7,7 @@ const g2o = require('./converters/gemini-to-openai');
 const a2g = require('./converters/anthropic-to-gemini');
 const g2a = require('./converters/gemini-to-anthropic');
 const { recordUsage } = require('./stats-store');
+const logger = require('./logger');
 
 function createProxyApp(proxyConfigOrGetter) {
   const getProxyConfig = typeof proxyConfigOrGetter === 'function'
@@ -15,10 +16,11 @@ function createProxyApp(proxyConfigOrGetter) {
   const app = express();
   app.use(express.json({ limit: '50mb' }));
 
-  // reasoning_content 缓存（用于 DeepSeek 等 reasoning model）
-  // key: assistant message content, value: reasoning_content
   const reasoningCache = new Map();
   const MAX_CACHE_SIZE = 100;
+  const routeState = new Map();
+  const FAILURE_THRESHOLD = 3;
+  const OPEN_DURATION_MS = 60 * 1000;
 
   function getReasoningKey(msg) {
     const toolIds = msg.tool_calls?.map(t => t.id).join(',') || '';
@@ -45,11 +47,8 @@ function createProxyApp(proxyConfigOrGetter) {
     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);
@@ -75,9 +74,7 @@ function createProxyApp(proxyConfigOrGetter) {
         }
       }
     }
-    if (body.tools) {
-      text += JSON.stringify(body.tools);
-    }
+    if (body.tools) text += JSON.stringify(body.tools);
     return estimateTokens(text);
   }
 
@@ -86,7 +83,6 @@ function createProxyApp(proxyConfigOrGetter) {
     for (const msg of messages) {
       if (msg.role === 'assistant' && msg.reasoning_content === undefined) {
         const reasoning = getReasoning(msg);
-        // DeepSeek 等 reasoning model 要求 assistant message 必须包含 reasoning_content 字段
         msg.reasoning_content = reasoning || '';
       }
     }
@@ -100,6 +96,130 @@ function createProxyApp(proxyConfigOrGetter) {
     }
   }
 
+  function getRouteState(proxyId) {
+    if (!routeState.has(proxyId)) {
+      routeState.set(proxyId, { rrIndex: 0, metrics: new Map() });
+    }
+    return routeState.get(proxyId);
+  }
+
+  function getMetrics(proxyId, providerId) {
+    const state = getRouteState(proxyId);
+    if (!state.metrics.has(providerId)) {
+      state.metrics.set(providerId, {
+        successCount: 0,
+        failureCount: 0,
+        avgLatencyMs: null,
+        lastErrorAt: 0,
+        circuitOpenUntil: 0,
+      });
+    }
+    return state.metrics.get(providerId);
+  }
+
+  function isRetryableStatus(status) {
+    return status === 401
+      || status === 403
+      || status === 408
+      || status === 409
+      || status === 425
+      || status === 429
+      || status >= 500;
+  }
+
+  function isProviderAvailable(metrics) {
+    return !metrics.circuitOpenUntil || metrics.circuitOpenUntil <= Date.now();
+  }
+
+  function recordSuccess(proxyId, providerId, latencyMs) {
+    const metrics = getMetrics(proxyId, providerId);
+    metrics.successCount += 1;
+    metrics.lastErrorAt = 0;
+    metrics.failureCount = 0;
+    metrics.circuitOpenUntil = 0;
+    metrics.avgLatencyMs = metrics.avgLatencyMs == null
+      ? latencyMs
+      : Math.round(metrics.avgLatencyMs * 0.7 + latencyMs * 0.3);
+  }
+
+  function recordFailure(proxyId, providerId) {
+    const metrics = getMetrics(proxyId, providerId);
+    metrics.failureCount += 1;
+    metrics.lastErrorAt = Date.now();
+    if (metrics.failureCount >= FAILURE_THRESHOLD) {
+      metrics.circuitOpenUntil = Date.now() + OPEN_DURATION_MS;
+    }
+  }
+
+  function buildCandidates(proxyConfig) {
+    const target = proxyConfig.target;
+    if (!target || !Array.isArray(target.providerPool) || target.providerPool.length === 0) return [];
+    const pool = target.providerPool;
+
+    const ordered = pool.map((item, index) => ({
+      ...item,
+      providerId: item.providerId || `provider-${index}`,
+      weight: Math.max(1, parseInt(item.weight, 10) || 1),
+    }));
+
+    const strategy = target.routingStrategy || 'primary_fallback';
+    const proxyId = proxyConfig.id || 'default';
+
+    const byHealth = ordered.filter(item => isProviderAvailable(getMetrics(proxyId, item.providerId)));
+    const healthy = byHealth.length > 0 ? byHealth : ordered;
+
+    if (strategy === 'weighted') {
+      // 加权随机选择第一个候选，剩余按权重排序作为 fallback
+      const totalWeight = healthy.reduce((sum, c) => sum + c.weight, 0);
+      let rand = Math.random() * totalWeight;
+      let picked = healthy.length - 1;
+      for (let i = 0; i < healthy.length; i++) {
+        rand -= healthy[i].weight;
+        if (rand <= 0) { picked = i; break; }
+      }
+      const first = healthy[picked];
+      const rest = healthy.filter((_, i) => i !== picked).sort((a, b) => b.weight - a.weight);
+      return [first, ...rest];
+    }
+
+    if (strategy === 'fastest') {
+      return healthy.slice().sort((a, b) => {
+        const am = getMetrics(proxyId, a.providerId).avgLatencyMs ?? Number.MAX_SAFE_INTEGER;
+        const bm = getMetrics(proxyId, b.providerId).avgLatencyMs ?? Number.MAX_SAFE_INTEGER;
+        return am - bm;
+      });
+    }
+
+    if (strategy === 'round_robin') {
+      const state = getRouteState(proxyId);
+      const start = state.rrIndex % healthy.length;
+      state.rrIndex = (state.rrIndex + 1) % healthy.length;
+      return healthy.slice(start).concat(healthy.slice(0, start));
+    }
+
+    return healthy;
+  }
+
+  function getRoutingHealth(proxyConfig) {
+    const proxyId = proxyConfig.id || 'default';
+    const target = proxyConfig.target || {};
+    const pool = Array.isArray(target.providerPool) && target.providerPool.length > 0
+      ? target.providerPool
+      : [];
+    return pool.map(item => {
+      const metrics = getMetrics(proxyId, item.providerId || 'primary');
+      return {
+        providerId: item.providerId || 'primary',
+        providerName: item.providerName || '',
+        successCount: metrics.successCount,
+        failureCount: metrics.failureCount,
+        avgLatencyMs: metrics.avgLatencyMs,
+        circuitOpenUntil: metrics.circuitOpenUntil,
+        available: isProviderAvailable(metrics),
+      };
+    });
+  }
+
   app.use((req, res, next) => {
     res.header('Access-Control-Allow-Origin', '*');
     res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -110,10 +230,7 @@ function createProxyApp(proxyConfigOrGetter) {
 
   app.use((req, res, next) => {
     const proxyConfig = getProxyConfig();
-    if (!proxyConfig.requireAuth || !proxyConfig.authToken) {
-      return next();
-    }
-
+    if (!proxyConfig.requireAuth || !proxyConfig.authToken) return next();
     const token = req.headers.authorization?.replace('Bearer ', '') || req.headers['x-api-key'];
     if (token !== proxyConfig.authToken) {
       return res.status(401).json({ error: 'Unauthorized' });
@@ -123,204 +240,222 @@ function createProxyApp(proxyConfigOrGetter) {
 
   app.post('/v1/chat/completions', handleRequest);
   app.post('/v1/messages', handleRequest);
+  app.get('/_internal/routing-health', (req, res) => {
+    res.json({
+      proxy: getProxyConfig()?.id || null,
+      providers: getRoutingHealth(getProxyConfig() || {}),
+    });
+  });
 
   async function handleRequest(req, res) {
     const requestId = `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-    try {
-      const proxyConfig = getProxyConfig();
-      const inboundProtocol = detectInboundProtocol(req, req.body);
-      const target = proxyConfig.target;
+    const proxyConfig = getProxyConfig();
+    const inboundProtocol = detectInboundProtocol(req, req.body);
+    const candidates = buildCandidates(proxyConfig);
 
-      if (!target) {
-        return res.status(500).json({ error: 'Proxy target not configured' });
-      }
+    if (candidates.length === 0) {
+      return res.status(500).json({ error: 'Proxy target not configured' });
+    }
 
-      const targetProtocol = target.protocol;
-      const isStream = req.body?.stream === true;
-
-      console.log(`[${requestId}] ⬅️  ${(inboundProtocol || 'unknown').toUpperCase()} → ${targetProtocol.toUpperCase()} | path=${req.path}`);
-
-      // 决定转换方向
-      let convertReq, convertRes, createSSEConv, nameToId = null;
-      if (inboundProtocol === 'openai' && targetProtocol === 'anthropic') {
-        convertReq = o2a.convertRequest;
-        convertRes = o2a.convertResponse;
-        createSSEConv = o2a.createSSEConverter;
-      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'openai') {
-        convertReq = a2o.convertRequest;
-        convertRes = a2o.convertResponse;
-        createSSEConv = a2o.createSSEConverter;
-      } else if (inboundProtocol === 'openai' && targetProtocol === 'gemini') {
-        convertReq = o2g.convertRequest;
-        convertRes = o2g.convertResponse;
-        createSSEConv = o2g.createSSEConverter;
-      } else if (inboundProtocol === 'gemini' && targetProtocol === 'openai') {
-        convertReq = g2o.convertRequest;
-        convertRes = g2o.convertResponse;
-        createSSEConv = g2o.createSSEConverter;
-      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'gemini') {
-        convertReq = a2g.convertRequest;
-        convertRes = a2g.convertResponse;
-        createSSEConv = a2g.createSSEConverter;
-      } else if (inboundProtocol === 'gemini' && targetProtocol === 'anthropic') {
-        // g2a.convertRequest 返回 { ...body, nameToId }，需要提取映射
-        convertReq = (body, model) => {
-          const result = g2a.convertRequest(body, model);
-          nameToId = result.nameToId;
-          const { nameToId: _, ...bodyOnly } = result;
-          return bodyOnly;
-        };
-        convertRes = g2a.convertResponse;
-        createSSEConv = (model) => g2a.createSSEConverter(nameToId);
-      } else {
-        convertReq = (body, model) => ({ ...body, model: body.model || model });
-        convertRes = (body) => body;
-        createSSEConv = null;
-      }
+    const targetProtocol = candidates[0].protocol;
+    const isStream = req.body?.stream === true;
+    const proxyId = proxyConfig.id || 'default';
+    const inboundModel = req.body?.model;
+    const effectiveModel = proxyConfig.target?.defaultModel || inboundModel;
+    const baseRequestBody = effectiveModel ? { ...req.body, model: effectiveModel } : { ...req.body };
+
+    logger.log(`[${requestId}] ${(inboundProtocol || 'unknown').toUpperCase()} -> ${targetProtocol.toUpperCase()} | path=${req.path}`);
+
+    let convertReq;
+    let convertRes;
+    let createSSEConv;
+    let nameToId = null;
+
+    if (inboundProtocol === 'openai' && targetProtocol === 'anthropic') {
+      convertReq = o2a.convertRequest;
+      convertRes = o2a.convertResponse;
+      createSSEConv = o2a.createSSEConverter;
+    } else if (inboundProtocol === 'anthropic' && targetProtocol === 'openai') {
+      convertReq = a2o.convertRequest;
+      convertRes = a2o.convertResponse;
+      createSSEConv = a2o.createSSEConverter;
+    } else if (inboundProtocol === 'openai' && targetProtocol === 'gemini') {
+      convertReq = o2g.convertRequest;
+      convertRes = o2g.convertResponse;
+      createSSEConv = o2g.createSSEConverter;
+    } else if (inboundProtocol === 'gemini' && targetProtocol === 'openai') {
+      convertReq = g2o.convertRequest;
+      convertRes = g2o.convertResponse;
+      createSSEConv = g2o.createSSEConverter;
+    } else if (inboundProtocol === 'anthropic' && targetProtocol === 'gemini') {
+      convertReq = a2g.convertRequest;
+      convertRes = a2g.convertResponse;
+      createSSEConv = a2g.createSSEConverter;
+    } else if (inboundProtocol === 'gemini' && targetProtocol === 'anthropic') {
+      convertReq = (body, model) => {
+        const result = g2a.convertRequest(body, model);
+        nameToId = result.nameToId;
+        const { nameToId: _, ...bodyOnly } = result;
+        return bodyOnly;
+      };
+      convertRes = g2a.convertResponse;
+      createSSEConv = () => g2a.createSSEConverter(nameToId);
+    } else {
+      convertReq = (body, model) => ({ ...body, model: body.model || model });
+      convertRes = (body) => body;
+      createSSEConv = null;
+    }
 
-      // 如果请求没有 model，注入默认 model
-      const inboundModel = req.body?.model;
-      const effectiveModel = target.defaultModel || inboundModel;
-      if (effectiveModel) {
-        req.body = { ...req.body, model: effectiveModel };
-      }
+    const requestTemplate = convertReq(baseRequestBody, effectiveModel);
+
+    for (const candidate of candidates) {
+      const isAzure = !!candidate.azureDeployment && /azure/i.test(candidate.providerUrl);
+      const targetBody = { ...requestTemplate };
 
-      const targetBody = convertReq(req.body, effectiveModel);
+      // If candidate has a specific model override, apply it
+      if (candidate.model) {
+        targetBody.model = candidate.model;
+      }
 
-      const isAzure = !!target.azureDeployment && /azure/i.test(target.providerUrl);
+      const candidateModel = candidate.model || effectiveModel;
+      logger.log(`[${requestId}] -> ${candidate.providerName} | model=${candidateModel || '(default)'}`);
 
-      // 流式请求时注入 stream_options 以获取 usage 统计（Azure 不支持）
-      if (isStream && targetProtocol === 'openai' && !isAzure) {
+      if (isStream && candidate.protocol === 'openai' && !isAzure) {
         targetBody.stream_options = { include_usage: true };
       }
 
-      // 注入 reasoning_content（针对 DeepSeek 等 reasoning model）
       injectReasoningToMessages(targetBody.messages);
 
-      // 构建目标 URL
-      const targetUrl = buildTargetUrl(target, req.path, isStream, effectiveModel);
-      console.log(`[${requestId}] 🔗 ${targetUrl} | model=${effectiveModel}`);
-
-      // 构建请求头
+      const targetUrl = buildTargetUrl(candidate, req.path, isStream, candidateModel);
       const headers = {
         'Content-Type': 'application/json',
         'Accept': isStream ? 'text/event-stream' : 'application/json',
       };
 
-      if (targetProtocol === 'openai') {
-        if (isAzure) {
-          headers['api-key'] = target.apiKey;
-        } else {
-          headers['Authorization'] = `Bearer ${target.apiKey}`;
-        }
-      } else if (targetProtocol === 'gemini') {
-        headers['x-goog-api-key'] = target.apiKey;
-      } else if (targetProtocol === 'anthropic') {
-        headers['X-Api-Key'] = target.apiKey;
+      if (candidate.protocol === 'openai') {
+        if (isAzure) headers['api-key'] = candidate.apiKey;
+        else headers['Authorization'] = `Bearer ${candidate.apiKey}`;
+      } else if (candidate.protocol === 'gemini') {
+        headers['x-goog-api-key'] = candidate.apiKey;
+      } else if (candidate.protocol === 'anthropic') {
+        headers['X-Api-Key'] = candidate.apiKey;
         headers['Anthropic-Version'] = '2023-06-01';
-        headers['Authorization'] = `Bearer ${target.apiKey}`;
+        headers['Authorization'] = `Bearer ${candidate.apiKey}`;
       }
 
-      const fetchRes = await fetch(targetUrl, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(targetBody),
-        signal: AbortSignal.timeout(300000),
-      });
-
-      if (!fetchRes.ok) {
-        const errBody = await fetchRes.text();
-        console.log(`[${requestId}] ❌ Target error: HTTP ${fetchRes.status} | ${errBody.slice(0, 500)}`);
-        res.status(fetchRes.status);
-        res.set('Content-Type', fetchRes.headers.get('content-type') || 'application/json');
-        return res.send(errBody);
-      }
+      const startedAt = Date.now();
 
-      // 流式响应（以客户端请求意图为准，不依赖上游 Content-Type）
-      if (isStream) {
-        res.setHeader('Content-Type', 'text/event-stream');
-        res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
-
-        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 */ }
+      try {
+        const fetchRes = await fetch(targetUrl, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(targetBody),
+          signal: AbortSignal.timeout(300000),
         });
 
-        try {
-          while (true) {
-            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++;
+        if (!fetchRes.ok) {
+          const errBody = await fetchRes.text();
+          const error = Object.assign(new Error(errBody.slice(0, 500) || `HTTP ${fetchRes.status}`), { status: fetchRes.status });
+          if (isRetryableStatus(fetchRes.status)) {
+            throw error;
+          }
+          return res.status(fetchRes.status).json({ error: error.message });
+        }
+
+        recordSuccess(proxyId, candidate.providerId, Date.now() - startedAt);
+        logger.log(`[${requestId}] ✓ ${candidate.providerName} | model=${candidateModel || '(default)'} (${Date.now() - startedAt}ms)`);
+
+        if (isStream) {
+          res.setHeader('Content-Type', 'text/event-stream');
+          res.setHeader('Cache-Control', 'no-cache');
+          res.setHeader('Connection', 'keep-alive');
+
+          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 { /* ignore */ }
+          });
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              const chunk = decoder.decode(value, { stream: true });
+              for (const line of chunk.split('\n')) {
+                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 */ }
+                } catch { /* ignore */ }
+              }
+
+              if (sseConverter) {
+                const converted = sseConverter.convertChunk(chunk);
+                if (converted) res.write(converted);
+              } else {
+                res.write(chunk);
+              }
+            }
+
+            if (streamUsage) {
+              recordUsage(proxyConfig.id, candidate.providerName, candidateModel, streamUsage, false);
+            } else if (responseText || toolCallCount > 0) {
+              const inputTokens = estimateInputTokens(req.body);
+              const outputTokens = estimateTokens(responseText) + toolCallCount * 15;
+              recordUsage(proxyConfig.id, candidate.providerName, candidateModel, {
+                prompt_tokens: inputTokens,
+                completion_tokens: outputTokens,
+              }, true);
             }
+
             if (sseConverter) {
-              const converted = sseConverter.convertChunk(chunk);
-              if (converted) res.write(converted);
-            } else {
-              res.write(chunk);
+              const flushed = sseConverter.flush();
+              if (flushed) res.write(flushed);
+            }
+          } catch (err) {
+            recordFailure(proxyId, candidate.providerId);
+            logger.error(`[${requestId}] Stream error:`, err.message);
+            if (!res.writableEnded) {
+              try {
+                res.write(`data: ${JSON.stringify({ error: { message: err.message, type: 'proxy_error' } })}\n\n`);
+              } catch { /* ignore */ }
             }
+          } finally {
+            res.end();
           }
+          return;
+        }
 
-          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);
-          }
-        } catch (err) {
-          console.error(`[${requestId}] Stream error:`, err.message);
-          if (!res.writableEnded) {
-            try {
-              res.write(`data: ${JSON.stringify({ error: { message: err.message, type: 'proxy_error' } })}\n\n`);
-            } catch { /* ignore */ }
-          }
-        } finally {
-          res.end();
+        const responseBody = await fetchRes.json();
+        extractReasoningFromResponse(responseBody);
+        recordUsage(proxyConfig.id, candidate.providerName, candidateModel, responseBody.usage);
+        const convertedBody = convertRes(responseBody);
+        return res.json(convertedBody);
+      } catch (err) {
+        recordFailure(proxyId, candidate.providerId);
+        logger.error(`[${requestId}] ✗ ${candidate.providerName} | model=${candidateModel || '(default)'} - ${err.message}`);
+        if (err?.status && !isRetryableStatus(err.status)) {
+          return res.status(err.status).json({ error: err.message });
         }
-        return;
+        continue;
       }
-
-      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);
-
-    } catch (err) {
-      console.error(`[${requestId}] ❌ Proxy error:`, err.message);
-      res.status(500).json({ error: 'Proxy error', message: err.message });
     }
+
+    logger.error(`[${requestId}] 所有供应商均失败`);
+    return res.status(502).json({ error: 'All providers failed' });
   }
 
   return app;
@@ -331,7 +466,6 @@ function buildTargetUrl(target, originalPath, isStream, effectiveModel) {
   const hasV1Suffix = base.endsWith('/v1');
 
   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}`;

package/lib/stats-store.js

@@ -194,14 +194,12 @@ function recordUsage(proxyId, provider, model, usage, estimated = false) {
     `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);
-    }
+  for (const key of keys) {
+    addToBuffer('daily', dk, key, prompt, completion, estimated);
   }
 }
 
+
 // ==================== 查询统计 ====================
 
 function getStats(opts = {}) {