coding-tool-x 3.8.4 → 3.8.6

package/src/{server/api/omp-config.js → platforms/drivers/omp/api-operations.js}

@@ -1,16 +1,15 @@
-const express = require('express');
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
-const router = express.Router();
 const {
   getOmpPaths,
   getOmpStatus,
   readJsonFile,
   readYamlFile
-} = require('../services/omp-config');
-const {
-  getOmpAuthProviderSnapshot
-} = require('../services/omp-auth-providers');
+} = require('./config');
+const { getOmpAuthProviderSnapshot } = require('./auth-providers');
+const { createApiOperationsDriver } = require('../../../shared/driver-factories/api');
 
 function listDirEntries(dirPath, options = {}) {
   const { extensions = null, includeDirectories = true } = options;
@@ -20,8 +19,8 @@ function listDirEntries(dirPath, options = {}) {
       .filter(entry => !entry.name.startsWith('.'))
       .filter((entry) => {
         if (entry.isDirectory()) return includeDirectories;
-        if (!Array.isArray(extensions) || extensions.length === 0) return true;
-        return extensions.includes(path.extname(entry.name).toLowerCase());
+        return !Array.isArray(extensions) || extensions.length === 0
+          || extensions.includes(path.extname(entry.name).toLowerCase());
       })
       .map((entry) => {
         const fullPath = path.join(dirPath, entry.name);
@@ -86,11 +85,14 @@ function buildCapabilities() {
   };
 }
 
-router.get('/', (req, res) => {
-  try {
-    const paths = getOmpPaths(process.env, { resolveRuntime: false });
-    const settings = readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
-    const resources = {
+function readConfig() {
+  const paths = getOmpPaths(process.env, { resolveRuntime: false });
+  const settings = readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
+  return {
+    success: true,
+    status: getOmpStatus(process.env, { resolveRuntime: false }),
+    capabilities: buildCapabilities(),
+    resources: {
       config: readYamlFile(paths.config, {}),
       settings: readYamlFile(paths.settings, {}),
       auth: fs.existsSync(paths.auth) ? { exists: true, path: paths.auth } : { exists: false, path: paths.auth },
@@ -104,59 +106,45 @@ router.get('/', (req, res) => {
       notes: listDirEntries(paths.notes, { extensions: ['.md'], includeDirectories: true }),
       extensions: listDirEntries(paths.extensions, { extensions: ['.js', '.mjs', '.cjs', '.ts'], includeDirectories: true }),
       sessionsDir: paths.sessions
-    };
-
-    res.json({
-      success: true,
-      status: getOmpStatus(process.env, { resolveRuntime: false }),
-      capabilities: buildCapabilities(),
-      resources
-    });
-  } catch (error) {
-    console.error('[OMP Config API] Failed to read config:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
+    }
+  };
+}
 
-router.get('/capabilities', (req, res) => {
-  res.json({
+function readResources() {
+  const paths = getOmpPaths(process.env, { resolveRuntime: false });
+  const settings = readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
+  return {
     success: true,
+    paths,
+    packages: normalizeArray(settings.packages),
+    skills: listDirEntries(paths.skills),
+    prompts: listDirEntries(paths.prompts, { extensions: ['.md'], includeDirectories: true }),
+    commands: listDirEntries(paths.commands, { extensions: ['.md'], includeDirectories: true }),
+    notes: listDirEntries(paths.notes, { extensions: ['.md'], includeDirectories: true }),
+    extensions: listDirEntries(paths.extensions, { extensions: ['.js', '.mjs', '.cjs', '.ts'], includeDirectories: true })
+  };
+}
+
+function createDriver(context = {}) {
+  return createApiOperationsDriver({
+    ...context,
     platform: 'omp',
-    capabilities: buildCapabilities()
+    operationHandlers: {
+      getConfig: () => readConfig(),
+      getConfigCapabilities: () => ({
+        success: true,
+        platform: 'omp',
+        capabilities: buildCapabilities()
+      }),
+      getConfigAuthProviders: (requestContext) => ({
+        success: true,
+        ...getOmpAuthProviderSnapshot({
+          forceRefresh: requestContext.query?.forceRefresh === 'true'
+        })
+      }),
+      getConfigResources: () => readResources()
+    }
   });
-});
-
-router.get('/auth-providers', (req, res) => {
-  try {
-    const forceRefresh = req.query.forceRefresh === 'true';
-    res.json({
-      success: true,
-      ...getOmpAuthProviderSnapshot({ forceRefresh })
-    });
-  } catch (error) {
-    console.error('[OMP Config API] Failed to list auth providers:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
-
-router.get('/resources', (req, res) => {
-  try {
-    const paths = getOmpPaths(process.env, { resolveRuntime: false });
-    const settings = readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
-    res.json({
-      success: true,
-      paths,
-      packages: normalizeArray(settings.packages),
-      skills: listDirEntries(paths.skills),
-      prompts: listDirEntries(paths.prompts, { extensions: ['.md'], includeDirectories: true }),
-      commands: listDirEntries(paths.commands, { extensions: ['.md'], includeDirectories: true }),
-      notes: listDirEntries(paths.notes, { extensions: ['.md'], includeDirectories: true }),
-      extensions: listDirEntries(paths.extensions, { extensions: ['.js', '.mjs', '.cjs', '.ts'], includeDirectories: true })
-    });
-  } catch (error) {
-    console.error('[OMP Config API] Failed to list resources:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
+}
 
-module.exports = router;
+module.exports = { createDriver };

package/src/{server/services/omp-auth-provider-worker.js → platforms/drivers/omp/auth-provider-worker.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getOmpAuthProviderSnapshot } = require('./omp-auth-providers');
+const { getOmpAuthProviderSnapshot } = require('./auth-providers');
 
 function attachWorkerHandler() {
   process.on('message', (options = {}) => {

package/src/{server/services/omp-auth-providers.js → platforms/drivers/omp/auth-providers.js}

@@ -1,6 +1,6 @@
 const path = require('path');
 const { fork, spawnSync } = require('child_process');
-const ompConfig = require('./omp-config');
+const ompConfig = require('./config');
 
 const COMMAND_TIMEOUT_MS = 5000;
 const TOKEN_LIST_TIMEOUT_MS = 3000;

package/src/{server/services/omp-channels.js → platforms/drivers/omp/channels-implementation.js}

@@ -2,9 +2,10 @@ const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
-const BaseChannelService = require('./base/base-channel-service');
-const ompConfig = require('./omp-config');
+const { PATHS, ensureStorageDirMigrated } = require('../../../config/paths');
+const BaseChannelService = require('../../../shared/base-channel-service');
+const ompConfig = require('./config');
+const { MODEL_METADATA, METADATA_SOURCE } = require('../../../config/model-metadata');
 const {
   writeManagedOmpProviders,
   removeManagedOmpProviders,
@@ -13,20 +14,36 @@ const {
   readOmpSettingsConfig,
   normalizeProviderId,
   normalizeProviderApi
-} = require('./omp-settings-manager');
+} = require('./native-config-implementation');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
-} = require('./channel-sync-utils');
+} = require('../../../server/services/channel-sync-utils');
 
 const OMP_THINKING_SUFFIX_RE = /:(minimal|low|medium|high|xhigh|off)$/;
 
+let configuredState = {
+  channels: PATHS.channels?.omp,
+  activeChannel: PATHS.activeChannel?.omp
+};
+
+function configure({ pathContext } = {}) {
+  const custom = pathContext?.customized === true;
+  ompConfig.configure?.({ pathContext });
+  configuredState = {
+    channels: custom ? (pathContext.state?.channels || PATHS.channels?.omp) : PATHS.channels?.omp,
+    activeChannel: custom ? (pathContext.state?.activeChannel || PATHS.activeChannel?.omp) : PATHS.activeChannel?.omp,
+    gatewaySecret: custom ? (pathContext.state?.gatewaySecret || PATHS.ompGatewaySecret) : PATHS.ompGatewaySecret
+  };
+  if (service) service.channelsFilePath = configuredState.channels;
+}
+
 function clearOmpChannelBalanceCache(channel) {
   try {
-    require('./channel-balance').clearChannelBalanceCache('omp', channel);
+    require('../../../server/services/channel-balance').clearChannelBalanceCache('omp', channel);
   } catch (_) {
     // Balance cache invalidation is an optimization; channel activation must still succeed.
   }
@@ -45,8 +62,8 @@ function selectLatestEnabledChannel(channels = []) {
 function loadManagedOmpModeState() {
   ensureStorageDirMigrated();
   try {
-    if (!fs.existsSync(PATHS.activeChannel.omp)) return null;
-    const data = JSON.parse(fs.readFileSync(PATHS.activeChannel.omp, 'utf8'));
+    if (!fs.existsSync(configuredState.activeChannel)) return null;
+    const data = JSON.parse(fs.readFileSync(configuredState.activeChannel, 'utf8'));
     return data && typeof data === 'object' && !Array.isArray(data) ? data : null;
   } catch {
     return null;
@@ -59,7 +76,7 @@ function loadManagedOmpActiveChannelId() {
 
 function isManagedOmpModeEnabled() {
   ensureStorageDirMigrated();
-  return fs.existsSync(PATHS.activeChannel.omp);
+  return fs.existsSync(configuredState.activeChannel);
 }
 
 function writeManagedOmpModeState(filePath, state) {
@@ -77,7 +94,7 @@ function writeManagedOmpModeState(filePath, state) {
 }
 
 function getOmpGatewaySecretPath() {
-  return PATHS.ompGatewaySecret
+  return configuredState.gatewaySecret || PATHS.ompGatewaySecret
     || path.join(path.dirname(PATHS.activeChannel.omp), 'omp-gateway-secret');
 }
 
@@ -126,7 +143,7 @@ function getOrCreateOmpGatewaySecret() {
 
 function enableManagedOmpMode(activeChannelId = null, gateway = null) {
   ensureStorageDirMigrated();
-  const filePath = PATHS.activeChannel.omp;
+  const filePath = configuredState.activeChannel;
   const dir = path.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
@@ -154,8 +171,8 @@ function enableManagedOmpMode(activeChannelId = null, gateway = null) {
 
 function disableManagedOmpMode() {
   ensureStorageDirMigrated();
-  if (fs.existsSync(PATHS.activeChannel.omp)) {
-    fs.unlinkSync(PATHS.activeChannel.omp);
+  if (fs.existsSync(configuredState.activeChannel)) {
+    fs.unlinkSync(configuredState.activeChannel);
   }
 }
 
@@ -163,13 +180,18 @@ class OmpChannelService extends BaseChannelService {
   constructor() {
     super({
       platform: 'omp',
-      channelsFilePath: PATHS.channels.omp,
+      channelsFilePath: configuredState.channels,
       defaultGatewaySource: 'openai_compatible',
+      oauthChannelPolicy: 'mixed',
       isProxyRunning: () => isManagedOmpModeEnabled()
     });
   }
 
   _applyDefaults(channel) {
+    const isOAuthGateway = channel?.authMode === 'oauth'
+      && String(channel?.transport || channel?.providerConfig?.transport || '').trim() === 'pi-native';
+    const gatewayUrl = String(channel?.baseUrl || '').trim();
+    const gatewayToken = String(channel?.apiKey || '').trim();
     const normalized = super._applyDefaults(channel);
     normalized.providerKey = normalized.providerKey || normalized.provider || normalized.name || normalized.id;
     normalized.providerApi = normalizeProviderApi(
@@ -182,7 +204,15 @@ class OmpChannelService extends BaseChannelService {
     normalized.routingGroup = String(normalized.routingGroup || '').trim();
     normalized.oauthProviderId = normalized.oauthProviderId || (normalized.authMode === 'oauth' ? normalized.providerKey : '');
     if (normalized.authMode === 'oauth') {
-      normalized.apiKey = normalized.apiKey || '';
+      normalized.apiKey = isOAuthGateway ? gatewayToken : '';
+      normalized.baseUrl = isOAuthGateway ? gatewayUrl : '';
+      if (isOAuthGateway) {
+        normalized.transport = 'pi-native';
+        normalized.providerConfig = {
+          ...(normalized.providerConfig || {}),
+          transport: 'pi-native'
+        };
+      }
     } else if (normalized.authMode === 'none') {
       normalized.apiKey = '';
       normalized.oauthProviderId = '';
@@ -203,6 +233,41 @@ class OmpChannelService extends BaseChannelService {
     return normalized;
   }
 
+  _normalizeAuthFields(fields = {}, channels = [], existing = null) {
+    const hasTransport = Object.prototype.hasOwnProperty.call(fields, 'transport')
+    const hasProviderTransport = fields.providerConfig
+      && Object.prototype.hasOwnProperty.call(fields.providerConfig, 'transport')
+    const transport = hasTransport
+      ? fields.transport
+      : (hasProviderTransport ? fields.providerConfig.transport : existing?.transport || existing?.providerConfig?.transport)
+    const isOAuthGateway = fields?.authMode === 'oauth'
+      && String(transport || '').trim() === 'pi-native';
+    const gatewayUrl = String(fields?.baseUrl ?? existing?.baseUrl ?? '').trim();
+    const gatewayToken = String(fields?.apiKey ?? existing?.apiKey ?? '').trim();
+    const normalized = super._normalizeAuthFields(fields, channels, existing);
+    if (!isOAuthGateway) return normalized;
+    if (!gatewayUrl) {
+      const error = new Error('OMP OAuth Auth Gateway URL is required');
+      error.code = 'oauth_auth_gateway_url_required';
+      error.statusCode = 400;
+      throw error;
+    }
+    if (!gatewayToken) {
+      const error = new Error('OMP OAuth Gateway Token is required');
+      error.code = 'oauth_auth_gateway_token_required';
+      error.statusCode = 400;
+      throw error;
+    }
+    normalized.baseUrl = gatewayUrl;
+    normalized.apiKey = gatewayToken;
+    normalized.transport = 'pi-native';
+    normalized.providerConfig = {
+      ...(normalized.providerConfig || {}),
+      transport: 'pi-native'
+    };
+    return normalized;
+  }
+
   _applyToNativeSettings(channel) {
     if (isManagedOmpModeEnabled()) {
       const state = loadManagedOmpModeState();
@@ -296,9 +361,6 @@ class OmpChannelService extends BaseChannelService {
     return this.syncOmpProvidersForCurrentMode(channels);
   }
 
-  disableManagedProviderExtension() {
-    this.disableManagedOmpProviders();
-  }
 }
 
 const service = new OmpChannelService();
@@ -545,7 +607,7 @@ function resolveOmpAuthMode(provider = {}, sourceProvider = {}, existing = null)
   return 'api_key';
 }
 
-function buildOmpSyncCandidate(modelsConfig, selection, channels) {
+function buildOmpSyncCandidate(modelsConfig, selection, channels, options = {}) {
   const providers = getOmpProviders(modelsConfig);
   const providerId = selection?.providerId || '';
   const provider = providers[providerId] || null;
@@ -574,7 +636,9 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
   )
     ? existing?.baseUrl || ''
     : providerBaseUrl || existing?.baseUrl || managedBaseUrl;
-  const authMode = resolveOmpAuthMode(provider, sourceProvider, existing);
+  const authMode = options.authMode === 'oauth'
+    ? 'oauth'
+    : resolveOmpAuthMode(provider, sourceProvider, existing);
 
   let credential = resolveApiKeyValue(sourceProvider.apiKey || sourceProvider.api_key || '');
   if (!credential.value) {
@@ -598,13 +662,11 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
   const preferredModel = selection?.roleModelIds?.[0]
     || selectedModelIds[0]
     || existing?.model
-    || allowedModels[0]
-    || null;
-  if (!baseUrl || (authMode !== 'none' && !apiKey)) {
+  if (authMode !== 'oauth' && (!baseUrl || (authMode !== 'none' && !apiKey))) {
     return {
       skip: true,
       channel: existing || null,
-      warning: `OMP 当前 provider "${providerId}" 缺少可解析的上游 Base URL 或 API Key，OAuth/登录态渠道不支持同步导入。`
+      warning: `OMP 当前 provider "${providerId}" 缺少可解析的上游 Base URL 或 API Key；如使用本地 OAuth，请通过显式 OAuth 同步。`
     };
   }
 
@@ -627,11 +689,19 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
   return {
     name: existing?.name || originalProviderId || providerId,
     providerKey: originalProviderId || providerId,
-    baseUrl,
-    apiKey: authMode === 'none' ? '' : apiKey,
+    baseUrl: authMode === 'oauth' ? '' : baseUrl,
+    apiKey: authMode === 'oauth' || authMode === 'none' ? '' : apiKey,
     providerApi,
     wireApi: providerApi,
     authMode,
+    authRef: authMode === 'oauth' ? {
+      credentialId: '',
+      providerId: providerId || originalProviderId,
+      accountId: sourceProvider.accountId || sourceProvider.account_id || '',
+      identityKey: sourceProvider.identityKey || sourceProvider.identity_key || '',
+      accountEmail: sourceProvider.accountEmail || sourceProvider.email || ''
+    } : undefined,
+    authSource: authMode === 'oauth' ? 'synced-local' : undefined,
     oauthProviderId: authMode === 'oauth' ? (existing?.oauthProviderId || originalProviderId || providerId) : '',
     model: preferredModel,
     allowedModels,
@@ -641,7 +711,64 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
   };
 }
 
-function syncCurrentOmpChannel() {
+
+function getCatalogMetadata({
+  providerKey = '',
+  model = '',
+  speedTestModel = '',
+  allowedModels = [],
+  models = [],
+  availableModels = []
+} = {}) {
+  const requestedIds = [
+    model,
+    speedTestModel,
+    ...(Array.isArray(models)
+      ? models.map(item => (
+        item && typeof item === 'object' && !Array.isArray(item) ? item.id || item.name : item
+      ))
+      : []),
+    ...(Array.isArray(allowedModels)
+      ? allowedModels.map(item => (
+        item && typeof item === 'object' && !Array.isArray(item) ? item.id || item.name : item
+      ))
+      : []),
+    ...(Array.isArray(availableModels)
+      ? availableModels.map(item => (
+        item && typeof item === 'object' && !Array.isArray(item) ? item.value || item.id || item.name : item
+      ))
+      : [])
+  ]
+    .map(value => String(value || '').trim().toLowerCase())
+    .filter(Boolean);
+  const normalizedProviderKey = String(providerKey || '').trim().toLowerCase();
+
+  const allEntries = Object.entries(MODEL_METADATA)
+    .filter(([, metadata]) => Array.isArray(metadata.toolTypes) && metadata.toolTypes.includes('omp'))
+    .map(([id, metadata]) => ({ ...structuredClone(metadata), id }));
+
+  const matchesRequestedId = entry => requestedIds.length > 0 && requestedIds.some(requested => (
+    requested === entry.id.toLowerCase()
+      || requested === String(entry.sourceId || '').toLowerCase()
+      || requested === entry.id.split('/').pop().toLowerCase()
+  ));
+  const matchesProvider = entry => (
+    String(entry.provider || '').toLowerCase() === normalizedProviderKey
+    || String(entry.sourceId || '').toLowerCase().startsWith(`${normalizedProviderKey}/`)
+  );
+  const requestedEntries = requestedIds.length > 0 ? allEntries.filter(matchesRequestedId) : [];
+  const providerEntries = normalizedProviderKey ? allEntries.filter(matchesProvider) : [];
+  const entries = requestedIds.length > 0 ? requestedEntries : providerEntries;
+
+  return {
+    models: entries,
+    warnings: [],
+    source: { ...METADATA_SOURCE }
+  };
+}
+
+function syncCurrentOmpChannel(options = {}) {
+  const authMode = options.authMode || 'api_key';
   let modelsConfig = { providers: {} };
   let settings = {};
   try {
@@ -650,19 +777,16 @@ function syncCurrentOmpChannel() {
   } catch (error) {
     return createSkippedResult('omp', `OMP 配置读取失败：${error.message}`);
   }
-
   const data = service.loadChannels();
   const channels = Array.isArray(data.channels) ? data.channels : [];
   const selections = collectOmpSyncSelections(modelsConfig, settings);
-  if (selections.length === 0) {
-    const active = resolveExistingActiveChannel('omp', channels);
-    if (active) {
-      return createSkippedResult('omp', 'OMP 当前配置未明确 provider；已找到当前面板中的 active 渠道，未重复导入。', active);
-    }
-    return createSkippedResult('omp', 'OMP 当前配置未明确 provider，无法同步当前渠道。');
-  }
-  const candidates = selections.map(selection => buildOmpSyncCandidate(modelsConfig, selection, channels));
-
+  if (selections.length === 0) return createSkippedResult('omp', 'OMP 当前配置未明确 provider，无法同步当前渠道。');
+  const candidates = selections
+    .map(selection => buildOmpSyncCandidate(modelsConfig, selection, channels, { authMode }))
+    .filter(candidate => authMode === 'all'
+      || candidate.authMode === authMode
+      || (authMode === 'api_key' && candidate.authMode === 'none')
+      || candidate.skip);
   return upsertSyncedChannels({
     toolType: 'omp',
     loadChannels: () => service.loadChannels(),
@@ -670,13 +794,16 @@ function syncCurrentOmpChannel() {
     applyDefaults: channel => service._applyDefaults(channel),
     candidates,
     matchers: [
-      (channel, current) => channel.providerKey && channel.providerKey === current.providerKey,
+      (channel, current) => channel.providerKey === current.providerKey
+        && channel.authMode === current.authMode
+        && (channel.model || '') === (current.model || ''),
       (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey
     ]
   });
 }
 
 module.exports = {
+  configure,
   getChannels: () => service.getChannels(),
   createChannel: (name, baseUrl, apiKey, extra = {}) => service.createChannel({
     name,
@@ -696,7 +823,7 @@ module.exports = {
   syncManagedOmpProviders: (channels, options) => service.syncManagedOmpProviders(channels, options),
   disableManagedOmpProviders: () => service.disableManagedOmpProviders(),
   syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
-  disableManagedProviderExtension: () => service.disableManagedProviderExtension(),
+  getCatalogMetadata,
   isManagedOmpModeEnabled,
   getOrCreateOmpGatewaySecret,
   enableManagedOmpMode,

package/src/platforms/drivers/omp/channels.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { createChannelDriver } = require('../../../shared/channel-driver');
+const { ok, failed } = require('../../../shared/driver-result');
+
+function createDriver(context = {}) {
+  const driver = createChannelDriver({
+    ...context,
+    platform: 'omp',
+    servicePath: './omp/channels-implementation',
+    localServicePath: '../platforms/drivers/omp/channels-implementation',
+    syncMethod: 'syncCurrentOmpChannel',
+    createArgs: (input, rest) => typeof input === 'object'
+      ? (() => {
+        const { name, baseUrl, apiKey, extra, ...channelExtra } = input;
+        return [name, baseUrl, apiKey, { ...channelExtra, ...extra }];
+      })()
+      : [input, ...rest],
+    cliMetadata: {
+      supportsCliCreate: false,
+      supportsCliToggle: true,
+      managedProviderConfig: true,
+      defaultPort: 20092,
+      createUnavailableMessage: '提示: OMP 渠道请通过 Web UI 或 API 添加后，再在这里启停调度。'
+    },
+    dashboardChannelShape: 'array'
+  });
+  driver.syncManagedProviderExtension = (...args) => (
+    driver._service().syncManagedProviderExtension(...args)
+  );
+  driver.catalogMetadata = (input = {}) => {
+    const operation = 'catalogMetadata';
+    const body = input && typeof input === 'object' && Object.prototype.hasOwnProperty.call(input, 'body')
+      ? input.body || {}
+      : input || {};
+    try {
+      const value = driver._service().getCatalogMetadata(body);
+      const wrap = result => (
+        result && typeof result.status === 'string'
+          ? result
+          : ok('omp', 'channels', operation, result)
+      );
+      return value && typeof value.then === 'function'
+        ? value.then(wrap).catch(error => failed('omp', 'channels', operation, error))
+        : wrap(value);
+    } catch (error) {
+      return failed('omp', 'channels', operation, error);
+    }
+  };
+  const auth = require('../../channel-auth-service');
+  driver.getAuth = context => auth.getChannelAuth('omp', { channelId: context?.params?.channelId || context?.query?.channelId || '' });
+  driver.syncLocalAuth = context => auth.syncLocalChannelAuth('omp', { channelId: context?.body?.channelId || context?.params?.channelId || context?.query?.channelId || '' });
+  driver.getAuthQuota = context => auth.fetchChannelAuthQuota('omp', context?.params?.channelId, { refresh: context?.query?.refresh === 'true' });
+  driver.getHealthPolicy = () => ({ freezeOnFailure: false });
+  return driver;
+}
+
+module.exports = { createDriver };