@mokuyoaxis/dsh-iris 0.2.4 → 0.2.6

package/lib/model-directory.js

@@ -0,0 +1,103 @@
+import crypto from 'node:crypto';
+import { isKnownCapability } from './capability.js';
+import { providerApiKey, providerMediaBaseUrl, selectMediaProtocol, providerForImageModel, providerForMusicModel } from './provider-protocol.js';
+
+export const MODEL_DIRECTORY_TTL_MS = 10 * 60 * 1000;
+export const MODEL_DIRECTORY_RETRY_MS = 30 * 1000;
+
+/** 配置是外部输入，目录只接受不含连接凭据的固定数据形状。 */
+export function validateModelDirectory(value) {
+  if (value === undefined) return;
+  if (!value || value.version !== 1 || !/^[a-f0-9]{64}$/.test(value.binding)
+      || (value.checkedAt !== undefined && !Number.isFinite(Date.parse(value.checkedAt)))
+      || (value.checkedAt && !Array.isArray(value.models))
+      || (value.models !== undefined && (!Array.isArray(value.models) || value.models.some(model =>
+        !model || typeof model.id !== 'string' || !model.id.trim() || !Array.isArray(model.capabilities)
+        || !model.capabilities.every(isKnownCapability))))
+      || (value.added !== undefined && (!Array.isArray(value.added) || !value.added.every(id => typeof id === 'string')))) {
+    throw new TypeError('模型目录快照结构无效');
+  }
+}
+
+/** 摘要绑定实际连接，不保存或回传密钥。 */
+export function modelDirectoryBinding(provider) {
+  return crypto.createHash('sha256').update(JSON.stringify([
+    provider.id, provider.type || '', provider.baseUrl || '', providerMediaBaseUrl(provider), selectMediaProtocol(provider).mediaProtocol,
+    provider.auth || 'bearer', providerApiKey(provider)
+  ])).digest('hex');
+}
+
+export function currentModelDirectory(provider, { allowUnresolvedConnections = false } = {}) {
+  const directory = provider?.modelDirectory;
+  if (!directory || directory.version !== 1) return null;
+  if (directory.binding === modelDirectoryBinding(provider)) return directory;
+  return allowUnresolvedConnections && provider.dshProvider && !provider.baseUrl ? directory : null;
+}
+
+export function modelAvailabilityBinding(provider, modelId, capability) {
+  if (capability === 'image-gen') return modelDirectoryBinding(providerForImageModel(provider, modelId));
+  if (capability === 'music-gen' && provider.models?.some(model => model?.id === modelId && model.musicProtocol)) {
+    return modelDirectoryBinding(providerForMusicModel(provider, modelId));
+  }
+  return modelDirectoryBinding(provider);
+}
+
+export function modelDirectoryEntry(provider, modelId, options) {
+  return currentModelDirectory(provider, options)?.models?.find(model => model.id === modelId) || null;
+}
+
+export function modelDirectoryStatus(provider, modelId) {
+  const directory = currentModelDirectory(provider, { allowUnresolvedConnections: true });
+  if (!directory?.checkedAt) return 'unknown';
+  return directory.models.some(model => model.id === modelId) ? 'listed' : 'unlisted';
+}
+
+/** 普通请求路径404或参数400不代表模型不存在。兼容已有精确404记录。 */
+export function isModelNotFound(result) {
+  if (result?.stage === 'poll') return false;
+  const status = Number(result?.httpStatus ?? result?.status);
+  if (status !== 404) return false;
+  const code = String(result?.providerCode || result?.code || '');
+  const message = String(result?.note || result?.safeMessage || result?.message || '');
+  return /^(?:NotFound\.Model|model_not_found|ModelNotFound)$/i.test(code)
+    || /\bModel not exist\./i.test(message);
+}
+
+/** 当前可选性与历史成功分开；旧Task成功不能解除新提交已确认的阻断。 */
+export function modelUnavailable(provider, modelId, capability, { allowUnresolvedConnections = false } = {}) {
+  const observation = provider?.health?.observations?.find(item => item.modelId === modelId && item.capability === capability);
+  const availability = observation?.availability;
+  if (availability) {
+    if (availability.binding !== modelAvailabilityBinding(provider, modelId, capability)
+        && !(allowUnresolvedConnections && provider.dshProvider && !provider.baseUrl)) return null;
+    return availability.state === 'blocked' ? availability : null;
+  }
+  const failure = [observation?.lastTransient, observation?.lastFailure].filter(isModelNotFound)
+    .sort((a, b) => String(b.at).localeCompare(String(a.at)))[0];
+  if (!failure) return null;
+  if (observation.lastSuccess?.source === 'probe' && observation.lastSuccess.at >= failure.at) return null;
+  return { ...failure, state: 'blocked' };
+}
+
+export function modelUnavailableReason() {
+  return '当前连接已返回模型不存在，已暂停自动选用；请核对目录后单独实测恢复';
+}
+
+export function modelDirectorySummary(provider) {
+  const directory = currentModelDirectory(provider, { allowUnresolvedConnections: true });
+  if (!directory) return { status: 'unknown', note: '尚未同步当前连接的模型目录' };
+  const models = directory.models || [];
+  const configuredIds = Array.isArray(provider.models)
+    ? provider.models.map(model => typeof model === 'string' ? model : model.id)
+    : [...new Set(['imageModel', 'videoModel', 'ttsModel', 'musicModel', 'transcribeModel', 'visionModel']
+      .map(field => provider[field]).filter(id => typeof id === 'string' && id.trim()).map(id => id.trim()))];
+  const missing = directory.checkedAt ? configuredIds.filter(id => !models.some(model => model.id === id)) : [];
+  const stale = Boolean(directory.lastError) || Date.now() - Date.parse(directory.checkedAt || '') >= MODEL_DIRECTORY_TTL_MS
+    || Date.parse(directory.invalidatedAt || '') >= Date.parse(directory.checkedAt || '');
+  return {
+    status: directory.checkedAt ? stale ? 'stale' : 'current' : 'unknown',
+    checkedAt: directory.checkedAt || null, modelCount: models.length,
+    added: directory.added || [], missing,
+    ...(directory.lastError ? { error: directory.lastError, failedAt: directory.failedAt } : {})
+  };
+}

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