@mokuyoaxis/dsh-iris 0.2.4 → 0.2.6

package/docs/VISION_CLI.md

@@ -1,6 +1,6 @@
 # 独立视觉 CLI
 
-状态：**Iris 0.2.2**。安装 `npm install @mokuyoaxis/dsh-iris@0.2.2` 后运行 `npx dsh-iris ...`，或从源码运行 `node bin/dsh-iris.js ...`。需要 Node.js ≥ 22、已有依赖 Sharp；从视频文件抽帧还需要 PATH 中的 ffmpeg、ffprobe，复用既有 Core 帧不需要。
+版本要求：**Iris 0.2.6**。发布状态见 [README](../README.md)；安装 `npm install @mokuyoaxis/dsh-iris@0.2.6` 后运行 `npx dsh-iris ...`，或从源码运行 `node bin/dsh-iris.js ...`。需要 Node.js ≥ 22、依赖 Sharp；从视频文件抽帧还需要 PATH 中的 ffmpeg、ffprobe，复用既有 Core 帧不需要。
 
 ## 四个命令
 
@@ -95,7 +95,7 @@ dsh-iris vision summarize \
 }
 ```
 
-0.2.4省略 `--model-ref` 时仅按 `assignments.vision` 名单排序，不补入模型池。只有本地不可用、明确拒绝或正常空正文才允许下一候选；截断、未知终态、收到正文后的失败、取消和超时停止调用。显式 `--model-ref providerId::modelId` 须已分配且只绑定该账号与模型，失败不会替换；新视觉命令不接受裸模型名。模型需启用并声明vision能力，未配置时直接失败。自持视觉支持OpenAI-compatible Chat Completions SSE；CLI不能执行DSH宿主视觉资源。见 [功能模型分配](FUNCTION_MODEL_ASSIGNMENTS.md)。
+省略 `--model-ref` 时按视觉功能策略排序：自动池使用已确认用途的合格模型，手选模式只用 `assignments.vision` 名单，停用不调用。只有本地不可用、明确拒绝或正常空正文才允许下一候选；截断、未知终态、收到正文后的失败、取消和超时停止调用。显式 `--model-ref providerId::modelId` 须在允许范围内且只绑定该账号与模型，失败不会替换；视觉命令不接受裸模型名。模型需启用并声明 vision 能力，未配置时直接失败。自持视觉支持 OpenAI-compatible Chat Completions SSE；CLI 不能执行 DSH 宿主视觉资源。见 [功能模型池](FUNCTION_MODEL_POOLS.md)。
 
 成功JSON携带实际`modelRef`、`selectionReason`（`explicit` / `assignment`）、模型身份、正常终态及可用usage；旧记录的`pool`来源仍可读取。OCR实际选择保留在每个成功块上。配置凭据、端点和原始错误响应不会出现在诊断中；模型回答和OCR正文是用户内容。
 

package/docs/releases/0.2.5.md

@@ -0,0 +1,33 @@
+# Iris 0.2.5：旧宿主继续使用当前功能
+
+0.2.5恢复当前Iris在旧DSH上的支持，将准确版本范围从2个扩展至12个。已验证的旧宿主可使用同一套Music、图片导入、原生Qwen改图和其他现有功能，无需停留在Iris0.1.4。
+
+## DSH版本范围
+
+- `0.1.2-rc.1`
+- `0.1.5-rc.1`、`0.1.5-rc.2`、`0.1.5-rc.3`
+- `0.1.7-rc.1`、`0.1.7-rc.2`
+- `0.2.0-rc.1`、`0.2.0-rc.2`
+- `0.2.1-alpha.1`、`0.2.1-alpha.2`、`0.2.1-alpha.3`、`0.2.1-alpha.4`
+
+engines、可选客户端peer和Doctor同步使用上述范围。保留旧DSH时仍需Node.js ≥22.0.0；宿主自身要求更高时以宿主为准。未列出的版本需单独验收。见 [兼容矩阵](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.5/docs/DSH_COMPATIBILITY.md)。
+
+## 视觉桥接修正
+
+默认视觉按宿主实际接口能力启用精确模型路由，修复旧SDK已有相同接口却进入历史路径、可能返回空结果或忽略失败终态的问题。旧版同样确认图片输入能力并处理取消；Core、Provider和数据格式保持，未增加生产依赖。
+
+## 安装与升级
+
+```bash
+dsh plugin --profile web add @mokuyoaxis/dsh-iris@0.2.5
+```
+
+将`web`替换为实际profile，更新后重载后端并刷新页面，用Iris宿主诊断确认17工具、3项Skill和客户端版本。独立CLI可使用`npm install @mokuyoaxis/dsh-iris@0.2.5`。
+
+从较早版本升级时，六类模型功能都需明确分配；DSH默认视觉也需加入视觉名单。见 [功能分配与升级说明](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.5/docs/FUNCTION_MODEL_ASSIGNMENTS.md)。本版不迁移旧任务、作品或个人配置。
+
+## 验证范围
+
+12个准确版本及现有根0.1.5-rc.1/组件rc.2混合安装，共13组官方SDK组合通过工具、附件、模型路由、HTTP和界面插槽隔离检查；旧Profile/Boot另通过实际tarball安装和装载。
+
+模型响应使用离线夹具，Music/Qwen检查验证协议与作品交付。React/DOM和部分会话数据使用fixture；完整浏览器/移动端交互、草稿写回、热更新和从Iris0.1.4个人数据整体升级仍需实际使用验证。见 [用户指南](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.5/user_guide.md)。

package/docs/releases/0.2.6.md

@@ -0,0 +1,50 @@
+# Iris 0.2.6：连接复用、功能模型池与目录同步
+
+0.2.6 减少首次配置的重复操作，并根据当前连接的目录和明确失败更新候选状态。安装要求见 [README](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/README.md)，本版升级方式与验证范围如下。
+
+## 配置与模型选择
+
+- 工作台可引用 DSH 已有的 API Key 连接，只保存连接标识，操作时取得地址与凭据；也可继续手动配置。缺少宿主接口、OAuth 或自定义认证时明确说明限制。独立 CLI 仍使用显式私有配置。
+- 六类功能可选自动池、仅用所选模型或停用。首次确认模型用途时可同时启用所选功能的自动池，免去再次分配。自动池按登记顺序选择，只有明确未受理才安全切换，没有跨请求轮转。
+- 旧手工名单、缺失/空分配及停用状态不会自动启用或扩池。新发现模型须确认用途；临时指定须在当前功能允许范围内且只调用该项。
+
+详见 [连接复用](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/DSH_PROVIDER_CONNECTIONS.md) 和 [功能模型池](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/FUNCTION_MODEL_POOLS.md)。
+
+## 目录与能力检测
+
+自动请求前按需同步完整目录，成功缓存 10 分钟，同连接并发合并；失败保留旧快照并短暂退避。目录未列出不证明模型下线，不删除手工配置。当前连接在新提交或实测中明确返回模型不存在时，仅隔离该模型及能力，保留历史成功；核对后可单项实测恢复，旧任务查询不改变此阻断。
+
+能力状态卡提供检测直达、配置检查与单模型实测。实测先确认费用，忙碌时防止重复提交；未知结果提示核对已有记录。视频、音乐、转写引导至真实任务，不提交空样本探针。
+
+TTS 会预先说明尚未支持的实时 WebSocket/其他语音接口，以及复刻/设计模型的专用音色要求。模型不存在错误提供模型 ID、请求域名及地域/协议排查方向。这些修正不承诺任意账号的模型当前可用，见 [能力健康](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/PROVIDER_HEALTH.md)。
+
+## 工作台与安全修正
+
+工作台统一卡片与控件样式并收紧留白。能力检测、功能池与高级分区默认折叠，保留摘要、草稿及正在执行的请求。关闭时只显示“展开”，打开时只显示“收起”；客户端会原位更新旧样式，避免旧 CSS 残留导致双文案。
+
+媒体适配层在截断错误前移除本次已知密钥，覆盖无固定前缀 API Key 的上游回显。`sharp` 最低版本提高至 `0.35.5` 并更新锁文件，处理 librsvg 高危公告；见 [安全边界](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/SECURITY.md#图像处理依赖)。
+
+## 安装与升级
+
+```bash
+dsh plugin --profile web add @mokuyoaxis/dsh-iris@0.2.6
+```
+
+独立 CLI：
+
+```bash
+npm install @mokuyoaxis/dsh-iris@0.2.6
+npx dsh-iris --help
+```
+
+将 `web` 替换为实际 profile。先备份 Iris 私有数据，升级后让 DSH 服务端加载新代码，再刷新页面；宿主诊断应显示一致的 0.2.6。只刷新网页而服务端仍旧时，策略切换会被暂停并提示重启。
+
+Node.js 最低仍为 22.0.0，DSH 声明沿用 0.2.5 的 12 个准确版本，见 [兼容矩阵](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/DSH_COMPATIBILITY.md)。连接复用按实际公开服务检测，缺少服务的宿主保留手动配置。
+
+读取旧配置不自动迁移。用户主动启用新策略或目录同步后会保存相应可选字段；回退旧版前应使用升级前备份，不能假定旧版识别新的策略对象。已有任务继续按原模型、协议与端点绑定观察或补交付；池中有其他模型也不会使已受理任务重新生成。
+
+## 验证范围与保留限制
+
+本版验证覆盖离线协议/任务回归、凭据隔离和错误脱敏、DSH 公开服务隔离以及实际 Chromium 中的工作台流程。模型响应使用本地夹具，不能据此宣称真实 TTS 已恢复或保证上游可用率。
+
+完整 Android 真机触摸、实际热更新、长任务进程重启接管，以及从 Iris 0.1.4 个人数据整体升级仍需单独验收。作品、回收区和同步缓存仍需用户管理磁盘占用；Music 已有显式 502 重发规则可能增加费用，见 [音乐生成](https://github.com/mokuyoaxis/dsh-iris/blob/v0.2.6/docs/MUSIC.md)。

package/lib/actions.js

@@ -31,13 +31,21 @@ import { formatOcrResult } from './ocr.js';
 import { runOcrRequest } from './ocr-model-routing.js';
 import { ffmpegAvailable, extractFrames, probeVideo } from './media-probe.js';
 import { ensurePrivateDir, writePrivateFile } from './private-storage.js';
-import { selectMediaProtocol, selectImageProtocol, providerForImageModel, supportsImageEdit } from './provider-protocol.js';
+import { selectMediaProtocol, selectImageProtocol, providerForImageModel, supportsImageEdit, supportsModelCapability, dashscopeTtsProtocolIssue, dashscopeTtsInputIssue } from './provider-protocol.js';
 import { musicCandidatesFromCatalog, providerTaskBinding } from './provider-catalog.js';
 import { invokeProviderOperation, providerPollTaskView, prepareProviderInput } from './provider-adapter.js';
 import { createConfiguredProviderAdapter as createProviderAdapter } from './provider-adapters.js';
 import { deriveUserState } from './task-semantics.js';
 import { normalizeGenerationInput } from './generation-input.js';
 import { videoTaskCandidates } from './video-input.js';
+import { normalizeDshProvider, withDshProviderConfig } from './dsh-provider-config.js';
+import { modelDirectorySummary, modelUnavailableReason } from './model-directory.js';
+
+const PROVIDER_ACTIONS = new Set(['image', 'image_edit', 'video', 'music', 'tts', 'transcribe', 'look', 'relook',
+  'locate', 'ocr', 'media_summarize', 'task_reobserve', 'task_redeliver', 'task_manual_retry',
+  'providers_discover', 'providers_sync_directory', 'providers_test_vision', 'providers_test_model']);
+const AUTO_DIRECTORY_ACTIONS = new Set(['image', 'image_edit', 'video', 'music', 'tts', 'transcribe', 'look', 'relook',
+  'locate', 'ocr', 'media_summarize']);
 
 const MEDIA_TYPES = {
   '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
@@ -46,6 +54,7 @@ const MEDIA_TYPES = {
 
 function createConfiguredProviderAdapter(provider, options = {}) {
   return createProviderAdapter(provider, { ...options,
+    onModelAvailability: event => store.recordAvailability(event),
     onRateLimit: options.allowRateLimited ? undefined : store.recordRateLimit });
 }
 
@@ -92,11 +101,14 @@ function throwIfAborted(signal) {
  * 不因后续轮询或结果下载失败重提，避免同一请求重复计费。
  */
 function selectProviders(capability, label, requestedModelRef) {
+  const policy = models.functionPolicy(store.assignments()[capability], capability);
+  if (policy.mode === 'disabled') throw new Error('iris: 没有可用' + label + '模型：此功能已停用，请在功能池中选择调用方式');
   let providers = store.pickAllFor(capability);
   const requested = String(requestedModelRef || '').trim();
   if (requested) {
-    const pool = models.orderedModels(models.modelPool(store.providers()), capability, store.assignments()[capability], { includeRateLimited: true });
+    const pool = models.orderedModels(models.functionModelPool(store.providers(), capability, store.assignments()[capability]), capability, store.assignments()[capability], { includeRateLimited: true, includeUnavailable: true });
     const selected = models.resolvePoolModel(pool, requested, capability);
+    if (selected?.unavailableCapabilities?.includes(capability)) throw new Error('iris: ' + modelUnavailableReason());
     if (selected?.rateLimited) throw Object.assign(new Error(store.modelHealth(selected.providerId, selected.id, capability).retryAt
       ? 'iris: 指定模型正在限流冷却，请稍后使用或手动实测'
       : 'iris: 指定模型额度或预算耗尽，请手动实测成功后再使用'), {
@@ -106,7 +118,7 @@ function selectProviders(capability, label, requestedModelRef) {
     providers = selected ? providers.filter((p) => p.id === selected.providerId && p[field] === selected.id) : [];
     if (!providers.length) throw new Error('iris: 指定模型未分配给该功能、不可用或不具备' + label + '能力');
   }
-  if (!providers.length) throw new Error('iris: 没有可用' + label + '供应商——先在 Iris 设置里添加、标注并分配模型');
+  if (!providers.length) throw new Error('iris: 没有可用' + label + '模型：请检查连接、已确认的模型用途、协议和冷却状态；手选模式还需选择模型');
   return providers;
 }
 
@@ -161,13 +173,13 @@ async function observeProviderCapability(route, capability, operation, { recordS
     const result = await operation();
     if (recordSuccess && result && ['accepted', 'completed', 'pending', 'succeeded'].includes(result.kind)) {
       recordProviderHealthSafe(route.provider.id, route.model, capability, {
-        ok: true,
+        ok: true, stage: 'poll',
         category: 'success',
         note: result.kind === 'accepted' ? '任务已受理' : '供应商请求成功'
       });
     } else if (result && result.error) {
       recordProviderHealthSafe(route.provider.id, route.model, capability, {
-        ok: false,
+        ok: false, stage: 'poll',
         category: result.error.category,
         httpStatus: result.error.httpStatus,
         note: result.error.safeMessage
@@ -176,7 +188,7 @@ async function observeProviderCapability(route, capability, operation, { recordS
     return result;
   } catch (error) {
     recordProviderHealthSafe(route.provider.id, route.model, capability, {
-      ok: false,
+      ok: false, stage: 'poll',
       category: error && error.category,
       httpStatus: error && (error.httpStatus ?? error.status),
       note: String(error && (error.safeMessage || error.message) || error)
@@ -200,7 +212,8 @@ function recordVisionHealth(errors) {
 
 async function askSingleVisionWithHealth(host, request) {
   try {
-    const result = await runVisionRequest(host, { providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit, ...request });
+    const result = await runVisionRequest(host, { providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit,
+      onModelAvailability: store.recordAvailability, ...request });
     recordVisionHealth(result.errors);
     if (result.via === 'selfstack') recordProviderHealthSafe(result.backendId, result.model, cap.CAPABILITIES.VISION, {
       ok: true, category: 'success', note: '视觉请求成功'
@@ -462,7 +475,14 @@ export function listActions() {
 export async function runAction(host, name, args, { signal } = {}) {
   const fn = actions[name];
   if (!fn) throw new Error(`iris: 未知动作 "${name}"`);
-  return fn(actionHost(host), args || {}, { signal });
+  const adapter = actionHost(host);
+  const execute = async () => {
+    if (AUTO_DIRECTORY_ACTIONS.has(name) && !args?.model) await store.refreshAutomaticDirectories({
+      capability: ({ image: 'image-gen', image_edit: 'image-gen', video: 'video-gen', music: 'music-gen', tts: 'tts', transcribe: 'transcribe' })[name] || 'vision', signal
+    });
+    return fn(adapter, args || {}, { signal });
+  };
+  return PROVIDER_ACTIONS.has(name) ? withDshProviderConfig(adapter, execute, { signal }) : execute();
 }
 
 /* ============ 动作实现 ============ */
@@ -585,7 +605,7 @@ register('music', async (host, args, { signal }) => {
     ...(optionalActionText(args.retry_502) !== undefined ? { retry_502: args.retry_502 } : {}),
     ...(optionalActionText(args.retry_delay_ms) !== undefined ? { retry_delay_ms: args.retry_delay_ms } : {})
   });
-  const routes = musicCandidatesFromCatalog({ providers: store.allProviders(), assignments: store.assignments() }, args.model);
+  const routes = musicCandidatesFromCatalog({ providers: store.runtimeProviders(), assignments: store.assignments() }, args.model);
   const submitted = await submitMusicForDsh({
     candidates: routes.map(route => ({ adapter: createConfiguredProviderAdapter(route.provider), model: route.modelRef,
       selectionReason: route.selectionReason, providerBinding: providerTaskBinding(route.provider) })),
@@ -721,7 +741,8 @@ register('locate', async (host, args, { signal }) => {
   const p = String(args.image_path || '').trim();
   if (source === 'image_path' && (!p || !path.isAbsolute(p))) throw new Error('iris: image_path 必须是绝对路径');
   const mt = MEDIA_TYPES[path.extname(p).toLowerCase()] || 'image/png';
-  const r = await runLocateRequest(host, { providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit, model: args.model,
+  const r = await runLocateRequest(host, { providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit,
+    onModelAvailability: store.recordAvailability, model: args.model,
     target: args.target, prepareImage: operationSignal => source === 'artifact_id'
       ? visionImageForDsh({ artifactId: args.artifact_id, signal: operationSignal }) : readVisionImageFile(p, mt, operationSignal), signal });
   const { width, height } = r;
@@ -750,7 +771,7 @@ register('ocr', async (host, args, { signal }) => {
     if (!mediaType || mediaType === 'image/gif') throw new Error('iris: 不支持的图片格式（png/jpg/jpeg/webp）');
   }
   const result = await runOcrRequest(host, { providers: store.pickAllFor(cap.CAPABILITIES.VISION),
-    onRateLimit: store.recordRateLimit,
+    onRateLimit: store.recordRateLimit, onModelAvailability: store.recordAvailability,
     prepareImage: operationSignal => source === 'artifact_id'
       ? visionImageForDsh({ artifactId: args.artifact_id, signal: operationSignal }) : readVisionImageFile(p, mediaType, operationSignal),
     chunkHeight: args.chunk_height, overlap: args.overlap, signal });
@@ -1032,22 +1053,32 @@ register('relook', async (host, args, { signal }) => {
 /** 列出全部供应商及其模型池（管理 GUI 用；apiKey 只给 hint） */
 register('providers_list', async (host, args) => {
   const list = store.allProviders();
+  const connections = list.some(provider => provider.dshProvider) && hasHostPort(host, 'providerConnections')
+    ? await host.ports.providerConnections.list() : [];
   return {
     ok: true,
+    setupSuggested: Object.keys(store.assignments()).length === 0 && list.every(provider => models.providerModels(provider).length === 0),
     providers: list.map((p) => ({
       id: p.id,
       name: p.name || p.id,
       type: p.type || 'openai',
-      baseUrl: p.baseUrl,
+      baseUrl: p.dshProvider ? (connections.find(item => item.provider === p.dshProvider.provider
+        && item.settingsNs === p.dshProvider.settingsNs)?.baseUrl || '') : p.baseUrl,
+      ...(p.dshProvider ? { dshProvider: p.dshProvider,
+        connection: connections.find(item => item.provider === p.dshProvider.provider && item.settingsNs === p.dshProvider.settingsNs)
+          || { available: false, reason: 'DSH 原连接不可用，请检查宿主供应商设置' } } : {}),
       mediaBaseUrl: p.mediaBaseUrl || '',
       enabled: p.enabled !== false,
       auth: p.auth === 'none' ? 'none' : 'bearer',
       ...selectMediaProtocol(p),
       visionInput: p.visionInput || null,
-      apiKeyHint: String(p.apiKey || '').length <= 8 ? '****' : String(p.apiKey).slice(0, 3) + '****' + String(p.apiKey).slice(-4),
-      models: models.providerModels(p).map((m) => ({
+      directory: modelDirectorySummary(p),
+      apiKeyHint: p.dshProvider ? '由 DSH 管理' : String(p.apiKey || '').length <= 8 ? '****' : String(p.apiKey).slice(0, 3) + '****' + String(p.apiKey).slice(-4),
+      models: models.providerModelsWithDirectory(p).map((m) => ({
         id: m.id,
         capabilities: m.capabilities,
+        ...(m.directoryOnly ? { directoryOnly: true } : {}),
+        ...(m.catalogStatus ? { catalogStatus: m.catalogStatus } : {}),
         ...(m.imageProtocol !== undefined ? { imageProtocol: m.imageProtocol } : {}),
         ...(m.musicProtocol !== undefined ? { musicProtocol: m.musicProtocol } : {}),
         ...(m.visionInput !== undefined ? { visionInput: m.visionInput } : {}),
@@ -1064,6 +1095,12 @@ register('providers_list', async (host, args) => {
   };
 });
 
+register('providers_host_connections', async host => {
+  if (!hasHostPort(host, 'providerConnections')) return { ok: true, connections: [],
+    note: '当前 DSH 未提供连接复用接口，请手动添加 Iris 供应商' };
+  return { ok: true, connections: await host.ports.providerConnections.list() };
+});
+
 /** 新增/更新供应商 */
 register('providers_upsert', async (host, args) => {
   const id = args.id || undefined;
@@ -1073,6 +1110,16 @@ register('providers_upsert', async (host, args) => {
   for (const key of allowed) {
     if (Object.prototype.hasOwnProperty.call(args, key)) patch[key] = args[key];
   }
+  if (Object.hasOwn(args, 'dshProvider')) {
+    patch.dshProvider = normalizeDshProvider(args.dshProvider);
+    const source = requireHostPort(host, 'providerConnections', '复用 DSH 供应商连接');
+    const connection = (await source.list()).find(item => item.provider === patch.dshProvider.provider
+      && item.settingsNs === patch.dshProvider.settingsNs);
+    if (!connection?.available) throw new Error(connection?.reason || 'DSH 连接不可用');
+    if (!['dashscope', 'openai-images', 'openai-chat-images', 'openai-responses-images'].includes(patch.mediaProtocol)) {
+      throw new Error('复用 DSH 连接时请明确选择媒体协议');
+    }
+  }
   if (!id && !Object.prototype.hasOwnProperty.call(patch, 'enabled')) patch.enabled = true;
   const saved = store.upsert(patch);
   return { ok: true, providerId: saved.id };
@@ -1098,21 +1145,27 @@ register('providers_set_models', async (host, args) => {
 register('providers_discover', async (host, args, { signal }) => {
   const p = store.providerById(String(args.id || ''));
   if (!p) throw new Error('iris: 供应商不存在或未启用');
-  let discoveredModels;
-  try {
-    const providerAdapter = createConfiguredProviderAdapter(p);
-    const discovered = await invokeProviderOperation(providerAdapter, 'discover', { signal });
-    discoveredModels = discovered.models;
-  } catch (err) {
-    throw new Error('iris: 模型发现失败（保留现有池）：' + String(err.message || err));
-  }
-  const entries = discoveredModels.map((model) => ({ id: model.id, capabilities: models.capabilitiesOfDiscoveredModel(model) }));
+  const [updated] = await store.refreshProviderDirectories({ providerId: p.id, force: true, signal });
+  if (updated.error) throw new Error('iris: 模型发现失败（保留现有池）：' + updated.error);
+  const entries = updated.directory.models;
   const mediaCount = entries.filter((model) => model.capabilities.length).length;
   store.mergeDiscoveredModels(p.id, entries);
-  return { ok: true, total: discoveredModels.length, media: mediaCount,
+  return { ok: true, total: entries.length, media: mediaCount,
     text: `[iris] ${p.name}：发现 ${entries.length} 个模型，${mediaCount} 个有能力声明；未标注模型请在模型池中设置能力` };
 });
 
+/** 只更新目录快照；新增项在管理视图待确认，不改模型用途与功能名单。 */
+register('providers_sync_directory', async (host, args, { signal }) => {
+  const id = String(args.id || '').trim();
+  if (!store.providerById(id)) throw new Error('iris: 供应商不存在或连接未就绪');
+  const [result] = await store.refreshProviderDirectories({ providerId: id, force: args.force === true, signal });
+  if (result.error) return { ok: true, synced: false, error: result.error,
+    text: '目录同步失败，已保留上次完整目录：' + result.error };
+  return { ok: true, synced: true, refreshed: result.refreshed,
+    text: result.refreshed ? '模型目录已同步；新模型仍需确认用途' : '目录仍在有效期内',
+    directory: modelDirectorySummary(store.providerById(id)) };
+});
+
 /** 能力实测（红色测试图）：对某供应商的 vision 模型跑 testVisionCapability */
 register('providers_test_vision', async (host, args, { signal }) => {
   const p = store.providerById(String(args.id || ''));
@@ -1121,7 +1174,7 @@ register('providers_test_vision', async (host, args, { signal }) => {
   if (!vision) return { ok: true, tested: false, text: '该供应商未配置 vision 模型，跳过' };
   const model = vision.id;
   if (args.confirm_paid !== true) throw new Error('iris: 视觉实测会发起真实供应商请求，请先明确确认');
-  const r = await probeVisionModel(p, model, visionImageFromDataUrl(RED_TEST_IMAGE), { timeoutMs: 15000, signal });
+  const r = await probeVisionModel(p, model, visionImageFromDataUrl(RED_TEST_IMAGE), { timeoutMs: 15000, signal, onModelAvailability: store.recordAvailability });
   store.setModelVerified(p.id, model, cap.CAPABILITIES.VISION, {
     ok: r.ok,
     note: r.ok ? '认出红色测试图' : (r.error || '未识别出红色'),
@@ -1146,7 +1199,7 @@ async function probeModel(host, p, modelId, capability, signal) {
     return { skipped: true, ok: false, note: 'Music 不发起小样本探测；请通过音乐功能提交实际创作要求' };
   }
   if (capability === cap.CAPABILITIES.VISION) {
-    const r = await probeVisionModel(p, modelId, visionImageFromDataUrl(RED_TEST_IMAGE), { timeoutMs: 15000, signal });
+    const r = await probeVisionModel(p, modelId, visionImageFromDataUrl(RED_TEST_IMAGE), { timeoutMs: 15000, signal, onModelAvailability: store.recordAvailability });
     return {
       ok: r.ok,
       note: r.ok ? '认出红色测试图' : (r.error || '未识别出红色'),
@@ -1158,6 +1211,8 @@ async function probeModel(host, p, modelId, capability, signal) {
     return { skipped: true, ok: false, note: '需真实音频；可用 CLI models test --capability transcribe --input 提供素材进行实测恢复' };
   }
   if (capability === cap.CAPABILITIES.TTS) {
+    const issue = selectMediaProtocol(p).mediaProtocol === 'dashscope' && dashscopeTtsInputIssue(modelId);
+    if (issue) return { skipped: true, ok: false, note: issue };
     const providerAdapter = createConfiguredProviderAdapter(p, { allowRateLimited: true });
     const submitted = await invokeProviderOperation(providerAdapter, 'submit', {
       capability: 'tts', model: modelId, input: { text: '你好' }, signal
@@ -1231,6 +1286,14 @@ register('providers_add_model', async (host, args) => {
   return { ok: true, text: `[iris] 已添加模型 ${modelId}（能力：${(caps || []).join(',') || '未标注'}）` };
 });
 
+register('providers_confirm_model', async (_host, args) => {
+  const entry = store.confirmModelUsage(args.id, args.model_id, args.capabilities, {
+    enableAutomatic: args.enableAutomatic, musicProtocol: args.musicProtocol
+  });
+  return { ok: true, model_id: entry.id, text: args.enableAutomatic
+    ? '已确认模型用途，并启用所选功能的自动池' : '已确认模型用途；已有调用方式保持' };
+});
+
 /** 从池移除模型 */
 register('providers_remove_model', async (host, args) => {
   const ok = store.removeProviderModel(String(args.id || ''), String(args.model_id || ''));
@@ -1303,22 +1366,62 @@ register('providers_test_model', async (host, args, { signal }) => {
 register('assignments_get', async (host, args) => {
   const providers = store.allProviders();
   const configured = new Set(store.providers().map(provider => provider.id));
+  const connections = providers.some(provider => provider.dshProvider) && hasHostPort(host, 'providerConnections')
+    ? await host.ports.providerConnections.list() : [];
+  for (const provider of providers) {
+    if (provider.enabled !== false && provider.dshProvider && connections.some(item => item.available
+        && item.provider === provider.dshProvider.provider && item.settingsNs === provider.dshProvider.settingsNs)) {
+      configured.add(provider.id);
+    }
+  }
+  const previewProviders = providers.map(provider => provider.dshProvider ? { ...provider,
+    baseUrl: connections.find(item => item.provider === provider.dshProvider.provider
+      && item.settingsNs === provider.dshProvider.settingsNs)?.baseUrl } : provider);
   const pool = models.modelPool(providers, { includeHostVision: true });
   const byCap = {};
   for (const m of pool) {
     for (const c of m.capabilities) {
       if (!byCap[c]) byCap[c] = [];
-      const provider = providers.find(provider => provider.id === m.providerId);
+      const provider = previewProviders.find(provider => provider.id === m.providerId);
+      const hostResource = m.ref === models.HOST_VISION_REF;
+      const protocolSupported = hostResource || supportsModelCapability(provider, m.id, c);
+      const modelUnavailable = m.unavailableCapabilities?.includes(c) === true;
+      const connected = hostResource ? hasHostPort(host, 'textModel') : configured.has(m.providerId);
       byCap[c].push({ ref: m.ref, id: m.id, providerId: m.providerId,
         label: m.ref === models.HOST_VISION_REF ? 'DSH 当前默认模型' : m.id + ' · ' + m.providerId,
-        unavailable: m.ref !== models.HOST_VISION_REF && (!configured.has(m.providerId) || m.rateLimited === true),
+        unavailable: !connected || !protocolSupported || m.rateLimited === true || modelUnavailable,
+        modelUnavailable,
+        pendingConfirmation: m.source === 'discovered', protocolSupported,
+        reason: !connected ? '连接未就绪，请检查供应商或宿主服务' : !protocolSupported
+          ? (c === cap.CAPABILITIES.TTS && selectMediaProtocol(provider).mediaProtocol === 'dashscope'
+            && dashscopeTtsProtocolIssue(m.id)) || '当前接口协议不支持此功能'
+          : modelUnavailable ? modelUnavailableReason() : m.rateLimited ? '限流冷却或额度不可用，请稍后或检查账号' : m.source === 'discovered' ? '已发现，待确认模型用途' : '',
         ...(c === cap.CAPABILITIES.IMAGE && provider ? { imageRouting: imageRoutingForModel(provider, m.id) } : {}) });
     }
   }
   // order：归一化的有序分配列表（GUI 直接渲染 failover 顺序，无需处理单字符串旧格式）
   const order = {};
   for (const c of Object.values(cap.CAPABILITIES)) order[c] = store.assignmentOrder(c);
-  return { ok: true, assignments: store.assignments(), order, poolByCapability: byCap };
+  const policies = {}, readiness = {};
+  for (const capability of Object.values(cap.CAPABILITIES)) {
+    const assignment = store.assignments()[capability];
+    const policy = models.functionPolicy(assignment, capability);
+    policies[capability] = policy;
+    if (policy.mode === 'auto') order[capability] = models.orderedModels(
+      models.functionModelPool(previewProviders, capability, assignment, { includeHostVision: true }),
+      capability, assignment, { includeRateLimited: true, includeUnavailable: true }).map(model => model.ref);
+    const options = byCap[capability] || [];
+    const candidates = options.filter(model => order[capability].includes(model.ref) && !model.unavailable);
+    let note = '';
+    if (policy.mode === 'disabled') note = '此功能已停用，可选择自动池或手选模型';
+    else if (policy.mode === 'manual' && !order[capability].length) note = '尚未选择模型，可添加所选项或改用自动池';
+    else if (!options.length) note = '请先添加模型，并确认它可用于此功能';
+    else if (!candidates.length) note = options.some(model => model.pendingConfirmation)
+      ? '发现的模型尚待确认用途，请在供应商中确认功能'
+      : options.find(model => model.reason)?.reason || '当前没有匹配的候选，请检查功能范围和模型';
+    readiness[capability] = { mode: policy.mode, candidateCount: candidates.length, note };
+  }
+  return { ok: true, assignments: store.assignments(), order, poolByCapability: byCap, policies, readiness };
 });
 
 /**
@@ -1329,6 +1432,10 @@ register('assignments_get', async (host, args) => {
 register('assignments_set', async (host, args) => {
   const capability = String(args.capability || '').trim();
   if (!capability) throw new Error('iris: capability 不能为空');
+  if (Object.hasOwn(args, 'mode')) {
+    const policy = store.setFunctionPolicy(capability, args.mode, { hostVision: args.hostVision });
+    return { ok: true, capability, mode: policy.mode, model_refs: store.assignmentOrder(capability) };
+  }
   const listArg = Array.isArray(args.model_refs) ? args.model_refs : args.model_ids;
   if (Array.isArray(listArg)) {
     const refs = listArg.map((x) => String(x || '').trim()).filter(Boolean);
@@ -1465,7 +1572,7 @@ register('media_summarize', async (host, args, { signal }) => {
     if (!ffmpegAvailable()) throw new Error('iris: ffmpeg/ffprobe 不可用，无法分析视频（可选安装 ffmpeg 后启用）');
   }
   const { answer, via, model, sheet, meta, frames } = await runSummaryRequest(host, {
-    onRateLimit: store.recordRateLimit,
+    onRateLimit: store.recordRateLimit, onModelAvailability: store.recordAvailability,
     providers: store.pickAllFor(cap.CAPABILITIES.VISION), model: args.model, question: args.question, signal,
     async prepareMedia(operationSignal) {
       if (source === 'core-artifacts') {

package/lib/adapters.js

@@ -367,7 +367,15 @@ export async function synthesizeTts({ key, baseUrl, model = 'qwen-tts-latest', t
     body: JSON.stringify({ model, input: { text, voice } })
   });
   const body = await readJson(res);
-  if (!res.ok) throw providerError(res.status, body, '合成失败', res.headers);
+  if (!res.ok) {
+    const error = providerError(res.status, body, '合成失败', res.headers);
+    if (res.status === 404 && (/NotFound\.Model|model_not_found/i.test(error.providerCode)
+        || /model (?:not exist|can not be found|.*does not exist)/i.test(String(error.rootCause)))) {
+      error.category = 'invalid_parameter';
+      error.message = `当前语音接口找不到模型 ${model}（${new URL(apiBase).hostname}）；请核对模型 ID、所属地域及调用协议。上游：${error.rootCause}`;
+    }
+    throw error;
+  }
   const audio = body && body.output && body.output.audio;
   const url = audio && (audio.url || audio.audio_url);
   const b64 = audio && typeof audio.data === 'string' ? audio.data : null;
@@ -510,6 +518,7 @@ export async function listModels({ key, baseUrl, timeoutMs = T_SUBMIT, signal })
   const found = new Map();
   const maxPages = dashscope ? 50 : 1;
   let loaded = 0;
+  let expectedTotal = null;
   for (let page = 1; page <= maxPages; page++) {
     const url = new URL(endpoint);
     if (dashscope) {
@@ -519,14 +528,24 @@ export async function listModels({ key, baseUrl, timeoutMs = T_SUBMIT, signal })
     const res = await fetch(url, { headers: authHeaders(key), signal: timeoutSignal(timeoutMs, signal) });
     const body = await readJson(res);
     if (!res.ok) throw providerError(res.status, body, '模型发现失败', res.headers);
+    if (!body || body.success === false) throw new ProviderContractError('模型目录响应无效，已保留上次完整目录', {
+      stage: 'validate', category: 'protocol', acceptance: 'not_accepted'
+    });
     const output = body && body.output;
     const items = (output && Array.isArray(output.models) && output.models)
       || (body && Array.isArray(body.data) && body.data)
-      || (Array.isArray(body && body.models) ? body.models : []);
+      || (Array.isArray(body && body.models) ? body.models : null);
+    if (!items) throw new ProviderContractError('模型目录缺少模型数组，已保留上次完整目录', {
+      stage: 'validate', category: 'protocol', acceptance: 'not_accepted'
+    });
     loaded += items.length;
     for (const item of items) {
-      const id = String(typeof item === 'string' ? item : item?.id || item?.model || '').trim();
-      if (!id || found.has(id)) continue;
+      const rawId = typeof item === 'string' ? item : item?.id || item?.model;
+      if (typeof rawId !== 'string' || !rawId.trim()) throw new ProviderContractError('模型目录包含无效模型 ID，已保留上次完整目录', {
+        stage: 'validate', category: 'protocol', acceptance: 'not_accepted'
+      });
+      const id = rawId.trim();
+      if (found.has(id)) continue;
       const capabilities = Array.isArray(item?.capabilities)
         ? item.capabilities.filter((value) => typeof value === 'string' && value)
         : [];
@@ -538,17 +557,25 @@ export async function listModels({ key, baseUrl, timeoutMs = T_SUBMIT, signal })
       if (!Array.isArray(item?.capabilities)) {
         if (responseModalities.includes('image')) capabilities.push('IG');
         if (responseModalities.includes('video')) capabilities.push('VG');
-        if (requestModalities.includes('audio') && responseModalities.includes('text')) capabilities.push('ASR');
-        if (requestModalities.includes('text') && responseModalities.includes('audio')) capabilities.push('TTS');
+        // 音频理解不证明支持文件转写；混合视频/图像/文本输出也不证明独立TTS。
+        if (requestModalities.length === 1 && requestModalities[0] === 'text'
+            && responseModalities.length === 1 && responseModalities[0] === 'audio') capabilities.push('TTS');
         if (requestModalities.includes('image') && responseModalities.includes('text')) capabilities.push('VU');
       }
       const normalizedCapabilities = [...new Set(capabilities)];
       found.set(id, normalizedCapabilities.length ? { id, capabilities: normalizedCapabilities } : id);
     }
     if (!dashscope) break;
-    const statedTotal = Number(output?.total);
-    const total = Number.isFinite(statedTotal) && statedTotal >= 0 ? statedTotal : null;
-    if (!items.length || (total !== null && loaded >= total) || items.length < 100) break;
+    const total = output?.total === undefined ? expectedTotal : Number(output.total);
+    if (total !== null && (!Number.isSafeInteger(total) || total < 0
+        || (expectedTotal !== null && total !== expectedTotal) || loaded > total || (!items.length && loaded < total)
+        || (loaded === total && found.size !== loaded))) {
+      throw new ProviderContractError('模型目录分页不完整或总数变化，已保留上次完整目录', {
+        stage: 'validate', category: 'protocol', acceptance: 'not_accepted'
+      });
+    }
+    if (total !== null) expectedTotal = total;
+    if ((total !== null && loaded === total) || (total === null && items.length < 100)) break;
     if (page === maxPages) throw new Error('iris: 模型目录超过安全分页上限，已保留原模型池');
   }
   return [...found.values()];

package/lib/api.js

@@ -66,7 +66,8 @@ function providerPublic(p) {
     mediaBaseUrl: p.mediaBaseUrl || '',
     enabled: p.enabled !== false,
     ...selectMediaProtocol(p),
-    apiKeyHint: keyHint(p.apiKey),
+    apiKeyHint: p.dshProvider ? '由 DSH 管理' : keyHint(p.apiKey),
+    ...(p.dshProvider ? { dshProvider: p.dshProvider } : {}),
     capabilities: capabilitiesOf(p),
     // 迁移/推断结果是否与原始声明不同（UI 提示旧配置已推断）
     capabilityInferred: !Array.isArray(p.capabilities) || p.capabilities.length === 0,