@mokuyoaxis/dsh-iris 0.1.3 → 0.2.0

package/lib/config.js

@@ -10,7 +10,15 @@ import os from 'node:os';
 import * as cap from './capability.js';
 import * as models from './models.js';
 import { atomicWritePrivate, chmodPrivateFile, privateSibling } from './private-storage.js';
-import { inferMediaProtocol } from './provider-protocol.js';
+import { selectMediaProtocol, isConfiguredProvider } from './provider-protocol.js';
+import { redactProviderMessage } from './provider-contract.js';
+import {
+  PROVIDER_HEALTH_FRESH_MS,
+  aggregateHealthStates,
+  healthObservationState,
+  isDefinitiveHealthFailure,
+  newestHealthEvidence
+} from './provider-health.js';
 
 function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -24,6 +32,7 @@ function validateStoredConfig(value) {
     if (!isPlainObject(provider)) throw new Error('provider 条目必须是对象');
     if (provider.id !== undefined && typeof provider.id !== 'string') throw new Error('provider.id 必须是字符串');
     if (provider.baseUrl !== undefined && typeof provider.baseUrl !== 'string') throw new Error('provider.baseUrl 必须是字符串');
+    if (provider.mediaBaseUrl !== undefined && typeof provider.mediaBaseUrl !== 'string') throw new Error('provider.mediaBaseUrl 必须是字符串');
     if (provider.apiKey !== undefined && typeof provider.apiKey !== 'string') throw new Error('provider.apiKey 必须是字符串');
     if (provider.models !== undefined && !Array.isArray(provider.models)) throw new Error('provider.models 必须是数组');
     for (const model of provider.models || []) {
@@ -35,10 +44,27 @@ function validateStoredConfig(value) {
   }
 }
 
+/**
+ * 供应商认证方式：'bearer'（默认，需要 apiKey）或 'none'（本地/内网无鉴权端点）。
+ * T-01：解除 ComfyUI、Ollama、本地 TTS 等本地部署的硬编码阻塞（审计 C-1）。
+ * 无 auth 字段时一律视为 'bearer'——现有用户行为完全不变。
+ */
+function authModeOf(provider) {
+  return provider && provider.auth === 'none' ? 'none' : 'bearer';
+}
+
+/** 该供应商是否缺少必需凭据（'none' 认证永不缺）。 */
+function missingCredentials(provider) {
+  if (!provider || authModeOf(provider) === 'none') return false;
+  return typeof provider.apiKey !== 'string' || !provider.apiKey.trim();
+}
+
 function normalizeStoredProvider(provider) {
-  if (provider.mediaProtocol === 'dashscope' || provider.mediaProtocol === 'openai-images') return false;
-  provider.mediaProtocol = inferMediaProtocol(provider.baseUrl);
-  return true;
+  const selected = selectMediaProtocol(provider);
+  const changed = provider.mediaProtocol !== selected.mediaProtocol
+    || (provider.protocolInferred === true) !== selected.protocolInferred;
+  Object.assign(provider, selected);
+  return models.migrateProviderModels(provider) || changed;
 }
 
 export function irisHome() {
@@ -126,15 +152,17 @@ export function importFromWorkbench(workbenchConfigPath) {
   for (const p of list) {
     if (!p || typeof p.apiKey !== 'string' || !p.apiKey.trim() ||
         typeof p.baseUrl !== 'string' || !p.baseUrl.trim()) continue;
-    c.providers.push({
+    const imported = {
       id: 'iris_' + Math.random().toString(36).slice(2, 8),
       name: p.name || p.id,
-      type: p.type === 'anthropic' ? 'anthropic' : 'openai',
+      type: typeof p.type === 'string' && p.type.trim() ? p.type.trim() : 'openai',
       baseUrl: p.baseUrl,
       apiKey: p.apiKey,
       enabled: p.enabled !== false,
-      mediaProtocol: inferMediaProtocol(p.baseUrl)
-    });
+      mediaProtocol: p.mediaProtocol
+    };
+    normalizeStoredProvider(imported);
+    c.providers.push(imported);
     n++;
   }
   if (n) persist();
@@ -142,7 +170,7 @@ export function importFromWorkbench(workbenchConfigPath) {
 }
 
 export function providers() {
-  return load().providers.filter((p) => p.enabled && p.apiKey);
+  return load().providers.filter(isConfiguredProvider);
 }
 
 export function providerById(id) {
@@ -181,16 +209,7 @@ export function pickFor(capability) {
  */
 export function pickAllFor(capability) {
   const pool = models.modelPool(providers());
-  const chosen = [];
-  const seen = new Set();
-  const add = (m) => {
-    const k = m.providerId + '\u0000' + m.id;
-    if (!seen.has(k)) { seen.add(k); chosen.push(m); }
-  };
-  for (const ref of assignmentOrder(capability)) {
-    for (const m of pool) if (m.ref === ref && m.capabilities.includes(capability)) add(m);
-  }
-  for (const m of pool) if (m.capabilities.includes(capability)) add(m);
+  const chosen = models.orderedModels(pool, capability, assignments()[capability]);
   const out = [];
   for (const m of chosen) {
     const p = providerById(m.providerId);
@@ -206,21 +225,7 @@ export function assignments() {
   return load().assignments || {};
 }
 
-function resolveAssignment(pool, raw, capability) {
-  let providerId = '';
-  let modelId = '';
-  if (raw && typeof raw === 'object') {
-    providerId = String(raw.providerId || '');
-    modelId = String(raw.modelId || raw.id || '');
-  } else if (typeof raw === 'string') {
-    const parsed = models.parseModelRef(raw);
-    if (parsed) ({ providerId, modelId } = parsed);
-    else modelId = raw; // v1 旧格式：纯 model id，按池顺序取第一个
-  }
-  return pool.find((m) => m.id === modelId
-    && (!providerId || m.providerId === providerId)
-    && m.capabilities.includes(capability)) || null;
-}
+const resolveAssignment = models.resolvePoolModel;
 
 /** 归一化某能力的有序分配列表 → [providerId::modelId, ...]。 */
 export function assignmentOrder(capability) {
@@ -293,6 +298,163 @@ export function capabilitiesOf(p) {
   return [...caps];
 }
 
+const HEALTH_SENSITIVE_FIELDS = new Set([
+  'auth', 'type', 'baseUrl', 'mediaBaseUrl', 'apiKey', 'mediaProtocol',
+  'imageModel', 'videoModel', 'ttsModel', 'transcribeModel', 'visionModel'
+]);
+
+function healthContainer(provider) {
+  const current = provider.health;
+  if (current && current.version === 1 && Number.isSafeInteger(current.revision)
+      && Array.isArray(current.observations)) return current;
+  const revision = Number.isSafeInteger(current && current.revision) ? current.revision : 0;
+  provider.health = { version: 1, revision, observations: [] };
+  return provider.health;
+}
+
+function healthObservation(provider, modelId, capability) {
+  const health = provider && provider.health;
+  if (!health || health.version !== 1 || !Array.isArray(health.observations)) return null;
+  return health.observations.find((item) => item && item.modelId === modelId
+    && item.capability === capability) || null;
+}
+
+function safeHealthNote(provider, value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return '';
+  let note = redactProviderMessage(raw, 200);
+  const key = String(provider && provider.apiKey || '');
+  if (key) note = note.split(key).join('[REDACTED]');
+  return note;
+}
+
+function observationEvidence(provider, result, fallbackSource) {
+  const atMs = Date.parse(String(result && result.at || ''));
+  const status = Number(result && (result.httpStatus ?? result.status));
+  const note = safeHealthNote(provider, result && (result.note || result.safeMessage || result.message));
+  return {
+    at: new Date(Number.isFinite(atMs) ? atMs : Date.now()).toISOString(),
+    source: ['probe', 'task'].includes(result && result.source) ? result.source : fallbackSource,
+    category: String(result && result.category || (result && result.ok ? 'success' : 'unknown')).slice(0, 40),
+    ...(Number.isInteger(status) && status >= 100 && status <= 599 ? { httpStatus: status } : {}),
+    ...(note ? { note } : {})
+  };
+}
+
+function applyProviderHealth(provider, modelId, capability, result, fallbackSource = 'task') {
+  const model = String(modelId || '').trim();
+  if (!provider || !model || !cap.isKnownCapability(capability)) return false;
+  const health = healthContainer(provider);
+  let observation = health.observations.find((item) => item && item.modelId === model
+    && item.capability === capability);
+  if (!observation) {
+    observation = { modelId: model, capability };
+    health.observations.push(observation);
+  }
+  const evidence = observationEvidence(provider, result || {}, fallbackSource);
+  if (result && result.ok === true) {
+    observation.lastSuccess = evidence;
+  } else if (isDefinitiveHealthFailure({ ...result, ...evidence })) {
+    observation.lastFailure = evidence;
+  } else {
+    observation.lastTransient = evidence;
+  }
+  return true;
+}
+
+function pruneHealthToEffectiveModels(provider) {
+  if (!provider) return;
+  const allowedByModel = new Map();
+  for (const entry of models.providerModels(provider)) {
+    allowedByModel.set(entry.id, new Set(entry.capabilities));
+  }
+  if (provider.health && Array.isArray(provider.health.observations)) {
+    provider.health.observations = provider.health.observations.filter((item) =>
+      item && allowedByModel.get(item.modelId)?.has(item.capability));
+  }
+  for (const entry of provider.models || []) {
+    if (!entry || typeof entry !== 'object' || !entry.verified || typeof entry.verified !== 'object') continue;
+    const allowed = allowedByModel.get(entry.id) || new Set();
+    entry.verified = Object.fromEntries(Object.entries(entry.verified).filter(([capability]) => allowed.has(capability)));
+    if (!Object.keys(entry.verified).length) delete entry.verified;
+  }
+}
+
+function pruneModelHealth(provider, modelId) {
+  if (!provider || !provider.health || !Array.isArray(provider.health.observations)) return;
+  provider.health.observations = provider.health.observations.filter((item) => item.modelId !== modelId);
+}
+
+function resetHealthOnCriticalChange(previous, next, patch) {
+  const changed = [...HEALTH_SENSITIVE_FIELDS].some((key) =>
+    Object.prototype.hasOwnProperty.call(patch, key) && previous[key] !== next[key]);
+  if (!changed) return;
+  const current = previous.health;
+  const revision = Number.isSafeInteger(current && current.revision) ? current.revision + 1 : 1;
+  next.health = { version: 1, revision, observations: [] };
+}
+
+/** 记录一次显式实测或真实任务观察；临时错误不会覆盖近期成功。 */
+export function recordProviderHealth(id, modelId, capability, result) {
+  const c = load();
+  const provider = c.providers.find((item) => item.id === id);
+  if (!provider || !applyProviderHealth(provider, modelId, capability, result, result && result.source || 'task')) {
+    return false;
+  }
+  persist();
+  return true;
+}
+
+/** 返回单个 Provider × Model × Capability 的安全状态。 */
+export function modelHealth(id, modelId, capability, { now = Date.now() } = {}) {
+  const provider = load().providers.find((item) => item.id === id);
+  if (!provider || provider.enabled === false || missingCredentials(provider)) return { status: 'unconfigured' };
+  const observation = healthObservation(provider, modelId, capability);
+  const status = healthObservationState(observation, { now });
+  const evidence = status === 'verified'
+    ? observation && observation.lastSuccess
+    : (status === 'failed' ? observation && observation.lastFailure : newestHealthEvidence(observation));
+  return {
+    status,
+    ...(evidence ? {
+      observedAt: evidence.at,
+      source: evidence.source,
+      category: evidence.category,
+      ...(evidence.httpStatus ? { httpStatus: evidence.httpStatus } : {}),
+      ...(evidence.note ? { note: evidence.note } : {})
+    } : {})
+  };
+}
+
+/** 当前有序 failover 路径的健康快照；只含脱敏标量，不触发网络。 */
+export function providerHealthSnapshot({ now = Date.now() } = {}) {
+  const capabilities = {};
+  for (const capability of Object.values(cap.CAPABILITIES)) {
+    const candidates = pickAllFor(capability).map((provider) => {
+      const modelId = String(provider[FIELD_OF[capability]] || '');
+      const health = modelHealth(provider.id, modelId, capability, { now });
+      return { providerId: provider.id, modelId, ...health };
+    });
+    const status = aggregateHealthStates(candidates.map((item) => item.status));
+    const newest = [...candidates]
+      .filter((item) => item.status === status && item.observedAt)
+      .sort((a, b) => String(b.observedAt).localeCompare(String(a.observedAt)))[0];
+    capabilities[capability] = {
+      status,
+      candidateCount: candidates.length,
+      ...(newest ? { observedAt: newest.observedAt } : {}),
+      candidates
+    };
+  }
+  return {
+    schemaVersion: 1,
+    freshForMs: PROVIDER_HEALTH_FRESH_MS,
+    generatedAt: new Date(Number(now)).toISOString(),
+    overall: aggregateHealthStates(Object.values(capabilities).map((item) => item.status)),
+    capabilities
+  };
+}
+
 export function upsert(provider) {
   const c = load();
   const { id, ...input } = provider;
@@ -301,15 +463,19 @@ export function upsert(provider) {
   if (id) {
     const i = c.providers.findIndex((p) => p.id === id);
     if (i >= 0) {
-      if (rest.mediaProtocol === 'auto') rest.mediaProtocol = inferMediaProtocol(rest.baseUrl ?? c.providers[i].baseUrl);
-      c.providers[i] = { ...c.providers[i], ...rest };
-      normalizeStoredProvider(c.providers[i]);
+      const previous = c.providers[i];
+      const next = { ...previous, ...rest };
+      if (Object.prototype.hasOwnProperty.call(rest, 'mediaProtocol')) next.protocolInferred = false;
+      normalizeStoredProvider(next);
+      resetHealthOnCriticalChange(previous, next, rest);
+      if (Object.prototype.hasOwnProperty.call(rest, 'models')) pruneHealthToEffectiveModels(next);
+      c.providers[i] = next;
       persist();
-      return c.providers[i];
+      return next;
     }
   }
   const fresh = { id: 'iris_' + Math.random().toString(36).slice(2, 8), ...rest };
-  if (fresh.mediaProtocol === 'auto') delete fresh.mediaProtocol;
+  fresh.protocolInferred = false;
   normalizeStoredProvider(fresh);
   c.providers.push(fresh);
   persist();
@@ -331,31 +497,46 @@ export function removeProvider(id) {
   return true;
 }
 
-/** 设置一个供应商的模型池（覆盖显式 models 数组；空数组 = 回退到自动发现/旧字段） */
+/** 显式替换模型池；空数组表示没有可用模型。发现使用合并入口。 */
 export function setProviderModels(id, modelEntries) {
   const c = load();
   const p = c.providers.find((x) => x.id === id);
   if (!p) return null;
   if (Array.isArray(modelEntries)) {
-    // 保留同名模型已有的 verified/source（重新发现不丢实测结果）
-    const prev = {};
-    for (const m of p.models || []) if (m && m.id) prev[m.id] = m;
+    // 保留同名模型的实测结果；手工能力标注优先于后续自动发现。
+    const prev = new Map();
+    for (const m of p.models || []) if (m && m.id) prev.set(m.id, m);
     p.models = modelEntries.map((m) => {
       const entry = typeof m === 'string' ? { id: m } : { id: m.id, capabilities: m.capabilities };
-      const old = prev[entry.id];
+      const old = prev.get(entry.id);
       if (old) {
         if (old.verified) entry.verified = old.verified;
         if (old.source) entry.source = old.source;
+        if (old.source === 'manual' && Array.isArray(old.capabilities)) entry.capabilities = old.capabilities;
       }
       if (m && m.verified) entry.verified = m.verified;
       if (m && m.source) entry.source = m.source;
       return entry;
     });
   }
+  pruneHealthToEffectiveModels(p);
   persist();
   return p;
 }
 
+/** 发现只追加或更新；用户手工项和未再返回的旧项始终保留。 */
+export function mergeDiscoveredModels(id, modelEntries) {
+  const provider = load().providers.find((p) => p.id === id);
+  if (!provider) return null;
+  const merged = new Map(models.providerModels(provider).map((m) => [m.id, m]));
+  for (const model of modelEntries) {
+    const previous = merged.get(model.id);
+    if (previous?.source === 'manual') continue;
+    merged.set(model.id, { ...previous, ...model, source: 'discovered' });
+  }
+  return setProviderModels(id, [...merged.values()]);
+}
+
 /** 找 provider 里的某个模型条目（可变引用） */
 function findModelEntry(p, modelId) {
   return (p.models || []).find((m) => m && m.id === modelId);
@@ -376,6 +557,8 @@ export function addProviderModel(id, modelId, capabilities) {
   } else if (Array.isArray(capabilities)) {
     entry.capabilities = capabilities;
   }
+  entry.source = 'manual';
+  pruneHealthToEffectiveModels(p);
   persist();
   return entry;
 }
@@ -388,6 +571,7 @@ export function removeProviderModel(id, modelId) {
   const i = p.models.findIndex((m) => m && m.id === modelId);
   if (i < 0) return false;
   p.models.splice(i, 1);
+  pruneModelHealth(p, modelId);
   persist();
   return true;
 }
@@ -399,20 +583,32 @@ export function setModelCapabilities(id, modelId, capabilities) {
   if (!p) return false;
   const entry = findModelEntry(p, modelId);
   if (!entry) return false;
-  entry.capabilities = (Array.isArray(capabilities) ? capabilities : []).filter((x) => cap.isKnownCapability(x));
+  const nextCapabilities = (Array.isArray(capabilities) ? capabilities : []).filter((x) => cap.isKnownCapability(x));
+  entry.capabilities = nextCapabilities;
+  entry.source = 'manual';
+  pruneHealthToEffectiveModels(p);
   persist();
   return true;
 }
 
-/** 记录某模型的实测结果（verified[capability] = {ok, at, note}） */
+/** 记录某模型的显式实测结果，并同步到新健康事实。 */
 export function setModelVerified(id, modelId, capability, result) {
   const c = load();
   const p = c.providers.find((x) => x.id === id);
   if (!p) return false;
   const entry = findModelEntry(p, modelId);
-  if (!entry) return false;
-  if (!entry.verified) entry.verified = {};
-  entry.verified[capability] = { ok: !!result.ok, at: new Date().toISOString(), note: String(result.note || '').slice(0, 200) };
+  const at = new Date().toISOString();
+  if (entry) {
+    if (!entry.verified) entry.verified = {};
+    entry.verified[capability] = {
+      ok: !!result.ok,
+      at,
+      note: safeHealthNote(p, result.note || ''),
+      source: 'probe',
+      category: String(result.category || (result.ok ? 'success' : 'unknown')).slice(0, 40)
+    };
+  }
+  applyProviderHealth(p, modelId, capability, { ...result, at, source: 'probe' }, 'probe');
   persist();
   return true;
 }