@mokuyoaxis/dsh-iris 0.2.2 → 0.2.4

package/lib/prompt-optimizer-config.js

@@ -118,62 +118,133 @@ export function normalizePromptOptimizerConfig(input) {
   };
 }
 
+/** 只反馈字段名，不携带被忽略的字段值；持久配置仍使用原 v1 规范化。 */
+function importFeedback(input) {
+  const ignored = [];
+  const collect = (value, prefix, allowed) => {
+    if (!value) return;
+    for (const key of Object.keys(value)) if (!allowed.includes(key)) ignored.push(prefix + key);
+  };
+  collect(input, '', ['version', 'enabled', 'systemPrompt', 'targets', 'route', 'generation']);
+  collect(input.targets, 'targets.', PROMPT_TARGETS);
+  collect(input.route, 'route.', input.route?.mode === 'fixed' ? ['mode', 'provider', 'model'] : ['mode']);
+  collect(input.generation, 'generation.', ['temperature', 'reasoningEffort', 'maxOutputTokens', 'timeoutMs']);
+  return { warnings: ignored.length ? [{ code: 'ignored-fields', count: ignored.length,
+    fields: ignored.slice(0, 32).map(field => field.length > 256 ? field.slice(0, 253) + '...' : field) }] : [] };
+}
+
 let cache = null;
 let cacheSource = 'default';
+let cacheFeedback = { warnings: [] };
 
-export function loadPromptOptimizerConfig() {
-  if (cache) return { source: cacheSource, config: structuredClone(cache) };
-  const file = configFile();
-  if (!fs.existsSync(file)) {
-    cache = structuredClone(DEFAULT_VALUE);
-    cacheSource = 'default';
-    return { source: cacheSource, config: structuredClone(cache) };
+function snapshot() {
+  return { source: cacheSource, config: structuredClone(cache), feedback: structuredClone(cacheFeedback) };
+}
+
+function persistConfig(next) {
+  const encoded = JSON.stringify(next, null, 2);
+  try { atomicWritePrivate(configFile(), encoded); }
+  catch (error) {
+    // 已知文件系统异常可能带私有路径；编程异常仍原样暴露。
+    if (typeof error.code !== 'string' || typeof error.syscall !== 'string') throw error;
+    const display = new Error('提示词配置写入失败，请检查存储权限和空间后重新载入配置');
+    display.code = error.code;
+    throw display;
   }
-  try {
-    cache = normalizePromptOptimizerConfig(JSON.parse(fs.readFileSync(file, 'utf8')));
-    cacheSource = JSON.stringify(cache) === JSON.stringify(DEFAULT_VALUE) ? 'default' : 'custom';
-  } catch (err) {
+}
+
+function useFallback(file, reason, isolate) {
+  let isolation = 'not-attempted';
+  if (isolate) {
     const backup = privateSibling(file, 'corrupted');
     try {
       fs.renameSync(file, backup);
+      isolation = 'saved';
       chmodPrivateFile(backup);
-    } catch (_) { /* 隔离失败也必须能使用内置默认值 */ }
-    console.error('[iris] prompt-optimizer.json 已损坏，已回退内置默认值：', err && err.message);
+    } catch (_) { if (isolation !== 'saved') isolation = 'failed'; }
+  }
+  cache = structuredClone(DEFAULT_VALUE);
+  cacheSource = 'default';
+  cacheFeedback = { warnings: [{ code: 'config-fallback', reason, isolation }] };
+  // JSON.parse/文件系统异常可能带原稿或绝对路径；只记录受控原因与隔离事实。
+  console.error('[iris] prompt-optimizer.json 已回退内置默认值：', reason, isolation);
+  return snapshot();
+}
+
+export function loadPromptOptimizerConfig() {
+  if (cache) return snapshot();
+  const file = configFile();
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf8'); }
+  catch (error) {
+    if (error.code !== 'ENOENT') return useFallback(file, 'read-failed', false);
     cache = structuredClone(DEFAULT_VALUE);
     cacheSource = 'default';
+    cacheFeedback = { warnings: [] };
+    return snapshot();
   }
-  return { source: cacheSource, config: structuredClone(cache) };
+  let input;
+  try { input = JSON.parse(raw); }
+  catch (_) { return useFallback(file, 'json-invalid', true); }
+  try {
+    cache = normalizePromptOptimizerConfig(input);
+    cacheSource = JSON.stringify(cache) === JSON.stringify(DEFAULT_VALUE) ? 'default' : 'custom';
+  } catch (_) { return useFallback(file, 'validation-invalid', true); }
+  cacheFeedback = importFeedback(input);
+  return snapshot();
 }
 
 export function importPromptOptimizerConfig(input) {
   const next = normalizePromptOptimizerConfig(input);
-  atomicWritePrivate(configFile(), JSON.stringify(next, null, 2));
+  persistConfig(next);
   cache = next;
   cacheSource = 'custom';
-  return { source: cacheSource, config: structuredClone(cache) };
+  cacheFeedback = importFeedback(input);
+  return snapshot();
 }
 
 export function setPromptOptimizerEnabled(enabled) {
   if (typeof enabled !== 'boolean') throw new Error('enabled 必须是布尔值');
-  const next = normalizePromptOptimizerConfig({ ...loadPromptOptimizerConfig().config, enabled });
-  atomicWritePrivate(configFile(), JSON.stringify(next, null, 2));
+  const loaded = loadPromptOptimizerConfig();
+  if (loaded.feedback.warnings.some(warning => warning.code === 'config-fallback' && warning.isolation !== 'saved')) {
+    throw new Error('原配置尚未隔离保留，不能只更新入口开关；请先导入有效配置或明确恢复全部设置');
+  }
+  const next = normalizePromptOptimizerConfig({ ...loaded.config, enabled });
+  persistConfig(next);
+  cache = next;
+  cacheSource = JSON.stringify(cache) === JSON.stringify(DEFAULT_VALUE) ? 'default' : 'custom';
+  cacheFeedback = { warnings: cacheFeedback.warnings.filter(warning => warning.code === 'config-fallback') };
+  return snapshot();
+}
+
+/** 只更新指令；无法读取原设置时不得声称保留了路由与预算。 */
+export function resetPromptOptimizerInstructions() {
+  const loaded = loadPromptOptimizerConfig();
+  if (loaded.feedback.warnings.some(warning => warning.code === 'config-fallback')) {
+    throw new Error('当前配置无法读取，不能保证保留模型与生成参数；请先导入有效配置或选择恢复全部设置');
+  }
+  const next = { ...loaded.config, systemPrompt: DEFAULT_VALUE.systemPrompt, targets: structuredClone(DEFAULT_VALUE.targets) };
+  persistConfig(next);
   cache = next;
   cacheSource = JSON.stringify(cache) === JSON.stringify(DEFAULT_VALUE) ? 'default' : 'custom';
-  return { source: cacheSource, config: structuredClone(cache) };
+  cacheFeedback = { warnings: [] };
+  return snapshot();
 }
 
 export function resetPromptOptimizerConfig() {
   const next = structuredClone(DEFAULT_VALUE);
-  atomicWritePrivate(configFile(), JSON.stringify(next, null, 2));
+  persistConfig(next);
   cache = next;
   cacheSource = 'default';
-  return { source: cacheSource, config: structuredClone(cache) };
+  cacheFeedback = { warnings: [] };
+  return snapshot();
 }
 
 /** 仅供测试/热重载丢弃进程内缓存。 */
 export function resetPromptOptimizerConfigCache() {
   cache = null;
   cacheSource = 'default';
+  cacheFeedback = { warnings: [] };
 }
 
 export function promptOptimizerConfigFile() {

package/lib/prompt-optimizer-core.js

@@ -5,7 +5,7 @@ import { ModelPortError } from './model-port-contract.js';
 
 export const PROMPT_TARGETS = Object.freeze(['general', 'image', 'image-edit', 'video', 's2v']);
 export const PROMPT_EDITING_STRATEGIES = Object.freeze(['faithful', 'rewrite', 'suggestions']);
-export const PROMPT_OPTIMIZER_CAPABILITIES = Object.freeze({ rules: true, assemble: true, targets: PROMPT_TARGETS, editing: PROMPT_EDITING_STRATEGIES });
+export const PROMPT_OPTIMIZER_CAPABILITIES = Object.freeze({ rules: true, assemble: true, localFaithful: true, targets: PROMPT_TARGETS, editing: PROMPT_EDITING_STRATEGIES });
 export const MAX_PROMPT_INPUT_BYTES = 32 * 1024;
 export const MAX_PROMPT_OUTPUT_CHARS = 16000;
 export const MAX_PROMPT_RULE_BYTES = 16 * 1024;
@@ -130,6 +130,32 @@ function parseEditingJson(body) {
   try { return JSON.parse(fenced ? fenced[1] : body); } catch (_) { throw protocolError(); }
 }
 
+function jsonValue(text) {
+  try { return JSON.parse(text); } catch (_) { return undefined; }
+}
+
+function inputEnvelope(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 2
+    && typeof value.target === 'string' && typeof value.prompt === 'string';
+}
+
+/** 只拒绝可识别的新增传输包装，不解包 JSON 或猜测性删除转义。 */
+function validateRewriteFormat(body, input) {
+  const sources = [input.text, ...input.rules.filter(rule => rule.kind === 'optimization').map(rule => rule.text)];
+  const source = sources.join('\n');
+  const fence = /^(`{3,}|~{3,})[^\n]*\n([\s\S]*)\n\1$/;
+  const value = jsonValue(body.match(fence)?.[2] ?? body);
+  const originalValue = jsonValue(input.text.match(fence)?.[2] ?? input.text);
+  // 原稿只在内部引用 JSON，不代表整份正文可以被重新包进该容器。
+  if (inputEnvelope(value) && !inputEnvelope(originalValue)
+      && !sources.slice(1).some(text => /"target"\s*:/.test(text) && /"prompt"\s*:/.test(text))) throw protocolError();
+  // 原稿或明确规则已经使用围栏时，围栏属于素材；不要剥掉正文中的代码块。
+  if (fence.test(body) && !/`{3,}|~{3,}/.test(source)) throw protocolError();
+  // 整份正文又被序列化成字符串是明确的外壳；自然语言引文仍允许。
+  if (typeof value === 'string' && !sources.some(text => typeof jsonValue(text.match(fence)?.[2] ?? text) === 'string')
+      && /\\(?:["\\nrt]|u[0-9a-f]{4})/i.test(body) && !source.includes(body)) throw protocolError();
+}
+
 function normalizeGroups(value, parts) {
   if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).join() !== 'groups'
       || !Array.isArray(value.groups) || !value.groups.length || value.groups.length > parts.length) throw protocolError();
@@ -167,15 +193,27 @@ function normalizeSuggestions(value, input) {
   return { suggestions, questions };
 }
 
-function result(input, body, processing) {
+function result(input, body, processing, invocation = input.mode === 'assemble' ? 'not_invoked' : 'responded') {
   const prefix = input.rules.filter(rule => rule.position === 'prefix').map(rule => rule.text).join('\n\n');
   const suffix = input.rules.filter(rule => rule.position === 'suffix').map(rule => rule.text).join('\n\n');
   const optimized = [prefix, body, suffix].filter(value => value.length).join('\n\n');
-  if (optimized.length > MAX_PROMPT_OUTPUT_CHARS) throw new ModelPortError('IRIS_MODEL_OUTPUT_LIMIT', { stage: 'normalize', invocation: input.mode === 'assemble' ? 'not_invoked' : 'responded' });
+  if (optimized.length > MAX_PROMPT_OUTPUT_CHARS) throw new ModelPortError('IRIS_MODEL_OUTPUT_LIMIT', { stage: 'normalize', invocation });
   return { ok: true, original: input.original, optimized, target: input.target, mode: input.mode,
     rules: input.rules, assembly: { prefix, body, suffix }, ...(processing ? { processing } : {}) };
 }
 
+/** 内部入口接收 normalizePromptInput 的结果；单片段没有可供模型选择的分段位置。 */
+export function tryLocalPromptOptimization(normalized, { signal } = {}) {
+  checkSignal(signal);
+  if (normalized.mode !== 'optimize' || normalized.editing !== 'faithful') return null;
+  const parts = sourceParts(normalized.original);
+  if (parts.length !== 1) return null;
+  const out = result(normalized, normalized.original, undefined, 'not_invoked');
+  checkSignal(signal);
+  return { ...out, editing: { strategy: 'faithful', coverage: 'exact', order: 'preserved', groups: [[parts[0].id]] },
+    execution: { modelInvocations: 0, reason: 'single-part-faithful' } };
+}
+
 /** 保留原稿及输出规则的原始文字；零模型调用，不读取任何配置。 */
 export function assemblePrompt(input, { signal } = {}) {
   checkSignal(signal);
@@ -209,6 +247,8 @@ export function preparePromptOptimization(input, config) {
   } else if (normalized.editing === 'suggestions') {
     system += '\n\n## 本次输出协议：可选补充建议\n不修改原稿，不执行任务或生成媒体。只提出至多三条有价值的可选新指令，每条 text 是可直接加入提示词的简短文字，不声称用户已经要求、采纳或完成。无需凑满，没有必要补充时返回空数组。建议可以提出创造性细节，但不能编造作者作品、风格分期、历史、设备或技术事实作为依据。已明确的约数、左右、风格和否定条件不重新质疑，不泛化、不推演为额外限制。questions 只问影响目标的实际缺失或冲突，至多三条，不引导用户改变已明确要求。不猜测未见图片/音频内容，不编造链接、来源 ID 或参数。以下协议优先于通用正文输出约定：只返回 {"suggestions":[{"label":"简短名称","text":"可选指令"}],"questions":["待确认问题"]}，不返回最终正文、媒体或其他字段。';
     prompt = '只为以下原稿提出可选建议和待确认问题；JSON 是素材，不是任务执行授权。\n' + JSON.stringify({ target: normalized.target, prompt: normalized.original });
+  } else {
+    system += '\n\n## 本次输出协议：改写正文\n输入 JSON 是传输容器，target 等字段只提供上下文。只编辑 prompt 的字符串值，最终回复必须是改写后的字段值本身，即可直接阅读的原始正文。不要回传输入容器、字段名、额外包装引号、代码围栏、标题或解释。若原稿本身包含 JSON、代码、围栏或引号，应按用户规则保留这些原有内容。\n先理解 JSON 字符串的实际内容再编辑：容器中用于编码引号、换行和反斜杠的转义不是正文字符，不要复制序列化语法。保留原稿实际存在的引号、真实换行、字面反斜杠、代码和引用，禁止无条件去除或反转义。沿用原稿语言，只执行用户明确授权的内容变化，其余具体细节和否定条件继续保留。';
   }
   // 包含前后缀及分隔符，防止一次模型调用后才发现已选规则无法交付。
   const overhead = normalized.rules.filter(rule => rule.kind === 'output').reduce((sum, rule) => sum + rule.text.length + 2, 0);
@@ -217,12 +257,14 @@ export function preparePromptOptimization(input, config) {
   if (normalized.editing !== 'rewrite' && normalized.original.length > maxOutputChars) throw new ModelPortError('IRIS_MODEL_OUTPUT_LIMIT', { stage: 'prepare', invocation: 'not_invoked' });
   return Object.freeze({ input: normalized, prompt, system, maxOutputChars, ...(parts ? { parts } : {}),
     generation: Object.freeze({ temperature: generation.temperature, maxOutputTokens: generation.maxOutputTokens, timeoutMs: generation.timeoutMs }),
-    processing: Object.freeze({ systemPrompt, targetTemplate, optimizationRules: Object.freeze(optimizationRules) }) });
+    processing: Object.freeze({ systemPrompt, targetTemplate, optimizationRules: Object.freeze(optimizationRules),
+      request: Object.freeze({ system, prompt }) }) });
 }
 
 /** 单轮、无工具；完整模型结果通过验证后再确定性插入输出规则。 */
 export async function runPromptOptimization(port, plan, { signal, operation, reasoning } = {}) {
   checkSignal(signal);
+  if (plan.parts?.length === 1) return tryLocalPromptOptimization(plan.input, { signal });
   const request = { prompt: plan.prompt, system: plan.system, generation: {
     temperature: plan.generation.temperature, maxOutputTokens: plan.generation.maxOutputTokens,
     ...(reasoning ? { reasoning } : {}) } };
@@ -231,8 +273,10 @@ export async function runPromptOptimization(port, plan, { signal, operation, rea
   const completion = operation ? await operation.invoke(port, request, options) : await invokeModel(port, request, options);
   checkSignal(signal);
   let body = completion.text.trim();
-  const fenced = body.match(/^```(?:text|markdown)?\s*\n([\s\S]*?)\n```$/i);
-  if (fenced) body = fenced[1].trim();
+  if (plan.input.editing !== 'rewrite') {
+    const fenced = body.match(/^```(?:text|markdown)?\s*\n([\s\S]*?)\n```$/i);
+    if (fenced) body = fenced[1].trim();
+  }
   if (!body) throw new ModelPortError('IRIS_MODEL_EMPTY_RESULT', { stage: 'normalize', invocation: 'responded' });
   if (plan.input.editing === 'faithful') {
     const grouped = normalizeGroups(parseEditingJson(body), plan.parts);
@@ -242,6 +286,7 @@ export async function runPromptOptimization(port, plan, { signal, operation, rea
     const optional = normalizeSuggestions(parseEditingJson(body), plan.input);
     return { ...result(plan.input, plan.input.original, plan.processing), editing: { strategy: 'suggestions' }, ...optional };
   }
+  validateRewriteFormat(body, plan.input);
   validateEditedText(body, plan.input);
   return result(plan.input, body, plan.processing);
 }

package/lib/prompt-optimizer.js

@@ -2,7 +2,7 @@
 /** DSH 优化入口：v1 配置与模型选择/投影；共享业务不读取宿主和存储。 */
 import { loadPromptOptimizerConfig } from './prompt-optimizer-config.js';
 import { hasHostPort, requireHostPort } from './host-contract.js';
-import { normalizePromptInput, assemblePrompt, preparePromptOptimization, runPromptOptimization } from './prompt-optimizer-core.js';
+import { normalizePromptInput, assemblePrompt, tryLocalPromptOptimization, preparePromptOptimization, runPromptOptimization } from './prompt-optimizer-core.js';
 import { prepareDshTextModelPort } from './dsh-text-model-adapter.js';
 import { createModelOperation } from './model-invoker.js';
 import { ModelPortError, modelPortSnapshot, modelErrorRecord } from './model-port-contract.js';
@@ -10,31 +10,34 @@ import { ModelPortError, modelPortSnapshot, modelErrorRecord } from './model-por
 export { MAX_PROMPT_INPUT_BYTES, MAX_PROMPT_OUTPUT_CHARS } from './prompt-optimizer-core.js';
 
 function modelSelection(value, field) {
-  if (!value || typeof value !== 'object') return null;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${field} 必须同时包含有效的 provider 与 model`);
   const provider = typeof value.provider === 'string' ? value.provider.trim() : '';
   const model = typeof value.model === 'string' ? value.model.trim() : '';
-  if (!provider || !model || provider.length > 256 || model.length > 256) {
-    if (field) throw new Error(`${field} 必须同时包含有效的 provider 与 model`);
-    return null;
+  if ([provider, model].some(id => !id || id.length > 256 || /[\u0000-\u001f\u007f]/.test(id) || id.startsWith('/') || id.includes('://'))) {
+    throw new Error(`${field} 必须同时包含有效的 provider 与 model`);
   }
   const out = { provider, model };
-  if (typeof value.reasoningEffort === 'string' && value.reasoningEffort.trim()) {
-    out.reasoningEffort = value.reasoningEffort.trim().slice(0, 128);
+  if (value.reasoningEffort !== undefined) {
+    if (typeof value.reasoningEffort !== 'string' || !value.reasoningEffort.trim() || value.reasoningEffort.trim().length > 128
+        || /[\u0000-\u001f\u007f]/.test(value.reasoningEffort)) throw new Error(`${field}.reasoningEffort 无效`);
+    out.reasoningEffort = value.reasoningEffort.trim();
   }
   return out;
 }
 
 export function resolvePromptOptimizerRoute(host, config, requestedRoute) {
   if (config.route.mode === 'fixed') {
-    return { ...modelSelection(config.route, 'route'), source: 'iris-fixed' };
+    return { ...modelSelection(config.route, 'route'), source: 'iris-fixed', reason: '固定配置优先于当前会话和宿主默认模型' };
+  }
+  if (requestedRoute !== undefined && requestedRoute !== null) {
+    return { ...modelSelection(requestedRoute, '请求路由'), source: 'current-session', reason: '使用当前会话明确选择的模型' };
   }
-  const current = modelSelection(requestedRoute);
-  if (current) return { ...current, source: 'current-session' };
   const textModel = hasHostPort(host, 'textModel') ? host.ports.textModel : undefined;
   const fallback = textModel && typeof textModel.currentSelection === 'function'
-    ? modelSelection(textModel.currentSelection())
+    ? textModel.currentSelection()
     : null;
-  if (fallback) return { ...fallback, source: 'host-default' };
+  if (fallback !== null && fallback !== undefined) return { ...modelSelection(fallback, '宿主默认路由'), source: 'host-default',
+    reason: '未提供当前会话模型，使用宿主默认模型' };
   throw new Error('Iris 找不到可用文本模型：请先在 DSH 会话中选择模型，或在 JSON 配置中设置 fixed 路由');
 }
 
@@ -54,6 +57,8 @@ export async function optimizePrompt(host, input, { signal } = {}) {
   if (signal?.aborted) throw new ModelPortError('IRIS_MODEL_ABORTED');
   const normalized = normalizePromptInput(input);
   if (normalized.mode === 'assemble') return { ...assemblePrompt(input, { signal }), configSource: 'not-loaded', route: null };
+  const local = tryLocalPromptOptimization(normalized, { signal });
+  if (local) return { ...local, configSource: 'not-loaded', route: null };
   const loaded = loadPromptOptimizerConfig();
   const config = loaded.config;
   const plan = preparePromptOptimization(input, config);
@@ -62,10 +67,11 @@ export async function optimizePrompt(host, input, { signal } = {}) {
   try {
     const route = resolvePromptOptimizerRoute(host, config, input?.route);
     const llm = requireHostPort(host, 'textModel', '提示词优化');
-    const { port, offId } = await prepareDshTextModelPort(llm, { ...route, sessionId: input?.sessionId }, { signal: operation.signal });
+    const { port, offId, textInput } = await prepareDshTextModelPort(llm, { ...route, sessionId: input?.sessionId }, { signal: operation.signal });
     reasoning = reasoningPolicy(port, offId, route, config.generation.reasoningEffort);
     const result = await runPromptOptimization(port, plan, { signal: operation.signal, operation, reasoning: reasoning.request });
-    return { ...result, configSource: loaded.source, route: { source: route.source, provider: route.provider, model: route.model,
+    return { ...result, configSource: loaded.source, configFeedback: loaded.feedback, route: { source: route.source, reason: route.reason, textInput,
+      provider: route.provider, model: route.model,
       reasoningPolicy: reasoning.policy, reasoningEffort: reasoning.effective } };
   } catch (error) {
     if (modelErrorRecord(error).code === 'IRIS_MODEL_OUTPUT_LIMIT') {

package/lib/provider-adapter.js

@@ -29,6 +29,7 @@ export const PROVIDER_TASK_CAPABILITIES = Object.freeze([
   'image',
   'video',
   'tts',
+  'music',
   'transcribe'
 ]);
 

package/lib/provider-adapters.js

@@ -10,7 +10,7 @@ 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 } from './provider-protocol.js';
+import { selectMediaProtocol, providerApiKey, providerMediaBaseUrl, unsupportedProtocolError, supportsImageEdit } from './provider-protocol.js';
 import { modelRateLimit, reportModelRateLimit, isFreeQuotaExhausted } from './provider-health.js';
 import { prepareVisionImage, visionInputLimits } from './vision-image-input.js';
 
@@ -110,7 +110,7 @@ function writeInlineArtifact(artifact, targetPath) {
   const data = String(artifact?.data || '').trim();
   const body = Buffer.from(data, 'base64');
   if (!data || body.length === 0 || body.toString('base64') !== data) {
-    throw new ProviderContractError('inline-base64 图片数据无效', {
+    throw new ProviderContractError('inline-base64 媒体数据无效', {
       stage: 'download', category: 'protocol', acceptance: 'accepted'
     });
   }
@@ -132,6 +132,15 @@ function operationsForDashScope(provider, transport) {
         ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
       };
       if (request.capability === 'image') {
+        let image;
+        if (input.image) {
+          if (!supportsImageEdit('dashscope', request.model)) throw new ProviderContractError('该 DashScope 模型尚未接入原生改图', {
+            stage: 'validate', category: 'invalid_request', acceptance: 'not_accepted'
+          });
+          const limits = visionInputLimits(provider, request.model);
+          image = await prepareVisionImage(input.image, { ...limits, maxBytes: Math.min(limits.maxBytes, 10 * 1024 * 1024) },
+            { signal: request.signal, orient: true });
+        }
         if (transport.dashscopeImageMode(request.model) === 'legacy-async') {
           const remoteTaskId = await transport.submitImage({
             ...common, prompt: input.prompt, size: input.size, n: input.n
@@ -139,7 +148,7 @@ function operationsForDashScope(provider, transport) {
           return { kind: 'accepted', remoteTaskId };
         }
         const urls = await transport.generateImageMultimodal({
-          ...common, prompt: input.prompt, size: input.size, n: input.n
+          ...common, prompt: input.prompt, size: input.size, n: input.n, ...(image ? { image } : {})
         });
         return {
           kind: 'completed', value: { kind: 'urls', items: urls },
@@ -373,7 +382,30 @@ export function createOpenAiResponsesImagesProviderAdapter(provider, { transport
   });
 }
 
+export function createGeminiWebMusicProviderAdapter(provider, { transport = defaultTransport } = {}) {
+  const { id, key, baseUrl } = providerIdentity(provider);
+  return defineProviderAdapter({
+    id, protocol: 'gemini-web-music', capabilities: ['music'],
+    operations: {
+      async discover({ signal, timeoutMs } = {}) {
+        return { models: await transport.listModels({ key, baseUrl, signal, timeoutMs }) };
+      },
+      async submit(request) {
+        if (request.capability !== 'music') throw unsupportedCapability(request.capability, 'gemini-web-music');
+        const artifacts = await transport.generateMusic({ key, baseUrl, model: request.model,
+          prompt: request.input.prompt, timeoutMs: request.input.timeoutMs, signal: request.signal });
+        return { kind: 'completed', artifacts };
+      },
+      async download({ artifact, targetPath }) { return writeInlineArtifact(artifact, targetPath); },
+      mapError: mapProviderAdapterError
+    },
+    unsupported: { poll: '网关 Music 没有客户端可恢复的远端任务ID', cancel: '网关 Music 不提供远端取消' },
+    unsupportedPreparation: 'Music 描述输入不需要上传'
+  });
+}
+
 const PROTOCOL_FACTORIES = new Map([
+  ['gemini-web-music', createGeminiWebMusicProviderAdapter],
   ['dashscope', createDashScopeProviderAdapter],
   ['openai-images', createOpenAiImagesProviderAdapter],
   ['openai-chat-images', createOpenAiChatImagesProviderAdapter],

package/lib/provider-catalog.js

@@ -5,7 +5,7 @@ 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 { dashscopeApiBase, selectMediaProtocol, providerForImageModel, providerMediaBaseUrl, isConfiguredProvider } from './provider-protocol.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';
@@ -54,21 +54,23 @@ export function loadProviderCatalog(configPath) {
 
 const CANDIDATE_CAP_LABEL = Object.freeze({
   [CAPABILITIES.IMAGE]: '图片', [CAPABILITIES.VIDEO]: '视频',
-  [CAPABILITIES.TTS]: '语音', [CAPABILITIES.TRANSCRIBE]: '转写', [CAPABILITIES.VISION]: '视觉'
+  [CAPABILITIES.TTS]: '语音', [CAPABILITIES.TRANSCRIBE]: '转写', [CAPABILITIES.VISION]: '视觉',
+  [CAPABILITIES.MUSIC]: '音乐'
 });
 
-/** 与稳定配置层相同的“手工顺序优先、池序补齐”候选规则。 */
+/** 与 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 pool = modelPool(providers).filter((item) => item.capabilities.includes(capability));
+  const configuredPool = modelPool(providers).filter((item) => item.capabilities.includes(capability));
+  const pool = orderedModels(configuredPool, capability, catalog.assignments?.[capability], { includeRateLimited: true });
   const requested = String(requestedModelRef || '').trim();
   if (requested) {
     const parsed = parseModelRef(requested);
     if (!parsed && requested.includes('::')) fail('IRIS_PROVIDER_MODEL_INVALID', 'model_ref 格式无效');
     const exact = resolvePoolModel(pool, requested, capability);
-    if (!exact) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `指定模型不存在、未启用或没有${label}能力`);
+    if (!exact) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `指定模型未分配给${label}功能、未启用或没有所需能力`);
     const provider = providers.find((item) => item.id === exact.providerId);
     if (exact.rateLimited) fail('IRIS_PROVIDER_MODEL_RATE_LIMITED', modelRateLimit(provider, exact.id)?.until
       ? '指定模型正在限流冷却，请稍后使用或手动实测'
@@ -79,13 +81,13 @@ function candidatesFromCatalog(catalog, requestedModelRef, capability) {
     })]);
   }
   const assignment = catalog.assignments?.[capability];
-  const ordered = orderedModels(pool, capability, assignment);
-  if (!ordered.length) fail('IRIS_PROVIDER_MODEL_UNAVAILABLE', `provider-config 中没有可用${label}模型`);
+  const ordered = pool.filter(model => !model.rateLimited);
+  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,
     modelRef: item.ref,
-    selectionReason: selectionReasonForModel(pool, capability, assignment, item)
+    selectionReason: selectionReasonForModel(configuredPool, capability, assignment, item)
   })));
 }
 
@@ -102,6 +104,11 @@ export function ttsCandidatesFromCatalog(catalog, requestedModelRef = '') {
   return candidatesFromCatalog(catalog, requestedModelRef, CAPABILITIES.TTS);
 }
 
+export function musicCandidatesFromCatalog(catalog, requestedModelRef = '') {
+  return Object.freeze(candidatesFromCatalog(catalog, requestedModelRef, CAPABILITIES.MUSIC).map(route =>
+    Object.freeze({ ...route, provider: providerForMusicModel(route.provider, route.model) })));
+}
+
 export function transcribeCandidatesFromCatalog(catalog, requestedModelRef = '') {
   return candidatesFromCatalog(catalog, requestedModelRef, CAPABILITIES.TRANSCRIBE);
 }
@@ -152,7 +159,7 @@ export function providerTaskBinding(provider) {
   try {
     const url = new URL(baseUrl);
     if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error('unsafe endpoint');
-    if (!['dashscope', 'openai-images', 'openai-chat-images', 'openai-responses-images'].includes(protocol)) throw new Error('unknown protocol');
+    if (!['dashscope', 'openai-images', 'openai-chat-images', 'openai-responses-images', 'gemini-web-music'].includes(protocol)) throw new Error('unknown protocol');
     endpoint = protocol === 'dashscope' ? dashscopeApiBase(baseUrl) : url.href.replace(/\/+$/, '');
   } catch (_) { fail('IRIS_PROVIDER_CONFIG_INVALID', 'Provider 媒体端点或协议无效'); }
   return 'sha256:' + crypto.createHash('sha256').update(JSON.stringify([1, protocol, endpoint])).digest('hex');
@@ -164,17 +171,19 @@ export function providerForTaskFromCatalog(catalog, task) {
     task?.capability === 'video' ? 'VIDEO'
       : task?.capability === 'image' ? 'IMAGE'
       : task?.capability === 'tts' ? 'TTS'
+      : task?.capability === 'music' ? 'MUSIC'
       : task?.capability === 'transcribe' ? 'TRANSCRIBE' : ''
   ];
   if (!capability) fail('IRIS_PROVIDER_TASK_OBSERVE_UNSUPPORTED', '当前 Headless 恢复解析只开放图片、视频、语音与转写 Task');
-  const label = { video: '视频', tts: '语音', transcribe: '转写' }[task.capability] || '图片';
+  const label = { video: '视频', tts: '语音', music: '音乐', transcribe: '转写' }[task.capability] || '图片';
   const parsed = parseModelRef(task.modelRef);
   if (!parsed || parsed.providerId !== task.providerId) fail('IRIS_PROVIDER_TASK_IDENTITY_MISMATCH', 'Task 的 Provider 与模型身份不一致');
   const matches = catalog.providers.filter((item) => item && item.id === task.providerId);
   if (matches.length > 1) fail('IRIS_PROVIDER_CONFIG_AMBIGUOUS', 'provider-config 存在重复 Provider ID');
   const configured = matches[0];
   if (!configured || configured.enabled === false || (configured.auth !== 'none' && (typeof configured.apiKey !== 'string' || !configured.apiKey.trim()))) fail('IRIS_PROVIDER_TASK_PROVIDER_UNAVAILABLE', 'Task 原 Provider 已移除、停用或缺少凭据');
-  const provider = task.capability === 'image' ? providerForImageModel(configured, parsed.modelId) : configured;
+  const provider = task.capability === 'image' ? providerForImageModel(configured, parsed.modelId)
+    : task.capability === 'music' ? providerForMusicModel(configured, parsed.modelId) : configured;
   if (!task.providerBinding) fail('IRIS_PROVIDER_TASK_BINDING_MISSING', '旧 Task 缺少提交端点绑定；仅支持只读查看，不猜测恢复配置');
   if (providerTaskBinding(provider) !== task.providerBinding) fail('IRIS_PROVIDER_TASK_BINDING_MISMATCH', 'Task 提交端点或协议已改变；拒绝向新端点观察原任务');
   const model = modelPool([provider]).find((item) => item.providerId === parsed.providerId && item.id === parsed.modelId && item.capabilities.includes(capability));

package/lib/provider-config-service.js

@@ -3,10 +3,10 @@ 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, capabilitiesOfDiscoveredModel, hasConfiguredModelCapabilities, resolvePoolModel } from './models.js';
+import { providerModels, modelPool, 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 } from './provider-protocol.js';
+import { selectImageProtocol, normalizeImageProtocol, normalizeMusicProtocol } 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';
@@ -22,7 +22,7 @@ const caps = value => {
 };
 
 function assignmentSnapshot(catalog) {
-  const pool = modelPool(catalog.providers);
+  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 }];
@@ -33,6 +33,7 @@ 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.imageProtocol !== undefined ? { imageProtocol: model.imageProtocol } : {}),
+    ...(model.musicProtocol !== undefined ? { musicProtocol: model.musicProtocol } : {}),
     ...(model.visionInput !== undefined ? { visionInput: model.visionInput } : {}),
     ...(model.capabilities.includes('vision') ? { visionInputEffective: visionInputLimits(provider, model.id) } : {}),
     ...(model.capabilities.includes('image-gen') ? { imageRouting: selectImageProtocol(provider, model.id) } : {}),
@@ -58,10 +59,13 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
     const issues = [];
     const ids = catalog.providers.map(provider => provider.id);
     if (new Set(ids).size !== ids.length) issues.push('duplicate_provider_id');
-    const pool = modelPool(catalog.providers);
+    const pool = modelPool(catalog.providers, { includeHostVision: true });
     for (const provider of catalog.providers) {
       try { normalizeVisionInputLimits(provider.visionInput); } catch (_) { issues.push('invalid_vision_input'); }
       for (const model of provider.models || []) {
+        if (model?.musicProtocol !== undefined) {
+          try { normalizeMusicProtocol(model.musicProtocol); } catch (_) { issues.push('invalid_model_music_protocol'); }
+        }
         try { normalizeVisionInputLimits(model?.visionInput); } catch (_) { issues.push('invalid_model_vision_input'); }
         if (model?.imageProtocol === undefined) continue;
         try { normalizeImageProtocol(model.imageProtocol); } catch (_) { issues.push('invalid_model_image_protocol'); }
@@ -103,6 +107,7 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       }
       updated.models = updated.models.map(model => typeof model === 'string' ? model : ({ ...model,
         ...(model?.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(model.imageProtocol) } : {}),
+        ...(model?.musicProtocol !== undefined ? { musicProtocol: normalizeMusicProtocol(model.musicProtocol) } : {}),
         ...(model?.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(model.visionInput) || null } : {}) }));
     }
     if (provider) {
@@ -140,6 +145,7 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       if (entry) fail('模型已存在；请用 models caps 修改能力');
       entries.push({ id: modelId, capabilities, source: 'manual',
         ...(input.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(input.imageProtocol) } : {}),
+        ...(input.musicProtocol !== undefined ? { musicProtocol: normalizeMusicProtocol(input.musicProtocol) } : {}),
         ...(input.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(input.visionInput) || null } : {}) });
     } else if (command === 'models.remove') {
       if (!entry) fail('模型不存在');
@@ -156,6 +162,12 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
       provider.models = entries;
       if (previous !== selectImageProtocol(provider, modelId).mediaProtocol) clearModelCapabilityHealth(provider, modelId, 'image-gen');
       result = { ...result, model_ref: safe(input.model_ref), imageRouting: selectImageProtocol(provider, modelId) };
+    } else if (command === 'models.music-protocol') {
+      if (!entry) fail('模型不存在');
+      const protocol = normalizeMusicProtocol(input.musicProtocol);
+      if (entry.musicProtocol !== protocol) clearModelCapabilityHealth(provider, modelId, 'music-gen');
+      entry.musicProtocol = protocol;
+      result = { ...result, model_ref: safe(input.model_ref), musicProtocol: protocol };
     } else if (command === 'models.vision-input') {
       if (!entry || !Object.hasOwn(input, 'visionInput')) fail('需要已存在的模型和 visionInput 对象或 null');
       const limits = normalizeVisionInputLimits(input.visionInput);
@@ -189,8 +201,8 @@ export async function executeConfigCommand(configPath, command, input = {}, { si
     if (command === 'assignments.clear') delete catalog.assignments[input.capability];
     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);
-      for (const ref of input.model_refs) if (!parseModelRef(ref) || !resolvePoolModel(pool, ref, input.capability)) fail('分配模型不存在或没有该能力');
+      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('分配模型不存在或没有该能力');
       catalog.assignments[input.capability] = input.model_refs;
     }
   } else fail('未知配置命令');