@mokuyoaxis/dsh-iris 0.2.5 → 0.2.6

package/lib/models.js

@@ -13,6 +13,8 @@
  */
 import { CAPABILITIES, configuredModelCapabilities } from './capability.js';
 import { modelRateLimit } from './provider-health.js';
+import { supportsModelCapability } from './provider-protocol.js';
+import { currentModelDirectory, modelDirectoryEntry, modelDirectoryStatus, modelUnavailable } from './model-directory.js';
 
 /** 能力 → provider 上的模型字段（保持向后兼容的返回形状） */
 export const CAP_FIELD = {
@@ -108,7 +110,11 @@ export function providerModels(p) {
   const push = (id, caps, extra) => {
     const name = String(id || '').trim();
     if (!name || out.some((m) => m.id === name)) return;
+    const unavailableCapabilities = caps.filter(capability => modelUnavailable(p, name, capability, { allowUnresolvedConnections: true }));
+    const catalogStatus = modelDirectoryStatus(p, name);
     out.push({ id: name, providerId: p.id, ref: modelRef(p.id, name), capabilities: [...caps], ...(extra || {}),
+      ...(catalogStatus !== 'unknown' ? { catalogStatus } : {}),
+      ...(unavailableCapabilities.length ? { unavailableCapabilities } : {}),
       ...(modelRateLimit(p, name) ? { rateLimited: true } : {}) });
   };
   // ① 显式 models 数组（带可选 capabilities 覆盖 + verified/source 透传）
@@ -119,7 +125,8 @@ export function providerModels(p) {
     for (const m of p.models) {
       const id = typeof m === 'string' ? m : m && m.id;
       // 没有明确能力的名称保留为未标注模型，不进入候选链。
-      const caps = configuredModelCapabilities(p, m);
+      const metadata = m?.source === 'discovered' && modelDirectoryEntry(p, id, { allowUnresolvedConnections: true });
+      const caps = metadata ? metadata.capabilities : configuredModelCapabilities(p, m);
       const extra = typeof m === 'object' && m ? { verified: m.verified, source: m.source,
         ...(m.imageProtocol !== undefined ? { imageProtocol: m.imageProtocol } : {}),
         ...(m.musicProtocol !== undefined ? { musicProtocol: m.musicProtocol } : {}),
@@ -136,6 +143,14 @@ export function providerModels(p) {
   return out;
 }
 
+/** 管理界面附上新目录条目，未登记的发现项不会因此进入执行范围。 */
+export function providerModelsWithDirectory(provider) {
+  const configured = providerModels(provider);
+  const directory = currentModelDirectory(provider, { allowUnresolvedConnections: true });
+  return configured.concat((directory?.models || []).filter(model => !configured.some(entry => entry.id === model.id))
+    .map(model => ({ ...model, providerId: provider.id, ref: modelRef(provider.id, model.id), source: 'discovered', catalogStatus: 'listed', directoryOnly: true })));
+}
+
 /** 只解析用户配置中的模型；裸 ID 与复合引用共享能力校验。 */
 export function resolveModelRef(provider, capability, requested = '') {
   const pool = providerModels(provider).filter((m) => m.capabilities.includes(capability));
@@ -162,19 +177,67 @@ export function resolvePoolModel(pool, raw, capability) {
     && m.capabilities.includes(capability)) || null;
 }
 
-/** DSH 与 CLI 共用的执行名单：只按明确分配排序并去重。 */
-export function orderedModels(pool, capability, assignments, { includeRateLimited = false } = {}) {
+/** Legacy assignments stay manual/disabled; only an explicit policy enables a pool. */
+export function functionPolicy(value, capability) {
+  if (value && typeof value === 'object' && !Array.isArray(value) && Object.hasOwn(value, 'mode')) {
+    if (!['auto', 'manual', 'disabled'].includes(value.mode)
+        || Object.keys(value).some(key => !['mode', 'models', 'hostVision'].includes(key))
+        || (value.models !== undefined && (!Array.isArray(value.models) || !value.models.every(ref => typeof ref === 'string')))
+        || (value.hostVision !== undefined && (typeof value.hostVision !== 'boolean'
+          || (value.hostVision && capability !== CAPABILITIES.VISION)))) {
+      throw Object.assign(new TypeError('功能策略需要 auto、manual 或 disabled；models 为引用数组，hostVision 仅用于视觉'), {
+        code: 'IRIS_FUNCTION_POLICY_INVALID'
+      });
+    }
+    return { mode: value.mode, models: value.models || [], hostVision: value.hostVision === true };
+  }
+  return { mode: value ? 'manual' : 'disabled', models: Array.isArray(value) ? value : value ? [value] : [], hostVision: false };
+}
+
+/** Preserve legacy names/object references when a user explicitly changes policy. */
+export function savedAssignmentRefs(pool, capability, values) {
+  const refs = values.map(raw => {
+    const resolved = resolvePoolModel(pool, raw, capability);
+    if (resolved) return resolved.ref;
+    if (typeof raw === 'string') return raw;
+    const id = String(raw?.modelId || raw?.id || '');
+    return id && raw?.providerId ? modelRef(raw.providerId, id) : id;
+  });
+  return [...new Set(refs.filter(Boolean))];
+}
+
+/** Automatic pools reject known protocol gaps before constructing any adapter. */
+export function functionModelPool(providers, capability, assignment, { includeHostVision = false, allowUnresolvedConnections = false } = {}) {
+  const policy = functionPolicy(assignment, capability);
+  return modelPool(providers, { includeHostVision }).filter(model => {
+    if (!model.capabilities.includes(capability)) return false;
+    if (policy.mode !== 'auto' || model.ref === HOST_VISION_REF) return true;
+    const provider = providers.find(provider => provider.id === model.providerId);
+    return supportsModelCapability(provider, model.id, capability, {
+      checkEndpoint: !allowUnresolvedConnections || !provider?.dshProvider
+    });
+  });
+}
+
+/** Shared scope and stable ordering; discovery alone never expands an automatic pool. */
+export function orderedModels(pool, capability, assignments, { includeRateLimited = false, includeUnavailable = false } = {}) {
   const ordered = [];
   const seen = new Set();
   const add = (model) => {
     if (model && (includeRateLimited || !model.rateLimited)
+        && (includeUnavailable || !model.unavailableCapabilities?.includes(capability))
         && model.capabilities.includes(capability) && !seen.has(model.ref)) {
       seen.add(model.ref);
       ordered.push(model);
     }
   };
-  for (const raw of (Array.isArray(assignments) ? assignments : (assignments ? [assignments] : []))) {
-    add(resolvePoolModel(pool, raw, capability));
+  const policy = functionPolicy(assignments, capability);
+  if (policy.mode === 'auto') {
+    for (const model of pool) {
+      if (model.source !== 'discovered' && (model.ref !== HOST_VISION_REF || policy.hostVision)) add(model);
+    }
+  } else if (policy.mode === 'manual') {
+    for (const raw of policy.models) add(resolvePoolModel(pool, raw, capability));
   }
   return ordered;
 }
@@ -189,7 +252,9 @@ export function selectionReasonForModel(pool, capability, assignments, modelOrRe
     modelOrRef && typeof modelOrRef === 'object' ? modelOrRef.ref : modelOrRef,
     capability);
   if (!selected) return null;
-  for (const raw of (Array.isArray(assignments) ? assignments : (assignments ? [assignments] : []))) {
+  const policy = functionPolicy(assignments, capability);
+  if (policy.mode === 'auto') return 'pool';
+  for (const raw of policy.models) {
     const assigned = resolvePoolModel(pool, raw, capability);
     if (assigned?.ref === selected.ref) return 'assignment';
   }

package/lib/ocr-model-routing.js

@@ -8,13 +8,13 @@ import { waitForModelWork } from './model-call-runtime.js';
 import { createVisionInputObserver } from './vision-image-input.js';
 
 export async function runOcrRequest(host, { providers = [], model, image, prepareImage, signal,
-  chunkHeight, overlap, maxDimension, maxInvocations, budget = OCR_BUDGET, onRateLimit }) {
+  chunkHeight, overlap, maxDimension, maxInvocations, budget = OCR_BUDGET, onRateLimit, onModelAvailability }) {
   const settings = normalizeOcrSettings({ chunkHeight, overlap, maxDimension, maxInvocations });
   const operation = createModelOperation({ signal, budget: { timeoutMs: budget.timeoutMs, maxInvocations: settings.maxInvocations } });
   try {
     if (operation.signal.aborted) throw new ModelPortError('IRIS_MODEL_ABORTED');
     const inputs = new Map();
-    const candidates = buildVisionModelCandidates(host, { providers, model, onRateLimit, prepareImages: true,
+    const candidates = buildVisionModelCandidates(host, { providers, model, onRateLimit, onModelAvailability, prepareImages: true,
       prepareImageRequest: createVisionInputObserver(inputs) });
     normalizeModelCall(modelPortSnapshot(candidates[0].port), { prompt: 'OCR',
       image: { bytes: new Uint8Array([0]), mediaType: 'image/png' } }, { budget });

package/lib/provider-adapters.js

@@ -10,8 +10,9 @@ import * as defaultTransport from './adapters.js';
 import { ProviderContractError, providerErrorRecord } from './provider-contract.js';
 import { writePrivateFile } from './private-storage.js';
 import { defineProviderAdapter } from './provider-adapter.js';
-import { selectMediaProtocol, providerApiKey, providerMediaBaseUrl, unsupportedProtocolError, supportsImageEdit } from './provider-protocol.js';
-import { modelRateLimit, reportModelRateLimit, isFreeQuotaExhausted } from './provider-health.js';
+import { selectMediaProtocol, providerApiKey, providerMediaBaseUrl, unsupportedProtocolError, supportsImageEdit, dashscopeTtsInputIssue } from './provider-protocol.js';
+import { modelRateLimit, reportModelRateLimit, isFreeQuotaExhausted, recordModelAvailability } from './provider-health.js';
+import { modelUnavailable, modelUnavailableReason, modelAvailabilityBinding } from './model-directory.js';
 import { prepareVisionImage, visionInputLimits } from './vision-image-input.js';
 
 const AMBIGUOUS_4XX = new Set([408, 409, 425, 499]);
@@ -74,6 +75,15 @@ export function mapProviderAdapterError(error, context = {}) {
   });
 }
 
+/** Remove the operation's exact key before generic redaction can truncate it. */
+function mapProviderErrorWithKey(error, context, key) {
+  const scrub = value => typeof value === 'string' && key ? value.split(key).join('[REDACTED]') : value;
+  return providerErrorRecord(mapProviderAdapterError(error, context), {
+    safeMessage: scrub(String(error?.safeMessage || error?.message || error)),
+    providerCode: scrub(error?.providerCode ?? error?.code)
+  });
+}
+
 function unsupportedCapability(capability, protocol) {
   return new ProviderContractError(
     '协议 ' + protocol + ' 不支持任务能力 ' + String(capability || ''),
@@ -174,6 +184,10 @@ function operationsForDashScope(provider, transport) {
         return { kind: 'accepted', remoteTaskId };
       }
       if (request.capability === 'tts') {
+        const issue = dashscopeTtsInputIssue(request.model, input.voice);
+        if (issue) throw new ProviderContractError(issue, {
+          stage: 'validate', category: 'invalid_request', acceptance: 'not_accepted'
+        });
         const value = await transport.synthesizeTts({
           ...common, text: input.text, voice: input.voice
         });
@@ -197,9 +211,9 @@ function operationsForDashScope(provider, transport) {
         if (!result.ok) {
           return {
             kind: pollFailureKind(result.status),
-            error: mapProviderAdapterError(result.message || '转写任务失败', {
+            error: mapProviderErrorWithKey(result.message || '转写任务失败', {
               stage: 'poll', acceptance: 'accepted'
-            })
+            }, key)
           };
         }
         // E3：转写正文物化为 text/plain Artifact（inline-base64，不再依赖签名 URL 生命周期）。
@@ -216,9 +230,9 @@ function operationsForDashScope(provider, transport) {
         if (!result.ok) {
           return {
             kind: pollFailureKind(result.status),
-            error: mapProviderAdapterError(result.message || '生成任务失败', {
+            error: mapProviderErrorWithKey(result.message || '生成任务失败', {
               stage: 'poll', acceptance: 'accepted'
-            })
+            }, key)
           };
         }
         return {
@@ -253,7 +267,7 @@ function operationsForDashScope(provider, transport) {
       };
     },
 
-    mapError: mapProviderAdapterError
+    mapError: (error, context) => mapProviderErrorWithKey(error, context, key)
   };
 }
 
@@ -336,7 +350,7 @@ function operationsForOpenAiImages(provider, transport, protocol = 'openai-image
       };
     },
 
-    mapError: mapProviderAdapterError
+    mapError: (error, context) => mapProviderErrorWithKey(error, context, key)
   };
 }
 
@@ -397,7 +411,7 @@ export function createGeminiWebMusicProviderAdapter(provider, { transport = defa
         return { kind: 'completed', artifacts };
       },
       async download({ artifact, targetPath }) { return writeInlineArtifact(artifact, targetPath); },
-      mapError: mapProviderAdapterError
+      mapError: (error, context) => mapProviderErrorWithKey(error, context, key)
     },
     unsupported: { poll: '网关 Music 没有客户端可恢复的远端任务ID', cancel: '网关 Music 不提供远端取消' },
     unsupportedPreparation: 'Music 描述输入不需要上传'
@@ -431,6 +445,23 @@ export function createConfiguredProviderAdapter(provider, options = {}) {
         retryAfterMs: error.retryAfterMs,
         source: options.allowRateLimited ? 'probe' : 'task'
       }, options.onRateLimit, request.capability);
+      const availability = result => {
+        if (name !== 'submit') return;
+        const event = { ok: result.ok === true, category: result.category,
+          httpStatus: result.httpStatus ?? result.status, providerCode: result.providerCode || result.code,
+          note: result.safeMessage || result.message,
+          stage: 'submit', source: options.allowRateLimited ? 'probe' : 'task',
+          binding: modelAvailabilityBinding(provider, modelId, capability) };
+        if (!recordModelAvailability(provider, modelId, request.capability, event)) return;
+        try { options.onModelAvailability?.({ providerId: provider.id, modelId, capability: request.capability, ...event }); }
+        catch (_) { console.warn('[iris] 模型可用性未能持久化，请检查配置写入权限'); }
+      };
+      const capability = { image: 'image-gen', video: 'video-gen', music: 'music-gen' }[request.capability] || request.capability;
+      if (name === 'submit' && !options.allowRateLimited && modelUnavailable(provider, modelId, capability)) {
+        throw new ProviderContractError(modelUnavailableReason(), {
+          stage: 'validate', category: 'invalid_request', acceptance: 'not_accepted'
+        });
+      }
       if (name === 'submit' && !options.allowRateLimited && modelRateLimit(provider, modelId)) {
         const blocked = modelRateLimit(provider, modelId);
         throw new ProviderContractError(blocked.until ? '该模型正在限流冷却，请稍后使用' : '该模型额度或预算耗尽，请手动实测成功后再使用', {
@@ -440,9 +471,11 @@ export function createConfiguredProviderAdapter(provider, options = {}) {
       try {
         const result = await run(request);
         if (result.error) report(result.error);
+        availability(result.error || { ok: ['completed', 'accepted'].includes(result.kind) });
         return result;
       } catch (error) {
         report(error);
+        availability(error);
         throw error;
       }
     };

package/lib/provider-catalog.js

@@ -4,11 +4,12 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { CAPABILITIES } from './capability.js';
-import { modelPool, orderedModels, providerModels, parseModelRef, resolveModelRef, resolvePoolModel, selectionReasonForModel } from './models.js';
+import { modelPool, functionModelPool, functionPolicy, orderedModels, providerModels, parseModelRef, resolveModelRef, resolvePoolModel, selectionReasonForModel } from './models.js';
 import { dashscopeApiBase, selectMediaProtocol, providerForImageModel, providerForMusicModel, providerMediaBaseUrl, isConfiguredProvider } from './provider-protocol.js';
 import { redactProviderMessage } from './provider-contract.js';
 import { modelRateLimit } from './provider-health.js';
 import { normalizeVisionInputLimits } from './vision-image-input.js';
+import { modelDirectorySummary, modelUnavailableReason, validateModelDirectory } from './model-directory.js';
 
 export class ProviderCatalogError extends Error {
   constructor(code, message) {
@@ -49,6 +50,8 @@ export function loadProviderCatalog(configPath) {
         || Array.isArray(parsed.assignments)))) {
     fail('IRIS_PROVIDER_CONFIG_INVALID', 'provider-config 结构无效');
   }
+  for (const [capability, assignment] of Object.entries(parsed.assignments || {})) functionPolicy(assignment, capability);
+  for (const provider of parsed.providers) validateModelDirectory(provider.modelDirectory);
   return parsed;
 }
 
@@ -58,13 +61,13 @@ const CANDIDATE_CAP_LABEL = Object.freeze({
   [CAPABILITIES.MUSIC]: '音乐'
 });
 
-/** 与 DSH 相同的严格功能名单；CLI 不附加宿主资源。 */
+/** 与 DSH 共用功能策略；CLI 不附加宿主资源。 */
 function candidatesFromCatalog(catalog, requestedModelRef, capability) {
   const label = CANDIDATE_CAP_LABEL[capability];
   if (!label) fail('IRIS_PROVIDER_TASK_OBSERVE_UNSUPPORTED', '当前 Headless 候选链只开放图片、视频、语音与转写能力');
   const providers = catalog.providers.filter(isConfiguredProvider);
-  const configuredPool = modelPool(providers).filter((item) => item.capabilities.includes(capability));
-  const pool = orderedModels(configuredPool, capability, catalog.assignments?.[capability], { includeRateLimited: true });
+  const configuredPool = functionModelPool(providers, capability, catalog.assignments?.[capability]);
+  const pool = orderedModels(configuredPool, capability, catalog.assignments?.[capability], { includeRateLimited: true, includeUnavailable: true });
   const requested = String(requestedModelRef || '').trim();
   if (requested) {
     const parsed = parseModelRef(requested);
@@ -72,6 +75,7 @@ function candidatesFromCatalog(catalog, requestedModelRef, capability) {
     const exact = resolvePoolModel(pool, requested, capability);
     if (!exact) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `指定模型未分配给${label}功能、未启用或没有所需能力`);
     const provider = providers.find((item) => item.id === exact.providerId);
+    if (exact.unavailableCapabilities?.includes(capability)) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', modelUnavailableReason());
     if (exact.rateLimited) fail('IRIS_PROVIDER_MODEL_RATE_LIMITED', modelRateLimit(provider, exact.id)?.until
       ? '指定模型正在限流冷却，请稍后使用或手动实测'
       : '指定模型额度或预算耗尽，请手动实测成功后再使用');
@@ -81,8 +85,8 @@ function candidatesFromCatalog(catalog, requestedModelRef, capability) {
     })]);
   }
   const assignment = catalog.assignments?.[capability];
-  const ordered = pool.filter(model => !model.rateLimited);
-  if (!ordered.length) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `请先给${label}功能分配当前入口可用的模型`);
+  const ordered = pool.filter(model => !model.rateLimited && !model.unavailableCapabilities?.includes(capability));
+  if (!ordered.length) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `请检查${label}功能的启用方式、已确认模型、连接和协议；当前没有可用候选`);
   return Object.freeze(ordered.map((item) => Object.freeze({
     provider: providers.find((provider) => provider.id === item.providerId),
     model: item.id,
@@ -133,20 +137,21 @@ export function providerCatalogSnapshot(catalog) {
         mediaProtocol: safeLabel(selection.mediaProtocol), protocolInferred: selection.protocolInferred,
         ...(provider.visionInput ? { visionInput: normalizeVisionInputLimits(provider.visionInput) } : {}),
         capabilities: Object.values(CAPABILITIES).filter((capability) => models.some((model) => model.capabilities.includes(capability))),
-        modelCount: models.length
+        modelCount: models.length, directory: modelDirectorySummary(provider)
       };
     })
   };
 }
 
 export function catalogCapabilitySnapshot(catalog) {
-  const pool = modelPool(catalog.providers.filter(isConfiguredProvider));
   return {
     schemaVersion: 1,
     source: 'configuration',
     capabilities: Object.values(CAPABILITIES).map((capability) => {
+      const policy = functionPolicy(catalog.assignments?.[capability], capability);
+      const pool = functionModelPool(catalog.providers.filter(isConfiguredProvider), capability, catalog.assignments?.[capability]);
       const candidates = orderedModels(pool, capability, catalog.assignments?.[capability]).map((model) => model.ref);
-      return { capability, candidates, ...(candidates.length ? {} : { gap: 'no_configured_model' }) };
+      return { capability, mode: policy.mode, candidates, ...(candidates.length ? {} : { gap: 'no_configured_model' }) };
     })
   };
 }

package/lib/provider-config-scope.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+// Resolved credentials live only in one operation's asynchronous context.
+const scope = new AsyncLocalStorage();
+
+export function scopedProvider(provider) {
+  return (provider.dshProvider && scope.getStore()?.get(provider.id)) || provider;
+}
+
+export function hasProviderConfigScope() {
+  return scope.getStore() !== undefined;
+}
+
+export function withProviderConfigScope(providers, callback) {
+  return scope.run(new Map(providers.map(provider => [provider.id, provider])), callback);
+}

package/lib/provider-config-service.js

@@ -3,14 +3,16 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { loadProviderCatalog, providerCatalogSnapshot, catalogCapabilitySnapshot } from './provider-catalog.js';
 import { isKnownCapability } from './capability.js';
-import { providerModels, modelPool, parseModelRef, HOST_VISION_REF, capabilitiesOfDiscoveredModel, hasConfiguredModelCapabilities, resolvePoolModel } from './models.js';
+import { providerModels, modelPool, functionPolicy, savedAssignmentRefs, parseModelRef, HOST_VISION_REF, capabilitiesOfDiscoveredModel, hasConfiguredModelCapabilities, resolvePoolModel } from './models.js';
 import { atomicWritePrivate, privateSibling, ensurePrivateDir } from './private-storage.js';
 import { createConfiguredProviderAdapter } from './provider-adapters.js';
-import { selectImageProtocol, normalizeImageProtocol, normalizeMusicProtocol } from './provider-protocol.js';
+import { selectImageProtocol, normalizeImageProtocol, normalizeMusicProtocol, isConfiguredProvider } from './provider-protocol.js';
 import { invokeProviderOperation } from './provider-adapter.js';
 import { redactProviderMessage } from './provider-contract.js';
-import { modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth, isDefinitiveHealthFailure } from './provider-health.js';
+import { modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth, isDefinitiveHealthFailure, recordModelAvailability, resetHealthOnCriticalChange } from './provider-health.js';
 import { normalizeVisionInputLimits, visionInputLimits } from './vision-image-input.js';
+import { currentModelDirectory, modelDirectoryBinding, modelAvailabilityBinding } from './model-directory.js';
+import { refreshModelDirectory } from './model-directory-service.js';
 
 const fail = message => { throw Object.assign(new Error(message), { code: 'IRIS_CONFIG_INPUT_INVALID' }); };
 const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
@@ -24,14 +26,18 @@ const caps = value => {
 function assignmentSnapshot(catalog) {
   const pool = modelPool(catalog.providers, { includeHostVision: true });
   return Object.fromEntries(Object.entries(catalog.assignments || {}).map(([capability, value]) => {
-    const refs = (Array.isArray(value) ? value : [value]).map(ref => resolvePoolModel(pool, ref, capability));
-    return [safe(capability), { model_refs: refs.filter(Boolean).map(model => safe(model.ref)), invalidRefs: refs.filter(ref => !ref).length }];
+    const policy = functionPolicy(value, capability);
+    const refs = policy.models.map(ref => resolvePoolModel(pool, ref, capability));
+    return [safe(capability), { mode: policy.mode, hostVision: policy.hostVision,
+      model_refs: refs.filter(Boolean).map(model => safe(model.ref)), invalidRefs: refs.filter(ref => !ref).length }];
   }));
 }
 
 export function configSnapshot(catalog) {
   return { ...providerCatalogSnapshot(catalog), models: catalog.providers.flatMap(provider => providerModels(provider).map(model => ({
     ref: safe(model.ref), providerId: safe(provider.id), id: safe(model.id), capabilities: model.capabilities,
+    ...(model.catalogStatus ? { catalogStatus: model.catalogStatus } : {}),
+    ...(model.unavailableCapabilities ? { unavailableCapabilities: model.unavailableCapabilities } : {}),
     ...(model.imageProtocol !== undefined ? { imageProtocol: model.imageProtocol } : {}),
     ...(model.musicProtocol !== undefined ? { musicProtocol: model.musicProtocol } : {}),
     ...(model.visionInput !== undefined ? { visionInput: model.visionInput } : {}),
@@ -73,7 +79,8 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
     }
     for (const [capability, assignment] of Object.entries(catalog.assignments || {})) {
       if (!isKnownCapability(capability)) issues.push('unknown_assignment_capability');
-      for (const ref of (Array.isArray(assignment) ? assignment : [assignment])) if (!resolvePoolModel(pool, ref, capability)) issues.push('unavailable_assignment_model');
+      const policy = functionPolicy(assignment, capability);
+      if (policy.mode === 'manual') for (const ref of policy.models) if (!resolvePoolModel(pool, ref, capability)) issues.push('unavailable_assignment_model');
     }
     return { valid: issues.length === 0, issues: [...new Set(issues)] };
   }
@@ -116,6 +123,7 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
           clearModelCapabilityHealth(updated, model.id, 'image-gen');
         }
       }
+      resetHealthOnCriticalChange(provider, updated, value);
     }
     if (provider) catalog.providers[catalog.providers.indexOf(provider)] = updated;
     else catalog.providers.push(updated);
@@ -134,6 +142,9 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       const models = discovered.models.map(model => ({ id: text(typeof model === 'string' ? model : model.id), capabilities: capabilitiesOfDiscoveredModel(model), source: 'discovered' }));
       result = { command, changed: input.apply === true, total: models.length, mediaCount: models.filter(model => model.capabilities.length).length, models: models.map(model => ({ ...model, id: safe(model.id) })) };
       if (input.apply !== true) return result;
+      provider.modelDirectory = { version: 1, binding: modelDirectoryBinding(provider), checkedAt: new Date().toISOString(),
+        models: models.map(({ id, capabilities }) => ({ id, capabilities })),
+        added: models.filter(model => !entries.some(entry => entry.id === model.id)).map(model => model.id) };
       for (const model of models) {
         const old = entries.find(value => value.id === model.id);
         if (!old) entries.push(model);
@@ -181,12 +192,14 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       const tested = await probe({ provider, modelId, capability: input.capability, signal });
       if (tested.skipped) return { command, changed: false, ...tested };
       const evidence = { at: new Date().toISOString(), source: 'probe', category: tested.category || (tested.ok ? 'success' : 'unknown'),
+        ...(tested.providerCode ? { providerCode: safe(tested.providerCode) } : {}),
         ...(tested.httpStatus || tested.status ? { httpStatus: tested.httpStatus || tested.status } : {}) };
       entry.verified = { ...(entry.verified || {}), [input.capability]: { ok: tested.ok === true, ...evidence } };
       provider.health ||= { version: 1, revision: 0, observations: [] };
       const observations = provider.health.observations;
       let observation = observations.find(value => value.modelId === modelId && value.capability === input.capability);
       if (!observation) { observation = { modelId, capability: input.capability }; observations.push(observation); }
+      recordModelAvailability(provider, modelId, input.capability, { ...tested, ...evidence });
       if (tested.ok === true) { observation.lastSuccess = evidence; clearModelRateLimit(provider, modelId); }
       else {
         observation[isDefinitiveHealthFailure(evidence) ? 'lastFailure' : 'lastTransient'] = evidence;
@@ -195,11 +208,34 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       result = { command, changed: true, passed: tested.ok === true, ...(tested.taskId ? { taskId: tested.taskId } : {}), ...(tested.code ? { code: tested.code } : {}) };
     } else fail('未知模型命令');
     provider.models = entries;
+    if (['models.add', 'models.caps'].includes(command) && input.enableAutomatic !== undefined) {
+      if (typeof input.enableAutomatic !== 'boolean') fail('enableAutomatic 必须是布尔值');
+      if (input.enableAutomatic) for (const capability of caps(input.capabilities)) {
+        catalog.assignments ||= {};
+        const previous = functionPolicy(catalog.assignments[capability], capability);
+        catalog.assignments[capability] = { mode: 'auto', models: savedAssignmentRefs(modelPool(catalog.providers, { includeHostVision: true }), capability, previous.models),
+          ...(capability === 'vision' ? { hostVision: previous.hostVision } : {}) };
+      }
+    }
   } else if (command === 'assignments.set' || command === 'assignments.clear') {
     if (!isKnownCapability(input.capability)) fail('未知能力');
     catalog.assignments ||= {};
     if (command === 'assignments.clear') delete catalog.assignments[input.capability];
-    else {
+    else if (input.mode !== undefined) {
+      const previous = functionPolicy(catalog.assignments[input.capability], input.capability);
+      const next = { mode: input.mode, models: savedAssignmentRefs(modelPool(catalog.providers, { includeHostVision: true }), input.capability, previous.models),
+        ...(input.capability === 'vision' ? { hostVision: input.hostVision ?? previous.hostVision } : {}) };
+      functionPolicy(next, input.capability);
+      if (input.hostVision && input.capability !== 'vision') fail('hostVision 仅用于视觉');
+      if (input.model_refs !== undefined) {
+        if (!Array.isArray(input.model_refs) || new Set(input.model_refs).size !== input.model_refs.length) fail('model_refs 必须是不重复的引用数组');
+        const pool = modelPool(catalog.providers, { includeHostVision: true });
+        for (const ref of input.model_refs) if ((typeof ref !== 'string' || (!parseModelRef(ref) && ref !== HOST_VISION_REF))
+            || !resolvePoolModel(pool, ref, input.capability)) fail('分配模型不存在或没有该能力');
+        next.models = input.model_refs;
+      }
+      catalog.assignments[input.capability] = next;
+    } else {
       if (!Array.isArray(input.model_refs) || new Set(input.model_refs).size !== input.model_refs.length) fail('model_refs 必须是不重复的复合引用数组');
       const pool = modelPool(catalog.providers, { includeHostVision: true });
       for (const ref of input.model_refs) if ((!parseModelRef(ref) && ref !== HOST_VISION_REF) || !resolvePoolModel(pool, ref, input.capability)) fail('分配模型不存在或没有该能力');
@@ -211,8 +247,9 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
   if (command === 'providers.remove' || command === 'models.remove' || command === 'models.caps') {
     const pool = modelPool(catalog.providers);
     for (const [capability, assignment] of Object.entries(catalog.assignments || {})) {
-      const values = (Array.isArray(assignment) ? assignment : [assignment]).filter(ref => resolvePoolModel(pool, ref, capability) || !resolvePoolModel(initialPool, ref, capability));
-      if (!values.length) delete catalog.assignments[capability];
+      const values = functionPolicy(assignment, capability).models.filter(ref => resolvePoolModel(pool, ref, capability) || !resolvePoolModel(initialPool, ref, capability));
+      if (assignment && typeof assignment === 'object' && !Array.isArray(assignment) && Object.hasOwn(assignment, 'mode')) catalog.assignments[capability] = { ...assignment, models: values };
+      else if (!values.length) delete catalog.assignments[capability];
       else catalog.assignments[capability] = Array.isArray(assignment) ? values : values[0];
     }
   }
@@ -230,7 +267,37 @@ export function recordCatalogRateLimit(configPath, event) {
   return writeConfigChange(configPath, catalog, before, { changed: true });
 }
 
-function writeConfigChange(configPath, catalog, before, result) {
+/** CLI真实提交的可用性证据，复用同一配置锁；不为可重建元数据新增备份。 */
+export function recordCatalogAvailability(configPath, { providerId, modelId, capability, ...event }) {
+  const catalog = loadProviderCatalog(configPath);
+  const before = fs.readFileSync(configPath);
+  const provider = catalog.providers.find(item => item.id === providerId);
+  const cap = { image: 'image-gen', video: 'video-gen', music: 'music-gen' }[capability] || capability;
+  if (!provider || (event.binding && modelAvailabilityBinding(provider, modelId, cap) !== event.binding)
+      || !recordModelAvailability(provider, modelId, capability, event)) return;
+  const directory = currentModelDirectory(provider);
+  if (directory && event.ok !== true) directory.invalidatedAt = event.at || new Date().toISOString();
+  return writeConfigChange(configPath, catalog, before, { changed: true }, { backup: false });
+}
+
+/** 新的自动请求按需读取目录；只读CLI命令与手选/停用不走这里。 */
+export async function refreshCatalogDirectories(configPath, catalog, capability, { signal } = {}) {
+  if (functionPolicy(catalog.assignments?.[capability], capability).mode !== 'auto') return [];
+  return Promise.all(catalog.providers.filter(provider => isConfiguredProvider(provider)
+    && providerModels(provider).some(model => model.capabilities.includes(capability))).map(provider =>
+    refreshModelDirectory(provider, { signal, save: directory => {
+      const fresh = loadProviderCatalog(configPath);
+      const before = fs.readFileSync(configPath);
+      const current = fresh.providers.find(item => item.id === provider.id);
+      if (!current || modelDirectoryBinding(current) !== directory.binding) return false;
+      current.modelDirectory = directory;
+      writeConfigChange(configPath, fresh, before, { changed: true }, { backup: false });
+      provider.modelDirectory = directory;
+      return true;
+    } })));
+}
+
+function writeConfigChange(configPath, catalog, before, result, { backup = true } = {}) {
   const lock = configPath + '.lock';
   let fd;
   try { fd = fs.openSync(lock, 'wx', 0o600); }
@@ -238,10 +305,12 @@ function writeConfigChange(configPath, catalog, before, result) {
   try {
     loadProviderCatalog(configPath);
     if (hash(fs.readFileSync(configPath)) !== hash(before)) throw Object.assign(new Error('配置在操作期间发生变化，请重新读取后重试'), { code: 'IRIS_CONFIG_CHANGED' });
-    const backupPath = privateSibling(configPath, 'backup');
-    fs.writeFileSync(backupPath, before, { flag: 'wx', mode: 0o600 });
+    if (backup) {
+      const backupPath = privateSibling(configPath, 'backup');
+      fs.writeFileSync(backupPath, before, { flag: 'wx', mode: 0o600 });
+      result.backupPath = backupPath;
+    }
     atomicWritePrivate(configPath, JSON.stringify(catalog, null, 2) + '\n');
-    result.backupPath = backupPath;
     return result;
   } finally { fs.closeSync(fd); fs.unlinkSync(lock); }
 }

package/lib/provider-health.js

@@ -1,4 +1,37 @@
 'use strict';
+import { isKnownCapability } from './capability.js';
+import { isModelNotFound, modelAvailabilityBinding, modelUnavailable } from './model-directory.js';
+
+const HEALTH_SENSITIVE_FIELDS = new Set([
+  'auth', 'type', 'baseUrl', 'mediaBaseUrl', 'apiKey', 'mediaProtocol',
+  'imageModel', 'videoModel', 'ttsModel', 'transcribeModel', 'visionModel'
+]);
+
+/** 明确修改连接后旧健康证据失效；额度停用仍需显式实测解除。 */
+export function resetHealthOnCriticalChange(previous, next, patch) {
+  if (![...HEALTH_SENSITIVE_FIELDS].some(key => Object.hasOwn(patch, key) && previous[key] !== next[key])) return;
+  const current = previous.health;
+  next.health = { version: 1, revision: (Number.isSafeInteger(current?.revision) ? current.revision : 0) + 1,
+    observations: [], ...(current?.rateLimits?.length ? { rateLimits: current.rateLimits } : {}) };
+}
+
+/** 仅提交或显式实测更新模型可选性，远端旧任务的观察不解除阻断。 */
+export function recordModelAvailability(provider, modelId, capability, result) {
+  const cap = { image: 'image-gen', video: 'video-gen', music: 'music-gen' }[capability] || capability;
+  if (!modelId || !isKnownCapability(cap)) return false;
+  let observation = provider.health?.observations?.find(item => item.modelId === modelId && item.capability === cap);
+  const blocked = isModelNotFound(result);
+  if (!blocked && !(result.ok === true && (result.source === 'probe' || result.stage === 'submit')
+      && (observation?.availability?.state === 'blocked' || modelUnavailable(provider, modelId, cap)))) return false;
+  provider.health ||= { version: 1, revision: 0, observations: [] };
+  provider.health.observations ||= [];
+  observation ||= provider.health.observations.find(item => item.modelId === modelId && item.capability === cap);
+  if (!observation) { observation = { modelId, capability: cap }; provider.health.observations.push(observation); }
+  observation.availability = { state: blocked ? 'blocked' : 'available', at: result.at || new Date().toISOString(),
+    binding: result.binding || modelAvailabilityBinding(provider, modelId, cap), source: result.source === 'probe' ? 'probe' : 'task',
+    ...(blocked ? { httpStatus: 404, reason: 'model_not_found' } : {}) };
+  return true;
+}
 
 export const PROVIDER_HEALTH_SCHEMA_VERSION = 1;
 export const PROVIDER_HEALTH_FRESH_MS = 7 * 24 * 60 * 60 * 1000;

package/lib/provider-protocol.js

@@ -114,6 +114,36 @@ export function isConfiguredProvider(provider) {
     && (provider.auth === 'none' || (typeof provider.apiKey === 'string' && provider.apiKey.trim())));
 }
 
+/** 已知需要其他接口的语音系列；自定义模型仍以明确配置和实测为准。 */
+export function dashscopeTtsProtocolIssue(modelId) {
+  const model = String(modelId || '');
+  if (/^qwen(?:\d+(?:\.\d+)?)?-(?:tts|omni|audio)-.*realtime(?:-|$)/i.test(model)) {
+    return '该实时语音模型需要 WebSocket，Iris 尚未接入该调用方式';
+  }
+  if (/^(?:qwen-audio-|cosyvoice(?:-|$)|sambert-|MiniMax\/speech-)/i.test(model)) {
+    return 'Iris 尚未接入该语音系列的合成接口；当前使用 Qwen-TTS 普通 HTTP 接口';
+  }
+  return '';
+}
+
+/** 复刻/设计模型不能沿用普通模型的默认音色。 */
+export function dashscopeTtsInputIssue(modelId, voice) {
+  return dashscopeTtsProtocolIssue(modelId)
+    || (/^qwen(?:\d+)?-tts-(?:vc|vd)(?:-|$)/i.test(String(modelId || '')) && !String(voice || '').trim()
+      ? '该模型需要先创建复刻或设计音色；请在语音功能填写与该模型匹配的音色 ID 后验证'
+      : '');
+}
+
+/** Protocol support is independent from model capability declarations and health. */
+export function supportsModelCapability(provider, modelId, capability, { checkEndpoint = true } = {}) {
+  if (capability === 'vision') return true;
+  if (capability === 'music-gen') return provider?.models?.some(model => model?.id === modelId && model.musicProtocol === 'gemini-web-music') === true;
+  const protocol = capability === 'image-gen' ? selectImageProtocol(provider, modelId).mediaProtocol : selectMediaProtocol(provider).mediaProtocol;
+  if (protocol === 'dashscope') return (capability !== 'tts' || !dashscopeTtsProtocolIssue(modelId))
+    && (!checkEndpoint || isDashScopeBaseUrl(providerMediaBaseUrl(provider)));
+  return capability === 'image-gen' && ['openai-images', 'openai-chat-images', 'openai-responses-images'].includes(protocol);
+}
+
 /**
  * 生图尺寸的协议差异集中在这里，调用点不再自带厂商假设。
  *