coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services/claude-openai-gateway.js → platforms/drivers/claude/openai-gateway.js}

@@ -2,13 +2,10 @@ const http = require('http');
 const https = require('https');
 const crypto = require('crypto');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { broadcastLog } = require('../websocket-server');
-const { recordRequest } = require('./statistics-service');
-const { recordSuccess, recordFailure } = require('./channel-health');
-const { publishUsageLog, publishFailureLog } = require('./proxy-log-helper');
-const { createDecodedStream } = require('./response-decoder');
-const { parseNonStreamingUsage } = require('./base/response-usage-parser');
-const { convertClaudeToOpenCodePayload } = require('./opencode-gateway-converter');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { createDecodedStream } = require('../../../server/services/response-decoder');
+const { parseNonStreamingUsage } = require('../../../shared/response-usage-parser');
+const { convertClaudeToOpenCodePayload } = require('../opencode/gateway-converter');
 
 const REQUEST_TIMEOUT_MS = 120000;
 
@@ -299,18 +296,6 @@ function buildClaudeUsageFromTokens(tokens = {}) {
   };
 }
 
-function buildPublishTokensFromClaudeUsage(usage = {}) {
-  return {
-    input: Number(usage.input_tokens || 0),
-    output: Number(usage.output_tokens || 0),
-    cacheCreation: Number(usage.cache_creation_input_tokens || 0),
-    cacheRead: Number(usage.cache_read_input_tokens || 0),
-    cached: Number(usage.cache_read_input_tokens || 0),
-    reasoning: 0,
-    total: 0
-  };
-}
-
 function mapResponsesStopReason(response, hasToolUse) {
   if (hasToolUse) return 'tool_use';
 
@@ -1086,31 +1071,8 @@ async function relayChatStreamAsClaude(upstreamResponse, res, fallbackModel = ''
   });
 }
 
-function publishClaudeGatewayUsage(metadata, message, calculateCost) {
-  return publishUsageLog({
-    source: 'claude',
-    metadata,
-    model: message?.model || '',
-    tokens: buildPublishTokensFromClaudeUsage(message?.usage || {}),
-    calculateCost,
-    broadcastLog,
-    recordRequest,
-    recordSuccess,
-    allowBroadcast: true
-  });
-}
-
-function reportGatewayFailure({ channel, metadata, res, statusCode, message, error, stage, onDone }) {
+function reportGatewayFailure({ channel, res, statusCode, message, error, onDone }) {
   recordFailure(channel.id, 'claude', error || new Error(message));
-  publishFailureLog({
-    source: 'claude',
-    metadata,
-    message,
-    error,
-    statusCode,
-    stage,
-    broadcastLog
-  });
   sendAnthropicError(res, statusCode, message);
   if (typeof onDone === 'function') {
     onDone();
@@ -1118,7 +1080,7 @@ function reportGatewayFailure({ channel, metadata, res, statusCode, message, err
   return true;
 }
 
-async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKey, calculateCost, onDone }) {
+async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKey, onDone }) {
   const pathname = getRequestPathname(req?.url || '');
   if (!isClaudeMessagesPath(pathname)) {
     return false;
@@ -1132,21 +1094,12 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
     return true;
   }
 
-  const requestId = `claude-openai-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-  const startTime = Date.now();
   const targetApi = resolveClaudeGatewayTargetApi(channel);
   const converted = convertClaudeToOpenCodePayload({
     payload: req.body,
     options: { targetApi }
   });
   const upstreamModel = converted?.requestBody?.model || req.body.model || '';
-  const metadata = {
-    id: requestId,
-    channel: channel?.name,
-    channelId: channel?.id,
-    startTime,
-    requestModel: upstreamModel
-  };
   const wantsStream = req.body.stream === true;
   const targetUrl = buildOpenAiTargetUrl(channel?.baseUrl || '', converted.endpoint || '/v1/responses');
   const headers = buildOpenAiHeaders(effectiveKey, {
@@ -1171,12 +1124,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
         const upstreamMessage = parsedError?.error?.message || parsedError?.message || rawBody || `HTTP ${upstream.statusCode}`;
         return reportGatewayFailure({
           channel,
-          metadata,
           res,
           statusCode: upstream.statusCode,
           message: String(upstreamMessage).slice(0, 1000),
           error: new Error(String(upstreamMessage).slice(0, 200)),
-          stage: 'openai_gateway_upstream',
           onDone
         });
       }
@@ -1185,9 +1136,7 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
         ? await relayChatStreamAsClaude(upstream.response, res, upstreamModel)
         : await relayResponsesStreamAsClaude(upstream.response, res, upstreamModel);
 
-      if (message) {
-        publishClaudeGatewayUsage(metadata, message, calculateCost);
-      }
+      recordSuccess(channel.id, 'claude');
       if (typeof onDone === 'function') {
         onDone();
       }
@@ -1207,12 +1156,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
       const upstreamMessage = parsedBody?.error?.message || parsedBody?.message || upstream.rawBody || `HTTP ${upstream.statusCode}`;
       return reportGatewayFailure({
         channel,
-        metadata,
         res,
         statusCode: upstream.statusCode,
         message: String(upstreamMessage).slice(0, 1000),
         error: new Error(String(upstreamMessage).slice(0, 200)),
-        stage: 'openai_gateway_upstream',
         onDone
       });
     }
@@ -1220,12 +1167,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
     if (!parsedBody || typeof parsedBody !== 'object') {
       return reportGatewayFailure({
         channel,
-        metadata,
         res,
         statusCode: 502,
         message: 'Invalid OpenAI gateway response',
         error: new Error('Invalid OpenAI gateway response'),
-        stage: 'openai_gateway_parse',
         onDone
       });
     }
@@ -1235,7 +1180,7 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
       : buildClaudeMessageFromResponses(parsedBody, upstreamModel);
 
     res.json(message);
-    publishClaudeGatewayUsage(metadata, message, calculateCost);
+    recordSuccess(channel.id, 'claude');
     if (typeof onDone === 'function') {
       onDone();
     }
@@ -1243,12 +1188,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
   } catch (error) {
     return reportGatewayFailure({
       channel,
-      metadata,
       res,
       statusCode: 502,
       message: `OpenAI gateway network error: ${error.message}`,
       error,
-      stage: 'openai_gateway_network',
       onDone
     });
   }

package/src/platforms/drivers/claude/project-config.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createJsonMcpHandlers
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createJsonMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'claude-json',
+    toNative: mcpFormat.extractServerSpec,
+    fromNative: value => ({ ...value }),
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createProject({ projectName, projectPath } = {}) {
+  if (!projectName || !projectPath) {
+    const error = new Error('projectName and projectPath are required');
+    error.statusCode = 400;
+    throw error;
+  }
+  if (!fs.existsSync(projectPath)) {
+    const error = new Error('项目路径不存在');
+    error.statusCode = 400;
+    throw error;
+  }
+  if (!fs.statSync(projectPath).isDirectory()) {
+    const error = new Error('项目路径必须是一个目录');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const claudeDir = path.join(projectPath, '.claude');
+  const sessionsDir = path.join(claudeDir, 'sessions');
+  if (fs.existsSync(claudeDir)) {
+    const error = new Error('该项目已经初始化过 Claude Code');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  fs.mkdirSync(sessionsDir, { recursive: true });
+  const projectConfig = {
+    name: projectName,
+    createdAt: new Date().toISOString(),
+    version: '1.0'
+  };
+  fs.writeFileSync(
+    path.join(claudeDir, 'project.json'),
+    JSON.stringify(projectConfig, null, 2),
+    'utf8'
+  );
+
+  return { success: true, projectName, projectPath, claudeDir };
+}
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'claude',
+    servicePath: './claude/sessions-implementation',
+    localServicePath: '../../platforms/drivers/claude/sessions-implementation',
+    createProject,
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('claude');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

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

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

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,