@mokuyoaxis/dsh-iris 0.2.1 → 0.2.3

package/lib/actions.js

@@ -23,7 +23,7 @@ import { registerMedia, mediaLinksOf, webBase } from './media.js';
 import { RED_TEST_IMAGE } from './vision.js';
 import { runVisionRequest, readVisionImageFile, probeVisionModel, visionImageFromDataUrl } from './vision-model-routing.js';
 import { HOST_CONTRACT_VERSION, HOST_PORTS, defineHostAdapter, hasHostPort, requireHostPort } from './host-contract.js';
-import { coreSnapshotForDsh, cropForDsh, diffForDsh, framesForDsh, summaryFramesForDsh, visionImageForDsh, htmlForDsh, inspectProviderTaskForDsh, submitProviderTaskForDsh, watchProviderTaskForDsh } from './dsh-core-adapter.js';
+import { coreSnapshotForDsh, cropForDsh, diffForDsh, framesForDsh, summaryFramesForDsh, visionImageForDsh, htmlForDsh, inspectProviderTaskForDsh, submitMusicForDsh, submitProviderTaskForDsh, watchProviderTaskForDsh } from './dsh-core-adapter.js';
 import { runLocateRequest, runSummaryRequest } from './composite-vision-routing.js';
 import { normalizeSummarySource, summaryFrameRecords, summaryTimelineLabel } from './summary-input.js';
 import { normalizeVisionImageSource } from './vision-input.js';
@@ -32,7 +32,7 @@ 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 } from './provider-protocol.js';
-import { providerTaskBinding } from './provider-catalog.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';
@@ -136,7 +136,8 @@ function imageRoute(provider, args) {
 }
 
 function taskActionError(taskId, message, details) {
-  const error = new Error('iris: ' + message + '（task: ' + taskId + '）');
+  const diagnostic = details?.safeMessage ? '：' + details.safeMessage : '';
+  const error = new Error('iris: ' + message + '（task: ' + taskId + '）' + diagnostic);
   error.taskId = taskId;
   if (details) error.details = details;
   return error;
@@ -563,6 +564,33 @@ async function submitCoreTts(routes, normalizedInput, signal) {
 }
 
 /* ---------- 🔊 语音合成 ---------- */
+register('music', async (host, args, { signal }) => {
+  const normalized = normalizeGenerationInput('music', {
+    prompt: args.prompt,
+    ...(optionalActionText(args.timeout_ms) !== undefined ? { timeout_ms: args.timeout_ms } : {}),
+    ...(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 submitted = await submitMusicForDsh({
+    candidates: routes.map(route => ({ adapter: createConfiguredProviderAdapter(route.provider), model: route.modelRef,
+      selectionReason: route.selectionReason, providerBinding: providerTaskBinding(route.provider) })),
+    providerInput: normalized.providerInput, musicOptions: normalized.musicOptions, signal
+  });
+  const task = submitted.task;
+  recordCoreTaskAttemptHealth(task, cap.CAPABILITIES.MUSIC);
+  if (submitted.localError) throw taskActionError(task.id, 'Music 结果未能可靠落盘', submitted.localError);
+  if (task.outcome !== 'succeeded' || task.deliveryState !== 'ready') {
+    throw taskActionError(task.id, task.outcome === 'succeeded'
+      ? '音乐已返回，但交付失败；可从缓存重新交付'
+      : `音乐未取得产物（已重试${submitted.retries}次）`, task.lastError);
+  }
+  return { ok: true, storage: 'core', taskId: task.id, taskIds: submitted.taskIds, retries: submitted.retries,
+    model: task.modelRef, providerId: task.providerId, artifactIds: task.artifactIds,
+    audioUrl: '/iris/api/core/artifact/' + encodeURIComponent(task.artifactIds[0]) + '/media',
+    text: `[iris] 音乐已生成（${task.modelRef}，重试${submitted.retries}次，Core task: ${task.id}）` };
+});
+
 register('tts', async (host, args, { signal }) => {
   const { providerInput } = normalizeGenerationInput('tts', {
     text: args.text, voice: optionalActionText(args.voice)
@@ -1007,6 +1035,7 @@ register('providers_list', async (host, args) => {
         id: m.id,
         capabilities: m.capabilities,
         ...(m.imageProtocol !== undefined ? { imageProtocol: m.imageProtocol } : {}),
+        ...(m.musicProtocol !== undefined ? { musicProtocol: m.musicProtocol } : {}),
         ...(m.visionInput !== undefined ? { visionInput: m.visionInput } : {}),
         ...(m.capabilities.includes(cap.CAPABILITIES.VISION) ? { visionInputEffective: visionInputLimits(p, m.id) } : {}),
         ...(m.capabilities.includes(cap.CAPABILITIES.IMAGE) ? { imageRouting: selectImageProtocol(p, m.id) } : {}),
@@ -1049,7 +1078,7 @@ register('providers_set_models', async (host, args) => {
 });
 
 /**
- * 模型发现：读取供应商目录 → 官方能力元数据优先、名称规则兜底 → 写入显式池。
+ * 模型发现：读取供应商目录 → 明确能力元数据 → 合并模型池。
  * 免费只读；拉不到/不支持则原样保留现有池（优雅降级），报人话错误。
  */
 register('providers_discover', async (host, args, { signal }) => {
@@ -1063,16 +1092,11 @@ register('providers_discover', async (host, args, { signal }) => {
   } catch (err) {
     throw new Error('iris: 模型发现失败（保留现有池）：' + String(err.message || err));
   }
-  const media = [];
-  for (const model of discoveredModels) {
-    const caps = models.capabilitiesOfDiscoveredModel(model);
-    if (caps.length) media.push({ id: model.id, capabilities: caps });
-  }
-  if (!media.length) {
-    return { ok: true, total: discoveredModels.length, media: 0, text: `[iris] ${p.name}：拉到 ${discoveredModels.length} 个模型，无媒体能力匹配——可在模型池区手动添加并标能力` };
-  }
-  store.mergeDiscoveredModels(p.id, media);
-  return { ok: true, total: discoveredModels.length, media: media.length, text: `[iris] ${p.name}：发现 ${discoveredModels.length} 个模型，${media.length} 个媒体能力模型已入池（官方元数据优先）` };
+  const entries = discoveredModels.map((model) => ({ id: model.id, capabilities: models.capabilitiesOfDiscoveredModel(model) }));
+  const mediaCount = entries.filter((model) => model.capabilities.length).length;
+  store.mergeDiscoveredModels(p.id, entries);
+  return { ok: true, total: discoveredModels.length, media: mediaCount,
+    text: `[iris] ${p.name}：发现 ${entries.length} 个模型，${mediaCount} 个有能力声明；未标注模型请在模型池中设置能力` };
 });
 
 /** 能力实测（红色测试图）：对某供应商的 vision 模型跑 testVisionCapability */
@@ -1104,6 +1128,9 @@ register('providers_test_vision', async (host, args, { signal }) => {
 
 /** 按能力实测单个模型；返回 {ok, note}。真实调用仅在 UI 明确确认后执行。 */
 async function probeModel(host, p, modelId, capability, signal) {
+  if (capability === cap.CAPABILITIES.MUSIC) {
+    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 });
     return {
@@ -1177,17 +1204,17 @@ async function probeModel(host, p, modelId, capability, signal) {
   return { ok: false, note: '未知能力' };
 }
 
-/** 手动添加模型到池（能力可选，缺省按规则推断） */
+/** 手动添加模型到池；省略或清空能力时保留未标注模型。 */
 register('providers_add_model', async (host, args) => {
   const id = String(args.id || '');
   const modelId = String(args.model_id || '').trim();
   if (!modelId) throw new Error('iris: model_id 不能为空');
-  const caps = Array.isArray(args.capabilities) && args.capabilities.length
+  const caps = Array.isArray(args.capabilities)
     ? args.capabilities.filter((c) => cap.isKnownCapability(c))
-    : models.capabilitiesOfModel(modelId);
+    : undefined;
   const entry = store.addProviderModel(id, modelId, caps);
   if (!entry) throw new Error('iris: 供应商不存在');
-  return { ok: true, text: `[iris] 已添加模型 ${modelId}（能力：${caps.join(',') || '未标注'}）` };
+  return { ok: true, text: `[iris] 已添加模型 ${modelId}（能力：${(caps || []).join(',') || '未标注'}）` };
 });
 
 /** 从池移除模型 */
@@ -1211,6 +1238,12 @@ register('providers_set_model_image_protocol', async (host, args) => {
   return { ok: true, text: '[iris] 模型图片协议已更新' };
 });
 
+register('providers_set_model_music_protocol', async (host, args) => {
+  const ok = store.setModelMusicProtocol(String(args.id || ''), String(args.model_id || ''), args.musicProtocol);
+  if (!ok) throw new Error('iris: 模型不在池中');
+  return { ok: true, text: '[iris] 模型音乐协议已更新' };
+});
+
 register('providers_set_model_vision_input', async (host, args) => {
   if (!Object.hasOwn(args, 'visionInput')) throw new Error('iris: 需要 visionInput 对象或 null');
   const ok = store.setModelVisionInput(String(args.id || ''), String(args.model_id || ''), args.visionInput);
@@ -1225,7 +1258,7 @@ register('providers_test_model', async (host, args, { signal }) => {
   const modelId = String(args.model_id || '').trim();
   const capability = String(args.capability || '').trim();
   if (!modelId || !cap.isKnownCapability(capability)) throw new Error('iris: 需 model_id 与合法 capability');
-  if (![cap.CAPABILITIES.VIDEO, cap.CAPABILITIES.TRANSCRIBE].includes(capability) && args.confirm_paid !== true) {
+  if (![cap.CAPABILITIES.VIDEO, cap.CAPABILITIES.TRANSCRIBE, cap.CAPABILITIES.MUSIC].includes(capability) && args.confirm_paid !== true) {
     throw new Error('iris: 模型实测会发起真实供应商请求，请先明确确认');
   }
   let result;

package/lib/adapters.js

@@ -11,10 +11,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { dashscopeApiBase, isDashScopeBaseUrl } from './provider-protocol.js';
+import { dashscopeApiBase, imageSizeViolation, isDashScopeBaseUrl, normalizeImageSize } from './provider-protocol.js';
 import { chmodPrivateFile, ensurePrivateDir, privateSibling } from './private-storage.js';
 import { isFreeQuotaExhausted, retryAfterDelay } from './provider-health.js';
 import { ProviderContractError } from './provider-contract.js';
+export { generateMusic } from './music-transport.js';
 
 /**
  * 网络调用超时档位（2026-09-03 健康检查）：挂死的连接绝不能冻住盯守 tick——
@@ -95,17 +96,65 @@ function classifyHttpError(status, body, fallback, headers) {
     ...(status === 429 ? { retryAfterMs: retryAfterDelay(headers?.get('retry-after')) } : {}) });
 }
 
-/** 包装 fetch 层的网络异常（无 HTTP 状态） */
-export function networkError(err) {
+/** 包装 fetch 层的网络异常（无 HTTP 状态）。hint 补一句可执行的排查方向。 */
+export function networkError(err, hint) {
+  const code = String(err?.cause?.code || err?.code || '');
   const e = new ProviderError({
     category: 'network',
     status: 0,
-    message: '网络错误：' + String((err && err.message) || err),
-    rootCause: err
+    message: '网络错误：' + String((err && err.message) || err) + (hint ? '（' + hint + '）' : ''),
+    rootCause: err,
+    ...(/^[A-Z][A-Z0-9_]{1,63}$/.test(code) ? { providerCode: code } : {})
   });
   return e;
 }
 
+/** 超时/取消必须保持原分类：轮询 errStreak 容错与 submitGuard 都依赖 network 与 timeout 的区分。 */
+function isAbortLike(err) {
+  return err?.name === 'AbortError' || err?.name === 'TimeoutError' || err?.code === 'ABORT_ERR';
+}
+
+function transportFetchError(err, response) {
+  if (isAbortLike(err)) return err;
+  const code = String(err?.cause?.code || err?.code || '');
+  const detail = {
+    ENOTFOUND: 'DNS 未找到目标主机',
+    EAI_AGAIN: 'DNS 解析暂时失败',
+    ECONNREFUSED: '目标连接被拒绝',
+    UND_ERR_CONNECT_TIMEOUT: '连接建立超时',
+    UND_ERR_HEADERS_TIMEOUT: '等待响应头超时',
+    UND_ERR_BODY_TIMEOUT: '响应正文读取超时',
+    ETIMEDOUT: '网络操作超时',
+    ECONNRESET: '连接被重置',
+    UND_ERR_SOCKET: '底层连接中断',
+    CERT_HAS_EXPIRED: 'TLS 证书已过期',
+    DEPTH_ZERO_SELF_SIGNED_CERT: 'TLS 证书不受信任',
+    UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'TLS 证书链验证失败'
+  }[code];
+  const phase = response
+    ? `已收到 HTTP ${response.status} 响应头，读取响应正文失败`
+    : '请求传输失败，尚未收到响应头';
+  const error = networkError(err, phase + (detail ? '；' + detail : '') +
+    (code && /^[A-Z][A-Z0-9_]{1,63}$/.test(code) ? '；' + code : '') + '；受理结果未知，禁止自动重提');
+  if (['UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT', 'ETIMEDOUT'].includes(code)) {
+    error.category = 'timeout';
+  }
+  error.stage = response ? 'response' : 'submit';
+  error.acceptance = 'unknown';
+  return error;
+}
+
+/** 只包装网络读取；HTTP 业务错误和图片协议校验由调用方处理。 */
+async function fetchImageJson(url, options) {
+  let response;
+  try {
+    response = await fetch(url, options);
+    return { res: response, body: await readJson(response) };
+  } catch (err) {
+    throw transportFetchError(err, response);
+  }
+}
+
 function providerError(status, body, fallback, headers) {
   return classifyHttpError(status, body, fallback, headers);
 }
@@ -125,20 +174,34 @@ export function dashscopeImageMode(model) {
   return 'legacy-async';
 }
 
+/**
+ * 尺寸在进入请求体前统一「归一 + 校验」：
+ * 协议差异（分隔符、数值边界）全部来自 provider-protocol.js，本地违规明确标记为未受理。
+ * 归一的意义是跨协议可用 —— 例如把 `1024x1536` 送给 DashScope 多模态（服务端要求 `*`），
+ * 或把 `1024*1536` 送给 OpenAI 兼容端点（服务端要求 `x`），都不再需要调用方自己记格式。
+ */
+export function applyImageSize({ protocol, mode, size }) {
+  const violation = imageSizeViolation({ protocol, mode, size });
+  if (violation) throw new ProviderContractError(violation, {
+    stage: 'validate', category: 'invalid_request', acceptance: 'not_accepted'
+  });
+  return normalizeImageSize({ protocol, mode, size });
+}
+
 /** 新版多模态同步协议：响应中直接返回图片 URL。 */
 export async function generateImageMultimodal({ key, baseUrl, model, prompt, size, n = 1, timeoutMs = T_SYNC_GEN, signal }) {
   const apiBase = dashscopeApiBase(baseUrl);
-  const res = await fetch(`${apiBase}/services/aigc/multimodal-generation/generation`, {
+  const requestSize = applyImageSize({ protocol: 'dashscope', mode: 'multimodal-sync', size });
+  const { res, body } = await fetchImageJson(`${apiBase}/services/aigc/multimodal-generation/generation`, {
     method: 'POST',
     headers: authHeaders(key),
     signal: timeoutSignal(timeoutMs, signal),
     body: JSON.stringify({
       model,
       input: { messages: [{ role: 'user', content: [{ text: prompt }] }] },
-      parameters: { ...(size ? { size } : {}), n: Number(n) || 1 }
+      parameters: { ...(requestSize ? { size: requestSize } : {}), n: Number(n) || 1 }
     })
   });
-  const body = await readJson(res);
   if (!res.ok) throw providerError(res.status, body, '生成失败', res.headers);
   const urls = [];
   for (const choice of (body && body.output && body.output.choices) || []) {
@@ -160,13 +223,13 @@ export async function startImageGeneration(opts) {
 }
 export async function submitImage({ key, baseUrl, model, prompt, size, n = 1, timeoutMs = T_SUBMIT, signal }) {
   const apiBase = dashscopeApiBase(baseUrl);
-  const res = await fetch(`${apiBase}/services/aigc/text2image/image-synthesis`, {
+  const requestSize = applyImageSize({ protocol: 'dashscope', mode: 'legacy-async', size });
+  const { res, body } = await fetchImageJson(`${apiBase}/services/aigc/text2image/image-synthesis`, {
     method: 'POST',
     headers: { ...authHeaders(key), 'X-DashScope-Async': 'enable' },
     signal: timeoutSignal(timeoutMs, signal),
-    body: JSON.stringify({ model, input: { prompt }, parameters: { ...(size ? { size } : {}), n: Number(n) || 1 } })
+    body: JSON.stringify({ model, input: { prompt }, parameters: { ...(requestSize ? { size: requestSize } : {}), n: Number(n) || 1 } })
   });
-  const body = await readJson(res);
   if (!res.ok) throw providerError(res.status, body, '提交失败', res.headers);
   const taskId = body && body.output && body.output.task_id;
   if (!taskId) throw new Error('提交成功但未返回 task_id');
@@ -312,13 +375,13 @@ export async function synthesizeTts({ key, baseUrl, model = 'qwen-tts-latest', t
 /* ---------------- OpenAI Images 兼容（同步 base64/url） ---------------- */
 export async function openAiGenerateImage({ key, baseUrl, model, prompt, size = '1024x1024', n = 1, timeoutMs = T_SYNC_GEN, signal }) {
   const base = String(baseUrl || '').replace(/\/+$/, '');
-  const res = await fetch(`${base}/images/generations`, {
+  const requestSize = applyImageSize({ protocol: 'openai-images', size });
+  const { res, body } = await fetchImageJson(`${base}/images/generations`, {
     method: 'POST',
     headers: authHeaders(key),
     signal: timeoutSignal(timeoutMs, signal),
-    body: JSON.stringify({ model, prompt, size, n: Number(n) || 1 })
+    body: JSON.stringify({ model, prompt, size: requestSize, n: Number(n) || 1 })
   });
-  const body = await readJson(res);
   if (!res.ok) throw providerError(res.status, body, '生成失败', res.headers);
   const items = (body && Array.isArray(body.data) && body.data) || [];
   const out = [];
@@ -389,12 +452,11 @@ export async function openAiChatGenerateImage({ key, baseUrl, model, prompt, ima
     { type: 'text', text: prompt },
     { type: 'image_url', image_url: { url: 'data:' + image.mediaType + ';base64,' + Buffer.from(image.bytes).toString('base64') } }
   ] : prompt;
-  const res = await fetch(`${base}/chat/completions`, {
+  const { res, body } = await fetchImageJson(`${base}/chat/completions`, {
     method: 'POST', headers: authHeaders(key), signal: timeoutSignal(timeoutMs, signal),
     body: JSON.stringify({ model, stream: false, messages: [{ role: 'user', content }],
       ...(Number(n) > 1 ? { n: Number(n) } : {}) })
   });
-  const body = await readJson(res);
   if (!res.ok) throw providerError(res.status, body, '聊天生图失败', res.headers);
   return chatImageItems(body);
 }
@@ -407,13 +469,13 @@ export async function openAiResponsesGenerateImage({ key, baseUrl, model, prompt
     });
   }
   const base = String(baseUrl || '').replace(/\/+$/, '');
-  const res = await fetch(`${base}/responses`, {
+  const requestSize = applyImageSize({ protocol: 'openai-responses-images', size });
+  const { res, body } = await fetchImageJson(`${base}/responses`, {
     method: 'POST', headers: authHeaders(key), signal: timeoutSignal(timeoutMs, signal),
     body: JSON.stringify({ model, input: prompt, stream: false, store: false, background: false,
-      tools: [{ type: 'image_generation', action: 'generate', ...(size ? { size: size.replace('*', 'x') } : {}) }],
+      tools: [{ type: 'image_generation', action: 'generate', ...(requestSize ? { size: requestSize } : {}) }],
       tool_choice: { type: 'image_generation' } })
   });
-  const body = await readJson(res);
   if (!res.ok) throw providerError(res.status, body, 'Responses 生图失败', res.headers);
   if (body?.status !== 'completed') throw imageResponseError('Responses 生图未返回同步完成结果；禁止自动重提');
   const output = Array.isArray(body.output) ? body.output : [];
@@ -469,11 +531,14 @@ export async function listModels({ key, baseUrl, timeoutMs = T_SUBMIT, signal })
         ? item.inference_metadata.request_modality.map((value) => String(value).toLowerCase()) : [];
       const responseModalities = Array.isArray(item?.inference_metadata?.response_modality)
         ? item.inference_metadata.response_modality.map((value) => String(value).toLowerCase()) : [];
-      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');
-      if (requestModalities.includes('image') && responseModalities.includes('text')) capabilities.push('VU');
+      // 明确能力代码（含空数组/未知新能力）优先，不能被通用模态推断追加用途。
+      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');
+        if (requestModalities.includes('image') && responseModalities.includes('text')) capabilities.push('VU');
+      }
       const normalizedCapabilities = [...new Set(capabilities)];
       found.set(id, normalizedCapabilities.length ? { id, capabilities: normalizedCapabilities } : id);
     }

package/lib/api.js

@@ -33,9 +33,12 @@ import {
   importPromptOptimizerConfig,
   loadPromptOptimizerConfig,
   resetPromptOptimizerConfig,
+  resetPromptOptimizerInstructions,
   setPromptOptimizerEnabled
 } from './prompt-optimizer-config.js';
 
+const PROMPT_CONFIG_CAPABILITIES = Object.freeze({ ...PROMPT_OPTIMIZER_CAPABILITIES, resetInstructions: true });
+
 function readJsonSafe(file) {
   try {
     const raw = fs.readFileSync(file, 'utf8');
@@ -369,7 +372,7 @@ export function serveApi(req, res, host) {
       return serveSse(res);
     }
     if (urlPath === '/iris/api/prompt-optimizer/config') {
-      return sendJson(res, 200, method === 'HEAD' ? {} : { ...loadPromptOptimizerConfig(), capabilities: PROMPT_OPTIMIZER_CAPABILITIES });
+      return sendJson(res, 200, method === 'HEAD' ? {} : { ...loadPromptOptimizerConfig(), capabilities: PROMPT_CONFIG_CAPABILITIES });
     }
     if (urlPath === '/iris/api/doctor') {
       if (!host || typeof host !== 'object') return sendJson(res, 503, { error: 'host unavailable' });
@@ -506,7 +509,9 @@ function handleJsonPost(req, res, execute, respond = sendJson) {
     if (overflow) return finish(413, { error: 'request body too large (limit 1MB)' });
     try {
       const raw = Buffer.concat(chunks).toString('utf8');
-      const body = raw ? JSON.parse(raw) : {};
+      let body;
+      try { body = raw ? JSON.parse(raw) : {}; }
+      catch (_) { return finish(controller.signal.aborted ? 499 : 400, { error: controller.signal.aborted ? 'request canceled' : 'invalid JSON' }); }
       const result = await execute(body, controller.signal);
       if (controller.signal.aborted) return finish(499, { error: 'request canceled' });
       finish(200, result);
@@ -630,10 +635,14 @@ function handlePromptOptimizer(host, operation, req, res) {
     if (operation === 'optimize') return optimizePrompt(host, body, { signal });
     if (operation === 'import') {
       const imported = body && body.config !== undefined ? body.config : body;
-      return { ok: true, ...importPromptOptimizerConfig(imported), capabilities: PROMPT_OPTIMIZER_CAPABILITIES };
+      return { ok: true, ...importPromptOptimizerConfig(imported), capabilities: PROMPT_CONFIG_CAPABILITIES };
+    }
+    if (operation === 'reset') {
+      const scope = body?.scope === undefined ? 'all' : body.scope;
+      if (!['all', 'instructions'].includes(scope)) throw new Error('scope 只能是 all 或 instructions');
+      return { ok: true, ...(scope === 'instructions' ? resetPromptOptimizerInstructions() : resetPromptOptimizerConfig()), capabilities: PROMPT_CONFIG_CAPABILITIES };
     }
-    if (operation === 'reset') return { ok: true, ...resetPromptOptimizerConfig(), capabilities: PROMPT_OPTIMIZER_CAPABILITIES };
-    if (operation === 'enabled') return { ok: true, ...setPromptOptimizerEnabled(body && body.enabled), capabilities: PROMPT_OPTIMIZER_CAPABILITIES };
+    if (operation === 'enabled') return { ok: true, ...setPromptOptimizerEnabled(body && body.enabled), capabilities: PROMPT_CONFIG_CAPABILITIES };
     throw new Error('unknown prompt optimizer operation');
   });
 }

package/lib/bundled-skills.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { requireHostPort } from './host-contract.js';
 
-const SKILL_NAMES = ['iris-verify-ui', 'iris-compose-media'];
+const SKILL_NAMES = ['iris-use', 'iris-compose-media', 'iris-verify-ui'];
 const SKILL_ROOT = fileURLToPath(new URL('../.dsh/skills/', import.meta.url));
 
 function parseScalar(value, file) {

package/lib/capability.js

@@ -6,7 +6,7 @@
  * - 能力常量：image-gen / video-gen / tts / transcribe / vision
  * - 严格选择：不具备某能力的 Provider 不得被兜底选中
  * - 有序 failover：同一能力按 providers.json 声明顺序返回，调用方按序尝试
- * - 旧配置迁移：老 provider（无 capabilities 数组）按模型字段推断能力
+ * - 能力只来自明确标签或旧模型字段绑定，不按供应商端点赋能
  *
  * 本模块是纯函数，不读写磁盘；只吃 provider 记录、吐能力判断。
  */
@@ -14,6 +14,7 @@ export const CAPABILITIES = Object.freeze({
   IMAGE: 'image-gen',
   VIDEO: 'video-gen',
   TTS: 'tts',
+  MUSIC: 'music-gen',
   TRANSCRIBE: 'transcribe',
   VISION: 'vision'
 });
@@ -26,40 +27,48 @@ const INFER_FIELD = {
   [CAPABILITIES.IMAGE]: 'imageModel',
   [CAPABILITIES.VIDEO]: 'videoModel',
   [CAPABILITIES.TTS]: 'ttsModel',
+  [CAPABILITIES.MUSIC]: 'musicModel',
   [CAPABILITIES.TRANSCRIBE]: 'transcribeModel',
   [CAPABILITIES.VISION]: 'visionModel'
 };
 
+/** 模型级明确标签优先；旧能力字段只为同名模型提供明确绑定。 */
+export function configuredModelCapabilities(provider, model) {
+  if (Array.isArray(model?.capabilities)) {
+    return [...new Set(model.capabilities.filter(isKnownCapability))];
+  }
+  const id = typeof model === 'string' ? model.trim() : String(model?.id || '').trim();
+  if (!id) return [];
+  const bound = Object.entries(INFER_FIELD)
+    .filter(([, field]) => typeof provider?.[field] === 'string' && provider[field].trim() === id)
+    .map(([capability]) => capability);
+  return Array.isArray(provider?.capabilities) ? bound.filter((capability) => provider.capabilities.includes(capability)) : bound;
+}
+
 export function isKnownCapability(capability) {
   return KNOWN.has(capability);
 }
 
 /**
  * 一个 provider 的能力列表（去重、只留已知能力）。
- * 迁移规则（旧配置）：
- *   ① capabilities 显式声明 → 权威（严格使用，不额外推断）；
- *   ② 否则按模型字段推断（imageModel→image-gen 等）；
- *   ③ 仍为空且是 DashScope 端点 → 全部媒体能力
- *      （百炼单一 API 服务 t2i/t2v/tts/compatible-vision，裸账号常见于迁移期）。
+ * 显式模型池优先，包括空池；其次是账号明确标签（含空数组），
+ * 最后兼容旧能力字段绑定。账号地址和模型名称都不证明能力。
  * @param {object} p provider 记录
  * @returns {string[]}
  */
 export function capabilitiesOf(p) {
-  const declared = Array.isArray(p && p.capabilities) ? p.capabilities : [];
-  if (declared.some((c) => isKnownCapability(c))) {
-    return [...new Set(declared)].filter(isKnownCapability);
+  if (Array.isArray(p?.models)) {
+    return [...new Set(p.models.flatMap((model) => configuredModelCapabilities(p, model)))];
+  }
+  if (Array.isArray(p?.capabilities)) {
+    return [...new Set(p.capabilities.filter(isKnownCapability))];
   }
   // 旧配置迁移：按模型字段推断（有该能力模型才认为具备该能力）
   const inferred = [];
   for (const [cap, field] of Object.entries(INFER_FIELD)) {
-    if (p && p[field]) inferred.push(cap);
-  }
-  if (inferred.length) return inferred;
-  // 裸 DashScope 账号兜底迁移
-  if (p && /dashscope/i.test(String(p.baseUrl || ''))) {
-    return Object.values(CAPABILITIES);
+    if (typeof p?.[field] === 'string' && p[field].trim()) inferred.push(cap);
   }
-  return [];
+  return inferred;
 }
 
 /**