@mokuyoaxis/dsh-iris 0.2.4 → 0.2.6

package/lib/composite-vision-routing.js

@@ -8,10 +8,10 @@ import { VISION_BUDGET } from './vision-core.js';
 import { normalizeModelCall } from './model-port-contract.js';
 import { waitForModelWork } from './model-call-runtime.js';
 
-export async function runLocateRequest(host, { providers = [], model, target, image, prepareImage, signal, budget = VISION_BUDGET, onRateLimit }) {
+export async function runLocateRequest(host, { providers = [], model, target, image, prepareImage, signal, budget = VISION_BUDGET, onRateLimit, onModelAvailability }) {
   target = normalizeLocateTarget(target);
   const inputs = new Map();
-  const result = await runVisionOperation(host, { providers, model, signal, budget, onRateLimit, prepareImages: true,
+  const result = await runVisionOperation(host, { providers, model, signal, budget, onRateLimit, onModelAvailability, prepareImages: true,
     orientImages: true, prepareImageRequest: createLocateImageRequest(target, inputs) }, async (ports, operation) => {
     const resolved = await waitForModelWork(() => prepareImage ? prepareImage(operation.signal) : image, operation.signal);
     const source = normalizeModelCall(ports[0].describe(), { prompt: target, image: resolved }, { budget }).request.image;
@@ -23,8 +23,8 @@ export async function runLocateRequest(host, { providers = [], model, target, im
   return location;
 }
 
-export async function runSummaryRequest(host, { providers = [], model, prepareMedia, frames, question, transcript, signal, budget = VISION_BUDGET, onRateLimit }) {
-  return runVisionOperation(host, { providers, model, signal, budget, onRateLimit }, async (ports, operation) => {
+export async function runSummaryRequest(host, { providers = [], model, prepareMedia, frames, question, transcript, signal, budget = VISION_BUDGET, onRateLimit, onModelAvailability }) {
+  return runVisionOperation(host, { providers, model, signal, budget, onRateLimit, onModelAvailability }, async (ports, operation) => {
     const media = await waitForModelWork(() => prepareMedia ? prepareMedia(operation.signal) : { frames, transcript }, operation.signal);
     const completion = await summarizeMedia({ ports, frames: media.frames, question, transcript: media.transcript,
       operation, budget });
@@ -33,9 +33,9 @@ export async function runSummaryRequest(host, { providers = [], model, prepareMe
 }
 
 /** 增强描述沿用共享调用；失败不改变已经完成的媒体交付。 */
-export async function describeGeneratedImage(host, { providers = [], originalPrompt, image, prepareImage, signal, onRateLimit }) {
+export async function describeGeneratedImage(host, { providers = [], originalPrompt, image, prepareImage, signal, onRateLimit, onModelAvailability }) {
   try {
-    const result = await runVisionRequest(host, { providers, image, prepareImage, signal, onRateLimit,
+    const result = await runVisionRequest(host, { providers, image, prepareImage, signal, onRateLimit, onModelAvailability,
       question: `用不超过两句话描述这张图片的主题与构图。生成该图的提示词是：「${String(originalPrompt).slice(0, 200)}」` });
     return result.answer.slice(0, 300);
   } catch (_) { return ''; }

package/lib/config.js

@@ -1,5 +1,8 @@
 'use strict';
 import { normalizeVisionInputLimits } from './vision-image-input.js';
+import { scopedProvider } from './provider-config-scope.js';
+import { currentModelDirectory, modelDirectoryBinding, modelAvailabilityBinding, modelUnavailable, modelUnavailableReason, validateModelDirectory } from './model-directory.js';
+import { refreshModelDirectory } from './model-directory-service.js';
 /**
  * Iris 配置存储：$DSH_HOME/iris/v1/providers.json
  * Iris 独立持有配置；旧工作台仅作为用户显式指定的一次性导入来源。
@@ -19,7 +22,7 @@ import {
   healthObservationState,
   isDefinitiveHealthFailure,
   newestHealthEvidence,
-  modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth
+  modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth, recordModelAvailability, resetHealthOnCriticalChange
 } from './provider-health.js';
 
 function isPlainObject(value) {
@@ -30,12 +33,21 @@ function validateStoredConfig(value) {
   if (!isPlainObject(value)) throw new Error('配置根节点必须是对象');
   if (!Array.isArray(value.providers)) throw new Error('providers 必须是数组');
   if (!isPlainObject(value.assignments)) throw new Error('assignments 必须是对象');
+  for (const [capability, assignment] of Object.entries(value.assignments)) models.functionPolicy(assignment, capability);
   for (const provider of value.providers) {
     if (!isPlainObject(provider)) throw new Error('provider 条目必须是对象');
+    validateModelDirectory(provider.modelDirectory);
     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.dshProvider !== undefined) {
+      const ref = provider.dshProvider;
+      if (!isPlainObject(ref) || typeof ref.provider !== 'string' || !ref.provider.trim()
+          || typeof ref.settingsNs !== 'string' || !ref.settingsNs.trim()
+          || Object.keys(ref).some(key => !['provider', 'settingsNs'].includes(key))) throw new Error('DSH 连接引用无效');
+      if (provider.apiKey !== undefined || provider.baseUrl !== undefined) throw new Error('DSH 引用不能同时保存密钥或普通 Base URL');
+    }
     if (provider.models !== undefined && !Array.isArray(provider.models)) throw new Error('provider.models 必须是数组');
     for (const model of provider.models || []) {
       if (typeof model === 'string') continue;
@@ -58,6 +70,7 @@ function authModeOf(provider) {
 /** 该供应商是否缺少必需凭据（'none' 认证永不缺）。 */
 function missingCredentials(provider) {
   if (!provider || authModeOf(provider) === 'none') return false;
+  if (provider.dshProvider) return false;
   return typeof provider.apiKey !== 'string' || !provider.apiKey.trim();
 }
 
@@ -172,7 +185,37 @@ export function importFromWorkbench(workbenchConfigPath) {
 }
 
 export function providers() {
-  return load().providers.filter(isConfiguredProvider);
+  return runtimeProviders().filter(isConfiguredProvider);
+}
+
+/** Runtime copies may contain Host-resolved credentials; never persist these copies. */
+export function runtimeProviders() {
+  return load().providers.map(scopedProvider);
+}
+
+/** 目录更新只保存可选元数据，不保存宿主解析出的连接副本。 */
+export function saveModelDirectory(providerId, directory) {
+  const provider = load().providers.find(item => item.id === providerId);
+  const current = runtimeProviders().find(item => item.id === providerId);
+  if (!provider || !current || modelDirectoryBinding(current) !== directory.binding) return false;
+  provider.modelDirectory = directory;
+  // 同一次操作的已解析副本也使用最新快照。
+  if (current !== provider) current.modelDirectory = directory;
+  persist();
+  return true;
+}
+
+export async function refreshProviderDirectories({ providerId, force = false, signal } = {}) {
+  const selected = providers().filter(provider => !providerId || provider.id === providerId);
+  return Promise.all(selected.map(provider => refreshModelDirectory(provider, { force, signal,
+    save: directory => saveModelDirectory(provider.id, directory) })));
+}
+
+export async function refreshAutomaticDirectories({ capability, signal } = {}) {
+  const capabilities = (capability ? [capability] : Object.values(cap.CAPABILITIES)).filter(c => models.functionPolicy(assignments()[c], c).mode === 'auto');
+  const selected = providers().filter(provider => models.providerModels(provider).some(model => model.capabilities.some(c => capabilities.includes(c))));
+  return Promise.all(selected.map(provider => refreshModelDirectory(provider, { signal,
+    save: directory => saveModelDirectory(provider.id, directory) })));
 }
 
 export function providerById(id) {
@@ -183,7 +226,7 @@ export function providerById(id) {
 const FIELD_OF = models.CAP_FIELD;
 
 /**
- * 严格选择：仅从功能分配名单取第一个可用模型。
+ * 按当前功能策略取第一个可用模型。
  * 返回该模型所属 provider 的副本，并把该能力的模型字段设为选中模型。
  * 向后兼容：调用方继续读 provider.apiKey / provider.imageModel 等。
  * 无可用模型 → null（不再兜底到任意 provider）。
@@ -194,12 +237,12 @@ export function pickFor(capability) {
 
 /**
  * 同一能力的有序 provider 列表（供 failover 依次尝试）：
- * 只使用已分配顺序，不补入全局池。
+ * 自动池按登记顺序选择；手选名单不补池，停用没有候选。
  * 一个 provider 若池里有多个该能力模型，会返回多条（各自带不同模型）。
  */
-export function pickAllFor(capability, { includeRateLimited = false } = {}) {
-  const pool = models.modelPool(providers(), { includeHostVision: true });
-  const chosen = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited });
+export function pickAllFor(capability, { includeRateLimited = false, includeUnavailable = false } = {}) {
+  const pool = models.functionModelPool(providers(), capability, assignments()[capability], { includeHostVision: true });
+  const chosen = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited, includeUnavailable });
   const out = [];
   for (const m of chosen) {
     if (m.ref === models.HOST_VISION_REF) {
@@ -226,8 +269,11 @@ export function assignmentOrder(capability) {
   const a = assignments()[capability];
   if (!a) return [];
   const pool = models.modelPool(allProviders(), { includeHostVision: true });
+  const policy = models.functionPolicy(a, capability);
+  if (policy.mode === 'auto') return models.orderedModels(pool, capability, a, { includeRateLimited: true, includeUnavailable: true }).map(model => model.ref);
+  if (policy.mode === 'disabled') return [];
   const refs = [];
-  for (const raw of (Array.isArray(a) ? a : [a])) {
+  for (const raw of policy.models) {
     const m = resolveAssignment(pool, raw, capability);
     if (m && !refs.includes(m.ref)) refs.push(m.ref);
     else if (!m && typeof raw === 'string' && models.parseModelRef(raw) && !refs.includes(raw)) refs.push(raw);
@@ -284,6 +330,47 @@ export function clearAssignment(capability) {
   return true;
 }
 
+/** Explicit policy changes preserve the previous manual list for a later switch. */
+export function setFunctionPolicy(capability, mode, { hostVision } = {}) {
+  if (!cap.isKnownCapability(capability)) throw new TypeError('未知功能');
+  const c = load();
+  const previous = models.functionPolicy(c.assignments[capability], capability);
+  const next = { mode, models: models.savedAssignmentRefs(models.modelPool(c.providers, { includeHostVision: true }), capability, previous.models) };
+  if (capability === cap.CAPABILITIES.VISION) next.hostVision = hostVision === undefined ? previous.hostVision : hostVision;
+  models.functionPolicy(next, capability);
+  c.assignments[capability] = next;
+  persist();
+  return next;
+}
+
+/** One user confirmation updates capabilities and optional automatic use atomically. */
+export function confirmModelUsage(id, modelId, capabilities, { enableAutomatic = false, musicProtocol } = {}) {
+  const c = load();
+  const provider = c.providers.find(item => item.id === id);
+  if (!provider) throw new TypeError('供应商不存在');
+  if (typeof modelId !== 'string' || !modelId.trim() || !Array.isArray(capabilities)
+      || !capabilities.every(cap.isKnownCapability) || typeof enableAutomatic !== 'boolean') throw new TypeError('请填写模型名称并确认已知功能');
+  if (musicProtocol !== undefined) normalizeMusicProtocol(musicProtocol);
+  const entries = (Array.isArray(provider.models) ? provider.models : models.providerModels(provider)).map(model => typeof model === 'string' ? { id: model } : { ...model });
+  let entry = entries.find(model => model.id === modelId.trim());
+  if (!entry) { entry = { id: modelId.trim() }; entries.push(entry); }
+  entry.capabilities = [...new Set(capabilities)];
+  entry.source = 'manual';
+  provider.models = entries;
+  if (musicProtocol !== undefined) {
+    if (entry.musicProtocol !== musicProtocol) clearModelCapabilityHealth(provider, entry.id, cap.CAPABILITIES.MUSIC);
+    entry.musicProtocol = musicProtocol;
+  }
+  if (enableAutomatic) for (const capability of entry.capabilities) {
+    const previous = models.functionPolicy(c.assignments[capability], capability);
+    c.assignments[capability] = { mode: 'auto', models: models.savedAssignmentRefs(models.modelPool(c.providers, { includeHostVision: true }), capability, previous.models),
+      ...(capability === cap.CAPABILITIES.VISION ? { hostVision: previous.hostVision } : {}) };
+  }
+  pruneHealthToEffectiveModels(provider);
+  persist();
+  return entry;
+}
+
 /** 某 provider 的模型池覆盖的能力集合（合并各模型的能力标签） */
 export function capabilitiesOf(p) {
   const caps = new Set();
@@ -293,11 +380,6 @@ 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)
@@ -318,7 +400,7 @@ function safeHealthNote(provider, value) {
   const raw = String(value ?? '').trim();
   if (!raw) return '';
   let note = redactProviderMessage(raw, 200);
-  const key = String(provider && provider.apiKey || '');
+  const key = String(provider && scopedProvider(provider).apiKey || '');
   if (key) note = note.split(key).join('[REDACTED]');
   return note;
 }
@@ -330,7 +412,9 @@ function observationEvidence(provider, result, fallbackSource) {
   return {
     at: new Date(Number.isFinite(atMs) ? atMs : Date.now()).toISOString(),
     source: ['probe', 'task'].includes(result && result.source) ? result.source : fallbackSource,
+    ...(result?.stage === 'poll' ? { stage: 'poll' } : {}),
     category: String(result && result.category || (result && result.ok ? 'success' : 'unknown')).slice(0, 40),
+    ...(typeof result?.providerCode === 'string' ? { providerCode: safeHealthNote(provider, result.providerCode) } : {}),
     ...(Number.isInteger(status) && status >= 100 && status <= 599 ? { httpStatus: status } : {}),
     ...(note ? { note } : {})
   };
@@ -340,6 +424,8 @@ function applyProviderHealth(provider, modelId, capability, result, fallbackSour
   const model = String(modelId || '').trim();
   if (!provider || !model || !cap.isKnownCapability(capability)) return false;
   const health = healthContainer(provider);
+  const scoped = scopedProvider(provider);
+  if (scoped !== provider) scoped.health = health;
   let observation = health.observations.find((item) => item && item.modelId === model
     && item.capability === capability);
   if (!observation) {
@@ -347,6 +433,12 @@ function applyProviderHealth(provider, modelId, capability, result, fallbackSour
     health.observations.push(observation);
   }
   const evidence = observationEvidence(provider, result || {}, fallbackSource);
+  const effective = { ...scopedProvider(provider), health };
+  if (recordModelAvailability(effective, model, capability, { ...result, ...evidence,
+    binding: result?.binding || modelAvailabilityBinding(effective, model, capability) }) && observation.availability?.state === 'blocked') {
+    const directory = currentModelDirectory(effective);
+    if (directory) directory.invalidatedAt = evidence.at;
+  }
   recordModelRateLimit(provider, model, { ...evidence, retryAfterMs: result?.retryAfterMs, until: result?.until, reason: result?.reason });
   if (result && result.ok === true) {
     observation.lastSuccess = evidence;
@@ -382,16 +474,6 @@ function pruneModelHealth(provider, modelId) {
   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: [],
-    ...(current?.rateLimits?.length ? { rateLimits: current.rateLimits } : {}) };
-}
-
 /** 记录显式实测或真实任务观察；限流资格另存，保留原成功事实。 */
 export function recordProviderHealth(id, modelId, capability, result) {
   const c = load();
@@ -403,6 +485,14 @@ export function recordProviderHealth(id, modelId, capability, result) {
   return true;
 }
 
+/** Adapter提交边界的可用性事件；poll不会调用这一入口。 */
+export function recordAvailability({ providerId, modelId, capability, ...result }) {
+  const known = { image: cap.CAPABILITIES.IMAGE, video: cap.CAPABILITIES.VIDEO, music: cap.CAPABILITIES.MUSIC }[capability] || capability;
+  const current = runtimeProviders().find(provider => provider.id === providerId);
+  if (!current || result.binding && modelAvailabilityBinding(current, modelId, known) !== result.binding) return false;
+  return recordProviderHealth(providerId, modelId, known, result);
+}
+
 /** 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;
@@ -421,6 +511,10 @@ export function modelHealth(id, modelId, capability, { now = Date.now() } = {})
     source: blocked.source, category: blocked.category, httpStatus: blocked.httpStatus,
     ...(blocked.until ? { retryAt: blocked.until } : { reason: blocked.reason }),
     note: blocked.until ? '429 限流冷却，暂时跳过' : '额度或预算耗尽后已停用，手动实测成功后恢复' };
+  const unavailable = modelUnavailable(scopedProvider(provider), modelId, capability, { allowUnresolvedConnections: true });
+  if (unavailable) return { status: 'failed', modelUnavailable: true, reason: 'model_not_found',
+    observedAt: unavailable.at, source: unavailable.source, httpStatus: 404, category: 'invalid_request',
+    note: modelUnavailableReason() };
   const observation = healthObservation(provider, modelId, capability);
   const status = healthObservationState(observation, { now });
   const evidence = status === 'verified'
@@ -441,12 +535,18 @@ export function modelHealth(id, modelId, capability, { now = Date.now() } = {})
 /** 当前有序 failover 路径的健康快照；只含脱敏标量，不触发网络。 */
 export function providerHealthSnapshot({ now = Date.now() } = {}) {
   const capabilities = {};
+  // A stored Host reference is configured without local endpoint/key fields.
+  // This snapshot reports configuration and past evidence, not live readiness.
+  const healthProviders = runtimeProviders().filter(provider => provider.enabled !== false
+    && (provider.dshProvider || isConfiguredProvider(provider)));
   for (const capability of Object.values(cap.CAPABILITIES)) {
-    const candidates = pickAllFor(capability, { includeRateLimited: true }).map((provider) => {
-      const modelId = String(provider[FIELD_OF[capability]] || '');
-      const health = provider.id === models.HOST_VISION_REF ? { status: 'configured', source: 'configuration' }
-        : modelHealth(provider.id, modelId, capability, { now });
-      return { providerId: provider.id, modelId, ...health };
+    const pool = models.functionModelPool(healthProviders, capability, assignments()[capability], {
+      includeHostVision: true, allowUnresolvedConnections: true
+    });
+    const candidates = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited: true, includeUnavailable: true }).map((model) => {
+      const health = model.ref === models.HOST_VISION_REF ? { status: 'configured', source: 'configuration' }
+        : modelHealth(model.providerId, model.id, capability, { now });
+      return { providerId: model.providerId, modelId: model.id, ...health };
     });
     const status = aggregateHealthStates(candidates.map((item) => item.status));
     const newest = [...candidates]
@@ -480,6 +580,17 @@ export function upsert(provider) {
   const { id, ...input } = provider;
   // PATCH 语义：缺失字段和 undefined 都不覆盖旧值；null/空串仍是显式更新。
   const rest = Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+  const existing = id && c.providers.find(item => item.id === id);
+  const reference = rest.dshProvider || existing?.dshProvider;
+  if (reference) {
+    if (!isPlainObject(reference) || typeof reference.provider !== 'string' || !reference.provider.trim()
+        || typeof reference.settingsNs !== 'string' || !reference.settingsNs.trim()
+        || Object.keys(reference).some(key => !['provider', 'settingsNs'].includes(key))) throw new Error('DSH 连接引用无效');
+    if (['apiKey', 'baseUrl'].some(key => rest[key] !== undefined || existing?.[key] !== undefined)) {
+      throw new Error('DSH 引用不保存密钥或普通 Base URL；请新建引用供应商');
+    }
+    rest.dshProvider = { provider: reference.provider.trim(), settingsNs: reference.settingsNs.trim() };
+  }
   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) } : {}),

package/lib/doctor.js

@@ -103,16 +103,23 @@ function inspectConfig(dataDir, checks) {
   let incomplete = 0;
   let enabled = 0;
   let models = 0;
+  let hostReferences = 0;
   for (const provider of providers) {
     if (!plain(provider)) { incomplete++; continue; }
     if (provider.enabled !== false) enabled++;
-    if (provider.enabled !== false && (!providerMediaBaseUrl(provider)
+    const reference = provider.dshProvider;
+    const managed = plain(reference) && typeof reference.provider === 'string' && reference.provider.trim()
+      && typeof reference.settingsNs === 'string' && reference.settingsNs.trim();
+    if (provider.enabled !== false && managed) hostReferences++;
+    if (provider.enabled !== false && !managed && (!providerMediaBaseUrl(provider)
         || (provider.auth !== 'none' && !providerApiKey(provider).trim()))) incomplete++;
     models += Array.isArray(provider.models) ? provider.models.length : 0;
   }
   if (incomplete) checks.push(result('providers', 'warn', `${incomplete} 个启用供应商缺少端点、所需凭据或结构无效（auth:none 不要求密钥）`, '在 Iris 工作台补全或停用对应供应商。'));
   else if (!enabled) checks.push(result('providers', 'warn', '没有启用的供应商', '在 Iris 工作台启用至少一个供应商。'));
   else checks.push(result('providers', 'ok', `${enabled} 个供应商已启用；凭据未输出`));
+  if (hostReferences) checks.push(result('provider-references', 'warn', `${hostReferences} 个 DSH 连接引用需由运行中宿主解析；离线未验证连接`,
+    '在 DSH 的 Iris 工作台检查原连接与功能池候选，无需在 Iris 重填宿主密钥。'));
   const assignments = config.value.assignments || {};
   const assignmentCount = Object.keys(assignments).length;
   if (!models) checks.push(result('models', 'warn', '模型池为空或尚未发现模型', '在工作台对供应商执行“发现模型”，再核对能力标签。'));
@@ -378,7 +385,7 @@ export function hostDoctor(host, evidence = {}, options = {}) {
       checks.push(result('dsh-version', 'ok', 'DSH ' + snapshot.host.version + ' 位于已验证支持范围'));
     } else {
       checks.push(result('dsh-version', 'error', 'DSH ' + snapshot.host.version + ' 超出已验证支持范围',
-        '当前支持 DSH ' + SUPPORTED_DSH_VERSIONS.join('、') + '；旧 DSH 0.1.2 线或 0.1.5-rc.1 使用 Iris @mokuyoaxis/dsh-iris@0.1.4。其他版本须另行验收。'));
+        '当前支持 DSH ' + SUPPORTED_DSH_VERSIONS.join('、') + '；请核对所装 Iris 的兼容矩阵及 Node 要求，其他版本须另行验收。'));
     }
   }
 

package/lib/dsh-compatibility.js

@@ -1,7 +1,13 @@
 'use strict';
 
 /** 已完成宿主接口验收的版本；manifest/Doctor/验收脚本共用同一边界。 */
-export const SUPPORTED_DSH_VERSIONS = Object.freeze(['0.2.0-rc.2', '0.2.1-alpha.4']);
+export const SUPPORTED_DSH_VERSIONS = Object.freeze([
+  '0.1.2-rc.1',
+  '0.1.5-rc.1', '0.1.5-rc.2', '0.1.5-rc.3',
+  '0.1.7-rc.1', '0.1.7-rc.2',
+  '0.2.0-rc.1', '0.2.0-rc.2',
+  '0.2.1-alpha.1', '0.2.1-alpha.2', '0.2.1-alpha.3', '0.2.1-alpha.4'
+]);
 export const DSH_SUPPORT_RANGE = SUPPORTED_DSH_VERSIONS.join(' || ');
 
 export function isSupportedDshVersion(value) {

package/lib/dsh-core-adapter.js

@@ -2,7 +2,8 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { allProviders, assignments, irisHome, recordRateLimit } from './config.js';
+import { runtimeProviders, assignments, irisHome, recordRateLimit, recordAvailability, refreshAutomaticDirectories } from './config.js';
+import { withDshProviderConfig } from './dsh-provider-config.js';
 import { createCommandService } from './command-service.js';
 import { createCoreArtifact, inspectCoreArtifact, listCoreArtifacts, listCoreArtifactMetadata, readCoreArtifactBytes } from './core-artifacts.js';
 import { createCoreRuntime } from './core-runtime.js';
@@ -23,9 +24,16 @@ const providerWatchers = new Map();
 const DEFAULT_POLL_INTERVAL_MS = 2500;
 const DEFAULT_MAX_WATCH_MS = 20 * 60 * 1000;
 const POLL_ERROR_TOLERANCE = 5;
+let providerHost = () => undefined;
+
+/** The Host supplies a fresh optional connection port; no credentials are retained here. */
+export function configureProviderHostForDsh(factory) {
+  providerHost = factory;
+  return () => { if (providerHost === factory) providerHost = () => undefined; };
+}
 
 function createConfiguredProviderAdapter(provider, options = {}) {
-  return createProviderAdapter(provider, { ...options, onRateLimit: recordRateLimit });
+  return createProviderAdapter(provider, { ...options, onRateLimit: recordRateLimit, onModelAvailability: recordAvailability });
 }
 
 export class DshCoreAdapterError extends Error {
@@ -290,8 +298,9 @@ export function retryProviderTaskForDsh(input = {}) {
   }
   return withWriter(async (runtime) => {
     const commands = createCommandService(runtime, {
-      resolveTaskCandidates: ({ capability, modelRef }) => {
-        const catalog = { providers: allProviders(), assignments: assignments() };
+      resolveTaskCandidates: ({ capability, modelRef }) => withDshProviderConfig(providerHost(), async () => {
+        if (!modelRef) await refreshAutomaticDirectories({ capability: { image: 'image-gen', video: 'video-gen', music: 'music-gen' }[capability] || capability, signal: input.signal });
+        const catalog = { providers: runtimeProviders(), assignments: assignments() };
         const ref = modelRef || undefined;
         const candidates = capability === 'video'
           ? videoCandidatesFromCatalog(catalog, ref)
@@ -308,7 +317,7 @@ export function retryProviderTaskForDsh(input = {}) {
           selectionReason: route.selectionReason,
           providerBinding: providerTaskBinding(route.provider)
         }));
-      }
+      }, { signal: input.signal, fresh: true })
     });
     const result = await commands.execute('task.retry', {
       task_id: taskId,
@@ -346,9 +355,11 @@ function observableProviderTask(task) {
     && task.phase !== 'terminal');
 }
 
-function configuredAdapterForTask(task) {
-  const provider = providerForTaskFromCatalog({ providers: allProviders() }, task);
-  return createConfiguredProviderAdapter(provider, { modelId: parseModelRef(task.modelRef)?.modelId });
+async function configuredAdapterForTask(task) {
+  return withDshProviderConfig(providerHost(), () => {
+    const provider = providerForTaskFromCatalog({ providers: runtimeProviders() }, task);
+    return createConfiguredProviderAdapter(provider, { modelId: parseModelRef(task.modelRef)?.modelId });
+  }, { fresh: true });
 }
 
 function stopProviderWatch(taskId, expectedState) {
@@ -371,7 +382,7 @@ export async function watchProviderTaskForDsh(input = {}) {
   if (providerWatchers.has(taskId)) return false;
   const initial = await inspectProviderTaskForDsh(taskId, { signal: input.signal });
   if (!observableProviderTask(initial) || providerWatchers.has(taskId)) return false;
-  configuredAdapterForTask(initial); // binding/模型漂移在定时器和网络前失败
+  await configuredAdapterForTask(initial); // binding/模型漂移在定时器和网络前失败
 
   const state = {
     timer: null,
@@ -400,7 +411,7 @@ export async function watchProviderTaskForDsh(input = {}) {
     }
     let adapter;
     try {
-      adapter = configuredAdapterForTask(before);
+      adapter = await configuredAdapterForTask(before);
     } catch (error) {
       console.warn('[iris] Core Task 无法按原 Provider binding 恢复观察：' + taskId
         + ' · ' + String(error?.code || error?.message || error));
@@ -450,7 +461,7 @@ export async function resumeProviderTaskWatchesForDsh(options = {}) {
   for (const original of records) {
     if (!WATCHABLE_CAPABILITIES.has(original.capability)) continue;
     try {
-      if (observableProviderTask(original)) configuredAdapterForTask(original);
+      if (observableProviderTask(original)) await configuredAdapterForTask(original);
       const needsRecovery = (original.phase === 'submitting' && original.acceptance === 'none')
         || original.cancelState === 'requested'
         || (original.outcome === 'succeeded' && ['pending', 'downloading'].includes(original.deliveryState))

package/lib/dsh-host-adapter.js

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { defineHostAdapter } from './host-contract.js';
 import { BrowserHtmlRenderer } from './render.js';
+import { createDshProviderSource } from './dsh-provider-source.js';
 
 export function detectDshVersion({ entry = process.argv[1] } = {}) {
   if (!entry) return 'unknown';
@@ -93,37 +94,30 @@ function visionRouteError(message) {
   return Object.assign(new Error(message), { code: 'IRIS_HOST_CAPABILITY_INCOMPATIBLE' });
 }
 
-function dshVisionPort(llm, { defaults, requiresRoute }) {
+function dshVisionPort(llm, defaults) {
   return Object.freeze({
     id: 'dsh-global',
     model: '全局视觉模型',
     async analyze({ question, ref, signal }) {
-      let route = {};
-      if (requiresRoute) {
-        // rc.2 路由检查前就停止取消请求；旧桥接继续由宿主处理 signal，
-        // 其 fallback 语义待共享调用控制迁移时统一。
-        if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('已取消');
-        const selection = defaults.currentSelection();
-        if (typeof selection?.provider !== 'string' || !selection.provider.trim()
-            || typeof selection?.model !== 'string' || !selection.model.trim()) {
-          throw visionRouteError('DSH 默认模型没有明确路由；请在 Iris 配置视觉模型');
-        }
-        // 默认文本选择只有明确声明 image 输入时才可成为视觉候选。
-        const { provider, model } = selection;
-        const info = await llm.resolveModelInfo(provider, model, signal);
-        if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('已取消');
-        if (info?.provider !== provider || info?.id !== model || !Array.isArray(info.inputModalities)
-            || !info.inputModalities.includes('image')) {
-          throw visionRouteError('DSH 默认模型未确认支持图片；请在 Iris 配置视觉模型或选择已声明图片输入的宿主模型');
-        }
-        route = { provider, model };
+      if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('已取消');
+      const selection = defaults.currentSelection();
+      if (typeof selection?.provider !== 'string' || !selection.provider.trim()
+          || typeof selection?.model !== 'string' || !selection.model.trim()) {
+        throw visionRouteError('DSH 默认模型没有明确路由；请在 Iris 配置视觉模型');
+      }
+      // 默认文本选择只有明确声明 image 输入时才可成为视觉候选。
+      const { provider, model } = selection;
+      const info = await llm.resolveModelInfo(provider, model, signal);
+      if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('已取消');
+      if (info?.provider !== provider || info?.id !== model || !Array.isArray(info.inputModalities)
+          || !info.inputModalities.includes('image')) {
+        throw visionRouteError('DSH 默认模型未确认支持图片；请在 Iris 配置视觉模型或选择已声明图片输入的宿主模型');
       }
       const chunks = [];
       for await (const chunk of llm.stream({
         sessionId: undefined,
-        provider: undefined,
-        model: undefined,
-        ...route,
+        provider,
+        model,
         signal,
         messages: [{
           role: 'user',
@@ -134,8 +128,8 @@ function dshVisionPort(llm, { defaults, requiresRoute }) {
         }]
       })) {
         if (chunk?.type === 'error') throw visionRouteError('DSH 视觉调用失败；请检查宿主模型状态');
-        // rc.2 的 Runtime 把 Adapter 异常转换为 finish，而不是单独的 error 事件。
-        if (requiresRoute && chunk?.type === 'finish') {
+        // Runtime 也会把 Adapter 异常转换为 finish，不能接受失败前的部分文本。
+        if (chunk?.type === 'finish') {
           if (chunk.reason?.kind === 'error') throw visionRouteError('DSH 视觉调用失败；请检查宿主模型状态');
           if (chunk.reason?.kind === 'aborted') throw visionRouteError('DSH 视觉调用已取消');
         }
@@ -208,6 +202,15 @@ export function createDshHostAdapter(ctx, { version = detectDshVersion() } = {})
   } else unavailable.skills = unavailableFor(skills, 'DSH Skill registry 需要 register');
 
   const llm = service(ctx, 'llm');
+  const settings = service(ctx, 'settings');
+  if (typeof llm?.listProviders === 'function' && typeof llm?.listConfigurableProviders === 'function'
+      && typeof settings?.describe === 'function') {
+    ports.providerConnections = createDshProviderSource(() => ({
+      llm: service(ctx, 'llm'), settings: service(ctx, 'settings'), credentials: service(ctx, 'credentials')
+    }));
+  } else unavailable.providerConnections = {
+    kind: 'unavailable', reason: '当前 DSH 未提供供应商连接目录与设置接口，可继续手动添加供应商'
+  };
   const defaults = service(ctx, 'agentDefaultModel');
   if (llm && typeof llm.stream === 'function') {
     ports.textModel = Object.freeze({
@@ -219,12 +222,12 @@ export function createDshHostAdapter(ctx, { version = detectDshVersion() } = {})
         ? () => defaults.currentSelection()
         : () => null
     });
-    const requiresRoute = /^0\.2\./.test(version);
-    if (!requiresRoute || defaults && typeof defaults.currentSelection === 'function'
+    // 旧 SDK 同样提供精确路由；按接口探测，避免用宿主版本号误选历史路径。
+    if (defaults && typeof defaults.currentSelection === 'function'
         && typeof llm.resolveModelInfo === 'function') {
-      ports.visionModel = dshVisionPort(llm, { defaults, requiresRoute });
+      ports.visionModel = dshVisionPort(llm, defaults);
     } else unavailable.visionModel = {
-      kind: 'unavailable', reason: 'DSH 0.2 视觉桥接需要默认模型选择和精确图片能力元数据'
+      kind: 'unavailable', reason: 'DSH 视觉桥接需要默认模型选择和精确图片能力元数据'
     };
   } else {
     unavailable.textModel = unavailableFor(llm, 'DSH llm 需要 stream');

package/lib/dsh-provider-config.js

@@ -0,0 +1,35 @@
+import { allProviders } from './config.js';
+import { hasProviderConfigScope, withProviderConfigScope } from './provider-config-scope.js';
+import { DshProviderSourceError } from './dsh-provider-source.js';
+
+export function normalizeDshProvider(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+      || typeof value.provider !== 'string' || !value.provider.trim()
+      || typeof value.settingsNs !== 'string' || !value.settingsNs.trim()
+      || Object.keys(value).some(key => !['provider', 'settingsNs'].includes(key))) {
+    throw Object.assign(new Error('DSH 连接引用需要 provider 和 settingsNs'), { code: 'IRIS_CONFIG_INPUT_INVALID' });
+  }
+  return { provider: value.provider.trim(), settingsNs: value.settingsNs.trim() };
+}
+
+/** Existing request handlers see resolved copies; the persistent store stays raw. */
+export async function withDshProviderConfig(host, callback, { signal, fresh = false } = {}) {
+  if (!fresh && hasProviderConfigScope()) return callback();
+  const providers = allProviders();
+  if (!providers.some(provider => provider.dshProvider)) return callback();
+  const resolved = await Promise.all(providers.map(async provider => {
+    if (!provider.dshProvider || provider.enabled === false) return provider;
+    try {
+      if (typeof host?.ports?.providerConnections?.resolve !== 'function') {
+        throw new DshProviderSourceError('当前宿主无法解析 DSH 连接，请检查原连接或改用手动供应商');
+      }
+      const value = await host.ports.providerConnections.resolve(provider.dshProvider, { signal });
+      return { ...provider, baseUrl: value.baseUrl, apiKey: value.apiKey };
+    } catch (error) {
+      if (!(error instanceof DshProviderSourceError)) throw error;
+      return { ...provider, enabled: false, connectionError: error.message };
+    }
+  }));
+  signal?.throwIfAborted();
+  return withProviderConfigScope(resolved, callback);
+}