protocol-proxy 2.4.0 → 2.5.0

package/lib/proxy-server.js

@@ -1,491 +1,636 @@
-const express = require('express');
-const { detectInboundProtocol } = require('./detector');
-const o2a = require('./converters/openai-to-anthropic');
-const a2o = require('./converters/anthropic-to-openai');
-const o2g = require('./converters/openai-to-gemini');
-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'
-    ? proxyConfigOrGetter
-    : () => proxyConfigOrGetter;
-  const app = express();
-  app.use(express.json({ limit: '50mb' }));
-
-  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(',') || '';
-    return msg.content + '|' + toolIds;
-  }
-
-  function setReasoning(msg, reasoning) {
-    if (!msg?.content || !reasoning) return;
-    const key = getReasoningKey(msg);
-    if (reasoningCache.size >= MAX_CACHE_SIZE) {
-      const firstKey = reasoningCache.keys().next().value;
-      reasoningCache.delete(firstKey);
-    }
-    reasoningCache.set(key, reasoning);
-  }
-
-  function getReasoning(msg) {
-    if (!msg?.content) return undefined;
-    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);
-      if (code >= 0x4E00 && code <= 0x9FFF) tokens += 1.5;
-      else if (code >= 0x3000 && code <= 0x303F) tokens += 1;
-      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) {
-      if (msg.role === 'assistant' && msg.reasoning_content === undefined) {
-        const reasoning = getReasoning(msg);
-        msg.reasoning_content = reasoning || '';
-      }
-    }
-  }
-
-  function extractReasoningFromResponse(body) {
-    const choice = body.choices?.[0];
-    const message = choice?.message;
-    if (message?.role === 'assistant' && message.reasoning_content) {
-      setReasoning(message, message.reasoning_content);
-    }
-  }
-
-  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');
-    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Api-Key');
-    if (req.method === 'OPTIONS') return res.sendStatus(200);
-    next();
-  });
-
-  app.use((req, res, next) => {
-    const proxyConfig = getProxyConfig();
-    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' });
-    }
-    next();
-  });
-
-  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)}`;
-    const proxyConfig = getProxyConfig();
-    const inboundProtocol = detectInboundProtocol(req, req.body);
-    const candidates = buildCandidates(proxyConfig);
-
-    if (candidates.length === 0) {
-      return res.status(500).json({ error: 'Proxy target not configured' });
-    }
-
-    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;
-    }
-
-    const requestTemplate = convertReq(baseRequestBody, effectiveModel);
-
-    for (const candidate of candidates) {
-      const isAzure = !!candidate.azureDeployment && /azure/i.test(candidate.providerUrl);
-      const targetBody = { ...requestTemplate };
-
-      // If candidate has a specific model override, apply it
-      if (candidate.model) {
-        targetBody.model = candidate.model;
-      }
-
-      const candidateModel = candidate.model || effectiveModel;
-      logger.log(`[${requestId}] -> ${candidate.providerName} | model=${candidateModel || '(default)'}`);
-
-      if (isStream && candidate.protocol === 'openai' && !isAzure) {
-        targetBody.stream_options = { include_usage: true };
-      }
-
-      injectReasoningToMessages(targetBody.messages);
-
-      const targetUrl = buildTargetUrl(candidate, req.path, isStream, candidateModel);
-      const headers = {
-        'Content-Type': 'application/json',
-        'Accept': isStream ? 'text/event-stream' : 'application/json',
-      };
-
-      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 ${candidate.apiKey}`;
-      }
-
-      const startedAt = Date.now();
-
-      try {
-        const fetchRes = await fetch(targetUrl, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify(targetBody),
-          signal: AbortSignal.timeout(300000),
-        });
-
-        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 */ }
-              }
-
-              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 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;
-        }
-
-        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 });
-        }
-        continue;
-      }
-    }
-
-    logger.error(`[${requestId}] 所有供应商均失败`);
-    return res.status(502).json({ error: 'All providers failed' });
-  }
-
-  return app;
-}
-
-function buildTargetUrl(target, originalPath, isStream, effectiveModel) {
-  const base = target.providerUrl.replace(/\/$/, '');
-  const hasV1Suffix = base.endsWith('/v1');
-
-  if (target.protocol === '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 (target.protocol === 'anthropic') {
-    if (hasV1Suffix) return `${base}/messages`;
-    return `${base}/v1/messages`;
-  }
-
-  if (target.protocol === 'gemini') {
-    const model = effectiveModel || 'gemini-pro';
-    const action = isStream ? 'streamGenerateContent?alt=sse' : 'generateContent';
-    return `${base}/v1beta/models/${model}:${action}`;
-  }
-
-  return base + originalPath;
-}
-
-module.exports = { createProxyApp };
+const express = require('express');
+const { detectInboundProtocol } = require('./detector');
+const o2a = require('./converters/openai-to-anthropic');
+const a2o = require('./converters/anthropic-to-openai');
+const o2g = require('./converters/openai-to-gemini');
+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'
+    ? proxyConfigOrGetter
+    : () => proxyConfigOrGetter;
+  const app = express();
+  app.use(express.json({ limit: '50mb' }));
+
+  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(',') || '';
+    return msg.content + '|' + toolIds;
+  }
+
+  function setReasoning(msg, reasoning) {
+    if (!msg?.content || !reasoning) return;
+    const key = getReasoningKey(msg);
+    if (reasoningCache.size >= MAX_CACHE_SIZE) {
+      const firstKey = reasoningCache.keys().next().value;
+      reasoningCache.delete(firstKey);
+    }
+    reasoningCache.set(key, reasoning);
+  }
+
+  function getReasoning(msg) {
+    if (!msg?.content) return undefined;
+    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);
+      if (code >= 0x4E00 && code <= 0x9FFF) tokens += 1.5;
+      else if (code >= 0x3000 && code <= 0x303F) tokens += 1;
+      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) {
+      if (msg.role === 'assistant' && msg.reasoning_content === undefined) {
+        const reasoning = getReasoning(msg);
+        msg.reasoning_content = reasoning || '';
+      }
+    }
+  }
+
+  function extractReasoningFromResponse(body) {
+    const choice = body.choices?.[0];
+    const message = choice?.message;
+    if (message?.role === 'assistant' && message.reasoning_content) {
+      setReasoning(message, message.reasoning_content);
+    }
+  }
+
+  // Extract thinking blocks from Anthropic response and cache by assistant text content
+  function extractAnthropicThinking(body) {
+    const content = body.content;
+    if (!Array.isArray(content)) return;
+    const thinkingBlocks = content.filter(b => b.type === 'thinking');
+    if (thinkingBlocks.length === 0) return;
+    const textContent = content.filter(b => b.type === 'text').map(b => b.text).join('');
+    if (!textContent) return;
+    const msg = { content: textContent, tool_calls: null };
+    setReasoning(msg, thinkingBlocks);
+  }
+
+  // Inject cached thinking blocks into Anthropic-format assistant messages
+  function injectAnthropicThinking(messages) {
+    if (!Array.isArray(messages)) return;
+    for (const msg of messages) {
+      if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+      const hasThinking = msg.content.some(b => b.type === 'thinking');
+      if (hasThinking) continue;
+      const textContent = msg.content.filter(b => b.type === 'text').map(b => b.text).join('');
+      if (!textContent) continue;
+      const cached = getReasoning({ content: textContent, tool_calls: null });
+      if (cached) {
+        msg.content = [...cached, ...msg.content];
+      }
+    }
+  }
+
+  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;
+    }
+  }
+
+  // ==================== API Key 轮转 ====================
+
+  const keyPoolState = new Map();
+  const KEY_COOLDOWN_MS = 60 * 1000;
+
+  function getKeyState(providerId, apiKeys) {
+    if (!keyPoolState.has(providerId)) {
+      keyPoolState.set(providerId, {
+        keys: apiKeys || [],
+        index: 0,
+        cooldowns: new Map(), // key -> cooldownUntil timestamp
+      });
+    }
+    return keyPoolState.get(providerId);
+  }
+
+  function selectKey(providerId, apiKeys) {
+    if (!apiKeys || apiKeys.length === 0) return '';
+    // Filter out disabled keys (enabled defaults to true)
+    const enabledKeys = apiKeys.filter(k => (typeof k === 'object' ? k.enabled !== false : true));
+    if (enabledKeys.length === 0) return '';
+    // Normalize to string array (handle {key, alias} objects)
+    const keys = enabledKeys.map(k => typeof k === 'string' ? k : k.key);
+    if (keys.length === 1) return keys[0];
+
+    const state = getKeyState(providerId, keys);
+    // Sync keys in case they changed
+    state.keys = keys;
+    const now = Date.now();
+
+    // Clean expired cooldowns
+    for (const [key, until] of state.cooldowns) {
+      if (until <= now) state.cooldowns.delete(key);
+    }
+
+    // Try to find an available key starting from current index
+    for (let i = 0; i < keys.length; i++) {
+      const idx = (state.index + i) % keys.length;
+      const key = keys[idx];
+      if (!state.cooldowns.has(key)) {
+        state.index = (idx + 1) % keys.length;
+        return key;
+      }
+    }
+
+    // All keys on cooldown — pick the one with shortest remaining cooldown
+    let earliest = Infinity;
+    let bestKey = keys[0];
+    for (const [key, until] of state.cooldowns) {
+      if (keys.includes(key) && until < earliest) {
+        earliest = until;
+        bestKey = key;
+      }
+    }
+    state.index = (keys.indexOf(bestKey) + 1) % keys.length;
+    return bestKey;
+  }
+
+  function markKeyCooldown(providerId, key) {
+    const state = keyPoolState.get(providerId);
+    if (state) {
+      state.cooldowns.set(key, Date.now() + KEY_COOLDOWN_MS);
+      logger.log(`[KeyPool] ${providerId} key ${key.slice(0, 8)}... cooldown 60s`);
+    }
+  }
+
+  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');
+    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Api-Key');
+    if (req.method === 'OPTIONS') return res.sendStatus(200);
+    next();
+  });
+
+  app.use((req, res, next) => {
+    const proxyConfig = getProxyConfig();
+    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' });
+    }
+    next();
+  });
+
+  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)}`;
+    const proxyConfig = getProxyConfig();
+    const inboundProtocol = detectInboundProtocol(req, req.body);
+    const candidates = buildCandidates(proxyConfig);
+
+    if (candidates.length === 0) {
+      return res.status(500).json({ error: 'Proxy target not configured' });
+    }
+
+    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 };
+
+    // Inject cached reasoning for OpenAI inbound (OpenAI protocol lacks reasoning_content)
+    if (inboundProtocol === 'openai') {
+      injectReasoningToMessages(baseRequestBody.messages);
+    }
+
+    // Pre-build request templates for each protocol
+    const passthrough = (body, model) => ({ ...body, model: body.model || model });
+    const requestTemplates = {};
+    requestTemplates.openai = inboundProtocol === 'openai' ? passthrough(baseRequestBody, effectiveModel) :
+                              inboundProtocol === 'anthropic' ? a2o.convertRequest(baseRequestBody, effectiveModel) :
+                              inboundProtocol === 'gemini' ? g2o.convertRequest(baseRequestBody, effectiveModel) :
+                              passthrough(baseRequestBody, effectiveModel);
+    requestTemplates.anthropic = inboundProtocol === 'anthropic' ? passthrough(baseRequestBody, effectiveModel) :
+                                 inboundProtocol === 'openai' ? o2a.convertRequest(baseRequestBody, effectiveModel) :
+                                 inboundProtocol === 'gemini' ? (() => { const r = g2a.convertRequest(baseRequestBody, effectiveModel); return { body: r, nameToId: r.nameToId }; })() :
+                                 passthrough(baseRequestBody, effectiveModel);
+    requestTemplates.gemini = inboundProtocol === 'gemini' ? passthrough(baseRequestBody, effectiveModel) :
+                              inboundProtocol === 'openai' ? o2g.convertRequest(baseRequestBody, effectiveModel) :
+                              inboundProtocol === 'anthropic' ? a2g.convertRequest(baseRequestBody, effectiveModel) :
+                              passthrough(baseRequestBody, effectiveModel);
+
+    logger.log(`[${requestId}] ${(inboundProtocol || 'unknown').toUpperCase()} -> mixed | path=${req.path}`);
+
+    for (const candidate of candidates) {
+      const targetProtocol = candidate.protocol;
+      const isAzure = !!candidate.azureDeployment && /azure/i.test(candidate.providerUrl);
+
+      let convertRes;
+      let createSSEConv;
+      let nameToId = null;
+      let targetBody;
+
+      if (inboundProtocol === 'openai' && targetProtocol === 'anthropic') {
+        targetBody = { ...requestTemplates.anthropic };
+        convertRes = o2a.convertResponse;
+        createSSEConv = o2a.createSSEConverter;
+      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'openai') {
+        targetBody = { ...requestTemplates.openai };
+        convertRes = a2o.convertResponse;
+        createSSEConv = a2o.createSSEConverter;
+      } else if (inboundProtocol === 'openai' && targetProtocol === 'gemini') {
+        targetBody = { ...requestTemplates.gemini };
+        convertRes = o2g.convertResponse;
+        createSSEConv = o2g.createSSEConverter;
+      } else if (inboundProtocol === 'gemini' && targetProtocol === 'openai') {
+        const result = g2o.convertRequest(baseRequestBody, effectiveModel);
+        nameToId = result.nameToId;
+        const { nameToId: _, ...bodyOnly } = result;
+        targetBody = bodyOnly;
+        convertRes = g2o.convertResponse;
+        createSSEConv = g2o.createSSEConverter;
+      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'gemini') {
+        targetBody = { ...requestTemplates.gemini };
+        convertRes = a2g.convertResponse;
+        createSSEConv = a2g.createSSEConverter;
+      } else if (inboundProtocol === 'gemini' && targetProtocol === 'anthropic') {
+        const tpl = requestTemplates.anthropic;
+        targetBody = { ...tpl.body };
+        nameToId = tpl.nameToId;
+        convertRes = g2a.convertResponse;
+        createSSEConv = () => g2a.createSSEConverter(nameToId);
+      } else {
+        targetBody = { ...baseRequestBody };
+        convertRes = (body) => body;
+        createSSEConv = null;
+      }
+
+      // If candidate has a specific model override, apply it
+      if (candidate.model) {
+        targetBody.model = candidate.model;
+      }
+
+      const candidateModel = candidate.model || effectiveModel;
+      logger.log(`[${requestId}] -> ${candidate.providerName} (${targetProtocol}) | model=${candidateModel || '(default)'}`);
+
+      if (isStream && candidate.protocol === 'openai' && !isAzure) {
+        targetBody.stream_options = { include_usage: true };
+      }
+
+      const targetUrl = buildTargetUrl(candidate, req.path, isStream, candidateModel);
+      // Forward client headers (preserve anthropic-beta, user-agent, etc.)
+      const skipHeaders = new Set(['host', 'connection', 'content-length', 'content-type', 'accept', 'authorization', 'x-api-key', 'anthropic-version']);
+      const headers = {};
+      for (const [key, val] of Object.entries(req.headers)) {
+        if (!skipHeaders.has(key.toLowerCase())) headers[key] = val;
+      }
+      headers['Content-Type'] = 'application/json';
+      headers['Accept'] = isStream ? 'text/event-stream' : 'application/json';
+
+      const maxKeyRetries = (candidate.apiKeys || []).filter(k => typeof k === 'object' ? k.enabled !== false : true).length || 1;
+      let lastKeyError = null;
+
+      for (let keyAttempt = 0; keyAttempt < maxKeyRetries; keyAttempt++) {
+        const currentKey = selectKey(candidate.providerId, candidate.apiKeys || []);
+        const keyHeaders = { ...headers };
+
+        if (candidate.protocol === 'openai') {
+          if (isAzure) keyHeaders['api-key'] = currentKey;
+          else keyHeaders['Authorization'] = `Bearer ${currentKey}`;
+        } else if (candidate.protocol === 'gemini') {
+          keyHeaders['x-goog-api-key'] = currentKey;
+        } else if (candidate.protocol === 'anthropic') {
+          keyHeaders['X-Api-Key'] = currentKey;
+          keyHeaders['anthropic-version'] = keyHeaders['anthropic-version'] || '2023-06-01';
+          keyHeaders['Authorization'] = `Bearer ${currentKey}`;
+        }
+
+      const startedAt = Date.now();
+
+      try {
+        const fetchRes = await fetch(targetUrl, {
+          method: 'POST',
+          headers: keyHeaders,
+          body: JSON.stringify(targetBody),
+          signal: AbortSignal.timeout(300000),
+        });
+
+        if (!fetchRes.ok) {
+          const errBody = await fetchRes.text();
+          const error = Object.assign(new Error(errBody.slice(0, 500) || `HTTP ${fetchRes.status}`), { status: fetchRes.status });
+          // 429: mark key cooldown and retry with next key
+          if (fetchRes.status === 429 && maxKeyRetries > 1) {
+            markKeyCooldown(candidate.providerId, currentKey);
+            lastKeyError = error;
+            logger.log(`[${requestId}] 429 on key ${currentKey.slice(0, 8)}..., trying next key`);
+            continue;
+          }
+          if (isRetryableStatus(fetchRes.status)) {
+            throw error;
+          }
+          return res.status(fetchRes.status).json({ error: error.message });
+        }
+
+        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)}` : '-');
+        logger.log(`[${requestId}] ✓ ${candidate.providerName} | model=${candidateModel || '(default)'} key=${keyLabel} (${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 */ }
+              }
+
+              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 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;
+        }
+
+        const responseBody = await fetchRes.json();
+        extractReasoningFromResponse(responseBody);
+        extractAnthropicThinking(responseBody);
+        recordUsage(proxyConfig.id, candidate.providerName, candidateModel, responseBody.usage);
+        const convertedBody = convertRes(responseBody);
+        return res.json(convertedBody);
+      } catch (err) {
+        // 429 already handled by key retry loop above
+        if (err?.status === 429 && maxKeyRetries > 1) {
+          lastKeyError = err;
+          continue; // retry with next key
+        }
+        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 });
+        }
+        break; // break key retry loop, continue to next candidate
+      }
+      break; // success, exit key retry loop
+      } // end key retry loop
+
+      // All keys exhausted with 429 — trigger circuit breaker
+      if (lastKeyError) {
+        recordFailure(proxyId, candidate.providerId);
+        logger.error(`[${requestId}] ✗ ${candidate.providerName} | all keys rate-limited (429)`);
+      }
+    } // end candidate loop
+
+    logger.error(`[${requestId}] 所有供应商均失败`);
+    return res.status(502).json({ error: 'All providers failed' });
+  }
+
+  return app;
+}
+
+function buildTargetUrl(target, originalPath, isStream, effectiveModel) {
+  const base = target.providerUrl.replace(/\/$/, '');
+  const hasV1Suffix = base.endsWith('/v1');
+
+  if (target.protocol === '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 (target.protocol === 'anthropic') {
+    if (hasV1Suffix) return `${base}/messages`;
+    return `${base}/v1/messages`;
+  }
+
+  if (target.protocol === 'gemini') {
+    const model = effectiveModel || 'gemini-pro';
+    const action = isStream ? 'streamGenerateContent?alt=sse' : 'generateContent';
+    return `${base}/v1beta/models/${model}:${action}`;
+  }
+
+  return base + originalPath;
+}
+
+module.exports = { createProxyApp };