@mokuyoaxis/dsh-iris 0.1.4 → 0.2.1

package/lib/config.js

@@ -1,4 +1,5 @@
 'use strict';
+import { normalizeVisionInputLimits } from './vision-image-input.js';
 /**
  * Iris 配置存储：$DSH_HOME/iris/v1/providers.json
  * Iris 独立持有配置；旧工作台仅作为用户显式指定的一次性导入来源。
@@ -10,14 +11,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, selectImageProtocol, normalizeImageProtocol, isConfiguredProvider } from './provider-protocol.js';
 import { redactProviderMessage } from './provider-contract.js';
 import {
   PROVIDER_HEALTH_FRESH_MS,
   aggregateHealthStates,
   healthObservationState,
   isDefinitiveHealthFailure,
-  newestHealthEvidence
+  newestHealthEvidence,
+  modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth
 } from './provider-health.js';
 
 function isPlainObject(value) {
@@ -32,6 +34,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 || []) {
@@ -43,10 +46,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() {
@@ -134,15 +154,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();
@@ -150,7 +172,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) {
@@ -171,7 +193,7 @@ export function pickFor(capability) {
   const pool = models.modelPool(providers());
   let m = null;
   for (const ref of assignmentOrder(capability)) {
-    m = pool.find((x) => x.ref === ref && x.capabilities.includes(capability));
+    m = pool.find((x) => !x.rateLimited && x.ref === ref && x.capabilities.includes(capability));
     if (m) break;
   }
   if (!m) m = models.pickModel(pool, capability);
@@ -187,18 +209,9 @@ export function pickFor(capability) {
  * 已分配顺序优先（阶段 6 条目 4），其余按池顺序补齐（去重）。
  * 一个 provider 若池里有多个该能力模型，会返回多条（各自带不同模型）。
  */
-export function pickAllFor(capability) {
+export function pickAllFor(capability, { includeRateLimited = false } = {}) {
   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], { includeRateLimited });
   const out = [];
   for (const m of chosen) {
     const p = providerById(m.providerId);
@@ -214,21 +227,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) {
@@ -302,7 +301,7 @@ export function capabilitiesOf(p) {
 }
 
 const HEALTH_SENSITIVE_FIELDS = new Set([
-  'type', 'baseUrl', 'apiKey', 'mediaProtocol',
+  'auth', 'type', 'baseUrl', 'mediaBaseUrl', 'apiKey', 'mediaProtocol',
   'imageModel', 'videoModel', 'ttsModel', 'transcribeModel', 'visionModel'
 ]);
 
@@ -355,8 +354,10 @@ function applyProviderHealth(provider, modelId, capability, result, fallbackSour
     health.observations.push(observation);
   }
   const evidence = observationEvidence(provider, result || {}, fallbackSource);
+  recordModelRateLimit(provider, model, { ...evidence, retryAfterMs: result?.retryAfterMs, until: result?.until, reason: result?.reason });
   if (result && result.ok === true) {
     observation.lastSuccess = evidence;
+    if (evidence.source === 'probe') clearModelRateLimit(provider, model);
   } else if (isDefinitiveHealthFailure({ ...result, ...evidence })) {
     observation.lastFailure = evidence;
   } else {
@@ -394,10 +395,11 @@ function resetHealthOnCriticalChange(previous, next, patch) {
   if (!changed) return;
   const current = previous.health;
   const revision = Number.isSafeInteger(current && current.revision) ? current.revision + 1 : 1;
-  next.health = { version: 1, revision, observations: [] };
+  next.health = { version: 1, revision, observations: [],
+    ...(current?.rateLimits?.length ? { rateLimits: current.rateLimits } : {}) };
 }
 
-/** 记录一次显式实测或真实任务观察；临时错误不会覆盖近期成功。 */
+/** 记录显式实测或真实任务观察；限流资格另存，保留原成功事实。 */
 export function recordProviderHealth(id, modelId, capability, result) {
   const c = load();
   const provider = c.providers.find((item) => item.id === id);
@@ -408,10 +410,24 @@ export function recordProviderHealth(id, modelId, capability, result) {
   return true;
 }
 
+/** DSH 调用边界记录冷却或明确耗尽；覆盖同账号该模型的所有能力。 */
+export function recordRateLimit({ providerId, modelId, capability, httpStatus = 429, category = 'rate_limit', at, until, retryAfterMs, reason }) {
+  const known = { image: 'image-gen', video: 'video-gen' }[capability] || capability;
+  return recordProviderHealth(providerId, modelId, known, {
+    ok: false, source: 'task', category, httpStatus, at, until, retryAfterMs, reason,
+    note: category === 'quota' ? '额度或预算耗尽后已停用，手动实测成功后恢复' : '429 限流冷却，暂时跳过'
+  });
+}
+
 /** 返回单个 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 || !provider.apiKey) return { status: 'unconfigured' };
+  if (!provider || provider.enabled === false || missingCredentials(provider)) return { status: 'unconfigured' };
+  const blocked = modelRateLimit(provider, modelId, { now });
+  if (blocked) return { status: 'failed', rateLimited: true, observedAt: blocked.at,
+    source: blocked.source, category: blocked.category, httpStatus: blocked.httpStatus,
+    ...(blocked.until ? { retryAt: blocked.until } : { reason: blocked.reason }),
+    note: blocked.until ? '429 限流冷却，暂时跳过' : '额度或预算耗尽后已停用，手动实测成功后恢复' };
   const observation = healthObservation(provider, modelId, capability);
   const status = healthObservationState(observation, { now });
   const evidence = status === 'verified'
@@ -433,7 +449,7 @@ export function modelHealth(id, modelId, capability, { now = Date.now() } = {})
 export function providerHealthSnapshot({ now = Date.now() } = {}) {
   const capabilities = {};
   for (const capability of Object.values(cap.CAPABILITIES)) {
-    const candidates = pickAllFor(capability).map((provider) => {
+    const candidates = pickAllFor(capability, { includeRateLimited: true }).map((provider) => {
       const modelId = String(provider[FIELD_OF[capability]] || '');
       const health = modelHealth(provider.id, modelId, capability, { now });
       return { providerId: provider.id, modelId, ...health };
@@ -446,14 +462,21 @@ export function providerHealthSnapshot({ now = Date.now() } = {}) {
       status,
       candidateCount: candidates.length,
       ...(newest ? { observedAt: newest.observedAt } : {}),
+      ...(status === 'failed' && candidates.every(item => item.retryAt) ? {
+        rateLimited: true, retryAt: candidates.map(item => item.retryAt).sort()[0]
+      } : {}),
       candidates
     };
   }
+  const overall = aggregateHealthStates(Object.values(capabilities).map((item) => item.status));
+  const configured = Object.values(capabilities).filter(item => item.status !== 'unconfigured');
   return {
     schemaVersion: 1,
     freshForMs: PROVIDER_HEALTH_FRESH_MS,
     generatedAt: new Date(Number(now)).toISOString(),
-    overall: aggregateHealthStates(Object.values(capabilities).map((item) => item.status)),
+    overall,
+    ...(overall === 'failed' && configured.every(item => item.retryAt)
+      ? { retryAt: configured.map(item => item.retryAt).sort()[0] } : {}),
     capabilities
   };
 }
@@ -463,14 +486,19 @@ export function upsert(provider) {
   const { id, ...input } = provider;
   // PATCH 语义：缺失字段和 undefined 都不覆盖旧值；null/空串仍是显式更新。
   const rest = Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+  if (rest.visionInput !== undefined) rest.visionInput = normalizeVisionInputLimits(rest.visionInput) || null;
+  if (Array.isArray(rest.models)) rest.models = rest.models.map(model => typeof model === 'string' ? model : ({ ...model,
+    ...(model?.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(model.imageProtocol) } : {}),
+    ...(model?.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(model.visionInput) || null } : {}) }));
   if (id) {
     const i = c.providers.findIndex((p) => p.id === id);
     if (i >= 0) {
       const previous = c.providers[i];
-      if (rest.mediaProtocol === 'auto') rest.mediaProtocol = inferMediaProtocol(rest.baseUrl ?? previous.baseUrl);
       const next = { ...previous, ...rest };
+      if (Object.prototype.hasOwnProperty.call(rest, 'mediaProtocol')) next.protocolInferred = false;
       normalizeStoredProvider(next);
       resetHealthOnCriticalChange(previous, next, rest);
+      resetChangedImageProtocolHealth(previous, next);
       if (Object.prototype.hasOwnProperty.call(rest, 'models')) pruneHealthToEffectiveModels(next);
       c.providers[i] = next;
       persist();
@@ -478,7 +506,7 @@ export function upsert(provider) {
     }
   }
   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();
@@ -500,37 +528,99 @@ 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;
+  const previous = { ...p };
   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 entry = typeof m === 'string' ? { id: m } : { id: m.id, capabilities: m.capabilities,
+        ...(m.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(m.imageProtocol) } : {}),
+        ...(m.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(m.visionInput) || null } : {}) };
+      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?.imageProtocol === undefined && old.imageProtocol !== undefined) entry.imageProtocol = old.imageProtocol;
+        if (m?.visionInput === undefined && old.visionInput !== undefined) entry.visionInput = old.visionInput;
       }
       if (m && m.verified) entry.verified = m.verified;
       if (m && m.source) entry.source = m.source;
       return entry;
     });
   }
+  resetChangedImageProtocolHealth(previous, p);
   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);
 }
 
+function resetChangedImageProtocolHealth(previous, next) {
+  for (const model of models.providerModels(previous)) {
+    if (selectImageProtocol(previous, model.id).mediaProtocol !== selectImageProtocol(next, model.id).mediaProtocol) {
+      clearModelCapabilityHealth(next, model.id, cap.CAPABILITIES.IMAGE);
+    }
+  }
+}
+
+/** 手动选择单模型图片协议；auto 恢复账号默认，不解除模型停用。 */
+export function setModelImageProtocol(id, modelId, value) {
+  const protocol = normalizeImageProtocol(value);
+  const p = load().providers.find(provider => provider.id === id);
+  if (!p) return false;
+  const entries = Array.isArray(p.models) ? p.models : models.providerModels(p).map(({ id, capabilities }) => ({ id, capabilities }));
+  const index = entries.findIndex(model => (typeof model === 'string' ? model : model?.id)?.trim() === modelId);
+  if (index < 0) return false;
+  p.models = entries;
+  const entry = typeof p.models[index] === 'string' ? { id: p.models[index] } : p.models[index];
+  p.models[index] = entry;
+  const previous = selectImageProtocol(p, modelId).mediaProtocol;
+  if (protocol === 'auto') delete entry.imageProtocol;
+  else entry.imageProtocol = protocol;
+  if (previous !== selectImageProtocol(p, modelId).mediaProtocol) clearModelCapabilityHealth(p, modelId, cap.CAPABILITIES.IMAGE);
+  persist();
+  return true;
+}
+
+/** 看图预算变更不会伪造实测成功、解除额度停用或改写原图。 */
+export function setModelVisionInput(id, modelId, value) {
+  const limits = normalizeVisionInputLimits(value);
+  const p = load().providers.find(provider => provider.id === id);
+  if (!p) return false;
+  const entries = (Array.isArray(p.models) ? p.models : models.providerModels(p)).map(model => typeof model === 'string' ? { id: model } : { ...model });
+  const entry = entries.find(model => model.id === modelId);
+  if (!entry) return false;
+  if (limits) entry.visionInput = limits;
+  else delete entry.visionInput;
+  p.models = entries;
+  persist();
+  return true;
+}
+
 /** 手动添加一个模型到池（source=manual，能力由调用方给） */
 export function addProviderModel(id, modelId, capabilities) {
   const c = load();
@@ -546,6 +636,7 @@ export function addProviderModel(id, modelId, capabilities) {
   } else if (Array.isArray(capabilities)) {
     entry.capabilities = capabilities;
   }
+  entry.source = 'manual';
   pruneHealthToEffectiveModels(p);
   persist();
   return entry;
@@ -573,6 +664,7 @@ export function setModelCapabilities(id, modelId, capabilities) {
   if (!entry) return false;
   const nextCapabilities = (Array.isArray(capabilities) ? capabilities : []).filter((x) => cap.isKnownCapability(x));
   entry.capabilities = nextCapabilities;
+  entry.source = 'manual';
   pruneHealthToEffectiveModels(p);
   persist();
   return true;