coding-tool-x 3.8.3 → 3.8.5

package/src/{server/proxy-server.js → platforms/drivers/claude/proxy-implementation.js}

@@ -6,29 +6,20 @@ const path = require('path');
 const os = require('os');
 const chalk = require('chalk');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { allocateChannel, releaseChannel, getSchedulerState } = require('./services/channel-scheduler');
-const { recordSuccess, recordFailure } = require('./services/channel-health');
-const { broadcastLog, broadcastSchedulerState } = require('./websocket-server');
-const { loadConfig } = require('../config/loader');
-const DEFAULT_CONFIG = require('../config/default');
-const { resolveModelPricing } = require('./utils/pricing');
-const { recordRequest } = require('./services/statistics-service');
-const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
-const { createDecodedStream } = require('./services/response-decoder');
-const eventBus = require('../plugins/event-bus');
-const { getEffectiveApiKey } = require('./services/channels');
-const { persistProxyRequestSnapshot, persistClaudeRequestTemplate } = require('./services/request-logger');
-const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
-const { redirectModel, normalizeGatewaySourceType } = require('./services/base/proxy-utils');
-const { parseSSEUsage, parseNonStreamingUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
+const { allocateChannel, releaseChannel, getSchedulerState } = require('../../../server/services/channel-scheduler');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { broadcastSchedulerState } = require('../../../server/websocket-server');
+const { loadConfig } = require('../../../config/loader');
+const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('../../../server/services/proxy-runtime');
+const eventBus = require('../../../plugins/event-bus');
 const {
-  createClaudeStreamRecoveryState,
-  mergeClaudeStreamEvent,
-  buildAssistantMessageFromStreamState,
-  recoverClaudeUsageViaCountTokens
-} = require('./services/claude-token-recovery');
-const { handleClaudeOpenAiGatewayRequest } = require('./services/claude-openai-gateway');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
+  getEffectiveApiKey,
+  getClaudeProxyExcludedChannelIds = () => []
+} = require('./channels-implementation');
+const { persistProxyRequestSnapshot, persistClaudeRequestTemplate } = require('../../../server/services/request-logger');
+const { redirectModel, normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
+const { handleClaudeOpenAiGatewayRequest } = require('./openai-gateway');
+const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
@@ -41,33 +32,6 @@ const requestMetadata = new Map();
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
 const printedRedirectCache = new Map();
 
-const CLAUDE_BASE_PRICING = DEFAULT_CONFIG.pricing.claude;
-const ONE_MILLION = 1000000;
-
-// detectModelTier and redirectModel imported from services/base/proxy-utils
-
-/**
- * 计算请求成本
- * @param {string} model - 模型名称
- * @param {object} tokens - token 使用情况
- * @returns {number} 成本（美元）
- */
-function calculateCost(model, tokens) {
-  const pricing = resolveModelPricing('claude', model, {}, CLAUDE_BASE_PRICING);
-
-  const inputRate = typeof pricing.input === 'number' ? pricing.input : CLAUDE_BASE_PRICING.input;
-  const outputRate = typeof pricing.output === 'number' ? pricing.output : CLAUDE_BASE_PRICING.output;
-  const cacheCreationRate = typeof pricing.cacheCreation === 'number' ? pricing.cacheCreation : CLAUDE_BASE_PRICING.cacheCreation;
-  const cacheReadRate = typeof pricing.cacheRead === 'number' ? pricing.cacheRead : CLAUDE_BASE_PRICING.cacheRead;
-
-  return (
-    (tokens.input || 0) * inputRate / ONE_MILLION +
-    (tokens.output || 0) * outputRate / ONE_MILLION +
-    (tokens.cacheCreation || 0) * cacheCreationRate / ONE_MILLION +
-    (tokens.cacheRead || 0) * cacheReadRate / ONE_MILLION
-  );
-}
-
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
@@ -179,16 +143,6 @@ function buildClaudeRequestSummary(req, sessionId = null) {
   };
 }
 
-function clearTokenDataUsage(tokenData) {
-  tokenData.inputTokens = 0;
-  tokenData.outputTokens = 0;
-  tokenData.cacheCreation = 0;
-  tokenData.cacheRead = 0;
-  tokenData.cachedTokens = 0;
-  tokenData.reasoningTokens = 0;
-  tokenData.totalTokens = 0;
-}
-
 async function startProxyServer(options = {}) {
   const preserveStartTime = options.preserveStartTime || false;
 
@@ -196,6 +150,13 @@ async function startProxyServer(options = {}) {
     console.log('Proxy server already running on port', currentPort);
     return { success: true, port: currentPort };
   }
+  const excludedChannelIds = getClaudeProxyExcludedChannelIds();
+  if (excludedChannelIds.length > 0) {
+    const error = new Error('Claude dynamic proxy supports API-key channels only; disable OAuth channels first');
+    error.code = 'claude_oauth_proxy_unsupported';
+    error.statusCode = 409;
+    throw error;
+  }
 
   try {
     const config = loadConfig();
@@ -254,7 +215,12 @@ async function startProxyServer(options = {}) {
         const sessionId = extractSessionId(req);
         const config = loadConfig();
         const enableSessionBinding = config.enableSessionBinding !== false; // 默认开启
-        const channel = await allocateChannel({ source: 'claude', sessionId, enableSessionBinding });
+        const channel = await allocateChannel({
+          source: 'claude',
+          sessionId,
+          enableSessionBinding,
+          excludeChannelIds: getClaudeProxyExcludedChannelIds()
+        });
 
         // 广播调度状态（请求开始）
         broadcastSchedulerState('claude', getSchedulerState('claude'));
@@ -279,14 +245,6 @@ async function startProxyServer(options = {}) {
         const effectiveKey = getEffectiveApiKey(channel);
         if (!effectiveKey) {
           release();
-          publishFailureLog({
-            source: 'claude',
-            channel: channel.name,
-            message: 'API key not configured or expired. Please update your channel key.',
-            statusCode: 401,
-            stage: 'preflight',
-            broadcastLog
-          });
           return res.status(401).json({
             error: 'API key not configured or expired. Please update your channel key.',
             type: 'authentication_error'
@@ -338,7 +296,6 @@ async function startProxyServer(options = {}) {
             res,
             channel,
             effectiveKey,
-            calculateCost,
             onDone: release
           });
           if (handled) {
@@ -362,21 +319,6 @@ async function startProxyServer(options = {}) {
           if (err) {
             // 记录请求失败
             recordFailure(channel.id, 'claude', err);
-            const metadata = requestMetadata.get(req) || {
-              id: null,
-              channel: channel.name,
-              channelId: channel.id,
-              startTime: Date.now()
-            };
-            publishFailureLog({
-              source: 'claude',
-              metadata,
-              message: err.message,
-              error: err,
-              statusCode: 502,
-              stage: 'proxy_web',
-              broadcastLog
-            });
             console.error('Proxy error:', err);
             if (res && !res.headersSent) {
               res.status(502).json({
@@ -388,13 +330,6 @@ async function startProxyServer(options = {}) {
         });
       } catch (error) {
         console.error('Channel allocation error:', error);
-        publishFailureLog({
-          source: 'claude',
-          message: error.message || '所有渠道暂时不可用',
-          statusCode: 503,
-          stage: 'allocate_channel',
-          broadcastLog
-        });
         if (!res.headersSent) {
           res.status(503).json({
             error: error.message || '所有渠道暂时不可用',
@@ -404,6 +339,7 @@ async function startProxyServer(options = {}) {
       }
     });
 
+    // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
       const metadata = requestMetadata.get(req);
       if (!metadata) return;
@@ -413,185 +349,26 @@ async function startProxyServer(options = {}) {
         return;
       }
 
-      let isResponseClosed = false;
-
-      res.on('close', () => {
-        isResponseClosed = true;
-        requestMetadata.delete(req);
-      });
-
+      res.on('close', () => requestMetadata.delete(req));
       res.on('error', (err) => {
-        isResponseClosed = true;
-        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
-          console.error('Response error:', err);
-        }
+        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') console.error('Response error:', err);
+        recordFailure(metadata.channelId, 'claude', err);
         requestMetadata.delete(req);
       });
 
-      const isSseResponse = proxyRes.headers['content-type']?.includes('text/event-stream');
-      let buffer = '';
-      let tokenData = createTokenData();
-      let usageRecorded = false;
-      const streamRecoveryState = createClaudeStreamRecoveryState();
-      const usageObservation = {
-        sawAnyUsage: false,
-        sawMessageStartUsage: false,
-        sawNonInitialUsage: false
-      };
-      const parsedStream = createDecodedStream(proxyRes);
-
-      function recordUsageIfReady() {
-        if (usageRecorded) return false;
-
-        const result = publishUsageLog({
-          source: 'claude',
-          metadata,
-          model: tokenData.model,
-          tokens: {
-            input: tokenData.inputTokens,
-            output: tokenData.outputTokens,
-            cacheCreation: tokenData.cacheCreation,
-            cacheRead: tokenData.cacheRead,
-            cached: tokenData.cachedTokens,
-            reasoning: tokenData.reasoningTokens,
-            total: tokenData.totalTokens
-          },
-          calculateCost,
-          broadcastLog,
-          recordRequest,
-          recordSuccess,
-          allowBroadcast: true
-        });
-
-        if (!result) return false;
-        usageRecorded = true;
-        return true;
-      }
-
-      parsedStream.on('data', (chunk) => {
-        if (isResponseClosed) return;
-
-        buffer += chunk.toString('utf8');
-
-        if (!isSseResponse) {
-          return;
-        }
-
-        const events = buffer.split('\n\n');
-        buffer = events.pop() || '';
-
-        events.forEach(eventText => {
-          if (!eventText.trim()) return;
-
-          try {
-            const lines = eventText.split('\n');
-            let eventType = '';
-            let data = '';
-
-            lines.forEach(line => {
-              if (line.startsWith('event:')) {
-                eventType = line.substring(6).trim();
-              } else if (line.startsWith('data:')) {
-                data = line.substring(5).trim();
-              }
-            });
-
-            if (!data || data === '[DONE]') return;
-
-            const parsed = JSON.parse(data);
-            mergeClaudeStreamEvent(streamRecoveryState, eventType, parsed);
-            const usage = parseSSEUsage(parsed, eventType);
-            if (usage.tokens) {
-              usageObservation.sawAnyUsage = true;
-              if (eventType === 'message_start') {
-                usageObservation.sawMessageStartUsage = true;
-              } else {
-                usageObservation.sawNonInitialUsage = true;
-              }
-            }
-            mergeUsageIntoTokenData(tokenData, usage);
-
-            if (usage.isDone && (!isSseResponse || usageObservation.sawNonInitialUsage)) {
-              recordUsageIfReady();
-            }
-          } catch (err) {
-          }
-        });
-      });
-
-      const finalize = () => {
-        if (!isResponseClosed) {
-          requestMetadata.delete(req);
-        }
-        if (typeof req.__releaseChannel === 'function') {
-          req.__releaseChannel();
+      const statusCode = Number(proxyRes.statusCode) || 200;
+      proxyRes.on('end', () => {
+        if (statusCode >= 400) {
+          recordFailure(metadata.channelId, 'claude', new Error(`Claude upstream HTTP ${statusCode}`));
+        } else {
+          recordSuccess(metadata.channelId, 'claude');
         }
-      };
-
-      parsedStream.on('end', () => {
-        void (async () => {
-          if (!isSseResponse) {
-            try {
-              const parsed = JSON.parse(buffer);
-              const usage = parseNonStreamingUsage(parsed);
-              mergeUsageIntoTokenData(tokenData, usage);
-            } catch (err) {
-            }
-          } else {
-            const assistantMessage = buildAssistantMessageFromStreamState(streamRecoveryState);
-            const shouldRecoverUsage = Boolean(assistantMessage)
-              && (!usageObservation.sawAnyUsage || (usageObservation.sawMessageStartUsage && !usageObservation.sawNonInitialUsage));
-
-            if (shouldRecoverUsage) {
-              try {
-                const recoveredUsage = await recoverClaudeUsageViaCountTokens({
-                  baseUrl: req.selectedChannel?.baseUrl || '',
-                  apiKey: req.effectiveApiKey || '',
-                  requestBody: req.body,
-                  assistantMessage
-                });
-                if (recoveredUsage) {
-                  tokenData.model = tokenData.model || streamRecoveryState.model || '';
-                  tokenData.inputTokens = Number(recoveredUsage.inputTokens || 0);
-                  tokenData.outputTokens = Number(recoveredUsage.outputTokens || 0);
-                  // Let publishUsageLog recompute Claude totals from the recovered
-                  // prompt/output pair plus any cache fields already present.
-                  tokenData.totalTokens = 0;
-                } else {
-                  tokenData.model = tokenData.model || streamRecoveryState.model || '';
-                  clearTokenDataUsage(tokenData);
-                }
-              } catch (error) {
-                tokenData.model = tokenData.model || streamRecoveryState.model || '';
-                clearTokenDataUsage(tokenData);
-              }
-            }
-          }
-
-          recordUsageIfReady();
-          finalize();
-        })();
+        requestMetadata.delete(req);
       });
-
-      parsedStream.on('error', (err) => {
-        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
-          console.error('Proxy response error:', err);
-        }
-        // 记录响应错误
-        if (metadata && metadata.channelId) {
-          recordFailure(metadata.channelId, 'claude', err);
-        }
-        publishFailureLog({
-          source: 'claude',
-          metadata,
-          message: err.message,
-          error: err,
-          statusCode: proxyRes.statusCode,
-          stage: 'response_stream',
-          broadcastLog
-        });
-        isResponseClosed = true;
-        finalize();
+      proxyRes.on('error', (err) => {
+        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') console.error('Proxy response error:', err);
+        recordFailure(metadata.channelId, 'claude', err);
+        requestMetadata.delete(req);
       });
     });
 
@@ -601,20 +378,6 @@ async function startProxyServer(options = {}) {
       if (req && req.selectedChannel && req.selectedChannel.id) {
         recordFailure(req.selectedChannel.id, 'claude', err);
       }
-      const metadata = req ? requestMetadata.get(req) : null;
-      publishFailureLog({
-        source: 'claude',
-        metadata: metadata || {
-          channel: req?.selectedChannel?.name,
-          channelId: req?.selectedChannel?.id,
-          model: req?.body?.model
-        },
-        message: err.message,
-        error: err,
-        statusCode: 502,
-        stage: 'proxy',
-        broadcastLog
-      });
       if (res && !res.headersSent) {
         res.status(502).json({
           error: 'Proxy error: ' + err.message,

package/src/platforms/drivers/claude/proxy.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createProxyDriver } = require('../../../shared/proxy-driver');
+
+function createDriver(context = {}) {
+  return createProxyDriver({
+    ...context,
+    platform: 'claude',
+    servicePath: './claude/proxy-implementation',
+    localServicePath: '../platforms/drivers/claude/proxy-implementation',
+    exports: { status: 'getProxyStatus', start: 'startProxyServer', stop: 'stopProxyServer' },
+    cliMetadata: { defaultPort: 20088 }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/claude/resource-sync.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createResourceSyncDriver } = require('../../../shared/driver-factories/resource-sync');
+
+function createDriver(context = {}) {
+  return createResourceSyncDriver({ ...context, platform: 'claude' });
+}
+
+module.exports = { createDriver };