@mokuyoaxis/dsh-iris 0.2.2 → 0.2.3

package/lib/index.js

@@ -263,7 +263,7 @@ export async function apply(ctx) {
   // 若 webServer 已在运行，inject 回调也会触发；这里兜底立即挂载一次
   guard('媒体路由兜底挂载', () => mountIrisRoutes(ctx));
 
-  // DSH 的 Skill registry 是可选宿主能力。存在时把 npm 包内两项 Skill 注册到
+  // DSH 的 Skill registry 是可选宿主能力。存在时把 npm 包内三项 Skill 注册到
   // 全局层；项目目录中的同名 Skill 仍由 DSH 原生优先级覆盖。
   ctx.inject(['skills'], (skillCtx) => {
     guard('随包 Skill 注册', () => {
@@ -463,10 +463,29 @@ export async function apply(ctx) {
     }
   });
 
+  safeRegister(host, {
+    name: 'iris_generate_music',
+    description: 'Generate music using a model explicitly assigned to Music. Returns audio artifact IDs and playback links. Lyrics, vocals and duration are prompt intentions. Configured 502 retries may generate again.',
+    parameters: { type: 'object', properties: {
+      prompt: { type: 'string', description: 'Describe the music, including any lyrics, vocals, mood or intended duration' },
+      model: { type: 'string', description: 'Assigned providerId::modelId reference' },
+      timeout_ms: { type: 'integer', description: 'Per-attempt timeout; default 300000 ms' },
+      retry_502: { type: 'integer', description: '502 regeneration retries, 0–5; default 2; each retry consumes another request' },
+      retry_delay_ms: { type: 'integer', description: 'Delay between 502 retries; default 5000 ms' }
+    }, required: ['prompt'] },
+    output: { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] },
+    isConcurrencySafe: () => true,
+    async execute(args, exec) {
+      const submitted = await runAction(dshHost(ctx), 'music', args, { signal: exec.signal });
+      return submitted.text + '\nartifact: ' + submitted.artifactIds.join(', ') + '\n' +
+        submitted.artifactIds.map(id => '[♪ 音乐播放](/iris/api/core/artifact/' + encodeURIComponent(id) + '/media)').join('\n');
+    }
+  });
+
   /* ---------- 🔊 语音合成 ---------- */
   safeRegister(host, {
     name: 'iris_speak_text',
-    description: 'Synthesize speech audio from text using the configured TTS model (qwen-tts / compatible). Returns the saved audio file path.',
+    description: 'Synthesize spoken audio from text using the configured TTS model. Returns Core audio Artifact IDs and playback links; export an Artifact to a host file before passing it as audio_path to another tool. Use iris_generate_music for songs or background music.',
     parameters: {
       type: 'object',
       properties: {
@@ -780,7 +799,7 @@ export async function apply(ctx) {
   safeRegister(host, {
     name: 'iris_task_status',
     description:
-      'Query iris generation tasks (image/video/tts). Pass a task_id for one task, or omit it to list the latest tasks with status, progress, errors and output file paths.',
+      'Query Iris tasks (image/video/tts/music/transcription). Pass a task_id for one task, or omit it to list recent tasks. Core results provide Artifact IDs and playback links; legacy tasks may provide file paths. Querying does not re-observe or redeliver a task.',
     parameters: {
       type: 'object',
       properties: {
@@ -1022,7 +1041,7 @@ export async function apply(ctx) {
     }
   });
 
-  console.log('[iris] tools registered: iris_draw_image, iris_edit_image, iris_generate_video, iris_speak_text, iris_transcribe_audio, iris_task_status, iris_look_at_image, iris_relook_attachment, iris_crop, iris_pixel_diff, iris_locate, iris_html_screenshot, iris_long_ocr, iris_video_frames, iris_media_summarize');
+  console.log('[iris] tools registered: iris_draw_image, iris_edit_image, iris_generate_video, iris_generate_music, iris_speak_text, iris_transcribe_audio, iris_task_status, iris_look_at_image, iris_relook_attachment, iris_crop, iris_pixel_diff, iris_locate, iris_html_screenshot, iris_long_ocr, iris_video_frames, iris_media_summarize');
 };
 
 /* ---------------- 视觉路由（M3 补全）：look/relook 共用执行器 + 降级链 ---------------- */

package/lib/models.js

@@ -19,6 +19,7 @@ export const CAP_FIELD = {
   [CAPABILITIES.IMAGE]: 'imageModel',
   [CAPABILITIES.VIDEO]: 'videoModel',
   [CAPABILITIES.TTS]: 'ttsModel',
+  [CAPABILITIES.MUSIC]: 'musicModel',
   [CAPABILITIES.TRANSCRIBE]: 'transcribeModel',
   [CAPABILITIES.VISION]: 'visionModel'
 };
@@ -77,6 +78,7 @@ const DISCOVERY_CAPABILITIES = Object.freeze({
   IG: CAPABILITIES.IMAGE, IMAGE: CAPABILITIES.IMAGE, 'IMAGE-GEN': CAPABILITIES.IMAGE,
   VG: CAPABILITIES.VIDEO, VIDEO: CAPABILITIES.VIDEO, 'VIDEO-GEN': CAPABILITIES.VIDEO,
   TTS: CAPABILITIES.TTS, ASR: CAPABILITIES.TRANSCRIBE,
+  MUSIC: CAPABILITIES.MUSIC, 'MUSIC-GEN': CAPABILITIES.MUSIC,
   TRANSCRIBE: CAPABILITIES.TRANSCRIBE, VU: CAPABILITIES.VISION, VISION: CAPABILITIES.VISION
 });
 
@@ -115,6 +117,7 @@ export function providerModels(p) {
       const caps = configuredModelCapabilities(p, m);
       const extra = typeof m === 'object' && m ? { verified: m.verified, source: m.source,
         ...(m.imageProtocol !== undefined ? { imageProtocol: m.imageProtocol } : {}),
+        ...(m.musicProtocol !== undefined ? { musicProtocol: m.musicProtocol } : {}),
         ...(m.visionInput !== undefined ? { visionInput: m.visionInput } : {}) } : {};
       push(id, caps, extra);
     }
@@ -167,7 +170,7 @@ export function orderedModels(pool, capability, assignments, { includeRateLimite
   for (const raw of (Array.isArray(assignments) ? assignments : (assignments ? [assignments] : []))) {
     add(resolvePoolModel(pool, raw, capability));
   }
-  for (const model of pool) add(model);
+  if (capability !== CAPABILITIES.MUSIC) for (const model of pool) add(model);
   return ordered;
 }
 

package/lib/music-generation.js

@@ -0,0 +1,21 @@
+import { setTimeout as delay } from 'node:timers/promises';
+
+/** Explicit Music 502 regeneration policy; each resubmission is a new Core Task. */
+export async function generateMusicTask({ runner, candidates, providerInput, options, signal }) {
+  const taskIds = [];
+  let result, retriedFrom;
+  for (let index = 0; index <= options.retry502; index++) {
+    signal?.throwIfAborted();
+    result = await runner.submit({ capability: 'music', candidates, providerInput, ...(retriedFrom ? { retriedFrom } : {}) });
+    taskIds.push(result.task.id);
+    const task = result.task;
+    if (result.localError || task.phase !== 'terminal' || task.lastError?.httpStatus !== 502
+        || task.outcome === 'succeeded' || index === options.retry502) break;
+    // Retry the actual model, without switching to another (potentially paid) source.
+    candidates = candidates.filter(candidate => candidate.model === task.modelRef && candidate.adapter.id === task.providerId);
+    if (!candidates.length) throw new Error('Music 重试无法找到原模型绑定');
+    retriedFrom = task.id;
+    await delay(options.retryDelayMs, undefined, { signal });
+  }
+  return Object.freeze({ ...result, taskIds: Object.freeze(taskIds), retries: taskIds.length - 1 });
+}

package/lib/music-options.js

@@ -0,0 +1,18 @@
+/** Music caller controls; generation parameters remain in the prompt. */
+export function normalizeMusicOptions(input = {}) {
+  const integer = (field, fallback, min, max) => {
+    if (input[field] !== undefined && !['number', 'string'].includes(typeof input[field])) {
+      throw new TypeError(`${field} 必须是整数`);
+    }
+    const value = input[field] === undefined ? fallback : Number(input[field]);
+    if (!Number.isSafeInteger(value) || value < min || value > max) {
+      throw new TypeError(`${field} 必须是 ${min}–${max} 的整数`);
+    }
+    return value;
+  };
+  return Object.freeze({
+    timeoutMs: integer('timeout_ms', 300000, 1, 3600000),
+    retry502: integer('retry_502', 2, 0, 5),
+    retryDelayMs: integer('retry_delay_ms', 5000, 0, 60000)
+  });
+}

package/lib/music-transport.js

@@ -0,0 +1,46 @@
+import { ProviderContractError } from './provider-contract.js';
+
+function responseError(message) {
+  return new ProviderContractError(message, { stage: 'response', category: 'protocol', acceptance: 'unknown' });
+}
+
+/** Gemini web gateway's documented non-streaming Markdown audio response. */
+export function musicArtifactsFromResponse(body) {
+  if (!Array.isArray(body?.choices)) throw responseError('Music 响应缺少 choices');
+  const artifacts = [], seen = new Set();
+  for (const choice of body.choices) {
+    const content = choice?.message?.content;
+    if (typeof content !== 'string') continue;
+    for (const match of content.matchAll(/data:(audio\/(?:mpeg|wav|x-wav));base64,([A-Za-z0-9+/=]+)/gi)) {
+      const data = match[2];
+      const bytes = Buffer.from(data, 'base64');
+      if (!bytes.length || bytes.toString('base64') !== data) throw responseError('Music 音频 base64 无效');
+      if (seen.has(data)) continue;
+      seen.add(data);
+      artifacts.push({ kind: 'inline-base64', data, mediaType: match[1].toLowerCase() === 'audio/mpeg' ? 'audio/mpeg' : 'audio/wav' });
+    }
+  }
+  if (!artifacts.length) throw responseError('Music 响应没有可交付的 MP3/WAV 音频');
+  return artifacts;
+}
+
+export async function generateMusic({ key, baseUrl, model, prompt, timeoutMs = 300000, signal }) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const response = await fetch(String(baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...(key ? { Authorization: `Bearer ${key}` } : {}) },
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    body: JSON.stringify({ model, stream: false, messages: [{ role: 'user', content: prompt }] })
+  });
+  const text = await response.text();
+  let body;
+  try { body = JSON.parse(text); }
+  catch (error) { if (response.ok) throw responseError('Music 响应不是有效 JSON'); }
+  if (!response.ok) {
+    const message = String(body?.error?.message || body?.message || `Music HTTP ${response.status}`);
+    throw new ProviderContractError(key ? message.replaceAll(key, '[REDACTED]') : message, {
+      stage: 'submit', httpStatus: response.status, category: 'provider', acceptance: 'unknown', retryable: response.status === 502
+    });
+  }
+  return musicArtifactsFromResponse(body);
+}

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

@@ -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'
     });
   }
@@ -373,7 +373,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],