coding-tool-x 3.8.0 → 3.8.2

package/src/server/services/model-detector.js

@@ -11,6 +11,13 @@ const { URL } = require('url');
 const crypto = require('crypto');
 const zlib = require('zlib');
 const { loadConfig } = require('../../config/loader');
+const { createCodexRequest, buildCodexTargetUrl } = require('./codex-wire');
+const { createClaudeRequest, buildClaudeTargetUrl } = require('./claude-wire');
+const {
+  createGeminiRequest,
+  buildGeminiTargetUrl,
+  shouldUseGeminiCliFormat
+} = require('./gemini-wire');
 const { PATHS } = require('../../config/paths');
 
 // 内置模型优先级（当配置缺失时兜底）
@@ -236,7 +243,6 @@ const TEST_TIMEOUT_MS = 10000; // 10 seconds per model test
 const MODEL_LIST_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const MODEL_LIST_FAILURE_TTL_MS = 5 * 60 * 1000;
 const MODEL_LIST_AUTH_FAILURE_TTL_MS = 60 * 60 * 1000;
-const CLAUDE_CODE_BETA_HEADER = 'claude-code-20250219,interleaved-thinking-2025-05-14';
 
 const MODEL_UNAVAILABLE_HINTS = [
   'not found',
@@ -347,170 +353,82 @@ function buildOpenAiCompatibleUrl(baseUrl, endpoint) {
   return `${trimmed}${normalizedEndpoint}`;
 }
 
-function buildClaudeMessagesUrl(baseUrl, options = {}) {
-  const withBeta = options.withBeta !== false;
-  const parsed = new URL(String(baseUrl || '').trim());
-  let pathname = parsed.pathname.replace(/\/+$/, '');
-
-  if (!pathname || pathname === '/') {
-    pathname = '/v1/messages';
-  } else if (pathname.endsWith('/messages')) {
-    // noop
-  } else if (pathname.endsWith('/v1')) {
-    pathname = `${pathname}/messages`;
-  } else {
-    pathname = `${pathname}/v1/messages`;
-  }
-
-  parsed.pathname = pathname;
-  if (withBeta) {
-    parsed.searchParams.set('beta', 'true');
-  }
-  return parsed.toString();
-}
-
-function buildGeminiGenerateContentUrl(baseUrl, model, apiKey = '') {
-  const modelName = String(model || '').trim();
-  if (!modelName) {
-    throw new Error('Model is required for Gemini probe');
-  }
-
-  const parsed = new URL(String(baseUrl || '').trim());
-  let pathname = parsed.pathname.replace(/\/+$/, '');
-  const modelsIndex = pathname.indexOf('/models');
-  if (modelsIndex >= 0) {
-    pathname = pathname.slice(0, modelsIndex);
-  }
-
-  let apiBasePath;
-  if (!pathname || pathname === '/') {
-    apiBasePath = '/v1beta';
-  } else if (pathname.endsWith('/v1beta') || pathname.endsWith('/v1')) {
-    apiBasePath = pathname;
-  } else {
-    apiBasePath = `${pathname}/v1beta`;
-  }
 
-  parsed.pathname = `${apiBasePath}/models/${encodeURIComponent(modelName)}:generateContent`;
-  if (apiKey) {
-    parsed.searchParams.set('key', apiKey);
-  }
-  return parsed.toString();
+function resolveExplicitGeminiUseCli(channel) {
+  const providerApi = String(channel?.providerApi || channel?.wireApi || '').trim().toLowerCase();
+  if (providerApi === 'google-gemini-cli') return true;
+  if (providerApi === 'google-generative-ai' || providerApi === 'google-vertex') return false;
+  return shouldUseGeminiCliFormat(channel?.baseUrl || '');
 }
 
-function buildClaudeProbePayload(model, options = {}) {
-  const includeSystem = options.includeSystem === true;
-  const systemAsArray = options.systemAsArray === true;
-  const includeMetadata = options.includeMetadata === true;
-  const sessionId = Math.random().toString(36).substring(2, 15);
-
-  const payload = {
+function createClaudeProbeAttempts(channel, model) {
+  const apiKey = channel.apiKey || '';
+  const minimalPayload = {
     model,
     max_tokens: 1,
     stream: false,
     messages: [{ role: 'user', content: [{ type: 'text', text: 'ping' }] }]
   };
-
-  if (includeSystem) {
-    const systemPrompt = "You are Claude Code, Anthropic's official CLI for Claude.";
-    payload.system = systemAsArray
-      ? [{ type: 'text', text: systemPrompt }]
-      : systemPrompt;
-  }
-
-  if (includeMetadata) {
-    payload.metadata = {
-      user_id: `user_0000000000000000000000000000000000000000000000000000000000000000_account__session_${sessionId}`
-    };
-  }
-
-  return JSON.stringify(payload);
-}
-
-function createClaudeProbeAttempts(channel, model) {
-  const apiKey = channel.apiKey || '';
-  const commonHeaders = {
-    ...buildRequestHeaders('claude', channel),
-    'Content-Type': 'application/json',
-    'x-api-key': apiKey,
-    'Authorization': `Bearer ${apiKey}`,
-    'anthropic-version': '2023-06-01',
-    'anthropic-beta': CLAUDE_CODE_BETA_HEADER,
-    'Accept-Encoding': 'gzip, deflate, br',
-    'User-Agent': 'claude-cli/2.0.53 (external, cli)'
-  };
-
-  const legacyBody = buildClaudeProbePayload(model, {
-    includeSystem: true,
-    systemAsArray: true,
-    includeMetadata: true
+  const converted = createClaudeRequest('/v1/messages', minimalPayload, {
+    apiKey,
+    baseUrl: channel.baseUrl,
+    fallbackModel: model,
+    stream: false
   });
 
   return [
     {
-      label: 'claude-code-legacy-beta',
-      url: buildClaudeMessagesUrl(channel.baseUrl, { withBeta: true }),
-      body: legacyBody,
-      headers: {
-        ...commonHeaders,
-        'anthropic-dangerous-direct-browser-access': 'true',
-        'x-app': 'cli',
-        'x-stainless-lang': 'js',
-        'x-stainless-runtime': 'node'
-      }
+      label: 'claude-messages',
+      url: buildClaudeTargetUrl(channel.baseUrl),
+      body: JSON.stringify(converted.body),
+      headers: converted.headers
     }
   ];
 }
-
 function createCodexProbeAttempts(channel, model) {
   const apiKey = channel.apiKey || '';
-  const commonHeaders = {
-    ...buildRequestHeaders('codex', channel),
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${apiKey}`,
-    'User-Agent': 'codex_cli_rs/0.65.0'
-  };
-
-  const responsesBody = JSON.stringify({
+  const sessionId = crypto.randomUUID();
+  const converted = createCodexRequest({
     model,
     instructions: 'You are Codex.',
     input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
-    max_output_tokens: 1,
-    stream: false,
-    store: false
+    prompt_cache_key: sessionId
+  }, {
+    apiKey,
+    sessionId
   });
 
   return [
     {
       label: 'codex-responses',
-      url: buildOpenAiCompatibleUrl(channel.baseUrl, '/v1/responses'),
-      body: responsesBody,
-      headers: {
-        ...commonHeaders,
-        'openai-beta': 'responses=experimental'
-      }
+      url: buildCodexTargetUrl(channel.baseUrl),
+      body: JSON.stringify(converted.body),
+      headers: converted.headers
     }
   ];
 }
 
 function createGeminiProbeAttempt(channel, model) {
   const apiKey = channel.apiKey || '';
-  const body = JSON.stringify({
-    contents: [{ role: 'user', parts: [{ text: 'test' }] }],
-    generationConfig: { maxOutputTokens: 1, temperature: 0 }
+  const useCli = resolveExplicitGeminiUseCli(channel);
+  const minimalPayload = {
+    model,
+    max_output_tokens: 1,
+    temperature: 0,
+    input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }]
+  };
+  const converted = createGeminiRequest('/v1/responses', minimalPayload, {
+    apiKey,
+    fallbackModel: model,
+    stream: false,
+    useCli
   });
 
   return {
-    label: 'gemini-generate-content',
-    url: buildGeminiGenerateContentUrl(channel.baseUrl, model, apiKey),
-    body,
-    headers: {
-      ...buildRequestHeaders('gemini', channel),
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${apiKey}`,
-      'x-goog-api-key': apiKey,
-      'User-Agent': 'google-genai-sdk/0.8.0'
-    }
+    label: useCli ? 'gemini-cli-generate-content' : 'gemini-generate-content',
+    url: buildGeminiTargetUrl(channel.baseUrl, converted.model, apiKey, { stream: false, useCli }),
+    body: JSON.stringify(converted.body),
+    headers: converted.headers
   };
 }
 

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

@@ -172,7 +172,10 @@ class OmpChannelService extends BaseChannelService {
   _applyDefaults(channel) {
     const normalized = super._applyDefaults(channel);
     normalized.providerKey = normalized.providerKey || normalized.provider || normalized.name || normalized.id;
-    normalized.providerApi = normalized.providerApi || normalized.api || normalized.wireApi || 'openai-completions';
+    normalized.providerApi = normalizeProviderApi(
+      normalized.providerApi || normalized.api || normalized.wireApi || 'openai-completions',
+      { gatewaySourceType: normalized.gatewaySourceType }
+    );
     normalized.authMode = ['api_key', 'oauth', 'none'].includes(normalized.authMode)
       ? normalized.authMode
       : 'api_key';
@@ -605,19 +608,35 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     };
   }
 
+  const rawProviderApi = sourceProvider.api || provider.api || 'openai-completions';
+  const apiVal = String(rawProviderApi).trim();
+  let gatewaySourceType;
+  if (existing?.gatewaySourceType) {
+    gatewaySourceType = existing.gatewaySourceType;
+  } else if (apiVal === 'anthropic-messages') {
+    gatewaySourceType = 'claude';
+  } else if (apiVal === 'google-generative-ai' || apiVal === 'google-gemini-cli' || apiVal === 'google-vertex') {
+    gatewaySourceType = 'gemini';
+  } else if (apiVal === 'openai-codex-responses') {
+    gatewaySourceType = 'codex';
+  } else {
+    gatewaySourceType = 'openai_compatible';
+  }
+  const providerApi = normalizeProviderApi(rawProviderApi, { gatewaySourceType });
+
   return {
     name: existing?.name || originalProviderId || providerId,
     providerKey: originalProviderId || providerId,
     baseUrl,
     apiKey: authMode === 'none' ? '' : apiKey,
-    providerApi: normalizeProviderApi(sourceProvider.api || provider.api),
-    wireApi: sourceProvider.api || provider.api || 'openai-completions',
+    providerApi,
+    wireApi: providerApi,
     authMode,
     oauthProviderId: authMode === 'oauth' ? (existing?.oauthProviderId || originalProviderId || providerId) : '',
     model: preferredModel,
     allowedModels,
     models: filterOmpProviderModels(provider.models, allowedModels),
-    gatewaySourceType: existing?.gatewaySourceType || 'openai_compatible',
+    gatewaySourceType,
     credentialSource: credential.value ? credential.source : 'existing-channel'
   };
 }

package/src/server/services/omp-gateway.js

@@ -58,6 +58,34 @@ function buildUpstreamRequestPath(baseUrl, requestUrl) {
   return `${pathname.startsWith('/') ? pathname : `/${pathname}`}${query ? `?${query}` : ''}`;
 }
 
+function rewriteCodexResponsesRequestPath(baseUrl, requestUrl, providerApi = '') {
+  if (providerApi !== 'openai-codex-responses') return buildUpstreamRequestPath(baseUrl, requestUrl);
+
+  const base = new URL(baseUrl);
+  const request = new URL(requestUrl, 'http://127.0.0.1');
+  const requestedPath = request.pathname.replace(/\/+$/, '') || '/';
+  if (!requestedPath.endsWith('/codex/responses')) {
+    return buildUpstreamRequestPath(baseUrl, requestUrl);
+  }
+
+  const basePath = base.pathname === '/' ? '' : base.pathname.replace(/\/+$/, '');
+  let pathname;
+  if (!basePath) {
+    pathname = '/codex/responses';
+  } else if (basePath.endsWith('/responses')) {
+    pathname = basePath;
+  } else if (basePath.endsWith('/v1') || basePath.endsWith('/codex')) {
+    pathname = `${basePath}/responses`;
+  } else {
+    pathname = `${basePath}/codex/responses`;
+  }
+
+  const search = new URLSearchParams(base.searchParams);
+  request.searchParams.forEach((value, name) => search.set(name, value));
+  const query = search.toString();
+  return `${pathname.startsWith('/') ? pathname : `/${pathname}`}${query ? `?${query}` : ''}`;
+}
+
 function rewriteCredential(headers, requestUrl, route, channel, options = {}) {
   const next = { ...headers };
   delete next.host;
@@ -428,7 +456,7 @@ function createOmpGateway(options = {}) {
         return;
       }
 
-      const upstreamPath = buildUpstreamRequestPath(channel.baseUrl, route.upstreamPath);
+      const upstreamPath = rewriteCodexResponsesRequestPath(channel.baseUrl, route.upstreamPath, route.providerApi);
       const rewritten = rewriteCredential(req.headers, upstreamPath, route, channel);
       const transport = upstream.protocol === 'https:' ? https : http;
       let upstreamResponse = null;

package/src/server/services/omp-sessions.js

@@ -1,6 +1,13 @@
 const fs = require('fs');
 const path = require('path');
 const { PATHS, HOME_DIR } = require('../../config/paths');
+const {
+  listProjects: idxListProjects,
+  listSessions: idxListSessions,
+  getRecentSessions: idxGetRecent,
+  searchSessions: idxSearch,
+  getSessionStatus: idxGetSessionStatus,
+} = require('./session-history-index');
 const { getOmpCommand, getOmpPaths, resolveOmpRuntime } = require('./omp-config');
 
 const PROJECT_ORDER_FILE = PATHS.ompProjectOrder;
@@ -286,18 +293,16 @@ function scanSessionFiles(rootDir = getOmpSessionPaths().sessions) {
   return files;
 }
 
-function getAllSessions() {
-  return scanSessionFiles()
-    .map((filePath) => {
-      try {
-        return parseSessionFile(filePath);
-      } catch (error) {
-        console.warn('[OMP Sessions] Failed to parse session:', filePath, error.message);
-        return null;
-      }
-    })
-    .filter(Boolean)
-    .sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0));
+async function getAllSessions(options = {}) {
+  const projects = await idxListProjects('omp', options);
+  const groups = await Promise.all(projects.map(project => idxListSessions('omp', project.name, options)));
+  return groups.flat().map(session => normalizeSession({
+    ...session,
+    mtime: new Date(session.mtime).toISOString(),
+    mtimeMs: session.mtime,
+    directory: session.projectFullPath,
+    usage: session.tokens
+  }));
 }
 
 function getOmpUsageEvents(rootDir = getOmpSessionPaths().sessions) {
@@ -350,32 +355,20 @@ function loadSessionOrder() {
   return safeReadJson(SESSION_ORDER_FILE, {});
 }
 
-function getProjects(_options = {}) {
-  const sessions = getAllSessions();
-  const projectMap = new Map();
-  sessions.forEach((session) => {
-    const key = session.projectName;
-    const existing = projectMap.get(key) || {
-      name: key,
-      path: session.cwd,
-      fullPath: session.cwd,
-      displayName: getDisplayName(session.cwd),
-      sessionCount: 0,
-      latestSession: null,
-      mtime: session.mtime,
-      mtimeMs: 0,
-      source: 'omp'
-    };
-    existing.sessionCount += 1;
-    if ((session.mtimeMs || 0) > (existing.mtimeMs || 0)) {
-      existing.latestSession = session.sessionId;
-      existing.mtime = session.mtime;
-      existing.mtimeMs = session.mtimeMs;
-    }
-    projectMap.set(key, existing);
-  });
+async function getProjects(_options = {}) {
+  const idxProjects = await idxListProjects('omp');
+  const projects = idxProjects.map(p => ({
+    name: p.name,
+    path: p.fullPath || p.path || '',
+    fullPath: p.fullPath || '',
+    displayName: p.displayName || p.name,
+    sessionCount: p.sessionCount || 0,
+    latestSession: p.latestSession || null,
+    mtime: p.lastUsed || null,
+    mtimeMs: p.lastUsed ? new Date(p.lastUsed).getTime() : 0,
+    source: 'omp'
+  }));
 
-  const projects = Array.from(projectMap.values());
   const order = loadProjectOrder();
   projects.sort((a, b) => {
     const ai = order.indexOf(a.name);
@@ -390,10 +383,26 @@ function getProjects(_options = {}) {
   return projects;
 }
 
-function getSessionsByProject(projectName, _options = {}) {
+async function getSessionsByProject(projectName, _options = {}) {
+  const idxSessions = await idxListSessions('omp', projectName);
+  const sessions = idxSessions.map(s => ({
+    sessionId: s.sessionId,
+    filePath: s.filePath,
+    firstMessage: s.firstMessage,
+    gitBranch: s.gitBranch,
+    provider: s.provider,
+    model: s.model,
+    size: s.size,
+    mtime: new Date(s.mtime).toISOString(),
+    mtimeMs: s.mtime,
+    directory: s.projectFullPath,
+    cwd: s.projectFullPath,
+    messageCount: s.messageCount,
+    usage: s.tokens
+  }));
+
   const orderMap = loadSessionOrder();
   const order = Array.isArray(orderMap[projectName]) ? orderMap[projectName] : [];
-  const sessions = getAllSessions().filter(session => session.projectName === projectName);
   sessions.sort((a, b) => {
     const ai = order.indexOf(a.sessionId);
     const bi = order.indexOf(b.sessionId);
@@ -427,83 +436,71 @@ function normalizeSession(session) {
   };
 }
 
-function getSessionById(sessionId) {
-  return getAllSessions().find(session => session.sessionId === sessionId || path.basename(session.filePath, '.jsonl') === sessionId) || null;
+async function getSessionById(sessionId) {
+  const status = await idxGetSessionStatus('omp', sessionId);
+  if (!status) return null;
+  return {
+    sessionId: status.sessionId,
+    filePath: status.filePath,
+    size: status.size,
+    mtime: new Date(status.lastModified).toISOString(),
+    mtimeMs: status.lastModified,
+    source: 'omp',
+    firstMessage: null,
+    gitBranch: null,
+    forkedFrom: null,
+    provider: '',
+    model: '',
+    directory: null,
+    messageCount: 0,
+    tokens: { input: 0, output: 0, cached: 0, reasoning: 0, total: 0 }
+  };
 }
-
-function getSessionMessages(sessionId) {
-  const session = getSessionById(sessionId);
+async function getSessionMessages(sessionId) {
+  const session = await getSessionById(sessionId);
   if (!session) {
     throw new Error('Session not found');
   }
   return readJsonLines(session.filePath).map(convertOmpEntry).filter(Boolean);
 }
 
-function getRecentSessions(limit = 5) {
-  return getAllSessions().slice(0, limit).map(normalizeSession);
-}
-
-function searchSessions(keyword, contextLength = 35, projectName = null) {
-  const needle = String(keyword || '').toLowerCase();
-  if (!needle) return [];
-
-  return getAllSessions()
-    .filter(session => !projectName || session.projectName === projectName)
-    .map((session) => {
-      const messages = readJsonLines(session.filePath).map(convertOmpEntry).filter(Boolean);
-      const matches = [];
-      messages.forEach((message) => {
-        const text = String(message.content || '');
-        const index = text.toLowerCase().indexOf(needle);
-        if (index === -1) return;
-        const start = Math.max(0, index - contextLength);
-        const end = Math.min(text.length, index + needle.length + contextLength);
-        matches.push({
-          role: message.role || message.type,
-          context: text.slice(start, end),
-          timestamp: message.timestamp || null
-        });
-      });
-      if (matches.length === 0) return null;
-      return {
-        ...normalizeSession(session),
-        projectName: session.projectName,
-        projectDisplayName: getDisplayName(session.cwd),
-        matchCount: matches.length,
-        matches
-      };
-    })
-    .filter(Boolean);
-}
-
-function deleteSession(sessionId) {
-  const session = getSessionById(sessionId);
-  if (!session) {
-    throw new Error('Session not found');
-  }
+async function getRecentSessions(limit = 5) {
+  const indexed = await idxGetRecent('omp', limit);
+  return indexed.map(session => normalizeSession({
+    ...session,
+    mtime: new Date(session.mtime).toISOString(),
+    mtimeMs: session.mtime,
+    directory: session.projectFullPath,
+    usage: session.tokens
+  }));
+}
+
+async function searchSessions(keyword, contextLength = 35, projectName = null) {
+  return idxSearch('omp', keyword, { contextLength, projectName });
+}
+
+async function deleteSession(sessionId) {
+  const session = await getSessionById(sessionId);
+  if (!session) throw new Error('Session not found');
   fs.unlinkSync(session.filePath);
   return { success: true };
 }
 
-function deleteProject(projectName) {
-  const sessions = getAllSessions().filter(session => session.projectName === projectName);
-  if (sessions.length === 0) {
-    throw new Error('Project not found');
-  }
+async function deleteProject(projectName) {
+  const sessions = await getSessionsByProject(projectName);
+  if (sessions.length === 0) throw new Error('Project not found');
   sessions.forEach(session => fs.unlinkSync(session.filePath));
   return { success: true, deletedSessions: sessions.length };
 }
 
-function forkSession(sessionId) {
-  const session = getSessionById(sessionId);
-  if (!session) {
-    throw new Error('Session not found');
-  }
-  const parsed = path.parse(session.filePath);
-  const forkId = `fork-${Date.now()}`;
-  const targetPath = path.join(parsed.dir, `${parsed.name}-${forkId}${parsed.ext}`);
-  fs.copyFileSync(session.filePath, targetPath);
-  return { success: true, newSessionId: parseOmpSessionId(targetPath), filePath: targetPath };
+async function forkSession(sessionId) {
+  const session = await getSessionById(sessionId);
+  if (!session) throw new Error('Session not found');
+  const newSessionId = crypto.randomUUID();
+  const newFile = path.join(path.dirname(session.filePath), `${newSessionId}.jsonl`);
+  const content = fs.readFileSync(session.filePath, 'utf8');
+  fs.writeFileSync(newFile, content, 'utf8');
+  return { success: true, sessionId: newSessionId, filePath: newFile, forkedFrom: sessionId };
 }
 
 function saveProjectOrder(order) {
@@ -516,11 +513,11 @@ function saveSessionOrder(projectName, order) {
   safeWriteJson(SESSION_ORDER_FILE, data);
 }
 
-function getProjectAndSessionCounts(_options = {}) {
-  const sessions = getAllSessions();
+async function getProjectAndSessionCounts(options = {}) {
+  const projects = await idxListProjects('omp', options);
   return {
-    projectCount: new Set(sessions.map(session => session.projectName)).size,
-    sessionCount: sessions.length
+    projectCount: projects.length,
+    sessionCount: projects.reduce((sum, project) => sum + (project.sessionCount || 0), 0)
   };
 }
 

package/src/server/services/omp-settings-manager.js

@@ -60,9 +60,30 @@ function isManagedProviderId(providerId = '') {
   return String(providerId || '').startsWith(MANAGED_PROVIDER_PREFIX);
 }
 
-function normalizeProviderApi(value = '') {
+function normalizeProviderApi(value = '', options = {}) {
   const normalized = String(value || '').trim();
-  if (!normalized || normalized === 'openai' || normalized === 'chat' || normalized === 'chat.completions') {
+  const gatewaySourceType = String(options.gatewaySourceType || '').trim().toLowerCase();
+
+  const isGeneric = !normalized
+    || normalized === 'openai'
+    || normalized === 'chat'
+    || normalized === 'chat.completions'
+    || normalized === 'openai-completions';
+
+  if (gatewaySourceType === 'codex' && (
+    isGeneric
+    || normalized === 'responses'
+    || normalized === 'openai-responses'
+  )) {
+    return 'openai-codex-responses';
+  }
+  if (gatewaySourceType === 'claude' && isGeneric) {
+    return 'anthropic-messages';
+  }
+  if (gatewaySourceType === 'gemini' && isGeneric) {
+    return 'google-generative-ai';
+  }
+  if (isGeneric) {
     return 'openai-completions';
   }
   if (normalized === 'responses') {
@@ -341,7 +362,9 @@ function buildProviderEntry(channel = {}, options = {}) {
   const entry = compactObject({
     ...normalizedProvider.config,
     baseUrl: String(channel.baseUrl || providerConfig.baseUrl || '').trim(),
-    api: normalizeProviderApi(channel.providerApi || channel.api || channel.wireApi || providerConfig.api),
+    api: normalizeProviderApi(channel.providerApi || channel.api || channel.wireApi || providerConfig.api, {
+      gatewaySourceType: channel.gatewaySourceType
+    }),
     models
   });
 
@@ -1220,6 +1243,7 @@ module.exports = {
   getLastManagedOmpSyncResult,
   isManagedOmpProvidersActive,
   isManagedProviderExtensionActive: isManagedOmpProvidersActive,
+  isManagedProviderId,
   normalizeProviderId,
   normalizeProviderApi,
   normalizeModels,