dsh-model-groups 0.3.9 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-model-groups",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "在 DSH 网页端按供应商和密钥配置选择模型，并为同一供应商的不同密钥分别设置模型和 API 协议。支持 DSH 0.2.2-rc.1。",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,7 @@
     "README.md",
     "CHANGELOG.md",
     "docs/maintenance.md",
+    "docs/capabilities-beta.md",
     "docs/images/*.webp",
     "LICENSE"
   ],

package/scripts/settings-capabilities.mjs

@@ -0,0 +1,37 @@
+import { applyModelCapabilities, validateCapabilityBatch, applyModelBatchCapabilities, materializeCapabilityEntry, applyCapabilityBatch, mergeCapabilityModels } from '../src/capability-defaults.js';
+
+// Embedded into the verified host bundle. These functions modify drafts only.
+export function GroupCapabilityBatch({ entry, onChange, disabled, t }) {
+  const migrated = materializeCapabilityEntry(entry);
+  const jsx = react_jsx_runtime.jsx, jsxs = react_jsx_runtime.jsxs;
+  const css = ModelsSection_module_css_default;
+  return jsxs('div', { 'data-group-capabilities': true, className: css.field, children: ['vision', 'reasoning'].map(key => jsxs('div', {
+    className: css.modelReasoningHead,
+    children: [jsx('span', { className: css.fieldLabel, children: t(key === 'vision' ? 'capabilityVision' : 'capabilityReasoning') }), jsx(_deepseek_ai_dsh_client_ui_primitives.Switch, {
+      'data-capability-batch': key, label: t(key === 'vision' ? 'capabilityVision' : 'capabilityReasoning'), checked: migrated.capabilityBatch?.[key] === true, disabled,
+      onChange: enabled => { if (!disabled && typeof enabled === 'boolean') onChange(applyCapabilityBatch(entry, key, enabled)); }
+    })]
+  }, key)) });
+}
+
+export function addSettingsCapabilities(initial, apply) {
+  let source = initial;
+  const replace = (before, after) => { if (source.split(before).length !== 2) throw new Error('Expected unique capability batch anchor: ' + before.slice(0, 120)); apply(before, after); source = source.replace(before, after); };
+  const helpers = [applyModelCapabilities, validateCapabilityBatch, applyModelBatchCapabilities, materializeCapabilityEntry, applyCapabilityBatch, mergeCapabilityModels, GroupCapabilityBatch].map(fn => fn.toString()).join('\n');
+  replace('const MULTI_KEY_PROTOCOLS =', helpers + '\n\t\tconst MULTI_KEY_PROTOCOLS =');
+  replace('JSON.stringify(entry) !== JSON.stringify(saved)', 'JSON.stringify(materializeCapabilityEntry(entry)) !== JSON.stringify(materializeCapabilityEntry(saved))');
+  // Normalization materializes old beta policies when the existing save is used.
+  // Rendering retains raw entries for unchanged dirty/saved snapshot comparison.
+  replace('return Object.fromEntries(orderedKeyEntries(entries).map(([id, entry]) => {', 'return Object.fromEntries(orderedKeyEntries(entries).map(([id, rawEntry]) => {\n\t\t\t\tconst entry = materializeCapabilityEntry(rawEntry);');
+  const groupModel = source.indexOf('models: modelDrafts(entry.models), onChange: (models) => update(id, { models }),');
+  const groupStart = source.lastIndexOf('(0, react_jsx_runtime.jsx)(ModelListEditor, {', groupModel);
+  if (groupModel < 0 || groupStart < 0) throw new Error('Missing group model editor batch anchor');
+  const groupBefore = source.slice(groupStart, groupModel);
+  replace(groupBefore + 'models: modelDrafts(entry.models), onChange: (models) => update(id, { models }),',
+    '(0, react_jsx_runtime.jsx)(GroupCapabilityBatch, { entry, t, disabled: disabled || anyBusy, onChange: (next) => { if (!disabled && !anyBusy) onChange({ ...entries, [id]: next }); } }), ' + groupBefore + 'models: modelDrafts(materializeCapabilityEntry(entry).models), onChange: (models) => { if (!disabled && !anyBusy) onChange({ ...entries, [id]: mergeCapabilityModels(entry, models) }); },');
+  for (const [locale, labels] of Object.entries({ en: { capabilityVision: 'Image input', capabilityReasoning: 'Reasoning effort' }, zh: { capabilityVision: '识图', capabilityReasoning: '思考强度' } })) {
+    const text = Object.entries(labels).map(([key, value]) => `\t\t\t${key}: ${JSON.stringify(value)},\n`).join('');
+    replace(`const ${locale} = {\n`, `const ${locale} = {\n${text}`);
+  }
+  return source;
+}

package/src/capability-defaults.js

@@ -0,0 +1,93 @@
+/** Resolve group capability policy without mutating the saved upstream descriptor.
+ * Self-contained so the verified host generators can serialize this function.
+ */
+export function applyModelCapabilities(model, defaults) {
+  const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+  const overrides = model.capabilityOverrides;
+  if (defaults !== undefined && (!object(defaults) || Object.keys(defaults).some(key => key !== 'vision' && key !== 'reasoning') || typeof defaults.vision !== 'boolean' || typeof defaults.reasoning !== 'boolean')) {
+    throw new TypeError('capabilityDefaults must contain only boolean vision and reasoning');
+  }
+  if (overrides !== undefined && (!object(overrides) || Object.keys(overrides).some(key => key !== 'vision' && key !== 'reasoning') || Object.values(overrides).some(value => typeof value !== 'boolean' && value !== 'original'))) {
+    throw new TypeError('capabilityOverrides must contain only boolean or original vision and reasoning');
+  }
+  const { capabilityOverrides: ignored, ...effective } = model;
+  if (defaults === undefined) return effective;
+  const choice = key => overrides?.[key] === 'original' ? undefined : overrides?.[key] ?? defaults[key];
+  const vision = choice('vision');
+  if (vision !== undefined) {
+    const input = Array.isArray(model.input) ? [...model.input] : ['text'];
+    effective.input = [...new Set(input.filter(value => vision || value !== 'image'))];
+    if (effective.input.length === 0) effective.input.push('text');
+    if (vision && !effective.input.includes('image')) effective.input.push('image');
+  }
+  const reasoning = choice('reasoning');
+  if (reasoning === false) effective.reasoningEfforts = false;
+  if (reasoning === true) {
+    const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+    const efforts = model.reasoningEfforts;
+    const valid = object(efforts) && Object.keys(efforts).every(key => levels.includes(key)) && Object.entries(efforts).every(([key, value]) => key === 'off' && value === null || typeof value === 'string' && value.length > 0) && Object.keys(efforts).some(key => key !== 'off');
+    effective.reasoningEfforts = valid ? { ...efforts } : { off: null, low: 'low', medium: 'medium', high: 'high' };
+  }
+  return effective;
+}
+
+export function validateCapabilityDefaults(defaults) {
+  applyModelCapabilities({}, defaults);
+  return defaults;
+}
+
+export function validateCapabilityOverrides(overrides) {
+  applyModelCapabilities({ capabilityOverrides: overrides });
+  return overrides;
+}
+
+/** Last batch selections affect newly introduced models, never runtime overrides. */
+export function validateCapabilityBatch(batch) {
+  if (batch !== undefined && (batch === null || typeof batch !== 'object' || Array.isArray(batch) || Object.keys(batch).some(key => key !== 'vision' && key !== 'reasoning') || Object.values(batch).some(value => typeof value !== 'boolean'))) {
+    throw new TypeError('capabilityBatch must contain only boolean vision and reasoning');
+  }
+  return batch;
+}
+
+export function applyModelBatchCapabilities(model, batch) {
+  validateCapabilityBatch(batch);
+  const original = applyModelCapabilities(model);
+  if (batch === undefined || Object.keys(batch).length === 0) return original;
+  return applyModelCapabilities({ ...original, capabilityOverrides: {
+    ...(batch.vision === undefined ? { vision: 'original' } : {}),
+    ...(batch.reasoning === undefined ? { reasoning: 'original' } : {}),
+  } }, { vision: batch.vision ?? false, reasoning: batch.reasoning ?? false });
+}
+
+/** Upgrade a beta.1 entry in the draft, preserving its actual capabilities. */
+export function materializeCapabilityEntry(entry) {
+  validateCapabilityBatch(entry.capabilityBatch);
+  const { capabilityDefaults, ...rest } = entry;
+  applyModelCapabilities({}, capabilityDefaults);
+  const models = (Array.isArray(entry.models) ? entry.models : []).map(model => applyModelCapabilities(model, capabilityDefaults));
+  const capabilityBatch = capabilityDefaults === undefined ? entry.capabilityBatch : { ...capabilityDefaults, ...entry.capabilityBatch };
+  return { ...rest, models, ...(capabilityBatch === undefined ? {} : { capabilityBatch }) };
+}
+
+export function applyCapabilityBatch(entry, key, enabled) {
+  if (!['vision', 'reasoning'].includes(key) || typeof enabled !== 'boolean') throw new TypeError('capability batch needs vision/reasoning and a boolean');
+  const migrated = materializeCapabilityEntry(entry);
+  return { ...migrated, capabilityBatch: { ...migrated.capabilityBatch, [key]: enabled }, models: migrated.models.map(model => applyModelBatchCapabilities(model, { [key]: enabled })) };
+}
+
+/** Existing incoming rows are edits; only genuinely new IDs inherit batch values. */
+export function mergeCapabilityModels(entry, incoming) {
+  const migrated = materializeCapabilityEntry(entry);
+  const rows = new Map();
+  for (const model of migrated.models) {
+    if (!rows.has(model.id)) rows.set(model.id, []);
+    rows.get(model.id).push(model);
+  }
+  const grows = incoming.length > migrated.models.length;
+  return { ...migrated, models: incoming.map(model => {
+    const previous = rows.get(model.id)?.shift();
+    const nativeOff = migrated.capabilityBatch?.reasoning !== undefined && previous?.reasoningEfforts !== null && typeof previous?.reasoningEfforts === 'object' && !Array.isArray(previous.reasoningEfforts) && model.reasoningEfforts === undefined;
+    const edited = nativeOff ? { ...model, reasoningEfforts: false } : model;
+    return !grows || previous !== undefined ? applyModelCapabilities(edited) : applyModelBatchCapabilities(edited, migrated.capabilityBatch);
+  }) };
+}