coding-tool-x 3.7.10 → 3.7.11

package/dist/web/index.html

@@ -5,14 +5,14 @@
     <link rel="icon" href="/favicon.ico">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>coding-tool-x · AI 编程工作台</title>
-    <script type="module" crossorigin src="/assets/index-LYvv7wtx.js"></script>
+    <script type="module" crossorigin src="/assets/index-k5oP7c-A.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/markdown-BNJfEgCA.js">
     <link rel="modulepreload" crossorigin href="/assets/vue-vendor-B5RqjEjQ.js">
     <link rel="modulepreload" crossorigin href="/assets/naive-ui-BALVpMgd.js">
     <link rel="modulepreload" crossorigin href="/assets/icons-nGdSKQn2.js">
     <link rel="modulepreload" crossorigin href="/assets/vendors-DQA4Hw9v.js">
     <link rel="stylesheet" crossorigin href="/assets/markdown-BfC0goYb.css">
-    <link rel="stylesheet" crossorigin href="/assets/index-C5nLTbOk.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BceXgSSe.css">
   </head>
   <body>
     <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-tool-x",
-  "version": "3.7.10",
+  "version": "3.7.11",
   "description": "Vibe Coding 增强工作助手 - 智能会话管理、动态渠道切换、全局搜索、实时监控",
   "main": "src/index.js",
   "bin": {

package/src/commands/toggle-proxy.js

@@ -205,9 +205,10 @@ async function handleStartProxy(cliType, services) {
 
   console.log(chalk.cyan('动态切换功能说明:'));
   if (services.managedProviderConfig) {
-    console.log(chalk.gray('• 开启后会把已启用的 OMP 渠道写入受管 models.yml provider 配置'));
-    console.log(chalk.gray(`• 可以通过 Web UI 或"渠道管理"功能调整启用的 ${toolName} provider`));
-    console.log(chalk.gray(`• 状态端口: http://127.0.0.1:${defaultPort}\n`));
+    console.log(chalk.gray('• 开启后会启动 OMP 专用本地网关，并把受管 provider 指向该网关'));
+    console.log(chalk.gray(`• 可以通过 Web UI 或"渠道管理"功能调整启用的 ${toolName} 路由组`));
+    console.log(chalk.gray('• 同路由组内由 coding-tool-x 动态选择渠道，跨模型 fallback 仍由 OMP 处理'));
+    console.log(chalk.gray(`• OMP 网关地址: http://127.0.0.1:${defaultPort}\n`));
   } else {
     console.log(chalk.gray('• 开启后会在本地启动一个代理服务'));
     console.log(chalk.gray(`• 可以在不重启 ${toolName} 的情况下动态管理渠道`));
@@ -217,7 +218,7 @@ async function handleStartProxy(cliType, services) {
 
   console.log(chalk.yellow('[WARN]  重要提示:'));
   if (services.managedProviderConfig) {
-    console.log(chalk.yellow('• 启用后会写入 Coding-Tool 管理的 OMP models.yml provider 配置'));
+    console.log(chalk.yellow('• 启用后会写入指向本地网关的 OMP models.yml provider 配置'));
     console.log(chalk.yellow('• 关闭会移除受管 provider，不会清理 OMP 原生 auth.json\n'));
   } else {
     console.log(chalk.yellow('• 开启期间请勿关闭 CLI 终端窗口'));
@@ -253,9 +254,7 @@ async function handleStartProxy(cliType, services) {
 
     if (services.managedProviderConfig) {
       console.log(chalk.green('[OK] OMP models.yml 受管 provider 已启用'));
-      if (proxyResult.port) {
-        console.log(chalk.gray(`状态端口: http://127.0.0.1:${proxyResult.port}`));
-      }
+      console.log(chalk.gray('OMP 新增会话用量日志观察已启用'));
       (proxyResult.warnings || []).forEach((warning) => {
         console.log(chalk.yellow(`[WARN]  ${warning}`));
       });
@@ -325,7 +324,7 @@ async function handleStopProxy(cliType, services) {
   if (services.managedProviderConfig) {
     console.log(chalk.gray(`• 受管配置: ${chalk.green('已启用')}`));
     console.log(chalk.gray(`• 配置模式: ${proxyStatus.mode || 'models-yml-provider-config'}`));
-    console.log(chalk.gray(`• 状态端口: http://127.0.0.1:${proxyStatus.port || proxyStatus.defaultPort}\n`));
+    console.log(chalk.gray(`• 会话日志观察: ${proxyStatus.sessionLogObserver?.running ? chalk.green('运行中') : chalk.yellow('未运行')}\n`));
   } else {
     console.log(chalk.gray(`• 代理服务: ${chalk.green('运行中')}`));
     console.log(chalk.gray(`• 代理端口: ${proxyStatus.port}`));

package/src/commands/ui.js

@@ -87,6 +87,16 @@ async function handleUI() {
         // 忽略错误
       }
 
+      // OMP 动态网关持有 models.yml 事务，退出前必须先恢复原生配置。
+      try {
+        const { getOmpProxyStatus, stopOmpProxyServer } = require('../server/omp-proxy-server');
+        if (getOmpProxyStatus().running) {
+          await stopOmpProxyServer({ forceAfterMs: 1500 });
+        }
+      } catch (err) {
+        console.error(chalk.yellow(`[WARN] OMP 动态网关退出清理失败: ${err.message}`));
+      }
+
       console.log(chalk.green('[OK] Web UI 已停止\n'));
       process.exit(0);
     });
@@ -99,7 +109,7 @@ async function handleUI() {
 
   } catch (error) {
     console.error(chalk.red('启动服务器失败:'), error.message);
-    process.exit(1);
+    throw error;
   }
 }
 

package/src/config/default.js

@@ -21,7 +21,7 @@ const DEFAULT_CONFIG = {
     codexProxy: 20089,  // Codex 代理服务端口
     geminiProxy: 20090, // Gemini 代理服务端口
     opencodeProxy: 20091, // OpenCode 代理服务端口
-    ompProxy: 20092       // OMP 托管 provider 状态端口占位
+    ompProxy: 20092       // OMP 专用动态网关端口
   },
   maxLogs: 100,
   statsInterval: 30,

package/src/index.js

@@ -34,9 +34,7 @@ function getVersion() {
 }
 
 function finishCli(code = 0) {
-  eventBus.emitSync('cli:shutdown', {});
-  PluginManager.shutdownPlugins();
-  process.exit(code);
+  return shutdownProcess(code);
 }
 
 // 显示帮助信息
@@ -128,20 +126,49 @@ function showHelp() {
   console.log(chalk.gray('  问题: https://github.com/ZeaoZhang/coding-tool/issues\n'));
 }
 
+let processShutdownPromise = null;
+
+async function stopOwnedOmpGatewayBeforeExit() {
+  try {
+    const {
+      getOmpProxyStatus,
+      stopOmpProxyServer
+    } = require('./server/omp-proxy-server');
+    if (getOmpProxyStatus().running) {
+      await stopOmpProxyServer({ forceAfterMs: 1500 });
+    }
+  } catch (error) {
+    console.error(chalk.yellow(`[WARN]  OMP 动态网关退出清理失败: ${error.message}`));
+  }
+}
+
+function shutdownProcess(code = 0, error = null) {
+  if (processShutdownPromise) return processShutdownPromise;
+  processShutdownPromise = (async () => {
+    await stopOwnedOmpGatewayBeforeExit();
+    eventBus.emitSync('cli:shutdown', {});
+    PluginManager.shutdownPlugins();
+    if (error) {
+      console.error(error);
+    }
+    process.exit(code);
+  })();
+  return processShutdownPromise;
+}
+
 // 全局错误处理
 process.on('uncaughtException', (err) => {
   // 忽略终端相关的错误（通常在 Ctrl+C 时发生）
-  if (err.code === 'EIO' || err.code === 'ENOTTY' || err.code === 'EPIPE') {
-    process.exit(0);
-  }
-  throw err;
+  const terminalError = err.code === 'EIO' || err.code === 'ENOTTY' || err.code === 'EPIPE';
+  void shutdownProcess(terminalError ? 0 : 1, terminalError ? null : err);
 });
 
-// 处理 SIGINT 信号（Ctrl+C）
-process.on('SIGINT', async () => {
-  eventBus.emitSync('cli:shutdown', {});
-  PluginManager.shutdownPlugins();
-  process.exit(0);
+// 处理进程退出信号，OMP 必须先排空并恢复原生配置。
+process.on('SIGINT', () => {
+  void shutdownProcess(0);
+});
+process.on('SIGTERM', () => {
+  void shutdownProcess(0);
 });
 
 /**
@@ -416,7 +443,7 @@ async function main() {
     eventBus.emitSync('cli:command:after', { command: args[0], args: args.slice(1), result });
     if (!result.success) {
       console.error(chalk.red(result.error));
-      process.exit(1);
+      return shutdownProcess(1);
     }
     return;
   }
@@ -712,6 +739,5 @@ async function main() {
 
 // 启动应用
 main().catch((error) => {
-  console.error('程序出错:', error);
-  process.exit(1);
+  void shutdownProcess(1, error);
 });

package/src/server/api/omp-channels.js

@@ -294,7 +294,7 @@ module.exports = () => {
         baseUrl,
         apiKey: apiKey || '',
         gatewaySourceType: gatewaySourceType || 'openai_compatible',
-        authMode: authMode === 'oauth' ? 'oauth' : 'api_key',
+        authMode: ['api_key', 'oauth', 'none'].includes(authMode) ? authMode : 'api_key',
         oauthProviderId: oauthProviderId || '',
         model: model || null,
         speedTestModel: speedTestModel || null,
@@ -407,6 +407,7 @@ module.exports = () => {
         providerApi,
         authMode,
         oauthProviderId,
+        routingGroup,
         presetId,
         websiteUrl,
         balanceToken,
@@ -425,8 +426,8 @@ module.exports = () => {
       if (!name || !baseUrl) {
         return res.status(400).json({ error: 'Missing required fields: name and baseUrl' });
       }
-      const normalizedAuthMode = authMode === 'oauth' ? 'oauth' : 'api_key';
-      if (!apiKey && normalizedAuthMode !== 'oauth') {
+      const normalizedAuthMode = ['api_key', 'oauth', 'none'].includes(authMode) ? authMode : 'api_key';
+      if (!apiKey && normalizedAuthMode === 'api_key') {
         return res.status(400).json({ error: 'API Key is required' });
       }
 
@@ -435,7 +436,8 @@ module.exports = () => {
         providerApi: providerApi || wireApi || 'openai-completions',
         providerKey,
         authMode: normalizedAuthMode,
-        oauthProviderId: oauthProviderId || providerKey || '',
+        oauthProviderId: normalizedAuthMode === 'oauth' ? (oauthProviderId || providerKey || '') : '',
+        routingGroup: String(routingGroup || '').trim(),
         enabled,
         weight,
         maxConcurrency,

package/src/server/api/omp-config.js

@@ -81,7 +81,7 @@ function buildCapabilities() {
     },
     notes: [
       'The omp channel is backed by OMP and uses omp as its platform key.',
-      'Provider channels are enabled by merging managed ctx-* providers into OMP models.yml.'
+      'Dynamic mode exposes managed ctx-* providers through the loopback OMP HTTP gateway; disabling it restores native OMP configuration.'
     ]
   };
 }

package/src/server/api/omp-proxy.js

@@ -1,6 +1,4 @@
 const express = require('express');
-const fs = require('fs');
-const path = require('path');
 const router = express.Router();
 const {
   startOmpProxyServer,
@@ -10,10 +8,10 @@ const {
 const {
   getChannels,
   getEnabledChannels,
-  markChannelAsRecentlyUsed
+  markChannelAsRecentlyUsed,
+  loadManagedOmpActiveChannelId
 } = require('../services/omp-channels');
 const { getSchedulerState } = require('../services/channel-scheduler');
-const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
 
 function sanitizeChannel(channel) {
   if (!channel) return null;
@@ -21,7 +19,10 @@ function sanitizeChannel(channel) {
     id: channel.id,
     name: channel.name,
     baseUrl: channel.baseUrl,
-    websiteUrl: channel.websiteUrl
+    websiteUrl: channel.websiteUrl,
+    providerKey: channel.providerKey,
+    providerApi: channel.providerApi,
+    routingGroup: channel.routingGroup || ''
   };
 }
 
@@ -35,34 +36,6 @@ function selectLatestEnabledChannel(channels) {
   }, enabledChannels[0]);
 }
 
-function saveActiveChannelId(channelId) {
-  ensureStorageDirMigrated();
-  const filePath = PATHS.activeChannel.omp;
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(filePath, JSON.stringify({ activeChannelId: channelId }, null, 2), 'utf8');
-}
-
-function loadActiveChannelId() {
-  ensureStorageDirMigrated();
-  try {
-    if (!fs.existsSync(PATHS.activeChannel.omp)) return null;
-    const data = JSON.parse(fs.readFileSync(PATHS.activeChannel.omp, 'utf8'));
-    return data.activeChannelId || null;
-  } catch {
-    return null;
-  }
-}
-
-function removeActiveChannelFile() {
-  ensureStorageDirMigrated();
-  if (fs.existsSync(PATHS.activeChannel.omp)) {
-    fs.unlinkSync(PATHS.activeChannel.omp);
-  }
-}
-
 function resolveActiveChannel(channels, activeChannelId = null) {
   if (!Array.isArray(channels) || channels.length === 0) return null;
   if (activeChannelId) {
@@ -80,12 +53,12 @@ router.get('/status', (req, res) => {
     const proxy = getOmpProxyStatus();
     const { channels } = getChannels();
     const enabledChannels = channels.filter(ch => ch.enabled !== false);
-    const activeChannel = resolveActiveChannel(channels, loadActiveChannelId());
+    const activeChannel = resolveActiveChannel(channels, loadManagedOmpActiveChannelId());
     res.json({
       proxy,
       config: {
-        mode: 'models-yml-provider-config',
-        nativeProxyProtocol: false
+        mode: 'http-gateway',
+        nativeProxyProtocol: true
       },
       activeChannel: sanitizeChannel(activeChannel),
       enabledChannelsCount: enabledChannels.length,
@@ -107,11 +80,10 @@ router.post('/start', async (req, res) => {
 
     let currentChannel = selectLatestEnabledChannel(enabledChannels) || enabledChannels[0];
     currentChannel = markChannelAsRecentlyUsed(currentChannel.id);
-    saveActiveChannelId(currentChannel.id);
 
-    const proxyResult = await startOmpProxyServer();
+    const proxyResult = await startOmpProxyServer({ activeChannelId: currentChannel.id });
     if (!proxyResult.success) {
-      return res.status(500).json({ error: 'Failed to enable OMP models.yml provider config' });
+      return res.status(500).json({ error: 'Failed to start OMP gateway' });
     }
 
     const { broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
@@ -125,10 +97,10 @@ router.post('/start', async (req, res) => {
       success: true,
       port: proxyResult.port,
       activeChannel: sanitizeChannel(activeChannel),
-      mode: 'models-yml-provider-config',
+      mode: 'http-gateway',
       sync: proxyResult.sync || null,
       warnings: proxyResult.warnings || [],
-      message: `OMP models.yml provider config enabled, active channel: ${activeChannel.name}`
+      message: `OMP gateway and managed providers enabled, active channel: ${activeChannel.name}`
     });
   } catch (error) {
     console.error('[OMP Proxy] Start failed:', error);
@@ -139,7 +111,6 @@ router.post('/start', async (req, res) => {
 router.post('/stop', async (req, res) => {
   try {
     const result = await stopOmpProxyServer();
-    removeActiveChannelFile();
     const { broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
     const { channels } = getChannels();
     broadcastProxyState('omp', getOmpProxyStatus(), null, channels);

package/src/server/index.js

@@ -465,13 +465,13 @@ function autoRestoreProxies() {
     startOmpProxyServer({ preserveStartTime: true })
       .then((result) => {
         if (result.success) {
-          console.log(chalk.green(`[OK] OMP models.yml 受管 provider 已自动启用，端口: ${result.port}`));
+          console.log(chalk.green(`[OK] OMP 动态网关已自动恢复: http://127.0.0.1:${result.port}`));
         } else {
-          console.error(chalk.red(`[ERROR] OMP models.yml 受管 provider 恢复失败: ${result.error || 'Unknown error'}`));
+          console.error(chalk.red(`[ERROR] OMP 动态网关恢复失败: ${result.error || 'Unknown error'}`));
         }
       })
       .catch((err) => {
-        console.error(chalk.red(`[ERROR] OMP models.yml 受管 provider 恢复失败: ${err.message}`));
+        console.error(chalk.red(`[ERROR] OMP 动态网关恢复失败: ${err.message}`));
       });
   }
 }

package/src/server/omp-proxy-server.js

@@ -1,17 +1,96 @@
+const crypto = require('crypto');
 const { loadConfig } = require('../config/loader');
 const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
-const { syncManagedOmpProviders, disableManagedOmpProviders, getEnabledChannels } = require('./services/omp-channels');
+const {
+  syncManagedOmpProviders,
+  disableManagedOmpProviders,
+  getEnabledChannels,
+  isManagedOmpModeEnabled,
+  enableManagedOmpMode,
+  disableManagedOmpMode,
+  loadManagedOmpActiveChannelId,
+  loadManagedOmpModeState
+} = require('./services/omp-channels');
+const {
+  startOmpSessionLogObserver,
+  stopOmpSessionLogObserver,
+  getOmpSessionLogObserverStatus
+} = require('./services/omp-session-log-observer');
+const { createOmpGateway } = require('./services/omp-gateway');
+const { prepareManagedOmpChannels } = require('./services/omp-gateway-routing');
+const { probeOmpAuthGateways } = require('./services/omp-auth-gateway-client');
 
-let running = false;
 let currentPort = null;
 let lastSyncResult = null;
+let lastRoutingResult = { routes: [], unsupportedChannels: [] };
+let lifecycle = Promise.resolve();
 
-async function startOmpProxyServer(options = {}) {
+const gateway = createOmpGateway({
+  getChannels: () => getEnabledChannels()
+});
+
+function withLifecycleLock(operation) {
+  const next = lifecycle.then(operation, operation);
+  lifecycle = next.catch(() => {});
+  return next;
+}
+
+async function startOmpProxyServerUnlocked(options = {}) {
+  if (gateway.status().listening) {
+    return {
+      success: true,
+      port: gateway.status().port,
+      sync: lastSyncResult,
+      warnings: lastSyncResult?.warnings || []
+    };
+  }
   const preserveStartTime = options.preserveStartTime || false;
   const config = loadConfig();
-  currentPort = config.ports?.ompProxy || 20092;
-  lastSyncResult = syncManagedOmpProviders();
-  running = true;
+  const wasEnabled = isManagedOmpModeEnabled();
+  const previousState = loadManagedOmpModeState?.() || {
+    activeChannelId: loadManagedOmpActiveChannelId()
+  };
+  const channels = getEnabledChannels();
+  const secret = crypto.randomBytes(32).toString('hex');
+  const desiredPort = options.port ?? config.ports?.ompProxy ?? 20092;
+  const gatewayStatus = await gateway.start({
+    host: '127.0.0.1',
+    port: desiredPort,
+    secret
+  });
+  currentPort = gatewayStatus.port;
+  try {
+    const oauthSupport = await probeOmpAuthGateways(channels);
+    const descriptor = {
+      ...gateway.descriptor(),
+      supportedOAuthChannelIds: oauthSupport.supportedOAuthChannelIds
+    };
+    lastRoutingResult = prepareManagedOmpChannels(channels, descriptor);
+    enableManagedOmpMode(options.activeChannelId, descriptor);
+    lastSyncResult = syncManagedOmpProviders(channels, {
+      gateway: descriptor,
+      activeChannelId: options.activeChannelId
+    });
+    if (oauthSupport.warnings.length > 0) {
+      lastSyncResult = {
+        ...lastSyncResult,
+        warnings: [
+          ...(lastSyncResult?.warnings || []),
+          ...oauthSupport.warnings
+        ]
+      };
+    }
+  } catch (error) {
+    if (wasEnabled) {
+      enableManagedOmpMode(previousState.activeChannelId, previousState.gateway || null);
+    } else {
+      disableManagedOmpMode();
+    }
+    await gateway.stop().catch(() => {});
+    currentPort = null;
+    throw error;
+  }
+  startOmpSessionLogObserver();
   saveProxyStartTime('omp', preserveStartTime);
   return {
     success: true,
@@ -21,12 +100,34 @@ async function startOmpProxyServer(options = {}) {
   };
 }
 
-async function stopOmpProxyServer(options = {}) {
+function startOmpProxyServer(options = {}) {
+  return withLifecycleLock(() => startOmpProxyServerUnlocked(options));
+}
+
+async function stopOmpProxyServerUnlocked(options = {}) {
   const clearStartTime = options.clearStartTime !== false;
   const stoppedPort = currentPort;
-  lastSyncResult = disableManagedOmpProviders();
-  running = false;
+  if (!gateway.status().listening && !isManagedOmpModeEnabled()) {
+    return {
+      success: true,
+      port: stoppedPort,
+      sync: lastSyncResult,
+      warnings: lastSyncResult?.warnings || []
+    };
+  }
+  gateway.beginDraining();
+  stopOmpSessionLogObserver();
+  try {
+    lastSyncResult = disableManagedOmpProviders();
+  } catch (error) {
+    startOmpSessionLogObserver();
+    gateway.cancelDraining();
+    throw error;
+  }
+  disableManagedOmpMode();
+  await gateway.stop({ forceAfterMs: options.forceAfterMs });
   currentPort = null;
+  lastRoutingResult = { routes: [], unsupportedChannels: [] };
   if (clearStartTime) {
     clearProxyStartTime('omp');
   }
@@ -38,8 +139,14 @@ async function stopOmpProxyServer(options = {}) {
   };
 }
 
+function stopOmpProxyServer(options = {}) {
+  return withLifecycleLock(() => stopOmpProxyServerUnlocked(options));
+}
+
 function getOmpProxyStatus() {
   const config = loadConfig();
+  const gatewayStatus = gateway.status();
+  const running = gatewayStatus.listening;
   const startTime = getProxyStartTime('omp', { allowRecovery: running });
   const runtime = getProxyRuntime('omp', { allowRecovery: running });
   const enabledCount = getEnabledChannels().length;
@@ -50,11 +157,23 @@ function getOmpProxyStatus() {
     defaultPort: config.ports?.ompProxy || 20092,
     startTime,
     runtime,
-    mode: 'models-yml-provider-config',
+    mode: 'http-gateway',
+    listening: gatewayStatus.listening,
+    draining: gatewayStatus.draining,
+    inflightRequests: gatewayStatus.inflightRequests,
+    routingGroups: lastRoutingResult.routes.map(route => ({
+      providerKey: route.providerKey,
+      providerApi: route.providerApi,
+      routingGroup: route.routingGroup,
+      managedProviderId: route.managedProviderId,
+      channelsCount: route.channelIds.length
+    })),
+    unsupportedChannels: lastRoutingResult.unsupportedChannels,
     enabledChannelsCount: enabledCount,
     modelsPath: lastSyncResult?.modelsPath || lastSyncResult?.path || null,
     backupPath: lastSyncResult?.backupPath || null,
     modelsValidation: validation,
+    sessionLogObserver: getOmpSessionLogObserverStatus(),
     warnings: lastSyncResult?.warnings || []
   };
 }

package/src/server/services/channel-scheduler.js

@@ -101,10 +101,35 @@ function refreshChannels(source = 'claude') {
   });
 }
 
-function getAvailableChannels(source = 'claude') {
+function matchesAllocationRequest(channel, options = {}) {
+  const candidateIds = Array.isArray(options.candidateIds)
+    ? new Set(options.candidateIds.filter(Boolean))
+    : null;
+  const excludedIds = new Set(
+    Array.isArray(options.excludeChannelIds) ? options.excludeChannelIds.filter(Boolean) : []
+  );
+  if (candidateIds && !candidateIds.has(channel.id)) return false;
+  if (excludedIds.has(channel.id)) return false;
+  if (options.routingGroup && String(channel.routingGroup || channel.id) !== String(options.routingGroup)) {
+    return false;
+  }
+  if (options.providerKey && String(channel.providerKey || channel.provider || '') !== String(options.providerKey)) {
+    return false;
+  }
+  if (
+    options.providerApi
+    && String(channel.providerApi || channel.api || channel.wireApi || 'openai-completions') !== String(options.providerApi)
+  ) {
+    return false;
+  }
+  return true;
+}
+
+function getAvailableChannels(source = 'claude', options = {}) {
   refreshChannels(source);
   const state = getState(source);
   return state.channels.filter(ch => {
+    if (!matchesAllocationRequest(ch, options)) return false;
     if (!isChannelAvailable(ch.id, source)) {
       return false;
     }
@@ -132,7 +157,7 @@ function tryAllocate(source = 'claude', options = {}) {
   const state = getState(source);
   const sessionId = options.sessionId;
   const enableSessionBinding = options.enableSessionBinding !== false; // 默认开启
-  const available = getAvailableChannels(source);
+  const available = getAvailableChannels(source, options);
   if (!available.length) {
     return null;
   }
@@ -169,6 +194,7 @@ function drainQueue(source = 'claude') {
     if (channel) {
       clearTimeout(entry.timer);
       state.queue.splice(i, 1);
+      entry.cleanup?.();
       entry.resolve(channel);
       return drainQueue(source);
     }
@@ -178,6 +204,9 @@ function drainQueue(source = 'claude') {
 function allocateChannel(options = {}) {
   const source = options.source || 'claude';
   const state = getState(source);
+  if (options.signal?.aborted) {
+    return Promise.reject(Object.assign(new Error('Channel allocation aborted'), { name: 'AbortError' }));
+  }
   const channel = tryAllocate(source, options);
   if (channel) {
     return Promise.resolve(channel);
@@ -186,16 +215,31 @@ function allocateChannel(options = {}) {
   if (!state.channels.length) {
     return Promise.reject(new Error('暂无可用渠道，请先添加并启用至少一个渠道'));
   }
+  if (!state.channels.some(ch => matchesAllocationRequest(ch, options))) {
+    return Promise.reject(new Error('没有匹配当前请求的可用渠道'));
+  }
 
   // 检查是否所有渠道都被冻结
   const allFrozen = state.channels.every(ch => !isChannelAvailable(ch.id, source));
 
   return new Promise((resolve, reject) => {
+    let entry;
+    const cleanup = () => {
+      options.signal?.removeEventListener('abort', onAbort);
+    };
+    const removeEntry = () => {
+      const index = state.queue.indexOf(entry);
+      if (index !== -1) state.queue.splice(index, 1);
+    };
+    const onAbort = () => {
+      clearTimeout(timer);
+      removeEntry();
+      cleanup();
+      reject(Object.assign(new Error('Channel allocation aborted'), { name: 'AbortError' }));
+    };
     const timer = setTimeout(() => {
-      const index = state.queue.findIndex(item => item.timer === timer);
-      if (index !== -1) {
-        state.queue.splice(index, 1);
-      }
+      removeEntry();
+      cleanup();
       // 根据实际情况返回更准确的错误信息
       if (allFrozen) {
         reject(new Error('所有渠道均已被冻结，请等待健康检查恢复或手动重置'));
@@ -204,13 +248,19 @@ function allocateChannel(options = {}) {
       }
     }, WAIT_TIMEOUT_MS);
 
-    state.queue.push({
+    entry = {
       source,
       options,
       resolve,
       reject,
-      timer
-    });
+      timer,
+      cleanup
+    };
+    state.queue.push(entry);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted) {
+      onAbort();
+    }
   });
 }