@mokuyoaxis/dsh-iris 0.2.5 → 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', '模型池为空或尚未发现模型', '在工作台对供应商执行“发现模型”，再核对能力标签。'));

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';
@@ -201,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({

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);
+}

package/lib/dsh-provider-source.js

@@ -0,0 +1,102 @@
+/** Read only public DSH services; never open profile or credential files. */
+export class DshProviderSourceError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DshProviderSourceError';
+    this.code = 'IRIS_DSH_PROVIDER_UNAVAILABLE';
+  }
+}
+
+const unavailable = message => { throw new DshProviderSourceError(message); };
+const refName = value => typeof value === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+const recordId = value => typeof value === 'string' && /^[a-z][a-z0-9-]*$/.test(value);
+
+async function credentialRead(read) {
+  try { return await read(); }
+  catch (_) { unavailable('DSH 凭据服务读取失败，请在宿主检查该连接'); }
+}
+
+function endpoint(value) {
+  let url;
+  try { url = new URL(value); } catch (_) { unavailable('DSH 连接没有可复用的 HTTP(S) 地址'); }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    unavailable('DSH 连接地址包含不支持的协议或凭据参数');
+  }
+  return url.href.replace(/\/+$/, '');
+}
+
+export function createDshProviderSource(services) {
+  function entries() {
+    const { llm, settings, credentials } = services();
+    if (typeof llm?.listProviders !== 'function' || typeof llm?.listConfigurableProviders !== 'function'
+        || typeof settings?.describe !== 'function') {
+      unavailable('当前 DSH 未提供连接目录与设置接口，请手动添加 Iris 供应商');
+    }
+    const active = new Set(llm.listProviders().map(provider => provider.id));
+    const forms = settings.describe({ redactSecrets: true });
+    return llm.listConfigurableProviders().filter(entry => active.has(entry.provider)).map(entry => {
+      let profile = forms.find(form => form.ns === entry.settingsNs)?.value;
+      for (const key of entry.settingsPath) profile = profile && Object.hasOwn(profile, key) ? profile[key] : undefined;
+      return { entry, profile, credentials };
+    });
+  }
+
+  async function facts({ entry, profile, credentials }) {
+    if (!profile || typeof profile !== 'object' || Array.isArray(profile)) unavailable('DSH 连接设置不可读取');
+    if (profile.headers && Object.keys(profile.headers).length) unavailable('该 DSH 连接含自定义请求头，当前请手动配置 Iris 供应商');
+    const baseUrl = endpoint(profile.baseURL || entry.defaultBaseURL);
+    if (!credentials) unavailable('当前 DSH 没有凭据解析服务，请手动配置 Iris 供应商');
+    if (profile.apiKeyEnv !== undefined) {
+      if (!refName(profile.apiKeyEnv) || typeof credentials.describe !== 'function'
+          || typeof credentials.resolve !== 'function') unavailable('DSH 凭据引用不可用');
+      if (!(await credentialRead(() => credentials.describe(profile.apiKeyEnv))).configured) unavailable('DSH 连接尚未配置可用密钥');
+      return { baseUrl, ref: profile.apiKeyEnv };
+    }
+    // This is the documented api-key record space owned by llm-pi-ai.
+    if (entry.settingsNs === 'llm-pi-ai' && recordId(entry.provider)
+        && typeof credentials.describeRecord === 'function' && typeof credentials.readRecord === 'function') {
+      const key = 'llm-pi-ai/' + entry.provider;
+      const info = await credentialRead(() => credentials.describeRecord(key));
+      if (info.configured) {
+        if (info.kind !== 'api-key') unavailable('该 DSH 连接使用登录授权，当前不支持将其用于媒体请求');
+        return { baseUrl, recordKey: key };
+      }
+    }
+    for (const ref of entry.nativeAuth?.env || []) {
+      if (refName(ref) && typeof credentials.describe === 'function' && typeof credentials.resolve === 'function'
+          && (await credentialRead(() => credentials.describe(ref))).configured) return { baseUrl, ref };
+    }
+    unavailable('该 DSH 连接没有可复用的 API Key；登录授权和专有认证需单独适配');
+  }
+
+  async function list() {
+    return Promise.all(entries().map(async source => {
+      const { entry } = source;
+      const common = { provider: entry.provider, settingsNs: entry.settingsNs, name: entry.displayName || entry.provider };
+      try { return { ...common, baseUrl: (await facts(source)).baseUrl, available: true }; }
+      catch (error) {
+        if (!(error instanceof DshProviderSourceError)) throw error;
+        return { ...common, available: false, reason: error.message };
+      }
+    }));
+  }
+
+  async function resolve(reference, { signal } = {}) {
+    signal?.throwIfAborted();
+    const source = entries().find(({ entry }) => entry.provider === reference.provider && entry.settingsNs === reference.settingsNs);
+    if (!source) unavailable('DSH 原连接已停用、移除或改变来源，请检查宿主供应商设置');
+    const plan = await facts(source);
+    let key;
+    if (plan.ref) key = (await credentialRead(() => source.credentials.resolve(plan.ref)))?.value;
+    else {
+      const record = await credentialRead(() => source.credentials.readRecord(plan.recordKey));
+      if (record?.kind === 'api-key') key = record.key;
+    }
+    signal?.throwIfAborted();
+    if (typeof key !== 'string' || !key.trim() || /[\r\n]/.test(key)) unavailable('DSH 原连接没有可用于媒体请求的 API Key');
+    // Even accidental JSON serialization of this Host-only result excludes the key.
+    return Object.freeze(Object.defineProperty({ baseUrl: plan.baseUrl }, 'apiKey', { value: key }));
+  }
+
+  return Object.freeze({ list, resolve });
+}