dsh-router-core 0.3.13 → 0.3.14

package/lib/client-registry.js

@@ -4115,6 +4115,60 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
+		//#region src/client/model-hint-copy.ts
+		/**
+		* 设置-模型 → Router 卡片：把宿主那句走不通的提示换成正确说法。
+		*
+		* 为什么不能直接改源头：Router 的卡片走宿主的 "unknown" 布局（宿主只认得
+		* llm-deepseek / llm-pi-ai 两套表单），那句
+		*   「其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)」
+		* 属于宿主 `settings.models` 的 locale 字典，而字典注册对同一个 (ns, locale)
+		* 只允许一个占位者（重复注册直接抛），插件覆写不了，契约也没给可覆写字段。
+		* 所以沿用本插件既有的认领手法（同 settings-nav-icon.ts）：按文案指纹认出宿主
+		* 渲染的那一段，就地改写。
+		*
+		* 只写 `nodeValue`、不增删节点（节点归 React，摘掉会让它的引用落空）。React 重渲染
+		* 覆盖回来时观察器会再改一次；已是目标文案就早退，不会自激。
+		*
+		* 升级路径：宿主若给该提示长出可覆写字段（或 Router 有了专属布局），删掉本文件。
+		*/
+		/** 指纹：语言无关（不受中英文切换影响），且只出现在 Router 卡片上。 */
+		var FINGERPRINT = "(llm-dsh-router)";
+		/** 正确说法：对齐 README「组合即模型」。 */
+		var ROUTER_MODEL_HINT_COPY = "组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。";
+		/**
+		* 这段文本要不要改写。
+		* @param text 段落当前文本
+		* @returns 需要改写时给出目标文案，否则 undefined
+		*/
+		function routerHintRewrite(text) {
+			if (!text.includes(FINGERPRINT)) return void 0;
+			if (text === "组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。") return void 0;
+			return ROUTER_MODEL_HINT_COPY;
+		}
+		/**
+		* 持续把 Router 卡片里的宿主提示改写成 {@link ROUTER_MODEL_HINT_COPY}。
+		* @returns 清理函数：断开观察
+		*/
+		function rewriteRouterModelHint() {
+			const sync = () => {
+				for (const el of document.querySelectorAll("p[class*=\"advancedHint\"]")) {
+					const next = routerHintRewrite(el.textContent ?? "");
+					const node = el.firstChild;
+					if (next === void 0 || node?.nodeType !== Node.TEXT_NODE) continue;
+					node.nodeValue = next;
+				}
+			};
+			sync();
+			const observer = new MutationObserver(sync);
+			observer.observe(document.body, {
+				childList: true,
+				subtree: true,
+				characterData: true
+			});
+			return () => observer.disconnect();
+		}
+		//#endregion
 		//#region src/client/index.tsx
 		/**
 		* Client half of dsh-router.
@@ -4157,6 +4211,7 @@ window.__ModuleLoader__.load({
 			}
 			ctx.effect(() => disposeSettings, "dsh-router: settings section");
 			ctx.effect(() => registerSettingsNavIcon(SECTION_LABEL), "dsh-router: settings nav icon");
+			ctx.effect(() => rewriteRouterModelHint(), "dsh-router: models provider hint copy");
 		}
 		//#endregion
 		exports.apply = apply;

package/lib/client.js

@@ -4115,6 +4115,60 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
+		//#region src/client/model-hint-copy.ts
+		/**
+		* 设置-模型 → Router 卡片：把宿主那句走不通的提示换成正确说法。
+		*
+		* 为什么不能直接改源头：Router 的卡片走宿主的 "unknown" 布局（宿主只认得
+		* llm-deepseek / llm-pi-ai 两套表单），那句
+		*   「其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)」
+		* 属于宿主 `settings.models` 的 locale 字典，而字典注册对同一个 (ns, locale)
+		* 只允许一个占位者（重复注册直接抛），插件覆写不了，契约也没给可覆写字段。
+		* 所以沿用本插件既有的认领手法（同 settings-nav-icon.ts）：按文案指纹认出宿主
+		* 渲染的那一段，就地改写。
+		*
+		* 只写 `nodeValue`、不增删节点（节点归 React，摘掉会让它的引用落空）。React 重渲染
+		* 覆盖回来时观察器会再改一次；已是目标文案就早退，不会自激。
+		*
+		* 升级路径：宿主若给该提示长出可覆写字段（或 Router 有了专属布局），删掉本文件。
+		*/
+		/** 指纹：语言无关（不受中英文切换影响），且只出现在 Router 卡片上。 */
+		var FINGERPRINT = "(llm-dsh-router)";
+		/** 正确说法：对齐 README「组合即模型」。 */
+		var ROUTER_MODEL_HINT_COPY = "组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。";
+		/**
+		* 这段文本要不要改写。
+		* @param text 段落当前文本
+		* @returns 需要改写时给出目标文案，否则 undefined
+		*/
+		function routerHintRewrite(text) {
+			if (!text.includes(FINGERPRINT)) return void 0;
+			if (text === "组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。") return void 0;
+			return ROUTER_MODEL_HINT_COPY;
+		}
+		/**
+		* 持续把 Router 卡片里的宿主提示改写成 {@link ROUTER_MODEL_HINT_COPY}。
+		* @returns 清理函数：断开观察
+		*/
+		function rewriteRouterModelHint() {
+			const sync = () => {
+				for (const el of document.querySelectorAll("p[class*=\"advancedHint\"]")) {
+					const next = routerHintRewrite(el.textContent ?? "");
+					const node = el.firstChild;
+					if (next === void 0 || node?.nodeType !== Node.TEXT_NODE) continue;
+					node.nodeValue = next;
+				}
+			};
+			sync();
+			const observer = new MutationObserver(sync);
+			observer.observe(document.body, {
+				childList: true,
+				subtree: true,
+				characterData: true
+			});
+			return () => observer.disconnect();
+		}
+		//#endregion
 		//#region src/client/index.tsx
 		/**
 		* Client half of dsh-router.
@@ -4157,6 +4211,7 @@ window.__ModuleLoader__.load({
 			}
 			ctx.effect(() => disposeSettings, "dsh-router: settings section");
 			ctx.effect(() => registerSettingsNavIcon(SECTION_LABEL), "dsh-router: settings nav icon");
+			ctx.effect(() => rewriteRouterModelHint(), "dsh-router: models provider hint copy");
 		}
 		//#endregion
 		exports.apply = apply;

package/lib/index.js

@@ -1,4 +1,5 @@
 import { basename, dirname, join, resolve } from "node:path";
+import Schema from "@deepseek-ai/schemastery";
 import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ReasoningEffortId, ToolCallId, attributionHeaders } from "@deepseek-ai/dsh-llm";
@@ -2298,10 +2299,14 @@ var Router = class {
 * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
 * 由现有路由按组合策略命中供应商模型。
 *
-* 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+* 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+* `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+* 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+* 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+* 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
 */
 /**
-* 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。
+* 把 DSH 消息序列化成 openai 兼容 wire 消息（文本 + 图片 + tool）。
 *
 * `system` 必须由调用方从 `options.system` 传进来：one-shot 调用方把系统提示词
 * 放在 **options.system 这个独立槽位**，不放进 messages。不读这个槽位，
@@ -2313,8 +2318,12 @@ var Router = class {
 * 可出现在任意位置以支持提示词热更新）。两条路径都必须支持 —— 与官方
 * dsh-llm-deepseek 一致（serializeRequest 前置 options.system，再按位置序列化
 * messages 里的 system 消息）。
+*
+* 图片：`image` 块被序列化成 OpenAI `content` 数组里的 `image_url` part（data URI
+* base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
+* **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
 */
-function wireMessages(options, system) {
+async function wireMessages(options, system, attachments) {
 	const out = [];
 	if (typeof system === "string" && system !== "") out.push({
 		role: "system",
@@ -2347,12 +2356,24 @@ function wireMessages(options, system) {
 			});
 			continue;
 		}
-		const text = flattenText(message.content);
 		const toolResults = message.content.filter((b) => b.type === "tool-result");
-		if (text.length > 0 || toolResults.length === 0) out.push({
-			role: "user",
-			content: text
-		});
+		if (hasImageBlock(message.content)) {
+			const parts = await contentParts(message.content, attachments, options.signal);
+			if (parts.length > 0) out.push({
+				role: "user",
+				content: parts
+			});
+			else if (toolResults.length === 0) out.push({
+				role: "user",
+				content: ""
+			});
+		} else {
+			const text = flattenText(message.content);
+			if (text.length > 0 || toolResults.length === 0) out.push({
+				role: "user",
+				content: text
+			});
+		}
 		for (const result of toolResults) out.push({
 			role: "tool",
 			tool_call_id: result.toolCallId,
@@ -2361,9 +2382,73 @@ function wireMessages(options, system) {
 	}
 	return out;
 }
-/** 组装 wire 请求体。 */
-function wireRequest(options) {
-	const messages = wireMessages(options, options.system);
+/**
+* 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
+* 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
+* attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
+*/
+async function contentParts(blocks, attachments, signal) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.type === "text") {
+			const text = block.text ?? "";
+			if (text.length > 0) parts.push({
+				type: "text",
+				text
+			});
+			continue;
+		}
+		if (block.type === "image") {
+			const ref = block.attachment;
+			parts.push(...await imageParts(ref, attachments, signal));
+			continue;
+		}
+		if (block.type === "tool-result") parts.push(...await contentParts(block.content, attachments, signal));
+	}
+	return parts;
+}
+/** 一张图片 → 一个 OpenAI image_url part（或读不到附件时的占位文本）。 */
+async function imageParts(ref, attachments, signal) {
+	if (attachments === void 0) return [{
+		type: "text",
+		text: imagePlaceholder(ref.attachmentId)
+	}];
+	try {
+		const img = await attachments.readImageRequest({
+			attachmentId: ref.attachmentId,
+			mediaType: ref.mediaType,
+			bytes: ref.bytes,
+			width: ref.width,
+			height: ref.height
+		}, {
+			maxPixels: 64e4,
+			maxBytes: 1048576
+		}, signal);
+		return [{
+			type: "image_url",
+			image_url: { url: `data:${img.mediaType};base64,${bytesToBase64(img.data)}` }
+		}];
+	} catch {
+		return [{
+			type: "text",
+			text: imagePlaceholder(ref.attachmentId)
+		}];
+	}
+}
+/** Uint8Array → base64（browser + node 双环境安全，不依赖 Buffer 全局）。 */
+function bytesToBase64(bytes) {
+	let bin = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(bin);
+}
+/** 读不到图片字节时的稳定占位文本。 */
+function imagePlaceholder(attachmentId) {
+	return `[image omitted because the attached bytes could not be read; attachment ${attachmentId}]`;
+}
+/** 组装 wire 请求体。图片序列化需要读 attachments，故为异步。 */
+async function wireRequest(options, attachments) {
+	const messages = await wireMessages(options, options.system, attachments);
 	const body = {
 		model: options.model,
 		messages,
@@ -2410,6 +2495,14 @@ function applyReasoning(body, effort) {
 function flattenText(blocks) {
 	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
 }
+/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
+function hasImageBlock(blocks) {
+	for (const b of blocks) {
+		if (b.type === "image") return true;
+		if (b.type === "tool-result" && hasImageBlock(b.content)) return true;
+	}
+	return false;
+}
 /** openai SSE payload → DSH StreamChunk 流。导出以便单测锁死 usage 契约。 */
 /**
 * 把上游 SSE 的 `data:` 载荷流翻译成 DSH 的 StreamChunk 事件流。
@@ -2643,10 +2736,12 @@ const ROUTER_REASONING_EFFORTS = [
 var RouterAdapter = class RouterAdapter extends LlmAdapter {
 	baseURL;
 	source;
-	constructor(baseURL, source) {
+	resolveAttachments;
+	constructor(baseURL, source, resolveAttachments) {
 		super();
 		this.baseURL = baseURL;
 		this.source = source;
+		this.resolveAttachments = resolveAttachments ?? (() => void 0);
 	}
 	providerInfo(provider) {
 		return {
@@ -2670,14 +2765,14 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		return out;
 	}
 	/**
-	* 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-	* 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-	* 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-	* 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-	* 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-	* 投影，我们仍只处理文本。
+	* 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+	* - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+	*   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+	*   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+	* - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+	*   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
 	*/
-	static INPUT_MODALITIES = ["text"];
+	static INPUT_MODALITIES = ["text", "image"];
 	async resolveModel(_provider, model) {
 		const found = (await this.source.comboModels()).find((m) => m.id === model || m.name === model);
 		return {
@@ -2693,7 +2788,7 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		};
 	}
 	async *stream(options) {
-		const body = wireRequest(options);
+		const body = await wireRequest(options, this.resolveAttachments());
 		const controller = new AbortController();
 		const onAbort = () => controller.abort();
 		options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -4161,13 +4256,26 @@ function apply(rawContext) {
 			disposers.push(ctx.llm.registerModelDiscovery(LLM_NS, async () => {
 				return (await router.combos()).map((c) => ({ id: c.name }));
 			}));
+			const routerSettingsSchema = Schema.object({});
+			ctx.inject(["settings"], (sctx) => {
+				const settings = sctx.settings;
+				if (settings === void 0) {
+					log("settings service absent — skip Router settings-section registration");
+					return;
+				}
+				settings.installSection(rawContext, LLM_NS, routerSettingsSchema, {}, {
+					setSource: () => {},
+					onChange: () => {}
+				});
+				log(`Router settings section registered (${LLM_NS})`);
+			});
 			disposers.push(ctx.llm.registerAdapter(["router"], new RouterAdapter("http://localhost:3080/v1", { comboModels: async () => (await router.combos()).map((c) => {
 				const w = router.comboContextWindow(c);
 				return {
 					id: c.name,
 					...w !== void 0 ? { contextWindow: w } : {}
 				};
-			}) })));
+			}) }, () => ctx.get("attachments"))));
 			log("llm provider (Router) + discovery + adapter registered ok");
 			(async () => {
 				for (const c of await router.combos()) for (const ref of c.models) {
@@ -4195,11 +4303,20 @@ function apply(rawContext) {
 		} catch (err) {
 			registeredProviders = `error: ${err.message}`;
 		}
+		let settingsNamespaces = "n/a";
+		try {
+			const settings = ctx.get("settings");
+			settingsNamespaces = settings?.describe === void 0 ? "no settings service" : settings.describe({ redactSecrets: true }).map((d) => d.ns);
+		} catch (err) {
+			settingsNamespaces = `error: ${err.message}`;
+		}
 		writeJson(res, 200, {
 			ok: true,
 			llmAvailable: ctx.llm !== void 0,
 			directory,
-			registeredProviders
+			registeredProviders,
+			settingsNamespaces,
+			routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes("llm-dsh-router")
 		});
 	});
 	ctx.effect(() => () => {

package/lib/types/llm/adapter.d.ts

@@ -4,9 +4,34 @@
  * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
  * 由现有路由按组合策略命中供应商模型。
  *
- * 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+ * 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+ * `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+ * 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+ * 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+ * 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
  */
 import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmResolvedModelInfo, type StreamChunk } from '@deepseek-ai/dsh-llm';
+/**
+ * dsh-attachment 的最小本地切面：adapter 只依赖「读一张图片的请求版本」
+ * 这一行为，不引入对 dsh-attachment 包编译期/运行期的依赖（它是宿主注入的
+ * devDependency）。本地声明与原包 `AttachmentStore.readImageRequest` 形状一致，
+ * 宿主注入真实 store 时天然满足。
+ */
+export interface RouterAttachmentStore {
+    readImageRequest(ref: {
+        attachmentId: string;
+        mediaType: string;
+        bytes: number;
+        width: number;
+        height: number;
+    }, policy: {
+        maxPixels: number;
+        maxBytes: number;
+    }, signal?: AbortSignal): Promise<{
+        mediaType: string;
+        data: Uint8Array;
+    }>;
+}
 /** 模型目录来源：组合。 */
 export interface RouterAdapterSource {
     /**
@@ -32,19 +57,20 @@ export declare function translateSse(payloads: AsyncIterable<string> | Iterable<
 export declare class RouterAdapter extends LlmAdapter {
     private readonly baseURL;
     private readonly source;
-    constructor(baseURL: string, source: RouterAdapterSource);
+    private readonly resolveAttachments;
+    constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined);
     providerInfo(provider: string): {
         id: string;
         name: string;
     };
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
     /**
-     * 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-     * 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-     * 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-     * 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-     * 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-     * 投影，我们仍只处理文本。
+     * 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+     * - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+     *   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+     *   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+     * - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+     *   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
      */
     private static readonly INPUT_MODALITIES;
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {
@@ -64,11 +64,15 @@
     "prepublishOnly": "npm run build && node scripts/check-publish.mjs --pack"
   },
   "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-llm": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.1.5-rc.2",
     "cordis": "^4.0.0-rc.7",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"

package/src/client/index.tsx

@@ -11,6 +11,7 @@
 import { mountRouterWorkspace } from './workspace-mount.tsx'
 import { RouterSettingsSection } from './settings-section.tsx'
 import { registerSettingsNavIcon } from './settings-nav-icon.ts'
+import { rewriteRouterModelHint } from './model-hint-copy.ts'
 import './router.css'
 
 /**
@@ -65,4 +66,6 @@ export function apply(ctx: Ctx): void {
   ctx.effect(() => disposeSettings, 'dsh-router: settings section')
   // 换掉宿主的默认齿轮（契约没有 icon 字段，只能注册后认领自己的行）
   ctx.effect(() => registerSettingsNavIcon(SECTION_LABEL), 'dsh-router: settings nav icon')
+  // 设置-模型 里 Router 卡片的那句死路提示 → 正确说法（同样只能认领后就地改写）
+  ctx.effect(() => rewriteRouterModelHint(), 'dsh-router: models provider hint copy')
 }

package/src/client/model-hint-copy.test.ts

@@ -0,0 +1,31 @@
+/**
+ * 改写判据测试 —— 锁定「识别宿主提示」与「不自激」两条。
+ *
+ * 为什么要有：这个改写是按文案指纹认领宿主 DOM（见 model-hint-copy.ts）。
+ * 判据写错有两种坏法：漏认（提示原样留着）和自激（改完又被自己判定为需要改，
+ * 观察器反复触发）。两条都是纯函数可测的。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { routerHintRewrite, ROUTER_MODEL_HINT_COPY } from './model-hint-copy.ts'
+
+test('认出宿主提示（中/英两种文案 + 命名空间指纹）', () => {
+  const zh = '其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)'
+  const en = 'Other fields live in settings.yaml; edit that section directly. (llm-dsh-router)'
+  assert.equal(routerHintRewrite(zh), ROUTER_MODEL_HINT_COPY)
+  assert.equal(routerHintRewrite(en), ROUTER_MODEL_HINT_COPY)
+})
+
+test('别的 provider 的同类提示不动（指纹只属于 Router）', () => {
+  const deepseek = '其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-deepseek)'
+  assert.equal(routerHintRewrite(deepseek), undefined)
+})
+
+test('已是目标文案时早退 —— 观察器不自激', () => {
+  assert.equal(routerHintRewrite(ROUTER_MODEL_HINT_COPY), undefined)
+})
+
+test('无关段落一律不动', () => {
+  assert.equal(routerHintRewrite(''), undefined)
+  assert.equal(routerHintRewrite('配置 DeepSeek 官方模型，即可开始使用。'), undefined)
+})

package/src/client/model-hint-copy.ts

@@ -0,0 +1,55 @@
+/**
+ * 设置-模型 → Router 卡片：把宿主那句走不通的提示换成正确说法。
+ *
+ * 为什么不能直接改源头：Router 的卡片走宿主的 "unknown" 布局（宿主只认得
+ * llm-deepseek / llm-pi-ai 两套表单），那句
+ *   「其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)」
+ * 属于宿主 `settings.models` 的 locale 字典，而字典注册对同一个 (ns, locale)
+ * 只允许一个占位者（重复注册直接抛），插件覆写不了，契约也没给可覆写字段。
+ * 所以沿用本插件既有的认领手法（同 settings-nav-icon.ts）：按文案指纹认出宿主
+ * 渲染的那一段，就地改写。
+ *
+ * 只写 `nodeValue`、不增删节点（节点归 React，摘掉会让它的引用落空）。React 重渲染
+ * 覆盖回来时观察器会再改一次；已是目标文案就早退，不会自激。
+ *
+ * 升级路径：宿主若给该提示长出可覆写字段（或 Router 有了专属布局），删掉本文件。
+ */
+
+/** 指纹：语言无关（不受中英文切换影响），且只出现在 Router 卡片上。 */
+const FINGERPRINT = '(llm-dsh-router)'
+
+/** 正确说法：对齐 README「组合即模型」。 */
+export const ROUTER_MODEL_HINT_COPY = '组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。'
+
+/**
+ * 这段文本要不要改写。
+ * @param text 段落当前文本
+ * @returns 需要改写时给出目标文案，否则 undefined
+ */
+export function routerHintRewrite(text: string): string | undefined {
+  if (!text.includes(FINGERPRINT)) return undefined
+  if (text === ROUTER_MODEL_HINT_COPY) return undefined // 已改过，早退防自激
+  return ROUTER_MODEL_HINT_COPY
+}
+
+/**
+ * 持续把 Router 卡片里的宿主提示改写成 {@link ROUTER_MODEL_HINT_COPY}。
+ * @returns 清理函数：断开观察
+ */
+export function rewriteRouterModelHint(): () => void {
+  const sync = (): void => {
+    for (const el of document.querySelectorAll<HTMLElement>('p[class*="advancedHint"]')) {
+      const next = routerHintRewrite(el.textContent ?? '')
+      // 宿主把整句渲染成一个文本节点（单个模板串）——直接整段替换
+      const node = el.firstChild
+      if (next === undefined || node?.nodeType !== Node.TEXT_NODE) continue
+      node.nodeValue = next
+    }
+  }
+
+  sync()
+  // 设置面板按需挂载、React 重渲染都会覆盖回去，子树变动时重新认领
+  const observer = new MutationObserver(sync)
+  observer.observe(document.body, { childList: true, subtree: true, characterData: true })
+  return () => observer.disconnect()
+}

package/src/index.ts

@@ -31,9 +31,10 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { join } from 'node:path'
+import Schema from '@deepseek-ai/schemastery'
 import { ROUTER_API_BASE, type RouterPeriod } from './shared.ts'
 import { Router } from './router/index.ts'
-import { RouterAdapter } from './llm/adapter.ts'
+import { RouterAdapter, type RouterAttachmentStore } from './llm/adapter.ts'
 import { KeysStore } from './keys.ts'
 import { loadSuppliers, wrapModule, type LoadedSupplier } from './suppliers/loader.ts'
 import { supplierRoutes } from './suppliers/registry.ts'
@@ -94,6 +95,29 @@ interface Llm {
   registerAdapter: (providers: readonly string[], adapter: unknown) => () => void
 }
 
+/**
+ * 设置服务（`ctx.settings`，dsh-settings）的最小切面：本插件只用 `installSection`
+ * 注册一个命名空间，让设置-模型页能列出 Router provider 卡片。dsh-settings 是
+ * 宿主注入的 peer service，这里不深绑它的类型，只声明用到的这一个方法。
+ */
+interface SettingsServiceFace {
+  installSection: (
+    owner: CordisContext,
+    ns: string,
+    schema: unknown,
+    entry: unknown,
+    hooks: { setSource: (current: () => unknown) => void; onChange: () => void },
+  ) => void
+}
+
+/**
+ * cordis Context 的最小切面。`installSection(owner)` 只会对 owner 调
+ * `ctx.effect(...)` 并在卸载时读 `fiber.state`，所以这里只声明 `effect`。
+ */
+interface CordisContext {
+  effect: (fn: () => () => void, label?: string) => unknown
+}
+
 function writeJson(res: ServerResponse, status: number, body: unknown): void {
   const payload = JSON.stringify(body)
   res.writeHead(status, {
@@ -574,14 +598,35 @@ export function apply(rawContext: unknown): void {
         const combos = await router.combos()
         return combos.map((c) => ({ id: c.name }))
       }))
+      // Router 的配置（组合/密钥/签到）存在 core 自己的 state.json，走插件自己的
+      // 「路由系统」面板；设置-模型 这边**仍必须注册 `llm-dsh-router` 命名空间**。
+      // 原因：设置-模型 的 provider 列表只渲染 settingsNs 能在设置镜像里解析出来的
+      // 行（见 dsh-client-ui-settings-models 的 configurable 过滤）。只调
+      // registerConfigurableProviders 而不注册 section，Router 卡片**不会出现**。
+      // 空 schema = 卡片是入口/占位（该布局下不可提交），真正的配置在路由系统面板。
+      const routerSettingsSchema = Schema.object({})
+      ctx.inject(['settings'], (sctx: unknown) => {
+        const settings = (sctx as { settings?: SettingsServiceFace }).settings
+        if (settings === undefined) {
+          log('settings service absent — skip Router settings-section registration')
+          return
+        }
+        settings.installSection(rawContext as CordisContext, LLM_NS, routerSettingsSchema, {}, {
+          setSource: () => {},
+          onChange: () => {},
+        })
+        log(`Router settings section registered (${LLM_NS})`)
+      })
       // adapter：模型目录自动带出组合；对话转发到本插件 /v1（组合路由在 /v1 内完成）。
       // 带上组合的上下文窗口：没有它 dsh 的自动压缩算不出阈值、会静默关闭。
+      // 图片序列化需要读附件字节：把 ctx.attachments 传给 adapter（dsh-attachment
+      // 是宿主注入的 service，插件不直接 import 它，只依赖 duck-typed 切面）。
       disposers.push(ctx.llm.registerAdapter(['router'], new RouterAdapter('http://localhost:3080/v1', {
         comboModels: async () => (await router.combos()).map((c) => {
           const w = router.comboContextWindow(c)
           return { id: c.name, ...(w !== undefined ? { contextWindow: w } : {}) }
         }),
-      })))
+      }, () => ctx.get('attachments') as RouterAttachmentStore | undefined)))
       log('llm provider (Router) + discovery + adapter registered ok')
       // 预热模型缓存：`comboContextWindow` 只读缓存、不打上游，缓存空着就
       // 报不出窗口。这里后台填一次，让第一次 resolveModel 就有值。
@@ -616,11 +661,25 @@ export function apply(rawContext: unknown): void {
     } catch (err) {
       registeredProviders = `error: ${(err as Error).message}`
     }
+    // 设置命名空间是否注册成功 —— 卡片不出现的**唯一**嫌疑点：provider 在目录里
+    // （上面的 directory）却没注册 section 时，设置-模型 的 configurable 过滤会
+    // 把该行整条丢掉，界面上什么都不显示、也没有任何报错。
+    let settingsNamespaces: unknown = 'n/a'
+    try {
+      const settings = ctx.get('settings') as { describe?: (opts?: unknown) => Array<{ ns: string }> } | undefined
+      settingsNamespaces = settings?.describe === undefined
+        ? 'no settings service'
+        : settings.describe({ redactSecrets: true }).map((d) => d.ns)
+    } catch (err) {
+      settingsNamespaces = `error: ${(err as Error).message}`
+    }
     writeJson(res, 200, {
       ok: true,
       llmAvailable: ctx.llm !== undefined,
       directory,
       registeredProviders,
+      settingsNamespaces,
+      routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes('llm-dsh-router'),
     })
   })
 

package/src/llm/adapter.test.ts

@@ -519,6 +519,9 @@ test('模型目录：resolveModel 对每个组合声明推理等级（off/low/hi
   assert.equal(a.provider, 'router')
   assert.equal(a.id, 'c-a')
   assert.equal(a.name, '组合A')
+  // 图文模态：必须声明含 image，否则 runtime/subagent 的模态门禁会抛
+  // `MODEL_DOES_NOT_SUPPORT_IMAGES`（界面「当前模型不支持图片」）。
+  assert.deepEqual(a.inputModalities, ['text', 'image'], 'adapter 必须声明 image 模态，否则图片被门禁拦截')
   assert.ok(a.reasoning, '组合应声明推理等级，DSH 才允许显式 effort')
   assert.deepEqual(a.reasoning!.efforts.map((e) => e.id), ['off', 'low', 'high', 'max'])
   assert.equal(a.reasoning!.defaultEffort, 'high', '默认 High：调用方不指定时物化为 high')
@@ -543,3 +546,82 @@ test('resolveModel 透传组合的 contextWindow（自动压缩才能算阈值
   const b = await adapter.resolveModel('router', 'c-b')
   assert.equal(b.context, undefined, '没拿到就不声明 context，绝不填一个假窗口')
 })
+
+/* ---------------- 图片序列化：图片必须真正到上游（不静默丢图） ---------------- */
+
+/** 假附件 store：返回指定 mediaType + bytes 的请求版本。 */
+function fakeAttachments(mediaType = 'image/png', data = new TextEncoder().encode('<png-bytes>')): {
+  readImageRequest: () => Promise<{ mediaType: string; data: Uint8Array }>
+} {
+  return {
+    readImageRequest: async () => ({ mediaType, data }),
+  }
+}
+
+/** 用给定 attachments 跑一次 stream()，返回上游收到的 body。 */
+async function captureBodyWith(options: Record<string, unknown>, attachments?: unknown): Promise<Record<string, unknown>> {
+  let captured: Record<string, unknown> = {}
+  globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+    captured = JSON.parse(init?.body ?? '{}') as Record<string, unknown>
+    return new Response('data: [DONE]\n\n', { status: 200 })
+  }) as typeof fetch
+  const adapter = new RouterAdapter(
+    'http://x',
+    { comboModels: async () => [] },
+    () => attachments as never,
+  )
+  for await (const _c of adapter.stream({ model: 'm', messages: [], signal: AbortSignal.timeout(3000), ...options } as never)) {
+    void _c
+  }
+  return captured
+}
+
+test('wire：图片块被序列化成 OpenAI image_url base64 part（不再静默丢图）', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [
+      { type: 'text', text: '看这张图' },
+      { type: 'image', attachment: ref },
+    ] }],
+  }, fakeAttachments())
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  const parts = (user?.content ?? []) as Array<{ type: string; text?: string; image_url?: { url: string } }>
+  assert.equal(parts.length, 2, 'text + image 两个 part')
+  assert.equal(parts[0]?.type, 'text')
+  assert.equal(parts[0]?.text, '看这张图')
+  assert.equal(parts[1]?.type, 'image_url', '图片必须是 image_url part，不是占位文本')
+  const b64 = btoa(String.fromCharCode(...new TextEncoder().encode('<png-bytes>')))
+  assert.equal(parts[1]?.image_url?.url, `data:image/png;base64,${b64}`, 'data URI 必须是 base64 编码的真实字节')
+})
+
+test('wire：纯文本 user 消息仍是紧凑字符串（不回归 wire 形式）', async () => {
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+  }, fakeAttachments())
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  assert.equal(user?.content, 'hi', '无图时必须保持字符串 content')
+})
+
+test('wire：无 attachments 时图片回退占位文本，绝不静默丢图', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [{ type: 'image', attachment: ref }] }],
+  }, undefined)
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  const parts = (user?.content ?? []) as Array<{ type: string; text?: string }>
+  assert.equal(parts.length, 1)
+  assert.equal(parts[0]?.type, 'text')
+  assert.ok((parts[0]?.text ?? '').includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+})

package/src/llm/adapter.ts

@@ -4,7 +4,11 @@
  * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
  * 由现有路由按组合策略命中供应商模型。
  *
- * 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+ * 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+ * `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+ * 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+ * 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+ * 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
  */
 import {
   EMPTY_RESPONSE_CODE,
@@ -22,6 +26,29 @@ import {
 } from '@deepseek-ai/dsh-llm'
 import { mergeUsage, normalizeUsage, toTokenUsage, type UsageTokens } from '../router/usage-tokens.ts'
 
+/**
+ * dsh-attachment 的最小本地切面：adapter 只依赖「读一张图片的请求版本」
+ * 这一行为，不引入对 dsh-attachment 包编译期/运行期的依赖（它是宿主注入的
+ * devDependency）。本地声明与原包 `AttachmentStore.readImageRequest` 形状一致，
+ * 宿主注入真实 store 时天然满足。
+ */
+export interface RouterAttachmentStore {
+  readImageRequest(
+    ref: { attachmentId: string; mediaType: string; bytes: number; width: number; height: number },
+    policy: { maxPixels: number; maxBytes: number },
+    signal?: AbortSignal,
+  ): Promise<{ mediaType: string; data: Uint8Array }>
+}
+
+/** 一张 image 块的 attachment ref 的最小形状（value 类型，够用即可）。 */
+interface RouterImgLike {
+  attachmentId: string
+  mediaType: string
+  bytes: number
+  width: number
+  height: number
+}
+
 /** 模型目录来源：组合。 */
 export interface RouterAdapterSource {
   /**
@@ -34,7 +61,7 @@ export interface RouterAdapterSource {
 }
 
 /**
- * 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。
+ * 把 DSH 消息序列化成 openai 兼容 wire 消息（文本 + 图片 + tool）。
  *
  * `system` 必须由调用方从 `options.system` 传进来：one-shot 调用方把系统提示词
  * 放在 **options.system 这个独立槽位**，不放进 messages。不读这个槽位，
@@ -46,8 +73,12 @@ export interface RouterAdapterSource {
  * 可出现在任意位置以支持提示词热更新）。两条路径都必须支持 —— 与官方
  * dsh-llm-deepseek 一致（serializeRequest 前置 options.system，再按位置序列化
  * messages 里的 system 消息）。
+ *
+ * 图片：`image` 块被序列化成 OpenAI `content` 数组里的 `image_url` part（data URI
+ * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
+ * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
  */
-function wireMessages(options: GenerateOptions, system?: string): Array<Record<string, unknown>> {
+async function wireMessages(options: GenerateOptions, system: string | undefined, attachments: RouterAttachmentStore | undefined): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
   if (typeof system === 'string' && system !== '') {
     out.push({ role: 'system', content: system })
@@ -76,9 +107,16 @@ function wireMessages(options: GenerateOptions, system?: string): Array<Record<s
       continue
     }
     // user / tool-result
-    const text = flattenText(message.content)
     const toolResults = message.content.filter((b) => b.type === 'tool-result')
-    if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    // 有图 → content 数组；纯文本 → 保持紧凑字符串 wire 形式不回归。
+    if (hasImageBlock(message.content)) {
+      const parts = await contentParts(message.content, attachments, options.signal)
+      if (parts.length > 0) out.push({ role: 'user', content: parts })
+      else if (toolResults.length === 0) out.push({ role: 'user', content: '' })
+    } else {
+      const text = flattenText(message.content)
+      if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    }
     for (const result of toolResults) {
       // 空结果就发空串，不要替换成 '(no output)' 之类的字面量 —— 模型会
       // 以为工具真的打印了那句话（9router 也是补 content: ""）。
@@ -88,9 +126,73 @@ function wireMessages(options: GenerateOptions, system?: string): Array<Record<s
   return out
 }
 
-/** 组装 wire 请求体。 */
-function wireRequest(options: GenerateOptions): Record<string, unknown> {
-  const messages = wireMessages(options, options.system)
+/**
+ * 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
+ * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
+ * attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
+ */
+async function contentParts(
+  blocks: ReadonlyArray<{ type: string }>,
+  attachments: RouterAttachmentStore | undefined,
+  signal: AbortSignal | undefined,
+): Promise<Array<Record<string, unknown>>> {
+  const parts: Array<Record<string, unknown>> = []
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      const text = (block as { text?: string }).text ?? ''
+      if (text.length > 0) parts.push({ type: 'text', text })
+      continue
+    }
+    if (block.type === 'image') {
+      const ref = (block as unknown as { attachment: RouterImgLike }).attachment
+      parts.push(...(await imageParts(ref, attachments, signal)))
+      continue
+    }
+    if (block.type === 'tool-result') {
+      parts.push(...(await contentParts((block as unknown as { content: ReadonlyArray<{ type: string }> }).content, attachments, signal)))
+    }
+    // 其它块（reasoning/tool-call）不属于 user content，忽略
+  }
+  return parts
+}
+
+/** 一张图片 → 一个 OpenAI image_url part（或读不到附件时的占位文本）。 */
+async function imageParts(
+  ref: { attachmentId: string; mediaType: string; bytes: number; width: number; height: number },
+  attachments: RouterAttachmentStore | undefined,
+  signal: AbortSignal | undefined,
+): Promise<Array<Record<string, unknown>>> {
+  if (attachments === undefined) return [{ type: 'text', text: imagePlaceholder(ref.attachmentId) }]
+  try {
+    const img = await attachments.readImageRequest(
+      { attachmentId: ref.attachmentId, mediaType: ref.mediaType, bytes: ref.bytes, width: ref.width, height: ref.height },
+      { maxPixels: 64e4, maxBytes: 1024 * 1024 },
+      signal,
+    )
+    return [{ type: 'image_url', image_url: { url: `data:${img.mediaType};base64,${bytesToBase64(img.data)}` } }]
+  } catch {
+    return [{ type: 'text', text: imagePlaceholder(ref.attachmentId) }]
+  }
+}
+
+/** Uint8Array → base64（browser + node 双环境安全，不依赖 Buffer 全局）。 */
+function bytesToBase64(bytes: Uint8Array): string {
+  let bin = ''
+  const chunk = 0x8000
+  for (let i = 0; i < bytes.length; i += chunk) {
+    bin += String.fromCharCode(...bytes.subarray(i, i + chunk))
+  }
+  return btoa(bin)
+}
+
+/** 读不到图片字节时的稳定占位文本。 */
+function imagePlaceholder(attachmentId: string): string {
+  return `[image omitted because the attached bytes could not be read; attachment ${attachmentId}]`
+}
+
+/** 组装 wire 请求体。图片序列化需要读 attachments，故为异步。 */
+async function wireRequest(options: GenerateOptions, attachments: RouterAttachmentStore | undefined): Promise<Record<string, unknown>> {
+  const messages = await wireMessages(options, options.system, attachments)
   const body: Record<string, unknown> = {
     model: options.model,
     messages,
@@ -136,6 +238,15 @@ function flattenText(blocks: readonly { type: string; text?: string }[]): string
   return blocks.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('')
 }
 
+/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
+function hasImageBlock(blocks: readonly { type: string }[]): boolean {
+  for (const b of blocks) {
+    if (b.type === 'image') return true
+    if (b.type === 'tool-result' && hasImageBlock((b as unknown as { content: ReadonlyArray<{ type: string }> }).content)) return true
+  }
+  return false
+}
+
 interface OpenBlock {
   index: number
   kind: 'text' | 'reasoning' | 'tool-call'
@@ -379,11 +490,13 @@ const ROUTER_REASONING_EFFORTS: readonly LlmReasoningEffortInfo[] = [
 export class RouterAdapter extends LlmAdapter {
   private readonly baseURL: string
   private readonly source: RouterAdapterSource
+  private readonly resolveAttachments: () => RouterAttachmentStore | undefined
 
-  constructor(baseURL: string, source: RouterAdapterSource) {
+  constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined) {
     super()
     this.baseURL = baseURL
     this.source = source
+    this.resolveAttachments = resolveAttachments ?? (() => undefined)
   }
 
   providerInfo(provider: string): { id: string; name: string } {
@@ -403,14 +516,14 @@ export class RouterAdapter extends LlmAdapter {
   }
 
   /**
-   * 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-   * 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-   * 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-   * 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-   * 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-   * 投影，我们仍只处理文本。
+   * 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+   * - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+   *   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+   *   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+   * - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+   *   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
    */
-  private static readonly INPUT_MODALITIES: readonly ModelModality[] = ['text']
+  private static readonly INPUT_MODALITIES: readonly ModelModality[] = ['text', 'image']
 
   async resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo> {
     const combos = await this.source.comboModels()
@@ -430,7 +543,7 @@ export class RouterAdapter extends LlmAdapter {
   }
 
   async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
-    const body = wireRequest(options)
+    const body = await wireRequest(options, this.resolveAttachments())
     const controller = new AbortController()
     const onAbort = (): void => controller.abort()
     options.signal?.addEventListener('abort', onAbort, { once: true })