coding-tool-x 3.7.8 → 3.7.10

package/dist/web/index.html

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

package/package.json

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

package/src/config/model-metadata.json

@@ -91,7 +91,15 @@
     },
     "gpt-5.5": {
       "limit": { "context": 1050000, "output": 128000 },
-      "pricing": { "input": 5, "output": 30, "cacheRead": 0.5 }
+      "pricing": { "input": 5, "output": 30, "cacheRead": 0.5 },
+      "reasoning": true,
+      "thinking": {
+        "mode": "effort",
+        "efforts": ["low", "medium", "high", "xhigh"],
+        "defaultLevel": "medium"
+      },
+      "input": ["text", "image"],
+      "supportsTools": true
     },
     "gpt-5.4": {
       "limit": { "context": 1050000, "output": 128000 },

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

@@ -26,9 +26,37 @@ const {
   getCachedOmpAuthProviderSnapshot,
   getOmpAuthProviderCacheMeta
 } = require('../services/omp-auth-providers');
+const {
+  MODEL_SCHEMA_VERSION,
+  MODEL_METADATA_MODES,
+  getPublicModelFieldSchema,
+  normalizeCatalogModelList,
+  redactSensitiveFields,
+  validateModelDefinitions,
+  validateProviderConfig
+} = require('../services/model-definition-schema');
+const { getOmpCatalogModels } = require('../services/omp-settings-manager');
 
 const CHANNEL_LIST_AUTH_OPTIONS = { accountCheck: false, includeStatus: false };
 
+function validateOmpModelPayload(payload = {}) {
+  if (payload.modelMetadataMode !== undefined && !MODEL_METADATA_MODES.includes(payload.modelMetadataMode)) {
+    return `modelMetadataMode must be one of: ${MODEL_METADATA_MODES.join(', ')}`;
+  }
+  if (payload.models !== undefined) {
+    const validation = validateModelDefinitions(payload.models);
+    if (!validation.valid) return validation.error;
+  }
+  if (payload.modelBindings !== undefined && !Array.isArray(payload.modelBindings)) {
+    return 'modelBindings must be an array';
+  }
+  if (payload.providerConfig !== undefined) {
+    const validation = validateProviderConfig(payload.providerConfig);
+    if (!validation.valid) return validation.error;
+  }
+  return null;
+}
+
 function uniqueModels(models = []) {
   const seen = new Set();
   const result = [];
@@ -322,6 +350,44 @@ module.exports = () => {
     }
   });
 
+  router.post('/catalog-metadata', (req, res) => {
+    try {
+      const providerKey = String(req.body?.providerKey || '').trim();
+      if (!providerKey) {
+        return res.status(400).json({ error: 'providerKey is required' });
+      }
+      const requestedModelIds = uniqueModels([
+        req.body?.model,
+        req.body?.speedTestModel,
+        ...(Array.isArray(req.body?.allowedModels) ? req.body.allowedModels : []),
+        ...(Array.isArray(req.body?.models)
+          ? req.body.models.map(model => typeof model === 'string' ? model : (model?.id || model?.name))
+          : [])
+      ]);
+      const rawModels = getOmpCatalogModels(providerKey, {
+        forceCatalogRefresh: req.body?.forceRefresh === true,
+        catalogTimeout: 5000,
+        requestedModelIds
+      });
+      const normalizedCatalog = normalizeCatalogModelList(rawModels);
+      const models = normalizedCatalog.models.map(model => redactSensitiveFields(model));
+      const warnings = normalizedCatalog.warnings.slice();
+      if (models.length === 0) {
+        warnings.push('OMP catalog did not return model metadata; existing manual definitions were left unchanged.');
+      }
+      res.json({
+        schemaVersion: MODEL_SCHEMA_VERSION,
+        fieldSchema: getPublicModelFieldSchema(),
+        providerKey,
+        models,
+        warnings
+      });
+    } catch (error) {
+      console.error('[OMP Channels API] Error reading OMP catalog metadata:', error);
+      res.status(502).json({ error: 'Failed to read OMP model metadata' });
+    }
+  });
+
   router.post('/', (req, res) => {
     try {
       const {
@@ -344,9 +410,18 @@ module.exports = () => {
         presetId,
         websiteUrl,
         balanceToken,
-        balanceUserId
+        balanceUserId,
+        models,
+        modelMetadataMode,
+        modelBindings,
+        providerConfig
       } = req.body || {};
 
+      const modelPayloadError = validateOmpModelPayload(req.body || {});
+      if (modelPayloadError) {
+        return res.status(400).json({ error: modelPayloadError });
+      }
+
       if (!name || !baseUrl) {
         return res.status(400).json({ error: 'Missing required fields: name and baseUrl' });
       }
@@ -372,7 +447,11 @@ module.exports = () => {
         presetId,
         websiteUrl: websiteUrl || '',
         balanceToken: balanceToken || '',
-        balanceUserId: balanceUserId || null
+        balanceUserId: balanceUserId || null,
+        models: Array.isArray(models) ? models : [],
+        modelMetadataMode: modelMetadataMode || 'auto',
+        modelBindings: Array.isArray(modelBindings) ? modelBindings : [],
+        providerConfig: providerConfig || {}
       });
       res.json(channel);
       broadcastSchedulerState('omp', getSchedulerState('omp'));
@@ -384,6 +463,10 @@ module.exports = () => {
 
   router.put('/:channelId', (req, res) => {
     try {
+      const modelPayloadError = validateOmpModelPayload(req.body || {});
+      if (modelPayloadError) {
+        return res.status(400).json({ error: modelPayloadError });
+      }
       const channel = updateChannel(req.params.channelId, req.body || {});
       res.json(channel);
       broadcastSchedulerState('omp', getSchedulerState('omp'));

package/src/server/api/settings.js

@@ -7,21 +7,68 @@ const {
   saveDefaultSpeedTestModels
 } = require('../../config/model-metadata');
 const { loadConfig, saveConfig } = require('../../config/loader');
+const {
+  MODEL_SCHEMA_VERSION,
+  getPublicModelFieldSchema,
+  isPlainObject,
+  redactSensitiveFields,
+  resolveModelDefinition,
+  validateModelDefinitions
+} = require('../services/model-definition-schema');
+
+function mergeMetadata(base = {}, override = {}) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override || {})) {
+    if (isPlainObject(value) && isPlainObject(result[key])) result[key] = { ...result[key], ...value };
+    else if (value !== undefined) result[key] = value;
+  }
+  return result;
+}
+
+function normalizeDefinitions(value) {
+  if (Array.isArray(value)) {
+    return Object.fromEntries(value
+      .filter(item => item && typeof item === 'object' && item.id)
+      .map(item => [String(item.id), item]));
+  }
+  return isPlainObject(value) ? value : {};
+}
+
+function buildResolvedModelSettings(definitions, overrides) {
+  const ids = new Set([
+    ...Object.keys(MODEL_METADATA),
+    ...Object.keys(overrides || {}),
+    ...Object.keys(definitions || {})
+  ]);
+  const resolvedModels = {};
+  const provenance = {};
+  const warnings = {};
+  for (const id of ids) {
+    const stored = definitions[id] || {
+      id,
+      metadataMode: 'hybrid',
+      overrides: overrides[id] || {}
+    };
+    const resolved = resolveModelDefinition(stored, { builtin: MODEL_METADATA[id] || {} });
+    resolvedModels[id] = resolved.spec;
+    provenance[id] = resolved.provenance;
+    if (resolved.warnings.length > 0) warnings[id] = resolved.warnings;
+  }
+  return { resolvedModels, provenance, warnings };
+}
 
 function handleGetModelSettings(req, res) {
   try {
     const config = loadConfig();
     const overrides = config.modelMetadataOverrides || {};
+    const definitions = normalizeDefinitions(config.modelDefinitions);
     const defaultSpeedTestModels = getDefaultSpeedTestModels();
 
     // Build merged table: built-in + user overrides
     const merged = {};
     for (const [id, meta] of Object.entries(MODEL_METADATA)) {
       merged[id] = overrides[id]
-        ? {
-          limit: { ...meta.limit, ...(overrides[id].limit || {}) },
-          pricing: { ...meta.pricing, ...(overrides[id].pricing || {}) }
-        }
+        ? mergeMetadata(meta, overrides[id])
         : meta;
     }
 
@@ -32,9 +79,16 @@ function handleGetModelSettings(req, res) {
       }
     }
 
+    const resolved = buildResolvedModelSettings(definitions, overrides);
     res.json({
-      models: merged,
-      overrides,
+      schemaVersion: MODEL_SCHEMA_VERSION,
+      fieldSchema: getPublicModelFieldSchema(),
+      models: redactSensitiveFields(merged),
+      overrides: redactSensitiveFields(overrides),
+      definitions: redactSensitiveFields(definitions),
+      resolvedModels: redactSensitiveFields(resolved.resolvedModels),
+      provenance: resolved.provenance,
+      warnings: resolved.warnings,
       builtinModelIds: Object.keys(MODEL_METADATA),
       lastUpdated: METADATA_LAST_UPDATED,
       defaultSpeedTestModels
@@ -52,7 +106,7 @@ router.get('/model-metadata', handleGetModelSettings);
 
 function handleSaveModelSettings(req, res) {
   try {
-    const { overrides, defaultSpeedTestModels } = req.body || {};
+    const { overrides, definitions, defaultSpeedTestModels } = req.body || {};
     if (overrides !== undefined && (typeof overrides !== 'object' || overrides === null || Array.isArray(overrides))) {
       return res.status(400).json({ error: 'overrides must be an object' });
     }
@@ -63,6 +117,9 @@ function handleSaveModelSettings(req, res) {
         if (typeof modelId !== 'string' || !modelId.trim()) {
           return res.status(400).json({ error: `Invalid model ID: "${modelId}"` });
         }
+        if (!isPlainObject(meta)) {
+          return res.status(400).json({ error: `${modelId}: metadata must be an object` });
+        }
         if (meta.limit !== undefined) {
           if (typeof meta.limit !== 'object') {
             return res.status(400).json({ error: `${modelId}: limit must be an object` });
@@ -87,19 +144,46 @@ function handleSaveModelSettings(req, res) {
       }
     }
 
+    if (definitions !== undefined && !Array.isArray(definitions) && !isPlainObject(definitions)) {
+      return res.status(400).json({ error: 'definitions must be an object or array' });
+    }
+    if (Array.isArray(definitions)) {
+      const validation = validateModelDefinitions(definitions);
+      if (!validation.valid) {
+        return res.status(400).json({ error: validation.error });
+      }
+    }
+    const normalizedDefinitions = definitions === undefined ? undefined : normalizeDefinitions(definitions);
+    if (normalizedDefinitions) {
+      const definitionList = Object.entries(normalizedDefinitions).map(([id, definition]) => ({
+        ...(isPlainObject(definition) ? definition : {}),
+        id: isPlainObject(definition) && definition.id ? definition.id : id
+      }));
+      const validation = validateModelDefinitions(definitionList);
+      if (!validation.valid) {
+        return res.status(400).json({ error: validation.error });
+      }
+    }
+
     const config = loadConfig();
     const newConfig = {
       ...config,
       modelMetadataOverrides: overrides && typeof overrides === 'object'
         ? overrides
-        : (config.modelMetadataOverrides || {})
+        : (config.modelMetadataOverrides || {}),
+      modelDefinitions: normalizedDefinitions === undefined
+        ? (config.modelDefinitions || {})
+        : normalizedDefinitions,
+      modelMetadataSchemaVersion: MODEL_SCHEMA_VERSION
     };
     saveConfig(newConfig);
     const persistedDefaultSpeedTestModels = saveDefaultSpeedTestModels(defaultSpeedTestModels);
 
     res.json({
       success: true,
-      overrides: newConfig.modelMetadataOverrides,
+      schemaVersion: MODEL_SCHEMA_VERSION,
+      overrides: redactSensitiveFields(newConfig.modelMetadataOverrides),
+      definitions: redactSensitiveFields(newConfig.modelDefinitions),
       defaultSpeedTestModels: persistedDefaultSpeedTestModels
     });
   } catch (error) {