coding-tool-x 3.8.4 → 3.8.5

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

@@ -2,9 +2,29 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const yaml = require('js-yaml');
-const { HOME_DIR, PATHS = {} } = require('../../config/paths');
+const {
+  HOME_DIR,
+  PATHS = {},
+  getOmpAgentDir: resolveSharedOmpAgentDir
+} = require('../../../config/paths');
 
 const DEFAULT_OMP_COMMAND = 'omp';
+const OMP_RUNTIME_ENV_KEYS = [
+  'PATH',
+  'OMP_COMMAND',
+  'OMP_CONFIG_DIR',
+  'OMP_PROFILE',
+  'PI_CODING_AGENT_DIR',
+  'OMP_CODING_AGENT_DIR'
+];
+let nativePathsOverride = null;
+let cachedRuntimeResolution = null;
+
+function configure({ pathContext } = {}) {
+  nativePathsOverride = pathContext?.customized && pathContext.native?.dir
+    ? { ...pathContext.native, agentDir: pathContext.native.dir }
+    : null;
+}
 const YAML_DUMP_OPTIONS = Object.freeze({
   lineWidth: 120,
   noRefs: true,
@@ -88,6 +108,10 @@ function readOmpAgentDirFromCommand(command, env = process.env, options = {}) {
 function getOmpAgentDir(env = process.env, options = {}) {
   const runtime = options.runtime || (options.resolveRuntime === false ? null : resolveOmpRuntime(env, options));
   if (runtime?.runtime === 'omp' && runtime.installed) {
+    if (!options.commandRunner && typeof resolveSharedOmpAgentDir === 'function') {
+      const configuredAgentDir = resolveSharedOmpAgentDir(env);
+      if (configuredAgentDir) return configuredAgentDir;
+    }
     const commandAgentDir = readOmpAgentDirFromCommand(runtime.command, env, options);
     if (commandAgentDir) {
       return commandAgentDir;
@@ -97,6 +121,9 @@ function getOmpAgentDir(env = process.env, options = {}) {
 }
 
 function getOmpPaths(env = process.env, options = {}) {
+  if (nativePathsOverride && options.usePathContext !== false) {
+    return { ...nativePathsOverride };
+  }
   const runtime = options.runtime || (options.resolveRuntime === false ? null : resolveOmpRuntime(env, options));
   const agentDir = getOmpAgentDir(env, { ...options, runtime });
   return {
@@ -233,6 +260,11 @@ function getOmpCommand(env = process.env) {
   return String(env.OMP_COMMAND || DEFAULT_OMP_COMMAND).trim() || DEFAULT_OMP_COMMAND;
 }
 
+function getRuntimeCacheKey(env = process.env, options = {}) {
+  if (typeof options.commandRunner === 'function') return '';
+  return JSON.stringify(OMP_RUNTIME_ENV_KEYS.map(key => [key, String(env[key] || '')]));
+}
+
 function commandExists(command, env = process.env, options = {}) {
   try {
     runOmpCommand(command, ['--version'], env, options, 'ignore');
@@ -243,35 +275,42 @@ function commandExists(command, env = process.env, options = {}) {
 }
 
 function resolveOmpRuntime(env = process.env, options = {}) {
+  const cacheKey = getRuntimeCacheKey(env, options);
+  if (cacheKey && cachedRuntimeResolution?.key === cacheKey) {
+    return cachedRuntimeResolution.value;
+  }
+
   const configured = env.OMP_COMMAND;
+  let result;
   if (configured) {
     const command = getOmpCommand(env);
-    return {
+    result = {
       command,
       runtime: 'omp',
       installed: commandExists(command, env, options),
       configured: true,
       commandSource: 'OMP_COMMAND'
     };
-  }
-
-  if (commandExists(DEFAULT_OMP_COMMAND, env, options)) {
-    return {
+  } else if (commandExists(DEFAULT_OMP_COMMAND, env, options)) {
+    result = {
       command: DEFAULT_OMP_COMMAND,
       runtime: 'omp',
       installed: true,
       configured: false,
       commandSource: 'path'
     };
+  } else {
+    result = {
+      command: DEFAULT_OMP_COMMAND,
+      runtime: 'omp',
+      installed: false,
+      configured: false,
+      commandSource: 'fallback'
+    };
   }
 
-  return {
-    command: DEFAULT_OMP_COMMAND,
-    runtime: 'omp',
-    installed: false,
-    configured: false,
-    commandSource: 'fallback'
-  };
+  if (cacheKey) cachedRuntimeResolution = { key: cacheKey, value: result };
+  return result;
 }
 
 function isOmpInstalled(env = process.env, options = {}) {
@@ -338,6 +377,7 @@ function getOmpStatus(env = process.env, options = {}) {
 }
 
 module.exports = {
+  configure,
   expandHome,
   getOmpAgentDir,
   getOmpPaths,

package/src/{server/services/omp-gateway-routing.js → platforms/drivers/omp/gateway-routing.js}

@@ -180,7 +180,11 @@ function prepareManagedOmpChannels(channels = [], gateway = {}) {
     throw new Error('OMP gateway secret is required before managed providers can be generated');
   }
 
-  const enabled = channels.filter(channel => channel && channel.enabled !== false && channel.baseUrl);
+  const enabled = channels.filter(channel => (
+    channel
+    && channel.enabled !== false
+    && (channel.baseUrl || normalizeText(channel.authMode) === 'oauth')
+  ));
   const groups = new Map();
   enabled.forEach((channel) => {
     const key = getGroupKey(channel);
@@ -211,13 +215,16 @@ function prepareManagedOmpChannels(channels = [], gateway = {}) {
     }
     const authMode = normalizeText(template.authMode) || 'api_key';
     const transport = normalizeText(template.transport || template.providerConfig?.transport);
-    const supportedOAuthIds = Array.isArray(gateway.supportedOAuthChannelIds)
-      ? new Set(gateway.supportedOAuthChannelIds)
-      : null;
+    const supportedOAuthIds = new Set(
+      Array.isArray(gateway.supportedOAuthChannelIds) ? gateway.supportedOAuthChannelIds : []
+    );
     const oauthGatewayUnavailable = authMode === 'oauth' && (
-      !normalizeText(template.apiKey)
-      || transport !== 'pi-native'
-      || (supportedOAuthIds && groupChannels.some(channel => !supportedOAuthIds.has(channel.id)))
+      groupChannels.some(channel => (
+        !normalizeText(channel.baseUrl)
+        || !normalizeText(channel.apiKey)
+        || normalizeText(channel.transport || channel.providerConfig?.transport) !== 'pi-native'
+        || !supportedOAuthIds.has(channel.id)
+      ))
     );
     if (oauthGatewayUnavailable) {
       groupChannels.forEach(channel => unsupportedChannels.push({

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

@@ -5,24 +5,10 @@ const http = require('http');
 const https = require('https');
 const httpProxy = require('http-proxy');
 const { URL } = require('url');
-const { allocateChannel, releaseChannel } = require('./channel-scheduler');
-const { recordSuccess, recordFailure } = require('./channel-health');
-const { recordRequest: recordOmpRequest } = require('./omp-statistics-service');
-const {
-  createTokenData,
-  mergeUsageIntoTokenData,
-  parseNonStreamingUsage,
-  parseSSEEventText,
-  parseSSEUsage,
-  splitSSEEvents
-} = require('./base/response-usage-parser');
-const {
-  publishFailureLog: publishSharedFailureLog,
-  publishUsageLog: publishSharedUsageLog
-} = require('./proxy-log-helper');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('./server-shutdown');
-const { resolveOmpGatewayRoute } = require('./omp-gateway-routing');
-const { broadcastLog } = require('../websocket-server');
+const { allocateChannel, releaseChannel } = require('../../../server/services/channel-scheduler');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { resolveOmpGatewayRoute } = require('./gateway-routing');
 
 const RETRYABLE_STATUS = new Set([401, 403, 429, 502, 503, 504]);
 const MAX_REQUEST_BYTES = 100 * 1024 * 1024;
@@ -221,96 +207,6 @@ function hasValidCapability(req, parsedUrl, route) {
   return candidates.some(candidate => constantTimeEqual(candidate, route.capability));
 }
 
-function mergeParsedUsage(tokenData, value, eventType = '') {
-  if (Array.isArray(value)) {
-    value.forEach(item => mergeParsedUsage(tokenData, item, eventType));
-    return;
-  }
-  mergeUsageIntoTokenData(
-    tokenData,
-    eventType ? parseSSEUsage(value, eventType) : parseNonStreamingUsage(value)
-  );
-}
-
-function createResponseUsageMonitor(contentType = '') {
-  const tokenData = createTokenData();
-  const streaming = String(contentType).toLowerCase().includes('text/event-stream');
-  const chunks = [];
-  let bufferedBytes = 0;
-  let sseBuffer = '';
-  let observationDisabled = false;
-
-  const parseEvent = (eventText) => {
-    const event = parseSSEEventText(eventText);
-    if (!event) return;
-    try {
-      mergeParsedUsage(tokenData, JSON.parse(event.data), event.eventType);
-    } catch {
-      // Usage observation must never alter or reject the transparent response.
-    }
-  };
-
-  return {
-    observe(chunk) {
-      if (observationDisabled) return;
-      if (streaming) {
-        if (Buffer.byteLength(sseBuffer) + chunk.length > MAX_REQUEST_BYTES) {
-          observationDisabled = true;
-          sseBuffer = '';
-          return;
-        }
-        sseBuffer += chunk.toString('utf8');
-        const split = splitSSEEvents(sseBuffer);
-        split.events.forEach(parseEvent);
-        sseBuffer = split.remainder;
-      } else if (bufferedBytes + chunk.length <= MAX_REQUEST_BYTES) {
-        chunks.push(Buffer.from(chunk));
-        bufferedBytes += chunk.length;
-      } else {
-        observationDisabled = true;
-        chunks.length = 0;
-      }
-    },
-    finish() {
-      if (observationDisabled) {
-        return {
-          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
-          }
-        };
-      }
-      if (streaming) {
-        parseEvent(sseBuffer);
-      } else if (chunks.length > 0) {
-        try {
-          mergeParsedUsage(tokenData, JSON.parse(Buffer.concat(chunks).toString('utf8')));
-        } catch {
-          // Non-JSON responses are valid passthrough responses without usage.
-        }
-      }
-      return {
-        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
-        }
-      };
-    }
-  };
-}
-
 function closeServer(server, forceAfterMs = 1000) {
   if (!server) return Promise.resolve();
   return new Promise((resolve, reject) => {
@@ -332,59 +228,6 @@ function createOmpGateway(options = {}) {
   const release = options.releaseChannel || releaseChannel;
   const onSuccess = options.recordSuccess || recordSuccess;
   const onFailure = options.recordFailure || recordFailure;
-  const publishUsage = options.publishUsageLog || ((data) => {
-    const enrich = (payload) => broadcastLog({
-      ...payload,
-      originalProvider: data.originalProvider,
-      providerApi: data.providerApi,
-      routingGroup: data.routingGroup,
-      actualChannelId: data.channelId,
-      upstreamModel: data.model,
-      switchReason: data.switchReason || undefined,
-      attemptedChannels: data.attemptedChannels
-    });
-    return publishSharedUsageLog({
-      source: 'omp',
-      metadata: {
-        id: data.requestId,
-        channel: data.channel,
-        channelId: data.channelId,
-        originalModel: data.originalModel,
-        startTime: data.startTime
-      },
-      model: data.model || data.originalModel,
-      tokens: data.tokens,
-      broadcastLog: enrich,
-      recordRequest: recordOmpRequest,
-      recordSuccess: null
-    });
-  });
-  const publishFailure = options.publishFailureLog || ((data) => {
-    const enrich = (payload) => broadcastLog({
-      ...payload,
-      originalProvider: data.originalProvider,
-      providerApi: data.providerApi,
-      routingGroup: data.routingGroup,
-      actualChannelId: data.channelId,
-      switchReason: data.switchReason || undefined,
-      attemptedChannels: data.attemptedChannels
-    });
-    return publishSharedFailureLog({
-      source: 'omp',
-      metadata: {
-        id: data.requestId,
-        channel: data.channel,
-        model: data.model
-      },
-      channel: data.channel,
-      model: data.model,
-      message: data.message,
-      error: data.error,
-      statusCode: data.statusCode,
-      stage: data.stage,
-      broadcastLog: enrich
-    });
-  });
   const websocketProxy = httpProxy.createProxyServer({
     ws: true,
     changeOrigin: true,
@@ -512,11 +355,7 @@ function createOmpGateway(options = {}) {
     if (signal?.aborted) throw createAbortError();
     const modelId = extractModelId(body, req.headers['content-type']);
     const attemptedIds = [];
-    const attemptedChannels = [];
-    const requestId = `omp-${crypto.randomUUID()}`;
-    const startTime = Date.now();
     let lastError = null;
-    let switchReason = '';
 
     for (let attempt = 0; attempt < 2; attempt++) {
       let channel;
@@ -532,7 +371,6 @@ function createOmpGateway(options = {}) {
         break;
       }
       attemptedIds.push(channel.id);
-      attemptedChannels.push(channel.name || channel.id);
 
       try {
         const result = await forwardAttempt(req, route, channel, body, signal);
@@ -541,22 +379,6 @@ function createOmpGateway(options = {}) {
           result.response.resume();
           result.release();
           onFailure(channel.id, 'omp');
-          switchReason = `http-${result.statusCode}`;
-          publishFailure({
-            source: 'omp',
-            requestId,
-            channel: channel.name || channel.id,
-            channelId: channel.id,
-            originalProvider: route.providerKey,
-            providerApi: route.providerApi,
-            routingGroup: route.routingGroup,
-            model: modelId,
-            statusCode: result.statusCode,
-            stage: 'dynamic-switch',
-            switchReason,
-            attemptedChannels: [...attemptedChannels],
-            message: `OMP upstream returned HTTP ${result.statusCode}`
-          });
           lastError = Object.assign(new Error(`OMP upstream returned HTTP ${result.statusCode}`), {
             statusCode: result.statusCode
           });
@@ -564,7 +386,6 @@ function createOmpGateway(options = {}) {
         }
 
         res.writeHead(result.statusCode, result.response.headers);
-        const usageMonitor = createResponseUsageMonitor(result.response.headers['content-type']);
         await new Promise((resolve) => {
           let completed = false;
           const finish = (error) => {
@@ -573,45 +394,12 @@ function createOmpGateway(options = {}) {
             activeUpstreams.delete(result.response);
             result.release();
             if (result.statusCode < 400 && !error) {
-              const usage = usageMonitor.finish();
               onSuccess(channel.id, 'omp');
-              publishUsage({
-                source: 'omp',
-                requestId,
-                startTime,
-                channel: channel.name || channel.id,
-                channelId: channel.id,
-                originalProvider: route.providerKey,
-                providerApi: route.providerApi,
-                routingGroup: route.routingGroup,
-                originalModel: modelId,
-                model: usage.model || modelId,
-                tokens: usage.tokens,
-                switchReason,
-                attemptedChannels: [...attemptedChannels]
-              });
             } else {
               onFailure(channel.id, 'omp');
-              publishFailure({
-                source: 'omp',
-                requestId,
-                channel: channel.name || channel.id,
-                channelId: channel.id,
-                originalProvider: route.providerKey,
-                providerApi: route.providerApi,
-                routingGroup: route.routingGroup,
-                model: modelId,
-                error,
-                statusCode: result.statusCode,
-                stage: error ? 'response-stream' : 'upstream-response',
-                switchReason,
-                attemptedChannels: [...attemptedChannels],
-                message: error?.message || `OMP upstream returned HTTP ${result.statusCode}`
-              });
             }
             resolve();
           };
-          result.response.on('data', chunk => usageMonitor.observe(chunk));
           result.response.once('end', () => finish());
           result.response.once('close', () => finish(new Error('OMP upstream response closed early')));
           result.response.once('error', (error) => {
@@ -632,22 +420,6 @@ function createOmpGateway(options = {}) {
           break;
         }
         onFailure(channel.id, 'omp');
-        switchReason = error.code || error.message || 'connection-error';
-        publishFailure({
-          source: 'omp',
-          requestId,
-          channel: channel.name || channel.id,
-          channelId: channel.id,
-          originalProvider: route.providerKey,
-          providerApi: route.providerApi,
-          routingGroup: route.routingGroup,
-          model: modelId,
-          error,
-          statusCode: error.statusCode,
-          stage: attempt === 0 ? 'dynamic-switch' : 'upstream-connect',
-          switchReason,
-          attemptedChannels: [...attemptedChannels]
-        });
       }
     }
 
@@ -770,9 +542,6 @@ function createOmpGateway(options = {}) {
     }
 
     inflightRequests++;
-    const requestId = `omp-${crypto.randomUUID()}`;
-    const startTime = Date.now();
-    const websocketModel = normalizeModelId(channel.model || '');
     let released = false;
     let failed = false;
     let failureRecorded = false;
@@ -781,19 +550,6 @@ function createOmpGateway(options = {}) {
       if (failureRecorded) return;
       failureRecorded = true;
       onFailure(channel.id, 'omp');
-      publishFailure({
-        source: 'omp',
-        requestId,
-        channel: channel.name || channel.id,
-        channelId: channel.id,
-        originalProvider: route.providerKey,
-        providerApi: route.providerApi,
-        routingGroup: route.routingGroup,
-        model: websocketModel,
-        error,
-        stage: 'websocket',
-        attemptedChannels: [channel.name || channel.id]
-      });
     };
     const releaseOnce = () => {
       if (released) return;
@@ -801,20 +557,6 @@ function createOmpGateway(options = {}) {
       inflightRequests = Math.max(0, inflightRequests - 1);
       if (!failed) {
         onSuccess(channel.id, 'omp');
-        publishUsage({
-          source: 'omp',
-          requestId,
-          startTime,
-          channel: channel.name || channel.id,
-          channelId: channel.id,
-          originalProvider: route.providerKey,
-          providerApi: route.providerApi,
-          routingGroup: route.routingGroup,
-          originalModel: websocketModel,
-          model: websocketModel,
-          tokens: {},
-          attemptedChannels: [channel.name || channel.id]
-        });
       }
       release(channel.id, 'omp');
     };

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

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

package/src/{server/services/omp-settings-manager.js → platforms/drivers/omp/native-config-implementation.js}

@@ -2,9 +2,9 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const yaml = require('js-yaml');
-const ompConfig = require('./omp-config');
-const { prepareManagedOmpChannels } = require('./omp-gateway-routing');
-const { MODEL_METADATA, MODEL_ALIASES } = require('../../config/model-metadata');
+const ompConfig = require('./config');
+const { prepareManagedOmpChannels } = require('./gateway-routing');
+const { MODEL_METADATA, MODEL_ALIASES } = require('../../../config/model-metadata');
 const {
   MODEL_METADATA_MODES,
   isPlainObject,
@@ -12,7 +12,7 @@ const {
   resolveModelDefinition,
   serializeModelSelector,
   splitModelSelector
-} = require('./model-definition-schema');
+} = require('../../../server/services/model-definition-schema');
 
 const MANAGED_PROVIDER_PREFIX = 'ctx-';
 const MODELS_BACKUP_MARKER = '.ctx-backup-';
@@ -695,6 +695,57 @@ function buildManagedModelsConfig(channels = [], baseConfig = readModelsConfig()
   return next;
 }
 
+function isNativeOmpOAuthChannel(channel = {}) {
+  return channel
+    && channel.enabled !== false
+    && channel.authMode === 'oauth'
+    && !String(channel.baseUrl || '').trim();
+}
+
+function collectNativeOmpOAuthVisibility(channels = []) {
+  const enabledModels = [];
+  let defaultModel = null;
+
+  (channels || []).filter(isNativeOmpOAuthChannel).forEach((channel) => {
+    const rawProviderId = String(
+      channel.oauthProviderId || channel.authRef?.providerId || ''
+    ).trim();
+    if (!rawProviderId) return;
+    const providerId = normalizeProviderId(rawProviderId);
+
+    const allowedModels = Array.isArray(channel.allowedModels) ? channel.allowedModels : [];
+    const candidates = allowedModels.length > 0
+      ? allowedModels
+      : [
+        ...(Array.isArray(channel.models) ? channel.models : []),
+        channel.model
+      ];
+    const modelIds = [];
+    candidates.forEach((value) => {
+      const rawId = typeof value === 'object' && value !== null
+        ? value.id || value.name
+        : value;
+      const selector = splitModelSelector(rawId || '');
+      if (selector.modelId && !modelIds.some(id => id.toLowerCase() === selector.modelId.toLowerCase())) {
+        modelIds.push(selector.modelId);
+      }
+    });
+
+    modelIds.forEach((modelId) => {
+      pushUnique(enabledModels, `${providerId}/${modelId}`);
+    });
+
+    if (!defaultModel) {
+      const selected = splitModelSelector(channel.model || '');
+      if (selected.modelId && modelIds.some(id => id.toLowerCase() === selected.modelId.toLowerCase())) {
+        defaultModel = `${providerId}/${serializeModelSelector(selected.modelId, selected.thinkingLevel)}`;
+      }
+    }
+  });
+
+  return { enabledModels, defaultModel };
+}
+
 function getOriginalProviderId(channel = {}) {
   if (channel.originalProviderId) {
     return normalizeProviderId(channel.originalProviderId);
@@ -711,6 +762,10 @@ function collectManagedVisibility(channels = [], modelsConfig = { providers: {}
   const warnings = [];
   const providers = modelsConfig.providers || {};
   let managedDefaultModel = null;
+  const nativeOAuthVisibility = collectNativeOmpOAuthVisibility([
+    ...(Array.isArray(channels) ? channels : []),
+    ...(Array.isArray(options.nativeOAuthChannels) ? options.nativeOAuthChannels : [])
+  ]);
 
   (channels || [])
     .filter(channel => channel && channel.enabled !== false && channel.baseUrl)
@@ -761,13 +816,21 @@ function collectManagedVisibility(channels = [], modelsConfig = { providers: {}
     }
   }
 
+  const visibleModels = uniqueStrings([
+    ...managedEnabledModels,
+    ...nativeOAuthVisibility.enabledModels
+  ]);
+
   return {
-    managedEnabledModels,
-    managedEnabledModelsForSettings: managedEnabledModels.length > 0
-      ? managedEnabledModels
+    managedEnabledModels: visibleModels,
+    managedEnabledModelsForSettings: visibleModels.length > 0
+      ? visibleModels
       : [NO_MANAGED_MODELS_SELECTOR],
     managedDisabledProviders,
-    managedDefaultModel: managedDefaultModel || managedEnabledModels[0] || null,
+    managedDefaultModel: managedDefaultModel
+      || nativeOAuthVisibility.defaultModel
+      || visibleModels[0]
+      || null,
     warnings
   };
 }
@@ -898,7 +961,6 @@ function syncManagedOmpVisibility(channels = [], modelsConfig = { providers: {}
     : captureOriginalVisibility(settings);
   const before = JSON.stringify(settings);
   const settingsBackupPath = createModelsBackupIfNeeded(settingsPath, options);
-
   settings.enabledModels = visibility.managedEnabledModelsForSettings;
   settings.disabledProviders = uniqueStrings([
     ...collectUserDisabledProviders(settings, previousState),
@@ -1134,7 +1196,10 @@ function writeManagedOmpProviders(channels = [], options = {}) {
     });
     const backupPath = createModelsBackupIfNeeded(paths.modelsYml, options);
     writeModelsConfig(config, paths.modelsYml);
-    const visibility = syncManagedOmpVisibility(effectiveChannels, config, options);
+    const visibility = syncManagedOmpVisibility(effectiveChannels, config, {
+      ...options,
+      nativeOAuthChannels: channels.filter(isNativeOmpOAuthChannel)
+    });
     const validation = options.validateWithCli === true
       ? validateOmpModelsConfig(options)
       : { skipped: true, reason: 'cli-validation-disabled', warnings: [] };