coding-tool-x 3.9.0 → 3.9.2

package/src/platforms/drivers/omp/model-role-settings.js

@@ -0,0 +1,235 @@
+'use strict';
+
+const {
+  getOmpPaths,
+  readOmpSettingsStrict,
+  readYamlFile,
+  writeOmpSettingsAtomic
+} = require('./config');
+const { getPlatformCatalog } = require('../../../server/services/platform-catalog');
+
+const OMP_MODEL_ROLE_KEYS = Object.freeze([
+  'default',
+  'smol',
+  'slow',
+  'plan',
+  'commit',
+  'vision',
+  'designer',
+  'task',
+  'advisor',
+  'tiny'
+]);
+
+const OMP_THINKING_LEVELS = new Set([
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max'
+]);
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseModelRoleSelector(value) {
+  const selector = typeof value === 'string' ? value.trim() : '';
+  const suffix = selector.match(/:(minimal|low|medium|high|xhigh|max)$/i);
+  if (!suffix) return { model: selector, thinkingLevel: '' };
+
+  return {
+    model: selector.slice(0, -suffix[0].length),
+    thinkingLevel: suffix[1].toLowerCase()
+  };
+}
+
+function normalizeProviderId(value = '') {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    || 'coding-tool-x';
+}
+
+function readEnabledOmpChannels() {
+  const driver = getPlatformCatalog().driver('omp', 'channels');
+  const result = driver?.getEnabled?.();
+  if (!result || result.status !== 'ok') {
+    throw new Error(result?.error || 'Unable to read enabled OMP channels');
+  }
+  const channels = Array.isArray(result.data)
+    ? result.data
+    : (Array.isArray(result.data?.channels) ? result.data.channels : []);
+  return channels.filter(channel => channel && channel.enabled !== false);
+}
+
+function modelIdFromConfig(value) {
+  const candidate = typeof value === 'string' ? value : (value?.id || value?.name || '');
+  return String(candidate || '').trim().replace(/:(minimal|low|medium|high|xhigh|max|off)$/i, '');
+}
+
+function uniqueModelIds(values = []) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const modelId = modelIdFromConfig(value);
+    const key = modelId.toLowerCase();
+    if (!modelId || seen.has(key)) continue;
+    seen.add(key);
+    result.push(modelId);
+  }
+  return result;
+}
+
+function getManagedProviderId(channel = {}) {
+  const rawId = channel.managedProviderId
+    || channel.extra?.managedProviderId
+    || channel.providerKey
+    || channel.provider
+    || channel.name
+    || channel.id;
+  const normalizedId = normalizeProviderId(rawId);
+  return normalizedId.startsWith('ctx-') ? normalizedId : `ctx-${normalizedId}`;
+}
+
+function findConfiguredProviderId(providers, managedProviderId) {
+  const target = normalizeProviderId(managedProviderId);
+  return Object.keys(providers).find(providerId => normalizeProviderId(providerId) === target)
+    || managedProviderId;
+}
+
+function collectNativeOAuthModelOptions(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
+    ];
+  return uniqueModelIds(candidates).map(modelId => `${providerId}/${modelId}`);
+}
+
+function collectManagedChannelModelOptions(channel, providers) {
+  const managedProviderId = getManagedProviderId(channel);
+  const configuredProviderId = findConfiguredProviderId(providers, managedProviderId);
+  const configuredModels = providers[configuredProviderId]?.models;
+  const channelModels = [
+    ...(Array.isArray(channel.models) ? channel.models : []),
+    ...(Array.isArray(channel.allowedModels) ? channel.allowedModels : []),
+    channel.model,
+    channel.speedTestModel,
+    ...(Array.isArray(channel.modelBindings)
+      ? channel.modelBindings.map(binding => binding?.modelId || binding?.id || binding)
+      : [])
+  ];
+  const modelIds = uniqueModelIds(Array.isArray(configuredModels) && configuredModels.length > 0
+    ? configuredModels
+    : channelModels);
+  return modelIds.map(modelId => `${configuredProviderId}/${modelId}`);
+}
+
+function collectModelOptions(modelsConfig = {}, channels = []) {
+  const options = new Set();
+  const providers = isPlainObject(modelsConfig.providers) ? modelsConfig.providers : {};
+  for (const channel of channels) {
+    const isNativeOAuth = channel.authMode === 'oauth' && !String(channel.baseUrl || '').trim();
+    const channelOptions = isNativeOAuth
+      ? collectNativeOAuthModelOptions(channel)
+      : collectManagedChannelModelOptions(channel, providers);
+    channelOptions.forEach(option => options.add(option));
+  }
+  return [...options].sort((left, right) => left.localeCompare(right));
+}
+
+function readOmpModelRoleSettings() {
+  const settings = readOmpSettingsStrict();
+  const modelRoles = isPlainObject(settings.modelRoles) ? settings.modelRoles : {};
+  const roles = Object.fromEntries(OMP_MODEL_ROLE_KEYS.map((key) => [
+    key,
+    parseModelRoleSelector(modelRoles[key])
+  ]));
+  const modelsConfig = readYamlFile(getOmpPaths().modelsYml, {});
+  const modelOptions = collectModelOptions(modelsConfig, readEnabledOmpChannels());
+  const optionSet = new Set(modelOptions);
+
+  return {
+    roles,
+    modelOptions,
+    unavailableRoles: Object.fromEntries(Object.entries(roles)
+      .filter(([, role]) => role.model && !optionSet.has(role.model))
+      .map(([key]) => [key, true]))
+  };
+}
+
+function updateOmpModelRoleSettings(input) {
+  if (!isPlainObject(input)) {
+    throw new Error('roles must be an object');
+  }
+
+  const settings = readOmpSettingsStrict();
+  const modelRoles = isPlainObject(settings.modelRoles) ? { ...settings.modelRoles } : {};
+  const currentModelRoles = isPlainObject(settings.modelRoles) ? settings.modelRoles : {};
+  const modelOptions = new Set(collectModelOptions(
+    readYamlFile(getOmpPaths().modelsYml, {}),
+    readEnabledOmpChannels()
+  ));
+  for (const [key, role] of Object.entries(input)) {
+    if (!OMP_MODEL_ROLE_KEYS.includes(key)) {
+      throw new Error(`roles.${key} is not a supported OMP model role`);
+    }
+    if (!isPlainObject(role) || typeof role.model !== 'string') {
+      throw new Error(`roles.${key}.model must be a string`);
+    }
+
+    const suppliedModel = role.model.trim();
+    if (suppliedModel.length > 500) {
+      throw new Error(`roles.${key}.model must be 500 characters or fewer`);
+    }
+
+    const suppliedThinkingLevel = role.thinkingLevel == null ? '' : role.thinkingLevel;
+    if (typeof suppliedThinkingLevel !== 'string'
+        || (suppliedThinkingLevel && !OMP_THINKING_LEVELS.has(suppliedThinkingLevel))) {
+      throw new Error(`roles.${key}.thinkingLevel must be one of ${[...OMP_THINKING_LEVELS].join(', ')}`);
+    }
+
+    if (!suppliedModel) {
+      delete modelRoles[key];
+      continue;
+    }
+
+    const parsed = parseModelRoleSelector(suppliedModel);
+    if (!parsed.model) {
+      throw new Error(`roles.${key}.model must include a model selector`);
+    }
+    const thinkingLevel = suppliedThinkingLevel || parsed.thinkingLevel;
+    const nextSelector = thinkingLevel ? `${parsed.model}:${thinkingLevel}` : parsed.model;
+    const currentSelector = String(currentModelRoles[key] || '').trim();
+    if (!modelOptions.has(parsed.model) && nextSelector !== currentSelector) {
+      throw new Error(`roles.${key}.model must use a model from an enabled OMP channel`);
+    }
+    modelRoles[key] = nextSelector;
+  }
+
+  if (Object.keys(modelRoles).length > 0) settings.modelRoles = modelRoles;
+  else delete settings.modelRoles;
+
+  writeOmpSettingsAtomic(settings);
+  return readOmpModelRoleSettings();
+}
+
+module.exports = {
+  OMP_MODEL_ROLE_KEYS,
+  OMP_THINKING_LEVELS,
+  collectModelOptions,
+  readEnabledOmpChannels,
+  parseModelRoleSelector,
+  readOmpModelRoleSettings,
+  updateOmpModelRoleSettings
+};

package/src/platforms/drivers/opencode/conversion.js

@@ -2,22 +2,69 @@
 
 function createDriver(context = {}) {
   const converter = require('./gateway-converter');
+  const {
+    loadLatestProxyRequestHeaders,
+    loadLatestProxyRequestSnapshot
+  } = require('../../../server/services/request-logger');
+  const target = context.platform || 'opencode';
+
+  function getOmpTargetContext() {
+    const snapshot = loadLatestProxyRequestSnapshot('omp');
+    const providerApi = snapshot?.route?.providerApi;
+    const targetApi = providerApi === 'openai-completions'
+      ? 'chat.completions'
+      : ['openai-responses', 'openai-codex-responses', 'azure-openai-responses'].includes(providerApi)
+        ? 'responses'
+        : null;
+    return { snapshot, providerApi, targetApi };
+  }
+
+  function convertPayload({ sourceType, payload, options = {} } = {}) {
+    const ompContext = target === 'omp' ? getOmpTargetContext() : null;
+    if (ompContext && !ompContext.targetApi) {
+      throw new Error('The latest OMP request log does not identify a supported OpenAI-compatible provider API. Send an OMP request through an OpenAI-compatible route, then retry.');
+    }
+    const requestedTargetApi = options.targetApi || options.api;
+    if (ompContext && requestedTargetApi && requestedTargetApi !== ompContext.targetApi) {
+      throw new Error(`The latest OMP request uses ${ompContext.providerApi}; conversion only supports ${ompContext.targetApi}.`);
+    }
+    const result = converter.convertToOpenCodePayload({
+      sourceType,
+      payload,
+      options: ompContext ? { ...options, targetApi: ompContext.targetApi } : options
+    });
+    return {
+      ...result,
+      target,
+      ...(ompContext?.snapshot?.route?.path ? { endpoint: ompContext.snapshot.route.path } : {}),
+      requestHeaders: loadLatestProxyRequestHeaders(target)
+    };
+  }
+
   return {
     platform: context.platform,
     capability: 'conversion',
     formats() {
+      const ompContext = target === 'omp' ? getOmpTargetContext() : null;
+      const targetApis = target === 'omp'
+        ? (ompContext.targetApi ? [ompContext.targetApi] : [])
+        : converter.SUPPORTED_TARGET_APIS;
       return {
         sourceTypes: converter.SUPPORTED_SOURCE_TYPES,
         formats: converter.SUPPORTED_SOURCE_TYPES.map(type => ({
           id: type,
           name: type === 'claude' ? 'Claude Code' : type === 'codex' ? 'Codex' : 'Gemini'
         })),
-        targetApis: converter.SUPPORTED_TARGET_APIS,
-        defaultTargetApi: 'responses',
-        endpoints: {
-          responses: '/v1/responses',
-          'chat.completions': '/v1/chat/completions'
-        }
+        targetApis,
+        defaultTargetApi: targetApis[0] || null,
+        endpoints: ompContext
+          ? (ompContext.targetApi && ompContext.snapshot?.route?.path
+            ? { [ompContext.targetApi]: ompContext.snapshot.route.path }
+            : {})
+          : {
+            responses: '/v1/responses',
+            'chat.completions': '/v1/chat/completions'
+          }
       };
     },
     getFormats() {
@@ -30,10 +77,15 @@ function createDriver(context = {}) {
         codex: converter.convertCodexToOpenCodePayload,
         gemini: converter.convertGeminiToOpenCodePayload
       };
-      return (handlers[sourceType] || converter.convertToOpenCodePayload)({ sourceType, payload, options });
+      if (target === 'omp') return convertPayload({ sourceType, payload, options });
+      return {
+        ...(handlers[sourceType] || converter.convertToOpenCodePayload)({ sourceType, payload, options }),
+        target,
+        requestHeaders: loadLatestProxyRequestHeaders(target)
+      };
     },
     convert({ sourceType, payload, options = {} } = {}) {
-      return converter.convertToOpenCodePayload({ sourceType, payload, options });
+      return convertPayload({ sourceType, payload, options });
     }
   };
 }

package/src/platforms/manifest-schema.js

@@ -68,6 +68,7 @@ const CAPABILITY_OPERATIONS = Object.freeze({
     'listProfileCapabilities',
     'listProfileMcp',
     'listProfilePrompts',
+    'listProfileAgentPresets',
     'installPlugin',
     'uninstallPlugin',
     'updatePlugin',
@@ -75,6 +76,8 @@ const CAPABILITY_OPERATIONS = Object.freeze({
     'deleteMcp',
     'upsertPrompt',
     'deletePrompt',
+    'upsertAgentPreset',
+    'deleteAgentPreset',
     'listSkills',
     'getSkill',
     'createSkill',
@@ -113,6 +116,7 @@ const schema = {
     portLabel: { type: 'string', minLength: 1 },
     apiBasePath: { type: 'string', minLength: 1 },
     logFile: { type: 'string', minLength: 1 },
+    logLayout: { enum: ['basic'] },
     logAliases: { type: 'array', items: { type: 'string', minLength: 1 } },
     logNote: { type: 'string' },
     logColor: { type: 'string', minLength: 1 },

package/src/platforms/manifests/dsh.json

@@ -5,6 +5,7 @@
   "command": "dsh",
   "iconToken": "terminal",
   "color": "#2563eb",
+  "logLayout": "basic",
   "defaultVisible": true,
   "defaultEnabled": false,
   "sortOrder": 50,
@@ -25,7 +26,7 @@
   "resourceTypes": {
     "skills": true,
     "commands": false,
-    "agents": false,
+    "agents": true,
     "plugins": true,
     "mcp": true,
     "prompts": true
@@ -38,10 +39,10 @@
       "refresh": true
     },
     "plugins": {
-      "repositories": true,
+      "repositories": false,
       "market": false,
-      "install": false,
-      "uninstall": false,
+      "install": true,
+      "uninstall": true,
       "import": false,
       "syncRepos": false
     }
@@ -477,6 +478,30 @@
         "request": "default",
         "response": "default"
       },
+      {
+        "method": "GET",
+        "path": "/profiles/:profileName/agent-presets",
+        "capability": "api",
+        "operation": "listProfileAgentPresets",
+        "request": "default",
+        "response": "default"
+      },
+      {
+        "method": "POST",
+        "path": "/profiles/:profileName/agent-presets",
+        "capability": "api",
+        "operation": "upsertAgentPreset",
+        "request": "default",
+        "response": "default"
+      },
+      {
+        "method": "DELETE",
+        "path": "/profiles/:profileName/agent-presets/:presetId",
+        "capability": "api",
+        "operation": "deleteAgentPreset",
+        "request": "default",
+        "response": "default"
+      },
       {
         "method": "GET",
         "path": "/skills",

package/src/platforms/manifests/omp.json

@@ -45,11 +45,11 @@
   "resourceTypes": {
     "skills": true,
     "commands": true,
-    "agents": false,
+    "agents": true,
     "plugins": true
   },
   "agentCapabilities": {
-    "projectScope": false,
+    "projectScope": true,
     "repoOperations": true
   },
   "skillActivation": {
@@ -73,7 +73,7 @@
       ]
     },
     "agents": {
-      "canonicalRoot": null
+      "canonicalRoot": ".omp/agents"
     },
     "commands": {
       "canonicalRoot": ".omp/commands",
@@ -484,6 +484,7 @@
     "hooks": "legacy:omp",
     "resourceSync": "legacy:omp",
     "mcp": "legacy:omp",
-    "prompts": "legacy:omp"
+    "prompts": "legacy:omp",
+    "conversion": "opencode-conversion"
   }
 }

package/src/platforms/registry.js

@@ -188,6 +188,7 @@ function createPlatformRegistry({
       portLabel: platform.portLabel || null,
       apiPrefix: platform.api?.prefix || null,
       modelCatalogKey: platform.modelConfig?.catalogKey || platform.key,
+      ...(platform.logLayout ? { logLayout: platform.logLayout } : {}),
       capabilities
     };
     const resourceTypes = publicResourceTypes(platform.resourceTypes);

package/src/server/api/convert.js

@@ -1,40 +1,28 @@
 const express = require('express');
 const router = express.Router();
 const { getPlatformCatalog } = require('../services/platform-catalog');
+const { createSameOriginGuard } = require('../services/network-access');
 
-/**
- * 获取支持的格式列表
- * GET /api/convert/formats
- */
-router.get('/formats', (req, res) => {
-  const driver = getPlatformCatalog().driver('opencode', 'conversion');
+router.use(createSameOriginGuard({
+  message: '禁止跨站访问请求转换接口'
+}));
+
+function getConversionDriver(target) {
+  return getPlatformCatalog().driver(target, 'conversion');
+}
+
+function getConversionFormats(driver) {
   const formats = driver?.formats?.() || driver?.getFormats?.();
-  if (!formats) {
-    return res.status(404).json({ success: false, error: 'Conversion is not supported' });
-  }
-  const sourceTypes = formats.sourceTypes || [];
-  res.json({
-    formats: sourceTypes.map(type => ({
-      id: type,
-      name: (formats.formats || []).find(item => item.id === type)?.name
-        || String(type).replace(/[-_]/g, ' ').replace(/\b\w/g, char => char.toUpperCase()),
-      description: `${type} session format`,
-      extension: '.jsonl',
-      icon: type
-    })),
-    conversions: sourceTypes.flatMap(sourceType => sourceTypes
-      .filter(targetType => targetType !== sourceType)
-      .map(targetType => ({ from: sourceType, to: targetType })))
-  });
-});
+  return formats;
+}
 
 /**
- * 获取 OpenCode 网关支持格式
- * GET /api/convert/opencode/formats
+ * Read conversion capabilities for a target CLI.
+ * GET /api/convert/:target/formats
  */
-router.get('/opencode/formats', (req, res) => {
-  const driver = getConversionDriver();
-  const formats = driver?.formats?.() || driver?.getFormats?.();
+router.get('/:target/formats', (req, res) => {
+  const driver = getConversionDriver(req.params.target);
+  const formats = getConversionFormats(driver);
   if (!formats) {
     return res.status(404).json({ success: false, error: 'Conversion is not supported' });
   }
@@ -45,62 +33,24 @@ router.get('/opencode/formats', (req, res) => {
       name: (formats.formats || []).find(item => item.id === type)?.name
         || String(type).replace(/[-_]/g, ' ').replace(/\b\w/g, char => char.toUpperCase())
     })),
-    target: 'opencode',
+    target: req.params.target,
     targetApis: formats.targetApis || [],
     defaultTargetApi: formats.defaultTargetApi,
-    endpoints: formats.endpoints || {},
-    sourceEndpoints: Object.fromEntries(sourceTypes.map(type => [type, `/api/convert/opencode/${type}`]))
+    endpoints: formats.endpoints || {}
   });
 });
 
-function getConversionDriver() {
-  return getPlatformCatalog().driver('opencode', 'conversion');
-}
-
-function handleOpenCodeConvert(req, res, sourceType) {
-  try {
-    const { payload, options = {} } = req.body || {};
-    const driver = getConversionDriver();
-
-    if (!driver) {
-      return res.status(404).json({ success: false, error: 'Conversion is not supported' });
-    }
-    if (!payload) {
-      return res.status(400).json({
-        success: false,
-        error: 'Missing required parameters: payload'
-      });
-    }
-    const result = driver.convertSource
-      ? driver.convertSource(sourceType, payload, options)
-      : driver.convert({ sourceType, payload, options });
-    return res.json({
-      success: true,
-      ...result
-    });
-  } catch (error) {
-    console.error(`[Convert API] OpenCode ${sourceType} convert error:`, error);
-    return res.status(500).json({
-      success: false,
-      error: error.message
-    });
-  }
-}
-
-router.post('/opencode/:sourceType', (req, res) => {
-  return handleOpenCodeConvert(req, res, req.params.sourceType);
-});
-
 /**
- * 在线转换为 OpenCode 可处理格式
- * POST /api/convert/opencode
+ * Online conversion to a CLI-compatible request format.
+ * POST /api/convert/:target
  * Body: { sourceType, payload, options? }
  */
-router.post('/opencode', (req, res) => {
+router.post('/:target', (req, res) => {
   try {
     const { sourceType, payload, options = {} } = req.body || {};
-    const driver = getConversionDriver();
-    const sourceTypes = driver?.formats?.().sourceTypes || driver?.getFormats?.().sourceTypes || [];
+    const driver = getConversionDriver(req.params.target);
+    const formats = getConversionFormats(driver);
+    const sourceTypes = formats?.sourceTypes || [];
     const normalized = driver?.normalizeSourceType?.(sourceType) || sourceType;
 
     if (!driver) {
@@ -124,7 +74,7 @@ router.post('/opencode', (req, res) => {
       ...driver.convert({ sourceType: normalized, payload, options })
     });
   } catch (error) {
-    console.error('[Convert API] OpenCode gateway convert error:', error);
+    console.error(`[Convert API] ${req.params.target} convert error:`, error);
     return res.status(500).json({
       success: false,
       error: error.message

package/src/server/api/platforms.js

@@ -18,6 +18,7 @@ const PUBLIC_FIELDS = Object.freeze([
   'portLabel',
   'apiPrefix',
   'modelCatalogKey',
+  'logLayout',
   'promptLabel',
   'resourceTypes',
   'resourceActions'

package/src/server/api/settings.js

@@ -9,6 +9,10 @@ const {
 } = require('../../config/model-metadata');
 const { getPlatformCatalog } = require('../services/platform-catalog');
 const { loadConfig, saveConfig } = require('../../config/loader');
+const {
+  readOmpModelRoleSettings,
+  updateOmpModelRoleSettings
+} = require('../../platforms/drivers/omp/model-role-settings');
 const {
   MODEL_SCHEMA_VERSION,
   getPublicModelFieldSchema,
@@ -269,4 +273,27 @@ function handleDeleteModelOverride(req, res) {
 router.delete('/model-settings/:modelId', handleDeleteModelOverride);
 router.delete('/model-metadata/:modelId', handleDeleteModelOverride);
 
+router.get('/omp-model-roles', (req, res) => {
+  try {
+    res.json({ success: true, ...readOmpModelRoleSettings() });
+  } catch (error) {
+    console.error('Error getting OMP model roles:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.put('/omp-model-roles', (req, res) => {
+  try {
+    const { roles } = req.body || {};
+    if (!roles || typeof roles !== 'object' || Array.isArray(roles)) {
+      return res.status(400).json({ error: 'roles must be an object' });
+    }
+    res.json({ success: true, ...updateOmpModelRoleSettings(roles) });
+  } catch (error) {
+    console.error('Error saving OMP model roles:', error);
+    const isValidationError = /^roles(?:\.| must be)/.test(error.message);
+    res.status(isValidationError ? 400 : 500).json({ error: error.message });
+  }
+});
+
 module.exports = router;

package/src/server/services/model-definition-schema.js

@@ -3,7 +3,7 @@
 const MODEL_SCHEMA_VERSION = 2;
 const MODEL_METADATA_MODES = ['auto', 'hybrid', 'manual'];
 const THINKING_EFFORT_LEVELS = ['minimal', 'low', 'medium', 'high', 'xhigh'];
-const THINKING_SELECTOR_LEVELS = [...THINKING_EFFORT_LEVELS, 'off'];
+const THINKING_SELECTOR_LEVELS = [...THINKING_EFFORT_LEVELS, 'max', 'off'];
 const THINKING_MODES = [
   'effort',
   'budget',
@@ -173,7 +173,7 @@ function compactObject(value = {}) {
 
 function splitModelSelector(value = '') {
   const raw = String(value || '').trim();
-  const match = raw.match(/:(minimal|low|medium|high|xhigh|off)$/i);
+  const match = raw.match(/:(minimal|low|medium|high|xhigh|max|off)$/i);
   if (!match) return { modelId: raw, thinkingLevel: null };
   return {
     modelId: raw.slice(0, -match[0].length),